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

1 files changed, 903 insertions, 0 deletions

diff --git a/typing-break/drwright.c b/typing-break/drwright.c
new file mode 100644
index 00000000..315a2d51
--- /dev/null
+++ b/typing-break/drwright.c
@@ -0,0 +1,903 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright (C) 2003-2005 Imendio HB
+ * Copyright (C) 2002-2003 Richard Hult <[email protected]>
+ * Copyright (C) 2002 CodeFactory AB
+ *
+ * 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.
+ */
+
+#include <config.h>
+#include <string.h>
+#include <math.h>
+#include <glib/gi18n.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+
+#ifdef HAVE_APP_INDICATOR
+#include <libappindicator/app-indicator.h>
+#endif /* HAVE_APP_INDICATOR */
+
+#include "drwright.h"
+#include "drw-break-window.h"
+#include "drw-monitor.h"
+#include "drw-utils.h"
+#include "drw-timer.h"
+
+#ifndef HAVE_APP_INDICATOR
+#define BLINK_TIMEOUT        200
+#define BLINK_TIMEOUT_MIN    120
+#define BLINK_TIMEOUT_FACTOR 100
+#endif /* HAVE_APP_INDICATOR */
+
+#define POPUP_ITEM_ENABLED 1
+#define POPUP_ITEM_BREAK   2
+
+typedef enum {
+	STATE_START,
+	STATE_RUNNING,
+	STATE_WARN,
+	STATE_BREAK_SETUP,
+	STATE_BREAK,
+	STATE_BREAK_DONE_SETUP,
+	STATE_BREAK_DONE
+} DrwState;
+
+#ifdef HAVE_APP_INDICATOR
+#define TYPING_MONITOR_ACTIVE_ICON "bar-green"
+#define TYPING_MONITOR_ATTENTION_ICON "bar-red"
+#endif /* HAVE_APP_INDICATOR */
+
+struct _DrWright {
+	/* Widgets. */
+	GtkWidget      *break_window;
+	GList          *secondary_break_windows;
+
+	DrwMonitor     *monitor;
+
+	GtkUIManager *ui_manager;
+
+	DrwState        state;
+	DrwTimer       *timer;
+	DrwTimer       *idle_timer;
+
+	gint            last_elapsed_time;
+	gint            save_last_time;
+
+	/* Time settings. */
+	gint            type_time;
+	gint            break_time;
+	gint            warn_time;
+
+	gboolean        enabled;
+
+	guint           clock_timeout_id;
+#ifdef HAVE_APP_INDICATOR
+	AppIndicator   *indicator;
+#else
+	guint           blink_timeout_id;
+
+	gboolean        blink_on;
+
+	GtkStatusIcon  *icon;
+
+	GdkPixbuf      *neutral_bar;
+	GdkPixbuf      *red_bar;
+	GdkPixbuf      *green_bar;
+	GdkPixbuf      *disabled_bar;
+	GdkPixbuf      *composite_bar;
+#endif /* HAVE_APP_INDICATOR */
+
+	GtkWidget      *warn_dialog;
+};
+
+static void     activity_detected_cb           (DrwMonitor     *monitor,
+						DrWright       *drwright);
+static gboolean maybe_change_state             (DrWright       *drwright);
+static gint     get_time_left                  (DrWright       *drwright);
+static gboolean update_status                  (DrWright       *drwright);
+static void     break_window_done_cb           (GtkWidget      *window,
+						DrWright       *dr);
+static void     break_window_postpone_cb       (GtkWidget      *window,
+						DrWright       *dr);
+static void     break_window_destroy_cb        (GtkWidget      *window,
+						DrWright       *dr);
+static void     popup_break_cb                 (GtkAction      *action,
+						DrWright       *dr);
+static void     popup_preferences_cb           (GtkAction      *action,
+						DrWright       *dr);
+static void     popup_about_cb                 (GtkAction      *action,
+						DrWright       *dr);
+#ifdef HAVE_APP_INDICATOR
+static void     init_app_indicator             (DrWright       *dr);
+#else
+static void     init_tray_icon                 (DrWright       *dr);
+#endif /* HAVE_APP_INDICATOR */
+static GList *  create_secondary_break_windows (void);
+
+static const GtkActionEntry actions[] = {
+  {"Preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK (popup_preferences_cb)},
+  {"About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK (popup_about_cb)},
+  {"TakeABreak", NULL, N_("_Take a Break"), NULL, NULL, G_CALLBACK (popup_break_cb)}
+};
+
+extern gboolean debug;
+
+static void
+setup_debug_values (DrWright *dr)
+{
+	dr->type_time = 5;
+	dr->warn_time = 4;
+	dr->break_time = 10;
+}
+
+#ifdef HAVE_APP_INDICATOR
+static void
+update_app_indicator (DrWright *dr)
+{
+	AppIndicatorStatus new_status;
+
+	if (!dr->enabled) {
+		app_indicator_set_status (dr->indicator,
+					  APP_INDICATOR_STATUS_PASSIVE);
+		return;
+	}
+
+	switch (dr->state) {
+	case STATE_WARN:
+	case STATE_BREAK_SETUP:
+	case STATE_BREAK:
+		new_status = APP_INDICATOR_STATUS_ATTENTION;
+		break;
+	default:
+		new_status = APP_INDICATOR_STATUS_ACTIVE;
+	}
+
+	app_indicator_set_status (dr->indicator, new_status);
+}
+#else
+static void
+update_icon (DrWright *dr)
+{
+	GdkPixbuf *pixbuf;
+	GdkPixbuf *tmp_pixbuf;
+	gint       width, height;
+	gfloat     r;
+	gint       offset;
+	gboolean   set_pixbuf;
+
+	if (!dr->enabled) {
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->disabled_bar);
+		return;
+	}
+
+	tmp_pixbuf = gdk_pixbuf_copy (dr->neutral_bar);
+
+	width = gdk_pixbuf_get_width (tmp_pixbuf);
+	height = gdk_pixbuf_get_height (tmp_pixbuf);
+
+	set_pixbuf = TRUE;
+
+	switch (dr->state) {
+	case STATE_BREAK:
+	case STATE_BREAK_SETUP:
+		r = 1;
+		break;
+
+	case STATE_BREAK_DONE:
+	case STATE_BREAK_DONE_SETUP:
+	case STATE_START:
+		r = 0;
+		break;
+
+	default:
+		r = (float) (drw_timer_elapsed (dr->timer) + dr->save_last_time) /
+		    (float) dr->type_time;
+		break;
+	}
+
+	offset = CLAMP ((height - 0) * (1.0 - r), 1, height - 0);
+
+	switch (dr->state) {
+	case STATE_WARN:
+		pixbuf = dr->red_bar;
+		set_pixbuf = FALSE;
+		break;
+
+	case STATE_BREAK_SETUP:
+	case STATE_BREAK:
+		pixbuf = dr->red_bar;
+		break;
+
+	default:
+		pixbuf = dr->green_bar;
+	}
+
+	gdk_pixbuf_composite (pixbuf,
+			      tmp_pixbuf,
+			      0,
+			      offset,
+			      width,
+			      height - offset,
+			      0,
+			      0,
+			      1.0,
+			      1.0,
+			      GDK_INTERP_BILINEAR,
+			      255);
+
+	if (set_pixbuf) {
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 tmp_pixbuf);
+	}
+
+	if (dr->composite_bar) {
+		g_object_unref (dr->composite_bar);
+	}
+
+	dr->composite_bar = tmp_pixbuf;
+}
+
+static gboolean
+blink_timeout_cb (DrWright *dr)
+{
+	gfloat r;
+	gint   timeout;
+
+	r = (dr->type_time - drw_timer_elapsed (dr->timer) - dr->save_last_time) / dr->warn_time;
+	timeout = BLINK_TIMEOUT + BLINK_TIMEOUT_FACTOR * r;
+
+	if (timeout < BLINK_TIMEOUT_MIN) {
+		timeout = BLINK_TIMEOUT_MIN;
+	}
+
+	if (dr->blink_on || timeout == 0) {
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->composite_bar);
+	} else {
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->neutral_bar);
+	}
+
+	dr->blink_on = !dr->blink_on;
+
+	if (timeout) {
+		dr->blink_timeout_id = g_timeout_add (timeout,
+						      (GSourceFunc) blink_timeout_cb,
+						      dr);
+	} else {
+		dr->blink_timeout_id = 0;
+	}
+
+	return FALSE;
+}
+#endif /* HAVE_APP_INDICATOR */
+
+static void
+start_blinking (DrWright *dr)
+{
+#ifndef HAVE_APP_INDICATOR
+	if (!dr->blink_timeout_id) {
+		dr->blink_on = TRUE;
+		blink_timeout_cb (dr);
+	}
+
+	/*gtk_widget_show (GTK_WIDGET (dr->icon));*/
+#endif /* HAVE_APP_INDICATOR */
+}
+
+static void
+stop_blinking (DrWright *dr)
+{
+#ifndef HAVE_APP_INDICATOR
+	if (dr->blink_timeout_id) {
+		g_source_remove (dr->blink_timeout_id);
+		dr->blink_timeout_id = 0;
+	}
+
+	/*gtk_widget_hide (GTK_WIDGET (dr->icon));*/
+#endif /* HAVE_APP_INDICATOR */
+}
+
+static gboolean
+grab_keyboard_on_window (GdkWindow *window,
+			 guint32    activate_time)
+{
+	GdkGrabStatus status;
+
+	status = gdk_keyboard_grab (window, TRUE, activate_time);
+	if (status == GDK_GRAB_SUCCESS) {
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static gboolean
+break_window_map_event_cb (GtkWidget *widget,
+			   GdkEvent  *event,
+			   DrWright  *dr)
+{
+	grab_keyboard_on_window (gtk_widget_get_window (dr->break_window), gtk_get_current_event_time ());
+
+        return FALSE;
+}
+
+static gboolean
+maybe_change_state (DrWright *dr)
+{
+	gint elapsed_time;
+	gint elapsed_idle_time;
+
+	if (debug) {
+		drw_timer_start (dr->idle_timer);
+	}
+
+	elapsed_time = drw_timer_elapsed (dr->timer) + dr->save_last_time;
+	elapsed_idle_time = drw_timer_elapsed (dr->idle_timer);
+
+	if (elapsed_time > dr->last_elapsed_time + dr->warn_time) {
+		/* If the timeout is delayed by the amount of warning time, then
+		 * we must have been suspended or stopped, so we just start
+		 * over.
+		 */
+		dr->state = STATE_START;
+	}
+
+	switch (dr->state) {
+	case STATE_START:
+		if (dr->break_window) {
+			gtk_widget_destroy (dr->break_window);
+			dr->break_window = NULL;
+		}
+
+#ifndef HAVE_APP_INDICATOR
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->neutral_bar);
+#endif /* HAVE_APP_INDICATOR */
+
+		dr->save_last_time = 0;
+
+		drw_timer_start (dr->timer);
+		drw_timer_start (dr->idle_timer);
+
+		if (dr->enabled) {
+			dr->state = STATE_RUNNING;
+		}
+
+		update_status (dr);
+		stop_blinking (dr);
+		break;
+
+	case STATE_RUNNING:
+	case STATE_WARN:
+		if (elapsed_idle_time >= dr->break_time) {
+			dr->state = STATE_BREAK_DONE_SETUP;
+ 		} else if (elapsed_time >= dr->type_time) {
+			dr->state = STATE_BREAK_SETUP;
+		} else if (dr->state != STATE_WARN
+			   && elapsed_time >= dr->type_time - dr->warn_time) {
+			dr->state = STATE_WARN;
+			start_blinking (dr);
+		}
+		break;
+
+	case STATE_BREAK_SETUP:
+		/* Don't allow more than one break window to coexist, can happen
+		 * if a break is manually enforced.
+		 */
+		if (dr->break_window) {
+			dr->state = STATE_BREAK;
+			break;
+		}
+
+		stop_blinking (dr);
+#ifndef HAVE_APP_INDICATOR
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->red_bar);
+#endif /* HAVE_APP_INDICATOR */
+
+		drw_timer_start (dr->timer);
+
+		dr->break_window = drw_break_window_new ();
+
+		g_signal_connect (dr->break_window, "map_event",
+				  G_CALLBACK (break_window_map_event_cb),
+				  dr);
+
+		g_signal_connect (dr->break_window,
+				  "done",
+				  G_CALLBACK (break_window_done_cb),
+				  dr);
+
+		g_signal_connect (dr->break_window,
+				  "postpone",
+				  G_CALLBACK (break_window_postpone_cb),
+				  dr);
+
+		g_signal_connect (dr->break_window,
+				  "destroy",
+				  G_CALLBACK (break_window_destroy_cb),
+				  dr);
+
+		dr->secondary_break_windows = create_secondary_break_windows ();
+
+		gtk_widget_show (dr->break_window);
+
+		dr->save_last_time = elapsed_time;
+		dr->state = STATE_BREAK;
+		break;
+
+	case STATE_BREAK:
+		if (elapsed_time - dr->save_last_time >= dr->break_time) {
+			dr->state = STATE_BREAK_DONE_SETUP;
+		}
+		break;
+
+	case STATE_BREAK_DONE_SETUP:
+		stop_blinking (dr);
+#ifndef HAVE_APP_INDICATOR
+		gtk_status_icon_set_from_pixbuf (dr->icon,
+						 dr->green_bar);
+#endif /* HAVE_APP_INDICATOR */
+
+		dr->state = STATE_BREAK_DONE;
+		break;
+
+	case STATE_BREAK_DONE:
+		dr->state = STATE_START;
+		if (dr->break_window) {
+			gtk_widget_destroy (dr->break_window);
+			dr->break_window = NULL;
+		}
+		break;
+	}
+
+	dr->last_elapsed_time = elapsed_time;
+
+#ifdef HAVE_APP_INDICATOR
+	update_app_indicator (dr);
+#else
+	update_icon (dr);
+#endif /* HAVE_APP_INDICATOR */
+
+	return TRUE;
+}
+
+static gboolean
+update_status (DrWright *dr)
+{
+	gint       min;
+	gchar     *str;
+#ifdef HAVE_APP_INDICATOR
+	GtkWidget *item;
+#endif /* HAVE_APP_INDICATOR */
+
+	if (!dr->enabled) {
+#ifdef HAVE_APP_INDICATOR
+		app_indicator_set_status (dr->indicator,
+					  APP_INDICATOR_STATUS_PASSIVE);
+#else
+		gtk_status_icon_set_tooltip_text (dr->icon,
+						  _("Disabled"));
+#endif /* HAVE_APP_INDICATOR */
+		return TRUE;
+	}
+
+	min = get_time_left (dr);
+
+	if (min >= 1) {
+#ifdef HAVE_APP_INDICATOR
+		str = g_strdup_printf (_("Take a break now (next in %dm)"), min);
+#else
+		str = g_strdup_printf (ngettext("%d minute until the next break",
+						"%d minutes until the next break",
+						min), min);
+#endif /* HAVE_APP_INDICATOR */
+	} else {
+#ifdef HAVE_APP_INDICATOR
+		str = g_strdup_printf (_("Take a break now (next in less than one minute)"));
+#else
+		str = g_strdup_printf (_("Less than one minute until the next break"));
+#endif /* HAVE_APP_INDICATOR */
+	}
+
+#ifdef HAVE_APP_INDICATOR
+	item = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop/TakeABreak");
+	gtk_menu_item_set_label (GTK_MENU_ITEM (item), str);
+#else
+	gtk_status_icon_set_tooltip_text (dr->icon, str);
+#endif /* HAVE_APP_INDICATOR */
+
+	g_free (str);
+
+	return TRUE;
+}
+
+static gint
+get_time_left (DrWright *dr)
+{
+	gint elapsed_time;
+
+	elapsed_time = drw_timer_elapsed (dr->timer);
+
+	return floor (0.5 + (dr->type_time - elapsed_time - dr->save_last_time) / 60.0);
+}
+
+static void
+activity_detected_cb (DrwMonitor *monitor,
+		      DrWright   *dr)
+{
+	drw_timer_start (dr->idle_timer);
+}
+
+static void
+mateconf_notify_cb (MateConfClient *client,
+		 guint        cnxn_id,
+		 MateConfEntry  *entry,
+		 gpointer     user_data)
+{
+	DrWright  *dr = user_data;
+	GtkWidget *item;
+
+	if (!strcmp (entry->key, MATECONF_PATH "/type_time")) {
+		if (entry->value->type == MATECONF_VALUE_INT) {
+			dr->type_time = 60 * mateconf_value_get_int (entry->value);
+			dr->warn_time = MIN (dr->type_time / 10, 5*60);
+
+			dr->state = STATE_START;
+		}
+	}
+	else if (!strcmp (entry->key, MATECONF_PATH "/break_time")) {
+		if (entry->value->type == MATECONF_VALUE_INT) {
+			dr->break_time = 60 * mateconf_value_get_int (entry->value);
+			dr->state = STATE_START;
+		}
+	}
+	else if (!strcmp (entry->key, MATECONF_PATH "/enabled")) {
+		if (entry->value->type == MATECONF_VALUE_BOOL) {
+			dr->enabled = mateconf_value_get_bool (entry->value);
+			dr->state = STATE_START;
+
+			item = gtk_ui_manager_get_widget (dr->ui_manager,
+							  "/Pop/TakeABreak");
+			gtk_widget_set_sensitive (item, dr->enabled);
+
+			update_status (dr);
+		}
+	}
+
+	maybe_change_state (dr);
+}
+
+static void
+popup_break_cb (GtkAction *action, DrWright *dr)
+{
+	if (dr->enabled) {
+		dr->state = STATE_BREAK_SETUP;
+		maybe_change_state (dr);
+	}
+}
+
+static void
+popup_preferences_cb (GtkAction *action, DrWright *dr)
+{
+	GdkScreen *screen;
+	GError    *error = NULL;
+	GtkWidget *menu;
+
+	menu = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop");
+	screen = gtk_widget_get_screen (menu);
+
+	if (!gdk_spawn_command_line_on_screen (screen, "mate-keyboard-properties --typing-break", &error)) {
+		GtkWidget *error_dialog;
+
+		error_dialog = gtk_message_dialog_new (NULL, 0,
+						       GTK_MESSAGE_ERROR,
+						       GTK_BUTTONS_CLOSE,
+						       _("Unable to bring up the typing break properties dialog with the following error: %s"),
+						       error->message);
+		g_signal_connect (error_dialog,
+				  "response",
+				  G_CALLBACK (gtk_widget_destroy), NULL);
+		gtk_window_set_resizable (GTK_WINDOW (error_dialog), FALSE);
+		gtk_widget_show (error_dialog);
+
+		g_error_free (error);
+	}
+}
+
+static void
+popup_about_cb (GtkAction *action, DrWright *dr)
+{
+	gint   i;
+	gchar *authors[] = {
+		N_("Written by Richard Hult <[email protected]>"),
+		N_("Eye candy added by Anders Carlsson"),
+		NULL
+	};
+
+	for (i = 0; authors [i]; i++)
+		authors [i] = _(authors [i]);
+
+	gtk_show_about_dialog (NULL,
+			       "authors", authors,
+			       "comments",  _("A computer break reminder."),
+			       "logo-icon-name", "typing-monitor",
+			       "translator-credits", _("translator-credits"),
+			       "version", VERSION,
+			       NULL);
+}
+
+#ifndef HAVE_APP_INDICATOR
+static void
+popup_menu_cb (GtkWidget *widget,
+	       guint      button,
+	       guint      activate_time,
+	       DrWright  *dr)
+{
+	GtkWidget *menu;
+
+	menu = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop");
+
+	gtk_menu_popup (GTK_MENU (menu),
+			NULL,
+			NULL,
+			gtk_status_icon_position_menu,
+			dr->icon,
+			0,
+			gtk_get_current_event_time ());
+}
+#endif /* HAVE_APP_INDICATOR */
+
+static void
+break_window_done_cb (GtkWidget *window,
+		      DrWright  *dr)
+{
+	gtk_widget_destroy (dr->break_window);
+
+	dr->state = STATE_BREAK_DONE_SETUP;
+	dr->break_window = NULL;
+
+	update_status (dr);
+	maybe_change_state (dr);
+}
+
+static void
+break_window_postpone_cb (GtkWidget *window,
+			  DrWright  *dr)
+{
+	gint elapsed_time;
+
+	gtk_widget_destroy (dr->break_window);
+
+	dr->state = STATE_RUNNING;
+	dr->break_window = NULL;
+
+	elapsed_time = drw_timer_elapsed (dr->timer);
+
+	if (elapsed_time + dr->save_last_time >= dr->type_time) {
+		/* Typing time has expired, but break was postponed.
+		 * We'll warn again in (elapsed * sqrt (typing_time))^2 */
+		gfloat postpone_time = (((float) elapsed_time) / dr->break_time)
+					* sqrt (dr->type_time);
+		postpone_time *= postpone_time;
+		dr->save_last_time = dr->type_time - MAX (dr->warn_time, (gint) postpone_time);
+	}
+
+	drw_timer_start (dr->timer);
+	maybe_change_state (dr);
+	update_status (dr);
+#ifdef HAVE_APP_INDICATOR
+	update_app_indicator (dr);
+#else
+	update_icon (dr);
+#endif /* HAVE_APP_INDICATOR */
+}
+
+static void
+break_window_destroy_cb (GtkWidget *window,
+			 DrWright  *dr)
+{
+	GList *l;
+
+	for (l = dr->secondary_break_windows; l; l = l->next) {
+		gtk_widget_destroy (l->data);
+	}
+
+	g_list_free (dr->secondary_break_windows);
+	dr->secondary_break_windows = NULL;
+}
+
+#ifdef HAVE_APP_INDICATOR
+static void
+init_app_indicator (DrWright *dr)
+{
+	GtkWidget *indicator_menu;
+
+	dr->indicator =
+		app_indicator_new_with_path ("typing-break-indicator",
+					     TYPING_MONITOR_ACTIVE_ICON,
+					     APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
+					     IMAGEDIR);
+	if (dr->enabled) {
+		app_indicator_set_status (dr->indicator,
+					  APP_INDICATOR_STATUS_ACTIVE);
+	} else {
+		app_indicator_set_status (dr->indicator,
+					  APP_INDICATOR_STATUS_PASSIVE);
+	}
+
+	indicator_menu = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop");
+	app_indicator_set_menu (dr->indicator, GTK_MENU (indicator_menu));
+	app_indicator_set_attention_icon (dr->indicator, TYPING_MONITOR_ATTENTION_ICON);
+
+	update_status (dr);
+	update_app_indicator (dr);
+}
+#else
+static void
+init_tray_icon (DrWright *dr)
+{
+	dr->icon = gtk_status_icon_new_from_pixbuf (dr->neutral_bar);
+
+	update_status (dr);
+	update_icon (dr);
+
+	g_signal_connect (dr->icon,
+			  "popup_menu",
+			  G_CALLBACK (popup_menu_cb),
+			  dr);
+}
+#endif /* HAVE_APP_INDICATOR */
+
+static GList *
+create_secondary_break_windows (void)
+{
+	GdkDisplay *display;
+	GdkScreen  *screen;
+	GtkWidget  *window;
+	gint        i;
+	GList      *windows = NULL;
+
+	display = gdk_display_get_default ();
+
+	for (i = 0; i < gdk_display_get_n_screens (display); i++) {
+		screen = gdk_display_get_screen (display, i);
+
+		if (screen == gdk_screen_get_default ()) {
+			/* Handled by DrwBreakWindow. */
+			continue;
+		}
+
+		window = gtk_window_new (GTK_WINDOW_POPUP);
+
+		windows = g_list_prepend (windows, window);
+
+		gtk_window_set_screen (GTK_WINDOW (window), screen);
+
+		gtk_window_set_default_size (GTK_WINDOW (window),
+					     gdk_screen_get_width (screen),
+					     gdk_screen_get_height (screen));
+
+		gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
+		drw_setup_background (GTK_WIDGET (window));
+		gtk_window_stick (GTK_WINDOW (window));
+		gtk_widget_show (window);
+	}
+
+	return windows;
+}
+
+DrWright *
+drwright_new (void)
+{
+	DrWright  *dr;
+	GtkWidget *item;
+	MateConfClient *client;
+	GtkActionGroup *action_group;
+
+	static const char ui_description[] =
+	  "<ui>"
+	  "  <popup name='Pop'>"
+	  "    <menuitem action='Preferences'/>"
+	  "    <menuitem action='About'/>"
+	  "    <separator/>"
+	  "    <menuitem action='TakeABreak'/>"
+	  "  </popup>"
+	  "</ui>";
+
+        dr = g_new0 (DrWright, 1);
+
+	client = mateconf_client_get_default ();
+
+	mateconf_client_add_dir (client,
+			      MATECONF_PATH,
+			      MATECONF_CLIENT_PRELOAD_NONE,
+			      NULL);
+
+	mateconf_client_notify_add (client, MATECONF_PATH,
+				 mateconf_notify_cb,
+				 dr,
+				 NULL,
+				 NULL);
+
+	dr->type_time = 60 * mateconf_client_get_int (
+		client, MATECONF_PATH "/type_time", NULL);
+
+	dr->warn_time = MIN (dr->type_time / 12, 60*3);
+
+	dr->break_time = 60 * mateconf_client_get_int (
+		client, MATECONF_PATH "/break_time", NULL);
+
+	dr->enabled = mateconf_client_get_bool (
+		client,
+		MATECONF_PATH "/enabled",
+		NULL);
+
+	g_object_unref (client);
+
+	if (debug) {
+		setup_debug_values (dr);
+	}
+
+	dr->ui_manager = gtk_ui_manager_new ();
+
+	action_group = gtk_action_group_new ("MenuActions");
+	gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+	gtk_action_group_add_actions (action_group, actions, G_N_ELEMENTS (actions), dr);
+	gtk_ui_manager_insert_action_group (dr->ui_manager, action_group, 0);
+	gtk_ui_manager_add_ui_from_string (dr->ui_manager, ui_description, -1, NULL);
+
+	item = gtk_ui_manager_get_widget (dr->ui_manager, "/Pop/TakeABreak");
+	gtk_widget_set_sensitive (item, dr->enabled);
+
+	dr->timer = drw_timer_new ();
+	dr->idle_timer = drw_timer_new ();
+
+	dr->state = STATE_START;
+
+	dr->monitor = drw_monitor_new ();
+
+	g_signal_connect (dr->monitor,
+			  "activity",
+			  G_CALLBACK (activity_detected_cb),
+			  dr);
+
+#ifdef HAVE_APP_INDICATOR
+	init_app_indicator (dr);
+#else
+	dr->neutral_bar = gdk_pixbuf_new_from_file (IMAGEDIR "/bar.png", NULL);
+	dr->red_bar = gdk_pixbuf_new_from_file (IMAGEDIR "/bar-red.png", NULL);
+	dr->green_bar = gdk_pixbuf_new_from_file (IMAGEDIR "/bar-green.png", NULL);
+	dr->disabled_bar = gdk_pixbuf_new_from_file (IMAGEDIR "/bar-disabled.png", NULL);
+
+	init_tray_icon (dr);
+#endif /* HAVE_APP_INDICATOR */
+
+	g_timeout_add_seconds (12,
+			       (GSourceFunc) update_status,
+			       dr);
+
+	g_timeout_add_seconds (1,
+			       (GSourceFunc) maybe_change_state,
+			       dr);
+
+	return dr;
+}