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


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