]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/win_gtk.c
projects / wxWidgets.git / blob
? search:


b420b7764b57a1d9bbeaa01c459eb3969b534751
[wxWidgets.git] / src / gtk / win_gtk.c
1 /* ///////////////////////////////////////////////////////////////////////////
2 // Name: win_gtk.c
3 // Purpose: Native GTK+ widget for wxWindows, based on GtkLayout and
4 // GtkFixed. It makes use of the gravity window property and
5 // therefore does not work with GTK 1.0.
6 // Author: Robert Roebling
7 // Id: $Id$
8 // Copyright: (c) 1998 Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////// */
11
12 #include "wx/gtk/win_gtk.h"
13 #include "gtk/gtksignal.h"
14 #include "gtk/gtkprivate.h"
15 #include "gdk/gdkx.h"
16
17 #ifdef __cplusplus
18 extern "C" {
19 #endif /* __cplusplus */
20
21 #define IS_ONSCREEN(x,y) ((x >= G_MINSHORT) && (x <= G_MAXSHORT) && \
22 (y >= G_MINSHORT) && (y <= G_MAXSHORT))
23
24 typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
25 typedef struct _GtkPizzaChild GtkPizzaChild;
26
27 struct _GtkPizzaAdjData
28 {
29 gint dx;
30 gint dy;
31 };
32
33 struct _GtkPizzaChild
34 {
35 GtkWidget *widget;
36 gint x;
37 gint y;
38 gint width;
39 gint height;
40 };
41
42 static void gtk_pizza_class_init (GtkPizzaClass *klass);
43 static void gtk_pizza_init (GtkPizza *pizza);
44
45 static void gtk_pizza_realize (GtkWidget *widget);
46 static void gtk_pizza_unrealize (GtkWidget *widget);
47
48 static void gtk_pizza_map (GtkWidget *widget);
49
50 static void gtk_pizza_size_request (GtkWidget *widget,
51 GtkRequisition *requisition);
52 static void gtk_pizza_size_allocate (GtkWidget *widget,
53 GtkAllocation *allocation);
54 static void gtk_pizza_draw (GtkWidget *widget,
55 GdkRectangle *area);
56 static gint gtk_pizza_expose (GtkWidget *widget,
57 GdkEventExpose *event);
58 static void gtk_pizza_add (GtkContainer *container,
59 GtkWidget *widget);
60 static void gtk_pizza_remove (GtkContainer *container,
61 GtkWidget *widget);
62 static void gtk_pizza_forall (GtkContainer *container,
63 gboolean include_internals,
64 GtkCallback callback,
65 gpointer callback_data);
66
67 static void gtk_pizza_position_child (GtkPizza *pizza,
68 GtkPizzaChild *child);
69 static void gtk_pizza_allocate_child (GtkPizza *pizza,
70 GtkPizzaChild *child);
71 static void gtk_pizza_position_children (GtkPizza *pizza);
72
73 static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
74 gpointer cb_data);
75 static void gtk_pizza_adjust_allocations (GtkPizza *pizza,
76 gint dx,
77 gint dy);
78
79
80 static void gtk_pizza_expose_area (GtkPizza *pizza,
81 gint x,
82 gint y,
83 gint width,
84 gint height);
85 static void gtk_pizza_adjustment_changed (GtkAdjustment *adjustment,
86 GtkPizza *pizza);
87 static GdkFilterReturn gtk_pizza_filter (GdkXEvent *gdk_xevent,
88 GdkEvent *event,
89 gpointer data);
90 static GdkFilterReturn gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
91 GdkEvent *event,
92 gpointer data);
93
94
95 static GtkType gtk_pizza_child_type (GtkContainer *container);
96
97 static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
98 GtkAdjustment *hadj,
99 GtkAdjustment *vadj);
100
101
102 static GtkContainerClass *parent_class = NULL;
103 static gboolean gravity_works;
104
105 guint
106 gtk_pizza_get_type ()
107 {
108 static guint pizza_type = 0;
109
110 if (!pizza_type)
111 {
112 GtkTypeInfo pizza_info =
113 {
114 "GtkPizza",
115 sizeof (GtkPizza),
116 sizeof (GtkPizzaClass),
117 (GtkClassInitFunc) gtk_pizza_class_init,
118 (GtkObjectInitFunc) gtk_pizza_init,
119 /* reserved_1 */ NULL,
120 /* reserved_2 */ NULL,
121 (GtkClassInitFunc) NULL,
122 };
123 pizza_type = gtk_type_unique (gtk_container_get_type (), &pizza_info);
124 }
125
126 return pizza_type;
127 }
128
129 static void
130 gtk_pizza_class_init (GtkPizzaClass *klass)
131 {
132 GtkObjectClass *object_class;
133 GtkWidgetClass *widget_class;
134 GtkContainerClass *container_class;
135
136 object_class = (GtkObjectClass*) klass;
137 widget_class = (GtkWidgetClass*) klass;
138 container_class = (GtkContainerClass*) klass;
139 parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
140
141 widget_class->map = gtk_pizza_map;
142 widget_class->realize = gtk_pizza_realize;
143 widget_class->unrealize = gtk_pizza_unrealize;
144 widget_class->size_request = gtk_pizza_size_request;
145 widget_class->size_allocate = gtk_pizza_size_allocate;
146 widget_class->draw = gtk_pizza_draw;
147 widget_class->expose_event = gtk_pizza_expose;
148
149 container_class->add = gtk_pizza_add;
150 container_class->remove = gtk_pizza_remove;
151 container_class->forall = gtk_pizza_forall;
152
153 container_class->child_type = gtk_pizza_child_type;
154
155 klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
156
157 widget_class->set_scroll_adjustments_signal =
158 gtk_signal_new ("set_scroll_adjustments",
159 GTK_RUN_LAST,
160 object_class->type,
161 GTK_SIGNAL_OFFSET (GtkPizzaClass, set_scroll_adjustments),
162 gtk_marshal_NONE__POINTER_POINTER,
163 GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
164 }
165
166 static GtkType
167 gtk_pizza_child_type (GtkContainer *container)
168 {
169 return GTK_TYPE_WIDGET;
170 }
171
172 static void
173 gtk_pizza_init (GtkPizza *pizza)
174 {
175 GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
176
177 pizza->shadow_type = GTK_MYSHADOW_NONE;
178
179 pizza->children = NULL;
180
181 pizza->width = 20;
182 pizza->height = 20;
183
184 pizza->bin_window = NULL;
185
186 pizza->configure_serial = 0;
187 pizza->scroll_x = 0;
188 pizza->scroll_y = 0;
189 pizza->visibility = GDK_VISIBILITY_PARTIAL;
190
191 pizza->clear_on_draw = TRUE;
192 }
193
194 GtkWidget*
195 gtk_pizza_new ()
196 {
197 GtkPizza *pizza;
198
199 pizza = gtk_type_new (gtk_pizza_get_type ());
200
201 return GTK_WIDGET (pizza);
202 }
203
204 static void
205 gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
206 GtkAdjustment *hadj,
207 GtkAdjustment *vadj)
208 {
209 /* We handle scrolling in the wxScrolledWindow, not here. */
210 }
211
212 void
213 gtk_pizza_set_shadow_type (GtkPizza *pizza,
214 GtkMyShadowType type)
215 {
216 g_return_if_fail (pizza != NULL);
217 g_return_if_fail (GTK_IS_PIZZA (pizza));
218
219 if ((GtkMyShadowType) pizza->shadow_type != type)
220 {
221 pizza->shadow_type = type;
222
223 if (GTK_WIDGET_VISIBLE (pizza))
224 {
225 gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
226 gtk_widget_queue_draw (GTK_WIDGET (pizza));
227 }
228 }
229 }
230
231 void
232 gtk_pizza_set_clear (GtkPizza *pizza,
233 gboolean clear)
234 {
235 g_return_if_fail (pizza != NULL);
236 g_return_if_fail (GTK_IS_PIZZA (pizza));
237
238 pizza->clear_on_draw = clear;
239 }
240
241 void
242 gtk_pizza_put (GtkPizza *pizza,
243 GtkWidget *widget,
244 gint x,
245 gint y,
246 gint width,
247 gint height)
248 {
249 GtkPizzaChild *child_info;
250
251 g_return_if_fail (pizza != NULL);
252 g_return_if_fail (GTK_IS_PIZZA (pizza));
253 g_return_if_fail (widget != NULL);
254
255 child_info = g_new (GtkPizzaChild, 1);
256
257 child_info->widget = widget;
258 child_info->x = x;
259 child_info->y = y;
260 child_info->width = width;
261 child_info->height = height;
262
263 pizza->children = g_list_append (pizza->children, child_info);
264
265 gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
266
267 if (GTK_WIDGET_REALIZED (pizza))
268 gtk_widget_set_parent_window (widget, pizza->bin_window);
269
270 if (!IS_ONSCREEN (x, y))
271 GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN);
272
273 if (GTK_WIDGET_REALIZED (pizza))
274 gtk_widget_realize (widget);
275
276 gtk_widget_set_usize (widget, width, height);
277
278 if (GTK_WIDGET_VISIBLE (pizza) && GTK_WIDGET_VISIBLE (widget))
279 {
280 if (GTK_WIDGET_MAPPED (pizza))
281 gtk_widget_map (widget);
282
283 gtk_widget_queue_resize (widget);
284 }
285 }
286
287 void
288 gtk_pizza_move (GtkPizza *pizza,
289 GtkWidget *widget,
290 gint x,
291 gint y)
292 {
293 GtkPizzaChild *child;
294 GList *children;
295
296 g_return_if_fail (pizza != NULL);
297 g_return_if_fail (GTK_IS_PIZZA (pizza));
298 g_return_if_fail (widget != NULL);
299
300 children = pizza->children;
301 while (children)
302 {
303 child = children->data;
304 children = children->next;
305
306 if (child->widget == widget)
307 {
308 if ((child->x == x) && (child->y == y))
309 break;
310
311 child->x = x;
312 child->y = y;
313
314 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
315 gtk_widget_queue_resize (widget);
316 break;
317 }
318 }
319 }
320
321 void
322 gtk_pizza_resize (GtkPizza *pizza,
323 GtkWidget *widget,
324 gint width,
325 gint height)
326 {
327 GtkPizzaChild *child;
328 GList *children;
329
330 g_return_if_fail (pizza != NULL);
331 g_return_if_fail (GTK_IS_PIZZA (pizza));
332 g_return_if_fail (widget != NULL);
333
334 children = pizza->children;
335 while (children)
336 {
337 child = children->data;
338 children = children->next;
339
340 if (child->widget == widget)
341 {
342 if ((child->width == width) && (child->height == height))
343 break;
344
345 child->width = width;
346 child->height = height;
347
348 gtk_widget_set_usize (widget, width, height);
349
350 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
351 gtk_widget_queue_resize (widget);
352 break;
353 }
354 }
355 }
356
357 void
358 gtk_pizza_set_size (GtkPizza *pizza,
359 GtkWidget *widget,
360 gint x,
361 gint y,
362 gint width,
363 gint height)
364 {
365 GtkPizzaChild *child;
366 GList *children;
367
368 g_return_if_fail (pizza != NULL);
369 g_return_if_fail (GTK_IS_PIZZA (pizza));
370 g_return_if_fail (widget != NULL);
371
372 children = pizza->children;
373 while (children)
374 {
375 child = children->data;
376 children = children->next;
377
378 if (child->widget == widget)
379 {
380 if ((child->x == x) &&
381 (child->y == y) &&
382 (child->width == width) &&
383 (child->height == height)) return;
384
385 child->x = x;
386 child->y = y;
387 child->width = width;
388 child->height = height;
389
390 gtk_widget_set_usize (widget, width, height);
391
392 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
393 gtk_widget_queue_resize (widget);
394
395 return;
396 }
397 }
398 }
399
400 static void
401 gtk_pizza_map (GtkWidget *widget)
402 {
403 GtkPizza *pizza;
404 GtkPizzaChild *child;
405 GList *children;
406
407 g_return_if_fail (widget != NULL);
408 g_return_if_fail (GTK_IS_PIZZA (widget));
409
410 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
411 pizza = GTK_PIZZA (widget);
412
413 children = pizza->children;
414 while (children)
415 {
416 child = children->data;
417 children = children->next;
418
419 if ( GTK_WIDGET_VISIBLE (child->widget) &&
420 !GTK_WIDGET_MAPPED (child->widget) &&
421 !GTK_WIDGET_IS_OFFSCREEN (child->widget))
422 {
423 gtk_widget_map (child->widget);
424 }
425 }
426
427 gdk_window_show (widget->window);
428 gdk_window_show (pizza->bin_window);
429 }
430
431 static void
432 gtk_pizza_realize (GtkWidget *widget)
433 {
434 GtkPizza *pizza;
435 GdkWindowAttr attributes;
436 gint attributes_mask;
437 GtkPizzaChild *child;
438 GList *children;
439
440 g_return_if_fail (widget != NULL);
441 g_return_if_fail (GTK_IS_PIZZA (widget));
442
443 pizza = GTK_PIZZA (widget);
444
445 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
446
447 attributes.window_type = GDK_WINDOW_CHILD;
448
449 attributes.x = widget->allocation.x;
450 attributes.y = widget->allocation.y;
451 attributes.width = widget->allocation.width;
452 attributes.height = widget->allocation.height;
453
454 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
455 {
456 /* no border, no changes to sizes */
457 } else
458 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
459 {
460 /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
461 attributes.x += 1;
462 attributes.y += 1;
463 attributes.width -= 2;
464 attributes.height -= 2;
465 } else
466 {
467 /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
468 /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
469 attributes.x += 2;
470 attributes.y += 2;
471 attributes.width -= 4;
472 attributes.height -= 4;
473 }
474
475 /* minimal size */
476 if (attributes.width < 2) attributes.width = 2;
477 if (attributes.height < 2) attributes.height = 2;
478
479 attributes.wclass = GDK_INPUT_OUTPUT;
480 attributes.visual = gtk_widget_get_visual (widget);
481 attributes.colormap = gtk_widget_get_colormap (widget);
482 attributes.event_mask =
483 GDK_VISIBILITY_NOTIFY_MASK;
484 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
485
486 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
487 &attributes, attributes_mask);
488 gdk_window_set_user_data (widget->window, widget);
489
490 attributes.x = 0;
491 attributes.y = 0;
492
493 attributes.event_mask = gtk_widget_get_events (widget);
494 attributes.event_mask |=
495 GDK_EXPOSURE_MASK |
496 GDK_POINTER_MOTION_MASK |
497 GDK_POINTER_MOTION_HINT_MASK |
498 GDK_BUTTON_MOTION_MASK |
499 GDK_BUTTON1_MOTION_MASK |
500 GDK_BUTTON2_MOTION_MASK |
501 GDK_BUTTON3_MOTION_MASK |
502 GDK_BUTTON_PRESS_MASK |
503 GDK_BUTTON_RELEASE_MASK |
504 GDK_KEY_PRESS_MASK |
505 GDK_KEY_RELEASE_MASK |
506 GDK_ENTER_NOTIFY_MASK |
507 GDK_LEAVE_NOTIFY_MASK |
508 GDK_FOCUS_CHANGE_MASK;
509
510 pizza->bin_window = gdk_window_new (widget->window,
511 &attributes, attributes_mask);
512 gdk_window_set_user_data (pizza->bin_window, widget);
513
514 widget->style = gtk_style_attach (widget->style, widget->window);
515 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
516 gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL);
517
518 /* add filters for intercepting visibility and expose events */
519 gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
520 gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
521
522 /* we NEED gravity or we'll give up */
523 gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
524
525 /* cannot be done before realisation */
526 children = pizza->children;
527 while (children)
528 {
529 child = children->data;
530 children = children->next;
531
532 gtk_widget_set_parent_window (child->widget, pizza->bin_window);
533 }
534 }
535
536 static void
537 gtk_pizza_unrealize (GtkWidget *widget)
538 {
539 GtkPizza *pizza;
540
541 g_return_if_fail (widget != NULL);
542 g_return_if_fail (GTK_IS_PIZZA (widget));
543
544 pizza = GTK_PIZZA (widget);
545
546 gdk_window_set_user_data (pizza->bin_window, NULL);
547 gdk_window_destroy (pizza->bin_window);
548 pizza->bin_window = NULL;
549
550 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
551 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
552 }
553
554 static void
555 gtk_pizza_size_request (GtkWidget *widget,
556 GtkRequisition *requisition)
557 {
558 GtkPizza *pizza;
559 GtkPizzaChild *child;
560 GList *children;
561 GtkRequisition child_requisition;
562
563 g_return_if_fail (widget != NULL);
564 g_return_if_fail (GTK_IS_PIZZA (widget));
565 g_return_if_fail (requisition != NULL);
566
567 pizza = GTK_PIZZA (widget);
568
569 children = pizza->children;
570 while (children)
571 {
572 child = children->data;
573 children = children->next;
574
575 if (GTK_WIDGET_VISIBLE (child->widget))
576 {
577 gtk_widget_size_request (child->widget, &child_requisition);
578 }
579 }
580
581 /* request very little, I'm not sure if requesting nothing
582 will always have positive effects on stability... */
583 requisition->width = 2;
584 requisition->height = 2;
585 }
586
587 static void
588 gtk_pizza_size_allocate (GtkWidget *widget,
589 GtkAllocation *allocation)
590 {
591 GtkPizza *pizza;
592 gint border;
593 gint x,y,w,h;
594 GtkPizzaChild *child;
595 GList *children;
596
597 g_return_if_fail (widget != NULL);
598 g_return_if_fail (GTK_IS_PIZZA(widget));
599 g_return_if_fail (allocation != NULL);
600
601 pizza = GTK_PIZZA (widget);
602
603 widget->allocation = *allocation;
604
605 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
606 border = 0;
607 else
608 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
609 border = 1;
610 else
611 border = 2;
612
613 x = allocation->x + border;
614 y = allocation->y + border;
615 w = allocation->width - border*2;
616 h = allocation->height - border*2;
617
618 if (GTK_WIDGET_REALIZED (widget))
619 {
620 gdk_window_move_resize( widget->window, x, y, w, h );
621 gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
622 }
623
624 children = pizza->children;
625 while (children)
626 {
627 child = children->data;
628 children = children->next;
629
630 gtk_pizza_position_child (pizza, child);
631 gtk_pizza_allocate_child (pizza, child);
632 }
633 }
634
635 static void
636 gtk_pizza_draw (GtkWidget *widget,
637 GdkRectangle *area)
638 {
639 GtkPizza *pizza;
640 GtkPizzaChild *child;
641 GdkRectangle child_area;
642 GList *children;
643
644 g_return_if_fail (widget != NULL);
645 g_return_if_fail (GTK_IS_PIZZA (widget));
646
647 pizza = GTK_PIZZA (widget);
648
649 children = pizza->children;
650 if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
651 (pizza->clear_on_draw))
652 {
653 gdk_window_clear_area( pizza->bin_window,
654 area->x, area->y, area->width, area->height);
655 }
656
657 while (children)
658 {
659 child = children->data;
660 children = children->next;
661
662 if (gtk_widget_intersect (child->widget, area, &child_area))
663 gtk_widget_draw (child->widget, &child_area);
664 }
665 }
666
667 static gint
668 gtk_pizza_expose (GtkWidget *widget,
669 GdkEventExpose *event)
670 {
671 GtkPizza *pizza;
672 GtkPizzaChild *child;
673 GdkEventExpose child_event;
674 GList *children;
675
676 g_return_val_if_fail (widget != NULL, FALSE);
677 g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
678 g_return_val_if_fail (event != NULL, FALSE);
679
680 pizza = GTK_PIZZA (widget);
681
682 /*
683 if (event->window == widget->window)
684 {
685 gtk_pizza_draw_border( pizza );
686 return FALSE;
687 }
688 */
689
690 if (event->window != pizza->bin_window)
691 return FALSE;
692
693 children = pizza->children;
694 while (children)
695 {
696 child = children->data;
697 children = children->next;
698
699 child_event = *event;
700
701 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
702 GTK_WIDGET_DRAWABLE (child->widget) &&
703 gtk_widget_intersect (child->widget, &event->area, &child_event.area))
704 {
705 gtk_widget_event (child->widget, (GdkEvent*) &child_event);
706 }
707 }
708
709 return FALSE;
710 }
711
712 static void
713 gtk_pizza_add (GtkContainer *container,
714 GtkWidget *widget)
715 {
716 g_return_if_fail (container != NULL);
717 g_return_if_fail (GTK_IS_PIZZA (container));
718 g_return_if_fail (widget != NULL);
719
720 gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
721 }
722
723 static void
724 gtk_pizza_remove (GtkContainer *container,
725 GtkWidget *widget)
726 {
727 GtkPizza *pizza;
728 GtkPizzaChild *child;
729 GList *children;
730
731 g_return_if_fail (container != NULL);
732 g_return_if_fail (GTK_IS_PIZZA (container));
733 g_return_if_fail (widget != NULL);
734
735 pizza = GTK_PIZZA (container);
736
737 children = pizza->children;
738 while (children)
739 {
740 child = children->data;
741
742 if (child->widget == widget)
743 {
744 gtk_widget_unparent (widget);
745
746 /* security checks */
747 g_return_if_fail (GTK_IS_WIDGET (widget));
748
749 pizza->children = g_list_remove_link (pizza->children, children);
750 g_list_free (children);
751 g_free (child);
752
753 /* security checks */
754 g_return_if_fail (GTK_IS_WIDGET (widget));
755
756 GTK_PRIVATE_UNSET_FLAG (widget, GTK_IS_OFFSCREEN);
757
758 break;
759 }
760
761 children = children->next;
762 }
763 }
764
765 static void
766 gtk_pizza_forall (GtkContainer *container,
767 gboolean include_internals,
768 GtkCallback callback,
769 gpointer callback_data)
770 {
771 GtkPizza *pizza;
772 GtkPizzaChild *child;
773 GList *children;
774
775 g_return_if_fail (container != NULL);
776 g_return_if_fail (GTK_IS_PIZZA (container));
777 g_return_if_fail (callback != NULL);
778
779 pizza = GTK_PIZZA (container);
780
781 children = pizza->children;
782 while (children)
783 {
784 child = children->data;
785 children = children->next;
786
787 (* callback) (child->widget, callback_data);
788 }
789 }
790
791
792 /* Operations on children
793 */
794
795 static void
796 gtk_pizza_position_child (GtkPizza *pizza,
797 GtkPizzaChild *child)
798 {
799 gint x;
800 gint y;
801
802 x = child->x - pizza->xoffset;
803 y = child->y - pizza->yoffset;
804
805 if (IS_ONSCREEN (x,y))
806 {
807 if (GTK_WIDGET_MAPPED (pizza) &&
808 GTK_WIDGET_VISIBLE (child->widget))
809 {
810 if (!GTK_WIDGET_MAPPED (child->widget))
811 gtk_widget_map (child->widget);
812 }
813
814 if (GTK_WIDGET_IS_OFFSCREEN (child->widget))
815 GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN);
816 }
817 else
818 {
819 if (!GTK_WIDGET_IS_OFFSCREEN (child->widget))
820 GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN);
821
822 if (GTK_WIDGET_MAPPED (child->widget))
823 gtk_widget_unmap (child->widget);
824 }
825 }
826
827 static void
828 gtk_pizza_allocate_child (GtkPizza *pizza,
829 GtkPizzaChild *child)
830 {
831 GtkAllocation allocation;
832 GtkRequisition requisition;
833
834 allocation.x = child->x - pizza->xoffset;
835 allocation.y = child->y - pizza->yoffset;
836 gtk_widget_get_child_requisition (child->widget, &requisition);
837 allocation.width = requisition.width;
838 allocation.height = requisition.height;
839
840 gtk_widget_size_allocate (child->widget, &allocation);
841 }
842
843 static void
844 gtk_pizza_position_children (GtkPizza *pizza)
845 {
846 GList *tmp_list;
847
848 tmp_list = pizza->children;
849 while (tmp_list)
850 {
851 GtkPizzaChild *child = tmp_list->data;
852 tmp_list = tmp_list->next;
853
854 gtk_pizza_position_child (pizza, child);
855 }
856 }
857
858 static void
859 gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
860 gpointer cb_data)
861 {
862 GtkPizzaAdjData *data = cb_data;
863
864 widget->allocation.x += data->dx;
865 widget->allocation.y += data->dy;
866
867 if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
868 {
869 gtk_container_forall (GTK_CONTAINER (widget),
870 gtk_pizza_adjust_allocations_recurse,
871 cb_data);
872 }
873 }
874
875 static void
876 gtk_pizza_adjust_allocations (GtkPizza *pizza,
877 gint dx,
878 gint dy)
879 {
880 GList *tmp_list;
881 GtkPizzaAdjData data;
882
883 data.dx = dx;
884 data.dy = dy;
885
886 tmp_list = pizza->children;
887 while (tmp_list)
888 {
889 GtkPizzaChild *child = tmp_list->data;
890 tmp_list = tmp_list->next;
891
892 child->widget->allocation.x += dx;
893 child->widget->allocation.y += dy;
894
895 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
896 GTK_IS_CONTAINER (child->widget))
897 gtk_container_forall (GTK_CONTAINER (child->widget),
898 gtk_pizza_adjust_allocations_recurse,
899 &data);
900 }
901 }
902
903 /* Callbacks */
904
905 /* Send a synthetic expose event to the widget
906 */
907 static void
908 gtk_pizza_expose_area (GtkPizza *pizza,
909 gint x, gint y, gint width, gint height)
910 {
911 if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
912 {
913 GdkEventExpose event;
914
915 event.type = GDK_EXPOSE;
916 event.send_event = TRUE;
917 event.window = pizza->bin_window;
918 event.count = 0;
919
920 event.area.x = x;
921 event.area.y = y;
922 event.area.width = width;
923 event.area.height = height;
924
925 gdk_window_ref (event.window);
926 gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
927 gdk_window_unref (event.window);
928 }
929 }
930
931 /* This function is used to find events to process while scrolling
932 */
933
934 static Bool
935 gtk_pizza_expose_predicate (Display *display,
936 XEvent *xevent,
937 XPointer arg)
938 {
939 if ((xevent->type == Expose) ||
940 ((xevent->xany.window == *(Window *)arg) &&
941 (xevent->type == ConfigureNotify)))
942 return True;
943 else
944 return False;
945 }
946
947 /* This is the main routine to do the scrolling. Scrolling is
948 * done by "Guffaw" scrolling, as in the Mozilla XFE, with
949 * a few modifications.
950 *
951 * The main improvement is that we keep track of whether we
952 * are obscured or not. If not, we ignore the generated expose
953 * events and instead do the exposes ourself, without having
954 * to wait for a roundtrip to the server. This also provides
955 * a limited form of expose-event compression, since we do
956 * the affected area as one big chunk.
957 */
958
959 void
960 gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
961 {
962 GtkWidget *widget;
963 XEvent xevent;
964
965 gint x,y,w,h,border;
966
967 widget = GTK_WIDGET (pizza);
968
969 pizza->xoffset += dx;
970 pizza->yoffset += dy;
971
972 if (!GTK_WIDGET_MAPPED (pizza))
973 {
974 gtk_pizza_position_children (pizza);
975 return;
976 }
977
978 gtk_pizza_adjust_allocations (pizza, -dx, -dy);
979
980 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
981 border = 0;
982 else
983 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
984 border = 1;
985 else
986 border = 2;
987
988 x = 0;
989 y = 0;
990 w = widget->allocation.width - 2*border;
991 h = widget->allocation.height - 2*border;
992
993 if (dx > 0)
994 {
995 if (gravity_works)
996 {
997 gdk_window_resize (pizza->bin_window,
998 w + dx,
999 h);
1000 gdk_window_move (pizza->bin_window, x-dx, y);
1001 gdk_window_move_resize (pizza->bin_window, x, y, w, h );
1002 }
1003 else
1004 {
1005 /* FIXME */
1006 }
1007
1008 gtk_pizza_expose_area (pizza,
1009 MAX ((gint)w - dx, 0),
1010 0,
1011 MIN (dx, w),
1012 h);
1013 }
1014 else if (dx < 0)
1015 {
1016 if (gravity_works)
1017 {
1018 gdk_window_move_resize (pizza->bin_window,
1019 x + dx,
1020 y,
1021 w - dx,
1022 h);
1023 gdk_window_move (pizza->bin_window, x, y);
1024 gdk_window_resize (pizza->bin_window, w, h );
1025 }
1026 else
1027 {
1028 /* FIXME */
1029 }
1030
1031 gtk_pizza_expose_area (pizza,
1032 0,
1033 0,
1034 MIN (-dx, w),
1035 h);
1036 }
1037
1038 if (dy > 0)
1039 {
1040 if (gravity_works)
1041 {
1042 gdk_window_resize (pizza->bin_window, w, h + dy);
1043 gdk_window_move (pizza->bin_window, x, y-dy);
1044 gdk_window_move_resize (pizza->bin_window,
1045 x, y, w, h );
1046 }
1047 else
1048 {
1049 /* FIXME */
1050 }
1051
1052 gtk_pizza_expose_area (pizza,
1053 0,
1054 MAX ((gint)h - dy, 0),
1055 w,
1056 MIN (dy, h));
1057 }
1058 else if (dy < 0)
1059 {
1060 if (gravity_works)
1061 {
1062 gdk_window_move_resize (pizza->bin_window,
1063 x, y+dy, w, h - dy );
1064 gdk_window_move (pizza->bin_window, x, y);
1065 gdk_window_resize (pizza->bin_window, w, h );
1066 }
1067 else
1068 {
1069 /* FIXME */
1070 }
1071 gtk_pizza_expose_area (pizza,
1072 0,
1073 0,
1074 w,
1075 MIN (-dy, (gint)h));
1076 }
1077
1078 gtk_pizza_position_children (pizza);
1079
1080 /* We have to make sure that all exposes from this scroll get
1081 * processed before we scroll again, or the expose events will
1082 * have invalid coordinates.
1083 *
1084 * We also do expose events for other windows, since otherwise
1085 * their updating will fall behind the scrolling
1086 *
1087 * This also avoids a problem in pre-1.0 GTK where filters don't
1088 * have access to configure events that were compressed.
1089 */
1090
1091 gdk_flush();
1092 while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
1093 &xevent,
1094 gtk_pizza_expose_predicate,
1095 (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
1096 {
1097 GdkEvent event;
1098 GtkWidget *event_widget;
1099
1100 if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) &&
1101 (gtk_pizza_filter (&xevent, &event, pizza) == GDK_FILTER_REMOVE))
1102 continue;
1103
1104 if (xevent.type == Expose)
1105 {
1106 event.expose.window = gdk_window_lookup (xevent.xany.window);
1107 gdk_window_get_user_data (event.expose.window,
1108 (gpointer *)&event_widget);
1109
1110 if (event_widget)
1111 {
1112 event.expose.type = GDK_EXPOSE;
1113 event.expose.area.x = xevent.xexpose.x;
1114 event.expose.area.y = xevent.xexpose.y;
1115 event.expose.area.width = xevent.xexpose.width;
1116 event.expose.area.height = xevent.xexpose.height;
1117 event.expose.count = xevent.xexpose.count;
1118
1119 gdk_window_ref (event.expose.window);
1120 gtk_widget_event (event_widget, &event);
1121 gdk_window_unref (event.expose.window);
1122 }
1123 }
1124 }
1125 }
1126
1127 /* The main event filter. Actually, we probably don't really need
1128 * to install this as a filter at all, since we are calling it
1129 * directly above in the expose-handling hack. But in case scrollbars
1130 * are fixed up in some manner...
1131 *
1132 * This routine identifies expose events that are generated when
1133 * we've temporarily moved the bin_window_origin, and translates
1134 * them or discards them, depending on whether we are obscured
1135 * or not.
1136 */
1137 static GdkFilterReturn
1138 gtk_pizza_filter (GdkXEvent *gdk_xevent,
1139 GdkEvent *event,
1140 gpointer data)
1141 {
1142 XEvent *xevent;
1143 GtkPizza *pizza;
1144
1145 xevent = (XEvent *)gdk_xevent;
1146 pizza = GTK_PIZZA (data);
1147
1148 switch (xevent->type)
1149 {
1150 case Expose:
1151 if (xevent->xexpose.serial == pizza->configure_serial)
1152 {
1153 if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
1154 return GDK_FILTER_REMOVE;
1155 else
1156 {
1157 xevent->xexpose.x += pizza->scroll_x;
1158 xevent->xexpose.y += pizza->scroll_y;
1159
1160 break;
1161 }
1162 }
1163 break;
1164
1165 case ConfigureNotify:
1166 if ((xevent->xconfigure.x != 0) || (xevent->xconfigure.y != 0))
1167 {
1168 pizza->configure_serial = xevent->xconfigure.serial;
1169 pizza->scroll_x = xevent->xconfigure.x;
1170 pizza->scroll_y = xevent->xconfigure.y;
1171 }
1172 break;
1173 }
1174
1175 return GDK_FILTER_CONTINUE;
1176 }
1177
1178 /* Although GDK does have a GDK_VISIBILITY_NOTIFY event,
1179 * there is no corresponding event in GTK, so we have
1180 * to get the events from a filter
1181 */
1182 static GdkFilterReturn
1183 gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
1184 GdkEvent *event,
1185 gpointer data)
1186 {
1187 XEvent *xevent;
1188 GtkPizza *pizza;
1189
1190 xevent = (XEvent *)gdk_xevent;
1191 pizza = GTK_PIZZA (data);
1192
1193 if (xevent->type == VisibilityNotify)
1194 {
1195 switch (xevent->xvisibility.state)
1196 {
1197 case VisibilityFullyObscured:
1198 pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1199 break;
1200
1201 case VisibilityPartiallyObscured:
1202 pizza->visibility = GDK_VISIBILITY_PARTIAL;
1203 break;
1204
1205 case VisibilityUnobscured:
1206 pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
1207 break;
1208 }
1209
1210 return GDK_FILTER_REMOVE;
1211 }
1212
1213
1214 return GDK_FILTER_CONTINUE;
1215 }
1216
1217
1218
1219
1220 #ifdef __cplusplus
1221 }
1222 #endif /* __cplusplus */
1223
wxWidgets (Impactor)