src/gtk1/win_gtk.c

   1 /* ///////////////////////////////////////////////////////////////////////////
   2 // Name:        win_gtk.c
   3 // Purpose:     Native GTK+ widget for wxWindows, 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:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////// */
  11
  12 #ifdef VMS
  13 #define XCheckIfEvent XCHECKIFEVENT
  14 #endif
  15
  16 #include "wx/setup.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 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <X11/Xatom.h>
  29
  30 #define IS_ONSCREEN(x,y) ((x >= G_MINSHORT) && (x <= G_MAXSHORT) && \
  31                           (y >= G_MINSHORT) && (y <= G_MAXSHORT))
  32
  33 typedef struct _GtkPizzaAdjData  GtkPizzaAdjData;
  34
  35 struct _GtkPizzaAdjData
  36 {
  37     gint dx;
  38     gint dy;
  39 };
  40
  41 static void gtk_pizza_class_init    (GtkPizzaClass    *klass);
  42 static void gtk_pizza_init          (GtkPizza         *pizza);
  43
  44 static void gtk_pizza_realize       (GtkWidget        *widget);
  45 static void gtk_pizza_unrealize     (GtkWidget        *widget);
  46
  47 static void gtk_pizza_map           (GtkWidget        *widget);
  48
  49 static void gtk_pizza_size_request  (GtkWidget        *widget,
  50                                      GtkRequisition   *requisition);
  51 static void gtk_pizza_size_allocate (GtkWidget        *widget,
  52                                      GtkAllocation    *allocation);
  53 static void gtk_pizza_draw          (GtkWidget        *widget,
  54                                      GdkRectangle     *area);
  55 static gint gtk_pizza_expose        (GtkWidget        *widget,
  56                                      GdkEventExpose   *event);
  57 static void gtk_pizza_add           (GtkContainer     *container,
  58                                      GtkWidget        *widget);
  59 static void gtk_pizza_remove        (GtkContainer     *container,
  60                                      GtkWidget        *widget);
  61 static void gtk_pizza_forall        (GtkContainer     *container,
  62                                      gboolean          include_internals,
  63                                      GtkCallback       callback,
  64                                      gpointer          callback_data);
  65
  66 static void     gtk_pizza_position_child     (GtkPizza      *pizza,
  67                                               GtkPizzaChild *child);
  68 static void     gtk_pizza_allocate_child     (GtkPizza      *pizza,
  69                                               GtkPizzaChild *child);
  70 static void     gtk_pizza_position_children  (GtkPizza      *pizza);
  71
  72 static void     gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
  73                                                       gpointer   cb_data);
  74 static void     gtk_pizza_adjust_allocations         (GtkPizza  *pizza,
  75                                                       gint       dx,
  76                                                       gint       dy);
  77
  78
  79 /* unused */
  80 #if 0
  81 static void     gtk_pizza_expose_area        (GtkPizza       *pizza,
  82                                               gint            x,
  83                                               gint            y,
  84                                               gint            width,
  85                                               gint            height);
  86 static void     gtk_pizza_adjustment_changed (GtkAdjustment  *adjustment,
  87                                               GtkPizza       *pizza);
  88 #endif
  89
  90 static GdkFilterReturn gtk_pizza_filter      (GdkXEvent      *gdk_xevent,
  91                                               GdkEvent       *event,
  92                                               gpointer        data);
  93 static GdkFilterReturn gtk_pizza_main_filter (GdkXEvent      *gdk_xevent,
  94                                               GdkEvent       *event,
  95                                               gpointer        data);
  96
  97
  98 static GtkType gtk_pizza_child_type (GtkContainer     *container);
  99
 100 static void  gtk_pizza_scroll_set_adjustments (GtkPizza      *pizza,
 101                                                GtkAdjustment *hadj,
 102                                                GtkAdjustment *vadj);
 103
 104
 105 static GtkContainerClass *parent_class = NULL;
 106 static gboolean gravity_works;
 107
 108 guint
 109 gtk_pizza_get_type ()
 110 {
 111     static guint pizza_type = 0;
 112
 113     if (!pizza_type)
 114     {
 115         GtkTypeInfo pizza_info =
 116         {
 117            "GtkPizza",
 118            sizeof (GtkPizza),
 119            sizeof (GtkPizzaClass),
 120            (GtkClassInitFunc) gtk_pizza_class_init,
 121            (GtkObjectInitFunc) gtk_pizza_init,
 122            /* reserved_1 */ NULL,
 123            /* reserved_2 */ NULL,
 124            (GtkClassInitFunc) NULL,
 125         };
 126         pizza_type = gtk_type_unique (gtk_container_get_type (), &pizza_info);
 127     }
 128
 129     return pizza_type;
 130 }
 131
 132 static void
 133 gtk_pizza_class_init (GtkPizzaClass *klass)
 134 {
 135     GtkObjectClass *object_class;
 136     GtkWidgetClass *widget_class;
 137     GtkContainerClass *container_class;
 138
 139     object_class = (GtkObjectClass*) klass;
 140     widget_class = (GtkWidgetClass*) klass;
 141     container_class = (GtkContainerClass*) klass;
 142     parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 143
 144     widget_class->map = gtk_pizza_map;
 145     widget_class->realize = gtk_pizza_realize;
 146     widget_class->unrealize = gtk_pizza_unrealize;
 147     widget_class->size_request = gtk_pizza_size_request;
 148     widget_class->size_allocate = gtk_pizza_size_allocate;
 149     widget_class->draw = gtk_pizza_draw;
 150     widget_class->expose_event = gtk_pizza_expose;
 151
 152     container_class->add = gtk_pizza_add;
 153     container_class->remove = gtk_pizza_remove;
 154     container_class->forall = gtk_pizza_forall;
 155
 156     container_class->child_type = gtk_pizza_child_type;
 157
 158     klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments;
 159
 160     widget_class->set_scroll_adjustments_signal =
 161     gtk_signal_new ("set_scroll_adjustments",
 162                     GTK_RUN_LAST,
 163
 164 #ifdef __WXGTK20__
 165                     GTK_CLASS_TYPE(object_class),
 166 #else
 167                     object_class->type,
 168 #endif
 169                     GTK_SIGNAL_OFFSET (GtkPizzaClass, set_scroll_adjustments),
 170                     gtk_marshal_NONE__POINTER_POINTER,
 171                     GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 172 }
 173
 174 static GtkType
 175 gtk_pizza_child_type (GtkContainer     *container)
 176 {
 177     return GTK_TYPE_WIDGET;
 178 }
 179
 180 static void
 181 gtk_pizza_init (GtkPizza *pizza)
 182 {
 183     GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW);
 184
 185     pizza->shadow_type = GTK_MYSHADOW_NONE;
 186
 187     pizza->children = NULL;
 188
 189     pizza->width = 20;
 190     pizza->height = 20;
 191
 192     pizza->bin_window = NULL;
 193
 194     pizza->xoffset = 0;
 195     pizza->yoffset = 0;
 196
 197     pizza->configure_serial = 0;
 198     pizza->scroll_x = 0;
 199     pizza->scroll_y = 0;
 200     pizza->visibility = GDK_VISIBILITY_PARTIAL;
 201
 202     pizza->clear_on_draw = TRUE;
 203     pizza->use_filter = TRUE;
 204     pizza->external_expose = FALSE;
 205 }
 206
 207 GtkWidget*
 208 gtk_pizza_new ()
 209 {
 210     GtkPizza *pizza;
 211
 212     pizza = gtk_type_new (gtk_pizza_get_type ());
 213
 214     return GTK_WIDGET (pizza);
 215 }
 216
 217 static void
 218 gtk_pizza_scroll_set_adjustments (GtkPizza     *pizza,
 219                                     GtkAdjustment  *hadj,
 220                                     GtkAdjustment  *vadj)
 221 {
 222    /* We handle scrolling in the wxScrolledWindow, not here. */
 223 }
 224
 225 void
 226 gtk_pizza_set_shadow_type (GtkPizza        *pizza,
 227                            GtkMyShadowType  type)
 228 {
 229     g_return_if_fail (pizza != NULL);
 230     g_return_if_fail (GTK_IS_PIZZA (pizza));
 231
 232     if ((GtkMyShadowType) pizza->shadow_type != type)
 233     {
 234         pizza->shadow_type = type;
 235
 236         if (GTK_WIDGET_VISIBLE (pizza))
 237         {
 238             gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation));
 239             gtk_widget_queue_draw (GTK_WIDGET (pizza));
 240         }
 241     }
 242 }
 243
 244 void
 245 gtk_pizza_set_clear (GtkPizza  *pizza,
 246                      gboolean   clear)
 247 {
 248     g_return_if_fail (pizza != NULL);
 249     g_return_if_fail (GTK_IS_PIZZA (pizza));
 250
 251     pizza->clear_on_draw = clear;
 252 }
 253
 254 void
 255 gtk_pizza_set_filter (GtkPizza  *pizza,
 256                       gboolean   use)
 257 {
 258     g_return_if_fail (pizza != NULL);
 259     g_return_if_fail (GTK_IS_PIZZA (pizza));
 260
 261     pizza->use_filter = use;
 262 }
 263
 264 void
 265 gtk_pizza_set_external (GtkPizza  *pizza,
 266                         gboolean   expose)
 267 {
 268     g_return_if_fail (pizza != NULL);
 269     g_return_if_fail (GTK_IS_PIZZA (pizza));
 270
 271     pizza->external_expose = expose;
 272 }
 273
 274 void
 275 gtk_pizza_put (GtkPizza   *pizza,
 276                GtkWidget  *widget,
 277                gint        x,
 278                gint        y,
 279                gint        width,
 280                gint        height)
 281 {
 282     GtkPizzaChild *child_info;
 283
 284     g_return_if_fail (pizza != NULL);
 285     g_return_if_fail (GTK_IS_PIZZA (pizza));
 286     g_return_if_fail (widget != NULL);
 287
 288     child_info = g_new (GtkPizzaChild, 1);
 289
 290     child_info->widget = widget;
 291     child_info->x = x;
 292     child_info->y = y;
 293     child_info->width = width;
 294     child_info->height = height;
 295
 296     pizza->children = g_list_append (pizza->children, child_info);
 297
 298     gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
 299
 300     if (GTK_WIDGET_REALIZED (pizza))
 301       gtk_widget_set_parent_window (widget, pizza->bin_window);
 302
 303 #ifndef __WXGTK20__ /* FIXME? */
 304     if (!IS_ONSCREEN (x, y))
 305        GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN);
 306 #endif
 307
 308 /*
 309     if (GTK_WIDGET_REALIZED (pizza))
 310         gtk_widget_realize (widget);
 311 */
 312
 313     gtk_widget_set_usize (widget, width, height);
 314
 315 /*
 316     if (GTK_WIDGET_VISIBLE (pizza) && GTK_WIDGET_VISIBLE (widget))
 317     {
 318         if (GTK_WIDGET_MAPPED (pizza))
 319             gtk_widget_map (widget);
 320
 321         gtk_widget_queue_resize (widget);
 322     }
 323 */
 324 }
 325
 326 void
 327 gtk_pizza_move (GtkPizza     *pizza,
 328                   GtkWidget  *widget,
 329                   gint        x,
 330                   gint        y)
 331 {
 332     GtkPizzaChild *child;
 333     GList *children;
 334
 335     g_return_if_fail (pizza != NULL);
 336     g_return_if_fail (GTK_IS_PIZZA (pizza));
 337     g_return_if_fail (widget != NULL);
 338
 339     children = pizza->children;
 340     while (children)
 341     {
 342         child = children->data;
 343         children = children->next;
 344
 345         if (child->widget == widget)
 346         {
 347             if ((child->x == x) && (child->y == y))
 348                 break;
 349
 350             child->x = x;
 351             child->y = y;
 352
 353             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 354                 gtk_widget_queue_resize (widget);
 355             break;
 356         }
 357     }
 358 }
 359
 360 void
 361 gtk_pizza_resize (GtkPizza    *pizza,
 362                   GtkWidget   *widget,
 363                   gint         width,
 364                   gint         height)
 365 {
 366     GtkPizzaChild *child;
 367     GList *children;
 368
 369     g_return_if_fail (pizza != NULL);
 370     g_return_if_fail (GTK_IS_PIZZA (pizza));
 371     g_return_if_fail (widget != NULL);
 372
 373     children = pizza->children;
 374     while (children)
 375     {
 376         child = children->data;
 377         children = children->next;
 378
 379         if (child->widget == widget)
 380         {
 381             if ((child->width == width) && (child->height == height))
 382                 break;
 383
 384             child->width = width;
 385             child->height = height;
 386
 387             gtk_widget_set_usize (widget, width, height);
 388
 389             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 390                 gtk_widget_queue_resize (widget);
 391             break;
 392         }
 393     }
 394 }
 395
 396 void
 397 gtk_pizza_set_size (GtkPizza   *pizza,
 398                     GtkWidget  *widget,
 399                     gint        x,
 400                     gint        y,
 401                     gint        width,
 402                     gint        height)
 403 {
 404     GtkPizzaChild *child;
 405     GList *children;
 406
 407     g_return_if_fail (pizza != NULL);
 408     g_return_if_fail (GTK_IS_PIZZA (pizza));
 409     g_return_if_fail (widget != NULL);
 410
 411     children = pizza->children;
 412     while (children)
 413     {
 414         child = children->data;
 415         children = children->next;
 416
 417         if (child->widget == widget)
 418         {
 419             if ((child->x == x) &&
 420                 (child->y == y) &&
 421                 (child->width == width) &&
 422                 (child->height == height)) return;
 423
 424             child->x = x;
 425             child->y = y;
 426             child->width = width;
 427             child->height = height;
 428
 429             gtk_widget_set_usize (widget, width, height);
 430
 431             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza))
 432                 gtk_widget_queue_resize (widget);
 433
 434             return;
 435         }
 436     }
 437 }
 438
 439 gint
 440 gtk_pizza_child_resized  (GtkPizza   *pizza,
 441                           GtkWidget  *widget)
 442 {
 443     GtkPizzaChild *child;
 444     GList *children;
 445
 446     g_return_val_if_fail (pizza != NULL, FALSE);
 447     g_return_val_if_fail (GTK_IS_PIZZA (pizza), FALSE);
 448     g_return_val_if_fail (widget != NULL, FALSE);
 449
 450     children = pizza->children;
 451     while (children)
 452     {
 453         child = children->data;
 454         children = children->next;
 455
 456         if (child->widget == widget)
 457         {
 458             return ((child->width == widget->allocation.width) &&
 459                     (child->height == widget->allocation.height));
 460         }
 461     }
 462
 463     return FALSE;
 464 }
 465
 466 static void
 467 gtk_pizza_map (GtkWidget *widget)
 468 {
 469     GtkPizza *pizza;
 470     GtkPizzaChild *child;
 471     GList *children;
 472
 473     g_return_if_fail (widget != NULL);
 474     g_return_if_fail (GTK_IS_PIZZA (widget));
 475
 476     GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 477     pizza = GTK_PIZZA (widget);
 478
 479     children = pizza->children;
 480     while (children)
 481     {
 482         child = children->data;
 483         children = children->next;
 484
 485         if ( GTK_WIDGET_VISIBLE (child->widget) &&
 486             !GTK_WIDGET_MAPPED (child->widget) &&
 487 #ifdef __WXGTK20__
 488             TRUE)
 489 #else
 490             !GTK_WIDGET_IS_OFFSCREEN (child->widget))
 491 #endif
 492         {
 493             gtk_widget_map (child->widget);
 494         }
 495     }
 496
 497     gdk_window_show (widget->window);
 498     gdk_window_show (pizza->bin_window);
 499 }
 500
 501 static void
 502 gtk_pizza_realize (GtkWidget *widget)
 503 {
 504     GtkPizza *pizza;
 505     GdkWindowAttr attributes;
 506     gint attributes_mask;
 507     GtkPizzaChild *child;
 508     GList *children;
 509
 510     g_return_if_fail (widget != NULL);
 511     g_return_if_fail (GTK_IS_PIZZA (widget));
 512
 513     pizza = GTK_PIZZA (widget);
 514
 515     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 516
 517     attributes.window_type = GDK_WINDOW_CHILD;
 518
 519     attributes.x = widget->allocation.x;
 520     attributes.y = widget->allocation.y;
 521     attributes.width = widget->allocation.width;
 522     attributes.height = widget->allocation.height;
 523
 524     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
 525     {
 526         /* no border, no changes to sizes */
 527     } else
 528     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
 529     {
 530         /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */
 531         attributes.x += 1;
 532         attributes.y += 1;
 533         attributes.width -= 2;
 534         attributes.height -= 2;
 535     } else
 536     {
 537         /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */
 538         /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */
 539         attributes.x += 2;
 540         attributes.y += 2;
 541         attributes.width -= 4;
 542         attributes.height -= 4;
 543     }
 544
 545     /* minimal size */
 546     if (attributes.width < 2) attributes.width = 2;
 547     if (attributes.height < 2) attributes.height = 2;
 548
 549     attributes.wclass = GDK_INPUT_OUTPUT;
 550     attributes.visual = gtk_widget_get_visual (widget);
 551     attributes.colormap = gtk_widget_get_colormap (widget);
 552     attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
 553     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 554
 555     widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
 556                                      &attributes, attributes_mask);
 557     gdk_window_set_user_data (widget->window, widget);
 558
 559     attributes.x = 0;
 560     attributes.y = 0;
 561
 562     attributes.event_mask = gtk_widget_get_events (widget);
 563     attributes.event_mask |= GDK_EXPOSURE_MASK              |
 564                              GDK_POINTER_MOTION_MASK        |
 565                              GDK_POINTER_MOTION_HINT_MASK   |
 566                              GDK_BUTTON_MOTION_MASK         |
 567                              GDK_BUTTON1_MOTION_MASK        |
 568                              GDK_BUTTON2_MOTION_MASK        |
 569                              GDK_BUTTON3_MOTION_MASK        |
 570                              GDK_BUTTON_PRESS_MASK          |
 571                              GDK_BUTTON_RELEASE_MASK        |
 572                              GDK_KEY_PRESS_MASK             |
 573                              GDK_KEY_RELEASE_MASK           |
 574                              GDK_ENTER_NOTIFY_MASK          |
 575                              GDK_LEAVE_NOTIFY_MASK          |
 576                              GDK_FOCUS_CHANGE_MASK;
 577
 578     pizza->bin_window = gdk_window_new(widget->window,
 579                                           &attributes, attributes_mask);
 580     gdk_window_set_user_data (pizza->bin_window, widget);
 581
 582     widget->style = gtk_style_attach (widget->style, widget->window);
 583     gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 584     gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
 585
 586 /*
 587     gdk_window_set_back_pixmap( widget->window, NULL, FALSE );
 588     gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE );
 589 */
 590
 591     /* add filters for intercepting visibility and expose events */
 592     gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
 593     gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
 594
 595     /* we NEED gravity or we'll give up */
 596     gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
 597
 598     /* cannot be done before realisation */
 599     children = pizza->children;
 600     while (children)
 601     {
 602         child = children->data;
 603         children = children->next;
 604
 605         gtk_widget_set_parent_window (child->widget, pizza->bin_window);
 606     }
 607 }
 608
 609 static void
 610 gtk_pizza_unrealize (GtkWidget *widget)
 611 {
 612     GtkPizza *pizza;
 613
 614     g_return_if_fail (widget != NULL);
 615     g_return_if_fail (GTK_IS_PIZZA (widget));
 616
 617     pizza = GTK_PIZZA (widget);
 618
 619     gdk_window_set_user_data (pizza->bin_window, NULL);
 620     gdk_window_destroy (pizza->bin_window);
 621     pizza->bin_window = NULL;
 622
 623     if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 624        (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 625 }
 626
 627 static void
 628 gtk_pizza_size_request (GtkWidget      *widget,
 629                         GtkRequisition *requisition)
 630 {
 631     GtkPizza *pizza;
 632     GtkPizzaChild *child;
 633     GList *children;
 634     GtkRequisition child_requisition;
 635
 636     g_return_if_fail (widget != NULL);
 637     g_return_if_fail (GTK_IS_PIZZA (widget));
 638     g_return_if_fail (requisition != NULL);
 639
 640     pizza = GTK_PIZZA (widget);
 641
 642     children = pizza->children;
 643     while (children)
 644     {
 645         child = children->data;
 646         children = children->next;
 647
 648         if (GTK_WIDGET_VISIBLE (child->widget))
 649         {
 650             gtk_widget_size_request (child->widget, &child_requisition);
 651         }
 652     }
 653
 654     /* request very little, I'm not sure if requesting nothing
 655        will always have positive effects on stability... */
 656     requisition->width = 2;
 657     requisition->height = 2;
 658 }
 659
 660 static void
 661 gtk_pizza_size_allocate (GtkWidget     *widget,
 662                          GtkAllocation *allocation)
 663 {
 664     GtkPizza *pizza;
 665     gint border;
 666     gint x,y,w,h;
 667     GtkPizzaChild *child;
 668     GList *children;
 669
 670     g_return_if_fail (widget != NULL);
 671     g_return_if_fail (GTK_IS_PIZZA(widget));
 672     g_return_if_fail (allocation != NULL);
 673
 674     pizza = GTK_PIZZA (widget);
 675
 676     widget->allocation = *allocation;
 677
 678     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
 679         border = 0;
 680     else
 681     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
 682         border = 1;
 683     else
 684         border = 2;
 685
 686     x = allocation->x + border;
 687     y = allocation->y + border;
 688     w = allocation->width - border*2;
 689     h = allocation->height - border*2;
 690
 691     if (GTK_WIDGET_REALIZED (widget))
 692     {
 693         gdk_window_move_resize( widget->window, x, y, w, h );
 694         gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
 695     }
 696
 697     children = pizza->children;
 698     while (children)
 699     {
 700         child = children->data;
 701         children = children->next;
 702
 703         gtk_pizza_position_child (pizza, child);
 704         gtk_pizza_allocate_child (pizza, child);
 705     }
 706 }
 707
 708 static void
 709 gtk_pizza_draw (GtkWidget    *widget,
 710                 GdkRectangle *area)
 711 {
 712     GtkPizza *pizza;
 713     GtkPizzaChild *child;
 714     GdkRectangle child_area;
 715     GList *children;
 716
 717     g_return_if_fail (widget != NULL);
 718     g_return_if_fail (GTK_IS_PIZZA (widget));
 719
 720     pizza = GTK_PIZZA (widget);
 721
 722     /* Sometimes, We handle all expose events in window.cpp now. */
 723     if (pizza->external_expose)
 724         return;
 725
 726     children = pizza->children;
 727     if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
 728          (pizza->clear_on_draw))
 729     {
 730         gdk_window_clear_area( pizza->bin_window,
 731                                 area->x, area->y, area->width, area->height);
 732     }
 733
 734     while (children)
 735     {
 736         child = children->data;
 737         children = children->next;
 738
 739         if (gtk_widget_intersect (child->widget, area, &child_area))
 740             gtk_widget_draw (child->widget, &child_area);
 741     }
 742 }
 743
 744 static gint
 745 gtk_pizza_expose (GtkWidget      *widget,
 746                   GdkEventExpose *event)
 747 {
 748     GtkPizza *pizza;
 749     GtkPizzaChild *child;
 750     GdkEventExpose child_event;
 751     GList *children;
 752
 753     g_return_val_if_fail (widget != NULL, FALSE);
 754     g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
 755     g_return_val_if_fail (event != NULL, FALSE);
 756
 757     pizza = GTK_PIZZA (widget);
 758
 759     /* Sometimes, We handle all expose events in window.cpp now. */
 760     if (pizza->external_expose)
 761         return FALSE;
 762
 763     if (event->window != pizza->bin_window)
 764         return FALSE;
 765
 766     children = pizza->children;
 767     while (children)
 768     {
 769         child = children->data;
 770         children = children->next;
 771
 772         child_event = *event;
 773
 774         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 775             GTK_WIDGET_DRAWABLE (child->widget) &&
 776             gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 777         {
 778             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 779         }
 780     }
 781
 782     return TRUE;
 783 }
 784
 785 static void
 786 gtk_pizza_add (GtkContainer *container,
 787                GtkWidget    *widget)
 788 {
 789     g_return_if_fail (container != NULL);
 790     g_return_if_fail (GTK_IS_PIZZA (container));
 791     g_return_if_fail (widget != NULL);
 792
 793     gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
 794 }
 795
 796 static void
 797 gtk_pizza_remove (GtkContainer *container,
 798                   GtkWidget    *widget)
 799 {
 800     GtkPizza *pizza;
 801     GtkPizzaChild *child;
 802     GList *children;
 803
 804     g_return_if_fail (container != NULL);
 805     g_return_if_fail (GTK_IS_PIZZA (container));
 806     g_return_if_fail (widget != NULL);
 807
 808     pizza = GTK_PIZZA (container);
 809
 810     children = pizza->children;
 811     while (children)
 812     {
 813         child = children->data;
 814
 815         if (child->widget == widget)
 816         {
 817             gtk_widget_unparent (widget);
 818
 819             /* security checks */
 820             g_return_if_fail (GTK_IS_WIDGET (widget));
 821
 822             pizza->children = g_list_remove_link (pizza->children, children);
 823             g_list_free (children);
 824             g_free (child);
 825
 826             /* security checks */
 827             g_return_if_fail (GTK_IS_WIDGET (widget));
 828
 829 #ifndef __WXGTK20__
 830             GTK_PRIVATE_UNSET_FLAG (widget, GTK_IS_OFFSCREEN);
 831 #endif
 832
 833             break;
 834         }
 835
 836         children = children->next;
 837     }
 838 }
 839
 840 static void
 841 gtk_pizza_forall (GtkContainer *container,
 842                   gboolean      include_internals,
 843                   GtkCallback   callback,
 844                   gpointer      callback_data)
 845 {
 846     GtkPizza *pizza;
 847     GtkPizzaChild *child;
 848     GList *children;
 849
 850     g_return_if_fail (container != NULL);
 851     g_return_if_fail (GTK_IS_PIZZA (container));
 852     g_return_if_fail (callback != NULL);
 853
 854     pizza = GTK_PIZZA (container);
 855
 856     children = pizza->children;
 857     while (children)
 858     {
 859         child = children->data;
 860         children = children->next;
 861
 862         (* callback) (child->widget, callback_data);
 863     }
 864 }
 865
 866
 867 /* Operations on children
 868  */
 869
 870 static void
 871 gtk_pizza_position_child (GtkPizza      *pizza,
 872                           GtkPizzaChild *child)
 873 {
 874     gint x;
 875     gint y;
 876
 877     x = child->x - pizza->xoffset;
 878     y = child->y - pizza->yoffset;
 879
 880     if (IS_ONSCREEN (x,y))
 881     {
 882         if (GTK_WIDGET_MAPPED (pizza) &&
 883           GTK_WIDGET_VISIBLE (child->widget))
 884         {
 885             if (!GTK_WIDGET_MAPPED (child->widget))
 886                 gtk_widget_map (child->widget);
 887         }
 888
 889 #ifndef __WXGTK20__
 890         if (GTK_WIDGET_IS_OFFSCREEN (child->widget))
 891             GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN);
 892 #endif
 893     }
 894     else
 895     {
 896 #ifndef __WXGTK20__
 897         if (!GTK_WIDGET_IS_OFFSCREEN (child->widget))
 898             GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN);
 899 #endif
 900
 901         if (GTK_WIDGET_MAPPED (child->widget))
 902             gtk_widget_unmap (child->widget);
 903     }
 904 }
 905
 906 static void
 907 gtk_pizza_allocate_child (GtkPizza      *pizza,
 908                           GtkPizzaChild *child)
 909 {
 910     GtkAllocation allocation;
 911     GtkRequisition requisition;
 912
 913     allocation.x = child->x - pizza->xoffset;
 914     allocation.y = child->y - pizza->yoffset;
 915     gtk_widget_get_child_requisition (child->widget, &requisition);
 916     allocation.width = requisition.width;
 917     allocation.height = requisition.height;
 918
 919     gtk_widget_size_allocate (child->widget, &allocation);
 920 }
 921
 922 static void
 923 gtk_pizza_position_children (GtkPizza *pizza)
 924 {
 925     GList *tmp_list;
 926
 927     tmp_list = pizza->children;
 928     while (tmp_list)
 929     {
 930         GtkPizzaChild *child = tmp_list->data;
 931         tmp_list = tmp_list->next;
 932
 933         gtk_pizza_position_child (pizza, child);
 934     }
 935 }
 936
 937 static void
 938 gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
 939                                        gpointer   cb_data)
 940 {
 941     GtkPizzaAdjData *data = cb_data;
 942
 943     widget->allocation.x += data->dx;
 944     widget->allocation.y += data->dy;
 945
 946     if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
 947     {
 948         gtk_container_forall (GTK_CONTAINER (widget),
 949                           gtk_pizza_adjust_allocations_recurse,
 950                           cb_data);
 951     }
 952 }
 953
 954 static void
 955 gtk_pizza_adjust_allocations (GtkPizza *pizza,
 956                                gint       dx,
 957                                gint       dy)
 958 {
 959     GList *tmp_list;
 960     GtkPizzaAdjData data;
 961
 962     data.dx = dx;
 963     data.dy = dy;
 964
 965     tmp_list = pizza->children;
 966     while (tmp_list)
 967     {
 968         GtkPizzaChild *child = tmp_list->data;
 969         tmp_list = tmp_list->next;
 970
 971         child->widget->allocation.x += dx;
 972         child->widget->allocation.y += dy;
 973
 974         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 975             GTK_IS_CONTAINER (child->widget))
 976         {
 977             gtk_container_forall (GTK_CONTAINER (child->widget),
 978                                   gtk_pizza_adjust_allocations_recurse,
 979                                   &data);
 980         }
 981     }
 982 }
 983
 984 /* Callbacks */
 985
 986 /* unused */
 987 #if 0
 988 /* Send a synthetic expose event to the widget
 989  */
 990 static void
 991 gtk_pizza_expose_area (GtkPizza    *pizza,
 992                         gint x, gint y, gint width, gint height)
 993 {
 994     if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
 995     {
 996         GdkEventExpose event;
 997
 998         event.type = GDK_EXPOSE;
 999         event.send_event = TRUE;
1000         event.window = pizza->bin_window;
1001         event.count = 0;
1002
1003         event.area.x = x;
1004         event.area.y = y;
1005         event.area.width = width;
1006         event.area.height = height;
1007
1008         gdk_window_ref (event.window);
1009         gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
1010         gdk_window_unref (event.window);
1011     }
1012 }
1013 #endif /* unused */
1014
1015 /* This function is used to find events to process while scrolling
1016  */
1017
1018 static Bool
1019 gtk_pizza_expose_predicate (Display *display,
1020                   XEvent  *xevent,
1021                   XPointer arg)
1022 {
1023     if ((xevent->type == Expose) ||
1024        ((xevent->xany.window == *(Window *)arg) &&
1025        (xevent->type == ConfigureNotify)))
1026         return True;
1027     else
1028         return False;
1029 }
1030
1031 /* This is the main routine to do the scrolling. Scrolling is
1032  * done by "Guffaw" scrolling, as in the Mozilla XFE, with
1033  * a few modifications.
1034  *
1035  * The main improvement is that we keep track of whether we
1036  * are obscured or not. If not, we ignore the generated expose
1037  * events and instead do the exposes ourself, without having
1038  * to wait for a roundtrip to the server. This also provides
1039  * a limited form of expose-event compression, since we do
1040  * the affected area as one big chunk.
1041  */
1042
1043 void
1044 gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
1045 {
1046     GtkWidget *widget;
1047     XEvent xevent;
1048
1049     gint x,y,w,h,border;
1050
1051     widget = GTK_WIDGET (pizza);
1052
1053     pizza->xoffset += dx;
1054     pizza->yoffset += dy;
1055
1056     if (!GTK_WIDGET_MAPPED (pizza))
1057     {
1058         gtk_pizza_position_children (pizza);
1059         return;
1060     }
1061
1062     gtk_pizza_adjust_allocations (pizza, -dx, -dy);
1063
1064     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
1065         border = 0;
1066     else
1067     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
1068         border = 1;
1069     else
1070         border = 2;
1071
1072     x = 0;
1073     y = 0;
1074     w = widget->allocation.width - 2*border;
1075     h = widget->allocation.height - 2*border;
1076
1077     if (dx > 0)
1078     {
1079         if (gravity_works)
1080         {
1081           gdk_window_resize (pizza->bin_window,
1082                              w + dx,
1083                              h);
1084           gdk_window_move   (pizza->bin_window, x-dx, y);
1085           gdk_window_move_resize (pizza->bin_window, x, y, w, h );
1086         }
1087         else
1088         {
1089           /* FIXME */
1090         }
1091     }
1092     else if (dx < 0)
1093     {
1094         if (gravity_works)
1095         {
1096           gdk_window_move_resize (pizza->bin_window,
1097                                   x + dx,
1098                                   y,
1099                                   w - dx,
1100                                   h);
1101           gdk_window_move   (pizza->bin_window, x, y);
1102           gdk_window_resize (pizza->bin_window, w, h );
1103         }
1104         else
1105         {
1106           /* FIXME */
1107         }
1108     }
1109
1110     if (dy > 0)
1111     {
1112         if (gravity_works)
1113         {
1114           gdk_window_resize (pizza->bin_window, w, h + dy);
1115           gdk_window_move   (pizza->bin_window, x, y-dy);
1116           gdk_window_move_resize (pizza->bin_window,
1117                                   x, y, w, h );
1118         }
1119         else
1120         {
1121           /* FIXME */
1122         }
1123     }
1124     else if (dy < 0)
1125     {
1126         if (gravity_works)
1127         {
1128           gdk_window_move_resize (pizza->bin_window,
1129                                   x, y+dy, w, h - dy );
1130           gdk_window_move   (pizza->bin_window, x, y);
1131           gdk_window_resize (pizza->bin_window, w, h );
1132         }
1133         else
1134         {
1135           /* FIXME */
1136         }
1137     }
1138
1139     gtk_pizza_position_children (pizza);
1140
1141     gdk_flush();
1142     while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
1143                          &xevent,
1144                          gtk_pizza_expose_predicate,
1145                          (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
1146     {
1147         GdkEvent event;
1148         GtkWidget *event_widget;
1149
1150         if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) )
1151             gtk_pizza_filter (&xevent, &event, pizza);
1152
1153         if (xevent.type == Expose)
1154         {
1155             event.expose.window = gdk_window_lookup (xevent.xany.window);
1156             gdk_window_get_user_data (event.expose.window,
1157                                     (gpointer *)&event_widget);
1158
1159             if (event_widget)
1160             {
1161                 event.expose.type = GDK_EXPOSE;
1162                 event.expose.area.x = xevent.xexpose.x;
1163                 event.expose.area.y = xevent.xexpose.y;
1164                 event.expose.area.width = xevent.xexpose.width;
1165                 event.expose.area.height = xevent.xexpose.height;
1166                 event.expose.count = xevent.xexpose.count;
1167
1168                 gdk_window_ref (event.expose.window);
1169                 gtk_widget_event (event_widget, &event);
1170                 gdk_window_unref (event.expose.window);
1171             }
1172         }
1173     }
1174 }
1175
1176 /* The main event filter. Actually, we probably don't really need
1177  * to install this as a filter at all, since we are calling it
1178  * directly above in the expose-handling hack. But in case scrollbars
1179  * are fixed up in some manner...
1180  *
1181  * This routine identifies expose events that are generated when
1182  * we've temporarily moved the bin_window_origin, and translates
1183  * them or discards them, depending on whether we are obscured
1184  * or not.
1185  */
1186 static GdkFilterReturn
1187 gtk_pizza_filter (GdkXEvent *gdk_xevent,
1188                    GdkEvent  *event,
1189                    gpointer   data)
1190 {
1191     XEvent *xevent;
1192     GtkPizza *pizza;
1193
1194     xevent = (XEvent *)gdk_xevent;
1195
1196     pizza = GTK_PIZZA (data);
1197
1198     if (!pizza->use_filter)
1199         return GDK_FILTER_CONTINUE;
1200
1201     switch (xevent->type)
1202     {
1203         case Expose:
1204             if (xevent->xexpose.serial == pizza->configure_serial)
1205             {
1206                 xevent->xexpose.x += pizza->scroll_x;
1207                 xevent->xexpose.y += pizza->scroll_y;
1208             }
1209             break;
1210
1211         case ConfigureNotify:
1212             {
1213                 pizza->configure_serial = xevent->xconfigure.serial;
1214                 pizza->scroll_x = xevent->xconfigure.x;
1215                 pizza->scroll_y = xevent->xconfigure.y;
1216             }
1217             break;
1218     }
1219
1220     return GDK_FILTER_CONTINUE;
1221 }
1222
1223 /* Although GDK does have a GDK_VISIBILITY_NOTIFY event,
1224  * there is no corresponding event in GTK, so we have
1225  * to get the events from a filter
1226  */
1227 static GdkFilterReturn
1228 gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
1229                         GdkEvent  *event,
1230                         gpointer   data)
1231 {
1232     XEvent *xevent;
1233     GtkPizza *pizza;
1234
1235     xevent = (XEvent *)gdk_xevent;
1236     pizza = GTK_PIZZA (data);
1237
1238     if (!pizza->use_filter)
1239         return GDK_FILTER_CONTINUE;
1240
1241     if (xevent->type == VisibilityNotify)
1242     {
1243         switch (xevent->xvisibility.state)
1244         {
1245             case VisibilityFullyObscured:
1246                 pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1247                 break;
1248
1249             case VisibilityPartiallyObscured:
1250                 pizza->visibility = GDK_VISIBILITY_PARTIAL;
1251                 break;
1252
1253             case VisibilityUnobscured:
1254                 pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
1255                 break;
1256         }
1257
1258         return GDK_FILTER_REMOVE;
1259     }
1260
1261     return GDK_FILTER_CONTINUE;
1262 }
1263
1264
1265 #ifdef __cplusplus
1266 }
1267 #endif /* __cplusplus */
1268