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