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