+ -DGWEATHER_I_KNOW_THIS_IS_UNSTABLE

+static void clock_location_tile_dispose (GObject *g_obj);

+static void update_weather_icon (ClockLocation *loc, GWeatherInfo *info, gpointer data);

+ g_obj_class->dispose = clock_location_tile_dispose;

+ //g_obj_class->finalize = clock_location_tile_finalize;

+clock_location_tile_dispose (GObject *g_obj)

+{

+ ClockLocationTile *this;

+ ClockLocationTilePrivate *priv;

+

+ this = CLOCK_LOCATION_TILE (g_obj);

+ priv = clock_location_tile_get_instance_private (this);

+

+ if (priv->location) {

+ if (priv->location_weather_updated_id > 0)

+ g_signal_handler_disconnect (priv->location, priv->location_weather_updated_id);

+ priv->location_weather_updated_id = 0;

+

+ g_object_unref (priv->location);

+ priv->location = NULL;

+ }

+

+ if (priv->button_group) {

+ g_object_unref (priv->button_group);

+ priv->button_group = NULL;

+ }

+

+ if (priv->current_group) {

+ g_object_unref (priv->current_group);

+ priv->current_group = NULL;

+ }

+

+ G_OBJECT_CLASS (clock_location_tile_parent_class)->dispose (g_obj);

+}

+

+static void

+ if (priv->location_weather_updated_id > 0)

+ g_signal_handler_disconnect (priv->location, priv->location_weather_updated_id);

+ const char *tzname,

+ long hours;

+ hours = offset / 60;

+ if (hours != 0) {

+ gchar *tmp;

+ const gchar *tzname;

+ if (tzname == NULL) {

+ tzname = clock_location_get_tzid (priv->location);

+ }

+ if (priv->location == NULL) {

+ return;

+ }

+ tmp = format_time (&now, tzname, format, priv->last_offset);

+weather_info_setup_tooltip (GWeatherInfo *info, ClockLocation *location, GtkTooltip *tooltip,

+ gchar *line1, *line2, *line3, *line4, *line5, *tip;

+ icon_name = gweather_info_get_icon_name (info);

+ conditions = gweather_info_get_conditions (info);

+ gweather_info_get_sky (info));

+ line1 = g_strdup (gweather_info_get_weather_summary (info));

+ temp = g_strdup (gweather_info_get_temp (info));

+ apparent = g_strdup (gweather_info_get_apparent (info));

+ wind = gweather_info_get_wind (info);

+ setenv ("TZ", clock_location_get_tzid (location), 1);

+ if (gweather_info_get_value_sunrise (info, &sunrise_time))

+ if (gweather_info_get_value_sunset (info, &sunset_time))

+ line5 = g_strdup_printf ("%s %s", gweather_info_get_visibility(info),

+ gweather_info_get_pressure(info));

+

+ tip = g_strdup_printf ("<b>%s</b>\n%s\n%s\n%s%s", line1, line2, line5, line3, line4);

+ g_free (line5);

+ GWeatherInfo *info;

+ if (!info || !gweather_info_is_valid (info))

+update_weather_icon (ClockLocation *loc, GWeatherInfo *info, gpointer data)

+ if (!info || !gweather_info_is_valid (info))

+ icon_name = gweather_info_get_icon_name (info);

+void weather_info_setup_tooltip (GWeatherInfo *info, ClockLocation *location, GtkTooltip *tip,

+enum {

+ PROP_0,

+ PROP_LOCATION,

+ NUM_PROPERTIES

+};

+

+enum {

+ WEATHER_UPDATED,

+ SET_CURRENT,

+ LAST_SIGNAL

+};

+

+ SystemTimezone *systz;

+ GWeatherLocation *glocation;

+ GWeatherInfo *gweather_info;

+ gulong network_id;

+ gulong weather_id;

+} ClockLocationPrivate;

+static ClockLocation *current_location = NULL;

+static guint location_signals[LAST_SIGNAL];

+G_DEFINE_TYPE_WITH_PRIVATE (ClockLocation, clock_location, G_TYPE_OBJECT)

+static void clock_location_dispose (GObject *object);

+static void clock_location_finalize (GObject *);

+static void clock_location_set_tz (ClockLocation *this);

+static void clock_location_unset_tz (ClockLocation *this);

+static void weather_info_updated (GWeatherInfo *info, gpointer data);

+static void clock_location_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);

+static void clock_location_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);

+static gint clock_location_compare (ClockLocation *one, ClockLocation *two)

+{

+ g_return_val_if_fail (CLOCK_IS_LOCATION(one), FALSE);

+ g_return_val_if_fail (CLOCK_IS_LOCATION(two), FALSE);

+ ClockLocationPrivate *priv_one;

+ ClockLocationPrivate *priv_two;

+ priv_one = clock_location_get_instance_private (one);

+ priv_two = clock_location_get_instance_private (two);

+ if (gweather_location_equal (priv_one->glocation, priv_two->glocation)) {

+ return 0;

+ }

+ return -1;

+}

+gboolean clock_location_equal (ClockLocation *one, ClockLocation *two)

+{

+ if (clock_location_compare (one, two) == 0)

+ return TRUE;

+ else

+ return FALSE;

+}

+gboolean clock_locations_has_location (GList *list, ClockLocation *loc)

+{

+ GList *found = NULL;

+ found = g_list_find_custom (list, loc, clock_location_compare);

+ if (found) {

+ return TRUE;

+ } else {

+ return FALSE;

+ }

+}

+GList* clock_locations_append (GList *locations, ClockLocation *loc)

+{

+ if (!clock_locations_has_location (locations, loc)) {

+ locations = g_list_append(locations, loc);

+ }

+ return locations;

+}

+

+GList* clock_locations_merge (GList *old, GList *new)

+{

+ GList *l, *result = NULL;

+

+ for (l = old; l != NULL; l = l->next) {

+ if (clock_locations_has_location (new, l->data)) {

+ result = g_list_append (result, g_object_ref (l->data));

+ }

+ g_list_free_full (old, g_object_unref);

+ for (l = new; l != NULL; l = l->next) {

+ result = clock_locations_append (result, l->data);

+ }

+ return result;

+}

+

+ClockLocation *clock_location_new (GWeatherLocation *gloc)

+{

+ return g_object_new (CLOCK_TYPE_LOCATION, "location", gloc, NULL);

+}

+

+GVariant* clock_location_serialize (ClockLocation *loc)

+{

+ g_return_val_if_fail (CLOCK_IS_LOCATION(loc), NULL);

+ GVariant *value;

+ ClockLocationPrivate *priv;

+

+ priv = clock_location_get_instance_private (loc);

+

+ if (clock_location_is_current(loc)) {

+ value = g_variant_new ("(bv)", TRUE, gweather_location_serialize (priv->glocation));

+ } else {

+ if (priv->glocation != NULL) {

+ value = g_variant_new ("(bv)", FALSE, gweather_location_serialize (priv->glocation));

+ }

+ }

+

+ return value;

+ClockLocation* clock_location_deserialize (GVariant *serialized)

+ gboolean current;

+ GVariant *value;

+ GWeatherLocation *world, *gloc;

+ ClockLocation *location;

+ g_variant_get (serialized, "(bv)", &current, &value);

+ world = gweather_location_get_world ();

+ gloc = gweather_location_deserialize (world, value);

+ location = clock_location_new(gloc);

+ return location;

+}

+static void clock_location_set_gweather (ClockLocation *self, GWeatherLocation *loc)

+{

+ ClockLocationPrivate *priv;

+ priv = clock_location_get_instance_private (self);

+ if (priv->glocation != NULL && gweather_location_equal (priv->glocation, loc))

+ return;

+

+ if (priv->weather_id != 0) {

+ g_signal_handler_disconnect (priv->gweather_info, priv->weather_id);

+ priv->weather_id = 0;

+ }

+ if (priv->glocation != NULL) {

+ gweather_location_unref (priv->glocation);

+ priv->glocation = NULL;

+ }

+ if (priv->gweather_info != NULL) {

+ gweather_info_abort (priv->gweather_info);

+ g_object_unref (priv->gweather_info);

+ priv->gweather_info = NULL;

+ }

+ priv->glocation = gweather_location_ref (loc);

+ GWeatherProvider providers = GWEATHER_PROVIDER_METAR

+ | GWEATHER_PROVIDER_YAHOO

+ | GWEATHER_PROVIDER_YR_NO;

+ priv->gweather_info = g_object_new (GWEATHER_TYPE_INFO, "location", priv->glocation, "enabled-providers", providers, NULL);

+ priv->weather_id = g_signal_connect (priv->gweather_info, "updated", G_CALLBACK (weather_info_updated), self);

+static void clock_location_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)

+{

+ ClockLocation *self;

+

+ self = CLOCK_LOCATION (object);

+

+ switch (prop_id)

+ {

+ case PROP_LOCATION:

+ clock_location_set_gweather (self, g_value_get_boxed (value));

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+

+static void clock_location_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)

+{

+ ClockLocation *location;

+ ClockLocationPrivate *priv;

+

+ location = CLOCK_LOCATION (object);

+ priv = clock_location_get_instance_private (location);

+

+ switch (prop_id)

+ {

+ case PROP_LOCATION:

+ g_value_set_object (value, priv->glocation);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+ g_obj_class->dispose = clock_location_dispose;

+ g_obj_class->set_property = clock_location_set_property;

+ g_obj_class->get_property = clock_location_get_property;

+

+ g_object_class_install_property (g_obj_class,

+ PROP_LOCATION,

+ g_param_spec_boxed ("location",

+ NULL,

+ NULL,

+ GWEATHER_TYPE_LOCATION,

+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

+ g_cclosure_marshal_VOID__OBJECT,

+ G_TYPE_NONE, 1, G_TYPE_OBJECT);

+void clock_location_update_weather (ClockLocation *loc)

+{

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+

+ if (priv->gweather_info)

+ gweather_info_update (priv->gweather_info);

+}

+

+ gweather_info_update (priv->gweather_info);

+ ClockLocationPrivate *priv = clock_location_get_instance_private (this);

+ GNetworkMonitor *monitor;

+ priv->systz = system_timezone_new ();

+ priv->glocation = NULL;

+ priv->gweather_info = NULL;

+ priv->weather_id = 0;

+ monitor = g_network_monitor_get_default();

+ priv->network_id = g_signal_connect (monitor, "network-changed",

+ G_CALLBACK (network_changed), this);

+}

+static void clock_location_dispose (GObject *object)

+{

+ ClockLocation *loc;

+ ClockLocationPrivate *priv;

+ loc = CLOCK_LOCATION (object);

+ priv = clock_location_get_instance_private (loc);

+ if (priv->weather_id != 0) {

+ g_signal_handler_disconnect (priv->gweather_info, priv->weather_id);

+ priv->weather_id = 0;

+ }

+ if (priv->systz != NULL) {

+ g_object_unref (priv->systz);

+ priv->systz = NULL;

+ }

+ if (priv->glocation != NULL) {

+ gweather_location_unref (priv->glocation);

+ priv->glocation = NULL;

+ }

+ if (priv->gweather_info != NULL) {

+ g_object_unref (priv->gweather_info);

+ priv->gweather_info = NULL;

+ }

+ G_OBJECT_CLASS (clock_location_parent_class)->dispose (object);

+ return gweather_location_get_name (priv->glocation);

+ return clock_location_get_display_name (loc);

+const gchar *

+clock_location_get_sort_name (ClockLocation *loc)

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ return gweather_location_get_sort_name (priv->glocation);

+ return gweather_location_get_city_name (priv->glocation);

+const gchar *

+clock_location_get_tzname (ClockLocation *loc)

+ ClockLocationPrivate *priv;

+ GWeatherTimezone *zone;

+ const gchar *name;

+ priv = clock_location_get_instance_private (loc);

+ zone = gweather_location_get_timezone (priv->glocation);

+ name = gweather_timezone_get_name (zone);

+ if (name != NULL) {

+ return name;

+ } else {

+ return gweather_timezone_get_tzid (zone);

+ }

+const gchar *

+clock_location_get_tzid (ClockLocation *loc)

+ ClockLocationPrivate *priv;

+ GWeatherTimezone *zone;

+ priv = clock_location_get_instance_private (loc);

+ zone = gweather_location_get_timezone (priv->glocation);

+ return gweather_timezone_get_tzid (zone);

+ double lat, lon;

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ gweather_location_get_coords (priv->glocation, &lat, &lon);

+ *latitude = (gfloat)lat;

+ *longitude = (gfloat)lon;

+ return;

+ g_return_if_fail (CLOCK_IS_LOCATION(this));

+ const gchar* zone;

+ zone = clock_location_get_tzid (this);

+ if (zone != NULL) {

+ setenv ("TZ", zone, 1);

+ tzset();

+ now_t = time (NULL);

+ localtime_r (&now_t, &now);

+ g_return_val_if_fail (CLOCK_IS_LOCATION(loc), FALSE);

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ const char *zone, *tzid;

+ zone = system_timezone_get (priv->systz);

+ tzid = clock_location_get_tzid (loc);

+ if (zone && tzid != NULL) {

+ return strcmp (zone, tzid) == 0;

+ } else {

+ return clock_location_get_offset (loc) == 0;

+ }

+ if (current_location == loc) {

+ } else if (current_location != NULL) {

+ }

+gint

+ GWeatherTimezone *zone;

+ zone = gweather_location_get_timezone (priv->glocation);

+ if (zone != NULL) {

+ return gweather_timezone_get_offset (zone);

+ } else {

+ return 0;

+ filename = g_build_filename (SYSTEM_ZONEINFODIR, clock_location_get_tzid (loc), NULL);

+GWeatherInfo *

+ g_return_val_if_fail (CLOCK_IS_LOCATION(loc), NULL);

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ return g_object_ref (priv->gweather_info);

+GWeatherLocation* clock_location_get_glocation (ClockLocation *loc)

+ g_return_val_if_fail (CLOCK_IS_LOCATION(loc), NULL);

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ return gweather_location_ref(priv->glocation);

+weather_info_updated (GWeatherInfo *info, gpointer data)

+ g_return_if_fail (GWEATHER_IS_INFO(info));

+ ClockLocation *loc = data;

+ g_return_if_fail (CLOCK_IS_LOCATION(loc));

+ ClockLocationPrivate *priv = clock_location_get_instance_private (loc);

+ if (gweather_info_network_error (priv->gweather_info))

+ return;

+ if (priv->gweather_info) {

+ g_signal_emit (loc, location_signals[WEATHER_UPDATED], 0, priv->gweather_info);

+ }

+#include <libgweather/gweather.h>

+#include "clock-utils.h"

+G_BEGIN_DECLS

+#define CLOCK_TYPE_LOCATION (clock_location_get_type ())

+G_DECLARE_DERIVABLE_TYPE (ClockLocation, clock_location, CLOCK, LOCATION, GObject)

+struct _ClockLocationClass

+ GObjectClass parent_class;

+ void (* weather_updated) (ClockLocation *location, GWeatherInfo *info);

+ void (* set_current) (ClockLocation *location);

+};

+

+GList* clock_locations_append (GList *locations, ClockLocation *loc);

+GList* clock_locations_merge (GList *old, GList *new);

+gboolean clock_locations_has_location (GList *locations, ClockLocation *loc);

+

+ClockLocation* clock_location_new (GWeatherLocation *gloc);

+GVariant* clock_location_serialize (ClockLocation *loc);

+ClockLocation* clock_location_deserialize (GVariant *serialized);

+gboolean clock_location_equal (ClockLocation *one, ClockLocation *two);

+

+const gchar* clock_location_get_tzname (ClockLocation *loc);

+const gchar* clock_location_get_tzid (ClockLocation *loc);

+

+const gchar* clock_location_get_display_name (ClockLocation *loc);

+const gchar* clock_location_get_name (ClockLocation *loc);

+const gchar* clock_location_get_sort_name (ClockLocation *loc);

+const gchar* clock_location_get_city (ClockLocation *loc);

+void clock_location_set_timezone (ClockLocation *loc, const gchar *timezone);

+void clock_location_get_coords (ClockLocation *loc, gfloat *latitude, gfloat *longitude);

+void clock_location_localtime (ClockLocation *loc, struct tm *tm);

+gboolean clock_location_is_current (ClockLocation *loc);

+void clock_location_make_current (ClockLocation *loc,

+ GFunc callback,

+ gpointer data,

+ GDestroyNotify destroy);

+gboolean clock_location_is_current_timezone (ClockLocation *loc);

+const gchar* clock_location_get_weather_code (ClockLocation *loc);

+GWeatherInfo* clock_location_get_weather_info (ClockLocation *loc);

+void clock_location_update_weather (ClockLocation *loc);

+GWeatherLocation* clock_location_get_glocation (ClockLocation *loc);

+gint clock_location_get_offset (ClockLocation *loc);

+

+G_END_DECLS

+ g_return_if_fail (CLOCK_IS_LOCATION (loc));

+const gchar* clock_utils_get_temp_display_name (GWeatherTemperatureUnit temp)

+{

+ switch (temp) {

+ case GWEATHER_TEMP_UNIT_DEFAULT:

+ return N_("Default");

+ case GWEATHER_TEMP_UNIT_KELVIN:

+ /* translators: Kelvin */

+ return N_("K");

+ case GWEATHER_TEMP_UNIT_CENTIGRADE:

+ /* translators: Celsius */

+ return N_("C");

+ case GWEATHER_TEMP_UNIT_FAHRENHEIT:

+ /* translators: Fahrenheit */

+ return N_("F");

+ default:

+ return N_("Invalid");

+ }

+}

+

+const gchar* clock_utils_get_speed_display_name (GWeatherSpeedUnit speed)

+{

+ switch (speed) {

+ case GWEATHER_SPEED_UNIT_DEFAULT:

+ return N_("Default");

+ case GWEATHER_SPEED_UNIT_MS:

+ /* translators: meters per second */

+ return N_("m/s");

+ case GWEATHER_SPEED_UNIT_KPH:

+ /* translators: kilometers per hour */

+ return N_("km/h");

+ case GWEATHER_SPEED_UNIT_MPH:

+ /* translators: miles per hour */

+ return N_("mph");

+ case GWEATHER_SPEED_UNIT_KNOTS:

+ /* translators: knots (speed unit) */

+ return N_("knots");

+ case GWEATHER_SPEED_UNIT_BFT:

+ /* translators: wind speed */

+ return N_("Beaufort scale");

+ default:

+ return N_("Invalid");

+ }

+}

+

+const gchar* clock_utils_get_distance_display_name (GWeatherDistanceUnit distance)

+{

+ switch (distance) {

+ case GWEATHER_DISTANCE_UNIT_DEFAULT:

+ return N_("Default");

+ case GWEATHER_DISTANCE_UNIT_METERS:

+ /* translators: Meters */

+ return N_("m");

+ case GWEATHER_DISTANCE_UNIT_KM:

+ /* translators: Km*/

+ return N_("km");

+ case GWEATHER_DISTANCE_UNIT_MILES:

+ /* translators: Miles*/

+ return N_("miles");

+ default:

+ return N_("Invalid");

+ }

+}

+

+const gchar* clock_utils_get_pressure_display_name (GWeatherPressureUnit pressure)

+{

+ switch (pressure) {

+ case GWEATHER_PRESSURE_UNIT_DEFAULT:

+ return N_("Default");

+ case GWEATHER_PRESSURE_UNIT_KPA:

+ /* translators: kiloPascal */

+ return N_("kPa");

+ case GWEATHER_PRESSURE_UNIT_HPA:

+ /* translators: hectoPascal */

+ return N_("hPa");

+ case GWEATHER_PRESSURE_UNIT_MB:

+ /* translators: millibars */

+ return N_("mb");

+ case GWEATHER_PRESSURE_UNIT_MM_HG:

+ /* translators: millimeters of mercury */

+ return N_("mmHg");

+ case GWEATHER_PRESSURE_UNIT_INCH_HG:

+ /* translators: inches of mercury */

+ return N_("inHg");

+ case GWEATHER_PRESSURE_UNIT_ATM:

+ /* translators: atmospheres */

+ return N_("atm");

+ default:

+ return N_("Invalid");

+ }

+}

+#include <libgweather/gweather.h>

+G_BEGIN_DECLS

+const gchar* clock_utils_get_temp_display_name (GWeatherTemperatureUnit temp);

+const gchar* clock_utils_get_speed_display_name (GWeatherSpeedUnit speed);

+const gchar* clock_utils_get_distance_display_name (GWeatherDistanceUnit distance);

+const gchar* clock_utils_get_pressure_display_name (GWeatherPressureUnit pressure);

+

+G_END_DECLS

+#include <libgweather/gweather.h>

+#define KEY_LOCATIONS "locations"

+

+#define KEY_SPEED_UNIT "speed-unit"

+#define KEY_DISTANCE_UNIT "distance-unit"

+#define KEY_PRESSURE_UNIT "pressure-unit"

+ GtkWidget *location_entry;

+ GtkWidget *zone_combo;

+ GWeatherTemperatureUnit temperature_unit;

+ GWeatherSpeedUnit speed_unit;

+ GWeatherPressureUnit pressure_unit;

+ GWeatherDistanceUnit distance_unit;

+ GWeatherLocation *world;

+ GSettings *weather_settings;

+static void location_tiles_remove (gpointer data, gpointer user_data);

+ ClockLocationTile *tile;

+ for (l = cd->location_tiles; l != NULL; l = l->next) {

+ if (cd->weather_settings) {

+ g_object_unref (cd->weather_settings);

+ cd->weather_settings = NULL;

+ }

+

+ if (cd->locations != NULL) {

+ g_list_free_full (cd->locations, g_object_unref);

+ cd->locations = NULL;

+ }

+ if (cd->location_tiles) {

+ g_list_free_full (cd->location_tiles, g_object_unref);

+ cd->location_tiles = NULL;

+ }

+ const char *name_a = clock_location_get_sort_name (loc_a);

+ const char *name_b = clock_location_get_sort_name (loc_b);

+ CLOCK_TYPE_LOCATION)); /* COL_CITY_LOC */

+ const gchar *tzname = clock_location_get_tzname (loc);

+ if (tzname == NULL) {

+ tzname = clock_location_get_tzid (loc);

+ }

+ COL_CITY_TZ, tzname,

+static void location_tiles_remove (gpointer data, gpointer user_data)

+{

+ ClockData *cd;

+ ClockLocationTile *city;

+

+ city = data;

+ cd = user_data;

+ g_signal_handlers_disconnect_by_func(city, location_tile_pressed_cb, cd);

+ g_signal_handlers_disconnect_by_func(city, location_tile_need_clock_format_cb, cd);

+ gtk_container_remove (GTK_CONTAINER (cd->cities_section), GTK_WIDGET(city));

+}

+

+static void

+cities_section_sync (ClockData *cd)

+{

+ GList *l, *m, *n;

+ GList *node;

+ ClockLocationTile *city;

+ ClockLocation *loc;

+ gboolean found;

+

+ l = cd->location_tiles;

+ node = g_list_copy (cd->locations);

+ node = g_list_sort (node, sort_locations_by_time);

+ node = g_list_reverse (node);

+ while (l != NULL) {

+ GList *next = l->next;

+ found = FALSE;

+ loc = clock_location_tile_get_location (l->data);

+ for (n = node; n != NULL; n = n->next) {

+ if (clock_location_equal (loc, n->data)) {

+ found = TRUE;

+ break;

+ }

+ }

+ if (found) {

+ /* Remove existing elements from the new list */

+ node = g_list_delete_link (node, n);

+ } else {

+ /* Remove non-existing elements from the old list */

+ gtk_container_remove (GTK_CONTAINER (cd->cities_section), l->data);

+ cd->location_tiles = g_list_delete_link (cd->location_tiles, l);

+ }

+ l = next;

+ }

+

+ /* Append the remaining elements to the new list */

+ for (m = node; m != NULL; m = m->next) {

+ loc = m->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);

+

+ gtk_widget_show_all(GTK_WIDGET (city));

+ cd->location_tiles = g_list_append(cd->location_tiles, city);

+ clock_location_tile_refresh (city, TRUE);

+ }

+ g_list_free (node);

+}

+

+ clock_location_update_weather (loc);

+ GWeatherInfo *info;

+ if (!info || !gweather_info_is_valid (info))

+ GWeatherInfo *info,

+ if (!info || !gweather_info_is_valid (info))

+ cd->weather_icon_name = gweather_info_get_icon_name (info);

+ temp = gweather_info_get_temp_summary (info);

+ GWeatherInfo *info;

+locations_reset (ClockData *cd)

+ gulong id;

+ gpointer idp;

+ idp = g_object_get_data (G_OBJECT (loc), "weather-updated-id");

+ id = GPOINTER_TO_UINT (idp);

+ g_object_set_data (G_OBJECT (loc), "weather-updated-id", GUINT_TO_POINTER (id));

+ cities_section_sync (cd);

+locations_changed (GSettings *settings,

+ gchar *key,

+ ClockData *cd)

+ GList *cities = NULL;

+ GVariant *value, *item;

+ GVariantIter *iter;

+ ClockLocation* loc;

+ value = g_settings_get_value (settings, key);

+ g_variant_get (value, "av", &iter);

+ while (g_variant_iter_loop (iter, "v", &item)) {

+ loc = clock_location_deserialize (item);

+ cities = g_list_append(cities, loc);

+ g_variant_iter_free (iter);

+ cd->locations = clock_locations_merge (cd->locations, cities);

+ locations_reset (cd);

+ oldvalue = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + 1;

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), cd->temperature_unit - 1);

+ oldvalue = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + 1;

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), cd->speed_unit - 1);

+ }

+}

+

+static void

+distance_unit_changed (GSettings *settings,

+ gchar *key,

+ ClockData *cd)

+{

+ cd->distance_unit = g_settings_get_enum (settings, key);

+ if (cd->distance_unit > 0)

+ {

+ GtkWidget *widget;

+ gint oldvalue;

+ widget = _clock_get_widget (cd, "visibility_combo");

+ oldvalue = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + 1;

+ if (oldvalue != cd->distance_unit)

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), cd->distance_unit - 1);

+ }

+}

+

+static void

+pressure_unit_changed (GSettings *settings,

+ gchar *key,

+ ClockData *cd)

+{

+ cd->pressure_unit = g_settings_get_enum (settings, key);

+ if (cd->pressure_unit > 0)

+ {

+ GtkWidget *widget;

+ gint oldvalue;

+ widget = _clock_get_widget (cd, "pressure_combo");

+ oldvalue = gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + 1;

+ if (oldvalue != cd->pressure_unit)

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget), cd->pressure_unit - 1);

+ cd->weather_settings = g_settings_new ("org.gnome.GWeather");

+ g_signal_connect (cd->settings, "changed::" KEY_LOCATIONS, G_CALLBACK (locations_changed), cd);

+ g_signal_connect (cd->weather_settings, "changed::" KEY_DISTANCE_UNIT, G_CALLBACK (distance_unit_changed), cd);

+ g_signal_connect (cd->weather_settings, "changed::" KEY_PRESSURE_UNIT, G_CALLBACK (pressure_unit_changed), cd);

+ g_signal_connect (cd->weather_settings, "changed::" KEY_SPEED_UNIT, G_CALLBACK (speed_unit_changed), cd);

+ g_signal_connect (cd->weather_settings, "changed::" KEY_TEMPERATURE_UNIT, G_CALLBACK (temperature_unit_changed), cd);

+ GVariant *value, *item;

+ GVariantIter iter;

+ ClockLocation *loc;

+ cd->distance_unit = g_settings_get_enum (cd->weather_settings, KEY_DISTANCE_UNIT);

+ cd->pressure_unit = g_settings_get_enum (cd->weather_settings, KEY_PRESSURE_UNIT);

+ cd->speed_unit = g_settings_get_enum (cd->weather_settings, KEY_SPEED_UNIT);

+ cd->temperature_unit = g_settings_get_enum (cd->weather_settings, KEY_TEMPERATURE_UNIT);

+ value = g_settings_get_value (cd->settings, KEY_LOCATIONS);

+ g_variant_iter_init (&iter, value);

+ while (g_variant_iter_loop (&iter, "v", &item)) {

+ loc = clock_location_deserialize (item);

+ cd->locations = clock_locations_append(cd->locations, loc);

+ locations_reset(cd);

+ cd->world = gweather_location_get_world ();

+ GList *node;

+ GVariant *value;

+ GVariantBuilder *builder;

+ ClockLocation *loc;

+ builder = g_variant_builder_new (G_VARIANT_TYPE ("av"));

+ for (node = cd->locations; node != NULL; node = node->next) {

+ loc = node->data;

+ g_variant_builder_add (builder, "v", clock_location_serialize (loc));

+ }

+ value = g_variant_builder_end (builder);

+ g_variant_builder_unref (builder);

+ g_settings_set_value (cd->settings, KEY_LOCATIONS, value);

+ ClockLocation *loc;

+ GWeatherLocation *gloc;

+ const gchar *timezone;

+ timezone = gweather_timezone_menu_get_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo));

+ gloc = gweather_location_entry_get_location (GWEATHER_LOCATION_ENTRY(cd->location_entry));

+ loc = clock_location_new (gloc);

+ cd->locations = clock_locations_append(cd->locations, loc);

+ gtk_widget_set_sensitive(lat_entry, TRUE);

+ gtk_widget_set_sensitive(lon_entry, TRUE);

+ gtk_widget_set_sensitive(lat_combo, TRUE);

+ gtk_widget_set_sensitive(lon_combo, TRUE);

+ gtk_widget_set_sensitive(lat_entry, FALSE);

+ gtk_widget_set_sensitive(lon_entry, FALSE);

+ gtk_widget_set_sensitive(lat_combo, FALSE);

+ gtk_widget_set_sensitive(lon_combo, FALSE);

+ gweather_timezone_menu_set_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo),

+ clock_location_get_tzid (loc));

+ gweather_timezone_menu_set_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo), NULL);

+ timezone = gweather_timezone_menu_get_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo));

+location_entry_changed (GObject *object, GParamSpec *param, ClockData *cd)

+ GWeatherLocationEntry *entry = GWEATHER_LOCATION_ENTRY (object);

+ GWeatherLocation *gloc;

+ GWeatherTimezone *zone;

+ gdouble latitude = 0.0, longitude = 0.0;

+ gloc = gweather_location_entry_get_location (entry);

+ if (gloc == NULL)

+ return;

+

+ latlon_valid = gweather_location_has_coords (gloc);

+ gweather_location_get_coords (gloc, &latitude, &longitude);

+ zone = gweather_location_get_timezone (gloc);

+ if (zone != NULL) {

+ const gchar* tzid = gweather_timezone_get_tzid (zone);

+ if (tzid != NULL) {

+ gweather_timezone_menu_set_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo), tzid);

+ }

+ } else {

+ gweather_timezone_menu_set_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo), NULL);

+ }

+ if (zone) {

+ gweather_timezone_unref (zone);

+ }

+ if (gloc) {

+ gweather_location_unref (gloc);

+ }

+location_timezone_changed (GObject *object, G_GNUC_UNUSED GParamSpec *param, ClockData *cd)

+ gweather_location_entry_set_location (GWEATHER_LOCATION_ENTRY(cd->location_entry), NULL);

+ gweather_timezone_menu_set_tzid (GWEATHER_TIMEZONE_MENU(cd->zone_combo), NULL);

+ GWeatherLocation*gloc;

+ gloc = clock_location_get_glocation (loc);

+ gweather_location_entry_set_location (GWEATHER_LOCATION_ENTRY(cd->location_entry), gloc);

+ value = gtk_combo_box_get_active (combo) + 1;

+ g_settings_set_enum (cd->weather_settings, KEY_TEMPERATURE_UNIT, value);

+ value = gtk_combo_box_get_active (combo) + 1;

+ g_settings_set_enum (cd->weather_settings, KEY_SPEED_UNIT, value);

+static void

+visibility_combo_changed (GtkComboBox *combo, ClockData *cd)

+{

+ int value;

+ int old_value;

+

+ value = gtk_combo_box_get_active (combo) + 1;

+ old_value = cd->distance_unit;

+

+ if (value == old_value)

+ return;

+

+ g_settings_set_enum (cd->weather_settings, KEY_DISTANCE_UNIT, value);

+}

+

+static void

+pressure_combo_changed (GtkComboBox *combo, ClockData *cd)

+{

+ int value;

+ int old_value;

+

+ value = gtk_combo_box_get_active (combo) + 1;

+ old_value = cd->pressure_unit;

+

+ if (value == old_value)

+ return;

+

+ g_settings_set_enum (cd->weather_settings, KEY_PRESSURE_UNIT, value);

+}

+ GWEATHER_TEMP_UNIT_DEFAULT,

+ GWEATHER_TEMP_UNIT_KELVIN,

+ GWEATHER_TEMP_UNIT_CENTIGRADE,

+ GWEATHER_TEMP_UNIT_FAHRENHEIT,

+ GWEATHER_SPEED_UNIT_DEFAULT,

+ GWEATHER_SPEED_UNIT_MS, /* metres per second */

+ GWEATHER_SPEED_UNIT_KPH, /* kilometres per hour */

+ GWEATHER_SPEED_UNIT_MPH, /* miles per hour */

+ GWEATHER_SPEED_UNIT_KNOTS, /* Knots */

+ GWEATHER_SPEED_UNIT_BFT, /* Beaufort scale */

+ static const int distances [] = {

+ GWEATHER_DISTANCE_UNIT_DEFAULT,

+ GWEATHER_DISTANCE_UNIT_METERS,

+ GWEATHER_DISTANCE_UNIT_KM,

+ GWEATHER_DISTANCE_UNIT_MILES,

+ -1

+ };

+

+ static const int pressures[] = {

+ GWEATHER_PRESSURE_UNIT_DEFAULT,

+ GWEATHER_PRESSURE_UNIT_KPA, /* kiloPascal */

+ GWEATHER_PRESSURE_UNIT_HPA, /* hectoPascal */

+ GWEATHER_PRESSURE_UNIT_MB, /* 1 millibars = 1 hectoPascal */

+ GWEATHER_PRESSURE_UNIT_MM_HG, /* millimeters of mercury */

+ GWEATHER_PRESSURE_UNIT_INCH_HG, /* inches of mercury */

+ GWEATHER_PRESSURE_UNIT_ATM, /* atmosphere */

+ -1

+ };

+

+ for (i = 0; temperatures[i] > 0; i++)

+ 0, clock_utils_get_temp_display_name (temperatures[i]),

+ cd->temperature_unit - 1);

+ for (i = 0; speeds[i] > 0; i++)

+ 0, clock_utils_get_speed_display_name (speeds[i]),

+ cd->speed_unit - 1);

+

+ /* Visibility speed combo */

+ widget = _clock_get_widget (cd, "visibility_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; distances[i] > 0; i++)

+ gtk_list_store_insert_with_values (store, &iter, -1,

+ 0, clock_utils_get_distance_display_name (distances[i]),

+ -1);

+

+ if (cd->distance_unit > 0)

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget),

+ cd->distance_unit - 1);

+ g_signal_connect (widget, "changed",

+ G_CALLBACK (visibility_combo_changed), cd);

+

+ /* Pressure speed combo */

+ widget = _clock_get_widget (cd, "pressure_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; pressures[i] > 0; i++)

+ gtk_list_store_insert_with_values (store, &iter, -1,

+ 0, clock_utils_get_pressure_display_name (pressures[i]),

+ -1);

+

+ if (cd->distance_unit > 0)

+ gtk_combo_box_set_active (GTK_COMBO_BOX (widget),

+ cd->pressure_unit - 1);

+ g_signal_connect (widget, "changed",

+ G_CALLBACK (pressure_combo_changed), cd);

+ cd->location_entry = gweather_location_entry_new (cd->world);

+ G_CALLBACK (location_entry_changed), cd);

+ cd->zone_combo = gweather_timezone_menu_new (cd->world);

+ gtk_widget_set_sensitive (GTK_WIDGET(cd->zone_combo), FALSE);

+ gtk_container_add (GTK_CONTAINER (zone_box), cd->zone_combo);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (timezone_label), cd->zone_combo);

+static void display_about_dialog(GtkAction* action, G_GNUC_UNUSED ClockData* cd)

+ <property name="visible">True</property>

+ <property name="visible">True</property>

+ <property name="visible">True</property>

+ <property name="visible">True</property>

+ <property name="sensitive">False</property>

+ <property name="editable">False</property>

+ <property name="editable">False</property>

+ <property name="sensitive">False</property>

+

+ <key name="locations" type="av">

+GWEATHER_REQUIRED=3.32.0

+PKG_CHECK_MODULES(CLOCK, pango >= $PANGO_REQUIRED gtk+-3.0 >= $GTK_REQUIRED glib-2.0 >= $GLIB_REQUIRED gio-2.0 >= $GLIB_REQUIRED librsvg-2.0 >= $LIBRSVG_REQUIRED gweather-3.0 >= $GWEATHER_REQUIRED mate-desktop-2.0 >= $LIBMATE_DESKTOP_REQUIRED)