moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 728 insertions, 0 deletions

diff --git a/applets/clock/clock-location-tile.c b/applets/clock/clock-location-tile.c
new file mode 100644
index 00000000..a6f6a4ce
--- /dev/null
+++ b/applets/clock/clock-location-tile.c
@@ -0,0 +1,728 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+
+#include "clock.h"
+#include "clock-face.h"
+#include "clock-location-tile.h"
+#include "clock-location.h"
+#include "clock-utils.h"
+#include "clock-marshallers.h"
+#include "set-timezone.h"
+
+G_DEFINE_TYPE (ClockLocationTile, clock_location_tile, GTK_TYPE_ALIGNMENT)
+
+enum {
+	TILE_PRESSED,
+	NEED_CLOCK_FORMAT,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+typedef struct {
+        ClockLocation *location;
+
+        struct tm last_refresh;
+	long last_offset;
+
+        ClockFaceSize size;
+
+	GtkWidget *box;
+        GtkWidget *clock_face;
+        GtkWidget *city_label;
+        GtkWidget *time_label;
+
+        GtkWidget *current_button;
+        GtkWidget *current_label;
+        GtkWidget *current_marker;
+        GtkWidget *current_spacer;
+        GtkSizeGroup *current_group;
+        GtkSizeGroup *button_group;
+
+        GtkWidget *weather_icon;
+
+	gulong location_weather_updated_id;
+} ClockLocationTilePrivate;
+
+static void clock_location_tile_finalize (GObject *);
+
+#define PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CLOCK_LOCATION_TILE_TYPE, ClockLocationTilePrivate))
+
+static void clock_location_tile_fill (ClockLocationTile *this);
+static void update_weather_icon (ClockLocation *loc, WeatherInfo *info, gpointer data);
+static gboolean weather_tooltip (GtkWidget *widget,
+                                 gint x, gint y,
+		                 gboolean    keyboard_mode,
+		                 GtkTooltip *tooltip,
+		                 gpointer    data);
+
+ClockLocationTile *
+clock_location_tile_new (ClockLocation *loc,
+			 ClockFaceSize size)
+{
+        ClockLocationTile *this;
+        ClockLocationTilePrivate *priv;
+
+        this = g_object_new (CLOCK_LOCATION_TILE_TYPE, NULL);
+        priv = PRIVATE (this);
+
+        priv->location = g_object_ref (loc);
+        priv->size = size;
+
+        clock_location_tile_fill (this);
+
+	update_weather_icon (loc, clock_location_get_weather_info (loc), this);
+	gtk_widget_set_has_tooltip (priv->weather_icon, TRUE);
+
+	g_signal_connect (priv->weather_icon, "query-tooltip",
+			  G_CALLBACK (weather_tooltip), this);
+	priv->location_weather_updated_id = g_signal_connect (G_OBJECT (loc), "weather-updated",
+							      G_CALLBACK (update_weather_icon), this);
+
+        return this;
+}
+
+static void
+clock_location_tile_class_init (ClockLocationTileClass *this_class)
+{
+        GObjectClass *g_obj_class = G_OBJECT_CLASS (this_class);
+
+        g_obj_class->finalize = clock_location_tile_finalize;
+
+        g_type_class_add_private (this_class, sizeof (ClockLocationTilePrivate));
+
+	signals[TILE_PRESSED] = g_signal_new ("tile-pressed",
+					      G_TYPE_FROM_CLASS (g_obj_class),
+					      G_SIGNAL_RUN_FIRST,
+					      G_STRUCT_OFFSET (ClockLocationTileClass, tile_pressed),
+					      NULL,
+					      NULL,
+					      g_cclosure_marshal_VOID__VOID,
+					      G_TYPE_NONE, 0);
+	signals[NEED_CLOCK_FORMAT] = g_signal_new ("need-clock-format",
+						   G_TYPE_FROM_CLASS (g_obj_class),
+						   G_SIGNAL_RUN_LAST,
+						   G_STRUCT_OFFSET (ClockLocationTileClass, need_clock_format),
+						   NULL,
+						   NULL,
+						   _clock_marshal_INT__VOID,
+						   G_TYPE_INT, 0);
+}
+
+static void
+clock_location_tile_init (ClockLocationTile *this)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (this);
+
+        priv->location = NULL;
+
+        memset (&(priv->last_refresh), 0, sizeof (struct tm));
+	priv->last_offset = 0;
+
+        priv->size = CLOCK_FACE_SMALL;
+
+        priv->clock_face = NULL;
+        priv->city_label = NULL;
+        priv->time_label = NULL;
+}
+
+static void
+clock_location_tile_finalize (GObject *g_obj)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (g_obj);
+
+        if (priv->location) {
+		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)->finalize (g_obj);
+}
+
+static gboolean
+press_on_tile      (GtkWidget             *widget,
+                    GdkEventButton        *event,
+                    ClockLocationTile *tile)
+{
+	g_signal_emit (tile, signals[TILE_PRESSED], 0);
+
+        return TRUE;
+}
+
+static void
+make_current_cb (gpointer data, GError *error)
+{
+	GtkWidget *dialog;
+
+        if (error) {
+                dialog = gtk_message_dialog_new (NULL,
+                                                 0,
+                                                 GTK_MESSAGE_ERROR,
+                                                 GTK_BUTTONS_CLOSE,
+                                                 _("Failed to set the system timezone"));
+                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);
+        }
+}
+
+static void
+make_current (GtkWidget *widget, ClockLocationTile *tile)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (tile);
+	GtkWidget *toplevel;
+	guint xid;
+
+	xid = 0;
+	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tile));
+
+	if (toplevel) {
+		GdkWindow *window = gtk_widget_get_window (toplevel);
+
+		if (window)
+			xid = GDK_WINDOW_XWINDOW (window);
+	}
+
+	clock_location_make_current (priv->location,
+				     xid,
+				     (GFunc)make_current_cb, tile, NULL);
+}
+
+static gboolean
+enter_or_leave_tile (GtkWidget             *widget,
+                     GdkEventCrossing      *event,
+                     ClockLocationTile *tile)
+{
+	ClockLocationTilePrivate *priv = PRIVATE (tile);
+
+	if (event->mode != GDK_CROSSING_NORMAL) {
+		return TRUE;
+	}
+
+	if (clock_location_is_current (priv->location)) {
+		gtk_widget_hide (priv->current_button);
+		gtk_widget_hide (priv->current_spacer);
+		gtk_widget_show (priv->current_marker);
+
+		return TRUE;
+	}
+
+	if (event->type == GDK_ENTER_NOTIFY) {
+		gint can_set;
+
+		if (clock_location_is_current_timezone (priv->location))
+			can_set = 2;
+		else
+			can_set = can_set_system_timezone ();
+		if (can_set != 0) {
+			gtk_label_set_markup (GTK_LABEL (priv->current_label),
+						can_set == 1 ?
+							_("<small>Set...</small>") :
+							_("<small>Set</small>"));
+			gtk_widget_hide (priv->current_spacer);
+			gtk_widget_hide (priv->current_marker);
+			gtk_widget_show (priv->current_button);
+		}
+		else {
+			gtk_widget_hide (priv->current_marker);
+			gtk_widget_hide (priv->current_button);
+			gtk_widget_show (priv->current_spacer);
+		}
+	}
+	else {
+		if (event->detail != GDK_NOTIFY_INFERIOR) {
+			gtk_widget_hide (priv->current_button);
+			gtk_widget_hide (priv->current_marker);
+			gtk_widget_show (priv->current_spacer);
+		}
+	}
+
+	return TRUE;
+}
+
+static void
+clock_location_tile_fill (ClockLocationTile *this)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (this);
+	GtkWidget *align;
+        GtkWidget *strut;
+        GtkWidget *box;
+        GtkWidget *alignment;
+        GtkWidget *tile;
+        GtkWidget *head_section;
+
+        priv->box = gtk_event_box_new ();
+
+        gtk_widget_add_events (priv->box, GDK_BUTTON_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
+        g_signal_connect (priv->box, "button-press-event",
+                          G_CALLBACK (press_on_tile), this);
+        g_signal_connect (priv->box, "enter-notify-event",
+                          G_CALLBACK (enter_or_leave_tile), this);
+        g_signal_connect (priv->box, "leave-notify-event",
+                          G_CALLBACK (enter_or_leave_tile), this);
+
+        alignment = gtk_alignment_new (0, 0, 1, 0);
+        gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 3, 3, 3, 0);
+
+        tile = gtk_hbox_new (FALSE, 6);
+        head_section = gtk_vbox_new (FALSE, 0);
+
+        priv->city_label = gtk_label_new (NULL);
+        gtk_misc_set_alignment (GTK_MISC (priv->city_label), 0, 0);
+
+        align = gtk_alignment_new (0, 0, 0, 0);
+        gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 0, 3);
+        gtk_container_add (GTK_CONTAINER (align), priv->city_label);
+        gtk_box_pack_start (GTK_BOX (head_section), align, FALSE, FALSE, 0);
+
+        priv->time_label = gtk_label_new (NULL);
+        gtk_misc_set_alignment (GTK_MISC (priv->time_label), 0, 0);
+
+        priv->weather_icon = gtk_image_new ();
+        align = gtk_alignment_new (0, 0, 0, 0);
+        gtk_container_add (GTK_CONTAINER (align), priv->weather_icon);
+
+        box = gtk_hbox_new (FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (head_section), box, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (box), align, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (box), priv->time_label, FALSE, FALSE, 0);
+
+        priv->current_button = gtk_button_new ();
+	/* The correct label is set on EnterNotify events */
+	priv->current_label = gtk_label_new ("");
+        gtk_widget_show (priv->current_label);
+        gtk_widget_set_no_show_all (priv->current_button, TRUE);
+        gtk_container_add (GTK_CONTAINER (priv->current_button), priv->current_label);
+        gtk_widget_set_tooltip_text (priv->current_button,
+				     _("Set location as current location and use its timezone for this computer"));
+
+	priv->current_marker = gtk_image_new_from_icon_name ("go-home", GTK_ICON_SIZE_BUTTON);
+	gtk_misc_set_alignment (GTK_MISC (priv->current_marker), 1.0, 0.5);
+	gtk_widget_set_no_show_all (priv->current_marker, TRUE);
+
+	priv->current_spacer = gtk_event_box_new ();
+	gtk_widget_set_no_show_all (priv->current_spacer, TRUE);
+
+        strut = gtk_event_box_new ();
+        gtk_box_pack_start (GTK_BOX (box), strut, TRUE, TRUE, 0);
+        gtk_box_pack_start (GTK_BOX (box), priv->current_button, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (box), priv->current_marker, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (box), priv->current_spacer, FALSE, FALSE, 0);
+        priv->button_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+        gtk_size_group_set_ignore_hidden (priv->button_group, FALSE);
+        gtk_size_group_add_widget (priv->button_group, strut);
+        gtk_size_group_add_widget (priv->button_group, priv->current_button);
+
+	/* 
+	 * Avoid resizing the popup as the tiles display the current marker, 
+	 * set button or nothing. For that purpose, replace 'nothing' with 
+	 * an event box, and force the button, marker and spacer to have the 
+	 * same size via a size group. The visibility of the three is managed
+ 	 * manually to ensure that only one of them is shown at any time. 
+ 	 * (The all have to be shown initially to get the sizes worked out, 
+ 	 * but they are never visible together). 
+	 */
+        priv->current_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
+        gtk_size_group_set_ignore_hidden (priv->current_group, FALSE);
+        gtk_size_group_add_widget (priv->current_group, priv->current_button);
+        gtk_size_group_add_widget (priv->current_group, priv->current_marker);
+        gtk_size_group_add_widget (priv->current_group, priv->current_spacer);
+	
+	gtk_widget_show (priv->current_button);
+	gtk_widget_show (priv->current_marker);
+	gtk_widget_show (priv->current_spacer);
+
+        g_signal_connect (priv->current_button, "clicked",
+                          G_CALLBACK (make_current), this);
+
+        priv->clock_face = clock_face_new_with_location (
+                priv->size, priv->location, head_section);
+
+        gtk_box_pack_start (GTK_BOX (tile), priv->clock_face, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (tile), head_section, TRUE, TRUE, 0);
+
+        gtk_container_add (GTK_CONTAINER (alignment), tile);
+        gtk_container_add (GTK_CONTAINER (priv->box), alignment);
+        gtk_container_add (GTK_CONTAINER (this), priv->box);
+}
+
+static gboolean
+clock_needs_face_refresh (ClockLocationTile *this)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (this);
+        struct tm now;
+
+        clock_location_localtime (priv->location, &now);
+
+        if (now.tm_year > priv->last_refresh.tm_year
+            || now.tm_mon > priv->last_refresh.tm_mon
+            || now.tm_mday > priv->last_refresh.tm_mday
+            || now.tm_hour > priv->last_refresh.tm_hour
+            || now.tm_min > priv->last_refresh.tm_min) {
+                return TRUE;
+        }
+
+        if ((priv->size == CLOCK_FACE_LARGE)
+            && now.tm_sec > priv->last_refresh.tm_sec) {
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
+static gboolean
+clock_needs_label_refresh (ClockLocationTile *this)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (this);
+        struct tm now;
+	long offset;
+
+        clock_location_localtime (priv->location, &now);
+	offset = clock_location_get_offset (priv->location);
+
+        if (now.tm_year > priv->last_refresh.tm_year
+            || now.tm_mon > priv->last_refresh.tm_mon
+            || now.tm_mday > priv->last_refresh.tm_mday
+            || now.tm_hour > priv->last_refresh.tm_hour
+            || now.tm_min > priv->last_refresh.tm_min
+	    || offset != priv->last_offset) {
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
+static void
+copy_tm (struct tm *from, struct tm *to)
+{
+        to->tm_sec = from->tm_sec;
+        to->tm_min = from->tm_min;
+        to->tm_hour = from->tm_hour;
+        to->tm_mday = from->tm_mday;
+        to->tm_mon = from->tm_mon;
+        to->tm_year = from->tm_year;
+        to->tm_wday = from->tm_wday;
+        to->tm_yday = from->tm_yday;
+}
+
+static char *
+format_time (struct tm   *now, 
+             char        *tzname,
+             ClockFormat  clock_format,
+	     long         offset)
+{
+	char buf[256];
+	char *format;
+	time_t local_t;
+	struct tm local_now;
+	char *utf8;	
+	char *tmp;	
+	long hours, minutes;
+
+	time (&local_t);
+	localtime_r (&local_t, &local_now);
+
+	if (local_now.tm_wday != now->tm_wday) {
+		if (clock_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), when the local
+			 * weekday differs from the weekday at the location
+			 * (the %A expands to the weekday). The %p expands to
+			 * am/pm. */
+			format = _("%l:%M <small>%p (%A)</small>");
+		}
+		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), when the local
+			 * weekday differs from the weekday at the location
+			 * (the %A expands to the weekday). */
+			format = _("%H:%M <small>(%A)</small>");
+		}
+	}
+	else {
+		if (clock_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. */
+			format = _("%l:%M <small>%p</small>");
+		}
+		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 = _("%H:%M");
+		}
+	}
+
+	if (strftime (buf, sizeof (buf), format, now) <= 0) {
+		strcpy (buf, "???");
+	}
+
+        hours = offset / 3600;
+        minutes = labs (offset % 3600) / 60;
+
+	if (hours != 0 && minutes != 0) {
+		tmp = g_strdup_printf ("%s <small>%s %+ld:%ld</small>", buf, tzname, hours, minutes);
+	}
+	else if (hours != 0) {
+		tmp = g_strdup_printf ("%s <small>%s %+ld</small>", buf, tzname, hours);
+	}
+	else {
+		tmp = g_strdup_printf ("%s <small>%s</small>", buf, tzname);
+	}
+
+	utf8 = g_locale_to_utf8 (tmp, -1, NULL, NULL, NULL);
+
+	g_free (tmp);
+
+	return utf8;
+}
+
+static char *
+convert_time_to_str (time_t now, ClockFormat clock_format)
+{
+	const gchar *format;
+	struct tm *tm;
+	gchar buf[128];
+
+	if (clock_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.
+                 */
+		format = _("%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).
+                 */
+		format = _("%H:%M");
+	}
+
+	tm = localtime (&now);
+	strftime (buf, sizeof (buf) - 1, format, tm);
+
+	return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
+}
+
+void
+clock_location_tile_refresh (ClockLocationTile *this, gboolean force_refresh)
+{
+        ClockLocationTilePrivate *priv = PRIVATE (this);
+        gchar *tmp, *tzname;
+        struct tm now;
+	long offset;
+	int format;
+
+	g_return_if_fail (IS_CLOCK_LOCATION_TILE (this));
+
+        if (clock_location_is_current (priv->location)) {
+		gtk_widget_hide (priv->current_spacer);
+		gtk_widget_hide (priv->current_button);
+		gtk_widget_show (priv->current_marker);
+	}
+	else {
+		if (gtk_widget_get_visible (priv->current_marker)) {
+			gtk_widget_hide (priv->current_marker);
+			gtk_widget_hide (priv->current_button);
+			gtk_widget_show (priv->current_spacer);
+		}
+	}
+
+        if (clock_needs_face_refresh (this)) {
+                clock_face_refresh (CLOCK_FACE (priv->clock_face));
+        }
+
+        if (!force_refresh && !clock_needs_label_refresh (this)) {
+                return;
+        }
+
+        clock_location_localtime (priv->location, &now);
+        tzname = clock_location_get_tzname (priv->location);
+
+        copy_tm (&now, &(priv->last_refresh));
+	priv->last_offset = clock_location_get_offset (priv->location);
+
+        tmp = g_strdup_printf ("<big><b>%s</b></big>",
+                               clock_location_get_display_name (priv->location));
+        gtk_label_set_markup (GTK_LABEL (priv->city_label), tmp);
+        g_free (tmp);
+
+	g_signal_emit (this, signals[NEED_CLOCK_FORMAT], 0, &format);
+
+	offset = - priv->last_offset;
+
+	tmp = format_time (&now, tzname, format, offset);
+
+        gtk_label_set_markup (GTK_LABEL (priv->time_label), tmp);
+
+        g_free (tmp);
+}
+
+void
+weather_info_setup_tooltip (WeatherInfo *info, ClockLocation *location, GtkTooltip *tooltip,
+			    ClockFormat clock_format)
+{
+        GdkPixbuf *pixbuf = NULL;
+        GtkIconTheme *theme = NULL;
+	const gchar *conditions, *wind;
+	gchar *temp, *apparent;
+	gchar *line1, *line2, *line3, *line4, *tip;
+	const gchar *icon_name;
+	const gchar *sys_timezone;
+	time_t sunrise_time, sunset_time;
+	gchar *sunrise_str, *sunset_str;
+
+       	icon_name = weather_info_get_icon_name (info);
+        theme = gtk_icon_theme_get_default ();
+        pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48,
+                                           GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+        if (pixbuf)
+                gtk_tooltip_set_icon (tooltip, pixbuf);
+
+	conditions = weather_info_get_conditions (info);
+	if (strcmp (conditions, "-") != 0)
+		line1 = g_strdup_printf (_("%s, %s"),
+					 conditions,
+					 weather_info_get_sky (info));
+	else
+		line1 = g_strdup (weather_info_get_sky (info));
+
+	/* we need to g_strdup() since both functions return the same address
+	 * of a static buffer */
+	temp = g_strdup (weather_info_get_temp (info));
+	apparent = g_strdup (weather_info_get_apparent (info));
+	if (strcmp (apparent, temp) != 0 &&
+	    /* FMQ: it's broken to read from another module's translations; add some API to libmateweather. */
+            strcmp (apparent, dgettext ("mate-applets-2.0", "Unknown")) != 0)
+		/* Translators: The two strings are temperatures. */
+		line2 = g_strdup_printf (_("%s, feels like %s"), temp, apparent);
+	else
+		line2 = g_strdup (temp);
+	g_free (temp);
+	g_free (apparent);
+
+	wind = weather_info_get_wind (info);
+        if (strcmp (apparent, dgettext ("mate-applets-2.0", "Unknown")) != 0)
+		line3 = g_strdup_printf ("%s\n", wind);
+	else
+		line3 = g_strdup ("");
+
+	sys_timezone = getenv ("TZ");
+	setenv ("TZ", clock_location_get_timezone (location), 1);
+	tzset ();
+	if (weather_info_get_value_sunrise (info, &sunrise_time))
+		sunrise_str = convert_time_to_str (sunrise_time, clock_format);
+	else
+		sunrise_str = g_strdup ("???");
+	if (weather_info_get_value_sunset (info, &sunset_time))
+		sunset_str = convert_time_to_str (sunset_time, clock_format);
+	else
+		sunset_str = g_strdup ("???");
+	line4 = g_strdup_printf (_("Sunrise: %s / Sunset: %s"),
+				 sunrise_str, sunset_str);
+	g_free (sunrise_str);
+	g_free (sunset_str);
+
+	if (sys_timezone)
+		setenv ("TZ", sys_timezone, 1);
+	else
+		unsetenv ("TZ");
+	tzset ();
+
+	tip = g_strdup_printf ("<b>%s</b>\n%s\n%s%s", line1, line2, line3, line4);
+	gtk_tooltip_set_markup (tooltip, tip);
+	g_free (line1);
+	g_free (line2);
+	g_free (line3);
+	g_free (line4);
+	g_free (tip);
+}
+
+static gboolean
+weather_tooltip (GtkWidget  *widget,
+		 gint        x,
+		 gint	     y,
+		 gboolean    keyboard_mode,
+		 GtkTooltip *tooltip,
+		 gpointer    data)
+{
+        ClockLocationTile *tile = data;
+        ClockLocationTilePrivate *priv = PRIVATE (tile);
+	WeatherInfo *info;
+	int clock_format;
+
+	info = clock_location_get_weather_info (priv->location);
+
+	if (!info || !weather_info_is_valid (info))
+		return FALSE;
+
+	g_signal_emit (tile, signals[NEED_CLOCK_FORMAT], 0, &clock_format);
+
+	weather_info_setup_tooltip (info, priv->location, tooltip, clock_format);
+
+	return TRUE;
+}
+
+static void
+update_weather_icon (ClockLocation *loc, WeatherInfo *info, gpointer data)
+{
+        ClockLocationTile *tile = data;
+        ClockLocationTilePrivate *priv = PRIVATE (tile);
+        GdkPixbuf *pixbuf = NULL;
+        GtkIconTheme *theme = NULL;
+        const gchar *icon_name;
+
+        if (!info || !weather_info_is_valid (info))
+                return;
+
+        icon_name = weather_info_get_icon_name (info);
+        theme = gtk_icon_theme_get_default ();
+        pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 16,
+                                           GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
+
+        if (pixbuf) {
+                gtk_image_set_from_pixbuf (GTK_IMAGE (priv->weather_icon), pixbuf);
+                gtk_alignment_set_padding (GTK_ALIGNMENT (gtk_widget_get_parent (priv->weather_icon)), 0, 0, 0, 6);
+        }
+}
+
+ClockLocation *
+clock_location_tile_get_location (ClockLocationTile *this)
+{
+        ClockLocationTilePrivate *priv;
+
+	g_return_val_if_fail (IS_CLOCK_LOCATION_TILE (this), NULL);
+
+	priv = PRIVATE (this);
+
+	return g_object_ref (priv->location);
+}