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