]> 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
unnecessary ClipRects
[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 = GDK_VISIBILITY_NOTIFY_MASK;
553 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
554
555 widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
556 &attributes, attributes_mask);
557 gdk_window_set_user_data (widget->window, widget);
558
559 attributes.x = 0;
560 attributes.y = 0;
561
562 attributes.event_mask = gtk_widget_get_events (widget);
563 attributes.event_mask |= GDK_EXPOSURE_MASK |
564 GDK_POINTER_MOTION_MASK |
565 GDK_POINTER_MOTION_HINT_MASK |
566 GDK_BUTTON_MOTION_MASK |
567 GDK_BUTTON1_MOTION_MASK |
568 GDK_BUTTON2_MOTION_MASK |
569 GDK_BUTTON3_MOTION_MASK |
570 GDK_BUTTON_PRESS_MASK |
571 GDK_BUTTON_RELEASE_MASK |
572 GDK_KEY_PRESS_MASK |
573 GDK_KEY_RELEASE_MASK |
574 GDK_ENTER_NOTIFY_MASK |
575 GDK_LEAVE_NOTIFY_MASK |
576 GDK_FOCUS_CHANGE_MASK;
577
578 pizza->bin_window = gdk_window_new(widget->window,
579 &attributes, attributes_mask);
580 gdk_window_set_user_data (pizza->bin_window, widget);
581
582 widget->style = gtk_style_attach (widget->style, widget->window);
583 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
584 gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
585
586 /* add filters for intercepting visibility and expose events */
587 gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
588 gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
589
590 /* we NEED gravity or we'll give up */
591 gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
592
593 /* cannot be done before realisation */
594 children = pizza->children;
595 while (children)
596 {
597 child = children->data;
598 children = children->next;
599
600 gtk_widget_set_parent_window (child->widget, pizza->bin_window);
601 }
602}
603
604static void
605gtk_pizza_unrealize (GtkWidget *widget)
606{
607 GtkPizza *pizza;
608
609 g_return_if_fail (widget != NULL);
610 g_return_if_fail (GTK_IS_PIZZA (widget));
611
612 pizza = GTK_PIZZA (widget);
613
614 gdk_window_set_user_data (pizza->bin_window, NULL);
615 gdk_window_destroy (pizza->bin_window);
616 pizza->bin_window = NULL;
617
618 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
619 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
620}
621
622static void
623gtk_pizza_size_request (GtkWidget *widget,
624 GtkRequisition *requisition)
625{
626 GtkPizza *pizza;
627 GtkPizzaChild *child;
628 GList *children;
629 GtkRequisition child_requisition;
630
631 g_return_if_fail (widget != NULL);
632 g_return_if_fail (GTK_IS_PIZZA (widget));
633 g_return_if_fail (requisition != NULL);
634
635 pizza = GTK_PIZZA (widget);
636
637 children = pizza->children;
638 while (children)
639 {
640 child = children->data;
641 children = children->next;
642
643 if (GTK_WIDGET_VISIBLE (child->widget))
644 {
645 gtk_widget_size_request (child->widget, &child_requisition);
646 }
647 }
648
649 /* request very little, I'm not sure if requesting nothing
650 will always have positive effects on stability... */
651 requisition->width = 2;
652 requisition->height = 2;
653}
654
655static void
656gtk_pizza_size_allocate (GtkWidget *widget,
657 GtkAllocation *allocation)
658{
659 GtkPizza *pizza;
660 gint border;
661 gint x,y,w,h;
662 GtkPizzaChild *child;
663 GList *children;
664
665 g_return_if_fail (widget != NULL);
666 g_return_if_fail (GTK_IS_PIZZA(widget));
667 g_return_if_fail (allocation != NULL);
668
669 pizza = GTK_PIZZA (widget);
670
671 widget->allocation = *allocation;
672
673 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
674 border = 0;
675 else
676 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
677 border = 1;
678 else
679 border = 2;
680
681 x = allocation->x + border;
682 y = allocation->y + border;
683 w = allocation->width - border*2;
684 h = allocation->height - border*2;
685
686 if (GTK_WIDGET_REALIZED (widget))
687 {
688 gdk_window_move_resize( widget->window, x, y, w, h );
689 gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
690 }
691
692 children = pizza->children;
693 while (children)
694 {
695 child = children->data;
696 children = children->next;
697
698 gtk_pizza_position_child (pizza, child);
699 gtk_pizza_allocate_child (pizza, child);
700 }
701}
702
703static void
704gtk_pizza_draw (GtkWidget *widget,
705 GdkRectangle *area)
706{
707 GtkPizza *pizza;
708 GtkPizzaChild *child;
709 GdkRectangle child_area;
710 GList *children;
711
712 g_return_if_fail (widget != NULL);
713 g_return_if_fail (GTK_IS_PIZZA (widget));
714
715 pizza = GTK_PIZZA (widget);
716
717 /* Sometimes, We handle all expose events in window.cpp now. */
718 if (pizza->external_expose)
719 return;
720
721 children = pizza->children;
722 if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
723 (pizza->clear_on_draw))
724 {
725 gdk_window_clear_area( pizza->bin_window,
726 area->x, area->y, area->width, area->height);
727 }
728
729 while (children)
730 {
731 child = children->data;
732 children = children->next;
733
734 if (gtk_widget_intersect (child->widget, area, &child_area))
735 gtk_widget_draw (child->widget, &child_area);
736 }
737}
738
739static gint
740gtk_pizza_expose (GtkWidget *widget,
741 GdkEventExpose *event)
742{
743 GtkPizza *pizza;
744 GtkPizzaChild *child;
745 GdkEventExpose child_event;
746 GList *children;
747
748 g_return_val_if_fail (widget != NULL, FALSE);
749 g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
750 g_return_val_if_fail (event != NULL, FALSE);
751
752 pizza = GTK_PIZZA (widget);
753
754 /* Sometimes, We handle all expose events in window.cpp now. */
755 if (pizza->external_expose)
756 return FALSE;
757
758 if (event->window != pizza->bin_window)
759 return FALSE;
760
761 children = pizza->children;
762 while (children)
763 {
764 child = children->data;
765 children = children->next;
766
767 child_event = *event;
768
769 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
770 GTK_WIDGET_DRAWABLE (child->widget) &&
771 gtk_widget_intersect (child->widget, &event->area, &child_event.area))
772 {
773 gtk_widget_event (child->widget, (GdkEvent*) &child_event);
774 }
775 }
776
777 return TRUE;
778}
779
780static void
781gtk_pizza_add (GtkContainer *container,
782 GtkWidget *widget)
783{
784 g_return_if_fail (container != NULL);
785 g_return_if_fail (GTK_IS_PIZZA (container));
786 g_return_if_fail (widget != NULL);
787
788 gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
789}
790
791static void
792gtk_pizza_remove (GtkContainer *container,
793 GtkWidget *widget)
794{
795 GtkPizza *pizza;
796 GtkPizzaChild *child;
797 GList *children;
798
799 g_return_if_fail (container != NULL);
800 g_return_if_fail (GTK_IS_PIZZA (container));
801 g_return_if_fail (widget != NULL);
802
803 pizza = GTK_PIZZA (container);
804
805 children = pizza->children;
806 while (children)
807 {
808 child = children->data;
809
810 if (child->widget == widget)
811 {
812 gtk_widget_unparent (widget);
813
814 /* security checks */
815 g_return_if_fail (GTK_IS_WIDGET (widget));
816
817 pizza->children = g_list_remove_link (pizza->children, children);
818 g_list_free (children);
819 g_free (child);
820
821 /* security checks */
822 g_return_if_fail (GTK_IS_WIDGET (widget));
823
824#ifndef __WXGTK20__
825 GTK_PRIVATE_UNSET_FLAG (widget, GTK_IS_OFFSCREEN);
826#endif
827
828 break;
829 }
830
831 children = children->next;
832 }
833}
834
835static void
836gtk_pizza_forall (GtkContainer *container,
837 gboolean include_internals,
838 GtkCallback callback,
839 gpointer callback_data)
840{
841 GtkPizza *pizza;
842 GtkPizzaChild *child;
843 GList *children;
844
845 g_return_if_fail (container != NULL);
846 g_return_if_fail (GTK_IS_PIZZA (container));
847 g_return_if_fail (callback != NULL);
848
849 pizza = GTK_PIZZA (container);
850
851 children = pizza->children;
852 while (children)
853 {
854 child = children->data;
855 children = children->next;
856
857 (* callback) (child->widget, callback_data);
858 }
859}
860
861
862/* Operations on children
863 */
864
865static void
866gtk_pizza_position_child (GtkPizza *pizza,
867 GtkPizzaChild *child)
868{
869 gint x;
870 gint y;
871
872 x = child->x - pizza->xoffset;
873 y = child->y - pizza->yoffset;
874
875 if (IS_ONSCREEN (x,y))
876 {
877 if (GTK_WIDGET_MAPPED (pizza) &&
878 GTK_WIDGET_VISIBLE (child->widget))
879 {
880 if (!GTK_WIDGET_MAPPED (child->widget))
881 gtk_widget_map (child->widget);
882 }
883
884#ifndef __WXGTK20__
885 if (GTK_WIDGET_IS_OFFSCREEN (child->widget))
886 GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN);
887#endif
888 }
889 else
890 {
891#ifndef __WXGTK20__
892 if (!GTK_WIDGET_IS_OFFSCREEN (child->widget))
893 GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN);
894#endif
895
896 if (GTK_WIDGET_MAPPED (child->widget))
897 gtk_widget_unmap (child->widget);
898 }
899}
900
901static void
902gtk_pizza_allocate_child (GtkPizza *pizza,
903 GtkPizzaChild *child)
904{
905 GtkAllocation allocation;
906 GtkRequisition requisition;
907
908 allocation.x = child->x - pizza->xoffset;
909 allocation.y = child->y - pizza->yoffset;
910 gtk_widget_get_child_requisition (child->widget, &requisition);
911 allocation.width = requisition.width;
912 allocation.height = requisition.height;
913
914 gtk_widget_size_allocate (child->widget, &allocation);
915}
916
917static void
918gtk_pizza_position_children (GtkPizza *pizza)
919{
920 GList *tmp_list;
921
922 tmp_list = pizza->children;
923 while (tmp_list)
924 {
925 GtkPizzaChild *child = tmp_list->data;
926 tmp_list = tmp_list->next;
927
928 gtk_pizza_position_child (pizza, child);
929 }
930}
931
932static void
933gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
934 gpointer cb_data)
935{
936 GtkPizzaAdjData *data = cb_data;
937
938 widget->allocation.x += data->dx;
939 widget->allocation.y += data->dy;
940
941 if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
942 {
943 gtk_container_forall (GTK_CONTAINER (widget),
944 gtk_pizza_adjust_allocations_recurse,
945 cb_data);
946 }
947}
948
949static void
950gtk_pizza_adjust_allocations (GtkPizza *pizza,
951 gint dx,
952 gint dy)
953{
954 GList *tmp_list;
955 GtkPizzaAdjData data;
956
957 data.dx = dx;
958 data.dy = dy;
959
960 tmp_list = pizza->children;
961 while (tmp_list)
962 {
963 GtkPizzaChild *child = tmp_list->data;
964 tmp_list = tmp_list->next;
965
966 child->widget->allocation.x += dx;
967 child->widget->allocation.y += dy;
968
969 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
970 GTK_IS_CONTAINER (child->widget))
971 {
972 gtk_container_forall (GTK_CONTAINER (child->widget),
973 gtk_pizza_adjust_allocations_recurse,
974 &data);
975 }
976 }
977}
978
979/* Callbacks */
980
981/* unused */
982#if 0
983/* Send a synthetic expose event to the widget
984 */
985static void
986gtk_pizza_expose_area (GtkPizza *pizza,
987 gint x, gint y, gint width, gint height)
988{
989 if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
990 {
991 GdkEventExpose event;
992
993 event.type = GDK_EXPOSE;
994 event.send_event = TRUE;
995 event.window = pizza->bin_window;
996 event.count = 0;
997
998 event.area.x = x;
999 event.area.y = y;
1000 event.area.width = width;
1001 event.area.height = height;
1002
1003 gdk_window_ref (event.window);
1004 gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
1005 gdk_window_unref (event.window);
1006 }
1007}
1008#endif /* unused */
1009
1010/* This function is used to find events to process while scrolling
1011 */
1012
1013static Bool
1014gtk_pizza_expose_predicate (Display *display,
1015 XEvent *xevent,
1016 XPointer arg)
1017{
1018 if ((xevent->type == Expose) ||
1019 ((xevent->xany.window == *(Window *)arg) &&
1020 (xevent->type == ConfigureNotify)))
1021 return True;
1022 else
1023 return False;
1024}
1025
1026/* This is the main routine to do the scrolling. Scrolling is
1027 * done by "Guffaw" scrolling, as in the Mozilla XFE, with
1028 * a few modifications.
1029 *
1030 * The main improvement is that we keep track of whether we
1031 * are obscured or not. If not, we ignore the generated expose
1032 * events and instead do the exposes ourself, without having
1033 * to wait for a roundtrip to the server. This also provides
1034 * a limited form of expose-event compression, since we do
1035 * the affected area as one big chunk.
1036 */
1037
1038void
1039gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
1040{
1041 GtkWidget *widget;
1042 XEvent xevent;
1043
1044 gint x,y,w,h,border;
1045
1046 widget = GTK_WIDGET (pizza);
1047
1048 pizza->xoffset += dx;
1049 pizza->yoffset += dy;
1050
1051 if (!GTK_WIDGET_MAPPED (pizza))
1052 {
1053 gtk_pizza_position_children (pizza);
1054 return;
1055 }
1056
1057 gtk_pizza_adjust_allocations (pizza, -dx, -dy);
1058
1059 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
1060 border = 0;
1061 else
1062 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
1063 border = 1;
1064 else
1065 border = 2;
1066
1067 x = 0;
1068 y = 0;
1069 w = widget->allocation.width - 2*border;
1070 h = widget->allocation.height - 2*border;
1071
1072 if (dx > 0)
1073 {
1074 if (gravity_works)
1075 {
1076 gdk_window_resize (pizza->bin_window,
1077 w + dx,
1078 h);
1079 gdk_window_move (pizza->bin_window, x-dx, y);
1080 gdk_window_move_resize (pizza->bin_window, x, y, w, h );
1081 }
1082 else
1083 {
1084 /* FIXME */
1085 }
1086 }
1087 else if (dx < 0)
1088 {
1089 if (gravity_works)
1090 {
1091 gdk_window_move_resize (pizza->bin_window,
1092 x + dx,
1093 y,
1094 w - dx,
1095 h);
1096 gdk_window_move (pizza->bin_window, x, y);
1097 gdk_window_resize (pizza->bin_window, w, h );
1098 }
1099 else
1100 {
1101 /* FIXME */
1102 }
1103 }
1104
1105 if (dy > 0)
1106 {
1107 if (gravity_works)
1108 {
1109 gdk_window_resize (pizza->bin_window, w, h + dy);
1110 gdk_window_move (pizza->bin_window, x, y-dy);
1111 gdk_window_move_resize (pizza->bin_window,
1112 x, y, w, h );
1113 }
1114 else
1115 {
1116 /* FIXME */
1117 }
1118 }
1119 else if (dy < 0)
1120 {
1121 if (gravity_works)
1122 {
1123 gdk_window_move_resize (pizza->bin_window,
1124 x, y+dy, w, h - dy );
1125 gdk_window_move (pizza->bin_window, x, y);
1126 gdk_window_resize (pizza->bin_window, w, h );
1127 }
1128 else
1129 {
1130 /* FIXME */
1131 }
1132 }
1133
1134 gtk_pizza_position_children (pizza);
1135
1136 gdk_flush();
1137 while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
1138 &xevent,
1139 gtk_pizza_expose_predicate,
1140 (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
1141 {
1142 GdkEvent event;
1143 GtkWidget *event_widget;
1144
1145 if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) )
1146 gtk_pizza_filter (&xevent, &event, pizza);
1147
1148 if (xevent.type == Expose)
1149 {
1150 event.expose.window = gdk_window_lookup (xevent.xany.window);
1151 gdk_window_get_user_data (event.expose.window,
1152 (gpointer *)&event_widget);
1153
1154 if (event_widget)
1155 {
1156 event.expose.type = GDK_EXPOSE;
1157 event.expose.area.x = xevent.xexpose.x;
1158 event.expose.area.y = xevent.xexpose.y;
1159 event.expose.area.width = xevent.xexpose.width;
1160 event.expose.area.height = xevent.xexpose.height;
1161 event.expose.count = xevent.xexpose.count;
1162
1163 gdk_window_ref (event.expose.window);
1164 gtk_widget_event (event_widget, &event);
1165 gdk_window_unref (event.expose.window);
1166 }
1167 }
1168 }
1169}
1170
1171/* The main event filter. Actually, we probably don't really need
1172 * to install this as a filter at all, since we are calling it
1173 * directly above in the expose-handling hack. But in case scrollbars
1174 * are fixed up in some manner...
1175 *
1176 * This routine identifies expose events that are generated when
1177 * we've temporarily moved the bin_window_origin, and translates
1178 * them or discards them, depending on whether we are obscured
1179 * or not.
1180 */
1181static GdkFilterReturn
1182gtk_pizza_filter (GdkXEvent *gdk_xevent,
1183 GdkEvent *event,
1184 gpointer data)
1185{
1186 XEvent *xevent;
1187 GtkPizza *pizza;
1188
1189 xevent = (XEvent *)gdk_xevent;
1190
1191 pizza = GTK_PIZZA (data);
1192
1193 if (!pizza->use_filter)
1194 return GDK_FILTER_CONTINUE;
1195
1196 switch (xevent->type)
1197 {
1198 case Expose:
1199 if (xevent->xexpose.serial == pizza->configure_serial)
1200 {
1201 xevent->xexpose.x += pizza->scroll_x;
1202 xevent->xexpose.y += pizza->scroll_y;
1203 }
1204 break;
1205
1206 case ConfigureNotify:
1207 {
1208 pizza->configure_serial = xevent->xconfigure.serial;
1209 pizza->scroll_x = xevent->xconfigure.x;
1210 pizza->scroll_y = xevent->xconfigure.y;
1211 }
1212 break;
1213 }
1214
1215 return GDK_FILTER_CONTINUE;
1216}
1217
1218/* Although GDK does have a GDK_VISIBILITY_NOTIFY event,
1219 * there is no corresponding event in GTK, so we have
1220 * to get the events from a filter
1221 */
1222static GdkFilterReturn
1223gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
1224 GdkEvent *event,
1225 gpointer data)
1226{
1227 XEvent *xevent;
1228 GtkPizza *pizza;
1229
1230 xevent = (XEvent *)gdk_xevent;
1231 pizza = GTK_PIZZA (data);
1232
1233 if (!pizza->use_filter)
1234 return GDK_FILTER_CONTINUE;
1235
1236 if (xevent->type == VisibilityNotify)
1237 {
1238 switch (xevent->xvisibility.state)
1239 {
1240 case VisibilityFullyObscured:
1241 pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1242 break;
1243
1244 case VisibilityPartiallyObscured:
1245 pizza->visibility = GDK_VISIBILITY_PARTIAL;
1246 break;
1247
1248 case VisibilityUnobscured:
1249 pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
1250 break;
1251 }
1252
1253 return GDK_FILTER_REMOVE;
1254 }
1255
1256 return GDK_FILTER_CONTINUE;
1257}
1258
1259
1260#ifdef __cplusplus
1261}
1262#endif /* __cplusplus */
1263
wxWidgets (Impactor)