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