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