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 #include "gtk/gtksignal.h"
  19 #include "gtk/gtkprivate.h"
  20 #include "gdk/gdkx.h"
  21
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif /* __cplusplus */
  25
  26 typedef struct _GtkPizzaAdjData  GtkPizzaAdjData;
  27
  28 struct _GtkPizzaAdjData
  29 {
  30     gint dx;
  31     gint dy;
  32 };
  33
  34 static void gtk_pizza_class_init    (GtkPizzaClass    *klass);
  35 static void gtk_pizza_init          (GtkPizza         *pizza);
  36
  37 static void gtk_pizza_realize       (GtkWidget        *widget);
  38 static void gtk_pizza_unrealize     (GtkWidget        *widget);
  39
  40 static void gtk_pizza_map           (GtkWidget        *widget);
  41
  42 static void gtk_pizza_size_request  (GtkWidget        *widget,
  43                                      GtkRequisition   *requisition);
  44 static void gtk_pizza_size_allocate (GtkWidget        *widget,
  45                                      GtkAllocation    *allocation);
  46 static gint gtk_pizza_expose        (GtkWidget        *widget,
  47                                      GdkEventExpose   *event);
  48 static void gtk_pizza_style_set     (GtkWidget *widget,
  49                                      GtkStyle  *previous_style);
  50 static void gtk_pizza_add           (GtkContainer     *container,
  51                                      GtkWidget        *widget);
  52 static void gtk_pizza_remove        (GtkContainer     *container,
  53                                      GtkWidget        *widget);
  54 static void gtk_pizza_forall        (GtkContainer     *container,
  55                                      gboolean          include_internals,
  56                                      GtkCallback       callback,
  57                                      gpointer          callback_data);
  58
  59 static void     gtk_pizza_allocate_child     (GtkPizza      *pizza,
  60                                               GtkPizzaChild *child);
  61 static void     gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
  62                                                       gpointer   cb_data);
  63
  64 static GtkType gtk_pizza_child_type (GtkContainer     *container);
  65
  66 static void  gtk_pizza_scroll_set_adjustments (GtkPizza      *pizza,
  67                                                GtkAdjustment *hadj,
  68                                                GtkAdjustment *vadj);
  69
  70 /* static */
  71 GtkContainerClass *pizza_parent_class = NULL;
  72
  73 GtkType
  74 gtk_pizza_get_type ()
  75 {
  76     static GtkType pizza_type = 0;
  77
  78     if (!pizza_type)
  79     {
  80         static const GTypeInfo pizza_info =
  81         {
  82             sizeof (GtkPizzaClass),
  83             NULL,           /* base_init */
  84             NULL,           /* base_finalize */
  85             (GClassInitFunc) gtk_pizza_class_init,
  86             NULL,           /* class_finalize */
  87             NULL,           /* class_data */
  88             sizeof (GtkPizza),
  89             16,             /* n_preallocs */
  90             (GInstanceInitFunc) gtk_pizza_init,
  91         };
  92         pizza_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkPizza", &pizza_info, (GTypeFlags)0);
  93     }
  94
  95     return pizza_type;
  96 }
  97
  98 /* Marshaller needed for set_scroll_adjustments signal,
  99    generated with GLib-2.4.6 glib-genmarshal */
 100 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
 101 static void
 102 g_cclosure_user_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
 103                                              GValue       *return_value,
 104                                              guint         n_param_values,
 105                                              const GValue *param_values,
 106                                              gpointer      invocation_hint,
 107                                              gpointer      marshal_data)
 108 {
 109   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
 110                                                     gpointer     arg_1,
 111                                                     gpointer     arg_2,
 112                                                     gpointer     data2);
 113   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 114   register GCClosure *cc = (GCClosure*) closure;
 115   register gpointer data1, data2;
 116
 117   g_return_if_fail (n_param_values == 3);
 118
 119   if (G_CCLOSURE_SWAP_DATA (closure))
 120     {
 121       data1 = closure->data;
 122       data2 = g_value_peek_pointer (param_values + 0);
 123     }
 124   else
 125     {
 126       data1 = g_value_peek_pointer (param_values + 0);
 127       data2 = closure->data;
 128     }
 129   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 130
 131   callback (data1,
 132             g_marshal_value_peek_object (param_values + 1),
 133             g_marshal_value_peek_object (param_values + 2),
 134             data2);
 135 }
 136
 137 static void
 138 gtk_pizza_class_init (GtkPizzaClass *klass)
 139 {
 140     GtkObjectClass *object_class;
 141     GtkWidgetClass *widget_class;
 142     GtkContainerClass *container_class;
 143
 144     object_class = (GtkObjectClass*) klass;
 145     widget_class = (GtkWidgetClass*) klass;
 146     container_class = (GtkContainerClass*) klass;
 147     pizza_parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 148
 149     widget_class->map = gtk_pizza_map;
 150     widget_class->realize = gtk_pizza_realize;
 151     widget_class->unrealize = gtk_pizza_unrealize;
 152     widget_class->size_request = gtk_pizza_size_request;
 153     widget_class->size_allocate = gtk_pizza_size_allocate;
 154     widget_class->expose_event = gtk_pizza_expose;
 155     widget_class->style_set = gtk_pizza_style_set;
 156
 157     container_class->add = gtk_pizza_add;
 158     container_class->remove = gtk_pizza_remove;
 159     container_class->forall = gtk_pizza_forall;
 160
 161     container_class->child_type = gtk_pizza_child_type;
 162
 163     klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
 164
 165     widget_class->set_scroll_adjustments_signal =
 166         g_signal_new(
 167             "set_scroll_adjustments",
 168             G_TYPE_FROM_CLASS(object_class),
 169             G_SIGNAL_RUN_LAST,
 170             G_STRUCT_OFFSET(GtkPizzaClass, set_scroll_adjustments),
 171             NULL,
 172             NULL,
 173             g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
 174             G_TYPE_NONE,
 175             2,
 176             GTK_TYPE_ADJUSTMENT,
 177             GTK_TYPE_ADJUSTMENT);
 178 }
 179
 180 static GtkType
 181 gtk_pizza_child_type (GtkContainer     *container)
 182 {
 183     return GTK_TYPE_WIDGET;
 184 }
 185
 186 static void
 187 gtk_pizza_init (GtkPizza *pizza)
 188 {
 189     GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
 190
 191     pizza->shadow_type = GTK_MYSHADOW_NONE;
 192
 193     pizza->children = NULL;
 194
 195     pizza->width = 20;
 196     pizza->height = 20;
 197
 198     pizza->bin_window = NULL;
 199
 200     pizza->xoffset = 0;
 201     pizza->yoffset = 0;
 202
 203     pizza->configure_serial = 0;
 204     pizza->scroll_x = 0;
 205     pizza->scroll_y = 0;
 206     pizza->visibility = GDK_VISIBILITY_PARTIAL;
 207
 208     pizza->clear_on_draw = TRUE;
 209     pizza->use_filter = TRUE;
 210     pizza->external_expose = FALSE;
 211 }
 212
 213 GtkWidget*
 214 gtk_pizza_new ()
 215 {
 216     GtkPizza *pizza;
 217
 218     pizza = gtk_type_new (gtk_pizza_get_type ());
 219
 220     return GTK_WIDGET (pizza);
 221 }
 222
 223 static void
 224 gtk_pizza_scroll_set_adjustments (GtkPizza     *pizza,
 225                                     GtkAdjustment  *hadj,
 226                                     GtkAdjustment  *vadj)
 227 {
 228    /* We handle scrolling in the wxScrolledWindow, not here. */
 229 }
 230
 231 void
 232 gtk_pizza_set_shadow_type (GtkPizza        *pizza,
 233                            GtkMyShadowType  type)
 234 {
 235     g_return_if_fail (pizza != NULL);
 236     g_return_if_fail (GTK_IS_PIZZA (pizza));
 237
 238     if ((GtkMyShadowType) pizza->shadow_type != type)
 239     {
 240         pizza->shadow_type = type;
 241
 242         if (GTK_WIDGET_VISIBLE (pizza))
 243         {
 244             gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
 245             gtk_widget_queue_draw (GTK_WIDGET (pizza));
 246         }
 247     }
 248 }
 249
 250 void
 251 gtk_pizza_set_clear (GtkPizza  *pizza,
 252                      gboolean   clear)
 253 {
 254     g_return_if_fail (pizza != NULL);
 255     g_return_if_fail (GTK_IS_PIZZA (pizza));
 256
 257     pizza->clear_on_draw = clear;
 258 }
 259
 260 void
 261 gtk_pizza_set_filter (GtkPizza  *pizza,
 262                       gboolean   use)
 263 {
 264     g_return_if_fail (pizza != NULL);
 265     g_return_if_fail (GTK_IS_PIZZA (pizza));
 266
 267     pizza->use_filter = use;
 268 }
 269
 270 void
 271 gtk_pizza_set_external (GtkPizza  *pizza,
 272                         gboolean   expose)
 273 {
 274     g_return_if_fail (pizza != NULL);
 275     g_return_if_fail (GTK_IS_PIZZA (pizza));
 276
 277     pizza->external_expose = expose;
 278 }
 279
 280 void
 281 gtk_pizza_put (GtkPizza   *pizza,
 282                GtkWidget  *widget,
 283                gint        x,
 284                gint        y,
 285                gint        width,
 286                gint        height)
 287 {
 288     GtkPizzaChild *child_info;
 289
 290     g_return_if_fail (pizza != NULL);
 291     g_return_if_fail (GTK_IS_PIZZA (pizza));
 292     g_return_if_fail (widget != NULL);
 293
 294     child_info = g_new (GtkPizzaChild, 1);
 295
 296     child_info->widget = widget;
 297     child_info->x = x;
 298     child_info->y = y;
 299     child_info->width = width;
 300     child_info->height = height;
 301
 302     pizza->children = g_list_append (pizza->children, child_info);
 303
 304     if (GTK_WIDGET_REALIZED (pizza))
 305       gtk_widget_set_parent_window (widget, pizza->bin_window);
 306
 307     gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
 308
 309     gtk_widget_set_size_request (widget, width, height);
 310 }
 311
 312 void
 313 gtk_pizza_move (GtkPizza     *pizza,
 314                   GtkWidget  *widget,
 315                   gint        x,
 316                   gint        y)
 317 {
 318     GtkPizzaChild *child;
 319     GList *children;
 320
 321     g_return_if_fail (pizza != NULL);
 322     g_return_if_fail (GTK_IS_PIZZA (pizza));
 323     g_return_if_fail (widget != NULL);
 324
 325     children = pizza->children;
 326     while (children)
 327     {
 328         child = children->data;
 329         children = children->next;
 330
 331         if (child->widget == widget)
 332         {
 333             if ((child->x == x) && (child->y == y))
 334                 break;
 335
 336             child->x = x;
 337             child->y = y;
 338
 339             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 340                 gtk_widget_queue_resize (widget);
 341             break;
 342         }
 343     }
 344 }
 345
 346 void
 347 gtk_pizza_resize (GtkPizza    *pizza,
 348                   GtkWidget   *widget,
 349                   gint         width,
 350                   gint         height)
 351 {
 352     GtkPizzaChild *child;
 353     GList *children;
 354
 355     g_return_if_fail (pizza != NULL);
 356     g_return_if_fail (GTK_IS_PIZZA (pizza));
 357     g_return_if_fail (widget != NULL);
 358
 359     children = pizza->children;
 360     while (children)
 361     {
 362         child = children->data;
 363         children = children->next;
 364
 365         if (child->widget == widget)
 366         {
 367             if ((child->width == width) && (child->height == height))
 368                 break;
 369
 370             child->width = width;
 371             child->height = height;
 372
 373             gtk_widget_set_size_request (widget, width, height);
 374
 375             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 376                 gtk_widget_queue_resize (widget);
 377             break;
 378         }
 379     }
 380 }
 381
 382 void
 383 gtk_pizza_set_size (GtkPizza   *pizza,
 384                     GtkWidget  *widget,
 385                     gint        x,
 386                     gint        y,
 387                     gint        width,
 388                     gint        height)
 389 {
 390     GtkPizzaChild *child;
 391     GList *children;
 392
 393     g_return_if_fail (pizza != NULL);
 394     g_return_if_fail (GTK_IS_PIZZA (pizza));
 395     g_return_if_fail (widget != NULL);
 396
 397     /* this really shouldn't happen -- but it does, a lot, right now and we
 398        can't pass negative values to gtk_widget_set_size_request(), so filter
 399        them out here */
 400     if ( width < 0 )
 401         width = 0;
 402     if ( height < 0 )
 403         height = 0;
 404
 405     children = pizza->children;
 406     while (children)
 407     {
 408         child = children->data;
 409         children = children->next;
 410
 411         if (child->widget == widget)
 412         {
 413             if ((child->x == x) &&
 414                 (child->y == y) &&
 415                 (child->width == width) &&
 416                 (child->height == height)) return;
 417
 418             child->x = x;
 419             child->y = y;
 420             child->width = width;
 421             child->height = height;
 422
 423             gtk_widget_set_size_request (widget, width, height);
 424
 425             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 426                 gtk_widget_queue_resize (widget);
 427
 428             return;
 429         }
 430     }
 431 }
 432
 433 gint
 434 gtk_pizza_child_resized  (GtkPizza   *pizza,
 435                           GtkWidget  *widget)
 436 {
 437     GtkPizzaChild *child;
 438     GList *children;
 439
 440     g_return_val_if_fail (pizza != NULL, FALSE);
 441     g_return_val_if_fail (GTK_IS_PIZZA (pizza), FALSE);
 442     g_return_val_if_fail (widget != NULL, FALSE);
 443
 444     children = pizza->children;
 445     while (children)
 446     {
 447         child = children->data;
 448         children = children->next;
 449
 450         if (child->widget == widget)
 451         {
 452             return ((child->width == widget->allocation.width) &&
 453                     (child->height == widget->allocation.height));
 454         }
 455     }
 456
 457     return FALSE;
 458 }
 459
 460 static void
 461 gtk_pizza_map (GtkWidget *widget)
 462 {
 463     GtkPizza *pizza;
 464     GtkPizzaChild *child;
 465     GList *children;
 466
 467     g_return_if_fail (widget != NULL);
 468     g_return_if_fail (GTK_IS_PIZZA (widget));
 469
 470     GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 471     pizza = GTK_PIZZA (widget);
 472
 473     children = pizza->children;
 474     while (children)
 475     {
 476         child = children->data;
 477         children = children->next;
 478
 479         if ( GTK_WIDGET_VISIBLE (child->widget) &&
 480             !GTK_WIDGET_MAPPED (child->widget) &&
 481             TRUE)
 482         {
 483             gtk_widget_map (child->widget);
 484         }
 485     }
 486
 487     gdk_window_show (widget->window);
 488     gdk_window_show (pizza->bin_window);
 489 }
 490
 491 static void
 492 gtk_pizza_realize (GtkWidget *widget)
 493 {
 494     GtkPizza *pizza;
 495     GdkWindowAttr attributes;
 496     gint attributes_mask;
 497     GtkPizzaChild *child;
 498     GList *children;
 499
 500     g_return_if_fail (widget != NULL);
 501     g_return_if_fail (GTK_IS_PIZZA (widget));
 502
 503     pizza = GTK_PIZZA (widget);
 504     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 505
 506     attributes.window_type = GDK_WINDOW_CHILD;
 507
 508     attributes.x = widget->allocation.x;
 509     attributes.y = widget->allocation.y;
 510     attributes.width = widget->allocation.width;
 511     attributes.height = widget->allocation.height;
 512
 513 #ifndef __WXUNIVERSAL__
 514     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
 515     {
 516         /* no border, no changes to sizes */
 517     }
 518     else if (pizza->shadow_type == GTK_MYSHADOW_THIN)
 519     {
 520         /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
 521         attributes.x += 1;
 522         attributes.y += 1;
 523         attributes.width -= 2;
 524         attributes.height -= 2;
 525     }
 526     else
 527     {
 528         /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
 529         /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
 530         attributes.x += 2;
 531         attributes.y += 2;
 532         attributes.width -= 4;
 533         attributes.height -= 4;
 534     }
 535 #endif /* __WXUNIVERSAL__ */
 536
 537     /* minimal size */
 538     if (attributes.width < 2) attributes.width = 2;
 539     if (attributes.height < 2) attributes.height = 2;
 540
 541     attributes.wclass = GDK_INPUT_OUTPUT;
 542     attributes.visual = gtk_widget_get_visual (widget);
 543     attributes.colormap = gtk_widget_get_colormap (widget);
 544     attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
 545     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 546
 547     widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
 548                                      &attributes, attributes_mask);
 549     gdk_window_set_user_data (widget->window, widget);
 550
 551     attributes.x = 0;
 552     attributes.y = 0;
 553
 554     attributes.event_mask = gtk_widget_get_events (widget);
 555     attributes.event_mask |= GDK_EXPOSURE_MASK              |
 556                              GDK_SCROLL_MASK                |
 557                              GDK_POINTER_MOTION_MASK        |
 558                              GDK_POINTER_MOTION_HINT_MASK   |
 559                              GDK_BUTTON_MOTION_MASK         |
 560                              GDK_BUTTON1_MOTION_MASK        |
 561                              GDK_BUTTON2_MOTION_MASK        |
 562                              GDK_BUTTON3_MOTION_MASK        |
 563                              GDK_BUTTON_PRESS_MASK          |
 564                              GDK_BUTTON_RELEASE_MASK        |
 565                              GDK_KEY_PRESS_MASK             |
 566                              GDK_KEY_RELEASE_MASK           |
 567                              GDK_ENTER_NOTIFY_MASK          |
 568                              GDK_LEAVE_NOTIFY_MASK          |
 569                              GDK_FOCUS_CHANGE_MASK;
 570
 571     pizza->bin_window = gdk_window_new(widget->window,
 572                                           &attributes, attributes_mask);
 573     gdk_window_set_user_data (pizza->bin_window, widget);
 574
 575     widget->style = gtk_style_attach (widget->style, widget->window);
 576     gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 577     gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
 578
 579 /*
 580     gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
 581     gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
 582 */
 583
 584     /* cannot be done before realisation */
 585     children = pizza->children;
 586     while (children)
 587     {
 588         child = children->data;
 589         children = children->next;
 590
 591         gtk_widget_set_parent_window (child->widget, pizza->bin_window);
 592     }
 593 }
 594
 595 static void
 596 gtk_pizza_unrealize (GtkWidget *widget)
 597 {
 598     GtkPizza *pizza;
 599
 600     g_return_if_fail (widget != NULL);
 601     g_return_if_fail (GTK_IS_PIZZA (widget));
 602
 603     pizza = GTK_PIZZA (widget);
 604
 605     gdk_window_set_user_data (pizza->bin_window, NULL);
 606     gdk_window_destroy (pizza->bin_window);
 607     pizza->bin_window = NULL;
 608
 609     if (GTK_WIDGET_CLASS (pizza_parent_class)->unrealize)
 610        (* GTK_WIDGET_CLASS (pizza_parent_class)->unrealize) (widget);
 611 }
 612
 613 static void
 614 gtk_pizza_size_request (GtkWidget      *widget,
 615                         GtkRequisition *requisition)
 616 {
 617     GtkPizza *pizza;
 618     GtkPizzaChild *child;
 619     GList *children;
 620     GtkRequisition child_requisition;
 621
 622     g_return_if_fail (widget != NULL);
 623     g_return_if_fail (GTK_IS_PIZZA (widget));
 624     g_return_if_fail (requisition != NULL);
 625
 626     pizza = GTK_PIZZA (widget);
 627
 628     children = pizza->children;
 629     while (children)
 630     {
 631         child = children->data;
 632         children = children->next;
 633
 634         if (GTK_WIDGET_VISIBLE (child->widget))
 635         {
 636             gtk_widget_size_request (child->widget, &child_requisition);
 637         }
 638     }
 639
 640     /* request very little, I'm not sure if requesting nothing
 641        will always have positive effects on stability... */
 642     requisition->width = 2;
 643     requisition->height = 2;
 644 }
 645
 646 static void
 647 gtk_pizza_size_allocate (GtkWidget     *widget,
 648                          GtkAllocation *allocation)
 649 {
 650     GtkPizza *pizza;
 651     gint border;
 652     gint x,y,w,h;
 653     GtkPizzaChild *child;
 654     GList *children;
 655
 656     g_return_if_fail (widget != NULL);
 657     g_return_if_fail (GTK_IS_PIZZA(widget));
 658     g_return_if_fail (allocation != NULL);
 659
 660     pizza = GTK_PIZZA (widget);
 661
 662     widget->allocation = *allocation;
 663
 664     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
 665         border = 0;
 666     else
 667     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
 668         border = 1;
 669     else
 670         border = 2;
 671
 672     x = allocation->x + border;
 673     y = allocation->y + border;
 674     w = allocation->width - border*2;
 675     h = allocation->height - border*2;
 676
 677     if (GTK_WIDGET_REALIZED (widget))
 678     {
 679         gdk_window_move_resize( widget->window, x, y, w, h );
 680         gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
 681     }
 682
 683     children = pizza->children;
 684     while (children)
 685     {
 686         child = children->data;
 687         children = children->next;
 688
 689         gtk_pizza_allocate_child (pizza, child);
 690     }
 691 }
 692
 693 static gint
 694 gtk_pizza_expose (GtkWidget      *widget,
 695                   GdkEventExpose *event)
 696 {
 697     GtkPizza *pizza;
 698
 699     g_return_val_if_fail (widget != NULL, FALSE);
 700     g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
 701     g_return_val_if_fail (event != NULL, FALSE);
 702
 703     pizza = GTK_PIZZA (widget);
 704
 705     if (event->window != pizza->bin_window)
 706         return FALSE;
 707
 708     /* We handle all expose events in window.cpp now. */
 709     if (pizza->external_expose)
 710         return FALSE;
 711
 712     (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, event);
 713
 714     return FALSE;
 715 }
 716
 717 static void
 718 gtk_pizza_style_set(GtkWidget *widget, GtkStyle  *previous_style)
 719 {
 720     if (GTK_WIDGET_REALIZED(widget))
 721     {
 722         gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
 723         gtk_style_set_background(widget->style, GTK_PIZZA(widget)->bin_window, GTK_STATE_NORMAL );
 724     }
 725
 726     (* GTK_WIDGET_CLASS (pizza_parent_class)->style_set) (widget, previous_style);
 727 }
 728
 729 static void
 730 gtk_pizza_add (GtkContainer *container,
 731                GtkWidget    *widget)
 732 {
 733     g_return_if_fail (container != NULL);
 734     g_return_if_fail (GTK_IS_PIZZA (container));
 735     g_return_if_fail (widget != NULL);
 736
 737     gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
 738 }
 739
 740 static void
 741 gtk_pizza_remove (GtkContainer *container,
 742                   GtkWidget    *widget)
 743 {
 744     GtkPizza *pizza;
 745     GtkPizzaChild *child;
 746     GList *children;
 747
 748     g_return_if_fail (container != NULL);
 749     g_return_if_fail (GTK_IS_PIZZA (container));
 750     g_return_if_fail (widget != NULL);
 751
 752     pizza = GTK_PIZZA (container);
 753
 754     children = pizza->children;
 755     while (children)
 756     {
 757         child = children->data;
 758
 759         if (child->widget == widget)
 760         {
 761             gtk_widget_unparent (widget);
 762
 763             /* security checks */
 764             g_return_if_fail (GTK_IS_WIDGET (widget));
 765
 766             pizza->children = g_list_remove_link (pizza->children, children);
 767             g_list_free (children);
 768             g_free (child);
 769
 770             /* security checks */
 771             g_return_if_fail (GTK_IS_WIDGET (widget));
 772
 773             break;
 774         }
 775
 776         children = children->next;
 777     }
 778 }
 779
 780 static void
 781 gtk_pizza_forall (GtkContainer *container,
 782                   gboolean      include_internals,
 783                   GtkCallback   callback,
 784                   gpointer      callback_data)
 785 {
 786     GtkPizza *pizza;
 787     GtkPizzaChild *child;
 788     GList *children;
 789
 790     g_return_if_fail (container != NULL);
 791     g_return_if_fail (GTK_IS_PIZZA (container));
 792     g_return_if_fail (callback != (GtkCallback)NULL);
 793
 794     pizza = GTK_PIZZA (container);
 795
 796     children = pizza->children;
 797     while (children)
 798     {
 799         child = children->data;
 800         children = children->next;
 801
 802         (* callback) (child->widget, callback_data);
 803     }
 804 }
 805
 806 static void
 807 gtk_pizza_allocate_child (GtkPizza      *pizza,
 808                           GtkPizzaChild *child)
 809 {
 810     GtkAllocation allocation;
 811     GtkRequisition requisition;
 812
 813     allocation.x = child->x - pizza->xoffset;
 814     allocation.y = child->y - pizza->yoffset;
 815     gtk_widget_get_child_requisition (child->widget, &requisition);
 816     allocation.width = requisition.width;
 817     allocation.height = requisition.height;
 818
 819     gtk_widget_size_allocate (child->widget, &allocation);
 820 }
 821
 822 static void
 823 gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
 824                                        gpointer   cb_data)
 825 {
 826     GtkPizzaAdjData *data = cb_data;
 827
 828     widget->allocation.x += data->dx;
 829     widget->allocation.y += data->dy;
 830
 831     if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
 832     {
 833         gtk_container_forall (GTK_CONTAINER (widget),
 834                           gtk_pizza_adjust_allocations_recurse,
 835                           cb_data);
 836     }
 837 }
 838
 839 static void
 840 gtk_pizza_adjust_allocations (GtkPizza *pizza,
 841                                gint       dx,
 842                                gint       dy)
 843 {
 844     GList *tmp_list;
 845     GtkPizzaAdjData data;
 846
 847     data.dx = dx;
 848     data.dy = dy;
 849
 850     tmp_list = pizza->children;
 851     while (tmp_list)
 852     {
 853         GtkPizzaChild *child = tmp_list->data;
 854         tmp_list = tmp_list->next;
 855
 856         child->widget->allocation.x += dx;
 857         child->widget->allocation.y += dy;
 858
 859         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 860             GTK_IS_CONTAINER (child->widget))
 861         {
 862             gtk_container_forall (GTK_CONTAINER (child->widget),
 863                                   gtk_pizza_adjust_allocations_recurse,
 864                                   &data);
 865         }
 866     }
 867 }
 868
 869
 870 /* This is the main routine to do the scrolling. Scrolling is
 871  * done by "Guffaw" scrolling, as in the Mozilla XFE, with
 872  * a few modifications.
 873  *
 874  * The main improvement is that we keep track of whether we
 875  * are obscured or not. If not, we ignore the generated expose
 876  * events and instead do the exposes ourself, without having
 877  * to wait for a roundtrip to the server. This also provides
 878  * a limited form of expose-event compression, since we do
 879  * the affected area as one big chunk.
 880  */
 881
 882 void
 883 gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
 884 {
 885     pizza->xoffset += dx;
 886     pizza->yoffset += dy;
 887
 888     gtk_pizza_adjust_allocations (pizza, -dx, -dy);
 889
 890     if (pizza->bin_window)
 891         gdk_window_scroll( pizza->bin_window, -dx, -dy );
 892 }
 893
 894 #ifdef __cplusplus
 895 }
 896 #endif /* __cplusplus */