]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/win_gtk.c
projects / wxWidgets.git / blob
? search:


39388f98d37054023df06214e98b83ae6156ce07
[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 GtkWidgetClass* pizza_parent_class;
68
69 GtkType
70 gtk_pizza_get_type ()
71 {
72 static GtkType pizza_type = 0;
73
74 if (!pizza_type)
75 {
76 static const GTypeInfo pizza_info =
77 {
78 sizeof (GtkPizzaClass),
79 NULL, /* base_init */
80 NULL, /* base_finalize */
81 (GClassInitFunc) gtk_pizza_class_init,
82 NULL, /* class_finalize */
83 NULL, /* class_data */
84 sizeof (GtkPizza),
85 16, /* n_preallocs */
86 (GInstanceInitFunc) gtk_pizza_init,
87 NULL
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->bin_window = NULL;
193
194 pizza->m_xoffset = 0;
195 pizza->m_yoffset = 0;
196 }
197
198 GtkWidget*
199 gtk_pizza_new ()
200 {
201 GtkPizza *pizza;
202
203 pizza = g_object_new (gtk_pizza_get_type (), NULL);
204
205 return GTK_WIDGET (pizza);
206 }
207
208 gint gtk_pizza_get_xoffset (GtkPizza *pizza)
209 {
210 g_return_val_if_fail ( (pizza != NULL), -1 );
211 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
212
213 return pizza->m_xoffset;
214 }
215
216 gint gtk_pizza_get_yoffset (GtkPizza *pizza)
217 {
218 g_return_val_if_fail ( (pizza != NULL), -1 );
219 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), -1 );
220
221 return pizza->m_yoffset;
222 }
223
224 void gtk_pizza_set_xoffset (GtkPizza *pizza, gint xoffset)
225 {
226 g_return_if_fail (pizza != NULL);
227 g_return_if_fail (GTK_IS_PIZZA (pizza));
228
229 pizza->m_xoffset = xoffset;
230 // do something
231 }
232
233 void gtk_pizza_set_yoffset (GtkPizza *pizza, gint yoffset)
234 {
235 g_return_if_fail (pizza != NULL);
236 g_return_if_fail (GTK_IS_PIZZA (pizza));
237
238 pizza->m_xoffset = yoffset;
239 // do something
240 }
241
242 gint gtk_pizza_get_rtl_offset (GtkPizza *pizza)
243 {
244 gint width;
245
246 g_return_val_if_fail ( (pizza != NULL), 0 );
247 g_return_val_if_fail ( (GTK_IS_PIZZA (pizza)), 0 );
248
249 if (!pizza->bin_window) return 0;
250
251 gdk_window_get_geometry( pizza->bin_window, NULL, NULL, &width, NULL, NULL );
252
253 return width;
254 }
255
256
257 static void
258 gtk_pizza_scroll_set_adjustments (GtkPizza *pizza,
259 GtkAdjustment *hadj,
260 GtkAdjustment *vadj)
261 {
262 /* We handle scrolling in the wxScrolledWindow, not here. */
263 }
264
265 void
266 gtk_pizza_set_shadow_type (GtkPizza *pizza,
267 GtkMyShadowType type)
268 {
269 g_return_if_fail (pizza != NULL);
270 g_return_if_fail (GTK_IS_PIZZA (pizza));
271
272 if (pizza->shadow_type != type)
273 {
274 pizza->shadow_type = type;
275
276 if (GTK_WIDGET_VISIBLE (pizza))
277 {
278 gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
279 gtk_widget_queue_draw (GTK_WIDGET (pizza));
280 }
281 }
282 }
283
284 void
285 gtk_pizza_put (GtkPizza *pizza,
286 GtkWidget *widget,
287 gint x,
288 gint y,
289 gint width,
290 gint height)
291 {
292 GtkPizzaChild *child_info;
293
294 g_return_if_fail (pizza != NULL);
295 g_return_if_fail (GTK_IS_PIZZA (pizza));
296 g_return_if_fail (widget != NULL);
297
298 if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
299 {
300 /* reverse horizontal placement */
301 x = GTK_WIDGET(pizza)->allocation.width - x - width;
302 }
303
304 child_info = g_new (GtkPizzaChild, 1);
305
306 child_info->widget = widget;
307 child_info->x = x;
308 child_info->y = y;
309 child_info->width = width;
310 child_info->height = height;
311
312 pizza->children = g_list_append (pizza->children, child_info);
313
314 if (GTK_WIDGET_REALIZED (pizza))
315 gtk_widget_set_parent_window (widget, pizza->bin_window);
316
317 gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
318
319 gtk_widget_set_size_request (widget, width, height);
320 }
321
322 void
323 gtk_pizza_set_size (GtkPizza *pizza,
324 GtkWidget *widget,
325 gint x,
326 gint y,
327 gint width,
328 gint height)
329 {
330 GtkPizzaChild *child;
331 GList *children;
332
333 g_return_if_fail (pizza != NULL);
334 g_return_if_fail (GTK_IS_PIZZA (pizza));
335 g_return_if_fail (widget != NULL);
336
337 #ifndef WX_WARN_ILLEGAL_SETSIZE
338 /* this really shouldn't happen -- but it does, a lot, right now and we
339 can't pass negative values to gtk_widget_set_size_request() without getting
340 a warning printed out, so filter them out here */
341 if ( width < 0 )
342 width = 0;
343 if ( height < 0 )
344 height = 0;
345 #endif
346
347 children = pizza->children;
348 while (children)
349 {
350 child = children->data;
351 children = children->next;
352
353 if (child->widget == widget)
354 {
355 if ((child->x == x) &&
356 (child->y == y) &&
357 (child->width == width) &&
358 (child->height == height)) return;
359
360 child->x = x;
361 child->y = y;
362 child->width = width;
363 child->height = height;
364
365 gtk_widget_set_size_request (widget, width, height);
366
367 return;
368 }
369 }
370 }
371
372 static void
373 gtk_pizza_map (GtkWidget *widget)
374 {
375 GtkPizza *pizza;
376 GtkPizzaChild *child;
377 GList *children;
378
379 g_return_if_fail (widget != NULL);
380 g_return_if_fail (GTK_IS_PIZZA (widget));
381
382 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
383 pizza = GTK_PIZZA (widget);
384
385 children = pizza->children;
386 while (children)
387 {
388 child = children->data;
389 children = children->next;
390
391 if ( GTK_WIDGET_VISIBLE (child->widget) &&
392 !GTK_WIDGET_MAPPED (child->widget) )
393 {
394 gtk_widget_map (child->widget);
395 }
396 }
397
398 gdk_window_show (widget->window);
399 gdk_window_show (pizza->bin_window);
400 }
401
402 static void
403 gtk_pizza_realize (GtkWidget *widget)
404 {
405 GtkPizza *pizza;
406 GdkWindowAttr attributes;
407 gint attributes_mask;
408 GtkPizzaChild *child;
409 GList *children;
410
411 g_return_if_fail (widget != NULL);
412 g_return_if_fail (GTK_IS_PIZZA (widget));
413
414 pizza = GTK_PIZZA (widget);
415 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
416
417 attributes.window_type = GDK_WINDOW_CHILD;
418
419 attributes.x = widget->allocation.x;
420 attributes.y = widget->allocation.y;
421 attributes.width = widget->allocation.width;
422 attributes.height = widget->allocation.height;
423
424 #ifndef __WXUNIVERSAL__
425 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
426 {
427 /* no border, no changes to sizes */
428 }
429 else if (pizza->shadow_type == GTK_MYSHADOW_THIN)
430 {
431 /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
432 attributes.x += 1;
433 attributes.y += 1;
434 attributes.width -= 2;
435 attributes.height -= 2;
436 }
437 else
438 {
439 /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
440 /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
441 attributes.x += 2;
442 attributes.y += 2;
443 attributes.width -= 4;
444 attributes.height -= 4;
445 }
446 #endif /* __WXUNIVERSAL__ */
447
448 /* minimal size */
449 if (attributes.width < 2) attributes.width = 2;
450 if (attributes.height < 2) attributes.height = 2;
451
452 attributes.wclass = GDK_INPUT_OUTPUT;
453 attributes.visual = gtk_widget_get_visual (widget);
454 attributes.colormap = gtk_widget_get_colormap (widget);
455 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
456 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
457
458 widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
459 &attributes, attributes_mask);
460 gdk_window_set_user_data (widget->window, widget);
461
462 attributes.x = 0;
463 attributes.y = 0;
464
465 attributes.event_mask = gtk_widget_get_events (widget);
466 attributes.event_mask |= GDK_EXPOSURE_MASK |
467 GDK_SCROLL_MASK |
468 GDK_POINTER_MOTION_MASK |
469 GDK_POINTER_MOTION_HINT_MASK |
470 GDK_BUTTON_MOTION_MASK |
471 GDK_BUTTON1_MOTION_MASK |
472 GDK_BUTTON2_MOTION_MASK |
473 GDK_BUTTON3_MOTION_MASK |
474 GDK_BUTTON_PRESS_MASK |
475 GDK_BUTTON_RELEASE_MASK |
476 GDK_KEY_PRESS_MASK |
477 GDK_KEY_RELEASE_MASK |
478 GDK_ENTER_NOTIFY_MASK |
479 GDK_LEAVE_NOTIFY_MASK |
480 GDK_FOCUS_CHANGE_MASK;
481
482 pizza->bin_window = gdk_window_new(widget->window,
483 &attributes, attributes_mask);
484 gdk_window_set_user_data (pizza->bin_window, widget);
485
486 widget->style = gtk_style_attach (widget->style, widget->window);
487 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
488 gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
489
490 /*
491 gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
492 gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
493 */
494
495 /* cannot be done before realisation */
496 children = pizza->children;
497 while (children)
498 {
499 child = children->data;
500 children = children->next;
501
502 gtk_widget_set_parent_window (child->widget, pizza->bin_window);
503 }
504 }
505
506 static void
507 gtk_pizza_unrealize (GtkWidget *widget)
508 {
509 GtkPizza *pizza;
510
511 g_return_if_fail (widget != NULL);
512 g_return_if_fail (GTK_IS_PIZZA (widget));
513
514 pizza = GTK_PIZZA (widget);
515
516 gdk_window_set_user_data (pizza->bin_window, NULL);
517 gdk_window_destroy (pizza->bin_window);
518 pizza->bin_window = NULL;
519
520 if (pizza_parent_class->unrealize)
521 pizza_parent_class->unrealize(widget);
522 }
523
524 static void
525 gtk_pizza_size_request (GtkWidget *widget,
526 GtkRequisition *requisition)
527 {
528 GtkPizza *pizza;
529 GtkPizzaChild *child;
530 GList *children;
531 GtkRequisition child_requisition;
532
533 g_return_if_fail (widget != NULL);
534 g_return_if_fail (GTK_IS_PIZZA (widget));
535 g_return_if_fail (requisition != NULL);
536
537 pizza = GTK_PIZZA (widget);
538
539 children = pizza->children;
540 while (children)
541 {
542 child = children->data;
543 children = children->next;
544
545 if (GTK_WIDGET_VISIBLE (child->widget))
546 {
547 gtk_widget_size_request (child->widget, &child_requisition);
548 }
549 }
550
551 /* request very little, I'm not sure if requesting nothing
552 will always have positive effects on stability... */
553 requisition->width = 2;
554 requisition->height = 2;
555 }
556
557 static void
558 gtk_pizza_size_allocate (GtkWidget *widget,
559 GtkAllocation *allocation)
560 {
561 GtkPizza *pizza;
562 gint border;
563 gint x,y,w,h;
564 GtkPizzaChild *child;
565 GList *children;
566 gboolean only_resize;
567
568 g_return_if_fail (widget != NULL);
569 g_return_if_fail (GTK_IS_PIZZA(widget));
570 g_return_if_fail (allocation != NULL);
571
572 pizza = GTK_PIZZA (widget);
573
574 only_resize = ((widget->allocation.x == allocation->x) &&
575 (widget->allocation.y == allocation->y));
576 widget->allocation = *allocation;
577
578 if (pizza->shadow_type == GTK_MYSHADOW_NONE)
579 border = 0;
580 else
581 if (pizza->shadow_type == GTK_MYSHADOW_THIN)
582 border = 1;
583 else
584 border = 2;
585
586 x = allocation->x + border;
587 y = allocation->y + border;
588 w = allocation->width - border*2;
589 h = allocation->height - border*2;
590 if (w < 0)
591 w = 0;
592 if (h < 0)
593 h = 0;
594
595 if (GTK_WIDGET_REALIZED (widget))
596 {
597 if (only_resize)
598 gdk_window_resize( widget->window, w, h );
599 else
600 gdk_window_move_resize( widget->window, x, y, w, h );
601
602 gdk_window_resize( pizza->bin_window, w, h );
603 }
604
605 children = pizza->children;
606 while (children)
607 {
608 child = children->data;
609 children = children->next;
610
611 gtk_pizza_allocate_child (pizza, child);
612 }
613 }
614
615 static gint
616 gtk_pizza_expose (GtkWidget *widget,
617 GdkEventExpose *event)
618 {
619 GtkPizza *pizza;
620
621 g_return_val_if_fail (widget != NULL, FALSE);
622 g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
623 g_return_val_if_fail (event != NULL, FALSE);
624
625 pizza = (GtkPizza*)widget;
626
627 if (event->window != pizza->bin_window)
628 return FALSE;
629
630 pizza_parent_class->expose_event(widget, event);
631
632 return FALSE;
633 }
634
635 static void
636 gtk_pizza_style_set(GtkWidget *widget, GtkStyle *previous_style)
637 {
638 if (GTK_WIDGET_REALIZED(widget))
639 {
640 gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
641 gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
642 }
643
644 pizza_parent_class->style_set(widget, previous_style);
645 }
646
647 static void
648 gtk_pizza_add (GtkContainer *container,
649 GtkWidget *widget)
650 {
651 g_return_if_fail (container != NULL);
652 g_return_if_fail (GTK_IS_PIZZA (container));
653 g_return_if_fail (widget != NULL);
654
655 gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
656 }
657
658 static void
659 gtk_pizza_remove (GtkContainer *container,
660 GtkWidget *widget)
661 {
662 GtkPizza *pizza;
663 GtkPizzaChild *child;
664 GList *children;
665
666 g_return_if_fail (container != NULL);
667 g_return_if_fail (GTK_IS_PIZZA (container));
668 g_return_if_fail (widget != NULL);
669
670 pizza = GTK_PIZZA (container);
671
672 children = pizza->children;
673 while (children)
674 {
675 child = children->data;
676
677 if (child->widget == widget)
678 {
679 gtk_widget_unparent (widget);
680
681 /* security checks */
682 g_return_if_fail (GTK_IS_WIDGET (widget));
683
684 pizza->children = g_list_remove_link (pizza->children, children);
685 g_list_free (children);
686 g_free (child);
687
688 /* security checks */
689 g_return_if_fail (GTK_IS_WIDGET (widget));
690
691 break;
692 }
693
694 children = children->next;
695 }
696 }
697
698 static void
699 gtk_pizza_forall (GtkContainer *container,
700 gboolean include_internals,
701 GtkCallback callback,
702 gpointer callback_data)
703 {
704 GtkPizza *pizza;
705 GtkPizzaChild *child;
706 GList *children;
707
708 g_return_if_fail (container != NULL);
709 g_return_if_fail (GTK_IS_PIZZA (container));
710 g_return_if_fail (callback != (GtkCallback)NULL);
711
712 pizza = GTK_PIZZA (container);
713
714 children = pizza->children;
715 while (children)
716 {
717 child = children->data;
718 children = children->next;
719
720 (* callback) (child->widget, callback_data);
721 }
722 }
723
724 static void
725 gtk_pizza_allocate_child (GtkPizza *pizza,
726 GtkPizzaChild *child)
727 {
728 GtkAllocation allocation;
729 GtkRequisition requisition;
730
731 allocation.x = child->x - pizza->m_xoffset;
732 allocation.y = child->y - pizza->m_yoffset;
733 gtk_widget_get_child_requisition (child->widget, &requisition);
734 allocation.width = requisition.width;
735 allocation.height = requisition.height;
736
737 if (gtk_widget_get_direction( GTK_WIDGET(pizza) ) == GTK_TEXT_DIR_RTL)
738 {
739 /* reverse horizontal placement */
740 /* printf( "alloc width %d\n", GTK_WIDGET(pizza)->allocation.width ); */
741 allocation.x = GTK_WIDGET(pizza)->allocation.width - child->x - allocation.width - pizza->m_xoffset;
742 }
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)