diff --git a/typing-break/ChangeLog b/typing-break/ChangeLog index 652d266f8..e1abd0e22 100644 --- a/typing-break/ChangeLog +++ b/typing-break/ChangeLog @@ -1,3 +1,18 @@ +2007-02-02 William Jon McCann + + * drw-break-window.c: (drw_break_window_class_init), + (drw_break_window_init), (drw_break_window_finalize), + (drw_break_window_dispose), (drw_break_window_new), + (postpone_sensitize_cb), (clock_timeout_cb), (postpone_cancel_cb), + (postpone_entry_key_press_event_cb), (postpone_clicked_cb): + * drw-break-window.h: + * drw-utils.c: (window_expose_event), (set_pixmap_background), + (drw_setup_background): + * drwright.c: (break_window_map_event_cb), (maybe_change_state), + (create_secondary_break_windows): + Use compositing to display the typing break window when + available. Fixes #363665. + 2007-02-02 Christian Persch * main.c: (main): Use specific string as app ID in diff --git a/typing-break/drw-break-window.c b/typing-break/drw-break-window.c index 538eed49e..f4c438041 100644 --- a/typing-break/drw-break-window.c +++ b/typing-break/drw-break-window.c @@ -32,24 +32,25 @@ #include "drw-utils.h" #include "drw-break-window.h" -struct _DrwBreakWindowPriv { +struct _DrwBreakWindowPrivate { GtkWidget *clock_label; GtkWidget *break_label; GtkWidget *image; GtkWidget *postpone_entry; GtkWidget *postpone_button; - + GTimer *timer; gint break_time; - gchar *break_text; guint clock_timeout_id; guint postpone_timeout_id; guint postpone_sensitize_id; }; +#define DRW_BREAK_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DRW_TYPE_BREAK_WINDOW, DrwBreakWindowPrivate)) + #define POSTPONE_CANCEL 30*1000 /* Signals */ @@ -74,48 +75,19 @@ static void label_size_request_cb (GtkLabel *label, GtkRequisition *requisition, gpointer user_data); +G_DEFINE_TYPE (DrwBreakWindow, drw_break_window, GTK_TYPE_WINDOW) -static GObjectClass *parent_class; static guint signals[LAST_SIGNAL]; -GType -drw_break_window_get_type (void) -{ - static GType object_type = 0; - - if (!object_type) { - static const GTypeInfo object_info = { - sizeof (DrwBreakWindowClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) drw_break_window_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (DrwBreakWindow), - 0, /* n_preallocs */ - (GInstanceInitFunc) drw_break_window_init, - }; - - object_type = g_type_register_static (GTK_TYPE_WINDOW, - "DrwBreakWindow", - &object_info, - 0); - } - - return object_type; -} - static void drw_break_window_class_init (DrwBreakWindowClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - - parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass)); - + object_class->finalize = drw_break_window_finalize; object_class->dispose = drw_break_window_dispose; - signals[POSTPONE] = + signals[POSTPONE] = g_signal_new ("postpone", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, @@ -123,8 +95,8 @@ drw_break_window_class_init (DrwBreakWindowClass *klass) NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); - - signals[DONE] = + + signals[DONE] = g_signal_new ("done", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, @@ -132,43 +104,47 @@ drw_break_window_class_init (DrwBreakWindowClass *klass) NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); + + g_type_class_add_private (klass, sizeof (DrwBreakWindowPrivate)); } static void drw_break_window_init (DrwBreakWindow *window) { - DrwBreakWindowPriv *priv; - GtkWidget *vbox; - GtkWidget *hbox; - GtkWidget *align; - GtkWidget *monitor_box; - gchar *str; - GtkWidget *outer_vbox; - GtkWidget *button_box; - gboolean allow_postpone; + DrwBreakWindowPrivate *priv; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *align; + GtkWidget *monitor_box; + gchar *str; + GtkWidget *outer_vbox; + GtkWidget *button_box; + gboolean allow_postpone; - gint root_monitor = 0; - GdkScreen *screen = NULL; - GdkRectangle monitor; - gint right_padding; - gint bottom_padding; - GConfClient *client; + gint root_monitor = 0; + GdkScreen *screen = NULL; + GdkRectangle monitor; + gint right_padding; + gint bottom_padding; + GConfClient *client; - priv = g_new0 (DrwBreakWindowPriv, 1); - window->priv = priv; + priv = DRW_BREAK_WINDOW_GET_PRIVATE (window); + window->priv = priv; - client = gconf_client_get_default(); + client = gconf_client_get_default (); priv->break_time = 60 * gconf_client_get_int (client, GCONF_PATH "/break_time", NULL); - + allow_postpone = gconf_client_get_bool (client, GCONF_PATH "/allow_postpone", NULL); g_object_unref (client); - GTK_WINDOW (window)->type = GTK_WINDOW_POPUP; + + gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); + gtk_window_fullscreen (GTK_WINDOW (window)); screen = gdk_screen_get_default (); gdk_screen_get_monitor_geometry (screen, root_monitor, &monitor); @@ -176,25 +152,24 @@ drw_break_window_init (DrwBreakWindow *window) 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); - gtk_widget_realize (GTK_WIDGET (window)); + gtk_window_set_decorated (GTK_WINDOW (window), FALSE); + gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE); drw_setup_background (GTK_WIDGET (window)); - + align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_widget_show (align); outer_vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (outer_vbox); - + right_padding = gdk_screen_get_width (screen) - monitor.width - monitor.x; bottom_padding = gdk_screen_get_height (screen) - monitor.height - monitor.y; monitor_box = gtk_alignment_new (0.5, 0.5, 1, 1); - gtk_alignment_set_padding (GTK_ALIGNMENT (monitor_box), + gtk_alignment_set_padding (GTK_ALIGNMENT (monitor_box), monitor.y, - bottom_padding, + bottom_padding, monitor.x, right_padding); gtk_widget_show (monitor_box); @@ -207,10 +182,10 @@ drw_break_window_init (DrwBreakWindow *window) if (allow_postpone) { button_box = gtk_hbox_new (FALSE, 0); gtk_widget_show (button_box); - + gtk_container_set_border_width (GTK_CONTAINER (button_box), 12); - - priv->postpone_button = gtk_button_new_with_mnemonic (_("_Postpone break")); + + priv->postpone_button = gtk_button_new_with_mnemonic (_("_Postpone Break")); gtk_widget_show (priv->postpone_button); gtk_widget_set_sensitive (priv->postpone_button, FALSE); @@ -218,31 +193,40 @@ drw_break_window_init (DrwBreakWindow *window) if (priv->postpone_sensitize_id) { g_source_remove (priv->postpone_sensitize_id); } - + priv->postpone_sensitize_id = g_timeout_add (500, (GSourceFunc) postpone_sensitize_cb, window); - + g_signal_connect (priv->postpone_button, "clicked", G_CALLBACK (postpone_clicked_cb), window); - + gtk_box_pack_end (GTK_BOX (button_box), priv->postpone_button, FALSE, TRUE, 0); priv->postpone_entry = gtk_entry_new (); gtk_entry_set_has_frame (GTK_ENTRY (priv->postpone_entry), FALSE); gtk_box_pack_end (GTK_BOX (button_box), priv->postpone_entry, FALSE, TRUE, 4); - + gtk_box_pack_end (GTK_BOX (outer_vbox), button_box, FALSE, TRUE, 0); } - + vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); - + gtk_container_add (GTK_CONTAINER (align), vbox); + hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (hbox); + gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0); + + priv->image = gtk_image_new_from_file (IMAGEDIR "/stop.png"); + gtk_misc_set_alignment (GTK_MISC (priv->image), 1, 0.5); + gtk_widget_show (priv->image); + gtk_box_pack_start (GTK_BOX (hbox), priv->image, TRUE, TRUE, 8); + priv->break_label = gtk_label_new (NULL); gtk_widget_show (priv->break_label); @@ -260,40 +244,32 @@ drw_break_window_init (DrwBreakWindow *window) _("Take a break!")); gtk_label_set_markup (GTK_LABEL (priv->break_label), str); g_free (str); - - gtk_box_pack_start (GTK_BOX (vbox), priv->break_label, FALSE, FALSE, 12); - hbox = gtk_hbox_new (FALSE, 0); - gtk_widget_show (hbox); - gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0); - - priv->image = gtk_image_new_from_file (IMAGEDIR "/stop.png"); - gtk_misc_set_alignment (GTK_MISC (priv->image), 1, 0.5); - gtk_widget_show (priv->image); - gtk_box_pack_start (GTK_BOX (hbox), priv->image, TRUE, TRUE, 8); - + gtk_box_pack_start (GTK_BOX (hbox), priv->break_label, FALSE, FALSE, 12); + + priv->clock_label = gtk_label_new (NULL); - gtk_misc_set_alignment (GTK_MISC (priv->clock_label), 0, 0.5); + gtk_misc_set_alignment (GTK_MISC (priv->clock_label), 0.5, 0.5); gtk_widget_show (priv->clock_label); - gtk_box_pack_start (GTK_BOX (hbox), priv->clock_label, TRUE, TRUE, 8); + gtk_box_pack_start (GTK_BOX (vbox), priv->clock_label, TRUE, TRUE, 8); g_signal_connect (priv->clock_label, "expose_event", G_CALLBACK (label_expose_event_cb), NULL); - + g_signal_connect_after (priv->clock_label, "size_request", G_CALLBACK (label_size_request_cb), NULL); gtk_window_stick (GTK_WINDOW (window)); - + priv->timer = g_timer_new (); - + /* Make sure we have a valid time label from the start. */ clock_timeout_cb (window); - + priv->clock_timeout_id = g_timeout_add (1000, (GSourceFunc) clock_timeout_cb, window); @@ -302,10 +278,10 @@ drw_break_window_init (DrwBreakWindow *window) static void drw_break_window_finalize (GObject *object) { - DrwBreakWindow *window = DRW_BREAK_WINDOW (object); - DrwBreakWindowPriv *priv; - - priv = window->priv; + DrwBreakWindow *window = DRW_BREAK_WINDOW (object); + DrwBreakWindowPrivate *priv; + + priv = window->priv; if (priv->clock_timeout_id != 0) { g_source_remove (priv->clock_timeout_id); @@ -319,21 +295,20 @@ drw_break_window_finalize (GObject *object) g_source_remove (priv->postpone_sensitize_id); } - g_free (priv); window->priv = NULL; - if (G_OBJECT_CLASS (parent_class)->finalize) { - (* G_OBJECT_CLASS (parent_class)->finalize) (object); + if (G_OBJECT_CLASS (drw_break_window_parent_class)->finalize) { + (* G_OBJECT_CLASS (drw_break_window_parent_class)->finalize) (object); } } static void drw_break_window_dispose (GObject *object) { - DrwBreakWindow *window = DRW_BREAK_WINDOW (object); - DrwBreakWindowPriv *priv; - - priv = window->priv; + DrwBreakWindow *window = DRW_BREAK_WINDOW (object); + DrwBreakWindowPrivate *priv; + + priv = window->priv; if (priv->timer) { g_timer_destroy (priv->timer); @@ -353,22 +328,31 @@ drw_break_window_dispose (GObject *object) if (priv->postpone_sensitize_id != 0) { g_source_remove (priv->postpone_sensitize_id); } - - if (G_OBJECT_CLASS (parent_class)->dispose) { - (* G_OBJECT_CLASS (parent_class)->dispose) (object); - } + + if (G_OBJECT_CLASS (drw_break_window_parent_class)->dispose) { + (* G_OBJECT_CLASS (drw_break_window_parent_class)->dispose) (object); + } } GtkWidget * drw_break_window_new (void) { - return g_object_new (DRW_TYPE_BREAK_WINDOW, NULL); + GObject *object; + + object = g_object_new (DRW_TYPE_BREAK_WINDOW, + "type", GTK_WINDOW_POPUP, + "skip-taskbar-hint", TRUE, + "skip-pager-hint", TRUE, + "focus-on-map", TRUE, + NULL); + + return GTK_WIDGET (object); } static gboolean postpone_sensitize_cb (DrwBreakWindow *window) { - DrwBreakWindowPriv *priv; + DrwBreakWindowPrivate *priv; priv = window->priv; @@ -381,15 +365,15 @@ postpone_sensitize_cb (DrwBreakWindow *window) static gboolean clock_timeout_cb (DrwBreakWindow *window) { - DrwBreakWindowPriv *priv; - gchar *txt; - gint minutes; - gint seconds; + DrwBreakWindowPrivate *priv; + gchar *txt; + gint minutes; + gint seconds; g_return_val_if_fail (DRW_IS_BREAK_WINDOW (window), FALSE); priv = window->priv; - + seconds = 1 + priv->break_time - g_timer_elapsed (priv->timer, NULL); seconds = MAX (0, seconds); @@ -431,7 +415,7 @@ postpone_entry_activate_cb (GtkWidget *entry, GCONF_PATH "/unlock_phrase", NULL); g_object_unref (client); - + if (!strcmp (str, phrase)) { g_signal_emit (window, signals[POSTPONE], 0, NULL); g_free (phrase); @@ -466,7 +450,7 @@ grab_on_window (GdkWindow *window, static gboolean postpone_cancel_cb (DrwBreakWindow *window) { - DrwBreakWindowPriv *priv; + DrwBreakWindowPrivate *priv; priv = window->priv; @@ -474,16 +458,16 @@ postpone_cancel_cb (DrwBreakWindow *window) gtk_widget_hide (priv->postpone_entry); priv->postpone_timeout_id = 0; - + return FALSE; } static gboolean postpone_entry_key_press_event_cb (GtkEntry *entry, - GdkEventKey *event, - DrwBreakWindow *window) + GdkEventKey *event, + DrwBreakWindow *window) { - DrwBreakWindowPriv *priv; + DrwBreakWindowPrivate *priv; priv = window->priv; @@ -491,14 +475,14 @@ postpone_entry_key_press_event_cb (GtkEntry *entry, if (priv->postpone_timeout_id) { g_source_remove (priv->postpone_timeout_id); } - + postpone_cancel_cb (window); return TRUE; } - + g_source_remove (priv->postpone_timeout_id); - + priv->postpone_timeout_id = g_timeout_add (POSTPONE_CANCEL, (GSourceFunc) postpone_cancel_cb, window); return FALSE; @@ -506,12 +490,12 @@ postpone_entry_key_press_event_cb (GtkEntry *entry, static void postpone_clicked_cb (GtkWidget *button, - GtkWidget *window) + GtkWidget *window) { - DrwBreakWindow *bw = DRW_BREAK_WINDOW (window); - DrwBreakWindowPriv *priv = bw->priv; - gchar *phrase; - + DrwBreakWindow *bw = DRW_BREAK_WINDOW (window); + DrwBreakWindowPrivate *priv = bw->priv; + gchar *phrase; + /* Disable the phrase for now. */ phrase = NULL; /*gconf_client_get_string (gconf_client_get_default (), GCONF_PATH "/unlock_phrase", @@ -526,13 +510,13 @@ postpone_clicked_cb (GtkWidget *button, gtk_widget_activate (priv->postpone_entry); return; } - + gtk_widget_show (priv->postpone_entry); priv->postpone_timeout_id = g_timeout_add (POSTPONE_CANCEL, (GSourceFunc) postpone_cancel_cb, bw); - + grab_on_window (priv->postpone_entry->window, gtk_get_current_event_time ()); - + gtk_widget_grab_focus (priv->postpone_entry); g_signal_connect (priv->postpone_entry, @@ -555,28 +539,28 @@ get_layout_location (GtkLabel *label, GtkWidget *widget; gfloat xalign; gint x, y; - + misc = GTK_MISC (label); widget = GTK_WIDGET (label); - + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) { xalign = misc->xalign; } else { xalign = 1.0 - misc->xalign; } - + x = floor (widget->allocation.x + (int)misc->xpad + ((widget->allocation.width - widget->requisition.width - 1) * xalign) + 0.5); - - y = floor (widget->allocation.y + (int)misc->ypad + + y = floor (widget->allocation.y + (int)misc->ypad + ((widget->allocation.height - widget->requisition.height - 1) * misc->yalign) + 0.5); - + if (xp) { *xp = x; } - + if (yp) { *yp = y; } @@ -612,7 +596,7 @@ label_expose_event_cb (GtkLabel *label, &color, NULL); g_object_unref (gc); - + gtk_paint_layout (widget->style, widget->window, GTK_WIDGET_STATE (widget), diff --git a/typing-break/drw-break-window.h b/typing-break/drw-break-window.h index d3c19718d..18b131724 100644 --- a/typing-break/drw-break-window.h +++ b/typing-break/drw-break-window.h @@ -24,6 +24,8 @@ #include +G_BEGIN_DECLS + #define DRW_TYPE_BREAK_WINDOW (drw_break_window_get_type ()) #define DRW_BREAK_WINDOW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), DRW_TYPE_BREAK_WINDOW, DrwBreakWindow)) #define DRW_BREAK_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), DRW_TYPE_BREAK_WINDOW, DrwBreakWindowClass)) @@ -31,14 +33,14 @@ #define DRW_IS_BREAK_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), DRW_TYPE_BREAK_WINDOW)) #define DRW_BREAK_WINDOW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), DRW_TYPE_BREAK_WINDOW, DrwBreakWindowClass)) -typedef struct _DrwBreakWindow DrwBreakWindow; -typedef struct _DrwBreakWindowClass DrwBreakWindowClass; -typedef struct _DrwBreakWindowPriv DrwBreakWindowPriv; +typedef struct _DrwBreakWindow DrwBreakWindow; +typedef struct _DrwBreakWindowClass DrwBreakWindowClass; +typedef struct _DrwBreakWindowPrivate DrwBreakWindowPrivate; struct _DrwBreakWindow { - GtkWindow parent; + GtkWindow parent; - DrwBreakWindowPriv *priv; + DrwBreakWindowPrivate *priv; }; struct _DrwBreakWindowClass { @@ -48,5 +50,6 @@ struct _DrwBreakWindowClass { GType drw_break_window_get_type (void) G_GNUC_CONST; GtkWidget * drw_break_window_new (void); +G_END_DECLS #endif /* __DRW_BREAK_WINDOW_H__ */ diff --git a/typing-break/drw-utils.c b/typing-break/drw-utils.c index 10db6aee7..2eac50201 100644 --- a/typing-break/drw-utils.c +++ b/typing-break/drw-utils.c @@ -89,8 +89,60 @@ create_tile_pixbuf (GdkPixbuf *dest_pixbuf, return dest_pixbuf; } -void -drw_setup_background (GtkWidget *window) +static gboolean +window_expose_event (GtkWidget *widget, + GdkEventExpose *event, + gpointer data) +{ + cairo_t *context; + cairo_t *cr; + cairo_surface_t *surface; + int width; + int height; + + context = gdk_cairo_create (widget->window); + + cairo_set_operator (context, CAIRO_OPERATOR_SOURCE); + gtk_window_get_size (GTK_WINDOW (widget), &width, &height); + + surface = cairo_surface_create_similar (cairo_get_target (context), + CAIRO_CONTENT_COLOR_ALPHA, + width, + height); + + if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) { + goto done; + } + + cr = cairo_create (surface); + if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { + goto done; + } + cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + cairo_paint (cr); + + /* draw a box */ + cairo_rectangle (cr, 0, 0, width, height); + cairo_set_source_rgba (cr, 0.2, 0.2, 0.2, 0.5); + cairo_fill (cr); + + cairo_destroy (cr); + + cairo_set_source_surface (context, surface, 0, 0); + cairo_paint (context); + + done: + if (surface != NULL) { + cairo_surface_destroy (surface); + } + cairo_destroy (context); + + return FALSE; +} + +static void +set_pixmap_background (GtkWidget *window) { GdkScreen *screen; GdkPixbuf *tmp_pixbuf, *pixbuf, *tile_pixbuf; @@ -99,11 +151,12 @@ drw_setup_background (GtkWidget *window) GdkColor color; gint width, height; - screen = gtk_widget_get_screen (window); + gtk_widget_realize (window); + screen = gtk_widget_get_screen (window); width = gdk_screen_get_width (screen); height = gdk_screen_get_height (screen); - + tmp_pixbuf = gdk_pixbuf_get_from_drawable (NULL, gdk_screen_get_root_window (screen), gdk_screen_get_system_colormap (screen), @@ -112,18 +165,18 @@ drw_setup_background (GtkWidget *window) 0, 0, width, height); - + pixbuf = gdk_pixbuf_new_from_file (IMAGEDIR "/ocean-stripes.png", NULL); rect.x = 0; rect.y = 0; rect.width = width; rect.height = height; - + color.red = 0; color.blue = 0; color.green = 0; - + tile_pixbuf = create_tile_pixbuf (NULL, pixbuf, &rect, @@ -171,3 +224,27 @@ drw_setup_background (GtkWidget *window) g_object_unref (pixmap); } +void +drw_setup_background (GtkWidget *window) +{ + GdkScreen *screen; + GdkColormap *colormap; + gboolean is_composited; + + screen = gtk_widget_get_screen (window); + colormap = gdk_screen_get_rgba_colormap (screen); + + if (colormap != NULL && gdk_screen_is_composited (screen)) { + gtk_widget_set_colormap (GTK_WIDGET (window), colormap); + is_composited = TRUE; + } else { + is_composited = FALSE; + } + + if (is_composited) { + g_signal_connect (window, "expose-event", G_CALLBACK (window_expose_event), window); + } else { + set_pixmap_background (window); + } +} + diff --git a/typing-break/drwright.c b/typing-break/drwright.c index fdbd087b6..74e9cc4bd 100644 --- a/typing-break/drwright.c +++ b/typing-break/drwright.c @@ -291,7 +291,7 @@ 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; @@ -300,6 +300,16 @@ grab_keyboard_on_window (GdkWindow *window, return FALSE; } +static gboolean +break_window_map_event_cb (GtkWidget *widget, + GdkEvent *event, + DrWright *dr) +{ + grab_keyboard_on_window (dr->break_window->window, gtk_get_current_event_time ()); + + return FALSE; +} + static gboolean maybe_change_state (DrWright *dr) { @@ -393,7 +403,7 @@ maybe_change_state (DrWright *dr) dr->state = STATE_BREAK; break; } - + stop_blinking (dr); gtk_status_icon_set_from_pixbuf (dr->icon, dr->red_bar); @@ -402,6 +412,10 @@ maybe_change_state (DrWright *dr) 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), @@ -421,8 +435,6 @@ maybe_change_state (DrWright *dr) gtk_widget_show (dr->break_window); - grab_keyboard_on_window (dr->break_window->window, gtk_get_current_event_time ()); - dr->state = STATE_BREAK; break; @@ -704,33 +716,31 @@ create_secondary_break_windows (void) 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); - gtk_widget_realize (GTK_WIDGET (window)); - drw_setup_background (GTK_WIDGET (window)); gtk_window_stick (GTK_WINDOW (window)); gtk_widget_show (window); } - + return windows; } @@ -744,7 +754,7 @@ drwright_new (void) dr = g_new0 (DrWright, 1); client = gconf_client_get_default (); - + gconf_client_add_dir (client, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE,