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