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