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 =
 553        GDK_VISIBILITY_NOTIFY_MASK;
 554     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 555
 556     widget->window = gdk_window_new(gtk_widget_get_parent_window (widget),
 557                                      &attributes, attributes_mask);
 558     gdk_window_set_user_data (widget->window, widget);
 559
 560     attributes.x = 0;
 561     attributes.y = 0;
 562
 563     attributes.event_mask = gtk_widget_get_events (widget);
 564     attributes.event_mask |=
 565        GDK_EXPOSURE_MASK        |
 566        GDK_POINTER_MOTION_MASK        |
 567        GDK_POINTER_MOTION_HINT_MASK  |
 568        GDK_BUTTON_MOTION_MASK        |
 569        GDK_BUTTON1_MOTION_MASK        |
 570        GDK_BUTTON2_MOTION_MASK        |
 571        GDK_BUTTON3_MOTION_MASK        |
 572        GDK_BUTTON_PRESS_MASK        |
 573        GDK_BUTTON_RELEASE_MASK        |
 574        GDK_KEY_PRESS_MASK        |
 575        GDK_KEY_RELEASE_MASK        |
 576        GDK_ENTER_NOTIFY_MASK        |
 577        GDK_LEAVE_NOTIFY_MASK        |
 578        GDK_FOCUS_CHANGE_MASK;
 579
 580     pizza->bin_window = gdk_window_new(widget->window,
 581                                           &attributes, attributes_mask);
 582     gdk_window_set_user_data (pizza->bin_window, widget);
 583
 584     widget->style = gtk_style_attach (widget->style, widget->window);
 585     gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 586     gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL );
 587
 588     /* add filters for intercepting visibility and expose events */
 589     gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza);
 590     gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza);
 591
 592     /* we NEED gravity or we'll give up */
 593     gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE);
 594
 595     /* cannot be done before realisation */
 596     children = pizza->children;
 597     while (children)
 598     {
 599         child = children->data;
 600         children = children->next;
 601
 602         gtk_widget_set_parent_window (child->widget, pizza->bin_window);
 603     }
 604 }
 605
 606 static void
 607 gtk_pizza_unrealize (GtkWidget *widget)
 608 {
 609     GtkPizza *pizza;
 610
 611     g_return_if_fail (widget != NULL);
 612     g_return_if_fail (GTK_IS_PIZZA (widget));
 613
 614     pizza = GTK_PIZZA (widget);
 615
 616     gdk_window_set_user_data (pizza->bin_window, NULL);
 617     gdk_window_destroy (pizza->bin_window);
 618     pizza->bin_window = NULL;
 619
 620     if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 621        (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 622 }
 623
 624 static void
 625 gtk_pizza_size_request (GtkWidget      *widget,
 626                         GtkRequisition *requisition)
 627 {
 628     GtkPizza *pizza;
 629     GtkPizzaChild *child;
 630     GList *children;
 631     GtkRequisition child_requisition;
 632
 633     g_return_if_fail (widget != NULL);
 634     g_return_if_fail (GTK_IS_PIZZA (widget));
 635     g_return_if_fail (requisition != NULL);
 636
 637     pizza = GTK_PIZZA (widget);
 638
 639     children = pizza->children;
 640     while (children)
 641     {
 642         child = children->data;
 643         children = children->next;
 644
 645         if (GTK_WIDGET_VISIBLE (child->widget))
 646         {
 647             gtk_widget_size_request (child->widget, &child_requisition);
 648         }
 649     }
 650
 651     /* request very little, I'm not sure if requesting nothing
 652        will always have positive effects on stability... */
 653     requisition->width = 2;
 654     requisition->height = 2;
 655 }
 656
 657 static void
 658 gtk_pizza_size_allocate (GtkWidget     *widget,
 659                          GtkAllocation *allocation)
 660 {
 661     GtkPizza *pizza;
 662     gint border;
 663     gint x,y,w,h;
 664     GtkPizzaChild *child;
 665     GList *children;
 666
 667     g_return_if_fail (widget != NULL);
 668     g_return_if_fail (GTK_IS_PIZZA(widget));
 669     g_return_if_fail (allocation != NULL);
 670
 671     pizza = GTK_PIZZA (widget);
 672
 673     widget->allocation = *allocation;
 674
 675     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
 676         border = 0;
 677     else
 678     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
 679         border = 1;
 680     else
 681         border = 2;
 682
 683     x = allocation->x + border;
 684     y = allocation->y + border;
 685     w = allocation->width - border*2;
 686     h = allocation->height - border*2;
 687
 688     if (GTK_WIDGET_REALIZED (widget))
 689     {
 690         gdk_window_move_resize( widget->window, x, y, w, h );
 691         gdk_window_move_resize( pizza->bin_window, 0, 0, w, h );
 692     }
 693
 694     children = pizza->children;
 695     while (children)
 696     {
 697         child = children->data;
 698         children = children->next;
 699
 700         gtk_pizza_position_child (pizza, child);
 701         gtk_pizza_allocate_child (pizza, child);
 702     }
 703 }
 704
 705 static void
 706 gtk_pizza_draw (GtkWidget    *widget,
 707                 GdkRectangle *area)
 708 {
 709     GtkPizza *pizza;
 710     GtkPizzaChild *child;
 711     GdkRectangle child_area;
 712     GList *children;
 713
 714     g_return_if_fail (widget != NULL);
 715     g_return_if_fail (GTK_IS_PIZZA (widget));
 716
 717     pizza = GTK_PIZZA (widget);
 718
 719     /* Sometimes, We handle all expose events in window.cpp now. */
 720     if (pizza->external_expose)
 721         return;
 722
 723     children = pizza->children;
 724     if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) &&
 725          (pizza->clear_on_draw))
 726     {
 727         gdk_window_clear_area( pizza->bin_window,
 728                                 area->x, area->y, area->width, area->height);
 729     }
 730
 731     while (children)
 732     {
 733         child = children->data;
 734         children = children->next;
 735
 736         if (gtk_widget_intersect (child->widget, area, &child_area))
 737             gtk_widget_draw (child->widget, &child_area);
 738     }
 739 }
 740
 741 static gint
 742 gtk_pizza_expose (GtkWidget      *widget,
 743                   GdkEventExpose *event)
 744 {
 745     GtkPizza *pizza;
 746     GtkPizzaChild *child;
 747     GdkEventExpose child_event;
 748     GList *children;
 749
 750     g_return_val_if_fail (widget != NULL, FALSE);
 751     g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE);
 752     g_return_val_if_fail (event != NULL, FALSE);
 753
 754     pizza = GTK_PIZZA (widget);
 755
 756     /* Sometimes, We handle all expose events in window.cpp now. */
 757     if (pizza->external_expose)
 758         return FALSE;
 759
 760     if (event->window != pizza->bin_window)
 761         return FALSE;
 762
 763     children = pizza->children;
 764     while (children)
 765     {
 766         child = children->data;
 767         children = children->next;
 768
 769         child_event = *event;
 770
 771         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 772             GTK_WIDGET_DRAWABLE (child->widget) &&
 773             gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 774         {
 775             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 776         }
 777     }
 778
 779     return TRUE;
 780 }
 781
 782 static void
 783 gtk_pizza_add (GtkContainer *container,
 784                GtkWidget    *widget)
 785 {
 786     g_return_if_fail (container != NULL);
 787     g_return_if_fail (GTK_IS_PIZZA (container));
 788     g_return_if_fail (widget != NULL);
 789
 790     gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 );
 791 }
 792
 793 static void
 794 gtk_pizza_remove (GtkContainer *container,
 795                   GtkWidget    *widget)
 796 {
 797     GtkPizza *pizza;
 798     GtkPizzaChild *child;
 799     GList *children;
 800
 801     g_return_if_fail (container != NULL);
 802     g_return_if_fail (GTK_IS_PIZZA (container));
 803     g_return_if_fail (widget != NULL);
 804
 805     pizza = GTK_PIZZA (container);
 806
 807     children = pizza->children;
 808     while (children)
 809     {
 810         child = children->data;
 811
 812         if (child->widget == widget)
 813         {
 814             gtk_widget_unparent (widget);
 815
 816             /* security checks */
 817             g_return_if_fail (GTK_IS_WIDGET (widget));
 818
 819             pizza->children = g_list_remove_link (pizza->children, children);
 820             g_list_free (children);
 821             g_free (child);
 822
 823             /* security checks */
 824             g_return_if_fail (GTK_IS_WIDGET (widget));
 825
 826 #ifndef __WXGTK20__
 827             GTK_PRIVATE_UNSET_FLAG (widget, GTK_IS_OFFSCREEN);
 828 #endif
 829
 830             break;
 831         }
 832
 833         children = children->next;
 834     }
 835 }
 836
 837 static void
 838 gtk_pizza_forall (GtkContainer *container,
 839                   gboolean      include_internals,
 840                   GtkCallback   callback,
 841                   gpointer      callback_data)
 842 {
 843     GtkPizza *pizza;
 844     GtkPizzaChild *child;
 845     GList *children;
 846
 847     g_return_if_fail (container != NULL);
 848     g_return_if_fail (GTK_IS_PIZZA (container));
 849     g_return_if_fail (callback != NULL);
 850
 851     pizza = GTK_PIZZA (container);
 852
 853     children = pizza->children;
 854     while (children)
 855     {
 856         child = children->data;
 857         children = children->next;
 858
 859         (* callback) (child->widget, callback_data);
 860     }
 861 }
 862
 863
 864 /* Operations on children
 865  */
 866
 867 static void
 868 gtk_pizza_position_child (GtkPizza      *pizza,
 869                           GtkPizzaChild *child)
 870 {
 871     gint x;
 872     gint y;
 873
 874     x = child->x - pizza->xoffset;
 875     y = child->y - pizza->yoffset;
 876
 877     if (IS_ONSCREEN (x,y))
 878     {
 879         if (GTK_WIDGET_MAPPED (pizza) &&
 880           GTK_WIDGET_VISIBLE (child->widget))
 881         {
 882             if (!GTK_WIDGET_MAPPED (child->widget))
 883                 gtk_widget_map (child->widget);
 884         }
 885
 886 #ifndef __WXGTK20__
 887         if (GTK_WIDGET_IS_OFFSCREEN (child->widget))
 888             GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN);
 889 #endif
 890     }
 891     else
 892     {
 893 #ifndef __WXGTK20__
 894         if (!GTK_WIDGET_IS_OFFSCREEN (child->widget))
 895             GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN);
 896 #endif
 897
 898         if (GTK_WIDGET_MAPPED (child->widget))
 899             gtk_widget_unmap (child->widget);
 900     }
 901 }
 902
 903 static void
 904 gtk_pizza_allocate_child (GtkPizza      *pizza,
 905                           GtkPizzaChild *child)
 906 {
 907     GtkAllocation allocation;
 908     GtkRequisition requisition;
 909
 910     allocation.x = child->x - pizza->xoffset;
 911     allocation.y = child->y - pizza->yoffset;
 912     gtk_widget_get_child_requisition (child->widget, &requisition);
 913     allocation.width = requisition.width;
 914     allocation.height = requisition.height;
 915
 916     gtk_widget_size_allocate (child->widget, &allocation);
 917 }
 918
 919 static void
 920 gtk_pizza_position_children (GtkPizza *pizza)
 921 {
 922     GList *tmp_list;
 923
 924     tmp_list = pizza->children;
 925     while (tmp_list)
 926     {
 927         GtkPizzaChild *child = tmp_list->data;
 928         tmp_list = tmp_list->next;
 929
 930         gtk_pizza_position_child (pizza, child);
 931     }
 932 }
 933
 934 static void
 935 gtk_pizza_adjust_allocations_recurse (GtkWidget *widget,
 936                                        gpointer   cb_data)
 937 {
 938     GtkPizzaAdjData *data = cb_data;
 939
 940     widget->allocation.x += data->dx;
 941     widget->allocation.y += data->dy;
 942
 943     if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget))
 944     {
 945         gtk_container_forall (GTK_CONTAINER (widget),
 946                           gtk_pizza_adjust_allocations_recurse,
 947                           cb_data);
 948     }
 949 }
 950
 951 static void
 952 gtk_pizza_adjust_allocations (GtkPizza *pizza,
 953                                gint       dx,
 954                                gint       dy)
 955 {
 956     GList *tmp_list;
 957     GtkPizzaAdjData data;
 958
 959     data.dx = dx;
 960     data.dy = dy;
 961
 962     tmp_list = pizza->children;
 963     while (tmp_list)
 964     {
 965         GtkPizzaChild *child = tmp_list->data;
 966         tmp_list = tmp_list->next;
 967
 968         child->widget->allocation.x += dx;
 969         child->widget->allocation.y += dy;
 970
 971         if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 972             GTK_IS_CONTAINER (child->widget))
 973         {
 974             gtk_container_forall (GTK_CONTAINER (child->widget),
 975                                   gtk_pizza_adjust_allocations_recurse,
 976                                   &data);
 977         }
 978     }
 979 }
 980
 981 /* Callbacks */
 982
 983 /* unused */
 984 #if 0
 985 /* Send a synthetic expose event to the widget
 986  */
 987 static void
 988 gtk_pizza_expose_area (GtkPizza    *pizza,
 989                         gint x, gint y, gint width, gint height)
 990 {
 991     if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED)
 992     {
 993         GdkEventExpose event;
 994
 995         event.type = GDK_EXPOSE;
 996         event.send_event = TRUE;
 997         event.window = pizza->bin_window;
 998         event.count = 0;
 999
1000         event.area.x = x;
1001         event.area.y = y;
1002         event.area.width = width;
1003         event.area.height = height;
1004
1005         gdk_window_ref (event.window);
1006         gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event);
1007         gdk_window_unref (event.window);
1008     }
1009 }
1010 #endif /* unused */
1011
1012 /* This function is used to find events to process while scrolling
1013  */
1014
1015 static Bool
1016 gtk_pizza_expose_predicate (Display *display,
1017                   XEvent  *xevent,
1018                   XPointer arg)
1019 {
1020     if ((xevent->type == Expose) ||
1021        ((xevent->xany.window == *(Window *)arg) &&
1022        (xevent->type == ConfigureNotify)))
1023         return True;
1024     else
1025         return False;
1026 }
1027
1028 /* This is the main routine to do the scrolling. Scrolling is
1029  * done by "Guffaw" scrolling, as in the Mozilla XFE, with
1030  * a few modifications.
1031  *
1032  * The main improvement is that we keep track of whether we
1033  * are obscured or not. If not, we ignore the generated expose
1034  * events and instead do the exposes ourself, without having
1035  * to wait for a roundtrip to the server. This also provides
1036  * a limited form of expose-event compression, since we do
1037  * the affected area as one big chunk.
1038  */
1039
1040 void
1041 gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy)
1042 {
1043     GtkWidget *widget;
1044     XEvent xevent;
1045
1046     gint x,y,w,h,border;
1047
1048     widget = GTK_WIDGET (pizza);
1049
1050     pizza->xoffset += dx;
1051     pizza->yoffset += dy;
1052
1053     if (!GTK_WIDGET_MAPPED (pizza))
1054     {
1055         gtk_pizza_position_children (pizza);
1056         return;
1057     }
1058
1059     gtk_pizza_adjust_allocations (pizza, -dx, -dy);
1060
1061     if (pizza->shadow_type == GTK_MYSHADOW_NONE)
1062         border = 0;
1063     else
1064     if (pizza->shadow_type == GTK_MYSHADOW_THIN)
1065         border = 1;
1066     else
1067         border = 2;
1068
1069     x = 0;
1070     y = 0;
1071     w = widget->allocation.width - 2*border;
1072     h = widget->allocation.height - 2*border;
1073
1074     if (dx > 0)
1075     {
1076         if (gravity_works)
1077         {
1078           gdk_window_resize (pizza->bin_window,
1079                              w + dx,
1080                              h);
1081           gdk_window_move   (pizza->bin_window, x-dx, y);
1082           gdk_window_move_resize (pizza->bin_window, x, y, w, h );
1083         }
1084         else
1085         {
1086           /* FIXME */
1087         }
1088     }
1089     else if (dx < 0)
1090     {
1091         if (gravity_works)
1092         {
1093           gdk_window_move_resize (pizza->bin_window,
1094                                   x + dx,
1095                                   y,
1096                                   w - dx,
1097                                   h);
1098           gdk_window_move   (pizza->bin_window, x, y);
1099           gdk_window_resize (pizza->bin_window, w, h );
1100         }
1101         else
1102         {
1103           /* FIXME */
1104         }
1105     }
1106
1107     if (dy > 0)
1108     {
1109         if (gravity_works)
1110         {
1111           gdk_window_resize (pizza->bin_window, w, h + dy);
1112           gdk_window_move   (pizza->bin_window, x, y-dy);
1113           gdk_window_move_resize (pizza->bin_window,
1114                                   x, y, w, h );
1115         }
1116         else
1117         {
1118           /* FIXME */
1119         }
1120     }
1121     else if (dy < 0)
1122     {
1123         if (gravity_works)
1124         {
1125           gdk_window_move_resize (pizza->bin_window,
1126                                   x, y+dy, w, h - dy );
1127           gdk_window_move   (pizza->bin_window, x, y);
1128           gdk_window_resize (pizza->bin_window, w, h );
1129         }
1130         else
1131         {
1132           /* FIXME */
1133         }
1134     }
1135
1136     gtk_pizza_position_children (pizza);
1137
1138     gdk_flush();
1139     while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window),
1140                          &xevent,
1141                          gtk_pizza_expose_predicate,
1142                          (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window)))
1143     {
1144         GdkEvent event;
1145         GtkWidget *event_widget;
1146
1147         if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) )
1148             gtk_pizza_filter (&xevent, &event, pizza);
1149
1150         if (xevent.type == Expose)
1151         {
1152             event.expose.window = gdk_window_lookup (xevent.xany.window);
1153             gdk_window_get_user_data (event.expose.window,
1154                                     (gpointer *)&event_widget);
1155
1156             if (event_widget)
1157             {
1158                 event.expose.type = GDK_EXPOSE;
1159                 event.expose.area.x = xevent.xexpose.x;
1160                 event.expose.area.y = xevent.xexpose.y;
1161                 event.expose.area.width = xevent.xexpose.width;
1162                 event.expose.area.height = xevent.xexpose.height;
1163                 event.expose.count = xevent.xexpose.count;
1164
1165                 gdk_window_ref (event.expose.window);
1166                 gtk_widget_event (event_widget, &event);
1167                 gdk_window_unref (event.expose.window);
1168             }
1169         }
1170     }
1171 }
1172
1173 /* The main event filter. Actually, we probably don't really need
1174  * to install this as a filter at all, since we are calling it
1175  * directly above in the expose-handling hack. But in case scrollbars
1176  * are fixed up in some manner...
1177  *
1178  * This routine identifies expose events that are generated when
1179  * we've temporarily moved the bin_window_origin, and translates
1180  * them or discards them, depending on whether we are obscured
1181  * or not.
1182  */
1183 static GdkFilterReturn
1184 gtk_pizza_filter (GdkXEvent *gdk_xevent,
1185                    GdkEvent  *event,
1186                    gpointer   data)
1187 {
1188     XEvent *xevent;
1189     GtkPizza *pizza;
1190
1191     xevent = (XEvent *)gdk_xevent;
1192
1193     pizza = GTK_PIZZA (data);
1194
1195     if (!pizza->use_filter)
1196         return GDK_FILTER_CONTINUE;
1197
1198     switch (xevent->type)
1199     {
1200     case Expose:
1201       if (xevent->xexpose.serial == pizza->configure_serial)
1202         {
1203           xevent->xexpose.x += pizza->scroll_x;
1204           xevent->xexpose.y += pizza->scroll_y;
1205         }
1206       break;
1207
1208     case ConfigureNotify:
1209         {
1210           pizza->configure_serial = xevent->xconfigure.serial;
1211           pizza->scroll_x = xevent->xconfigure.x;
1212           pizza->scroll_y = xevent->xconfigure.y;
1213         }
1214       break;
1215     }
1216
1217     return GDK_FILTER_CONTINUE;
1218 }
1219
1220 /* Although GDK does have a GDK_VISIBILITY_NOTIFY event,
1221  * there is no corresponding event in GTK, so we have
1222  * to get the events from a filter
1223  */
1224 static GdkFilterReturn
1225 gtk_pizza_main_filter (GdkXEvent *gdk_xevent,
1226                         GdkEvent  *event,
1227                         gpointer   data)
1228 {
1229     XEvent *xevent;
1230     GtkPizza *pizza;
1231
1232     xevent = (XEvent *)gdk_xevent;
1233     pizza = GTK_PIZZA (data);
1234
1235     if (!pizza->use_filter)
1236         return GDK_FILTER_CONTINUE;
1237
1238     if (xevent->type == VisibilityNotify)
1239     {
1240         switch (xevent->xvisibility.state)
1241         {
1242             case VisibilityFullyObscured:
1243                 pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
1244                 break;
1245
1246             case VisibilityPartiallyObscured:
1247                 pizza->visibility = GDK_VISIBILITY_PARTIAL;
1248                 break;
1249
1250             case VisibilityUnobscured:
1251                 pizza->visibility = GDK_VISIBILITY_UNOBSCURED;
1252                 break;
1253         }
1254
1255         return GDK_FILTER_REMOVE;
1256     }
1257
1258     return GDK_FILTER_CONTINUE;
1259 }
1260
1261
1262 #ifdef __cplusplus
1263 }
1264 #endif /* __cplusplus */
1265