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