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