applications/gnome-control-center
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use compositing to display the typing break window when available. Fixes

Browse source 
2007-02-02  William Jon McCann  <mccann@jhu.edu>

	* 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.


svn path=/trunk/; revision=7233
This commit is contained in:
William Jon McCann 2007-02-03 00:42:23 +00:00 • committed by William Jon McCann
parent 09076c4e27
commit f600be796a
5 changed files with 253 additions and 164 deletions
Download patch file Download diff file Expand all files Collapse all files

15
typing-break/ChangeLog
View file

@ -1,3 +1,18 @@
2007-02-02 William Jon McCann <mccann@jhu.edu>
* 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 <chpe@svn.gnome.org>
* main.c: (main): Use specific string as app ID in

258
typing-break/drw-break-window.c
View file

@ -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),

13
typing-break/drw-break-window.h
View file

@ -24,6 +24,8 @@
#include <gtk/gtkwindow.h>
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__ */

91
typing-break/drw-utils.c
View file

@ -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);
}
}

40
typing-break/drwright.c
View file

@ -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,