summaryrefslogtreecommitdiff
path: root/applets/clock/clock.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-12-01 22:56:10 -0300
committerPerberos <[email protected]>2011-12-01 22:56:10 -0300
commitc51ef797a707f4e2c6f9688d4378f2b0e9898a66 (patch)
tree019ae92bb53c19b30077545cb14743cbd1b57aef /applets/clock/clock.c
downloadmate-panel-c51ef797a707f4e2c6f9688d4378f2b0e9898a66.tar.bz2
mate-panel-c51ef797a707f4e2c6f9688d4378f2b0e9898a66.tar.xz
moving from https://github.com/perberos/mate-desktop-environment
Diffstat (limited to 'applets/clock/clock.c')
-rw-r--r--applets/clock/clock.c3745
1 files changed, 3745 insertions, 0 deletions
diff --git a/applets/clock/clock.c b/applets/clock/clock.c
new file mode 100644
index 00000000..b4846009
--- /dev/null
+++ b/applets/clock/clock.c
@@ -0,0 +1,3745 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
+/*
+ * clock.c: the MATE clock applet
+ *
+ * Copyright (C) 1997-2003 Free Software Foundation, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors:
+ * Miguel de Icaza
+ * Frederico Mena
+ * Stuart Parmenter
+ * Alexander Larsson
+ * George Lebl
+ * Gediminas Paulauskas
+ * Mark McLoughlin
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+#include <math.h>
+#include <locale.h>
+
+#include <mate-panel-applet.h>
+#include <mate-panel-applet-mateconf.h>
+
+#include <glib/gi18n.h>
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+#include <mateconf/mateconf-client.h>
+
+#include <libmateweather/mateweather-prefs.h>
+#include <libmateweather/mateweather-xml.h>
+#include <libmateweather/location-entry.h>
+#include <libmateweather/timezone-menu.h>
+
+#ifdef HAVE_LIBECAL
+#include <libedataserverui/e-passwords.h>
+#endif
+
+#include "clock.h"
+
+#include "calendar-window.h"
+#include "clock-location.h"
+#include "clock-location-tile.h"
+#include "clock-map.h"
+#include "clock-utils.h"
+#include "set-timezone.h"
+#include "system-timezone.h"
+
+#define INTERNETSECOND (864)
+#define INTERNETBEAT (86400)
+
+#define NEVER_SENSITIVE "never_sensitive"
+
+#define N_MATECONF_PREFS 11 /* Keep this in sync with the number of keys below! */
+#define KEY_FORMAT "format"
+#define KEY_SHOW_SECONDS "show_seconds"
+#define KEY_SHOW_DATE "show_date"
+#define KEY_SHOW_WEATHER "show_weather"
+#define KEY_SHOW_TEMPERATURE "show_temperature"
+#define KEY_CUSTOM_FORMAT "custom_format"
+#define KEY_SHOW_WEEK "show_week_numbers"
+#define KEY_CITIES "cities"
+#define KEY_TEMPERATURE_UNIT "temperature_unit"
+#define KEY_SPEED_UNIT "speed_unit"
+
+static MateConfEnumStringPair format_type_enum_map [] = {
+ { CLOCK_FORMAT_12, "12-hour" },
+ { CLOCK_FORMAT_24, "24-hour" },
+ { CLOCK_FORMAT_UNIX, "unix" },
+ { CLOCK_FORMAT_INTERNET, "internet" },
+ { CLOCK_FORMAT_CUSTOM, "custom" },
+ { 0, NULL }
+};
+
+enum {
+ COL_CITY_NAME = 0,
+ COL_CITY_TZ,
+ COL_CITY_LOC,
+ COL_CITY_LAST
+};
+
+typedef struct _ClockData ClockData;
+
+struct _ClockData {
+ /* widgets */
+ GtkWidget *applet;
+
+ GtkWidget *panel_button; /* main toggle button for the whole clock */
+
+ GtkWidget *main_obox; /* orientable box inside panel_button */
+ GtkWidget *weather_obox; /* orientable box for the weather widgets */
+
+ GtkWidget *clockw; /* main label for the date/time display */
+
+ GtkWidget *panel_weather_icon;
+ GtkWidget *panel_temperature_label;
+
+ GtkWidget *props;
+ GtkWidget *calendar_popup;
+
+ GtkWidget *clock_vbox;
+ GtkSizeGroup *clock_group;
+
+ GtkBuilder *builder;
+
+ /* Preferences dialog */
+ GtkWidget *prefs_window;
+ GtkTreeView *prefs_locations;
+
+ GtkWidget *prefs_location_add_button;
+ GtkWidget *prefs_location_edit_button;
+ GtkWidget *prefs_location_remove_button;
+
+ MateWeatherLocationEntry *location_entry;
+ MateWeatherTimezoneMenu *zone_combo;
+
+ GtkWidget *time_settings_button;
+ GtkWidget *calendar;
+ GtkWidget *hours_spin;
+ GtkWidget *minutes_spin;
+ GtkWidget *seconds_spin;
+ GtkWidget *set_time_button;
+
+ GtkListStore *cities_store;
+ GtkWidget *cities_section;
+ GtkWidget *map_section;
+ GtkWidget *map_widget;
+
+ /* Window to set the time */
+ GtkWidget *set_time_window;
+ GtkWidget *current_time_label;
+
+ /* preferences */
+ ClockFormat format;
+ char *custom_format;
+ gboolean showseconds;
+ gboolean showdate;
+ gboolean showweek;
+ gboolean show_weather;
+ gboolean show_temperature;
+
+ gboolean use_temperature_default;
+ gboolean use_speed_default;
+ TempUnit temperature_unit;
+ SpeedUnit speed_unit;
+
+ /* Locations */
+ GList *locations;
+ GList *location_tiles;
+
+ /* runtime data */
+ time_t current_time;
+ char *timeformat;
+ guint timeout;
+ MatePanelAppletOrient orient;
+ int size;
+ GtkAllocation old_allocation;
+
+ SystemTimezone *systz;
+
+ int fixed_width;
+ int fixed_height;
+
+ GtkWidget *showseconds_check;
+ GtkWidget *showdate_check;
+ GtkWidget *custom_hbox;
+ GtkWidget *custom_label;
+ GtkWidget *custom_entry;
+ gboolean custom_format_shown;
+
+ gboolean can_handle_format_12;
+
+ guint listeners [N_MATECONF_PREFS];
+};
+
+/* Used to count the number of clock instances. It's there to know when we
+ * should free resources that are shared. */
+static int clock_numbers = 0;
+
+static void update_clock (ClockData * cd);
+static void update_tooltip (ClockData * cd);
+static void update_panel_weather (ClockData *cd);
+static int clock_timeout_callback (gpointer data);
+static float get_itime (time_t current_time);
+
+static void set_atk_name_description (GtkWidget *widget,
+ const char *name,
+ const char *desc);
+static void verb_display_properties_dialog (GtkAction *action,
+ ClockData *cd);
+
+static void display_properties_dialog (ClockData *cd,
+ gboolean start_in_locations_page);
+static void display_help_dialog (GtkAction *action,
+ ClockData *cd);
+static void display_about_dialog (GtkAction *action,
+ ClockData *cd);
+static void position_calendar_popup (ClockData *cd);
+static void update_orient (ClockData *cd);
+static void applet_change_orient (MatePanelApplet *applet,
+ MatePanelAppletOrient orient,
+ ClockData *cd);
+
+static void edit_hide (GtkWidget *unused, ClockData *cd);
+static gboolean edit_delete (GtkWidget *unused, GdkEvent *event, ClockData *cd);
+static void save_cities_store (ClockData *cd);
+
+/* ClockBox, an instantiable GtkBox */
+
+typedef GtkBox ClockBox;
+typedef GtkBoxClass ClockBoxClass;
+
+static GType clock_box_get_type (void);
+
+G_DEFINE_TYPE (ClockBox, clock_box, GTK_TYPE_BOX)
+
+static void
+clock_box_init (ClockBox *box)
+{
+}
+
+static void
+clock_box_class_init (ClockBoxClass *klass)
+{
+}
+
+/* Clock */
+
+static inline GtkWidget *
+_clock_get_widget (ClockData *cd,
+ const char *name)
+{
+ return GTK_WIDGET (gtk_builder_get_object (cd->builder, name));
+}
+
+static void
+unfix_size (ClockData *cd)
+{
+ cd->fixed_width = -1;
+ cd->fixed_height = -1;
+ gtk_widget_queue_resize (cd->panel_button);
+}
+
+static int
+calculate_minimum_width (GtkWidget *widget,
+ const gchar *text)
+{
+ PangoContext *context;
+ PangoLayout *layout;
+ int width, height;
+ int focus_width = 0;
+ int focus_pad = 0;
+
+ context = gtk_widget_get_pango_context (widget);
+
+ layout = pango_layout_new (context);
+ pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
+ pango_layout_set_text (layout, text, -1);
+ pango_layout_get_pixel_size (layout, &width, &height);
+ g_object_unref (G_OBJECT (layout));
+ layout = NULL;
+
+ gtk_widget_style_get (widget,
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_pad,
+ NULL);
+
+ width += 2 * (focus_width + focus_pad + gtk_widget_get_style (widget)->xthickness);
+
+ return width;
+}
+
+static void
+clock_set_timeout (ClockData *cd,
+ time_t now)
+{
+ int timeouttime;
+
+ if (cd->format == CLOCK_FORMAT_INTERNET) {
+ int itime_ms;
+
+ itime_ms = ((unsigned int) (get_itime (now) * 1000));
+
+ if (!cd->showseconds)
+ timeouttime = (999 - itime_ms % 1000) * 86.4 + 1;
+ else {
+ struct timeval tv;
+ gettimeofday (&tv, NULL);
+ itime_ms += (tv.tv_usec * 86.4) / 1000;
+ timeouttime = ((999 - itime_ms % 1000) * 86.4) / 100 + 1;
+ }
+ } else {
+ struct timeval tv;
+
+ gettimeofday (&tv, NULL);
+ timeouttime = (G_USEC_PER_SEC - tv.tv_usec)/1000+1;
+
+ /* timeout of one minute if we don't care about the seconds */
+ if (cd->format != CLOCK_FORMAT_UNIX &&
+ !cd->showseconds &&
+ (!cd->set_time_window || !gtk_widget_get_visible (cd->set_time_window)))
+ timeouttime += 1000 * (59 - now % 60);
+ }
+
+ cd->timeout = g_timeout_add (timeouttime,
+ clock_timeout_callback,
+ cd);
+}
+
+static int
+clock_timeout_callback (gpointer data)
+{
+ ClockData *cd = data;
+ time_t new_time;
+
+ time (&new_time);
+
+ if (!cd->showseconds &&
+ (!cd->set_time_window || !gtk_widget_get_visible (cd->set_time_window)) &&
+ cd->format != CLOCK_FORMAT_UNIX &&
+ cd->format != CLOCK_FORMAT_CUSTOM) {
+ if (cd->format == CLOCK_FORMAT_INTERNET &&
+ (unsigned int)get_itime (new_time) !=
+ (unsigned int)get_itime (cd->current_time)) {
+ update_clock (cd);
+ } else if ((cd->format == CLOCK_FORMAT_12 ||
+ cd->format == CLOCK_FORMAT_24) &&
+ new_time / 60 != cd->current_time / 60) {
+ update_clock (cd);
+ }
+ } else {
+ update_clock (cd);
+ }
+
+ clock_set_timeout (cd, new_time);
+
+ return FALSE;
+}
+
+static float
+get_itime (time_t current_time)
+{
+ struct tm *tm;
+ float itime;
+ time_t bmt;
+
+ /* BMT (Biel Mean Time) is GMT+1 */
+ bmt = current_time + 3600;
+ tm = gmtime (&bmt);
+ itime = (tm->tm_hour*3600.0 + tm->tm_min*60.0 + tm->tm_sec)/86.4;
+
+ return itime;
+}
+
+/* adapted from panel-toplevel.c */
+static int
+calculate_minimum_height (GtkWidget *widget,
+ MatePanelAppletOrient orientation)
+{
+ GtkStyle *style;
+ PangoContext *context;
+ PangoFontMetrics *metrics;
+ int focus_width = 0;
+ int focus_pad = 0;
+ int ascent;
+ int descent;
+ int thickness;
+
+ style = gtk_widget_get_style (widget);
+ context = gtk_widget_get_pango_context (widget);
+ metrics = pango_context_get_metrics (context,
+ style->font_desc,
+ pango_context_get_language (context));
+
+ ascent = pango_font_metrics_get_ascent (metrics);
+ descent = pango_font_metrics_get_descent (metrics);
+
+ pango_font_metrics_unref (metrics);
+
+ gtk_widget_style_get (widget,
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_pad,
+ NULL);
+
+ if (orientation == MATE_PANEL_APPLET_ORIENT_UP
+ || orientation == MATE_PANEL_APPLET_ORIENT_DOWN) {
+ thickness = style->ythickness;
+ } else {
+ thickness = style->xthickness;
+ }
+
+ return PANGO_PIXELS (ascent + descent) + 2 * (focus_width + focus_pad + thickness);
+}
+
+static gboolean
+use_two_line_format (ClockData *cd)
+{
+ if (cd->size >= 2 * calculate_minimum_height (cd->panel_button, cd->orient))
+ return TRUE;
+
+ return FALSE;
+}
+
+static char *
+get_updated_timeformat (ClockData *cd)
+{
+ /* Show date in another line if panel is vertical, or
+ * horizontal but large enough to hold two lines of text
+ */
+ char *result;
+ const char *time_format;
+ const char *date_format;
+ char *clock_format;
+
+ if (cd->format == CLOCK_FORMAT_12)
+ /* Translators: This is a strftime format string.
+ * It is used to display the time in 12-hours format (eg, like
+ * in the US: 8:10 am). The %p expands to am/pm. */
+ time_format = cd->showseconds ? _("%l:%M:%S %p") : _("%l:%M %p");
+ else
+ /* Translators: This is a strftime format string.
+ * It is used to display the time in 24-hours format (eg, like
+ * in France: 20:10). */
+ time_format = cd->showseconds ? _("%H:%M:%S") : _("%H:%M");
+
+ if (!cd->showdate)
+ clock_format = g_strdup (time_format);
+
+ else {
+ /* Translators: This is a strftime format string.
+ * It is used to display the date. Replace %e with %d if, when
+ * the day of the month as a decimal number is a single digit,
+ * it should begin with a 0 in your locale (e.g. "May 01"
+ * instead of "May 1"). */
+ date_format = _("%a %b %e");
+
+ if (use_two_line_format (cd))
+ /* translators: reverse the order of these arguments
+ * if the time should come before the
+ * date on a clock in your locale.
+ */
+ clock_format = g_strdup_printf (_("%1$s\n%2$s"),
+ date_format,
+ time_format);
+ else
+ /* translators: reverse the order of these arguments
+ * if the time should come before the
+ * date on a clock in your locale.
+ */
+ clock_format = g_strdup_printf (_("%1$s, %2$s"),
+ date_format,
+ time_format);
+ }
+
+ result = g_locale_from_utf8 (clock_format, -1, NULL, NULL, NULL);
+ g_free (clock_format);
+
+ /* let's be paranoid */
+ if (!result)
+ result = g_strdup ("???");
+
+ return result;
+}
+
+static void
+update_timeformat (ClockData *cd)
+{
+ g_free (cd->timeformat);
+ cd->timeformat = get_updated_timeformat (cd);
+}
+
+/* sets accessible name and description for the widget */
+static void
+set_atk_name_description (GtkWidget *widget,
+ const char *name,
+ const char *desc)
+{
+ AtkObject *obj;
+ obj = gtk_widget_get_accessible (widget);
+
+ /* return if gail is not loaded */
+ if (!GTK_IS_ACCESSIBLE (obj))
+ return;
+
+ if (desc != NULL)
+ atk_object_set_description (obj, desc);
+ if (name != NULL)
+ atk_object_set_name (obj, name);
+}
+
+static void
+update_location_tiles (ClockData *cd)
+{
+ GList *l;
+
+ for (l = cd->location_tiles; l; l = l->next) {
+ ClockLocationTile *tile;
+
+ tile = CLOCK_LOCATION_TILE (l->data);
+ clock_location_tile_refresh (tile, FALSE);
+ }
+}
+
+static char *
+format_time (ClockData *cd)
+{
+ struct tm *tm;
+ char hour[256];
+ char *utf8;
+
+ utf8 = NULL;
+
+ tm = localtime (&cd->current_time);
+
+ if (cd->format == CLOCK_FORMAT_UNIX) {
+ if (use_two_line_format (cd)) {
+ utf8 = g_strdup_printf ("%lu\n%05lu",
+ (unsigned long)(cd->current_time / 100000L),
+ (unsigned long)(cd->current_time % 100000L));
+ } else {
+ utf8 = g_strdup_printf ("%lu",
+ (unsigned long)cd->current_time);
+ }
+ } else if (cd->format == CLOCK_FORMAT_INTERNET) {
+ float itime = get_itime (cd->current_time);
+ if (cd->showseconds)
+ utf8 = g_strdup_printf ("@%3.2f", itime);
+ else
+ utf8 = g_strdup_printf ("@%3d", (unsigned int) itime);
+ } else if (cd->format == CLOCK_FORMAT_CUSTOM) {
+ char *timeformat = g_locale_from_utf8 (cd->custom_format, -1,
+ NULL, NULL, NULL);
+ if (!timeformat)
+ strcpy (hour, "???");
+ else if (strftime (hour, sizeof (hour), timeformat, tm) <= 0)
+ strcpy (hour, "???");
+ g_free (timeformat);
+
+ utf8 = g_locale_to_utf8 (hour, -1, NULL, NULL, NULL);
+ } else {
+ if (strftime (hour, sizeof (hour), cd->timeformat, tm) <= 0)
+ strcpy (hour, "???");
+
+ utf8 = g_locale_to_utf8 (hour, -1, NULL, NULL, NULL);
+ }
+
+ if (!utf8)
+ utf8 = g_strdup (hour);
+
+ return utf8;
+}
+
+static gchar *
+format_time_24 (ClockData *cd)
+{
+ struct tm *tm;
+ gchar buf[128];
+
+ tm = localtime (&cd->current_time);
+ strftime (buf, sizeof (buf) - 1, "%k:%M:%S", tm);
+ return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
+}
+
+static void
+update_clock (ClockData * cd)
+{
+ gboolean use_markup;
+ char *utf8;
+
+ use_markup = FALSE;
+
+ time (&cd->current_time);
+ utf8 = format_time (cd);
+
+ use_markup = FALSE;
+ if (pango_parse_markup (utf8, -1, 0, NULL, NULL, NULL, NULL))
+ use_markup = TRUE;
+
+ if (use_markup)
+ gtk_label_set_markup (GTK_LABEL (cd->clockw), utf8);
+ else
+ gtk_label_set_text (GTK_LABEL (cd->clockw), utf8);
+
+ g_free (utf8);
+
+ update_orient (cd);
+ gtk_widget_queue_resize (cd->panel_button);
+
+ update_tooltip (cd);
+ update_location_tiles (cd);
+
+ if (cd->map_widget && cd->calendar_popup && gtk_widget_get_visible (cd->calendar_popup))
+ clock_map_update_time (CLOCK_MAP (cd->map_widget));
+
+ if (cd->current_time_label &&
+ gtk_widget_get_visible (cd->current_time_label)) {
+ utf8 = format_time_24 (cd);
+ gtk_label_set_text (GTK_LABEL (cd->current_time_label), utf8);
+ g_free (utf8);
+ }
+}
+
+static void
+update_tooltip (ClockData * cd)
+{
+ if (!cd->showdate) {
+ struct tm *tm;
+ char date[256];
+ char *utf8, *loc;
+ char *zone;
+ time_t now_t;
+ struct tm now;
+ char *tip;
+
+ tm = localtime (&cd->current_time);
+
+ utf8 = NULL;
+
+ /* Show date in tooltip. */
+ /* Translators: This is a strftime format string.
+ * It is used to display a date. Please leave "%%s" as it is:
+ * it will be used to insert the timezone name later. */
+ loc = g_locale_from_utf8 (_("%A %B %d (%%s)"), -1, NULL, NULL, NULL);
+ if (!loc)
+ strcpy (date, "???");
+ else if (strftime (date, sizeof (date), loc, tm) <= 0)
+ strcpy (date, "???");
+ g_free (loc);
+
+ utf8 = g_locale_to_utf8 (date, -1, NULL, NULL, NULL);
+
+ /* Add the timezone name */
+
+ tzset ();
+ time (&now_t);
+ localtime_r (&now_t, &now);
+
+ if (now.tm_isdst > 0) {
+ zone = tzname[1];
+ } else {
+ zone = tzname[0];
+ }
+
+ tip = g_strdup_printf (utf8, zone);
+
+ gtk_widget_set_tooltip_text (cd->panel_button, tip);
+ g_free (utf8);
+ g_free (tip);
+ } else {
+#ifdef HAVE_LIBECAL
+ if (cd->calendar_popup)
+ gtk_widget_set_tooltip_text (cd->panel_button,
+ _("Click to hide your appointments and tasks"));
+ else
+ gtk_widget_set_tooltip_text (cd->panel_button,
+ _("Click to view your appointments and tasks"));
+#else
+ if (cd->calendar_popup)
+ gtk_widget_set_tooltip_text (cd->panel_button,
+ _("Click to hide month calendar"));
+ else
+ gtk_widget_set_tooltip_text (cd->panel_button,
+ _("Click to view month calendar"));
+#endif
+ }
+}
+
+static void
+refresh_clock (ClockData *cd)
+{
+ unfix_size (cd);
+ update_clock (cd);
+}
+
+static void
+refresh_clock_timeout(ClockData *cd)
+{
+ unfix_size (cd);
+
+ update_timeformat (cd);
+
+ if (cd->timeout)
+ g_source_remove (cd->timeout);
+
+ update_clock (cd);
+
+ clock_set_timeout (cd, cd->current_time);
+}
+
+/**
+ * This is like refresh_clock_timeout(), except that we only care about whether
+ * the time actually changed. We don't care about the format.
+ */
+static void
+refresh_click_timeout_time_only (ClockData *cd)
+{
+ if (cd->timeout)
+ g_source_remove (cd->timeout);
+ clock_timeout_callback (cd);
+}
+
+static void
+free_locations (ClockData *cd)
+{
+ GList *l;
+
+ for (l = cd->locations; l; l = l->next)
+ g_object_unref (l->data);
+
+ g_list_free (cd->locations);
+ cd->locations = NULL;
+}
+
+static void
+destroy_clock (GtkWidget * widget, ClockData *cd)
+{
+ MateConfClient *client;
+ int i;
+
+ client = mateconf_client_get_default ();
+
+ for (i = 0; i < N_MATECONF_PREFS; i++)
+ mateconf_client_notify_remove (
+ client, cd->listeners [i]);
+
+ g_object_unref (G_OBJECT (client));
+
+ if (cd->timeout)
+ g_source_remove (cd->timeout);
+ cd->timeout = 0;
+
+ if (cd->props)
+ gtk_widget_destroy (cd->props);
+ cd->props = NULL;
+
+ if (cd->calendar_popup)
+ gtk_widget_destroy (cd->calendar_popup);
+ cd->calendar_popup = NULL;
+
+ g_free (cd->timeformat);
+ g_free (cd->custom_format);
+
+ free_locations (cd);
+
+ g_list_free (cd->location_tiles);
+ cd->location_tiles = NULL;
+
+ if (cd->systz) {
+ g_object_unref (cd->systz);
+ cd->systz = NULL;
+ }
+
+ if (cd->cities_store) {
+ g_object_unref (cd->cities_store);
+ cd->cities_store = NULL;
+ }
+
+ if (cd->builder) {
+ g_object_unref (cd->builder);
+ cd->builder = NULL;
+ }
+
+ g_free (cd);
+
+#ifdef HAVE_LIBECAL
+ if (clock_numbers > 0) {
+ e_passwords_shutdown ();
+ clock_numbers--;
+ }
+#endif
+}
+
+static gboolean
+close_on_escape (GtkWidget *widget,
+ GdkEventKey *event,
+ GtkToggleButton *toggle_button)
+{
+ if (event->keyval == GDK_Escape) {
+ gtk_toggle_button_set_active (toggle_button, FALSE);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+delete_event (GtkWidget *widget,
+ GdkEvent *event,
+ GtkToggleButton *toggle_button)
+{
+ gtk_toggle_button_set_active (toggle_button, FALSE);
+ return TRUE;
+}
+
+static void
+edit_locations_cb (CalendarWindow *calwin, gpointer data)
+{
+ ClockData *cd;
+
+ cd = data;
+
+ display_properties_dialog (cd, TRUE);
+}
+
+static GtkWidget *
+create_calendar (ClockData *cd)
+{
+ GtkWidget *window;
+ char *prefs_dir;
+
+ prefs_dir = mate_panel_applet_get_preferences_key (MATE_PANEL_APPLET (cd->applet));
+ window = calendar_window_new (&cd->current_time,
+ prefs_dir,
+ cd->orient == MATE_PANEL_APPLET_ORIENT_UP);
+ g_free (prefs_dir);
+
+ calendar_window_set_show_weeks (CALENDAR_WINDOW (window),
+ cd->showweek);
+ calendar_window_set_time_format (CALENDAR_WINDOW (window),
+ cd->format);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (cd->applet));
+
+ g_signal_connect (window, "edit-locations",
+ G_CALLBACK (edit_locations_cb), cd);
+
+ g_signal_connect (window, "delete_event",
+ G_CALLBACK (delete_event), cd->panel_button);
+ g_signal_connect (window, "key_press_event",
+ G_CALLBACK (close_on_escape), cd->panel_button);
+
+ return window;
+}
+
+static void
+position_calendar_popup (ClockData *cd)
+{
+ GtkRequisition req;
+ GtkAllocation allocation;
+ GdkScreen *screen;
+ GdkRectangle monitor;
+ GdkGravity gravity = GDK_GRAVITY_NORTH_WEST;
+ int button_w, button_h;
+ int x, y;
+ int w, h;
+ int i, n;
+ gboolean found_monitor = FALSE;
+
+ /* Get root origin of the toggle button, and position above that. */
+ gdk_window_get_origin (gtk_widget_get_window (cd->panel_button),
+ &x, &y);
+
+ gtk_window_get_size (GTK_WINDOW (cd->calendar_popup), &w, &h);
+ gtk_widget_size_request (cd->calendar_popup, &req);
+ w = req.width;
+ h = req.height;
+
+ gtk_widget_get_allocation (cd->panel_button, &allocation);
+ button_w = allocation.width;
+ button_h = allocation.height;
+
+ screen = gtk_window_get_screen (GTK_WINDOW (cd->calendar_popup));
+
+ n = gdk_screen_get_n_monitors (screen);
+ for (i = 0; i < n; i++) {
+ gdk_screen_get_monitor_geometry (screen, i, &monitor);
+ if (x >= monitor.x && x <= monitor.x + monitor.width &&
+ y >= monitor.y && y <= monitor.y + monitor.height) {
+ found_monitor = TRUE;
+ break;
+ }
+ }
+
+ if (!found_monitor) {
+ /* eek, we should be on one of those xinerama
+ monitors */
+ monitor.x = 0;
+ monitor.y = 0;
+ monitor.width = gdk_screen_get_width (screen);
+ monitor.height = gdk_screen_get_height (screen);
+ }
+
+ /* Based on panel orientation, position the popup.
+ * Ignore window gravity since the window is undecorated.
+ * The orientations are all named backward from what
+ * I expected.
+ */
+ switch (cd->orient) {
+ case MATE_PANEL_APPLET_ORIENT_RIGHT:
+ x += button_w;
+ if ((y + h) > monitor.y + monitor.height)
+ y -= (y + h) - (monitor.y + monitor.height);
+
+ if ((y + h) > (monitor.height / 2))
+ gravity = GDK_GRAVITY_SOUTH_WEST;
+ else
+ gravity = GDK_GRAVITY_NORTH_WEST;
+
+ break;
+ case MATE_PANEL_APPLET_ORIENT_LEFT:
+ x -= w;
+ if ((y + h) > monitor.y + monitor.height)
+ y -= (y + h) - (monitor.y + monitor.height);
+
+ if ((y + h) > (monitor.height / 2))
+ gravity = GDK_GRAVITY_SOUTH_EAST;
+ else
+ gravity = GDK_GRAVITY_NORTH_EAST;
+
+ break;
+ case MATE_PANEL_APPLET_ORIENT_DOWN:
+ y += button_h;
+ if ((x + w) > monitor.x + monitor.width)
+ x -= (x + w) - (monitor.x + monitor.width);
+
+ gravity = GDK_GRAVITY_NORTH_WEST;
+
+ break;
+ case MATE_PANEL_APPLET_ORIENT_UP:
+ y -= h;
+ if ((x + w) > monitor.x + monitor.width)
+ x -= (x + w) - (monitor.x + monitor.width);
+
+ gravity = GDK_GRAVITY_SOUTH_WEST;
+
+ break;
+ }
+
+ gtk_window_move (GTK_WINDOW (cd->calendar_popup), x, y);
+ gtk_window_set_gravity (GTK_WINDOW (cd->calendar_popup), gravity);
+}
+
+static void
+add_to_group (GtkWidget *child, gpointer data)
+{
+ GtkSizeGroup *group = data;
+
+ gtk_size_group_add_widget (group, child);
+}
+
+static void
+create_clock_window (ClockData *cd)
+{
+ GtkWidget *locations_box;
+
+ locations_box = calendar_window_get_locations_box (CALENDAR_WINDOW (cd->calendar_popup));
+ gtk_widget_show (locations_box);
+
+ cd->clock_vbox = gtk_vbox_new (FALSE, 6);
+ gtk_container_add (GTK_CONTAINER (locations_box), cd->clock_vbox);
+
+ cd->clock_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+ gtk_size_group_set_ignore_hidden (cd->clock_group, FALSE);
+
+ gtk_container_foreach (GTK_CONTAINER (locations_box),
+ (GtkCallback) add_to_group,
+ cd->clock_group);
+}
+
+static gint
+sort_locations_by_name (gconstpointer a, gconstpointer b)
+{
+ ClockLocation *loc_a = (ClockLocation *) a;
+ ClockLocation *loc_b = (ClockLocation *) b;
+
+ const char *name_a = clock_location_get_display_name (loc_a);
+ const char *name_b = clock_location_get_display_name (loc_b);
+
+ return strcmp (name_a, name_b);
+}
+
+static void
+create_cities_store (ClockData *cd)
+{
+ GtkTreeIter iter;
+ GList *cities = cd->locations;
+ GList *list = NULL;
+
+ if (cd->cities_store) {
+ g_object_unref (G_OBJECT (cd->cities_store));
+ cd->cities_store = NULL;
+ }
+
+ /* City name, Timezone name, Coordinates in lat/long */
+ cd->cities_store = g_object_ref (gtk_list_store_new (COL_CITY_LAST,
+ G_TYPE_STRING, /* COL_CITY_NAME */
+ G_TYPE_STRING, /* COL_CITY_TZ */
+ CLOCK_LOCATION_TYPE)); /* COL_CITY_LOC */
+
+ list = g_list_copy (cities);
+ list = g_list_sort (list, sort_locations_by_name);
+
+ while (list) {
+ ClockLocation *loc = CLOCK_LOCATION (list->data);
+
+ gtk_list_store_append (cd->cities_store, &iter);
+ gtk_list_store_set (cd->cities_store, &iter,
+ COL_CITY_NAME, clock_location_get_display_name (loc),
+ /* FIXME: translate the timezone */
+ COL_CITY_TZ, clock_location_get_timezone (loc),
+ COL_CITY_LOC, loc,
+ -1);
+
+ list = list->next;
+ }
+
+
+ if (cd->prefs_window) {
+ GtkWidget *widget = _clock_get_widget (cd, "cities_list");
+ gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
+ GTK_TREE_MODEL (cd->cities_store));
+ }
+}
+
+static gint
+sort_locations_by_time (gconstpointer a, gconstpointer b)
+{
+ ClockLocation *loc_a = (ClockLocation *) a;
+ ClockLocation *loc_b = (ClockLocation *) b;
+
+ struct tm tm_a;
+ struct tm tm_b;
+ gint ret;
+
+ clock_location_localtime (loc_a, &tm_a);
+ clock_location_localtime (loc_b, &tm_b);
+
+ ret = (tm_a.tm_year == tm_b.tm_year) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_year < tm_b.tm_year) ? -1 : 1;
+ }
+
+ ret = (tm_a.tm_mon == tm_b.tm_mon) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_mon < tm_b.tm_mon) ? -1 : 1;
+ }
+
+ ret = (tm_a.tm_mday == tm_b.tm_mday) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_mday < tm_b.tm_mday) ? -1 : 1;
+ }
+
+ ret = (tm_a.tm_hour == tm_b.tm_hour) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_hour < tm_b.tm_hour) ? -1 : 1;
+ }
+
+ ret = (tm_a.tm_min == tm_b.tm_min) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_min < tm_b.tm_min) ? -1 : 1;
+ }
+
+ ret = (tm_a.tm_sec == tm_b.tm_sec) ? 0 : 1;
+ if (ret) {
+ return (tm_a.tm_sec < tm_b.tm_sec) ? -1 : 1;
+ }
+
+ return ret;
+}
+
+static void
+location_tile_pressed_cb (ClockLocationTile *tile, gpointer data)
+{
+ ClockData *cd = data;
+ ClockLocation *loc;
+
+ loc = clock_location_tile_get_location (tile);
+
+ clock_map_blink_location (CLOCK_MAP (cd->map_widget), loc);
+
+ g_object_unref (loc);
+}
+
+static ClockFormat
+location_tile_need_clock_format_cb(ClockLocationTile *tile, gpointer data)
+{
+ ClockData *cd = data;
+
+ return cd->format;
+}
+
+static void
+create_cities_section (ClockData *cd)
+{
+ GList *node;
+ ClockLocationTile *city;
+ GList *cities;
+
+ if (cd->cities_section) {
+ gtk_widget_destroy (cd->cities_section);
+ cd->cities_section = NULL;
+ }
+
+ g_list_free (cd->location_tiles);
+ cd->location_tiles = NULL;
+
+ cd->cities_section = gtk_vbox_new (FALSE, 6);
+ gtk_container_set_border_width (GTK_CONTAINER (cd->cities_section), 0);
+
+ cities = cd->locations;
+ if (g_list_length (cities) == 0) {
+ /* if the list is empty, don't bother showing the
+ cities section */
+ gtk_widget_hide (cd->cities_section);
+ return;
+ }
+
+ /* Copy the existing list, so we can sort it nondestructively */
+ node = g_list_copy (cities);
+ node = g_list_sort (node, sort_locations_by_time);
+ node = g_list_reverse (node);
+
+ while (node) {
+ ClockLocation *loc = node->data;
+
+ city = clock_location_tile_new (loc, CLOCK_FACE_SMALL);
+ g_signal_connect (city, "tile-pressed",
+ G_CALLBACK (location_tile_pressed_cb), cd);
+ g_signal_connect (city, "need-clock-format",
+ G_CALLBACK (location_tile_need_clock_format_cb), cd);
+
+ gtk_box_pack_start (GTK_BOX (cd->cities_section),
+ GTK_WIDGET (city),
+ FALSE, FALSE, 0);
+
+ cd->location_tiles = g_list_prepend (cd->location_tiles, city);
+
+ clock_location_tile_refresh (city, TRUE);
+
+ node = g_list_next (node);
+ }
+
+ g_list_free (node);
+
+ gtk_box_pack_end (GTK_BOX (cd->clock_vbox),
+ cd->cities_section, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (cd->cities_section);
+}
+
+static GList *
+map_need_locations_cb (ClockMap *map, gpointer data)
+{
+ ClockData *cd = data;
+
+ return cd->locations;
+}
+
+static void
+create_map_section (ClockData *cd)
+{
+ ClockMap *map;
+
+ if (cd->map_widget) {
+ gtk_widget_destroy (GTK_WIDGET (cd->map_section));
+ cd->map_widget = NULL;
+ }
+
+ map = clock_map_new ();
+ g_signal_connect (map, "need-locations",
+ G_CALLBACK (map_need_locations_cb), cd);
+
+ cd->map_section = gtk_alignment_new (0, 0, 1, 1);
+ cd->map_widget = GTK_WIDGET (map);
+
+ gtk_container_add (GTK_CONTAINER (cd->map_section), cd->map_widget);
+
+ gtk_alignment_set_padding (GTK_ALIGNMENT (cd->map_section), 1, 1, 1, 1);
+
+ gtk_box_pack_start (GTK_BOX (cd->clock_vbox), cd->map_section, FALSE, FALSE, 0);
+ gtk_widget_show (cd->map_widget);
+ gtk_widget_show (cd->map_section);
+}
+
+static void
+update_calendar_popup (ClockData *cd)
+{
+ if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cd->panel_button))) {
+ if (cd->calendar_popup) {
+ gtk_widget_destroy (cd->calendar_popup);
+ cd->calendar_popup = NULL;
+ cd->cities_section = NULL;
+ cd->map_section = NULL;
+ cd->map_widget = NULL;
+ cd->clock_vbox = NULL;
+
+ g_list_free (cd->location_tiles);
+ cd->location_tiles = NULL;
+ }
+ update_tooltip (cd);
+ return;
+ }
+
+ if (!cd->calendar_popup) {
+ cd->calendar_popup = create_calendar (cd);
+ g_object_add_weak_pointer (G_OBJECT (cd->calendar_popup),
+ (gpointer *) &cd->calendar_popup);
+ update_tooltip (cd);
+
+ create_clock_window (cd);
+ create_cities_store (cd);
+ create_cities_section (cd);
+ create_map_section (cd);
+ }
+
+ if (cd->calendar_popup && gtk_widget_get_realized (cd->panel_button)) {
+ calendar_window_refresh (CALENDAR_WINDOW (cd->calendar_popup));
+ position_calendar_popup (cd);
+ gtk_window_present (GTK_WINDOW (cd->calendar_popup));
+ }
+}
+
+static void
+toggle_calendar (GtkWidget *button,
+ ClockData *cd)
+{
+ /* if time is wrong, the user might try to fix it by clicking on the
+ * clock */
+ refresh_click_timeout_time_only (cd);
+ update_calendar_popup (cd);
+}
+
+static gboolean
+do_not_eat_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ if (event->button != 1)
+ g_signal_stop_emission_by_name (widget, "button_press_event");
+
+ return FALSE;
+}
+
+/* Don't request smaller size then the last one we did, this avoids
+ jumping when proportional fonts are used. We must take care to
+ call "unfix_size" whenever options are changed or such where
+ we'd want to forget the fixed size */
+static void
+clock_size_request (GtkWidget *clock, GtkRequisition *req, gpointer data)
+{
+ ClockData *cd = data;
+
+ if (req->width > cd->fixed_width)
+ cd->fixed_width = req->width;
+ if (req->height > cd->fixed_height)
+ cd->fixed_height = req->height;
+ req->width = cd->fixed_width;
+ req->height = cd->fixed_height;
+}
+
+static void
+clock_update_text_gravity (GtkWidget *label)
+{
+ PangoLayout *layout;
+ PangoContext *context;
+
+ layout = gtk_label_get_layout (GTK_LABEL (label));
+ context = pango_layout_get_context (layout);
+ pango_context_set_base_gravity (context, PANGO_GRAVITY_AUTO);
+}
+
+static inline void
+force_no_focus_padding (GtkWidget *widget)
+{
+ static gboolean first_time = TRUE;
+
+ if (first_time) {
+ gtk_rc_parse_string ("\n"
+ " style \"clock-applet-button-style\"\n"
+ " {\n"
+ " GtkWidget::focus-line-width=0\n"
+ " GtkWidget::focus-padding=0\n"
+ " }\n"
+ "\n"
+ " widget \"*.clock-applet-button\" style \"clock-applet-button-style\"\n"
+ "\n");
+ first_time = FALSE;
+ }
+
+ gtk_widget_set_name (widget, "clock-applet-button");
+}
+
+static GtkWidget *
+create_main_clock_button (void)
+{
+ GtkWidget *button;
+
+ button = gtk_toggle_button_new ();
+ gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+
+ force_no_focus_padding (button);
+
+ return button;
+}
+
+static GtkWidget *
+create_main_clock_label (ClockData *cd)
+{
+ GtkWidget *label;
+
+ label = gtk_label_new (NULL);
+ g_signal_connect (label, "size_request",
+ G_CALLBACK (clock_size_request),
+ cd);
+ g_signal_connect_swapped (label, "style_set",
+ G_CALLBACK (unfix_size),
+ cd);
+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
+ clock_update_text_gravity (label);
+ g_signal_connect (label, "screen-changed",
+ G_CALLBACK (clock_update_text_gravity),
+ NULL);
+
+ return label;
+}
+
+static gboolean
+weather_tooltip (GtkWidget *widget,
+ gint x,
+ gint y,
+ gboolean keyboard_mode,
+ GtkTooltip *tooltip,
+ ClockData *cd)
+{
+ GList *locations, *l;
+ WeatherInfo *info;
+
+ locations = cd->locations;
+
+ for (l = locations; l; l = l->next) {
+ ClockLocation *location = l->data;
+ if (clock_location_is_current (location)) {
+ info = clock_location_get_weather_info (location);
+ if (!info || !weather_info_is_valid (info))
+ continue;
+
+ weather_info_setup_tooltip (info, location, tooltip, cd->format);
+
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static void
+create_clock_widget (ClockData *cd)
+{
+#ifdef HAVE_LIBECAL
+ clock_numbers++;
+ e_passwords_init ();
+#endif
+
+ /* Main toggle button */
+ cd->panel_button = create_main_clock_button ();
+ g_signal_connect (cd->panel_button, "button_press_event",
+ G_CALLBACK (do_not_eat_button_press), NULL);
+ g_signal_connect (cd->panel_button, "toggled",
+ G_CALLBACK (toggle_calendar), cd);
+ g_signal_connect (G_OBJECT (cd->panel_button), "destroy",
+ G_CALLBACK (destroy_clock),
+ cd);
+ gtk_widget_show (cd->panel_button);
+
+ /* Main orientable box */
+ cd->main_obox = g_object_new (clock_box_get_type (), NULL);
+ gtk_box_set_spacing (GTK_BOX (cd->main_obox), 12); /* spacing between weather and time */
+ gtk_container_add (GTK_CONTAINER (cd->panel_button), cd->main_obox);
+ gtk_widget_show (cd->main_obox);
+
+ /* Weather orientable box */
+ cd->weather_obox = g_object_new (clock_box_get_type (), NULL);
+ gtk_box_set_spacing (GTK_BOX (cd->weather_obox), 2); /* spacing between weather icon and temperature */
+ gtk_box_pack_start (GTK_BOX (cd->main_obox), cd->weather_obox, FALSE, FALSE, 0);
+ gtk_widget_set_has_tooltip (cd->weather_obox, TRUE);
+ g_signal_connect (cd->weather_obox, "query-tooltip",
+ G_CALLBACK (weather_tooltip), cd);
+
+ /* Weather widgets */
+ cd->panel_weather_icon = gtk_image_new ();
+ gtk_box_pack_start (GTK_BOX (cd->weather_obox), cd->panel_weather_icon, FALSE, FALSE, 0);
+
+ cd->panel_temperature_label = gtk_label_new (NULL);
+ gtk_box_pack_start (GTK_BOX (cd->weather_obox), cd->panel_temperature_label, FALSE, FALSE, 0);
+
+ /* Main label for time display */
+ cd->clockw = create_main_clock_label (cd);
+ gtk_box_pack_start (GTK_BOX (cd->main_obox), cd->clockw, FALSE, FALSE, 0);
+ gtk_widget_show (cd->clockw);
+
+ /* Done! */
+
+ set_atk_name_description (GTK_WIDGET (cd->applet), NULL,
+ _("Computer Clock"));
+
+ gtk_container_add (GTK_CONTAINER (cd->applet), cd->panel_button);
+ gtk_container_set_border_width (GTK_CONTAINER (cd->applet), 0);
+
+ cd->props = NULL;
+ cd->orient = -1;
+ cd->size = mate_panel_applet_get_size (MATE_PANEL_APPLET (cd->applet));
+
+ update_panel_weather (cd);
+
+ /* Refresh the clock so that it paints its first state */
+ refresh_clock_timeout (cd);
+ applet_change_orient (MATE_PANEL_APPLET (cd->applet),
+ mate_panel_applet_get_orient (MATE_PANEL_APPLET (cd->applet)),
+ cd);
+}
+
+static void
+update_orient (ClockData *cd)
+{
+ const gchar *text;
+ int min_width;
+ GtkAllocation allocation;
+ gdouble new_angle;
+ gdouble angle;
+
+ text = gtk_label_get_text (GTK_LABEL (cd->clockw));
+ min_width = calculate_minimum_width (cd->panel_button, text);
+ gtk_widget_get_allocation (cd->panel_button, &allocation);
+
+ if (cd->orient == MATE_PANEL_APPLET_ORIENT_LEFT &&
+ min_width > allocation.width)
+ new_angle = 270;
+ else if (cd->orient == MATE_PANEL_APPLET_ORIENT_RIGHT &&
+ min_width > allocation.width)
+ new_angle = 90;
+ else
+ new_angle = 0;
+
+ angle = gtk_label_get_angle (GTK_LABEL (cd->clockw));
+ if (angle != new_angle) {
+ unfix_size (cd);
+ gtk_label_set_angle (GTK_LABEL (cd->clockw), new_angle);
+ gtk_label_set_angle (GTK_LABEL (cd->panel_temperature_label), new_angle);
+ }
+}
+
+/* this is when the panel orientation changes */
+static void
+applet_change_orient (MatePanelApplet *applet,
+ MatePanelAppletOrient orient,
+ ClockData *cd)
+{
+ GtkOrientation o;
+
+ if (orient == cd->orient)
+ return;
+
+ cd->orient = orient;
+
+ switch (cd->orient) {
+ case MATE_PANEL_APPLET_ORIENT_RIGHT:
+ o = GTK_ORIENTATION_VERTICAL;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_LEFT:
+ o = GTK_ORIENTATION_VERTICAL;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_DOWN:
+ o = GTK_ORIENTATION_HORIZONTAL;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_UP:
+ o = GTK_ORIENTATION_HORIZONTAL;
+ break;
+ default:
+ g_assert_not_reached ();
+ return;
+ }
+
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (cd->main_obox), o);
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (cd->weather_obox), o);
+
+ unfix_size (cd);
+ update_clock (cd);
+ update_calendar_popup (cd);
+}
+
+/* this is when the panel size changes */
+static void
+panel_button_change_pixel_size (GtkWidget *widget,
+ GtkAllocation *allocation,
+ ClockData *cd)
+{
+ int new_size;
+
+ if (cd->old_allocation.width == allocation->width &&
+ cd->old_allocation.height == allocation->height)
+ return;
+
+ cd->old_allocation.width = allocation->width;
+ cd->old_allocation.height = allocation->height;
+
+ if (cd->orient == MATE_PANEL_APPLET_ORIENT_LEFT ||
+ cd->orient == MATE_PANEL_APPLET_ORIENT_RIGHT)
+ new_size = allocation->width;
+ else
+ new_size = allocation->height;
+
+ cd->size = new_size;
+
+ unfix_size (cd);
+ update_timeformat (cd);
+ update_clock (cd);
+}
+
+static void
+copy_time (GtkAction *action,
+ ClockData *cd)
+{
+ char string[256];
+ char *utf8;
+
+ if (cd->format == CLOCK_FORMAT_UNIX) {
+ g_snprintf (string, sizeof(string), "%lu",
+ (unsigned long)cd->current_time);
+ } else if (cd->format == CLOCK_FORMAT_INTERNET) {
+ float itime = get_itime (cd->current_time);
+ if (cd->showseconds)
+ g_snprintf (string, sizeof (string), "@%3.2f", itime);
+ else
+ g_snprintf (string, sizeof (string), "@%3d",
+ (unsigned int) itime);
+ } else {
+ struct tm *tm;
+ char *format;
+
+ if (cd->format == CLOCK_FORMAT_CUSTOM) {
+ format = g_locale_from_utf8 (cd->custom_format, -1,
+ NULL, NULL, NULL);
+ } else if (cd->format == CLOCK_FORMAT_12) {
+ if (cd->showseconds)
+ /* Translators: This is a strftime format
+ * string.
+ * It is used to display the time in 12-hours
+ * format with a leading 0 if needed (eg, like
+ * in the US: 08:10 am). The %p expands to
+ * am/pm. */
+ format = g_locale_from_utf8 (_("%I:%M:%S %p"), -1, NULL, NULL, NULL);
+ else
+ /* Translators: This is a strftime format
+ * string.
+ * It is used to display the time in 12-hours
+ * format with a leading 0 if needed (eg, like
+ * in the US: 08:10 am). The %p expands to
+ * am/pm. */
+ format = g_locale_from_utf8 (_("%I:%M %p"), -1, NULL, NULL, NULL);
+ } else {
+ if (cd->showseconds)
+ /* Translators: This is a strftime format
+ * string.
+ * It is used to display the time in 24-hours
+ * format (eg, like in France: 20:10). */
+ format = g_locale_from_utf8 (_("%H:%M:%S"), -1, NULL, NULL, NULL);
+ else
+ /* Translators: This is a strftime format
+ * string.
+ * It is used to display the time in 24-hours
+ * format (eg, like in France: 20:10). */
+ format = g_locale_from_utf8 (_("%H:%M"), -1, NULL, NULL, NULL);
+ }
+
+ tm = localtime (&cd->current_time);
+
+ if (!format)
+ strcpy (string, "???");
+ else if (strftime (string, sizeof (string), format, tm) <= 0)
+ strcpy (string, "???");
+ g_free (format);
+ }
+
+ utf8 = g_locale_to_utf8 (string, -1, NULL, NULL, NULL);
+ gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY),
+ utf8, -1);
+ gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ utf8, -1);
+ g_free (utf8);
+}
+
+static void
+copy_date (GtkAction *action,
+ ClockData *cd)
+{
+ struct tm *tm;
+ char string[256];
+ char *utf8, *loc;
+
+ tm = localtime (&cd->current_time);
+
+ /* Translators: This is a strftime format string.
+ * It is used to display a date in the full format (so that people can
+ * copy and paste it elsewhere). */
+ loc = g_locale_from_utf8 (_("%A, %B %d %Y"), -1, NULL, NULL, NULL);
+ if (!loc)
+ strcpy (string, "???");
+ else if (strftime (string, sizeof (string), loc, tm) <= 0)
+ strcpy (string, "???");
+ g_free (loc);
+
+ utf8 = g_locale_to_utf8 (string, -1, NULL, NULL, NULL);
+ gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY),
+ utf8, -1);
+ gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ utf8, -1);
+ g_free (utf8);
+}
+
+static void
+update_set_time_button (ClockData *cd)
+{
+ gint can_set;
+
+ /* this returns more than just a boolean; check the documentation of
+ * the dbus method for more information */
+ can_set = can_set_system_time ();
+
+ if (cd->time_settings_button)
+ gtk_widget_set_sensitive (cd->time_settings_button, can_set);
+
+ if (cd->set_time_button) {
+ gtk_widget_set_sensitive (cd->set_time_button, can_set != 0);
+ gtk_button_set_label (GTK_BUTTON (cd->set_time_button),
+ can_set == 1 ?
+ _("Set System Time...") :
+ _("Set System Time"));
+ }
+}
+
+static void
+set_time_callback (ClockData *cd, GError *error)
+{
+ GtkWidget *window;
+ GtkWidget *dialog;
+
+ if (error) {
+ dialog = gtk_message_dialog_new (NULL,
+ 0,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_CLOSE,
+ _("Failed to set the system time"));
+
+ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy), NULL);
+ gtk_window_present (GTK_WINDOW (dialog));
+
+ g_error_free (error);
+ }
+ else
+ update_set_time_button (cd);
+
+ window = _clock_get_widget (cd, "set-time-window");
+ gtk_widget_hide (window);
+}
+
+static void
+set_time (GtkWidget *widget, ClockData *cd)
+{
+ struct tm t;
+ time_t tim;
+ guint year, month, day;
+
+ time (&tim);
+ /* sets t.isdst -- we could set it to -1 to have mktime() guess the
+ * right value , but we don't know if this works with all libc */
+ localtime_r (&tim, &t);
+
+ t.tm_sec = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (cd->seconds_spin));
+ t.tm_min = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (cd->minutes_spin));
+ t.tm_hour = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (cd->hours_spin));
+ gtk_calendar_get_date (GTK_CALENDAR (cd->calendar), &year, &month, &day);
+ t.tm_year = year - 1900;
+ t.tm_mon = month;
+ t.tm_mday = day;
+
+ tim = mktime (&t);
+
+ set_system_time_async (tim, (GFunc)set_time_callback, cd, NULL);
+}
+
+static void
+cancel_time_settings (GtkWidget *button, ClockData *cd)
+{
+ gtk_widget_hide (cd->set_time_window);
+
+ refresh_click_timeout_time_only (cd);
+}
+
+static gboolean
+delete_time_settings (GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+ cancel_time_settings (widget, data);
+
+ return TRUE;
+}
+
+static void
+fill_time_settings_window (ClockData *cd)
+{
+ time_t now_t;
+ struct tm now;
+
+ /* Fill the time settings */
+ tzset ();
+ time (&now_t);
+ localtime_r (&now_t, &now);
+
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (cd->seconds_spin), now.tm_sec);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (cd->minutes_spin), now.tm_min);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (cd->hours_spin), now.tm_hour);
+
+ gtk_calendar_select_month (GTK_CALENDAR (cd->calendar), now.tm_mon,
+ now.tm_year + 1900);
+ gtk_calendar_select_day (GTK_CALENDAR (cd->calendar), now.tm_mday);
+}
+
+static void
+wrap_cb (GtkSpinButton *spin, ClockData *cd)
+{
+ gdouble value;
+ gdouble min, max;
+ GtkSpinType direction;
+
+ value = gtk_spin_button_get_value (spin);
+ gtk_spin_button_get_range (spin, &min, &max);
+
+ if (value == min)
+ direction = GTK_SPIN_STEP_FORWARD;
+ else
+ direction = GTK_SPIN_STEP_BACKWARD;
+
+ if (spin == (GtkSpinButton *) cd->seconds_spin)
+ gtk_spin_button_spin (GTK_SPIN_BUTTON (cd->minutes_spin), direction, 1.0);
+ else if (spin == (GtkSpinButton *) cd->minutes_spin)
+ gtk_spin_button_spin (GTK_SPIN_BUTTON (cd->hours_spin), direction, 1.0);
+ else {
+ guint year, month, day;
+ GDate *date;
+
+ gtk_calendar_get_date (GTK_CALENDAR (cd->calendar), &year, &month, &day);
+
+ date = g_date_new_dmy (day, month + 1, year);
+
+ if (direction == GTK_SPIN_STEP_FORWARD)
+ g_date_add_days (date, 1);
+ else
+ g_date_subtract_days (date, 1);
+
+ year = g_date_get_year (date);
+ month = g_date_get_month (date) - 1;
+ day = g_date_get_day (date);
+
+ gtk_calendar_select_month (GTK_CALENDAR (cd->calendar), month, year);
+ gtk_calendar_select_day (GTK_CALENDAR (cd->calendar), day);
+
+ g_date_free (date);
+ }
+}
+
+static gboolean
+output_cb (GtkSpinButton *spin,
+ gpointer data)
+{
+ GtkAdjustment *adj;
+ gchar *text;
+ int value;
+
+ adj = gtk_spin_button_get_adjustment (spin);
+ value = (int) gtk_adjustment_get_value (adj);
+ text = g_strdup_printf ("%02d", value);
+ gtk_entry_set_text (GTK_ENTRY (spin), text);
+ g_free (text);
+
+ return TRUE;
+}
+
+static void
+ensure_time_settings_window_is_created (ClockData *cd)
+{
+ GtkWidget *cancel_button;
+
+ if (cd->set_time_window)
+ return;
+
+ cd->set_time_window = _clock_get_widget (cd, "set-time-window");
+ g_signal_connect (cd->set_time_window, "delete_event",
+ G_CALLBACK (delete_time_settings), cd);
+
+ cd->calendar = _clock_get_widget (cd, "calendar");
+ cd->hours_spin = _clock_get_widget (cd, "hours_spin");
+ cd->minutes_spin = _clock_get_widget (cd, "minutes_spin");
+ cd->seconds_spin = _clock_get_widget (cd, "seconds_spin");
+
+ gtk_entry_set_width_chars (GTK_ENTRY (cd->hours_spin), 2);
+ gtk_entry_set_width_chars (GTK_ENTRY (cd->minutes_spin), 2);
+ gtk_entry_set_width_chars (GTK_ENTRY (cd->seconds_spin), 2);
+ gtk_entry_set_alignment (GTK_ENTRY (cd->hours_spin), 1.0);
+ gtk_entry_set_alignment (GTK_ENTRY (cd->minutes_spin), 1.0);
+ gtk_entry_set_alignment (GTK_ENTRY (cd->seconds_spin), 1.0);
+ g_signal_connect (cd->seconds_spin, "wrapped", G_CALLBACK (wrap_cb), cd);
+ g_signal_connect (cd->minutes_spin, "wrapped", G_CALLBACK (wrap_cb), cd);
+ g_signal_connect (cd->hours_spin, "wrapped", G_CALLBACK (wrap_cb), cd);
+
+ g_signal_connect (cd->minutes_spin, "output", G_CALLBACK (output_cb), cd);
+ g_signal_connect (cd->seconds_spin, "output", G_CALLBACK (output_cb), cd);
+
+ cd->set_time_button = _clock_get_widget (cd, "set-time-button");
+ g_signal_connect (cd->set_time_button, "clicked", G_CALLBACK (set_time), cd);
+
+ cancel_button = _clock_get_widget (cd, "cancel-set-time-button");
+ g_signal_connect (cancel_button, "clicked", G_CALLBACK (cancel_time_settings), cd);
+
+ cd->current_time_label = _clock_get_widget (cd, "current_time_label");
+}
+
+static void
+run_time_settings (GtkWidget *unused, ClockData *cd)
+{
+ ensure_time_settings_window_is_created (cd);
+ fill_time_settings_window (cd);
+
+ update_set_time_button (cd);
+
+ gtk_window_present (GTK_WINDOW (cd->set_time_window));
+
+ refresh_click_timeout_time_only (cd);
+}
+
+static void
+config_date (GtkAction *action,
+ ClockData *cd)
+{
+ run_time_settings (NULL, cd);
+}
+
+/* current timestamp */
+static const GtkActionEntry clock_menu_actions [] = {
+ { "ClockPreferences", GTK_STOCK_PROPERTIES, N_("_Preferences"),
+ NULL, NULL,
+ G_CALLBACK (verb_display_properties_dialog) },
+ { "ClockHelp", GTK_STOCK_HELP, N_("_Help"),
+ NULL, NULL,
+ G_CALLBACK (display_help_dialog) },
+ { "ClockAbout", GTK_STOCK_ABOUT, N_("_About"),
+ NULL, NULL,
+ G_CALLBACK (display_about_dialog) },
+ { "ClockCopyTime", GTK_STOCK_COPY, N_("Copy _Time"),
+ NULL, NULL,
+ G_CALLBACK (copy_time) },
+ { "ClockCopyDate", GTK_STOCK_COPY, N_("Copy _Date"),
+ NULL, NULL,
+ G_CALLBACK (copy_date) },
+ { "ClockConfig", GTK_STOCK_PREFERENCES, N_("Ad_just Date & Time"),
+ NULL, NULL,
+ G_CALLBACK (config_date) }
+};
+
+static void
+format_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *clock)
+{
+ const char *value;
+ int new_format;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_STRING)
+ return;
+
+ value = mateconf_value_get_string (entry->value);
+ if (!mateconf_string_to_enum (format_type_enum_map, value, &new_format))
+ return;
+
+ if (!clock->can_handle_format_12 && new_format == CLOCK_FORMAT_12)
+ new_format = CLOCK_FORMAT_24;
+
+ if (new_format == clock->format)
+ return;
+
+ clock->format = new_format;
+ refresh_clock_timeout (clock);
+
+ if (clock->calendar_popup != NULL) {
+ calendar_window_set_time_format (CALENDAR_WINDOW (clock->calendar_popup), clock->format);
+ position_calendar_popup (clock);
+ }
+
+}
+
+static void
+show_seconds_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *clock)
+{
+ gboolean value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL)
+ return;
+
+ value = mateconf_value_get_bool (entry->value);
+
+ clock->showseconds = (value != 0);
+ refresh_clock_timeout (clock);
+}
+
+static void
+show_date_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *clock)
+{
+ gboolean value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL)
+ return;
+
+ value = mateconf_value_get_bool (entry->value);
+
+ clock->showdate = (value != 0);
+ update_timeformat (clock);
+ refresh_clock (clock);
+}
+
+static void
+update_panel_weather (ClockData *cd)
+{
+ if (cd->show_weather)
+ gtk_widget_show (cd->panel_weather_icon);
+ else
+ gtk_widget_hide (cd->panel_weather_icon);
+
+ if (cd->show_temperature)
+ gtk_widget_show (cd->panel_temperature_label);
+ else
+ gtk_widget_hide (cd->panel_temperature_label);
+
+ if ((cd->show_weather || cd->show_temperature) &&
+ g_list_length (cd->locations) > 0)
+ gtk_widget_show (cd->weather_obox);
+ else
+ gtk_widget_hide (cd->weather_obox);
+
+ gtk_widget_queue_resize (cd->applet);
+}
+
+static void
+update_weather_bool_value_and_toggle_from_mateconf (ClockData *cd, MateConfEntry *entry,
+ gboolean *value_loc, const char *widget_name)
+{
+ GtkWidget *widget;
+ gboolean value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL)
+ return;
+
+ value = mateconf_value_get_bool (entry->value);
+
+ *value_loc = (value != 0);
+
+ widget = _clock_get_widget (cd, widget_name);
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
+ *value_loc);
+
+ update_panel_weather (cd);
+}
+
+static void
+show_weather_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *cd)
+{
+ update_weather_bool_value_and_toggle_from_mateconf (cd, entry, &cd->show_weather, "weather_check");
+}
+
+static void
+show_temperature_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *cd)
+{
+ update_weather_bool_value_and_toggle_from_mateconf (cd, entry, &cd->show_temperature, "temperature_check");
+}
+
+static void
+location_weather_updated_cb (ClockLocation *location,
+ WeatherInfo *info,
+ gpointer data)
+{
+ ClockData *cd = data;
+ const gchar *icon_name;
+ const gchar *temp;
+ GtkIconTheme *theme;
+ GdkPixbuf *pixbuf;
+
+ if (!info || !weather_info_is_valid (info))
+ return;
+
+ if (!clock_location_is_current (location))
+ return;
+
+ icon_name = weather_info_get_icon_name (info);
+ /* FIXME: mmh, screen please? Also, don't hardcode to 16 */
+ theme = gtk_icon_theme_get_default ();
+ pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 16,
+ GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+
+ temp = weather_info_get_temp_summary (info);
+
+ gtk_image_set_from_pixbuf (GTK_IMAGE (cd->panel_weather_icon), pixbuf);
+ gtk_label_set_text (GTK_LABEL (cd->panel_temperature_label), temp);
+}
+
+static void
+location_set_current_cb (ClockLocation *loc,
+ gpointer data)
+{
+ ClockData *cd = data;
+ WeatherInfo *info;
+
+ info = clock_location_get_weather_info (loc);
+ location_weather_updated_cb (loc, info, cd);
+
+ if (cd->map_widget)
+ clock_map_refresh (CLOCK_MAP (cd->map_widget));
+ update_location_tiles (cd);
+ save_cities_store (cd);
+}
+
+static void
+locations_changed (ClockData *cd)
+{
+ GList *l;
+ ClockLocation *loc;
+ glong id;
+
+ if (!cd->locations) {
+ if (cd->weather_obox)
+ gtk_widget_hide (cd->weather_obox);
+ if (cd->panel_weather_icon)
+ gtk_image_set_from_pixbuf (GTK_IMAGE (cd->panel_weather_icon),
+ NULL);
+ if (cd->panel_temperature_label)
+ gtk_label_set_text (GTK_LABEL (cd->panel_temperature_label),
+ "");
+ } else {
+ if (cd->weather_obox)
+ gtk_widget_show (cd->weather_obox);
+ }
+
+ for (l = cd->locations; l; l = l->next) {
+ loc = l->data;
+
+ id = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (loc), "weather-updated"));
+ if (id == 0) {
+ id = g_signal_connect (loc, "weather-updated",
+ G_CALLBACK (location_weather_updated_cb), cd);
+ g_object_set_data (G_OBJECT (loc), "weather-updated", GINT_TO_POINTER (id));
+ g_signal_connect (loc, "set-current",
+ G_CALLBACK (location_set_current_cb), cd);
+ }
+ }
+
+ if (cd->map_widget)
+ clock_map_refresh (CLOCK_MAP (cd->map_widget));
+
+ if (cd->clock_vbox)
+ create_cities_section (cd);
+}
+
+
+static void
+set_locations (ClockData *cd, GList *locations)
+{
+ free_locations (cd);
+ cd->locations = locations;
+ locations_changed (cd);
+}
+
+typedef struct {
+ GList *cities;
+ ClockData *cd;
+} LocationParserData;
+
+/* Parser for our serialized locations in mateconf */
+static void
+location_start_element (GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data,
+ GError **error)
+{
+ ClockLocation *loc;
+ LocationParserData *data = user_data;
+ ClockData *cd = data->cd;
+ WeatherPrefs prefs;
+ const gchar *att_name;
+
+ gchar *name = NULL;
+ gchar *city = NULL;
+ gchar *timezone = NULL;
+ gfloat latitude = 0.0;
+ gfloat longitude = 0.0;
+ gchar *code = NULL;
+ gboolean current = FALSE;
+
+ int index = 0;
+
+ prefs.temperature_unit = cd->temperature_unit;
+ prefs.speed_unit = cd->speed_unit;
+
+ if (strcmp (element_name, "location") != 0) {
+ return;
+ }
+
+ setlocale (LC_NUMERIC, "POSIX");
+
+ for (att_name = attribute_names[index]; att_name != NULL;
+ att_name = attribute_names[++index]) {
+ if (strcmp (att_name, "name") == 0) {
+ name = (gchar *)attribute_values[index];
+ } else if (strcmp (att_name, "city") == 0) {
+ city = (gchar *)attribute_values[index];
+ } else if (strcmp (att_name, "timezone") == 0) {
+ timezone = (gchar *)attribute_values[index];
+ } else if (strcmp (att_name, "latitude") == 0) {
+ sscanf (attribute_values[index], "%f", &latitude);
+ } else if (strcmp (att_name, "longitude") == 0) {
+ sscanf (attribute_values[index], "%f", &longitude);
+ } else if (strcmp (att_name, "code") == 0) {
+ code = (gchar *)attribute_values[index];
+ }
+ else if (strcmp (att_name, "current") == 0) {
+ if (strcmp (attribute_values[index], "true") == 0) {
+ current = TRUE;
+ }
+ }
+ }
+
+ setlocale (LC_NUMERIC, "");
+
+ if ((!name && !city) || !timezone) {
+ return;
+ }
+
+ /* migration from the old configuration, when name == city */
+ if (!city)
+ city = name;
+
+ loc = clock_location_find_and_ref (cd->locations, name, city,
+ timezone, latitude, longitude, code);
+ if (!loc)
+ loc = clock_location_new (name, city, timezone,
+ latitude, longitude, code, &prefs);
+
+ if (current && clock_location_is_current_timezone (loc))
+ clock_location_make_current (loc, GDK_WINDOW_XWINDOW (gtk_widget_get_window (cd->applet)),
+ NULL, NULL, NULL);
+
+ data->cities = g_list_append (data->cities, loc);
+}
+
+static GMarkupParser location_parser = {
+ location_start_element, NULL, NULL, NULL, NULL
+};
+
+static void
+cities_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *cd)
+{
+ LocationParserData data;
+
+ GSList *cur = NULL;
+
+ GMarkupParseContext *context;
+
+ data.cities = NULL;
+ data.cd = cd;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_LIST)
+ return;
+
+ context = g_markup_parse_context_new (&location_parser, 0, &data, NULL);
+
+ cur = mateconf_value_get_list (entry->value);
+
+ while (cur) {
+ const char *str = mateconf_value_get_string (cur->data);
+ g_markup_parse_context_parse (context, str, strlen (str), NULL);
+
+ cur = cur->next;
+ }
+
+ g_markup_parse_context_free (context);
+
+ set_locations (cd, data.cities);
+ create_cities_store (cd);
+}
+
+static void
+update_temperature_combo (ClockData *cd)
+{
+ GtkWidget *widget;
+ int active_index;
+
+ widget = _clock_get_widget (cd, "temperature_combo");
+
+ if (cd->use_temperature_default)
+ active_index = 0;
+ else
+ active_index = cd->temperature_unit - 1;
+
+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active_index);
+}
+
+static void
+update_weather_locations (ClockData *cd)
+{
+ GList *locations, *l;
+ WeatherPrefs prefs = {
+ FORECAST_STATE,
+ FALSE,
+ NULL,
+ TEMP_UNIT_CENTIGRADE,
+ SPEED_UNIT_MS,
+ PRESSURE_UNIT_MB,
+ DISTANCE_UNIT_KM
+ };
+
+ prefs.temperature_unit = cd->temperature_unit;
+ prefs.speed_unit = cd->speed_unit;
+
+ locations = cd->locations;
+
+ for (l = locations; l; l = l->next) {
+ clock_location_set_weather_prefs (l->data, &prefs);
+ }
+}
+
+static void
+clock_migrate_to_26 (ClockData *clock)
+{
+ gboolean unixtime;
+ gboolean internettime;
+ int hourformat;
+
+ internettime = mate_panel_applet_mateconf_get_bool (MATE_PANEL_APPLET (clock->applet),
+ "internet_time",
+ NULL);
+ unixtime = mate_panel_applet_mateconf_get_bool (MATE_PANEL_APPLET (clock->applet),
+ "unix_time",
+ NULL);
+ hourformat = mate_panel_applet_mateconf_get_int (MATE_PANEL_APPLET (clock->applet),
+ "hour_format",
+ NULL);
+
+ if (unixtime)
+ clock->format = CLOCK_FORMAT_UNIX;
+ else if (internettime)
+ clock->format = CLOCK_FORMAT_INTERNET;
+ else if (hourformat == 12)
+ clock->format = CLOCK_FORMAT_12;
+ else if (hourformat == 24)
+ clock->format = CLOCK_FORMAT_24;
+
+ /* It's still possible that we have none of the old keys, in which case
+ * we're not migrating from 2.6, but the config is simply wrong. So
+ * don't set the format key in this case. */
+ if (clock->format != CLOCK_FORMAT_INVALID)
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (clock->applet),
+ KEY_FORMAT,
+ mateconf_enum_to_string (format_type_enum_map,
+ clock->format),
+ NULL);
+}
+
+static void
+clock_timezone_changed (SystemTimezone *systz,
+ const char *new_tz,
+ ClockData *cd)
+{
+ /* This will refresh the current location */
+ save_cities_store (cd);
+
+ refresh_click_timeout_time_only (cd);
+}
+
+static void
+parse_and_set_temperature_string (const char *str, ClockData *cd)
+{
+ gint value = 0;
+ gboolean use_default = FALSE;
+
+ value = mateweather_prefs_parse_temperature (str, &use_default);
+
+ cd->use_temperature_default = use_default;
+ cd->temperature_unit = value;
+}
+
+static void
+parse_and_set_speed_string (const char *str, ClockData *cd)
+{
+ gint value = 0;
+ gboolean use_default = FALSE;
+
+ value = mateweather_prefs_parse_speed (str, &use_default);
+
+ cd->use_speed_default = use_default;
+ cd->speed_unit = value;
+}
+
+static void
+temperature_unit_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *cd)
+{
+ const gchar *value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_STRING)
+ return;
+
+ value = mateconf_value_get_string (entry->value);
+ parse_and_set_temperature_string (value, cd);
+ update_temperature_combo (cd);
+ update_weather_locations (cd);
+}
+
+static void
+update_speed_combo (ClockData *cd)
+{
+ GtkWidget *widget;
+ int active_index;
+
+ widget = _clock_get_widget (cd, "wind_speed_combo");
+
+ if (cd->use_speed_default)
+ active_index = 0;
+ else
+ active_index = cd->speed_unit - 1;
+
+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), active_index);
+}
+
+static void
+speed_unit_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *cd)
+{
+ const gchar *value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_STRING)
+ return;
+
+ value = mateconf_value_get_string (entry->value);
+ parse_and_set_speed_string (value, cd);
+ update_speed_combo (cd);
+ update_weather_locations (cd);
+}
+
+static void
+custom_format_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *clock)
+{
+ const char *value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_STRING)
+ return;
+
+ value = mateconf_value_get_string (entry->value);
+
+ g_free (clock->custom_format);
+ clock->custom_format = g_strdup (value);
+
+ if (clock->format == CLOCK_FORMAT_CUSTOM)
+ refresh_clock (clock);
+}
+
+static void
+show_week_changed (MateConfClient *client,
+ guint cnxn_id,
+ MateConfEntry *entry,
+ ClockData *clock)
+{
+ gboolean value;
+
+ if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL)
+ return;
+
+ value = mateconf_value_get_bool (entry->value);
+
+ if (clock->showweek == (value != 0))
+ return;
+
+ clock->showweek = (value != 0);
+
+ if (clock->calendar_popup != NULL) {
+ calendar_window_set_show_weeks (CALENDAR_WINDOW (clock->calendar_popup), clock->showweek);
+ position_calendar_popup (clock);
+ }
+}
+
+static guint
+setup_mateconf_preference (ClockData *cd, MateConfClient *client, const char *key_name, MateConfClientNotifyFunc callback)
+{
+ char *key;
+ guint id;
+
+ key = mate_panel_applet_mateconf_get_full_key (MATE_PANEL_APPLET (cd->applet),
+ key_name);
+ id = mateconf_client_notify_add (client, key,
+ callback,
+ cd, NULL, NULL);
+ g_free (key);
+
+ return id;
+}
+
+static void
+setup_mateconf (ClockData *cd)
+{
+ struct {
+ const char *key_name;
+ MateConfClientNotifyFunc callback;
+ } prefs[] = {
+ { KEY_FORMAT, (MateConfClientNotifyFunc) format_changed },
+ { KEY_SHOW_SECONDS, (MateConfClientNotifyFunc) show_seconds_changed },
+ { KEY_SHOW_DATE, (MateConfClientNotifyFunc) show_date_changed },
+ { KEY_SHOW_WEATHER, (MateConfClientNotifyFunc) show_weather_changed },
+ { KEY_SHOW_TEMPERATURE, (MateConfClientNotifyFunc) show_temperature_changed },
+ { KEY_CUSTOM_FORMAT, (MateConfClientNotifyFunc) custom_format_changed },
+ { KEY_SHOW_WEEK, (MateConfClientNotifyFunc) show_week_changed },
+ { KEY_CITIES, (MateConfClientNotifyFunc) cities_changed },
+ { KEY_TEMPERATURE_UNIT, (MateConfClientNotifyFunc) temperature_unit_changed },
+ { KEY_SPEED_UNIT, (MateConfClientNotifyFunc) speed_unit_changed },
+ };
+
+ MateConfClient *client;
+ int i;
+
+ client = mateconf_client_get_default ();
+
+ for (i = 0; i < G_N_ELEMENTS (prefs); i++)
+ cd->listeners[i] = setup_mateconf_preference (cd, client, prefs[i].key_name, prefs[i].callback);
+
+ g_object_unref (G_OBJECT (client));
+}
+
+static GList *
+parse_mateconf_cities (ClockData *cd, GSList *values)
+{
+ GSList *cur = values;
+ LocationParserData data;
+ GMarkupParseContext *context;
+
+ data.cities = NULL;
+ data.cd = cd;
+
+ context =
+ g_markup_parse_context_new (&location_parser, 0, &data, NULL);
+
+ while (cur) {
+ const char *str = (char *)cur->data;
+ g_markup_parse_context_parse (context, str, strlen(str), NULL);
+
+ cur = cur->next;
+ }
+
+ g_markup_parse_context_free (context);
+
+ return data.cities;
+}
+
+static void
+load_mateconf_settings (ClockData *cd)
+{
+ MatePanelApplet *applet;
+ int format;
+ char *format_str;
+ char *value;
+ GError *error;
+ GSList *values = NULL;
+ GList *cities = NULL;
+
+ applet = MATE_PANEL_APPLET (cd->applet);
+
+ cd->format = CLOCK_FORMAT_INVALID;
+
+ format_str = mate_panel_applet_mateconf_get_string (applet, KEY_FORMAT, NULL);
+ if (format_str &&
+ mateconf_string_to_enum (format_type_enum_map, format_str, &format))
+ cd->format = format;
+ else
+ clock_migrate_to_26 (cd);
+
+ g_free (format_str);
+
+ if (cd->format == CLOCK_FORMAT_INVALID)
+ cd->format = clock_locale_format ();
+
+ cd->custom_format = mate_panel_applet_mateconf_get_string (applet, KEY_CUSTOM_FORMAT, NULL);
+ cd->showseconds = mate_panel_applet_mateconf_get_bool (applet, KEY_SHOW_SECONDS, NULL);
+
+ error = NULL;
+ cd->showdate = mate_panel_applet_mateconf_get_bool (applet, KEY_SHOW_DATE, &error);
+ if (error) {
+ g_error_free (error);
+ /* if on a small screen don't show date by default */
+ if (gdk_screen_width () <= 800)
+ cd->showdate = FALSE;
+ else
+ cd->showdate = TRUE;
+ }
+
+ cd->show_weather = mate_panel_applet_mateconf_get_bool (applet, KEY_SHOW_WEATHER, NULL);
+ cd->show_temperature = mate_panel_applet_mateconf_get_bool (applet, KEY_SHOW_TEMPERATURE, NULL);
+ cd->showweek = mate_panel_applet_mateconf_get_bool (applet, KEY_SHOW_WEEK, NULL);
+ cd->timeformat = NULL;
+
+ cd->can_handle_format_12 = (clock_locale_format () == CLOCK_FORMAT_12);
+ if (!cd->can_handle_format_12 && cd->format == CLOCK_FORMAT_12)
+ cd->format = CLOCK_FORMAT_24;
+
+ value = mate_panel_applet_mateconf_get_string (applet, KEY_TEMPERATURE_UNIT, NULL);
+ parse_and_set_temperature_string (value, cd);
+ g_free (value);
+
+ value = mate_panel_applet_mateconf_get_string (applet, KEY_SPEED_UNIT, NULL);
+ parse_and_set_speed_string (value, cd);
+ g_free (value);
+
+ values = mate_panel_applet_mateconf_get_list (MATE_PANEL_APPLET (cd->applet), KEY_CITIES,
+ MATECONF_VALUE_STRING, NULL);
+
+ if (g_slist_length (values) == 0) {
+ cities = NULL;
+ } else {
+ cities = parse_mateconf_cities (cd, values);
+ }
+
+ set_locations (cd, cities);
+}
+
+static gboolean
+fill_clock_applet (MatePanelApplet *applet)
+{
+ ClockData *cd;
+ GtkActionGroup *action_group;
+ GtkAction *action;
+ gchar *ui_path;
+ char *filename;
+ GError *error;
+
+ mate_panel_applet_add_preferences (applet, CLOCK_SCHEMA_DIR, NULL);
+ mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
+
+ cd = g_new0 (ClockData, 1);
+ cd->fixed_width = -1;
+ cd->fixed_height = -1;
+
+ cd->applet = GTK_WIDGET (applet);
+
+ setup_mateconf (cd);
+ load_mateconf_settings (cd);
+
+ cd->builder = gtk_builder_new ();
+ gtk_builder_set_translation_domain (cd->builder, GETTEXT_PACKAGE);
+ filename = g_build_filename (BUILDERDIR, "clock.ui", NULL);
+
+ error = NULL;
+ gtk_builder_add_from_file (cd->builder, filename, &error);
+ if (error) {
+ g_warning ("Error loading \"%s\": %s",
+ filename, error->message);
+ g_error_free (error);
+ }
+
+ g_free (filename);
+
+ create_clock_widget (cd);
+
+#ifndef CLOCK_INPROCESS
+ gtk_window_set_default_icon_name (CLOCK_ICON);
+#endif
+ gtk_widget_show (cd->applet);
+
+ /* FIXME: Update this comment. */
+ /* we have to bind change_orient before we do applet_widget_add
+ since we need to get an initial change_orient signal to set our
+ initial oriantation, and we get that during the _add call */
+ g_signal_connect (G_OBJECT (cd->applet),
+ "change_orient",
+ G_CALLBACK (applet_change_orient),
+ cd);
+
+ g_signal_connect (G_OBJECT (cd->panel_button),
+ "size_allocate",
+ G_CALLBACK (panel_button_change_pixel_size),
+ cd);
+
+ mate_panel_applet_set_background_widget (MATE_PANEL_APPLET (cd->applet),
+ GTK_WIDGET (cd->applet));
+
+ action_group = gtk_action_group_new ("ClockApplet Menu Actions");
+ gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+ gtk_action_group_add_actions (action_group,
+ clock_menu_actions,
+ G_N_ELEMENTS (clock_menu_actions),
+ cd);
+ ui_path = g_build_filename (CLOCK_MENU_UI_DIR, "clock-menu.xml", NULL);
+ mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (cd->applet),
+ ui_path, action_group);
+ g_free (ui_path);
+
+ if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (cd->applet))) {
+ action = gtk_action_group_get_action (action_group, "ClockPreferences");
+ gtk_action_set_visible (action, FALSE);
+
+ action = gtk_action_group_get_action (action_group, "ClockConfig");
+ gtk_action_set_visible (action, FALSE);
+ }
+
+ cd->systz = system_timezone_new ();
+ g_signal_connect (cd->systz, "changed",
+ G_CALLBACK (clock_timezone_changed), cd);
+
+ action = gtk_action_group_get_action (action_group, "ClockConfig");
+ gtk_action_set_visible (action, can_set_system_time ());
+ g_object_unref (action_group);
+
+ return TRUE;
+}
+
+/* FIXME old clock applet */
+#if 0
+static void
+setup_writability_sensitivity (ClockData *clock, GtkWidget *w, GtkWidget *label, const char *key)
+{
+ /* FMQ: was used from old preferences dialog; fix this up */
+ char *fullkey;
+ MateConfClient *client;
+
+ client = mateconf_client_get_default ();
+
+ fullkey = mate_panel_applet_mateconf_get_full_key
+ (MATE_PANEL_APPLET (clock->applet), key);
+
+ if ( ! mateconf_client_key_is_writable (client, fullkey, NULL)) {
+ g_object_set_data (G_OBJECT (w), NEVER_SENSITIVE,
+ GINT_TO_POINTER (1));
+ gtk_widget_set_sensitive (w, FALSE);
+ if (label != NULL) {
+ g_object_set_data (G_OBJECT (label), NEVER_SENSITIVE,
+ GINT_TO_POINTER (1));
+ gtk_widget_set_sensitive (label, FALSE);
+ }
+ }
+
+ g_free (fullkey);
+
+ g_object_unref (G_OBJECT (client));
+}
+
+static void
+update_properties_for_format (ClockData *cd,
+ GtkComboBox *combo,
+ ClockFormat format)
+{
+
+ /* show the custom format things the first time we actually
+ * have a custom format set in MateConf, but after that don't
+ * unshow it if the format changes
+ */
+ if (!cd->custom_format_shown &&
+ (cd->format == CLOCK_FORMAT_CUSTOM ||
+ (cd->custom_format && cd->custom_format [0]))) {
+ gtk_widget_show (cd->custom_hbox);
+ gtk_widget_show (cd->custom_label);
+ gtk_widget_show (cd->custom_entry);
+
+ gtk_combo_box_append_text (combo, _("Custom format"));
+
+ cd->custom_format_shown = TRUE;
+ }
+
+ /* Some combinations of options do not make sense */
+ switch (format) {
+ case CLOCK_FORMAT_12:
+ case CLOCK_FORMAT_24:
+ gtk_widget_set_sensitive (cd->showseconds_check, TRUE);
+ gtk_widget_set_sensitive (cd->showdate_check, TRUE);
+ gtk_widget_set_sensitive (cd->custom_entry, FALSE);
+ gtk_widget_set_sensitive (cd->custom_label, FALSE);
+ break;
+ case CLOCK_FORMAT_UNIX:
+ gtk_widget_set_sensitive (cd->showseconds_check, FALSE);
+ gtk_widget_set_sensitive (cd->showdate_check, FALSE);
+ gtk_widget_set_sensitive (cd->custom_entry, FALSE);
+ gtk_widget_set_sensitive (cd->custom_label, FALSE);
+ break;
+ case CLOCK_FORMAT_INTERNET:
+ gtk_widget_set_sensitive (cd->showseconds_check, TRUE);
+ gtk_widget_set_sensitive (cd->showdate_check, FALSE);
+ gtk_widget_set_sensitive (cd->custom_entry, FALSE);
+ gtk_widget_set_sensitive (cd->custom_label, FALSE);
+ break;
+ case CLOCK_FORMAT_CUSTOM:
+ gtk_widget_set_sensitive (cd->showseconds_check, FALSE);
+ gtk_widget_set_sensitive (cd->showdate_check, FALSE);
+ gtk_widget_set_sensitive (cd->custom_entry, TRUE);
+ gtk_widget_set_sensitive (cd->custom_label, TRUE);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+static void
+set_format_cb (GtkComboBox *combo,
+ ClockData *cd)
+{
+ /* FMQ: was used from old preferences dialog; fix this up */
+ ClockFormat format;
+
+ /* valid values begin from 1 */
+ if (cd->can_handle_format_12)
+ format = gtk_combo_box_get_active (combo) + 1;
+ else
+ format = gtk_combo_box_get_active (combo) + 2;
+
+ update_properties_for_format (cd, combo, format);
+
+ if (cd->format != format)
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (cd->applet),
+ KEY_FORMAT,
+ mateconf_enum_to_string (format_type_enum_map, format),
+ NULL);
+}
+#endif
+
+static void
+set_show_seconds_cb (GtkWidget *w,
+ ClockData *clock)
+{
+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (clock->applet),
+ KEY_SHOW_SECONDS,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)),
+ NULL);
+}
+
+static void
+set_show_date_cb (GtkWidget *w,
+ ClockData *clock)
+{
+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (clock->applet),
+ KEY_SHOW_DATE,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)),
+ NULL);
+}
+
+static void
+set_show_weather_cb (GtkWidget *w,
+ ClockData *clock)
+{
+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (clock->applet),
+ KEY_SHOW_WEATHER,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)),
+ NULL);
+}
+
+static void
+set_show_temperature_cb (GtkWidget *w,
+ ClockData *clock)
+{
+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (clock->applet),
+ KEY_SHOW_TEMPERATURE,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)),
+ NULL);
+}
+
+#if 0
+static void
+set_show_zones_cb (GtkWidget *w,
+ ClockData *clock)
+{
+ mate_panel_applet_mateconf_set_bool (MATE_PANEL_APPLET (clock->applet),
+ KEY_SHOW_ZONES,
+ GTK_TOGGLE_BUTTON (w)->active,
+ NULL);
+}
+#endif
+
+/* FIXME old clock applet */
+#if 0
+static void
+set_custom_format_cb (GtkEntry *entry,
+ ClockData *cd)
+{
+ /* FMQ: was used from old preferences dialog; fix this up */
+ const char *custom_format;
+
+ custom_format = gtk_entry_get_text (entry);
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (cd->applet),
+ KEY_CUSTOM_FORMAT, custom_format, NULL);
+}
+#endif
+
+static void
+prefs_locations_changed (GtkTreeSelection *selection, ClockData *cd)
+{
+ gint n;
+
+ n = gtk_tree_selection_count_selected_rows (selection);
+ gtk_widget_set_sensitive (cd->prefs_location_edit_button, n > 0);
+ gtk_widget_set_sensitive (cd->prefs_location_remove_button, n > 0);
+}
+
+static gchar *
+loc_to_string (ClockLocation *loc)
+{
+ const gchar *name, *city;
+ gfloat latitude, longitude;
+ gchar *ret;
+
+ name = clock_location_get_name (loc);
+ city = clock_location_get_city (loc);
+ clock_location_get_coords (loc, &latitude, &longitude);
+
+ setlocale (LC_NUMERIC, "POSIX");
+
+ ret = g_markup_printf_escaped
+ ("<location name=\"%s\" city=\"%s\" timezone=\"%s\" latitude=\"%f\" longitude=\"%f\" code=\"%s\" current=\"%s\"/>",
+ name ? name : "",
+ city ? city : "",
+ clock_location_get_timezone (loc),
+ latitude, longitude,
+ clock_location_get_weather_code (loc),
+ clock_location_is_current (loc) ? "true" : "false");
+
+ setlocale (LC_NUMERIC, "");
+
+ return ret;
+}
+
+static void
+save_cities_store (ClockData *cd)
+{
+ ClockLocation *loc;
+ GList *node = cd->locations;
+
+ GSList *root = NULL;
+ GSList *list = NULL;
+
+ while (node) {
+ loc = CLOCK_LOCATION (node->data);
+ list = g_slist_prepend (list, loc_to_string (loc));
+ node = node->next;
+ }
+
+ list = g_slist_reverse (list);
+ mate_panel_applet_mateconf_set_list (MATE_PANEL_APPLET (cd->applet),
+ KEY_CITIES, MATECONF_VALUE_STRING, list, NULL);
+
+ root = list;
+
+ while (list) {
+ g_free (list->data);
+ list = g_slist_next (list);
+ }
+
+ g_slist_free (root);
+}
+
+static void
+run_prefs_edit_save (GtkButton *button, ClockData *cd)
+{
+ GtkWidget *edit_window = _clock_get_widget (cd, "edit-location-window");
+
+ ClockLocation *loc = g_object_get_data (G_OBJECT (edit_window), "clock-location");
+
+ GtkWidget *lat_entry = _clock_get_widget (cd, "edit-location-latitude-entry");
+ GtkWidget *lon_entry = _clock_get_widget (cd, "edit-location-longitude-entry");
+ GtkWidget *lat_combo = _clock_get_widget (cd, "edit-location-latitude-combo");
+ GtkWidget *lon_combo = _clock_get_widget (cd, "edit-location-longitude-combo");
+
+ const gchar *timezone, *weather_code;
+ gchar *city, *name;
+
+ MateWeatherLocation *gloc;
+ gfloat lat = 0;
+ gfloat lon = 0;
+
+ timezone = mateweather_timezone_menu_get_tzid (cd->zone_combo);
+ if (!timezone) {
+ edit_hide (NULL, cd);
+ return;
+ }
+
+ city = NULL;
+ weather_code = NULL;
+ name = NULL;
+
+ gloc = mateweather_location_entry_get_location (cd->location_entry);
+ if (gloc) {
+ city = mateweather_location_get_city_name (gloc);
+ weather_code = mateweather_location_get_code (gloc);
+ }
+
+ if (mateweather_location_entry_has_custom_text (cd->location_entry)) {
+ name = gtk_editable_get_chars (GTK_EDITABLE (cd->location_entry), 0, -1);
+ }
+
+ sscanf (gtk_entry_get_text (GTK_ENTRY (lat_entry)), "%f", &lat);
+ sscanf (gtk_entry_get_text (GTK_ENTRY (lon_entry)), "%f", &lon);
+
+ if (gtk_combo_box_get_active (GTK_COMBO_BOX (lat_combo)) != 0) {
+ lat = -lat;
+ }
+
+ if (gtk_combo_box_get_active (GTK_COMBO_BOX (lon_combo)) != 0) {
+ lon = -lon;
+ }
+
+ if (loc) {
+ clock_location_set_timezone (loc, timezone);
+ clock_location_set_name (loc, name);
+ clock_location_set_city (loc, city);
+ clock_location_set_coords (loc, lat, lon);
+ clock_location_set_weather_code (loc, weather_code);
+ } else {
+ WeatherPrefs prefs;
+
+ prefs.temperature_unit = cd->temperature_unit;
+ prefs.speed_unit = cd->speed_unit;
+
+ loc = clock_location_new (name, city, timezone, lat, lon, weather_code, &prefs);
+ /* has the side-effect of setting the current location if
+ * there's none and this one can be considered as a current one
+ */
+ clock_location_is_current (loc);
+
+ cd->locations = g_list_append (cd->locations, loc);
+ }
+ g_free (name);
+ g_free (city);
+
+ /* This will update everything related to locations to take into
+ * account the new location (via the mateconf notification) */
+ save_cities_store (cd);
+
+ edit_hide (edit_window, cd);
+}
+
+static void
+update_coords_helper (gfloat value, GtkWidget *entry, GtkWidget *combo)
+{
+ gchar *tmp;
+
+ tmp = g_strdup_printf ("%f", fabsf (value));
+ gtk_entry_set_text (GTK_ENTRY (entry), tmp);
+ g_free (tmp);
+
+ if (value > 0) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
+ } else {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
+ }
+}
+
+static void
+update_coords (ClockData *cd, gboolean valid, gfloat lat, gfloat lon)
+{
+ GtkWidget *lat_entry = _clock_get_widget (cd, "edit-location-latitude-entry");
+ GtkWidget *lon_entry = _clock_get_widget (cd, "edit-location-longitude-entry");
+ GtkWidget *lat_combo = _clock_get_widget (cd, "edit-location-latitude-combo");
+ GtkWidget *lon_combo = _clock_get_widget (cd, "edit-location-longitude-combo");
+
+ if (!valid) {
+ gtk_entry_set_text (GTK_ENTRY (lat_entry), "");
+ gtk_entry_set_text (GTK_ENTRY (lon_entry), "");
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lat_combo), -1);
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lon_combo), -1);
+
+ return;
+ }
+
+ update_coords_helper (lat, lat_entry, lat_combo);
+ update_coords_helper (lon, lon_entry, lon_combo);
+}
+
+static void
+fill_timezone_combo_from_location (ClockData *cd, ClockLocation *loc)
+{
+ if (loc != NULL) {
+ mateweather_timezone_menu_set_tzid (cd->zone_combo,
+ clock_location_get_timezone (loc));
+ } else {
+ mateweather_timezone_menu_set_tzid (cd->zone_combo, NULL);
+ }
+}
+
+static void
+location_update_ok_sensitivity (ClockData *cd)
+{
+ GtkWidget *ok_button;
+ const gchar *timezone;
+ gchar *name;
+
+ ok_button = _clock_get_widget (cd, "edit-location-ok-button");
+
+ timezone = mateweather_timezone_menu_get_tzid (cd->zone_combo);
+ name = gtk_editable_get_chars (GTK_EDITABLE (cd->location_entry), 0, -1);
+
+ if (timezone && name && name[0] != '\0') {
+ gtk_widget_set_sensitive (ok_button, TRUE);
+ } else {
+ gtk_widget_set_sensitive (ok_button, FALSE);
+ }
+
+ g_free (name);
+}
+
+static void
+location_changed (GObject *object, GParamSpec *param, ClockData *cd)
+{
+ MateWeatherLocationEntry *entry = MATEWEATHER_LOCATION_ENTRY (object);
+ MateWeatherLocation *gloc;
+ MateWeatherTimezone *zone;
+ gboolean latlon_valid;
+ double latitude = 0.0, longitude = 0.0;
+
+ gloc = mateweather_location_entry_get_location (entry);
+
+ latlon_valid = gloc && mateweather_location_has_coords (gloc);
+ if (latlon_valid)
+ mateweather_location_get_coords (gloc, &latitude, &longitude);
+ update_coords (cd, latlon_valid, latitude, longitude);
+
+ zone = gloc ? mateweather_location_get_timezone (gloc) : NULL;
+ if (zone)
+ mateweather_timezone_menu_set_tzid (cd->zone_combo, mateweather_timezone_get_tzid (zone));
+ else
+ mateweather_timezone_menu_set_tzid (cd->zone_combo, NULL);
+
+ if (gloc)
+ mateweather_location_unref (gloc);
+}
+
+static void
+location_name_changed (GObject *object, ClockData *cd)
+{
+ location_update_ok_sensitivity (cd);
+}
+
+static void
+location_timezone_changed (GObject *object, GParamSpec *param, ClockData *cd)
+{
+ location_update_ok_sensitivity (cd);
+}
+
+static void
+edit_clear (ClockData *cd)
+{
+ GtkWidget *lat_entry = _clock_get_widget (cd, "edit-location-latitude-entry");
+ GtkWidget *lon_entry = _clock_get_widget (cd, "edit-location-longitude-entry");
+ GtkWidget *lat_combo = _clock_get_widget (cd, "edit-location-latitude-combo");
+ GtkWidget *lon_combo = _clock_get_widget (cd, "edit-location-longitude-combo");
+
+ /* clear out the old data */
+ mateweather_location_entry_set_location (cd->location_entry, NULL);
+ mateweather_timezone_menu_set_tzid (cd->zone_combo, NULL);
+
+ gtk_entry_set_text (GTK_ENTRY (lat_entry), "");
+ gtk_entry_set_text (GTK_ENTRY (lon_entry), "");
+
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lat_combo), -1);
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lon_combo), -1);
+}
+
+static void
+edit_hide (GtkWidget *unused, ClockData *cd)
+{
+ GtkWidget *edit_window = _clock_get_widget (cd, "edit-location-window");
+
+ gtk_widget_hide (edit_window);
+ edit_clear (cd);
+}
+
+static gboolean
+edit_delete (GtkWidget *unused, GdkEvent *event, ClockData *cd)
+{
+ edit_hide (unused, cd);
+
+ return TRUE;
+}
+
+static gboolean
+edit_hide_event (GtkWidget *widget, GdkEvent *event, ClockData *cd)
+{
+ edit_hide (widget, cd);
+
+ return TRUE;
+}
+
+static void
+prefs_hide (GtkWidget *widget, ClockData *cd)
+{
+ GtkWidget *tree;
+
+ edit_hide (widget, cd);
+
+ gtk_widget_hide (cd->prefs_window);
+
+ tree = _clock_get_widget (cd, "cities_list");
+
+ gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)));
+
+ refresh_click_timeout_time_only (cd);
+}
+
+static gboolean
+prefs_hide_event (GtkWidget *widget, GdkEvent *event, ClockData *cd)
+{
+ prefs_hide (widget, cd);
+
+ return TRUE;
+}
+
+static void
+prefs_help (GtkWidget *widget, ClockData *cd)
+{
+ clock_utils_display_help (cd->prefs_window,
+ "clock", "clock-settings");
+}
+
+static void
+remove_tree_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+ ClockData *cd = data;
+ ClockLocation *loc = NULL;
+
+ gtk_tree_model_get (model, iter, COL_CITY_LOC, &loc, -1);
+ cd->locations = g_list_remove (cd->locations, loc);
+ g_object_unref (loc);
+
+ /* This will update everything related to locations to take into
+ * account the removed location (via the mateconf notification) */
+ save_cities_store (cd);
+}
+
+static void
+run_prefs_locations_remove (GtkButton *button, ClockData *cd)
+{
+ GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (cd->prefs_locations));
+
+ gtk_tree_selection_selected_foreach (sel, remove_tree_row, cd);
+}
+
+static void
+run_prefs_locations_add (GtkButton *button, ClockData *cd)
+{
+ GtkWidget *edit_window = _clock_get_widget (cd, "edit-location-window");
+
+ fill_timezone_combo_from_location (cd, NULL);
+
+ g_object_set_data (G_OBJECT (edit_window), "clock-location", NULL);
+ gtk_window_set_title (GTK_WINDOW (edit_window), _("Choose Location"));
+ gtk_window_set_transient_for (GTK_WINDOW (edit_window), GTK_WINDOW (cd->prefs_window));
+
+ if (g_object_get_data (G_OBJECT (edit_window), "delete-handler") == NULL) {
+ g_object_set_data (G_OBJECT (edit_window), "delete-handler",
+ GINT_TO_POINTER (g_signal_connect (edit_window, "delete_event", G_CALLBACK (edit_delete), cd)));
+ }
+
+ location_update_ok_sensitivity (cd);
+
+ gtk_widget_grab_focus (GTK_WIDGET (cd->location_entry));
+ gtk_editable_set_position (GTK_EDITABLE (cd->location_entry), -1);
+
+ gtk_window_present_with_time (GTK_WINDOW (edit_window), gtk_get_current_event_time ());
+}
+
+static void
+edit_tree_row (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
+{
+ ClockData *cd = data;
+ ClockLocation *loc;
+ const char *name;
+ gchar *tmp;
+ gfloat lat, lon;
+
+ /* fill the dialog with this location's data, show it */
+ GtkWidget *edit_window = _clock_get_widget (cd, "edit-location-window");
+
+ GtkWidget *lat_entry = _clock_get_widget (cd, "edit-location-latitude-entry");
+
+ GtkWidget *lon_entry = _clock_get_widget (cd, "edit-location-longitude-entry");
+
+ GtkWidget *lat_combo = _clock_get_widget (cd, "edit-location-latitude-combo");
+
+ GtkWidget *lon_combo = _clock_get_widget (cd, "edit-location-longitude-combo");
+
+ edit_clear (cd);
+
+ gtk_tree_model_get (model, iter, COL_CITY_LOC, &loc, -1);
+
+ mateweather_location_entry_set_city (cd->location_entry,
+ clock_location_get_city (loc),
+ clock_location_get_weather_code (loc));
+ name = clock_location_get_name (loc);
+ if (name && name[0]) {
+ gtk_entry_set_text (GTK_ENTRY (cd->location_entry), name);
+ }
+
+ clock_location_get_coords (loc, &lat, &lon);
+
+ fill_timezone_combo_from_location (cd, loc);
+
+ tmp = g_strdup_printf ("%f", fabsf(lat));
+ gtk_entry_set_text (GTK_ENTRY (lat_entry), tmp);
+ g_free (tmp);
+
+ if (lat > 0) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lat_combo), 0);
+ } else {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lat_combo), 1);
+ }
+
+ tmp = g_strdup_printf ("%f", fabsf(lon));
+ gtk_entry_set_text (GTK_ENTRY (lon_entry), tmp);
+ g_free (tmp);
+
+ if (lon > 0) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lon_combo), 0);
+ } else {
+ gtk_combo_box_set_active (GTK_COMBO_BOX (lon_combo), 1);
+ }
+
+ location_update_ok_sensitivity (cd);
+
+ g_object_set_data (G_OBJECT (edit_window), "clock-location", loc);
+
+ gtk_widget_grab_focus (GTK_WIDGET (cd->location_entry));
+ gtk_editable_set_position (GTK_EDITABLE (cd->location_entry), -1);
+
+ gtk_window_set_title (GTK_WINDOW (edit_window), _("Edit Location"));
+ gtk_window_present (GTK_WINDOW (edit_window));
+}
+
+static void
+run_prefs_locations_edit (GtkButton *unused, ClockData *cd)
+{
+ GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (cd->prefs_locations));
+
+ gtk_tree_selection_selected_foreach (sel, edit_tree_row, cd);
+}
+
+static void
+set_12hr_format_radio_cb (GtkWidget *widget, ClockData *cd)
+{
+ const gchar *val;
+ ClockFormat format;
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+ format = CLOCK_FORMAT_12;
+ else
+ format = CLOCK_FORMAT_24;
+
+ val = mateconf_enum_to_string (format_type_enum_map, format);
+
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (cd->applet),
+ KEY_FORMAT, val, NULL);
+}
+
+static void
+temperature_combo_changed (GtkComboBox *combo, ClockData *cd)
+{
+ int value;
+ int old_value;
+ const gchar *str;
+
+ value = gtk_combo_box_get_active (combo) + 1;
+
+ if (cd->use_temperature_default)
+ old_value = TEMP_UNIT_DEFAULT;
+ else
+ old_value = cd->temperature_unit;
+
+ if (value == old_value)
+ return;
+
+ str = mateweather_prefs_temp_enum_to_string (value);
+
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (cd->applet),
+ KEY_TEMPERATURE_UNIT, str, NULL);
+}
+
+static void
+speed_combo_changed (GtkComboBox *combo, ClockData *cd)
+{
+ int value;
+ int old_value;
+ const gchar *str;
+
+ value = gtk_combo_box_get_active (combo) + 1;
+
+ if (cd->use_speed_default)
+ old_value = SPEED_UNIT_DEFAULT;
+ else
+ old_value = cd->speed_unit;
+
+ if (value == old_value)
+ return;
+
+ str = mateweather_prefs_speed_enum_to_string (value);
+
+ mate_panel_applet_mateconf_set_string (MATE_PANEL_APPLET (cd->applet),
+ KEY_SPEED_UNIT, str, NULL);
+}
+
+static void
+fill_prefs_window (ClockData *cd)
+{
+ static const int temperatures[] = {
+ TEMP_UNIT_DEFAULT,
+ TEMP_UNIT_KELVIN,
+ TEMP_UNIT_CENTIGRADE,
+ TEMP_UNIT_FAHRENHEIT,
+ -1
+ };
+
+ static const int speeds[] = {
+ SPEED_UNIT_DEFAULT,
+ SPEED_UNIT_MS,
+ SPEED_UNIT_KPH,
+ SPEED_UNIT_MPH,
+ SPEED_UNIT_KNOTS,
+ SPEED_UNIT_BFT,
+ -1
+ };
+
+ GtkWidget *radio_12hr;
+ GtkWidget *radio_24hr;
+ GtkWidget *widget;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *col;
+ GtkListStore *store;
+ int i;
+
+ /* Set the 12 hour / 24 hour widget */
+ radio_12hr = _clock_get_widget (cd, "12hr_radio");
+ radio_24hr = _clock_get_widget (cd, "24hr_radio");
+
+ if (cd->format == CLOCK_FORMAT_12)
+ widget = radio_12hr;
+ else
+ widget = radio_24hr;
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
+
+ g_signal_connect (radio_12hr, "toggled",
+ G_CALLBACK (set_12hr_format_radio_cb), cd);
+
+ /* Set the "Show Date" checkbox */
+ widget = _clock_get_widget (cd, "date_check");
+ g_signal_connect (widget, "toggled",
+ G_CALLBACK (set_show_date_cb), cd);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), cd->showdate);
+
+ /* Set the "Show Seconds" checkbox */
+ widget = _clock_get_widget (cd, "seconds_check");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), cd->showseconds);
+ g_signal_connect (widget, "toggled",
+ G_CALLBACK (set_show_seconds_cb), cd);
+
+ /* Set the "Show weather" checkbox */
+ widget = _clock_get_widget (cd, "weather_check");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), cd->show_weather);
+ g_signal_connect (widget, "toggled",
+ G_CALLBACK (set_show_weather_cb), cd);
+
+ /* Set the "Show temperature" checkbox */
+ widget = _clock_get_widget (cd, "temperature_check");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), cd->show_temperature);
+ g_signal_connect (widget, "toggled",
+ G_CALLBACK (set_show_temperature_cb), cd);
+
+ /* Fill the Cities list */
+ widget = _clock_get_widget (cd, "cities_list");
+
+ renderer = gtk_cell_renderer_text_new ();
+ col = gtk_tree_view_column_new_with_attributes (_("City Name"), renderer, "text", COL_CITY_NAME, NULL);
+ gtk_tree_view_insert_column (GTK_TREE_VIEW (widget), col, -1);
+
+ renderer = gtk_cell_renderer_text_new ();
+ col = gtk_tree_view_column_new_with_attributes (_("City Time Zone"), renderer, "text", COL_CITY_TZ, NULL);
+ gtk_tree_view_insert_column (GTK_TREE_VIEW (widget), col, -1);
+
+ if (cd->cities_store == NULL)
+ create_cities_store (cd);
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
+ GTK_TREE_MODEL (cd->cities_store));
+
+ /* Temperature combo */
+ widget = _clock_get_widget (cd, "temperature_combo");
+ store = gtk_list_store_new (1, G_TYPE_STRING);
+ gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
+ renderer = gtk_cell_renderer_text_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (widget), renderer, "text", 0, NULL);
+
+ for (i = 0; temperatures[i] != -1; i++)
+ gtk_combo_box_append_text (GTK_COMBO_BOX (widget),
+ mateweather_prefs_get_temp_display_name (temperatures[i]));
+
+ update_temperature_combo (cd);
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (temperature_combo_changed), cd);
+
+ /* Wind speed combo */
+ widget = _clock_get_widget (cd, "wind_speed_combo");
+ store = gtk_list_store_new (1, G_TYPE_STRING);
+ gtk_combo_box_set_model (GTK_COMBO_BOX (widget), GTK_TREE_MODEL (store));
+ renderer = gtk_cell_renderer_text_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (widget), renderer, "text", 0, NULL);
+
+ for (i = 0; speeds[i] != -1; i++)
+ gtk_combo_box_append_text (GTK_COMBO_BOX (widget),
+ mateweather_prefs_get_speed_display_name (speeds[i]));
+
+ update_speed_combo (cd);
+ g_signal_connect (widget, "changed",
+ G_CALLBACK (speed_combo_changed), cd);
+}
+
+static void
+ensure_prefs_window_is_created (ClockData *cd)
+{
+ GtkWidget *edit_window;
+ GtkWidget *prefs_close_button;
+ GtkWidget *prefs_help_button;
+ GtkWidget *clock_options;
+ GtkWidget *edit_cancel_button;
+ GtkWidget *edit_ok_button;
+ GtkWidget *location_box;
+ GtkWidget *zone_box;
+ GtkWidget *location_name_label;
+ GtkWidget *timezone_label;
+ GtkTreeSelection *selection;
+ MateWeatherLocation *world;
+
+ if (cd->prefs_window)
+ return;
+
+ cd->prefs_window = _clock_get_widget (cd, "prefs-window");
+
+ gtk_window_set_icon_name (GTK_WINDOW (cd->prefs_window), CLOCK_ICON);
+
+ prefs_close_button = _clock_get_widget (cd, "prefs-close-button");
+ prefs_help_button = _clock_get_widget (cd, "prefs-help-button");
+ clock_options = _clock_get_widget (cd, "clock-options");
+ cd->prefs_locations = GTK_TREE_VIEW (_clock_get_widget (cd, "cities_list"));
+ location_name_label = _clock_get_widget (cd, "location-name-label");
+ timezone_label = _clock_get_widget (cd, "timezone-label");
+
+
+ if (!clock_locale_supports_am_pm ())
+ gtk_widget_hide (clock_options);
+
+ selection = gtk_tree_view_get_selection (cd->prefs_locations);
+ g_signal_connect (G_OBJECT (selection), "changed",
+ G_CALLBACK (prefs_locations_changed), cd);
+
+ g_signal_connect (G_OBJECT (cd->prefs_window), "delete_event",
+ G_CALLBACK (prefs_hide_event), cd);
+
+ g_signal_connect (G_OBJECT (prefs_close_button), "clicked",
+ G_CALLBACK (prefs_hide), cd);
+
+ g_signal_connect (G_OBJECT (prefs_help_button), "clicked",
+ G_CALLBACK (prefs_help), cd);
+
+ cd->prefs_location_remove_button = _clock_get_widget (cd, "prefs-locations-remove-button");
+
+ g_signal_connect (G_OBJECT (cd->prefs_location_remove_button), "clicked",
+ G_CALLBACK (run_prefs_locations_remove), cd);
+
+ cd->prefs_location_add_button = _clock_get_widget (cd, "prefs-locations-add-button");
+
+ g_signal_connect (G_OBJECT (cd->prefs_location_add_button), "clicked",
+ G_CALLBACK (run_prefs_locations_add), cd);
+
+ cd->prefs_location_edit_button = _clock_get_widget (cd, "prefs-locations-edit-button");
+
+ g_signal_connect (G_OBJECT (cd->prefs_location_edit_button), "clicked",
+ G_CALLBACK (run_prefs_locations_edit), cd);
+
+ edit_window = _clock_get_widget (cd, "edit-location-window");
+
+ gtk_window_set_transient_for (GTK_WINDOW (edit_window),
+ GTK_WINDOW (cd->prefs_window));
+
+ g_signal_connect (G_OBJECT (edit_window), "delete_event",
+ G_CALLBACK (edit_hide_event), cd);
+
+ edit_cancel_button = _clock_get_widget (cd, "edit-location-cancel-button");
+
+ edit_ok_button = _clock_get_widget (cd, "edit-location-ok-button");
+
+ world = mateweather_location_new_world (FALSE);
+
+ location_box = _clock_get_widget (cd, "edit-location-name-box");
+ cd->location_entry = MATEWEATHER_LOCATION_ENTRY (mateweather_location_entry_new (world));
+ gtk_widget_show (GTK_WIDGET (cd->location_entry));
+ gtk_container_add (GTK_CONTAINER (location_box), GTK_WIDGET (cd->location_entry));
+ gtk_label_set_mnemonic_widget (GTK_LABEL (location_name_label),
+ GTK_WIDGET (cd->location_entry));
+
+ g_signal_connect (G_OBJECT (cd->location_entry), "notify::location",
+ G_CALLBACK (location_changed), cd);
+ g_signal_connect (G_OBJECT (cd->location_entry), "changed",
+ G_CALLBACK (location_name_changed), cd);
+
+ zone_box = _clock_get_widget (cd, "edit-location-timezone-box");
+ cd->zone_combo = MATEWEATHER_TIMEZONE_MENU (mateweather_timezone_menu_new (world));
+ gtk_widget_show (GTK_WIDGET (cd->zone_combo));
+ gtk_container_add (GTK_CONTAINER (zone_box), GTK_WIDGET (cd->zone_combo));
+ gtk_label_set_mnemonic_widget (GTK_LABEL (timezone_label),
+ GTK_WIDGET (cd->zone_combo));
+
+ g_signal_connect (G_OBJECT (cd->zone_combo), "notify::tzid",
+ G_CALLBACK (location_timezone_changed), cd);
+
+ mateweather_location_unref (world);
+
+ g_signal_connect (G_OBJECT (edit_cancel_button), "clicked",
+ G_CALLBACK (edit_hide), cd);
+
+ g_signal_connect (G_OBJECT (edit_ok_button), "clicked",
+ G_CALLBACK (run_prefs_edit_save), cd);
+
+ /* Set up the time setting section */
+
+ cd->time_settings_button = _clock_get_widget (cd, "time-settings-button");
+ g_signal_connect (cd->time_settings_button, "clicked",
+ G_CALLBACK (run_time_settings), cd);
+
+ /* fill it with the current preferences */
+ fill_prefs_window (cd);
+}
+
+static void
+display_properties_dialog (ClockData *cd, gboolean start_in_locations_page)
+{
+ ensure_prefs_window_is_created (cd);
+
+ if (start_in_locations_page) {
+ GtkWidget *notebook = _clock_get_widget (cd, "notebook");
+ gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 1);
+ }
+
+ update_set_time_button (cd);
+
+ gtk_window_set_screen (GTK_WINDOW (cd->prefs_window),
+ gtk_widget_get_screen (cd->applet));
+ gtk_window_present (GTK_WINDOW (cd->prefs_window));
+
+ refresh_click_timeout_time_only (cd);
+
+ /* FMQ: cd->props was the old preferences window; remove references to it */
+ /* FMQ: connect to the Help button by hand; look at properties_response_cb() for the help code */
+#if 0
+ /* FMQ: check the code below; replace the proper parts */
+ GtkWidget *hbox;
+ GtkWidget *vbox;
+ GtkWidget *combo;
+ GtkWidget *label;
+
+ gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("24 hour"));
+ gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("UNIX time"));
+ gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Internet time"));
+
+ gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
+ gtk_widget_show (combo);
+
+ cd->custom_hbox = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox), cd->custom_hbox, TRUE, TRUE, 0);
+
+ cd->custom_label = gtk_label_new_with_mnemonic (_("Custom _format:"));
+ gtk_label_set_use_markup (GTK_LABEL (cd->custom_label), TRUE);
+ gtk_label_set_justify (GTK_LABEL (cd->custom_label),
+ GTK_JUSTIFY_LEFT);
+ gtk_misc_set_alignment (GTK_MISC (cd->custom_label), 0, 0.5);
+ gtk_box_pack_start (GTK_BOX (cd->custom_hbox),
+ cd->custom_label,
+ FALSE, FALSE, 0);
+
+ cd->custom_entry = gtk_entry_new ();
+ gtk_box_pack_start (GTK_BOX (cd->custom_hbox),
+ cd->custom_entry,
+ FALSE, FALSE, 0);
+ gtk_entry_set_text (GTK_ENTRY (cd->custom_entry),
+ cd->custom_format);
+ g_signal_connect (cd->custom_entry, "changed",
+ G_CALLBACK (set_custom_format_cb),
+ cd);
+
+ g_signal_connect (cd->props, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &cd->props);
+ g_signal_connect (cd->props, "response",
+ G_CALLBACK (properties_response_cb),
+ cd);
+
+ cd->custom_format_shown = FALSE;
+ update_properties_for_format (cd, GTK_COMBO_BOX (combo), cd->format);
+
+ /* valid values begin from 1 */
+ if (cd->can_handle_format_12)
+ gtk_combo_box_set_active (GTK_COMBO_BOX (combo),
+ cd->format - 1);
+ else
+ gtk_combo_box_set_active (GTK_COMBO_BOX (combo),
+ cd->format - 2);
+
+ g_signal_connect (combo, "changed",
+ G_CALLBACK (set_format_cb), cd);
+
+ /* Now set up the sensitivity based on mateconf key writability */
+ setup_writability_sensitivity (cd, combo, label, KEY_FORMAT);
+ setup_writability_sensitivity (cd, cd->custom_entry, cd->custom_label,
+ KEY_CUSTOM_FORMAT);
+ setup_writability_sensitivity (cd, cd->showseconds_check, NULL, KEY_SHOW_SECONDS);
+ setup_writability_sensitivity (cd, cd->showdate_check, NULL, KEY_SHOW_DATE);
+
+ gtk_widget_show (cd->props);
+#endif
+}
+
+static void
+verb_display_properties_dialog (GtkAction *action,
+ ClockData *cd)
+{
+ display_properties_dialog (cd, FALSE);
+}
+
+static void
+display_help_dialog (GtkAction *action,
+ ClockData *cd)
+{
+ clock_utils_display_help (cd->applet, "clock", NULL);
+}
+
+static void display_about_dialog(GtkAction* action, ClockData* cd)
+{
+ static const gchar* authors[] = {
+ "George Lebl <[email protected]>",
+ "Gediminas Paulauskas <[email protected]>",
+ NULL
+ };
+
+ static const char* documenters[] = {
+ "Dan Mueth <[email protected]>",
+ NULL
+ };
+
+ char copyright[] = \
+ "Copyright \xc2\xa9 1998-2004 Free Software Foundation, Inc.";
+
+ gtk_show_about_dialog(NULL,
+ "program-name", _("Clock"),
+ "authors", authors,
+ "comments", _("The Clock displays the current time and date"),
+ "copyright", copyright,
+ "documenters", documenters,
+ "logo-icon-name", CLOCK_ICON,
+ "translator-credits", _("translator-credits"),
+ "version", VERSION,
+ "website", "http://matsusoft.com.ar/projects/mate/",
+ NULL);
+}
+
+static gboolean
+clock_factory (MatePanelApplet *applet,
+ const char *iid,
+ gpointer data)
+{
+ gboolean retval = FALSE;
+
+ if (!strcmp (iid, "ClockApplet"))
+ retval = fill_clock_applet (applet);
+
+ return retval;
+}
+
+#ifdef CLOCK_INPROCESS
+MATE_PANEL_APPLET_IN_PROCESS_FACTORY ("ClockAppletFactory",
+ PANEL_TYPE_APPLET,
+ "ClockApplet",
+ clock_factory,
+ NULL)
+#else
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("ClockAppletFactory",
+ PANEL_TYPE_APPLET,
+ "ClockApplet",
+ clock_factory,
+ NULL)
+#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-02 07:46:03 +0000