?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
updated on Thu Jan 12 20:00:29 UTC 2012
[aur-mirror.git] / gtk2-ubuntu / 044_grips.patch
blobf3a35f310f1c33859ee3c59c64d69f8f5fcb7c63
1 ## Description: add some description
2 ## Origin/Author: add some origin or author
3 ## Bug: bug URL
4 Index: gtk+-2.24.4/gtk/gtk.symbols
5 ===================================================================
6 --- gtk+-2.24.4.orig/gtk/gtk.symbols 2011-04-04 10:57:59.396596969 +1000
7 +++ gtk+-2.24.4/gtk/gtk.symbols 2011-04-04 10:58:00.236596968 +1000
8 @@ -5381,6 +5381,7 @@
9 gtk_window_get_modal
10 gtk_window_get_position
11 gtk_window_get_resizable
12 +gtk_window_get_resize_grip_area
13 gtk_window_get_role
14 gtk_window_get_screen
15 gtk_window_get_size
16 @@ -5416,6 +5417,7 @@
17 gtk_window_remove_mnemonic
18 gtk_window_reshow_with_initial_size
19 gtk_window_resize
20 +gtk_window_resize_grip_is_visible
21 gtk_window_set_accept_focus
22 gtk_window_set_auto_startup_notification
23 gtk_window_set_decorated
24 @@ -5443,6 +5445,8 @@
25 gtk_window_get_has_frame
26 gtk_window_set_has_frame
27 #endif
28 +gtk_window_get_has_resize_grip
29 +gtk_window_set_has_resize_grip
30 gtk_window_set_icon
31 #ifndef _WIN64
32 gtk_window_set_icon_from_file PRIVATE
33 Index: gtk+-2.24.4/gtk/gtkalias.h
34 ===================================================================
35 --- gtk+-2.24.4.orig/gtk/gtkalias.h 2011-04-02 08:43:12.000000000 +1100
36 +++ gtk+-2.24.4/gtk/gtkalias.h 2011-04-04 10:58:00.236596968 +1000
37 @@ -12827,6 +12827,9 @@
38 extern __typeof (gtk_window_get_group) IA__gtk_window_get_group __attribute((visibility("hidden")));
39 #define gtk_window_get_group IA__gtk_window_get_group
40
41 +extern __typeof (gtk_window_get_has_resize_grip) IA__gtk_window_get_has_resize_grip __attribute((visibility("hidden")));
42 +#define gtk_window_get_has_resize_grip IA__gtk_window_get_has_resize_grip
43 +
44 extern __typeof (gtk_window_get_icon) IA__gtk_window_get_icon __attribute((visibility("hidden")));
45 #define gtk_window_get_icon IA__gtk_window_get_icon
46
47 @@ -12851,6 +12854,9 @@
48 extern __typeof (gtk_window_get_resizable) IA__gtk_window_get_resizable __attribute((visibility("hidden")));
49 #define gtk_window_get_resizable IA__gtk_window_get_resizable
50
51 +extern __typeof (gtk_window_get_resize_grip_area) IA__gtk_window_get_resize_grip_area __attribute((visibility("hidden")));
52 +#define gtk_window_get_resize_grip_area IA__gtk_window_get_resize_grip_area
53 +
54 extern __typeof (gtk_window_get_role) IA__gtk_window_get_role __attribute((visibility("hidden")));
55 #define gtk_window_get_role IA__gtk_window_get_role
56
57 @@ -12956,6 +12962,9 @@
58 extern __typeof (gtk_window_resize) IA__gtk_window_resize __attribute((visibility("hidden")));
59 #define gtk_window_resize IA__gtk_window_resize
60
61 +extern __typeof (gtk_window_resize_grip_is_visible) IA__gtk_window_resize_grip_is_visible __attribute((visibility("hidden")));
62 +#define gtk_window_resize_grip_is_visible IA__gtk_window_resize_grip_is_visible
63 +
64 extern __typeof (gtk_window_set_accept_focus) IA__gtk_window_set_accept_focus __attribute((visibility("hidden")));
65 #define gtk_window_set_accept_focus IA__gtk_window_set_accept_focus
66
67 Index: gtk+-2.24.4/gtk/gtkaliasdef.c
68 ===================================================================
69 --- gtk+-2.24.4.orig/gtk/gtkaliasdef.c 2011-04-02 08:43:10.000000000 +1100
70 +++ gtk+-2.24.4/gtk/gtkaliasdef.c 2011-04-04 10:58:00.246596968 +1000
71 @@ -12830,6 +12830,9 @@
72 #undef gtk_window_get_group
73 extern __typeof (gtk_window_get_group) gtk_window_get_group __attribute((alias("IA__gtk_window_get_group"), visibility("default")));
74
75 +#undef gtk_window_get_has_resize_grip
76 +extern __typeof (gtk_window_get_has_resize_grip) gtk_window_get_has_resize_grip __attribute((alias("IA__gtk_window_get_has_resize_grip"), visibility("default")));
77 +
78 #undef gtk_window_get_icon
79 extern __typeof (gtk_window_get_icon) gtk_window_get_icon __attribute((alias("IA__gtk_window_get_icon"), visibility("default")));
80
81 @@ -12854,6 +12857,9 @@
82 #undef gtk_window_get_resizable
83 extern __typeof (gtk_window_get_resizable) gtk_window_get_resizable __attribute((alias("IA__gtk_window_get_resizable"), visibility("default")));
84
85 +#undef gtk_window_get_resize_grip_area
86 +extern __typeof (gtk_window_get_resize_grip_area) gtk_window_get_resize_grip_area __attribute((alias("IA__gtk_window_get_resize_grip_area"), visibility("default")));
87 +
88 #undef gtk_window_get_role
89 extern __typeof (gtk_window_get_role) gtk_window_get_role __attribute((alias("IA__gtk_window_get_role"), visibility("default")));
90
91 @@ -12959,6 +12965,9 @@
92 #undef gtk_window_resize
93 extern __typeof (gtk_window_resize) gtk_window_resize __attribute((alias("IA__gtk_window_resize"), visibility("default")));
94
95 +#undef gtk_window_resize_grip_is_visible
96 +extern __typeof (gtk_window_resize_grip_is_visible) gtk_window_resize_grip_is_visible __attribute((alias("IA__gtk_window_resize_grip_is_visible"), visibility("default")));
97 +
98 #undef gtk_window_set_accept_focus
99 extern __typeof (gtk_window_set_accept_focus) gtk_window_set_accept_focus __attribute((alias("IA__gtk_window_set_accept_focus"), visibility("default")));
100
101 Index: gtk+-2.24.4/gtk/gtkassistant.c
102 ===================================================================
103 --- gtk+-2.24.4.orig/gtk/gtkassistant.c 2011-02-20 01:31:37.000000000 +1100
104 +++ gtk+-2.24.4/gtk/gtkassistant.c 2011-04-04 10:58:00.246596968 +1000
105 @@ -1413,6 +1413,9 @@
106 {
107 container = GTK_CONTAINER (widget);
108
109 + if (GTK_WIDGET_CLASS (gtk_assistant_parent_class)->expose_event)
110 + GTK_WIDGET_CLASS (gtk_assistant_parent_class)->expose_event (widget, event);
111 +
112 assistant_paint_colored_box (widget);
113
114 gtk_container_propagate_expose (container, priv->header_image, event);
115 Index: gtk+-2.24.4/gtk/gtkrange.c
116 ===================================================================
117 --- gtk+-2.24.4.orig/gtk/gtkrange.c 2011-03-18 11:14:36.000000000 +1100
118 +++ gtk+-2.24.4/gtk/gtkrange.c 2011-04-04 10:58:00.246596968 +1000
119 @@ -39,6 +39,7 @@
120 #include "gtkrange.h"
121 #include "gtkscale.h"
122 #include "gtkscrollbar.h"
123 +#include "gtkwindow.h"
124 #include "gtkprivate.h"
125 #include "gtkintl.h"
126 #include "gtkalias.h"
127 @@ -149,6 +150,8 @@
128 GtkRequisition *requisition);
129 static void gtk_range_size_allocate (GtkWidget *widget,
130 GtkAllocation *allocation);
131 +static void gtk_range_hierarchy_changed (GtkWidget *widget,
132 + GtkWidget *previous_toplevel);
133 static void gtk_range_realize (GtkWidget *widget);
134 static void gtk_range_unrealize (GtkWidget *widget);
135 static void gtk_range_map (GtkWidget *widget);
136 @@ -179,6 +182,8 @@
137 gint mouse_x,
138 gint mouse_y);
139 static void stop_scrolling (GtkRange *range);
140 +static gboolean modify_allocation_for_window_grip (GtkWidget *widget,
141 + GtkAllocation *allocation);
142
143 /* Range methods */
144
145 @@ -257,8 +262,9 @@
146
147 widget_class->size_request = gtk_range_size_request;
148 widget_class->size_allocate = gtk_range_size_allocate;
149 + widget_class->hierarchy_changed = gtk_range_hierarchy_changed;
150 widget_class->realize = gtk_range_realize;
151 - widget_class->unrealize = gtk_range_unrealize;
152 + widget_class->unrealize = gtk_range_unrealize;
153 widget_class->map = gtk_range_map;
154 widget_class->unmap = gtk_range_unmap;
155 widget_class->expose_event = gtk_range_expose;
156 @@ -1534,6 +1540,67 @@
157 requisition->height = range_rect.height + border.top + border.bottom;
158 }
159
160 +static gboolean
161 +modify_allocation_for_window_grip (GtkWidget *widget,
162 + GtkAllocation *allocation)
163 +{
164 + GtkRange *range = GTK_RANGE (widget);
165 + GtkWidget *window;
166 + GdkRectangle grip_rect;
167 + GdkRectangle translated_rect;
168 + gint border_width;
169 + gint x;
170 + gint y;
171 +
172 + window = gtk_widget_get_toplevel (widget);
173 + if (!GTK_IS_WINDOW (window))
174 + return FALSE;
175 +
176 + if (!gtk_window_resize_grip_is_visible (GTK_WINDOW (window)))
177 + return FALSE;
178 +
179 + /* Get the area of the window's corner grip */
180 + gtk_window_get_resize_grip_area (GTK_WINDOW (window), &grip_rect);
181 +
182 + x = 0;
183 + y = 0;
184 +
185 + /* Translate the stepper's area into window coords */
186 + if (gtk_widget_translate_coordinates (gtk_widget_get_parent (widget),
187 + window,
188 + allocation->x,
189 + allocation->y,
190 + &x,
191 + &y))
192 + {
193 + translated_rect.x = x;
194 + translated_rect.y = y;
195 + translated_rect.width = allocation->width;
196 + translated_rect.height = allocation->height;
197 +
198 + border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
199 +
200 + /* If the stepper button intersects the window resize grip.. */
201 + if (gdk_rectangle_intersect (&grip_rect, &translated_rect, NULL))
202 + {
203 + if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
204 + {
205 + allocation->width -= (grip_rect.width - border_width);
206 + if (gtk_widget_get_direction (window) == GTK_TEXT_DIR_RTL)
207 + allocation->x += grip_rect.width;
208 + }
209 + else
210 + {
211 + allocation->height -= (grip_rect.height - border_width);
212 + }
213 +
214 + return TRUE;
215 + }
216 + }
217 +
218 + return FALSE;
219 +}
220 +
221 static void
222 gtk_range_size_allocate (GtkWidget *widget,
223 GtkAllocation *allocation)
224 @@ -1542,6 +1609,7 @@
225
226 range = GTK_RANGE (widget);
227
228 + modify_allocation_for_window_grip (widget, allocation);
229 widget->allocation = *allocation;
230
231 range->layout->recalc_marks = TRUE;
232 @@ -1558,11 +1626,36 @@
233 }
234
235 static void
236 +resize_grip_visible_changed (GObject *object,
237 + GParamSpec *pspec,
238 + gpointer user_data)
239 +{
240 + gtk_widget_queue_resize (GTK_WIDGET (user_data));
241 +}
242 +
243 +static void
244 +gtk_range_hierarchy_changed (GtkWidget *widget,
245 + GtkWidget *previous_toplevel)
246 +{
247 + GtkWidget *window;
248 +
249 + if (previous_toplevel)
250 + g_signal_handlers_disconnect_by_func (previous_toplevel,
251 + G_CALLBACK (resize_grip_visible_changed),
252 + widget);
253 + window = gtk_widget_get_toplevel (widget);
254 + if (GTK_IS_WINDOW (window))
255 + g_signal_connect (window, "notify::resize-grip-visible",
256 + G_CALLBACK (resize_grip_visible_changed), widget);
257 +}
258 +
259 +static void
260 gtk_range_realize (GtkWidget *widget)
261 {
262 GtkRange *range;
263 GdkWindowAttr attributes;
264 - gint attributes_mask;
265 + gint attributes_mask;
266 + GtkAllocation allocation;
267
268 range = GTK_RANGE (widget);
269
270 @@ -1572,7 +1665,11 @@
271
272 widget->window = gtk_widget_get_parent_window (widget);
273 g_object_ref (widget->window);
274 -
275 +
276 + gtk_widget_get_allocation (widget, &allocation);
277 + if (modify_allocation_for_window_grip (widget, &allocation))
278 + gtk_widget_set_allocation (widget, &allocation);
279 +
280 attributes.window_type = GDK_WINDOW_CHILD;
281 attributes.x = widget->allocation.x;
282 attributes.y = widget->allocation.y;
283 Index: gtk+-2.24.4/gtk/gtkstatusbar.c
284 ===================================================================
285 --- gtk+-2.24.4.orig/gtk/gtkstatusbar.c 2011-02-20 01:31:37.000000000 +1100
286 +++ gtk+-2.24.4/gtk/gtkstatusbar.c 2011-04-04 10:58:00.246596968 +1000
287 @@ -72,20 +72,8 @@
288 static void gtk_statusbar_unrealize (GtkWidget *widget);
289 static void gtk_statusbar_map (GtkWidget *widget);
290 static void gtk_statusbar_unmap (GtkWidget *widget);
291 -static gboolean gtk_statusbar_button_press (GtkWidget *widget,
292 - GdkEventButton *event);
293 -static gboolean gtk_statusbar_expose_event (GtkWidget *widget,
294 - GdkEventExpose *event);
295 -static void gtk_statusbar_size_request (GtkWidget *widget,
296 - GtkRequisition *requisition);
297 static void gtk_statusbar_size_allocate (GtkWidget *widget,
298 GtkAllocation *allocation);
299 -static void gtk_statusbar_direction_changed (GtkWidget *widget,
300 - GtkTextDirection prev_dir);
301 -static void gtk_statusbar_state_changed (GtkWidget *widget,
302 - GtkStateType previous_state);
303 -static void gtk_statusbar_create_window (GtkStatusbar *statusbar);
304 -static void gtk_statusbar_destroy_window (GtkStatusbar *statusbar);
305 static void gtk_statusbar_get_property (GObject *object,
306 guint prop_id,
307 GValue *value,
308 @@ -125,13 +113,8 @@
309 widget_class->unrealize = gtk_statusbar_unrealize;
310 widget_class->map = gtk_statusbar_map;
311 widget_class->unmap = gtk_statusbar_unmap;
312 - widget_class->button_press_event = gtk_statusbar_button_press;
313 - widget_class->expose_event = gtk_statusbar_expose_event;
314 - widget_class->size_request = gtk_statusbar_size_request;
315 widget_class->size_allocate = gtk_statusbar_size_allocate;
316 - widget_class->direction_changed = gtk_statusbar_direction_changed;
317 - widget_class->state_changed = gtk_statusbar_state_changed;
318 -
319 +
320 class->text_pushed = gtk_statusbar_update;
321 class->text_popped = gtk_statusbar_update;
322
323 @@ -550,21 +533,7 @@
324 if (setting != statusbar->has_resize_grip)
325 {
326 statusbar->has_resize_grip = setting;
327 - gtk_widget_queue_resize (statusbar->label);
328 - gtk_widget_queue_draw (GTK_WIDGET (statusbar));
329
330 - if (gtk_widget_get_realized (GTK_WIDGET (statusbar)))
331 - {
332 - if (statusbar->has_resize_grip && statusbar->grip_window == NULL)
333 - {
334 - gtk_statusbar_create_window (statusbar);
335 - if (gtk_widget_get_mapped (GTK_WIDGET (statusbar)))
336 - gdk_window_show (statusbar->grip_window);
337 - }
338 - else if (!statusbar->has_resize_grip && statusbar->grip_window != NULL)
339 - gtk_statusbar_destroy_window (statusbar);
340 - }
341 -
342 g_object_notify (G_OBJECT (statusbar), "has-resize-grip");
343 }
344 }
345 @@ -678,123 +647,6 @@
346 }
347
348 static void
349 -get_grip_rect (GtkStatusbar *statusbar,
350 - GdkRectangle *rect)
351 -{
352 - GtkWidget *widget;
353 - gint w, h;
354 -
355 - widget = GTK_WIDGET (statusbar);
356 -
357 - /* These are in effect the max/default size of the grip. */
358 - w = 18;
359 - h = 18;
360 -
361 - if (w > widget->allocation.width)
362 - w = widget->allocation.width;
363 -
364 - if (h > widget->allocation.height - widget->style->ythickness)
365 - h = widget->allocation.height - widget->style->ythickness;
366 -
367 - rect->width = w;
368 - rect->height = h;
369 - rect->y = widget->allocation.y + widget->allocation.height - h;
370 -
371 - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
372 - rect->x = widget->allocation.x + widget->allocation.width - w;
373 - else
374 - rect->x = widget->allocation.x + widget->style->xthickness;
375 -}
376 -
377 -static void
378 -set_grip_cursor (GtkStatusbar *statusbar)
379 -{
380 - if (statusbar->has_resize_grip && statusbar->grip_window != NULL)
381 - {
382 - GtkWidget *widget = GTK_WIDGET (statusbar);
383 - GdkDisplay *display = gtk_widget_get_display (widget);
384 - GdkCursorType cursor_type;
385 - GdkCursor *cursor;
386 -
387 - if (gtk_widget_is_sensitive (widget))
388 - {
389 - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
390 - cursor_type = GDK_BOTTOM_RIGHT_CORNER;
391 - else
392 - cursor_type = GDK_BOTTOM_LEFT_CORNER;
393 -
394 - cursor = gdk_cursor_new_for_display (display, cursor_type);
395 - gdk_window_set_cursor (statusbar->grip_window, cursor);
396 - gdk_cursor_unref (cursor);
397 - }
398 - else
399 - gdk_window_set_cursor (statusbar->grip_window, NULL);
400 - }
401 -}
402 -
403 -static void
404 -gtk_statusbar_create_window (GtkStatusbar *statusbar)
405 -{
406 - GtkWidget *widget;
407 - GdkWindowAttr attributes;
408 - gint attributes_mask;
409 - GdkRectangle rect;
410 -
411 - widget = GTK_WIDGET (statusbar);
412 -
413 - g_return_if_fail (gtk_widget_get_realized (widget));
414 - g_return_if_fail (statusbar->has_resize_grip);
415 -
416 - get_grip_rect (statusbar, &rect);
417 -
418 - attributes.x = rect.x;
419 - attributes.y = rect.y;
420 - attributes.width = rect.width;
421 - attributes.height = rect.height;
422 - attributes.window_type = GDK_WINDOW_CHILD;
423 - attributes.wclass = GDK_INPUT_ONLY;
424 - attributes.event_mask = gtk_widget_get_events (widget) |
425 - GDK_BUTTON_PRESS_MASK;
426 -
427 - attributes_mask = GDK_WA_X | GDK_WA_Y;
428 -
429 - statusbar->grip_window = gdk_window_new (widget->window,
430 - &attributes, attributes_mask);
431 -
432 - gdk_window_set_user_data (statusbar->grip_window, widget);
433 -
434 - gdk_window_raise (statusbar->grip_window);
435 -
436 - set_grip_cursor (statusbar);
437 -}
438 -
439 -static void
440 -gtk_statusbar_direction_changed (GtkWidget *widget,
441 - GtkTextDirection prev_dir)
442 -{
443 - GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
444 -
445 - set_grip_cursor (statusbar);
446 -}
447 -
448 -static void
449 -gtk_statusbar_state_changed (GtkWidget *widget,
450 - GtkStateType previous_state)
451 -{
452 - GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
453 -
454 - set_grip_cursor (statusbar);
455 -}
456 -
457 -static void
458 -gtk_statusbar_destroy_window (GtkStatusbar *statusbar)
459 -{
460 - gdk_window_set_user_data (statusbar->grip_window, NULL);
461 - gdk_window_destroy (statusbar->grip_window);
462 - statusbar->grip_window = NULL;
463 -}
464 -
465 -static void
466 gtk_statusbar_realize (GtkWidget *widget)
467 {
468 GtkStatusbar *statusbar;
469 @@ -802,9 +654,6 @@
470 statusbar = GTK_STATUSBAR (widget);
471
472 GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->realize (widget);
473 -
474 - if (statusbar->has_resize_grip)
475 - gtk_statusbar_create_window (statusbar);
476 }
477
478 static void
479 @@ -814,9 +663,6 @@
480
481 statusbar = GTK_STATUSBAR (widget);
482
483 - if (statusbar->grip_window)
484 - gtk_statusbar_destroy_window (statusbar);
485 -
486 GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->unrealize (widget);
487 }
488
489 @@ -828,9 +674,6 @@
490 statusbar = GTK_STATUSBAR (widget);
491
492 GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->map (widget);
493 -
494 - if (statusbar->grip_window)
495 - gdk_window_show (statusbar->grip_window);
496 }
497
498 static void
499 @@ -840,103 +683,9 @@
500
501 statusbar = GTK_STATUSBAR (widget);
502
503 - if (statusbar->grip_window)
504 - gdk_window_hide (statusbar->grip_window);
505 -
506 GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->unmap (widget);
507 }
508
509 -static gboolean
510 -gtk_statusbar_button_press (GtkWidget *widget,
511 - GdkEventButton *event)
512 -{
513 - GtkStatusbar *statusbar;
514 - GtkWidget *ancestor;
515 - GdkWindowEdge edge;
516 -
517 - statusbar = GTK_STATUSBAR (widget);
518 -
519 - if (!statusbar->has_resize_grip ||
520 - event->type != GDK_BUTTON_PRESS ||
521 - event->window != statusbar->grip_window)
522 - return FALSE;
523 -
524 - ancestor = gtk_widget_get_toplevel (widget);
525 -
526 - if (!GTK_IS_WINDOW (ancestor))
527 - return FALSE;
528 -
529 - edge = get_grip_edge (statusbar);
530 -
531 - if (event->button == 1)
532 - gtk_window_begin_resize_drag (GTK_WINDOW (ancestor),
533 - edge,
534 - event->button,
535 - event->x_root, event->y_root,
536 - event->time);
537 - else if (event->button == 2)
538 - gtk_window_begin_move_drag (GTK_WINDOW (ancestor),
539 - event->button,
540 - event->x_root, event->y_root,
541 - event->time);
542 - else
543 - return FALSE;
544 -
545 - return TRUE;
546 -}
547 -
548 -static gboolean
549 -gtk_statusbar_expose_event (GtkWidget *widget,
550 - GdkEventExpose *event)
551 -{
552 - GtkStatusbar *statusbar;
553 - GdkRectangle rect;
554 -
555 - statusbar = GTK_STATUSBAR (widget);
556 -
557 - GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->expose_event (widget, event);
558 -
559 - if (statusbar->has_resize_grip)
560 - {
561 - GdkWindowEdge edge;
562 -
563 - edge = get_grip_edge (statusbar);
564 -
565 - get_grip_rect (statusbar, &rect);
566 -
567 - gtk_paint_resize_grip (widget->style,
568 - widget->window,
569 - gtk_widget_get_state (widget),
570 - &event->area,
571 - widget,
572 - "statusbar",
573 - edge,
574 - rect.x, rect.y,
575 - /* don't draw grip over the frame, though you
576 - * can click on the frame.
577 - */
578 - rect.width - widget->style->xthickness,
579 - rect.height - widget->style->ythickness);
580 - }
581 -
582 - return FALSE;
583 -}
584 -
585 -static void
586 -gtk_statusbar_size_request (GtkWidget *widget,
587 - GtkRequisition *requisition)
588 -{
589 - GtkStatusbar *statusbar;
590 - GtkShadowType shadow_type;
591 -
592 - statusbar = GTK_STATUSBAR (widget);
593 -
594 - gtk_widget_style_get (GTK_WIDGET (statusbar), "shadow-type", &shadow_type, NULL);
595 - gtk_frame_set_shadow_type (GTK_FRAME (statusbar->frame), shadow_type);
596 -
597 - GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->size_request (widget, requisition);
598 -}
599 -
600 /* look for extra children between the frame containing
601 * the label and where we want to draw the resize grip
602 */
603 @@ -979,40 +728,62 @@
604 {
605 GtkStatusbar *statusbar = GTK_STATUSBAR (widget);
606 gboolean extra_children = FALSE;
607 + gboolean has_resize_grip = FALSE;
608 GdkRectangle rect;
609 -
610 - if (statusbar->has_resize_grip)
611 - {
612 - get_grip_rect (statusbar, &rect);
613 -
614 - extra_children = has_extra_children (statusbar);
615 -
616 - /* If there are extra children, we don't want them to occupy
617 - * the space where we draw the resize grip, so we temporarily
618 - * shrink the allocation.
619 - * If there are no extra children, we want the frame to get
620 - * the full allocation, and we fix up the allocation of the
621 - * label afterwards to make room for the grip.
622 - */
623 - if (extra_children)
624 - {
625 - allocation->width -= rect.width;
626 - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
627 - allocation->x += rect.width;
628 - }
629 + GtkWidget *window;
630 + gint x, y;
631 + GdkRectangle translated_rect;
632 +
633 + window = gtk_widget_get_toplevel (widget);
634 + if (GTK_IS_WINDOW (window) && gtk_window_resize_grip_is_visible (GTK_WINDOW (window)))
635 + {
636 + gtk_window_get_resize_grip_area (GTK_WINDOW (window), &rect);
637 +
638 + if (gtk_widget_translate_coordinates (gtk_widget_get_parent (widget),
639 + window,
640 + allocation->x,
641 + allocation->y,
642 + &x,
643 + &y))
644 + {
645 + translated_rect.x = x;
646 + translated_rect.y = y;
647 + translated_rect.width = allocation->width;
648 + translated_rect.height = allocation->height;
649 +
650 + if (gdk_rectangle_intersect (&rect, &translated_rect, NULL))
651 + {
652 + has_resize_grip = TRUE;
653 + extra_children = has_extra_children (statusbar);
654 +
655 + /* If there are extra children, we don't want them to occupy
656 + * the space where we draw the resize grip, so we temporarily
657 + * shrink the allocation.
658 + * If there are no extra children, we want the frame to get
659 + * the full allocation, and we fix up the allocation of the
660 + * label afterwards to make room for the grip.
661 + */
662 + if (extra_children)
663 + {
664 + allocation->width -= rect.width;
665 + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
666 + allocation->x += rect.width;
667 + }
668 + }
669 + }
670 }
671
672 /* chain up normally */
673 GTK_WIDGET_CLASS (gtk_statusbar_parent_class)->size_allocate (widget, allocation);
674
675 - if (statusbar->has_resize_grip)
676 + if (has_resize_grip)
677 {
678 - if (extra_children)
679 - {
680 - allocation->width += rect.width;
681 - if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
682 - allocation->x -= rect.width;
683 -
684 + if (extra_children)
685 + {
686 + allocation->width += rect.width;
687 + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
688 + allocation->x -= rect.width;
689 +
690 widget->allocation = *allocation;
691 }
692 else
693 @@ -1036,17 +807,6 @@
694 gtk_widget_size_allocate (child, allocation);
695 }
696 }
697 -
698 - if (statusbar->grip_window)
699 - {
700 - get_grip_rect (statusbar, &rect);
701 -
702 - gdk_window_raise (statusbar->grip_window);
703 - gdk_window_move_resize (statusbar->grip_window,
704 - rect.x, rect.y,
705 - rect.width, rect.height);
706 - }
707 -
708 }
709 }
710
711 Index: gtk+-2.24.4/gtk/gtkwindow.c
712 ===================================================================
713 --- gtk+-2.24.4.orig/gtk/gtkwindow.c 2011-04-04 10:57:59.406596969 +1000
714 +++ gtk+-2.24.4/gtk/gtkwindow.c 2011-04-04 10:58:00.246596968 +1000
715 @@ -95,6 +95,8 @@
716 PROP_TRANSIENT_FOR,
717 PROP_OPACITY,
718 PROP_NO_PROXY,
719 + PROP_HAS_RESIZE_GRIP,
720 + PROP_RESIZE_GRIP_VISIBLE,
721
722 /* Readonly properties */
723 PROP_IS_ACTIVE,
724 @@ -198,6 +200,10 @@
725
726 gboolean no_proxy;
727
728 + gboolean has_resize_grip;
729 + GdkWindow *grip_window;
730 + gboolean resize_grip_visible;
731 +
732 gchar *startup_id;
733 };
734
735 @@ -226,6 +232,8 @@
736 GdkEventKey *event);
737 static gint gtk_window_key_release_event (GtkWidget *widget,
738 GdkEventKey *event);
739 +static gint gtk_window_button_press_event (GtkWidget *widget,
740 + GdkEventButton *event);
741 static gint gtk_window_enter_notify_event (GtkWidget *widget,
742 GdkEventCrossing *event);
743 static gint gtk_window_leave_notify_event (GtkWidget *widget,
744 @@ -236,11 +244,17 @@
745 GdkEventFocus *event);
746 static gint gtk_window_client_event (GtkWidget *widget,
747 GdkEventClient *event);
748 +static gboolean gtk_window_state_event (GtkWidget *widget,
749 + GdkEventWindowState *event);
750 static void gtk_window_check_resize (GtkContainer *container);
751 static gint gtk_window_focus (GtkWidget *widget,
752 GtkDirectionType direction);
753 static void gtk_window_real_set_focus (GtkWindow *window,
754 GtkWidget *focus);
755 +static void gtk_window_direction_changed (GtkWidget *widget,
756 + GtkTextDirection prev_dir);
757 +static void gtk_window_state_changed (GtkWidget *widget,
758 + GtkStateType previous_state);
759
760 static void gtk_window_real_activate_default (GtkWindow *window);
761 static void gtk_window_real_activate_focus (GtkWindow *window);
762 @@ -300,6 +314,10 @@
763 const gchar *name);
764 static void gtk_window_realize_icon (GtkWindow *window);
765 static void gtk_window_unrealize_icon (GtkWindow *window);
766 +static void resize_grip_create_window (GtkWindow *window);
767 +static void resize_grip_destroy_window (GtkWindow *window);
768 +static void update_grip_visibility (GtkWindow *window);
769 +
770
771 static void gtk_window_notify_keys_changed (GtkWindow *window);
772 static GtkKeyHash *gtk_window_get_key_hash (GtkWindow *window);
773 @@ -462,10 +480,14 @@
774 widget_class->enter_notify_event = gtk_window_enter_notify_event;
775 widget_class->leave_notify_event = gtk_window_leave_notify_event;
776 widget_class->focus_in_event = gtk_window_focus_in_event;
777 + widget_class->button_press_event = gtk_window_button_press_event;
778 widget_class->focus_out_event = gtk_window_focus_out_event;
779 widget_class->client_event = gtk_window_client_event;
780 widget_class->focus = gtk_window_focus;
781 widget_class->expose_event = gtk_window_expose;
782 + widget_class->window_state_event = gtk_window_state_event;
783 + widget_class->direction_changed = gtk_window_direction_changed;
784 + widget_class->state_changed = gtk_window_state_changed;
785
786 container_class->check_resize = gtk_window_check_resize;
787
788 @@ -514,6 +536,42 @@
789 GTK_PARAM_READWRITE));
790
791 /**
792 + * GtkWindow:has-resize-grip
793 + *
794 + * Whether the window has a corner resize grip.
795 + *
796 + * Note that the resize grip is only shown if the window is
797 + * actually resizable and not maximized. Use
798 + * #GtkWindow:resize-grip-visible to find out if the resize
799 + * grip is currently shown.
800 + *
801 + * Since: 3.0
802 + */
803 + g_object_class_install_property (gobject_class,
804 + PROP_HAS_RESIZE_GRIP,
805 + g_param_spec_boolean ("has-resize-grip",
806 + P_("Resize grip"),
807 + P_("Specifies whether the window should have a resize grip"),
808 + TRUE,
809 + GTK_PARAM_READWRITE));
810 +
811 + /**
812 + * GtkWindow: resize-grip-visible:
813 + *
814 + * Whether a corner resize grip is currently shown.
815 + *
816 + * Since: 3.0
817 + */
818 + g_object_class_install_property (gobject_class,
819 + PROP_RESIZE_GRIP_VISIBLE,
820 + g_param_spec_boolean ("resize-grip-visible",
821 + P_("Resize grip is visible"),
822 + P_("Specifies whether the window's resize grip is visible."),
823 + FALSE,
824 + GTK_PARAM_READABLE));
825 +
826 +
827 + /**
828 * GtkWindow:startup-id:
829 *
830 * The :startup-id is a write-only property for setting window's
831 @@ -816,6 +874,21 @@
832 1.0,
833 GTK_PARAM_READWRITE));
834
835 + /* Style properties.
836 + */
837 + gtk_widget_class_install_style_property (widget_class,
838 + g_param_spec_int ("resize-grip-width",
839 + P_("Width of resize grip"),
840 + P_("Width of resize grip"),
841 + 0, G_MAXINT, 16, GTK_PARAM_READWRITE));
842 +
843 + gtk_widget_class_install_style_property (widget_class,
844 + g_param_spec_int ("resize-grip-height",
845 + P_("Height of resize grip"),
846 + P_("Height of resize grip"),
847 + 0, G_MAXINT, 16, GTK_PARAM_READWRITE));
848 +
849 +
850 window_signals[SET_FOCUS] =
851 g_signal_new (I_("set-focus"),
852 G_TYPE_FROM_CLASS (gobject_class),
853 @@ -967,6 +1040,7 @@
854 priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
855 priv->opacity = 1.0;
856 priv->startup_id = NULL;
857 + priv->has_resize_grip = TRUE;
858 priv->mnemonics_visible = TRUE;
859
860 colormap = _gtk_widget_peek_colormap ();
861 @@ -1020,9 +1094,7 @@
862 g_object_notify (G_OBJECT (window), "resizable");
863 break;
864 case PROP_RESIZABLE:
865 - window->allow_grow = g_value_get_boolean (value);
866 - gtk_widget_queue_resize (GTK_WIDGET (window));
867 - g_object_notify (G_OBJECT (window), "allow-grow");
868 + gtk_window_set_resizable (window, g_value_get_boolean (value));
869 break;
870 case PROP_MODAL:
871 gtk_window_set_modal (window, g_value_get_boolean (value));
872 @@ -1092,6 +1164,9 @@
873 case PROP_OPACITY:
874 gtk_window_set_opacity (window, g_value_get_double (value));
875 break;
876 + case PROP_HAS_RESIZE_GRIP:
877 + gtk_window_set_has_resize_grip (window, g_value_get_boolean (value));
878 + break;
879 case PROP_MNEMONICS_VISIBLE:
880 gtk_window_set_mnemonics_visible (window, g_value_get_boolean (value));
881 break;
882 @@ -1213,6 +1288,12 @@
883 case PROP_OPACITY:
884 g_value_set_double (value, gtk_window_get_opacity (window));
885 break;
886 + case PROP_HAS_RESIZE_GRIP:
887 + g_value_set_boolean (value, priv->has_resize_grip);
888 + break;
889 + case PROP_RESIZE_GRIP_VISIBLE:
890 + g_value_set_boolean (value, gtk_window_resize_grip_is_visible (window));
891 + break;
892 case PROP_MNEMONICS_VISIBLE:
893 g_value_set_boolean (value, priv->mnemonics_visible);
894 break;
895 @@ -4656,6 +4737,9 @@
896 if (window->frame)
897 gdk_window_show (window->frame);
898
899 + if (priv->grip_window)
900 + gdk_window_show (priv->grip_window);
901 +
902 if (!disable_startup_notification)
903 {
904 /* Do we have a custom startup-notification id? */
905 @@ -4871,6 +4955,9 @@
906 if (window->frame)
907 gtk_style_set_background (widget->style, window->frame, GTK_STATE_NORMAL);
908
909 + if (priv->grip_window)
910 + gtk_style_set_background (widget->style, priv->grip_window, GTK_STATE_NORMAL);
911 +
912 /* This is a bad hack to set the window background. */
913 gtk_window_paint (widget, NULL);
914
915 @@ -4922,15 +5009,20 @@
916
917 /* Icons */
918 gtk_window_realize_icon (window);
919 +
920 + if (priv->has_resize_grip)
921 + resize_grip_create_window (window);
922 }
923
924 static void
925 gtk_window_unrealize (GtkWidget *widget)
926 {
927 GtkWindow *window;
928 + GtkWindowPrivate *priv;
929 GtkWindowGeometryInfo *info;
930
931 window = GTK_WINDOW (widget);
932 + priv = GTK_WINDOW_GET_PRIVATE (widget);
933
934 /* On unrealize, we reset the size of the window such
935 * that we will re-apply the default sizing stuff
936 @@ -4962,9 +5054,146 @@
937 /* Icons */
938 gtk_window_unrealize_icon (window);
939
940 + if (priv->grip_window != NULL)
941 + resize_grip_destroy_window (window);
942 +
943 GTK_WIDGET_CLASS (gtk_window_parent_class)->unrealize (widget);
944 }
945
946 +static GdkWindowEdge
947 +get_grip_edge (GtkWidget *widget)
948 +{
949 + return gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR ? GDK_WINDOW_EDGE_SOUTH_EAST : GDK_WINDOW_EDGE_SOUTH_WEST;
950 +}
951 +
952 +static gboolean
953 +get_drag_edge (GtkWidget *widget,
954 + GdkWindowEdge *edge)
955 +{
956 + GtkTextDirection dir;
957 +
958 + dir = gtk_widget_get_direction (widget);
959 +
960 + if (!GTK_WINDOW (widget)->allow_grow)
961 + return FALSE;
962 +
963 + *edge = dir == GTK_TEXT_DIR_LTR ? GDK_WINDOW_EDGE_SOUTH_EAST : GDK_WINDOW_EDGE_SOUTH_WEST;
964 +
965 + return TRUE;
966 +}
967 +
968 +static void
969 +set_grip_cursor (GtkWindow *window)
970 +{
971 + GtkWidget *widget = GTK_WIDGET (window);
972 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE(window);
973 +
974 + if (priv->grip_window == NULL)
975 + return;
976 +
977 + if (gtk_widget_is_sensitive (widget))
978 + {
979 + GdkWindowEdge edge;
980 + GdkDisplay *display;
981 + GdkCursorType cursor_type;
982 + GdkCursor *cursor;
983 +
984 + cursor_type = GDK_LEFT_PTR;
985 +
986 + if (get_drag_edge (widget, &edge))
987 + {
988 + switch (edge)
989 + {
990 + case GDK_WINDOW_EDGE_EAST:
991 + cursor_type = GDK_RIGHT_SIDE;
992 + break;
993 + case GDK_WINDOW_EDGE_SOUTH_EAST:
994 + cursor_type = GDK_BOTTOM_RIGHT_CORNER;
995 + break;
996 + case GDK_WINDOW_EDGE_SOUTH:
997 + cursor_type = GDK_BOTTOM_SIDE;
998 + break;
999 + case GDK_WINDOW_EDGE_SOUTH_WEST:
1000 + cursor_type = GDK_BOTTOM_LEFT_CORNER;
1001 + break;
1002 + case GDK_WINDOW_EDGE_WEST:
1003 + cursor_type = GDK_LEFT_SIDE;
1004 + break;
1005 + default: ;
1006 + }
1007 + }
1008 +
1009 + display = gtk_widget_get_display (widget);
1010 + cursor = gdk_cursor_new_for_display (display, cursor_type);
1011 + gdk_window_set_cursor (priv->grip_window, cursor);
1012 + gdk_cursor_unref (cursor);
1013 + }
1014 + else
1015 + gdk_window_set_cursor (priv->grip_window, NULL);
1016 +}
1017 +
1018 +static void
1019 +set_grip_shape (GtkWindow *window)
1020 +{
1021 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
1022 + GdkDrawable *mask;
1023 + cairo_t *cr;
1024 + gint width, height;
1025 +
1026 + if (priv->grip_window == NULL)
1027 + return;
1028 +
1029 + gdk_window_get_geometry (priv->grip_window,
1030 + NULL, NULL,
1031 + &width, &height,
1032 + NULL);
1033 +
1034 + mask = (GdkDrawable *) gdk_pixmap_new (NULL, width, height, 1);
1035 +
1036 + cr = gdk_cairo_create (mask);
1037 +
1038 + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
1039 + cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.0);
1040 + cairo_paint (cr);
1041 + cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
1042 +
1043 + if (get_grip_edge (GTK_WIDGET (window)) == GDK_WINDOW_EDGE_SOUTH_EAST)
1044 + {
1045 + cairo_move_to (cr, width, 0.0);
1046 + cairo_line_to (cr, width, height);
1047 + cairo_line_to (cr, 0.0, height);
1048 + }
1049 + else
1050 + {
1051 + cairo_move_to (cr, 0.0, 0.0);
1052 + cairo_line_to (cr, width, height);
1053 + cairo_line_to (cr, 0.0, height);
1054 + }
1055 +
1056 + cairo_close_path (cr);
1057 + cairo_fill (cr);
1058 + cairo_destroy (cr);
1059 +
1060 + gdk_window_shape_combine_mask (priv->grip_window, NULL, 0, 0);
1061 + gdk_window_shape_combine_mask (priv->grip_window, mask, 0, 0);
1062 +}
1063 +
1064 +static void
1065 +set_grip_position (GtkWindow *window)
1066 +{
1067 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE(window);
1068 + GdkRectangle rect;
1069 +
1070 + if (priv->grip_window == NULL)
1071 + return;
1072 +
1073 + gtk_window_get_resize_grip_area (window, &rect);
1074 + gdk_window_raise (priv->grip_window);
1075 + gdk_window_move_resize (priv->grip_window,
1076 + rect.x, rect.y,
1077 + rect.width, rect.height);
1078 +}
1079 +
1080 static void
1081 gtk_window_size_request (GtkWidget *widget,
1082 GtkRequisition *requisition)
1083 @@ -5011,14 +5240,293 @@
1084 gtk_widget_size_allocate (window->bin.child, &child_allocation);
1085 }
1086
1087 - if (gtk_widget_get_realized (widget) && window->frame)
1088 + if (gtk_widget_get_realized (widget))
1089 {
1090 - gdk_window_resize (window->frame,
1091 - allocation->width + window->frame_left + window->frame_right,
1092 - allocation->height + window->frame_top + window->frame_bottom);
1093 + if (window->frame)
1094 + {
1095 + gdk_window_resize (window->frame,
1096 + allocation->width + window->frame_left + window->frame_right,
1097 + allocation->height + window->frame_top + window->frame_bottom);
1098 + }
1099 +
1100 + update_grip_visibility (window);
1101 + set_grip_position (window);
1102 }
1103 }
1104
1105 +static gboolean
1106 +gtk_window_state_event (GtkWidget *widget,
1107 + GdkEventWindowState *event)
1108 +{
1109 + update_grip_visibility (GTK_WINDOW (widget));
1110 +
1111 + return FALSE;
1112 +}
1113 +
1114 +static void
1115 +gtk_window_direction_changed (GtkWidget *widget,
1116 + GtkTextDirection prev_dir)
1117 +{
1118 + GtkWindow *window = GTK_WINDOW (widget);
1119 +
1120 + set_grip_cursor (window);
1121 + set_grip_position (window);
1122 + set_grip_shape (window);
1123 +}
1124 +
1125 +static void
1126 +gtk_window_state_changed (GtkWidget *widget,
1127 + GtkStateType previous_state)
1128 +{
1129 + GtkWindow *window = GTK_WINDOW (widget);
1130 +
1131 + set_grip_cursor (window);
1132 + update_grip_visibility (window);
1133 +}
1134 +
1135 +static void
1136 +resize_grip_create_window (GtkWindow *window)
1137 +{
1138 + GtkWidget *widget;
1139 + GtkWindowPrivate *priv;
1140 + GdkWindowAttr attributes;
1141 + gint attributes_mask;
1142 + GdkRectangle rect;
1143 +
1144 + priv = GTK_WINDOW_GET_PRIVATE(window);
1145 + widget = GTK_WIDGET (window);
1146 +
1147 + g_return_if_fail (gtk_widget_get_realized (widget));
1148 + g_return_if_fail (priv->grip_window == NULL);
1149 +
1150 + gtk_window_get_resize_grip_area (window, &rect);
1151 +
1152 + attributes.x = rect.x;
1153 + attributes.y = rect.y;
1154 + attributes.width = rect.width;
1155 + attributes.height = rect.height;
1156 + attributes.window_type = GDK_WINDOW_CHILD;
1157 + attributes.wclass = GDK_INPUT_OUTPUT;
1158 + attributes.visual = gtk_widget_get_visual (widget);
1159 + attributes.event_mask = gtk_widget_get_events (widget) |
1160 + GDK_EXPOSURE_MASK |
1161 + GDK_BUTTON_PRESS_MASK;
1162 +
1163 + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
1164 +
1165 + priv->grip_window = gdk_window_new (gtk_widget_get_window (widget),
1166 + &attributes,
1167 + attributes_mask);
1168 +
1169 + gdk_window_set_user_data (priv->grip_window, widget);
1170 +
1171 + gdk_window_raise (priv->grip_window);
1172 +
1173 + set_grip_cursor (window);
1174 + set_grip_shape (window);
1175 + update_grip_visibility (window);
1176 +}
1177 +
1178 +static void
1179 +resize_grip_destroy_window (GtkWindow *window)
1180 +{
1181 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE(window);
1182 +
1183 + gdk_window_set_user_data (priv->grip_window, NULL);
1184 + gdk_window_destroy (priv->grip_window);
1185 + priv->grip_window = NULL;
1186 + update_grip_visibility (window);
1187 +}
1188 +
1189 +/**
1190 + * gtk_window_set_has_resize_grip:
1191 + * @window: a #GtkWindow
1192 + * @value: %TRUE to allow a resize grip
1193 + *
1194 + * Sets whether @window has a corner resize grip.
1195 + *
1196 + * Note that the resize grip is only shown if the window
1197 + * is actually resizable and not maximized. Use
1198 + * gtk_window_resize_grip_is_visible() to find out if the
1199 + * resize grip is currently shown.
1200 + *
1201 + * Since: 3.0
1202 + */
1203 +void
1204 +gtk_window_set_has_resize_grip (GtkWindow *window,
1205 + gboolean value)
1206 +{
1207 + GtkWidget *widget = GTK_WIDGET (window);
1208 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE(window);
1209 +
1210 + value = value != FALSE;
1211 +
1212 + if (value != priv->has_resize_grip)
1213 + {
1214 + priv->has_resize_grip = value;
1215 + gtk_widget_queue_draw (widget);
1216 +
1217 + if (gtk_widget_get_realized (widget))
1218 + {
1219 + if (priv->has_resize_grip && priv->grip_window == NULL)
1220 + resize_grip_create_window (window);
1221 + else if (!priv->has_resize_grip && priv->grip_window != NULL)
1222 + resize_grip_destroy_window (window);
1223 + }
1224 +
1225 + g_object_notify (G_OBJECT (window), "has-resize-grip");
1226 + }
1227 +}
1228 +
1229 +static void
1230 +update_grip_visibility (GtkWindow *window)
1231 +{
1232 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE(window);
1233 + gboolean val;
1234 +
1235 + val = gtk_window_resize_grip_is_visible (window);
1236 +
1237 + if (priv->grip_window != NULL)
1238 + {
1239 + if (val)
1240 + {
1241 + gdk_window_show (priv->grip_window);
1242 + set_grip_cursor (window);
1243 + }
1244 + else
1245 + {
1246 + gdk_window_hide (priv->grip_window);
1247 + }
1248 + }
1249 +
1250 + if (priv->resize_grip_visible != val)
1251 + {
1252 + priv->resize_grip_visible = val;
1253 +
1254 + g_object_notify (G_OBJECT (window), "resize-grip-visible");
1255 + }
1256 +}
1257 +
1258 +/**
1259 + * gtk_window_resize_grip_is_visible:
1260 + * @window: a #GtkWindow
1261 + *
1262 + * Determines whether a resize grip is visible for the specified window.
1263 + *
1264 + * Returns %TRUE if a resize grip exists and is visible.
1265 + *
1266 + * Since: 3.0
1267 + */
1268 +gboolean
1269 +gtk_window_resize_grip_is_visible (GtkWindow *window)
1270 +{
1271 + GtkWindowPrivate *priv;
1272 + GdkWindowEdge edge;
1273 +
1274 + g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
1275 +
1276 + priv = GTK_WINDOW_GET_PRIVATE(window);
1277 +
1278 + if (window->type == GTK_WINDOW_POPUP || !window->allow_grow)
1279 + return FALSE;
1280 +
1281 + if (gtk_widget_get_realized (GTK_WIDGET (window)))
1282 + {
1283 + GdkWindowState state;
1284 +
1285 + state = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (window)));
1286 +
1287 + if (state & GDK_WINDOW_STATE_MAXIMIZED || state & GDK_WINDOW_STATE_FULLSCREEN)
1288 + return FALSE;
1289 + }
1290 +
1291 + if (!get_drag_edge (GTK_WIDGET (window), &edge))
1292 + return FALSE;
1293 +
1294 + return priv->has_resize_grip;
1295 +}
1296 +
1297 +/**
1298 + * gtk_window_get_has_resize_grip:
1299 + * @window: a #GtkWindow
1300 + *
1301 + * Determines whether the window may has a resize grip.
1302 + *
1303 + * Returns: %TRUE if the window has a resize grip.
1304 + *
1305 + * Since: 3.0
1306 + */
1307 +gboolean
1308 +gtk_window_get_has_resize_grip (GtkWindow *window)
1309 +{
1310 + GtkWindowPrivate *priv;
1311 +
1312 + g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
1313 +
1314 + priv = GTK_WINDOW_GET_PRIVATE(window);
1315 +
1316 + return priv->has_resize_grip;
1317 +}
1318 +
1319 +/**
1320 + * gtk_window_get_resize_grip_area:
1321 + * @window: a #GtkWindow
1322 + * @rect: a pointer to a #GdkRectangle which we should store the
1323 + * resize grip area.
1324 + *
1325 + * If a window has a resize grip, this will retrieve the grip
1326 + * position, width and height into the specified #GdkRectangle.
1327 + *
1328 + * Returns: %TRUE if the resize grip's area was retrieved.
1329 + *
1330 + * Since: 3.0
1331 + */
1332 +gboolean
1333 +gtk_window_get_resize_grip_area (GtkWindow *window,
1334 + GdkRectangle *rect)
1335 +{
1336 + GtkWidget *widget;
1337 + GtkWindowPrivate *priv;
1338 + GtkAllocation allocation;
1339 + GtkStyle *style;
1340 + gint grip_width;
1341 + gint grip_height;
1342 +
1343 + g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
1344 +
1345 + widget = GTK_WIDGET (window);
1346 + priv = GTK_WINDOW_GET_PRIVATE (window);
1347 +
1348 + if (!priv->has_resize_grip)
1349 + return FALSE;
1350 +
1351 + gtk_widget_get_allocation (widget, &allocation);
1352 + style = gtk_widget_get_style (widget);
1353 +
1354 + gtk_widget_style_get (widget,
1355 + "resize-grip-width", &grip_width,
1356 + "resize-grip-height", &grip_height,
1357 + NULL);
1358 +
1359 + if (grip_width > allocation.width)
1360 + grip_width = allocation.width;
1361 +
1362 + if (grip_height > allocation.height)
1363 + grip_height = allocation.height;
1364 +
1365 + rect->width = grip_width;
1366 + rect->height = grip_height;
1367 + rect->y = allocation.y + allocation.height - grip_height;
1368 +
1369 + if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1370 + rect->x = allocation.x + allocation.width - grip_width;
1371 + else
1372 + rect->x = allocation.x;
1373 +
1374 + return TRUE;
1375 +}
1376 +
1377 +
1378 static gint
1379 gtk_window_event (GtkWidget *widget, GdkEvent *event)
1380 {
1381 @@ -5270,6 +5778,29 @@
1382 return handled;
1383 }
1384
1385 +static gint
1386 +gtk_window_button_press_event (GtkWidget *widget,
1387 + GdkEventButton *event)
1388 +{
1389 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (widget);
1390 + GdkWindowEdge edge;
1391 +
1392 + if (event->window == priv->grip_window)
1393 + {
1394 + if (get_drag_edge (widget, &edge))
1395 + gtk_window_begin_resize_drag (GTK_WINDOW (widget),
1396 + get_grip_edge (widget),
1397 + event->button,
1398 + event->x_root,
1399 + event->y_root,
1400 + event->time);
1401 +
1402 + return TRUE;
1403 + }
1404 +
1405 + return FALSE;
1406 +}
1407 +
1408 static void
1409 gtk_window_real_activate_default (GtkWindow *window)
1410 {
1411 @@ -6051,6 +6582,7 @@
1412 * the position request to be centered.
1413 */
1414 GtkWidget *widget;
1415 + GtkWindowPrivate *priv;
1416 GtkContainer *container;
1417 GtkWindowGeometryInfo *info;
1418 GdkGeometry new_geometry;
1419 @@ -6064,7 +6596,8 @@
1420 widget = GTK_WIDGET (window);
1421 container = GTK_CONTAINER (widget);
1422 info = gtk_window_get_geometry_info (window, TRUE);
1423 -
1424 + priv = GTK_WINDOW_GET_PRIVATE (window);
1425 +
1426 configure_request_size_changed = FALSE;
1427 configure_request_pos_changed = FALSE;
1428
1429 @@ -6260,6 +6793,9 @@
1430 allocation = widget->allocation;
1431 gtk_widget_size_allocate (widget, &allocation);
1432
1433 + set_grip_position (window);
1434 + update_grip_visibility (window);
1435 +
1436 gdk_window_process_updates (widget->window, TRUE);
1437
1438 gdk_window_configure_finished (widget->window);
1439 @@ -6636,24 +7172,75 @@
1440 ***********************/
1441
1442 static void
1443 -gtk_window_paint (GtkWidget *widget,
1444 - GdkRectangle *area)
1445 +paint_window_grip (GtkWidget *widget, GdkRectangle *area)
1446 {
1447 - gtk_paint_flat_box (widget->style, widget->window, GTK_STATE_NORMAL,
1448 - GTK_SHADOW_NONE, area, widget, "base", 0, 0, -1, -1);
1449 + GtkWindow *window = GTK_WINDOW (widget);
1450 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
1451 +
1452 + if (gtk_window_resize_grip_is_visible (window) && priv->grip_window != NULL)
1453 + {
1454 + GdkWindowEdge edge;
1455 + GdkRectangle rect;
1456 +
1457 + gtk_window_get_resize_grip_area (window, &rect);
1458 +
1459 + edge = get_grip_edge (widget);
1460 +
1461 + gtk_window_get_resize_grip_area (window, &rect);
1462 +
1463 + gtk_paint_flat_box (widget->style,
1464 + priv->grip_window,
1465 + GTK_STATE_NORMAL,
1466 + GTK_SHADOW_NONE,
1467 + area,
1468 + widget,
1469 + "base",
1470 + 0, 0,
1471 + -1, -1);
1472 +
1473 + gtk_paint_resize_grip (gtk_widget_get_style (widget),
1474 + priv->grip_window,
1475 + gtk_widget_get_state (widget),
1476 + area,
1477 + widget,
1478 + "statusbar",
1479 + edge,
1480 + 0, 0,
1481 + rect.width,
1482 + rect.height);
1483 + }
1484 +}
1485 +
1486 +static void
1487 +gtk_window_paint (GtkWidget *widget,
1488 + GdkRectangle *area)
1489 +{
1490 + gtk_paint_flat_box (widget->style, widget->window, GTK_STATE_NORMAL,
1491 + GTK_SHADOW_NONE, area, widget, "base", 0, 0, -1, -1);
1492 }
1493
1494 static gint
1495 gtk_window_expose (GtkWidget *widget,
1496 GdkEventExpose *event)
1497 {
1498 - if (!gtk_widget_get_app_paintable (widget))
1499 - gtk_window_paint (widget, &event->area);
1500 -
1501 - if (GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event)
1502 - return GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event (widget, event);
1503 + GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (widget);
1504 + gboolean ret = FALSE;
1505
1506 - return FALSE;
1507 + if (event->window == widget->window)
1508 + {
1509 + if (!gtk_widget_get_app_paintable (widget))
1510 + gtk_window_paint (widget, &event->area);
1511 +
1512 + if (GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event)
1513 + ret = GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event (widget, event);
1514 + }
1515 + else if (event->window == priv->grip_window)
1516 + {
1517 + paint_window_grip (widget, &event->area);
1518 + ret = TRUE;
1519 + }
1520 +
1521 + return ret;
1522 }
1523
1524 /**
1525 @@ -7265,8 +7852,16 @@
1526 gtk_window_set_resizable (GtkWindow *window,
1527 gboolean resizable)
1528 {
1529 + GtkWindowPrivate *priv;
1530 +
1531 g_return_if_fail (GTK_IS_WINDOW (window));
1532
1533 + priv = GTK_WINDOW_GET_PRIVATE (window);
1534 +
1535 + // XXX - need to do this after setting policy?
1536 + if (priv->grip_window != NULL)
1537 + update_grip_visibility (window);
1538 +
1539 gtk_window_set_policy_internal (window, FALSE, resizable, FALSE);
1540 }
1541
1542 Index: gtk+-2.24.4/gtk/gtkwindow.h
1543 ===================================================================
1544 --- gtk+-2.24.4.orig/gtk/gtkwindow.h 2011-02-20 01:31:37.000000000 +1100
1545 +++ gtk+-2.24.4/gtk/gtkwindow.h 2011-04-04 10:58:00.246596968 +1000
1546 @@ -404,6 +404,17 @@
1547 GList * gtk_window_group_list_windows (GtkWindowGroup *window_group);
1548
1549
1550 +
1551 +/* Window grips
1552 + */
1553 +void gtk_window_set_has_resize_grip (GtkWindow *window,
1554 + gboolean value);
1555 +gboolean gtk_window_get_has_resize_grip (GtkWindow *window);
1556 +gboolean gtk_window_resize_grip_is_visible (GtkWindow *window);
1557 +gboolean gtk_window_get_resize_grip_area (GtkWindow *window,
1558 + GdkRectangle *rect);
1559 +
1560 +
1561 /* --- internal functions --- */
1562 void _gtk_window_internal_set_focus (GtkWindow *window,
1563 GtkWidget *focus);
AUR mirror