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