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