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


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