]> 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
Use wxGtkString here too
[wxWidgets.git] / src / gtk / win_gtk.c
... / ...
CommitLineData
1/* ///////////////////////////////////////////////////////////////////////////
2// Name: src/gtk/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/platform.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
26typedef struct _GtkPizzaAdjData GtkPizzaAdjData;
27
28struct _GtkPizzaAdjData
29{
30 gint dx;
31 gint dy;
32};
33
34static void gtk_pizza_class_init (GtkPizzaClass *klass);
35static void gtk_pizza_init (GtkPizza *pizza);
36
37static void gtk_pizza_realize (GtkWidget *widget);
38static void gtk_pizza_unrealize (GtkWidget *widget);
39
40static void gtk_pizza_map (GtkWidget *widget);
41
42static void gtk_pizza_size_request (GtkWidget *widget,
43 GtkRequisition *requisition);
44static void gtk_pizza_size_allocate (GtkWidget *widget,
45 GtkAllocation *allocation);
46static gint gtk_pizza_expose (GtkWidget *widget,
47 GdkEventExpose *event);
48static void gtk_pizza_style_set (GtkWidget *widget,
49 GtkStyle *previous_style);
50static void gtk_pizza_add (GtkContainer *container,
51 GtkWidget *widget);
52static void gtk_pizza_remove (GtkContainer *container,
53 GtkWidget *widget);
54static void gtk_pizza_forall (GtkContainer *container,
55 gboolean include_internals,
56 GtkCallback callback,
57 gpointer callback_data);
58
59static void gtk_pizza_allocate_child (GtkPizza *pizza,
60 GtkPizzaChild *child);
61static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
62 gpointer cb_data);
63
64static GtkType gtk_pizza_child_type (GtkContainer *container);
65
66static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
67 GtkAdjustment *hadj,
68 GtkAdjustment *vadj);
69
70/* static */
71GtkContainerClass *pizza_parent_class = NULL;
72
73GtkType
74gtk_pizza_get_type ()
75{
76 static GtkType pizza_type = 0;
77
78 if (!pizza_type)
79 {
80 static const GTypeInfo pizza_info =
81 {
82 sizeof (GtkPizzaClass),
83 NULL, /* base_init */
84 NULL, /* base_finalize */
85 (GClassInitFunc) gtk_pizza_class_init,
86 NULL, /* class_finalize */
87 NULL, /* class_data */
88 sizeof (GtkPizza),
89 16, /* n_preallocs */
90 (GInstanceInitFunc) gtk_pizza_init,
91 };
92 pizza_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkPizza", &pizza_info, (GTypeFlags)0);
93 }
94
95 return pizza_type;
96}
97
98/* Marshaller needed for set_scroll_adjustments signal,
99 generated with GLib-2.4.6 glib-genmarshal */
100#define g_marshal_value_peek_object(v) g_value_get_object (v)
101static void
102g_cclosure_user_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
103 GValue *return_value,
104 guint n_param_values,
105 const GValue *param_values,
106 gpointer invocation_hint,
107 gpointer marshal_data)
108{
109 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
110 gpointer arg_1,
111 gpointer arg_2,
112 gpointer data2);
113 register GMarshalFunc_VOID__OBJECT_OBJECT callback;
114 register GCClosure *cc = (GCClosure*) closure;
115 register gpointer data1, data2;
116
117 g_return_if_fail (n_param_values == 3);
118
119 if (G_CCLOSURE_SWAP_DATA (closure))
120 {
121 data1 = closure->data;
122 data2 = g_value_peek_pointer (param_values + 0);
123 }
124 else
125 {
126 data1 = g_value_peek_pointer (param_values + 0);
127 data2 = closure->data;
128 }
129 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
130
131 callback (data1,
132 g_marshal_value_peek_object (param_values + 1),
133 g_marshal_value_peek_object (param_values + 2),
134 data2);
135}
136
137static void
138gtk_pizza_class_init (GtkPizzaClass *klass)
139{
140 GtkObjectClass *object_class;
141 GtkWidgetClass *widget_class;
142 GtkContainerClass *container_class;
143
144 object_class = (GtkObjectClass*) klass;
145 widget_class = (GtkWidgetClass*) klass;
146 container_class = (GtkContainerClass*) klass;
147 pizza_parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
148
149 widget_class->map = gtk_pizza_map;
150 widget_class->realize = gtk_pizza_realize;
151 widget_class->unrealize = gtk_pizza_unrealize;
152 widget_class->size_request = gtk_pizza_size_request;
153 widget_class->size_allocate = gtk_pizza_size_allocate;
154 widget_class->expose_event = gtk_pizza_expose;
155 widget_class->style_set = gtk_pizza_style_set;
156
157 container_class->add = gtk_pizza_add;
158 container_class->remove = gtk_pizza_remove;
159 container_class->forall = gtk_pizza_forall;
160
161 container_class->child_type = gtk_pizza_child_type;
162
163 klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
164
165 widget_class->set_scroll_adjustments_signal =
166 g_signal_new(
167 "set_scroll_adjustments",
168 G_TYPE_FROM_CLASS(object_class),
169 G_SIGNAL_RUN_LAST,
170 G_STRUCT_OFFSET(GtkPizzaClass, set_scroll_adjustments),
171 NULL,
172 NULL,
173 g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
174 G_TYPE_NONE,
175 2,
176 GTK_TYPE_ADJUSTMENT,
177 GTK_TYPE_ADJUSTMENT);
178}
179
180static GtkType
181gtk_pizza_child_type (GtkContainer *container)
182{
183 return GTK_TYPE_WIDGET;
184}
185
186static void
187gtk_pizza_init (GtkPizza *pizza)
188{
189 GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
190
191 pizza->shadow_type = GTK_MYSHADOW_NONE;
192
193 pizza->children = NULL;
194
195 pizza->width = 20;
196 pizza->height = 20;
197
198 pizza->bin_window = NULL;
199
200 pizza->xoffset = 0;
201 pizza->yoffset = 0;
202
203 pizza->configure_serial = 0;
204 pizza->scroll_x = 0;
205 pizza->scroll_y = 0;
206 pizza->visibility = GDK_VISIBILITY_PARTIAL;
207
208 pizza->clear_on_draw = TRUE;
209 pizza->use_filter = TRUE;
210 pizza->external_expose = FALSE;
211}
212
213GtkWidget*
214gtk_pizza_new ()
215{
216 GtkPizza *pizza;
217
218 pizza = gtk_type_new (gtk_pizza_get_type ());
219
220 return GTK_WIDGET (pizza);
221}
222
223static void
224gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
225 GtkAdjustment *hadj,
226 GtkAdjustment *vadj)
227{
228 /* We handle scrolling in the wxScrolledWindow, not here. */
229}
230
231void
232gtk_pizza_set_shadow_type (GtkPizza *pizza,
233 GtkMyShadowType type)
234{
235 g_return_if_fail (pizza != NULL);
236 g_return_if_fail (GTK_IS_PIZZA (pizza));
237
238 if ((GtkMyShadowType) pizza->shadow_type != type)
239 {
240 pizza->shadow_type = type;
241
242 if (GTK_WIDGET_VISIBLE (pizza))
243 {
244 gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
245 gtk_widget_queue_draw (GTK_WIDGET (pizza));
246 }
247 }
248}
249
250void
251gtk_pizza_set_clear (GtkPizza *pizza,
252 gboolean clear)
253{
254 g_return_if_fail (pizza != NULL);
255 g_return_if_fail (GTK_IS_PIZZA (pizza));
256
257 pizza->clear_on_draw = clear;
258}
259
260void
261gtk_pizza_set_filter (GtkPizza *pizza,
262 gboolean use)
263{
264 g_return_if_fail (pizza != NULL);
265 g_return_if_fail (GTK_IS_PIZZA (pizza));
266
267 pizza->use_filter = use;
268}
269
270void
271gtk_pizza_set_external (GtkPizza *pizza,
272 gboolean expose)
273{
274 g_return_if_fail (pizza != NULL);
275 g_return_if_fail (GTK_IS_PIZZA (pizza));
276
277 pizza->external_expose = expose;
278}
279
280void
281gtk_pizza_put (GtkPizza *pizza,
282 GtkWidget *widget,
283 gint x,
284 gint y,
285 gint width,
286 gint height)
287{
288 GtkPizzaChild *child_info;
289
290 g_return_if_fail (pizza != NULL);
291 g_return_if_fail (GTK_IS_PIZZA (pizza));
292 g_return_if_fail (widget != NULL);
293
294 child_info = g_new (GtkPizzaChild, 1);
295
296 child_info->widget = widget;
297 child_info->x = x;
298 child_info->y = y;
299 child_info->width = width;
300 child_info->height = height;
301
302 pizza->children = g_list_append (pizza->children, child_info);
303
304 if (GTK_WIDGET_REALIZED (pizza))
305 gtk_widget_set_parent_window (widget, pizza->bin_window);
306
307 gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
308
309 gtk_widget_set_size_request (widget, width, height);
310}
311
312void
313gtk_pizza_move (GtkPizza *pizza,
314 GtkWidget *widget,
315 gint x,
316 gint y)
317{
318 GtkPizzaChild *child;
319 GList *children;
320
321 g_return_if_fail (pizza != NULL);
322 g_return_if_fail (GTK_IS_PIZZA (pizza));
323 g_return_if_fail (widget != NULL);
324
325 children = pizza->children;
326 while (children)
327 {
328 child = children->data;
329 children = children->next;
330
331 if (child->widget == widget)
332 {
333 if ((child->x == x) && (child->y == y))
334 break;
335
336 child->x = x;
337 child->y = y;
338
339 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
340 gtk_widget_queue_resize (widget);
341 break;
342 }
343 }
344}
345
346void
347gtk_pizza_resize (GtkPizza *pizza,
348 GtkWidget *widget,
349 gint width,
350 gint height)
351{
352 GtkPizzaChild *child;
353 GList *children;
354
355 g_return_if_fail (pizza != NULL);
356 g_return_if_fail (GTK_IS_PIZZA (pizza));
357 g_return_if_fail (widget != NULL);
358
359 children = pizza->children;
360 while (children)
361 {
362 child = children->data;
363 children = children->next;
364
365 if (child->widget == widget)
366 {
367 if ((child->width == width) && (child->height == height))
368 break;
369
370 child->width = width;
371 child->height = height;
372
373 gtk_widget_set_size_request (widget, width, height);
374
375 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
376 gtk_widget_queue_resize (widget);
377 break;
378 }
379 }
380}
381
382void
383gtk_pizza_set_size (GtkPizza *pizza,
384 GtkWidget *widget,
385 gint x,
386 gint y,
387 gint width,
388 gint height)
389{
390 GtkPizzaChild *child;
391 GList *children;
392
393 g_return_if_fail (pizza != NULL);
394 g_return_if_fail (GTK_IS_PIZZA (pizza));
395 g_return_if_fail (widget != NULL);
396
397#ifndef WX_WARN_ILLEGAL_SETSIZE
398 /* this really shouldn't happen -- but it does, a lot, right now and we
399 can't pass negative values to gtk_widget_set_size_request() without getting
400 a warning printed out, so filter them out here */
401 if ( width < 0 )
402 width = 0;
403 if ( height < 0 )
404 height = 0;
405#endif
406
407 children = pizza->children;
408 while (children)
409 {
410 child = children->data;
411 children = children->next;
412
413 if (child->widget == widget)
414 {
415 if ((child->x == x) &&
416 (child->y == y) &&
417 (child->width == width) &&
418 (child->height == height)) return;
419
420 child->x = x;
421 child->y = y;
422 child->width = width;
423 child->height = height;
424
425 gtk_widget_set_size_request (widget, width, height);
426
427 if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
428 gtk_widget_queue_resize (widget);
429
430 return;
431 }
432 }
433}
434
435gint
436gtk_pizza_child_resized (GtkPizza *pizza,
437 GtkWidget *widget)
438{
439 GtkPizzaChild *child;
440 GList *children;
441
442 g_return_val_if_fail (pizza != NULL, FALSE);
443 g_return_val_if_fail (GTK_IS_PIZZA (pizza), FALSE);
444 g_return_val_if_fail (widget != NULL, FALSE);
445
446 children = pizza->children;
447 while (children)
448 {
449 child = children->data;
450 children = children->next;
451
452 if (child->widget == widget)
453 {
454 return ((child->width == widget->allocation.width) &&
455 (child->height == widget->allocation.height));
456 }
457 }
458
459 return FALSE;
460}
461
462static void
463gtk_pizza_map (GtkWidget *widget)
464{
465 GtkPizza *pizza;
466 GtkPizzaChild *child;
467 GList *children;
468
469 g_return_if_fail (widget != NULL);
470 g_return_if_fail (GTK_IS_PIZZA (widget));
471
472 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
473 pizza = GTK_PIZZA (widget);
474
475 children = pizza->children;
476 while (children)
477 {
478 child = children->data;
479 children = children->next;
480
481 if ( GTK_WIDGET_VISIBLE (child->widget) &&
482 !GTK_WIDGET_MAPPED (child->widget) &&
483 TRUE)
484 {
485 gtk_widget_map (child->widget);
486 }
487 }
488
489 gdk_window_show (widget->window);
490 gdk_window_show (pizza->bin_window);
491}
492
493static void
494gtk_pizza_realize (GtkWidget *widget)
495{
496 GtkPizza *pizza;
497 GdkWindowAttr attributes;
498 gint attributes_mask;
499 GtkPizzaChild *child;
500 GList *children;
501
502 g_return_if_fail (widget != NULL);
503 g_return_if_fail (GTK_IS_PIZZA (widget));
504
505 pizza = GTK_PIZZA (widget);
506 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
507
508 attributes.window_type = GDK_WINDOW_CHILD;
509
510 attributes.x = widget->allocation.x;
511 attributes.y = widget->allocation.y;
512 attributes.width = widget->allocation.width;
513 attributes.height = widget->allocation.height;
514
515#ifndef __WXUNIVERSAL__
516 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
517 {
518 /* no border, no changes to sizes */
519 }
520 else if (pizza->shadow_type == GTK_MYSHADOW_THIN)
521 {
522 /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
523 attributes.x += 1;
524 attributes.y += 1;
525 attributes.width -= 2;
526 attributes.height -= 2;
527 }
528 else
529 {
530 /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
531 /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
532 attributes.x += 2;
533 attributes.y += 2;
534 attributes.width -= 4;
535 attributes.height -= 4;
536 }
537#endif /* __WXUNIVERSAL__ */
538
539 /* minimal size */
540 if (attributes.width < 2) attributes.width = 2;
541 if (attributes.height < 2) attributes.height = 2;
542
543 attributes.wclass = GDK_INPUT_OUTPUT;
544 attributes.visual = gtk_widget_get_visual (widget);
545 attributes.colormap = gtk_widget_get_colormap (widget);
546 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
547 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
548
549 widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
550 &attributes, attributes_mask);
551 gdk_window_set_user_data (widget->window, widget);
552
553 attributes.x = 0;
554 attributes.y = 0;
555
556 attributes.event_mask = gtk_widget_get_events (widget);
557 attributes.event_mask |= GDK_EXPOSURE_MASK |
558 GDK_SCROLL_MASK |
559 GDK_POINTER_MOTION_MASK |
560 GDK_POINTER_MOTION_HINT_MASK |
561 GDK_BUTTON_MOTION_MASK |
562 GDK_BUTTON1_MOTION_MASK |
563 GDK_BUTTON2_MOTION_MASK |
564 GDK_BUTTON3_MOTION_MASK |
565 GDK_BUTTON_PRESS_MASK |
566 GDK_BUTTON_RELEASE_MASK |
567 GDK_KEY_PRESS_MASK |
568 GDK_KEY_RELEASE_MASK |
569 GDK_ENTER_NOTIFY_MASK |
570 GDK_LEAVE_NOTIFY_MASK |
571 GDK_FOCUS_CHANGE_MASK;
572
573 pizza->bin_window = gdk_window_new(widget->window,
574 &attributes, attributes_mask);
575 gdk_window_set_user_data (pizza->bin_window, widget);
576
577 widget->style = gtk_style_attach (widget->style, widget->window);
578 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
579 gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
580
581/*
582 gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
583 gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
584*/
585
586 /* cannot be done before realisation */
587 children = pizza->children;
588 while (children)
589 {
590 child = children->data;
591 children = children->next;
592
593 gtk_widget_set_parent_window (child->widget, pizza->bin_window);
594 }
595}
596
597static void
598gtk_pizza_unrealize (GtkWidget *widget)
599{
600 GtkPizza *pizza;
601
602 g_return_if_fail (widget != NULL);
603 g_return_if_fail (GTK_IS_PIZZA (widget));
604
605 pizza = GTK_PIZZA (widget);
606
607 gdk_window_set_user_data (pizza->bin_window, NULL);
608 gdk_window_destroy (pizza->bin_window);
609 pizza->bin_window = NULL;
610
611 if (GTK_WIDGET_CLASS (pizza_parent_class)->unrealize)
612 (* GTK_WIDGET_CLASS (pizza_parent_class)->unrealize) (widget);
613}
614
615static void
616gtk_pizza_size_request (GtkWidget *widget,
617 GtkRequisition *requisition)
618{
619 GtkPizza *pizza;
620 GtkPizzaChild *child;
621 GList *children;
622 GtkRequisition child_requisition;
623
624 g_return_if_fail (widget != NULL);
625 g_return_if_fail (GTK_IS_PIZZA (widget));
626 g_return_if_fail (requisition != NULL);
627
628 pizza = GTK_PIZZA (widget);
629
630 children = pizza->children;
631 while (children)
632 {
633 child = children->data;
634 children = children->next;
635
636 if (GTK_WIDGET_VISIBLE (child->widget))
637 {
638 gtk_widget_size_request (child->widget, &child_requisition);
639 }
640 }
641
642 /* request very little, I'm not sure if requesting nothing
643 will always have positive effects on stability... */
644 requisition->width = 2;
645 requisition->height = 2;
646}
647
648static void
649gtk_pizza_size_allocate (GtkWidget *widget,
650 GtkAllocation *allocation)
651{
652 GtkPizza *pizza;
653 gint border;
654 gint x,y,w,h;
655 GtkPizzaChild *child;
656 GList *children;
657
658 g_return_if_fail (widget != NULL);
659 g_return_if_fail (GTK_IS_PIZZA(widget));
660 g_return_if_fail (allocation != NULL);
661
662 pizza = GTK_PIZZA (widget);
663
664 widget->allocation = *allocation;
665
666 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
667 border = 0;
668 else
669 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
670 border = 1;
671 else
672 border = 2;
673
674 x = allocation->x + border;
675 y = allocation->y + border;
676 w = allocation->width - border*2;
677 h = allocation->height - border*2;
678
679 if (GTK_WIDGET_REALIZED (widget))
680 {
681 gdk_window_move_resize( widget->window, x, y, w, h );
682 gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
683 }
684
685 children = pizza->children;
686 while (children)
687 {
688 child = children->data;
689 children = children->next;
690
691 gtk_pizza_allocate_child (pizza, child);
692 }
693}
694
695static gint
696gtk_pizza_expose (GtkWidget *widget,
697 GdkEventExpose *event)
698{
699 GtkPizza *pizza;
700
701 g_return_val_if_fail (widget != NULL, FALSE);
702 g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
703 g_return_val_if_fail (event != NULL, FALSE);
704
705 pizza = GTK_PIZZA (widget);
706
707 if (event->window != pizza->bin_window)
708 return FALSE;
709
710 /* We handle all expose events in window.cpp now. */
711 if (pizza->external_expose)
712 return FALSE;
713
714 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, event);
715
716 return FALSE;
717}
718
719static void
720gtk_pizza_style_set(GtkWidget *widget, GtkStyle *previous_style)
721{
722 if (GTK_WIDGET_REALIZED(widget))
723 {
724 gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
725 gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
726 }
727
728 (* GTK_WIDGET_CLASS (pizza_parent_class)->style_set) (widget, previous_style);
729}
730
731static void
732gtk_pizza_add (GtkContainer *container,
733 GtkWidget *widget)
734{
735 g_return_if_fail (container != NULL);
736 g_return_if_fail (GTK_IS_PIZZA (container));
737 g_return_if_fail (widget != NULL);
738
739 gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
740}
741
742static void
743gtk_pizza_remove (GtkContainer *container,
744 GtkWidget *widget)
745{
746 GtkPizza *pizza;
747 GtkPizzaChild *child;
748 GList *children;
749
750 g_return_if_fail (container != NULL);
751 g_return_if_fail (GTK_IS_PIZZA (container));
752 g_return_if_fail (widget != NULL);
753
754 pizza = GTK_PIZZA (container);
755
756 children = pizza->children;
757 while (children)
758 {
759 child = children->data;
760
761 if (child->widget == widget)
762 {
763 gtk_widget_unparent (widget);
764
765 /* security checks */
766 g_return_if_fail (GTK_IS_WIDGET (widget));
767
768 pizza->children = g_list_remove_link (pizza->children, children);
769 g_list_free (children);
770 g_free (child);
771
772 /* security checks */
773 g_return_if_fail (GTK_IS_WIDGET (widget));
774
775 break;
776 }
777
778 children = children->next;
779 }
780}
781
782static void
783gtk_pizza_forall (GtkContainer *container,
784 gboolean include_internals,
785 GtkCallback callback,
786 gpointer callback_data)
787{
788 GtkPizza *pizza;
789 GtkPizzaChild *child;
790 GList *children;
791
792 g_return_if_fail (container != NULL);
793 g_return_if_fail (GTK_IS_PIZZA (container));
794 g_return_if_fail (callback != (GtkCallback)NULL);
795
796 pizza = GTK_PIZZA (container);
797
798 children = pizza->children;
799 while (children)
800 {
801 child = children->data;
802 children = children->next;
803
804 (* callback) (child->widget, callback_data);
805 }
806}
807
808static void
809gtk_pizza_allocate_child (GtkPizza *pizza,
810 GtkPizzaChild *child)
811{
812 GtkAllocation allocation;
813 GtkRequisition requisition;
814
815 allocation.x = child->x - pizza->xoffset;
816 allocation.y = child->y - pizza->yoffset;
817 gtk_widget_get_child_requisition (child->widget, &requisition);
818 allocation.width = requisition.width;
819 allocation.height = requisition.height;
820
821 gtk_widget_size_allocate (child->widget, &allocation);
822}
823
824static void
825gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
826 gpointer cb_data)
827{
828 GtkPizzaAdjData *data = cb_data;
829
830 widget->allocation.x += data->dx;
831 widget->allocation.y += data->dy;
832
833 if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
834 {
835 gtk_container_forall (GTK_CONTAINER (widget),
836 gtk_pizza_adjust_allocations_recurse,
837 cb_data);
838 }
839}
840
841static void
842gtk_pizza_adjust_allocations (GtkPizza *pizza,
843 gint dx,
844 gint dy)
845{
846 GList *tmp_list;
847 GtkPizzaAdjData data;
848
849 data.dx = dx;
850 data.dy = dy;
851
852 tmp_list = pizza->children;
853 while (tmp_list)
854 {
855 GtkPizzaChild *child = tmp_list->data;
856 tmp_list = tmp_list->next;
857
858 child->widget->allocation.x += dx;
859 child->widget->allocation.y += dy;
860
861 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
862 GTK_IS_CONTAINER (child->widget))
863 {
864 gtk_container_forall (GTK_CONTAINER (child->widget),
865 gtk_pizza_adjust_allocations_recurse,
866 &data);
867 }
868 }
869}
870
871
872/* This is the main routine to do the scrolling. Scrolling is
873 * done by "Guffaw" scrolling, as in the Mozilla XFE, with
874 * a few modifications.
875 *
876 * The main improvement is that we keep track of whether we
877 * are obscured or not. If not, we ignore the generated expose
878 * events and instead do the exposes ourself, without having
879 * to wait for a roundtrip to the server. This also provides
880 * a limited form of expose-event compression, since we do
881 * the affected area as one big chunk.
882 */
883
884void
885gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
886{
887 pizza->xoffset += dx;
888 pizza->yoffset += dy;
889
890 gtk_pizza_adjust_allocations (pizza, -dx, -dy);
891
892 if (pizza->bin_window)
893 gdk_window_scroll( pizza->bin_window, -dx, -dy );
894}
895
896#ifdef __cplusplus
897}
898#endif /* __cplusplus */
wxWidgets (Impactor)