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