Pileus Git - ~andy/gtk/blob - gtk/gtkwidget.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <stdarg.h>
  19 #include <string.h>
  20 #include "gtkcontainer.h"
  21 #include "gtkmain.h"
  22 #include "gtkrc.h"
  23 #include "gtkselection.h"
  24 #include "gtksignal.h"
  25 #include "gtkwidget.h"
  26 #include "gtkwindow.h"
  27 #include "gtkprivate.h"
  28 #include "gdk/gdk.h"
  29 #include "gdk/gdkx.h"
  30
  31
  32 #define WIDGET_CLASS(w)  GTK_WIDGET_CLASS (GTK_OBJECT (w)->klass)
  33
  34
  35 enum {
  36   SHOW,
  37   HIDE,
  38   MAP,
  39   UNMAP,
  40   REALIZE,
  41   UNREALIZE,
  42   DRAW,
  43   DRAW_FOCUS,
  44   DRAW_DEFAULT,
  45   SIZE_REQUEST,
  46   SIZE_ALLOCATE,
  47   STATE_CHANGED,
  48   INSTALL_ACCELERATOR,
  49   REMOVE_ACCELERATOR,
  50   EVENT,
  51   BUTTON_PRESS_EVENT,
  52   BUTTON_RELEASE_EVENT,
  53   MOTION_NOTIFY_EVENT,
  54   DELETE_EVENT,
  55   DESTROY_EVENT,
  56   EXPOSE_EVENT,
  57   KEY_PRESS_EVENT,
  58   KEY_RELEASE_EVENT,
  59   ENTER_NOTIFY_EVENT,
  60   LEAVE_NOTIFY_EVENT,
  61   CONFIGURE_EVENT,
  62   FOCUS_IN_EVENT,
  63   FOCUS_OUT_EVENT,
  64   MAP_EVENT,
  65   UNMAP_EVENT,
  66   PROPERTY_NOTIFY_EVENT,
  67   SELECTION_CLEAR_EVENT,
  68   SELECTION_REQUEST_EVENT,
  69   SELECTION_NOTIFY_EVENT,
  70   SELECTION_RECEIVED,
  71   PROXIMITY_IN_EVENT,
  72   PROXIMITY_OUT_EVENT,
  73   DRAG_BEGIN_EVENT,
  74   DRAG_REQUEST_EVENT,
  75   DROP_ENTER_EVENT,
  76   DROP_LEAVE_EVENT,
  77   DROP_DATA_AVAILABLE_EVENT,
  78   OTHER_EVENT,
  79   CLIENT_EVENT,
  80   NO_EXPOSE_EVENT,
  81   LAST_SIGNAL
  82 };
  83
  84 enum {
  85   ARG_0,
  86   ARG_X,
  87   ARG_Y,
  88   ARG_WIDTH,
  89   ARG_HEIGHT,
  90   ARG_VISIBLE,
  91   ARG_SENSITIVE,
  92   ARG_CAN_FOCUS,
  93   ARG_HAS_FOCUS,
  94   ARG_CAN_DEFAULT,
  95   ARG_HAS_DEFAULT,
  96   ARG_EVENTS,
  97   ARG_EXTENSION_EVENTS,
  98   ARG_NAME,
  99   ARG_STYLE,
 100   ARG_PARENT
 101 };
 102
 103
 104 typedef void (*GtkWidgetSignal1) (GtkObject *object,
 105                                   gpointer   arg1,
 106                                   gpointer   data);
 107 typedef gint (*GtkWidgetSignal2) (GtkObject *object,
 108                                   gpointer   arg1,
 109                                   gchar      arg2,
 110                                   gchar      arg3,
 111                                   gpointer   data);
 112 typedef void (*GtkWidgetSignal3) (GtkObject *object,
 113                                   gpointer   arg1,
 114                                   gpointer   data);
 115 typedef gint (*GtkWidgetSignal4) (GtkObject *object,
 116                                   gpointer   arg1,
 117                                   gpointer   data);
 118 typedef void (*GtkWidgetSignal5) (GtkObject *object,
 119                                   guint      arg1,
 120                                   gpointer   data);
 121
 122 typedef struct  _GtkStateData    GtkStateData;
 123
 124 struct _GtkStateData
 125 {
 126   GtkStateType  state;
 127   gint          parent_sensitive;
 128 };
 129
 130
 131 static void gtk_widget_marshal_signal_1 (GtkObject      *object,
 132                                          GtkSignalFunc   func,
 133                                          gpointer        func_data,
 134                                          GtkArg         *args);
 135 static void gtk_widget_marshal_signal_2 (GtkObject      *object,
 136                                          GtkSignalFunc   func,
 137                                          gpointer        func_data,
 138                                          GtkArg         *args);
 139 static void gtk_widget_marshal_signal_3 (GtkObject      *object,
 140                                          GtkSignalFunc   func,
 141                                          gpointer        func_data,
 142                                          GtkArg         *args);
 143 static void gtk_widget_marshal_signal_4 (GtkObject      *object,
 144                                          GtkSignalFunc   func,
 145                                          gpointer        func_data,
 146                                          GtkArg         *args);
 147 static void gtk_widget_marshal_signal_5 (GtkObject      *object,
 148                                          GtkSignalFunc   func,
 149                                          gpointer        func_data,
 150                                          GtkArg         *args);
 151
 152 static void gtk_widget_class_init                (GtkWidgetClass    *klass);
 153 static void gtk_widget_init                      (GtkWidget         *widget);
 154 static void gtk_widget_set_arg                   (GtkWidget         *widget,
 155                                                   GtkArg            *arg,
 156                                                   guint              arg_id);
 157 static void gtk_widget_get_arg                   (GtkWidget         *widget,
 158                                                   GtkArg            *arg,
 159                                                   guint              arg_id);
 160 static void gtk_widget_real_destroy              (GtkObject         *object);
 161 static void gtk_widget_real_finalize             (GtkObject         *object);
 162 static void gtk_widget_real_show                 (GtkWidget         *widget);
 163 static void gtk_widget_real_hide                 (GtkWidget         *widget);
 164 static void gtk_widget_real_map                  (GtkWidget         *widget);
 165 static void gtk_widget_real_unmap                (GtkWidget         *widget);
 166 static void gtk_widget_real_realize              (GtkWidget         *widget);
 167 static void gtk_widget_real_unrealize            (GtkWidget         *widget);
 168 static void gtk_widget_real_draw                 (GtkWidget         *widget,
 169                                                   GdkRectangle      *area);
 170 static gint gtk_widget_real_queue_draw           (GtkWidget         *widget);
 171 static gint gtk_widget_real_queue_resize         (GtkWidget         *widget);
 172 static void gtk_widget_real_size_allocate        (GtkWidget         *widget,
 173                                                   GtkAllocation     *allocation);
 174
 175 static GdkColormap* gtk_widget_peek_colormap (void);
 176 static GdkVisual*   gtk_widget_peek_visual   (void);
 177 static GtkStyle*    gtk_widget_peek_style    (void);
 178
 179 static void gtk_widget_reparent_container_child  (GtkWidget     *widget,
 180                                                   gpointer       client_data);
 181 static void gtk_widget_propagate_state           (GtkWidget     *widget,
 182                                                   GtkStateData  *data);
 183 static void gtk_widget_draw_children_recurse     (GtkWidget     *widget,
 184                                                   gpointer       client_data);
 185 static void gtk_widget_set_style_internal        (GtkWidget     *widget,
 186                                                   GtkStyle      *style);
 187 static void gtk_widget_set_style_recurse         (GtkWidget     *widget,
 188                                                   gpointer       client_data);
 189
 190 extern GtkArg* gtk_object_collect_args (guint   *nargs,
 191                                         va_list  args1,
 192                                         va_list  args2);
 193
 194 static GtkWidgetAuxInfo* gtk_widget_aux_info_new     (void);
 195 static void              gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
 196
 197 static GtkObjectClass *parent_class = NULL;
 198 static gint widget_signals[LAST_SIGNAL] = { 0 };
 199
 200 static GMemChunk *aux_info_mem_chunk = NULL;
 201
 202 static GdkColormap *default_colormap = NULL;
 203 static GdkVisual *default_visual = NULL;
 204 static GtkStyle *default_style = NULL;
 205
 206 static GSList *colormap_stack = NULL;
 207 static GSList *visual_stack = NULL;
 208 static GSList *style_stack = NULL;
 209
 210 static GSList *gtk_widget_redraw_queue = NULL;
 211 static GSList *gtk_widget_resize_queue = NULL;
 212
 213 static const gchar *aux_info_key = "gtk-aux-info";
 214 static const gchar *colormap_key = "gtk-colormap";
 215 static const gchar *visual_key = "gtk-visual";
 216 static const gchar *event_key = "gtk-event-mask";
 217 static const gchar *extension_event_key = "gtk-extension-event-mode";
 218 static const gchar *parent_window_key = "gtk-parent-window";
 219 static const gchar *shape_info_key = "gtk-shape-info";
 220
 221
 222
 223 /*****************************************
 224  * gtk_widget_get_type:
 225  *
 226  *   arguments:
 227  *
 228  *   results:
 229  *****************************************/
 230
 231 guint
 232 gtk_widget_get_type ()
 233 {
 234   static guint widget_type = 0;
 235
 236   if (!widget_type)
 237     {
 238       GtkTypeInfo widget_info =
 239       {
 240         "GtkWidget",
 241         sizeof (GtkWidget),
 242         sizeof (GtkWidgetClass),
 243         (GtkClassInitFunc) gtk_widget_class_init,
 244         (GtkObjectInitFunc) gtk_widget_init,
 245         (GtkArgSetFunc) gtk_widget_set_arg,
 246         (GtkArgGetFunc) gtk_widget_get_arg,
 247       };
 248
 249       widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
 250     }
 251
 252   return widget_type;
 253 }
 254
 255 /*****************************************
 256  * gtk_widget_class_init:
 257  *
 258  *   arguments:
 259  *
 260  *   results:
 261  *****************************************/
 262
 263 static void
 264 gtk_widget_class_init (GtkWidgetClass *klass)
 265 {
 266   GtkObjectClass *object_class;
 267
 268   object_class = (GtkObjectClass*) klass;
 269
 270   parent_class = gtk_type_class (gtk_object_get_type ());
 271
 272   gtk_object_add_arg_type ("GtkWidget::x", GTK_TYPE_INT, ARG_X);
 273   gtk_object_add_arg_type ("GtkWidget::y", GTK_TYPE_INT, ARG_Y);
 274   gtk_object_add_arg_type ("GtkWidget::width", GTK_TYPE_INT, ARG_WIDTH);
 275   gtk_object_add_arg_type ("GtkWidget::height", GTK_TYPE_INT, ARG_HEIGHT);
 276   gtk_object_add_arg_type ("GtkWidget::visible", GTK_TYPE_BOOL, ARG_VISIBLE);
 277   gtk_object_add_arg_type ("GtkWidget::sensitive", GTK_TYPE_BOOL, ARG_SENSITIVE);
 278   gtk_object_add_arg_type ("GtkWidget::can_focus", GTK_TYPE_BOOL, ARG_CAN_FOCUS);
 279   gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, ARG_HAS_FOCUS);
 280   gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, ARG_CAN_DEFAULT);
 281   gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, ARG_HAS_DEFAULT);
 282   gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, ARG_EVENTS);
 283   gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, ARG_EXTENSION_EVENTS);
 284   gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, ARG_NAME);
 285   gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, ARG_STYLE);
 286   gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, ARG_PARENT);
 287
 288   widget_signals[SHOW] =
 289     gtk_signal_new ("show",
 290                     GTK_RUN_FIRST,
 291                     object_class->type,
 292                     GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
 293                     gtk_signal_default_marshaller,
 294                     GTK_TYPE_NONE, 0);
 295   widget_signals[HIDE] =
 296     gtk_signal_new ("hide",
 297                     GTK_RUN_FIRST,
 298                     object_class->type,
 299                     GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
 300                     gtk_signal_default_marshaller,
 301                     GTK_TYPE_NONE, 0);
 302   widget_signals[MAP] =
 303     gtk_signal_new ("map",
 304                     GTK_RUN_FIRST,
 305                     object_class->type,
 306                     GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
 307                     gtk_signal_default_marshaller,
 308                     GTK_TYPE_NONE, 0);
 309   widget_signals[UNMAP] =
 310     gtk_signal_new ("unmap",
 311                     GTK_RUN_FIRST,
 312                     object_class->type,
 313                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
 314                     gtk_signal_default_marshaller,
 315                     GTK_TYPE_NONE, 0);
 316   widget_signals[REALIZE] =
 317     gtk_signal_new ("realize",
 318                     GTK_RUN_FIRST,
 319                     object_class->type,
 320                     GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
 321                     gtk_signal_default_marshaller,
 322                     GTK_TYPE_NONE, 0);
 323   widget_signals[UNREALIZE] =
 324     gtk_signal_new ("unrealize",
 325                     GTK_RUN_FIRST,
 326                     object_class->type,
 327                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
 328                     gtk_signal_default_marshaller,
 329                     GTK_TYPE_NONE, 0);
 330   widget_signals[DRAW] =
 331     gtk_signal_new ("draw",
 332                     GTK_RUN_FIRST,
 333                     object_class->type,
 334                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
 335                     gtk_widget_marshal_signal_1,
 336                     GTK_TYPE_NONE, 1,
 337                     GTK_TYPE_POINTER);
 338   widget_signals[DRAW_FOCUS] =
 339     gtk_signal_new ("draw_focus",
 340                     GTK_RUN_FIRST,
 341                     object_class->type,
 342                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus),
 343                     gtk_signal_default_marshaller,
 344                     GTK_TYPE_NONE, 0);
 345   widget_signals[DRAW_DEFAULT] =
 346     gtk_signal_new ("draw_default",
 347                     GTK_RUN_FIRST,
 348                     object_class->type,
 349                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default),
 350                     gtk_signal_default_marshaller,
 351                     GTK_TYPE_NONE, 0);
 352   widget_signals[SIZE_REQUEST] =
 353     gtk_signal_new ("size_request",
 354                     GTK_RUN_FIRST,
 355                     object_class->type,
 356                     GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request),
 357                     gtk_widget_marshal_signal_1,
 358                     GTK_TYPE_NONE, 1,
 359                     GTK_TYPE_POINTER);
 360   widget_signals[SIZE_ALLOCATE] =
 361     gtk_signal_new ("size_allocate",
 362                     GTK_RUN_FIRST,
 363                     object_class->type,
 364                     GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
 365                     gtk_widget_marshal_signal_1,
 366                     GTK_TYPE_NONE, 1,
 367                     GTK_TYPE_POINTER);
 368   widget_signals[STATE_CHANGED] =
 369     gtk_signal_new ("state_changed",
 370                     GTK_RUN_FIRST,
 371                     object_class->type,
 372                     GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
 373                     gtk_widget_marshal_signal_5,
 374                     GTK_TYPE_NONE, 1,
 375                     GTK_TYPE_UINT);
 376   widget_signals[INSTALL_ACCELERATOR] =
 377     gtk_signal_new ("install_accelerator",
 378                     GTK_RUN_FIRST,
 379                     object_class->type,
 380                     GTK_SIGNAL_OFFSET (GtkWidgetClass, install_accelerator),
 381                     gtk_widget_marshal_signal_2,
 382                     GTK_TYPE_BOOL, 3,
 383                     GTK_TYPE_STRING,
 384                     GTK_TYPE_CHAR,
 385                     GTK_TYPE_INT);
 386   widget_signals[REMOVE_ACCELERATOR] =
 387     gtk_signal_new ("remove_accelerator",
 388                     GTK_RUN_FIRST,
 389                     object_class->type,
 390                     GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator),
 391                     gtk_widget_marshal_signal_3,
 392                     GTK_TYPE_NONE, 1,
 393                     GTK_TYPE_STRING);
 394   widget_signals[EVENT] =
 395     gtk_signal_new ("event",
 396                     GTK_RUN_LAST,
 397                     object_class->type,
 398                     GTK_SIGNAL_OFFSET (GtkWidgetClass, event),
 399                     gtk_widget_marshal_signal_4,
 400                     GTK_TYPE_BOOL, 1,
 401                     GTK_TYPE_GDK_EVENT);
 402   widget_signals[BUTTON_PRESS_EVENT] =
 403     gtk_signal_new ("button_press_event",
 404                     GTK_RUN_LAST,
 405                     object_class->type,
 406                     GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event),
 407                     gtk_widget_marshal_signal_4,
 408                     GTK_TYPE_BOOL, 1,
 409                     GTK_TYPE_GDK_EVENT);
 410   widget_signals[BUTTON_RELEASE_EVENT] =
 411     gtk_signal_new ("button_release_event",
 412                     GTK_RUN_LAST,
 413                     object_class->type,
 414                     GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event),
 415                     gtk_widget_marshal_signal_4,
 416                     GTK_TYPE_BOOL, 1,
 417                     GTK_TYPE_GDK_EVENT);
 418   widget_signals[MOTION_NOTIFY_EVENT] =
 419     gtk_signal_new ("motion_notify_event",
 420                     GTK_RUN_LAST,
 421                     object_class->type,
 422                     GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event),
 423                     gtk_widget_marshal_signal_4,
 424                     GTK_TYPE_BOOL, 1,
 425                     GTK_TYPE_GDK_EVENT);
 426   widget_signals[DELETE_EVENT] =
 427     gtk_signal_new ("delete_event",
 428                     GTK_RUN_LAST,
 429                     object_class->type,
 430                     GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event),
 431                     gtk_widget_marshal_signal_4,
 432                     GTK_TYPE_BOOL, 1,
 433                     GTK_TYPE_GDK_EVENT);
 434   widget_signals[DESTROY_EVENT] =
 435     gtk_signal_new ("destroy_event",
 436                     GTK_RUN_LAST,
 437                     object_class->type,
 438                     GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event),
 439                     gtk_widget_marshal_signal_4,
 440                     GTK_TYPE_BOOL, 1,
 441                     GTK_TYPE_GDK_EVENT);
 442   widget_signals[EXPOSE_EVENT] =
 443     gtk_signal_new ("expose_event",
 444                     GTK_RUN_LAST,
 445                     object_class->type,
 446                     GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event),
 447                     gtk_widget_marshal_signal_4,
 448                     GTK_TYPE_BOOL, 1,
 449                     GTK_TYPE_GDK_EVENT);
 450   widget_signals[KEY_PRESS_EVENT] =
 451     gtk_signal_new ("key_press_event",
 452                     GTK_RUN_LAST,
 453                     object_class->type,
 454                     GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event),
 455                     gtk_widget_marshal_signal_4,
 456                     GTK_TYPE_BOOL, 1,
 457                     GTK_TYPE_GDK_EVENT);
 458   widget_signals[KEY_RELEASE_EVENT] =
 459     gtk_signal_new ("key_release_event",
 460                     GTK_RUN_LAST,
 461                     object_class->type,
 462                     GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event),
 463                     gtk_widget_marshal_signal_4,
 464                     GTK_TYPE_BOOL, 1,
 465                     GTK_TYPE_GDK_EVENT);
 466   widget_signals[ENTER_NOTIFY_EVENT] =
 467     gtk_signal_new ("enter_notify_event",
 468                     GTK_RUN_LAST,
 469                     object_class->type,
 470                     GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event),
 471                     gtk_widget_marshal_signal_4,
 472                     GTK_TYPE_BOOL, 1,
 473                     GTK_TYPE_GDK_EVENT);
 474   widget_signals[LEAVE_NOTIFY_EVENT] =
 475     gtk_signal_new ("leave_notify_event",
 476                     GTK_RUN_LAST,
 477                     object_class->type,
 478                     GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event),
 479                     gtk_widget_marshal_signal_4,
 480                     GTK_TYPE_BOOL, 1,
 481                     GTK_TYPE_GDK_EVENT);
 482   widget_signals[CONFIGURE_EVENT] =
 483     gtk_signal_new ("configure_event",
 484                     GTK_RUN_LAST,
 485                     object_class->type,
 486                     GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event),
 487                     gtk_widget_marshal_signal_4,
 488                     GTK_TYPE_BOOL, 1,
 489                     GTK_TYPE_GDK_EVENT);
 490   widget_signals[FOCUS_IN_EVENT] =
 491     gtk_signal_new ("focus_in_event",
 492                     GTK_RUN_LAST,
 493                     object_class->type,
 494                     GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event),
 495                     gtk_widget_marshal_signal_4,
 496                     GTK_TYPE_BOOL, 1,
 497                     GTK_TYPE_GDK_EVENT);
 498   widget_signals[FOCUS_OUT_EVENT] =
 499     gtk_signal_new ("focus_out_event",
 500                     GTK_RUN_LAST,
 501                     object_class->type,
 502                     GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event),
 503                     gtk_widget_marshal_signal_4,
 504                     GTK_TYPE_BOOL, 1,
 505                     GTK_TYPE_GDK_EVENT);
 506   widget_signals[MAP_EVENT] =
 507     gtk_signal_new ("map_event",
 508                     GTK_RUN_LAST,
 509                     object_class->type,
 510                     GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event),
 511                     gtk_widget_marshal_signal_4,
 512                     GTK_TYPE_BOOL, 1,
 513                     GTK_TYPE_GDK_EVENT);
 514   widget_signals[UNMAP_EVENT] =
 515     gtk_signal_new ("unmap_event",
 516                     GTK_RUN_LAST,
 517                     object_class->type,
 518                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event),
 519                     gtk_widget_marshal_signal_4,
 520                     GTK_TYPE_BOOL, 1,
 521                     GTK_TYPE_GDK_EVENT);
 522   widget_signals[PROPERTY_NOTIFY_EVENT] =
 523     gtk_signal_new ("property_notify_event",
 524                     GTK_RUN_LAST,
 525                     object_class->type,
 526                     GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event),
 527                     gtk_widget_marshal_signal_4,
 528                     GTK_TYPE_BOOL, 1,
 529                     GTK_TYPE_GDK_EVENT);
 530   widget_signals[SELECTION_CLEAR_EVENT] =
 531     gtk_signal_new ("selection_clear_event",
 532                     GTK_RUN_LAST,
 533                     object_class->type,
 534                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event),
 535                     gtk_widget_marshal_signal_4,
 536                     GTK_TYPE_BOOL, 1,
 537                     GTK_TYPE_GDK_EVENT);
 538   widget_signals[SELECTION_REQUEST_EVENT] =
 539     gtk_signal_new ("selection_request_event",
 540                     GTK_RUN_LAST,
 541                     object_class->type,
 542                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event),
 543                     gtk_widget_marshal_signal_4,
 544                     GTK_TYPE_BOOL, 1,
 545                     GTK_TYPE_GDK_EVENT);
 546   widget_signals[SELECTION_NOTIFY_EVENT] =
 547     gtk_signal_new ("selection_notify_event",
 548                     GTK_RUN_LAST,
 549                     object_class->type,
 550                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event),
 551                     gtk_widget_marshal_signal_4,
 552                     GTK_TYPE_BOOL, 1,
 553                     GTK_TYPE_GDK_EVENT);
 554   widget_signals[SELECTION_RECEIVED] =
 555     gtk_signal_new ("selection_received",
 556                     GTK_RUN_LAST,
 557                     object_class->type,
 558                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
 559                     gtk_widget_marshal_signal_1,
 560                     GTK_TYPE_BOOL, 1,
 561                     GTK_TYPE_GDK_EVENT);
 562   widget_signals[PROXIMITY_IN_EVENT] =
 563     gtk_signal_new ("proximity_in_event",
 564                     GTK_RUN_FIRST,
 565                     object_class->type,
 566                     GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event),
 567                     gtk_widget_marshal_signal_4,
 568                     GTK_TYPE_BOOL, 1,
 569                     GTK_TYPE_GDK_EVENT);
 570   widget_signals[PROXIMITY_OUT_EVENT] =
 571     gtk_signal_new ("proximity_out_event",
 572                     GTK_RUN_LAST,
 573                     object_class->type,
 574                     GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event),
 575                     gtk_widget_marshal_signal_4,
 576                     GTK_TYPE_BOOL, 1,
 577                     GTK_TYPE_GDK_EVENT);
 578   widget_signals[DRAG_BEGIN_EVENT] =
 579     gtk_signal_new ("drag_begin_event",
 580                     GTK_RUN_LAST,
 581                     object_class->type,
 582                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin_event),
 583                     gtk_widget_marshal_signal_4,
 584                     GTK_TYPE_BOOL, 1,
 585                     GTK_TYPE_GDK_EVENT);
 586   widget_signals[DRAG_REQUEST_EVENT] =
 587     gtk_signal_new ("drag_request_event",
 588                     GTK_RUN_LAST,
 589                     object_class->type,
 590                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_request_event),
 591                     gtk_widget_marshal_signal_4,
 592                     GTK_TYPE_BOOL, 1,
 593                     GTK_TYPE_GDK_EVENT);
 594   widget_signals[DROP_ENTER_EVENT] =
 595     gtk_signal_new ("drop_enter_event",
 596                     GTK_RUN_FIRST,
 597                     object_class->type,
 598                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_enter_event),
 599                     gtk_widget_marshal_signal_4,
 600                     GTK_TYPE_BOOL, 1,
 601                     GTK_TYPE_GDK_EVENT);
 602   widget_signals[DROP_LEAVE_EVENT] =
 603     gtk_signal_new ("drop_leave_event",
 604                     GTK_RUN_FIRST,
 605                     object_class->type,
 606                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_leave_event),
 607                     gtk_widget_marshal_signal_4,
 608                     GTK_TYPE_BOOL, 1,
 609                     GTK_TYPE_GDK_EVENT);
 610   widget_signals[DROP_DATA_AVAILABLE_EVENT] =
 611     gtk_signal_new ("drop_data_available_event",
 612                     GTK_RUN_FIRST,
 613                     object_class->type,
 614                     GTK_SIGNAL_OFFSET (GtkWidgetClass,
 615                                        drop_data_available_event),
 616                     gtk_widget_marshal_signal_4,
 617                     GTK_TYPE_BOOL, 1,
 618                     GTK_TYPE_GDK_EVENT);
 619   widget_signals[OTHER_EVENT] =
 620     gtk_signal_new ("other_event",
 621                     GTK_RUN_LAST,
 622                     object_class->type,
 623                     GTK_SIGNAL_OFFSET (GtkWidgetClass, other_event),
 624                     gtk_widget_marshal_signal_4,
 625                     GTK_TYPE_BOOL, 1,
 626                     GTK_TYPE_GDK_EVENT);
 627   widget_signals[CLIENT_EVENT] =
 628     gtk_signal_new ("client_event",
 629                     GTK_RUN_LAST,
 630                     object_class->type,
 631                     GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event),
 632                     gtk_widget_marshal_signal_4,
 633                     GTK_TYPE_BOOL, 1,
 634                     GTK_TYPE_GDK_EVENT);
 635   widget_signals[NO_EXPOSE_EVENT] =
 636     gtk_signal_new ("no_expose_event",
 637                     GTK_RUN_LAST,
 638                     object_class->type,
 639                     GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event),
 640                     gtk_widget_marshal_signal_4,
 641                     GTK_TYPE_BOOL, 1,
 642                     GTK_TYPE_GDK_EVENT);
 643
 644   gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
 645
 646   object_class->destroy = gtk_widget_real_destroy;
 647   object_class->finalize = gtk_widget_real_finalize;
 648
 649   klass->activate_signal = 0;
 650   klass->show = gtk_widget_real_show;
 651   klass->hide = gtk_widget_real_hide;
 652   klass->show_all = gtk_widget_real_show;
 653   klass->hide_all = gtk_widget_real_hide;
 654   klass->map = gtk_widget_real_map;
 655   klass->unmap = gtk_widget_real_unmap;
 656   klass->realize = gtk_widget_real_realize;
 657   klass->unrealize = gtk_widget_real_unrealize;
 658   klass->draw = gtk_widget_real_draw;
 659   klass->draw_focus = NULL;
 660   klass->size_request = NULL;
 661   klass->size_allocate = gtk_widget_real_size_allocate;
 662   klass->state_changed = NULL;
 663   klass->install_accelerator = NULL;
 664   klass->remove_accelerator = NULL;
 665   klass->event = NULL;
 666   klass->button_press_event = NULL;
 667   klass->button_release_event = NULL;
 668   klass->motion_notify_event = NULL;
 669   klass->delete_event = NULL;
 670   klass->destroy_event = NULL;
 671   klass->expose_event = NULL;
 672   klass->key_press_event = NULL;
 673   klass->key_release_event = NULL;
 674   klass->enter_notify_event = NULL;
 675   klass->leave_notify_event = NULL;
 676   klass->configure_event = NULL;
 677   klass->focus_in_event = NULL;
 678   klass->focus_out_event = NULL;
 679   klass->map_event = NULL;
 680   klass->unmap_event = NULL;
 681   klass->property_notify_event = gtk_selection_property_notify;
 682   klass->selection_clear_event = gtk_selection_clear;
 683   klass->selection_request_event = gtk_selection_request;
 684   klass->selection_notify_event = gtk_selection_notify;
 685   klass->selection_received = NULL;
 686   klass->proximity_in_event = NULL;
 687   klass->proximity_out_event = NULL;
 688   klass->drag_begin_event = NULL;
 689   klass->drag_request_event = NULL;
 690   klass->drop_enter_event = NULL;
 691   klass->drop_leave_event = NULL;
 692   klass->drop_data_available_event = NULL;
 693   klass->other_event = NULL;
 694   klass->no_expose_event = NULL;
 695 }
 696
 697 /*****************************************
 698  * gtk_widget_set_arg:
 699  *
 700  *   arguments:
 701  *
 702  *   results:
 703  *****************************************/
 704
 705 static void
 706 gtk_widget_set_arg (GtkWidget   *widget,
 707                     GtkArg      *arg,
 708                     guint        arg_id)
 709 {
 710   switch (arg_id)
 711     {
 712     case ARG_X:
 713       gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2);
 714       break;
 715     case ARG_Y:
 716       gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
 717       break;
 718     case ARG_WIDTH:
 719       gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -1);
 720       break;
 721     case ARG_HEIGHT:
 722       gtk_widget_set_usize (widget, -1, GTK_VALUE_INT (*arg));
 723       break;
 724     case ARG_VISIBLE:
 725       if (GTK_VALUE_BOOL(*arg))
 726         gtk_widget_show (widget);
 727       else
 728         gtk_widget_hide (widget);
 729       break;
 730     case ARG_SENSITIVE:
 731       gtk_widget_set_sensitive (widget, GTK_VALUE_BOOL (*arg));
 732       break;
 733     case ARG_CAN_FOCUS:
 734       if (GTK_VALUE_BOOL (*arg))
 735         GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 736       else
 737         GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
 738       break;
 739     case ARG_HAS_FOCUS:
 740       if (GTK_VALUE_BOOL (*arg))
 741         gtk_widget_grab_focus (widget);
 742       break;
 743     case ARG_CAN_DEFAULT:
 744       if (GTK_VALUE_BOOL (*arg))
 745         GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
 746       else
 747         GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
 748       break;
 749     case ARG_HAS_DEFAULT:
 750       if (GTK_VALUE_BOOL (*arg))
 751         gtk_widget_grab_default (widget);
 752       break;
 753     case ARG_EVENTS:
 754       gtk_widget_set_events (widget, GTK_VALUE_FLAGS (*arg));
 755       break;
 756     case ARG_EXTENSION_EVENTS:
 757       gtk_widget_set_extension_events (widget, GTK_VALUE_FLAGS (*arg));
 758       break;
 759     case ARG_NAME:
 760       gtk_widget_set_name (widget, GTK_VALUE_STRING (*arg));
 761       break;
 762     case ARG_STYLE:
 763       gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg));
 764       break;
 765     case ARG_PARENT:
 766       gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
 767       break;
 768     default:
 769       arg->type = GTK_TYPE_INVALID;
 770       break;
 771     }
 772 }
 773
 774 /*****************************************
 775  * gtk_widget_get_arg:
 776  *
 777  *   arguments:
 778  *
 779  *   results:
 780  *****************************************/
 781
 782 static void
 783 gtk_widget_get_arg (GtkWidget   *widget,
 784                     GtkArg      *arg,
 785                     guint        arg_id)
 786 {
 787   GtkWidgetAuxInfo *aux_info;
 788   gint *eventp;
 789   GdkExtensionMode *modep;
 790
 791   switch (arg_id)
 792     {
 793     case ARG_X:
 794       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 795       if (!aux_info)
 796         GTK_VALUE_INT (*arg) = -2;
 797       else
 798         GTK_VALUE_INT (*arg) = aux_info->x;
 799       break;
 800     case ARG_Y:
 801       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 802       if (!aux_info)
 803         GTK_VALUE_INT (*arg) = -2;
 804       else
 805         GTK_VALUE_INT (*arg) = aux_info->y;
 806       break;
 807     case ARG_WIDTH:
 808       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 809       if (!aux_info)
 810         GTK_VALUE_INT (*arg) = -2;
 811       else
 812         GTK_VALUE_INT (*arg) = aux_info->width;
 813       break;
 814     case ARG_HEIGHT:
 815       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 816       if (!aux_info)
 817         GTK_VALUE_INT (*arg) = -2;
 818       else
 819         GTK_VALUE_INT (*arg) = aux_info->height;
 820       break;
 821     case ARG_VISIBLE:
 822       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_VISIBLE (widget);
 823       break;
 824     case ARG_SENSITIVE:
 825       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_SENSITIVE (widget);
 826       break;
 827     case ARG_CAN_FOCUS:
 828       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_CAN_FOCUS (widget);
 829       break;
 830     case ARG_HAS_FOCUS:
 831       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_HAS_FOCUS (widget);
 832       break;
 833     case ARG_CAN_DEFAULT:
 834       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_CAN_DEFAULT (widget);
 835       break;
 836     case ARG_HAS_DEFAULT:
 837       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_HAS_DEFAULT (widget);
 838       break;
 839     case ARG_EVENTS:
 840       eventp = gtk_object_get_data (GTK_OBJECT (widget), event_key);
 841       if (!eventp)
 842         GTK_VALUE_FLAGS (*arg) = 0;
 843       else
 844         GTK_VALUE_FLAGS (*arg) = *eventp;
 845       break;
 846     case ARG_EXTENSION_EVENTS:
 847       modep = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
 848       if (!modep)
 849         GTK_VALUE_FLAGS (*arg) = 0;
 850       else
 851         GTK_VALUE_FLAGS (*arg) = *modep;
 852       break;
 853     case ARG_NAME:
 854       if (widget->name)
 855         GTK_VALUE_STRING (*arg) = g_strdup (widget->name);
 856       else
 857         GTK_VALUE_STRING (*arg) = g_strdup ("");
 858       break;
 859     case ARG_STYLE:
 860       GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
 861       break;
 862     case ARG_PARENT:
 863       GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
 864       break;
 865     default:
 866       arg->type = GTK_TYPE_INVALID;
 867       break;
 868     }
 869 }
 870
 871 /*****************************************
 872  * gtk_widget_init:
 873  *
 874  *   arguments:
 875  *
 876  *   results:
 877  *****************************************/
 878
 879 static void
 880 gtk_widget_init (GtkWidget *widget)
 881 {
 882   GdkColormap *colormap;
 883   GdkVisual *visual;
 884
 885   GTK_PRIVATE_FLAGS (widget) = 0;
 886   widget->state = GTK_STATE_NORMAL;
 887   widget->saved_state = GTK_STATE_NORMAL;
 888   widget->name = NULL;
 889   widget->requisition.width = 0;
 890   widget->requisition.height = 0;
 891   widget->allocation.x = -1;
 892   widget->allocation.y = -1;
 893   widget->allocation.width = 1;
 894   widget->allocation.height = 1;
 895   widget->window = NULL;
 896   widget->parent = NULL;
 897
 898   GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE | GTK_PARENT_SENSITIVE);
 899
 900   widget->style = gtk_widget_peek_style ();
 901   gtk_style_ref (widget->style);
 902
 903   colormap = gtk_widget_peek_colormap ();
 904   visual = gtk_widget_peek_visual ();
 905
 906   /* XXX - should we ref the colormap and visual, too? */
 907
 908   if (colormap != gtk_widget_get_default_colormap ())
 909     {
 910       /* gdk_colormap_ref (colormap); */
 911       gtk_object_set_data (GTK_OBJECT (widget), colormap_key, colormap);
 912     }
 913
 914   if (visual != gtk_widget_get_default_visual ())
 915     {
 916       /* gdk_visual_ref (visual); */
 917       gtk_object_set_data (GTK_OBJECT (widget), visual_key, visual);
 918     }
 919 }
 920
 921 /*****************************************
 922  * gtk_widget_new:
 923  *
 924  *   arguments:
 925  *
 926  *   results:
 927  *****************************************/
 928
 929 GtkWidget*
 930 gtk_widget_new (guint type,
 931                 ...)
 932 {
 933   GtkObject *obj;
 934   GtkArg *args;
 935   guint nargs;
 936   va_list args1;
 937   va_list args2;
 938
 939   g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
 940
 941   obj = gtk_type_new (type);
 942
 943   va_start (args1, type);
 944   va_start (args2, type);
 945
 946   args = gtk_object_collect_args (&nargs, args1, args2);
 947   gtk_object_setv (obj, nargs, args);
 948   g_free (args);
 949
 950   va_end (args1);
 951   va_end (args2);
 952
 953   return GTK_WIDGET (obj);
 954 }
 955
 956 void
 957 gtk_widget_ref (GtkWidget *widget)
 958 {
 959   gtk_object_ref (GTK_OBJECT (widget));
 960 }
 961
 962 void
 963 gtk_widget_unref (GtkWidget *widget)
 964 {
 965   gtk_object_unref (GTK_OBJECT (widget));
 966 }
 967
 968 /*****************************************
 969  * gtk_widget_newv:
 970  *
 971  *   arguments:
 972  *
 973  *   results:
 974  *****************************************/
 975
 976 GtkWidget*
 977 gtk_widget_newv (guint   type,
 978                  guint   nargs,
 979                  GtkArg *args)
 980 {
 981   g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
 982
 983   return GTK_WIDGET (gtk_object_newv (type, nargs, args));
 984 }
 985
 986 /*****************************************
 987  * gtk_widget_get:
 988  *
 989  *   arguments:
 990  *
 991  *   results:
 992  *****************************************/
 993
 994 void
 995 gtk_widget_get (GtkWidget       *widget,
 996                 GtkArg          *arg)
 997 {
 998   g_return_if_fail (widget != NULL);
 999   g_return_if_fail (arg != NULL);
1000
1001   gtk_object_getv (GTK_OBJECT (widget), 1, arg);
1002 }
1003
1004 /*****************************************
1005  * gtk_widget_getv:
1006  *
1007  *   arguments:
1008  *
1009  *   results:
1010  *****************************************/
1011
1012 void
1013 gtk_widget_getv (GtkWidget      *widget,
1014                  guint           nargs,
1015                  GtkArg         *args)
1016 {
1017   gtk_object_getv (GTK_OBJECT (widget), nargs, args);
1018 }
1019
1020 /*****************************************
1021  * gtk_widget_set:
1022  *
1023  *   arguments:
1024  *
1025  *   results:
1026  *****************************************/
1027
1028 void
1029 gtk_widget_set (GtkWidget *widget,
1030                 ...)
1031 {
1032   GtkArg *args;
1033   guint nargs;
1034   va_list args1;
1035   va_list args2;
1036
1037   g_return_if_fail (widget != NULL);
1038
1039   va_start (args1, widget);
1040   va_start (args2, widget);
1041
1042   args = gtk_object_collect_args (&nargs, args1, args2);
1043   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1044   g_free (args);
1045
1046   va_end (args1);
1047   va_end (args2);
1048 }
1049
1050 /*****************************************
1051  * gtk_widget_setv:
1052  *
1053  *   arguments:
1054  *
1055  *   results:
1056  *****************************************/
1057
1058 void
1059 gtk_widget_setv (GtkWidget *widget,
1060                  guint      nargs,
1061                  GtkArg    *args)
1062 {
1063   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1064 }
1065
1066 /*****************************************
1067  * gtk_widget_unparent:
1068  *   do any cleanup necessary necessary
1069  *   before setting parent = NULL.
1070  *   In particular, remove the focus
1071  *   properly.
1072  *
1073  *   arguments:
1074  *
1075  *   results:
1076  *****************************************/
1077
1078 void
1079 gtk_widget_unparent (GtkWidget *widget)
1080 {
1081   GtkWidget *toplevel;
1082   GtkWidget *child;
1083
1084   g_return_if_fail (widget != NULL);
1085   if (widget->parent == NULL)
1086     return;
1087
1088   toplevel = gtk_widget_get_toplevel (widget);
1089   if (GTK_IS_WINDOW (toplevel))
1090     {
1091       child = GTK_WINDOW (toplevel)->focus_widget;
1092
1093       while (child && child != widget)
1094         child = child->parent;
1095
1096       if (child == widget)
1097         gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
1098     }
1099
1100   if (widget->window &&
1101       GTK_WIDGET_NO_WINDOW (widget) &&
1102       GTK_WIDGET_DRAWABLE (widget))
1103     gdk_window_clear_area (widget->window,
1104                            widget->allocation.x,
1105                            widget->allocation.y,
1106                            widget->allocation.width,
1107                            widget->allocation.height);
1108
1109   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_IN_REPARENT (widget))
1110     gtk_widget_unrealize (widget);
1111
1112   widget->parent = NULL;
1113
1114   gtk_widget_unref (widget);
1115 }
1116
1117 /*****************************************
1118  * gtk_widget_destroy:
1119  *
1120  *   arguments:
1121  *
1122  *   results:
1123  *****************************************/
1124
1125 void
1126 gtk_widget_destroy (GtkWidget *widget)
1127 {
1128   g_return_if_fail (widget != NULL);
1129   g_return_if_fail (GTK_IS_WIDGET (widget));
1130
1131   gtk_object_destroy (GTK_OBJECT (widget));
1132 }
1133
1134 void
1135 gtk_widget_destroyed (GtkWidget      *widget,
1136                       GtkWidget      **widget_pointer)
1137 {
1138   if (widget_pointer)
1139     *widget_pointer = NULL;
1140 }
1141
1142 /*****************************************
1143  * gtk_widget_show:
1144  *
1145  *   arguments:
1146  *
1147  *   results:
1148  *****************************************/
1149
1150 void
1151 gtk_widget_show (GtkWidget *widget)
1152 {
1153   g_return_if_fail (widget != NULL);
1154
1155   if (!GTK_WIDGET_VISIBLE (widget))
1156     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
1157 }
1158
1159 /*****************************************
1160  * gtk_widget_hide:
1161  *
1162  *   arguments:
1163  *
1164  *   results:
1165  *****************************************/
1166
1167 void
1168 gtk_widget_hide (GtkWidget *widget)
1169 {
1170   g_return_if_fail (widget != NULL);
1171
1172   if (GTK_WIDGET_VISIBLE (widget))
1173     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
1174 }
1175
1176 /*****************************************
1177  * gtk_widget_show_all:
1178  *
1179  *   Shows the widget and all children.
1180  *
1181  *   Container classes overwrite
1182  *   show_all and hide_all to call
1183  *   show_all (hide_all) on both themselves
1184  *   and on their child widgets.
1185  *
1186  *   arguments:
1187  *
1188  *   results:
1189  *****************************************/
1190
1191 void
1192 gtk_widget_show_all (GtkWidget *widget)
1193 {
1194   GtkWidgetClass *widget_class;
1195
1196   g_return_if_fail (widget != NULL);
1197
1198   /* show_all shouldn't be invoked through a signal,
1199      because in this case it would be quite slow - there would
1200      be a show and show_all signal emitted for every child widget.
1201    */
1202   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1203   widget_class->show_all (widget);
1204 }
1205
1206 /*****************************************
1207  * gtk_widget_hide_all:
1208  *
1209  *   Hides the widget and all children.
1210  *   See gtk_widget_show_all.
1211  *
1212  *   arguments:
1213  *
1214  *   results:
1215  *****************************************/
1216
1217 void
1218 gtk_widget_hide_all (GtkWidget *widget)
1219 {
1220   GtkWidgetClass *widget_class;
1221
1222   g_return_if_fail (widget != NULL);
1223   g_assert (widget->parent);
1224
1225   if (GTK_WIDGET_RESIZE_NEEDED (widget))
1226     {
1227       GtkWidget *toplevel;
1228
1229       toplevel = gtk_widget_get_toplevel (widget);
1230       if (toplevel != widget)
1231         GTK_CONTAINER (toplevel)->resize_widgets =
1232           g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1233       GTK_PRIVATE_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED);
1234     }
1235
1236   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1237   widget_class->hide_all (widget);
1238 }
1239
1240 /*****************************************
1241  * gtk_widget_map:
1242  *
1243  *   arguments:
1244  *
1245  *   results:
1246  *****************************************/
1247
1248 void
1249 gtk_widget_map (GtkWidget *widget)
1250 {
1251   g_return_if_fail (widget != NULL);
1252
1253   if (!GTK_WIDGET_MAPPED (widget))
1254     {
1255       if (!GTK_WIDGET_REALIZED (widget))
1256         gtk_widget_realize (widget);
1257
1258       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);
1259     }
1260 }
1261
1262 /*****************************************
1263  * gtk_widget_unmap:
1264  *
1265  *   arguments:
1266  *
1267  *   results:
1268  *****************************************/
1269
1270 void
1271 gtk_widget_unmap (GtkWidget *widget)
1272 {
1273   g_return_if_fail (widget != NULL);
1274
1275   if (GTK_WIDGET_MAPPED (widget))
1276     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
1277 }
1278
1279 /*****************************************
1280  * gtk_widget_realize:
1281  *
1282  *   arguments:
1283  *
1284  *   results:
1285  *****************************************/
1286
1287 void
1288 gtk_widget_realize (GtkWidget *widget)
1289 {
1290   GtkStyle *new_style;
1291   gint events;
1292   GdkExtensionMode mode;
1293   GtkWidgetShapeInfo *shape_info;
1294
1295   g_return_if_fail (widget != NULL);
1296
1297   if (!GTK_WIDGET_REALIZED (widget))
1298     {
1299       /*
1300         if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
1301           g_print ("%s\n", gtk_type_name (GTK_WIDGET_TYPE (widget)));
1302       */
1303
1304       if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
1305         gtk_widget_realize (widget->parent);
1306
1307       if (!GTK_WIDGET_USER_STYLE (widget))
1308         {
1309           new_style = gtk_rc_get_style (widget);
1310           if (new_style != widget->style)
1311             gtk_widget_set_style_internal (widget, new_style);
1312         }
1313
1314       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REALIZE]);
1315
1316       if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
1317         {
1318           shape_info = gtk_object_get_data (GTK_OBJECT (widget),
1319                                             shape_info_key);
1320           gdk_window_shape_combine_mask (widget->window,
1321                                          shape_info->shape_mask,
1322                                          shape_info->offset_x,
1323                                          shape_info->offset_y);
1324         }
1325
1326       if (!GTK_WIDGET_NO_WINDOW (widget))
1327         {
1328           mode = gtk_widget_get_extension_events (widget);
1329           if (mode != GDK_EXTENSION_EVENTS_NONE)
1330             {
1331               events = gtk_widget_get_events (widget);
1332               gdk_input_set_extension_events (widget->window, events, mode);
1333             }
1334         }
1335
1336     }
1337 }
1338
1339 /*****************************************
1340  * gtk_widget_unrealize:
1341  *
1342  *   arguments:
1343  *
1344  *   results:
1345  *****************************************/
1346
1347 void
1348 gtk_widget_unrealize (GtkWidget *widget)
1349 {
1350   g_return_if_fail (widget != NULL);
1351
1352   if (GTK_WIDGET_REALIZED (widget))
1353     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
1354 }
1355
1356 /*****************************************
1357  * gtk_widget_queue_draw:
1358  *
1359  *   arguments:
1360  *
1361  *   results:
1362  *****************************************/
1363
1364 static gint
1365 gtk_widget_idle_draw (void *data)
1366 {
1367   GSList *node;
1368
1369   node = gtk_widget_redraw_queue;
1370   gtk_widget_redraw_queue = NULL;
1371   while (node)
1372     {
1373       gtk_widget_real_queue_draw ((GtkWidget*) node->data);
1374       node = node->next;
1375     }
1376
1377   return gtk_widget_redraw_queue != NULL;
1378 }
1379
1380 void
1381 gtk_widget_queue_draw (GtkWidget *widget)
1382 {
1383   GtkWidget *parent;
1384
1385   g_return_if_fail (widget != NULL);
1386
1387   if (GTK_WIDGET_DRAWABLE (widget))
1388     {
1389       /* We queue the redraw if:
1390        *  a) the widget is not already queued for redraw and
1391        *  b) non of the widgets ancestors are queued for redraw.
1392        */
1393       parent = widget;
1394       while (parent)
1395         {
1396           if (GTK_WIDGET_REDRAW_PENDING (parent))
1397             return;
1398           parent = parent->parent;
1399         }
1400
1401       GTK_PRIVATE_SET_FLAGS (widget, GTK_REDRAW_PENDING);
1402       if (gtk_widget_redraw_queue == NULL)
1403         gtk_idle_add ((GtkFunction) gtk_widget_idle_draw, NULL);
1404
1405       gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
1406     }
1407 }
1408
1409 /*****************************************
1410  * gtk_widget_queue_resize:
1411  *
1412  *   arguments:
1413  *
1414  *   results:
1415  *****************************************/
1416
1417 static gint
1418 gtk_widget_idle_sizer (void *data)
1419 {
1420   GSList *node;
1421
1422   node = gtk_widget_resize_queue;
1423   gtk_widget_resize_queue = NULL;
1424   while (node)
1425     {
1426       gtk_widget_real_queue_resize ((GtkWidget *)node->data);
1427       node = node->next;
1428     }
1429
1430   return gtk_widget_resize_queue != NULL;
1431 }
1432
1433 void
1434 gtk_widget_queue_resize (GtkWidget *widget)
1435 {
1436   GtkWidget *toplevel;
1437
1438   g_return_if_fail (widget != NULL);
1439
1440   toplevel = gtk_widget_get_toplevel (widget);
1441   if (GTK_WIDGET_TOPLEVEL (toplevel))
1442     {
1443       if (GTK_WIDGET_VISIBLE (toplevel))
1444         {
1445           if (!GTK_CONTAINER_RESIZE_PENDING (toplevel))
1446             {
1447               GTK_PRIVATE_SET_FLAGS (toplevel, GTK_RESIZE_PENDING);
1448               if (gtk_widget_resize_queue == NULL)
1449                 gtk_idle_add ((GtkFunction) gtk_widget_idle_sizer, NULL);
1450               gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, toplevel);
1451             }
1452
1453           if (!GTK_WIDGET_RESIZE_NEEDED (widget))
1454             {
1455               GTK_PRIVATE_SET_FLAGS (widget, GTK_RESIZE_NEEDED);
1456               GTK_CONTAINER (toplevel)->resize_widgets =
1457                 g_slist_prepend (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1458             }
1459           else
1460             g_assert (g_slist_find (GTK_CONTAINER (toplevel)->resize_widgets, widget)); /* paranoid */
1461         }
1462       else
1463         gtk_container_need_resize (GTK_CONTAINER (toplevel));
1464     }
1465 }
1466
1467 /*****************************************
1468  * gtk_widget_draw:
1469  *
1470  *   arguments:
1471  *
1472  *   results:
1473  *****************************************/
1474
1475 void
1476 gtk_widget_draw (GtkWidget    *widget,
1477                  GdkRectangle *area)
1478 {
1479   GdkRectangle temp_area;
1480
1481   g_return_if_fail (widget != NULL);
1482
1483   if (GTK_WIDGET_DRAWABLE (widget) &&
1484       !GTK_WIDGET_REDRAW_PENDING (widget))
1485     {
1486       if (!area)
1487         {
1488           if (GTK_WIDGET_NO_WINDOW (widget))
1489             {
1490               temp_area.x = widget->allocation.x;
1491               temp_area.y = widget->allocation.y;
1492             }
1493           else
1494             {
1495               temp_area.x = 0;
1496               temp_area.y = 0;
1497             }
1498
1499           temp_area.width = widget->allocation.width;
1500           temp_area.height = widget->allocation.height;
1501           area = &temp_area;
1502         }
1503
1504       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
1505     }
1506 }
1507
1508 /*****************************************
1509  * gtk_widget_draw_focus:
1510  *
1511  *   arguments:
1512  *
1513  *   results:
1514  *****************************************/
1515
1516 void
1517 gtk_widget_draw_focus (GtkWidget *widget)
1518 {
1519   g_return_if_fail (widget != NULL);
1520
1521   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_FOCUS]);
1522 }
1523
1524 /*****************************************
1525  * gtk_widget_draw_default:
1526  *
1527  *   arguments:
1528  *
1529  *   results:
1530  *****************************************/
1531
1532 void
1533 gtk_widget_draw_default (GtkWidget *widget)
1534 {
1535   g_return_if_fail (widget != NULL);
1536
1537   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_DEFAULT]);
1538 }
1539
1540 /*****************************************
1541  * gtk_widget_draw_children:
1542  *
1543  *   arguments:
1544  *
1545  *   results:
1546  *****************************************/
1547
1548 void
1549 gtk_widget_draw_children (GtkWidget *widget)
1550 {
1551   g_return_if_fail (widget != NULL);
1552
1553   if (GTK_IS_CONTAINER (widget))
1554     gtk_container_foreach (GTK_CONTAINER (widget),
1555                            gtk_widget_draw_children_recurse,
1556                            NULL);
1557 }
1558
1559 /*****************************************
1560  * gtk_widget_size_request:
1561  *
1562  *   arguments:
1563  *
1564  *   results:
1565  *****************************************/
1566
1567 void
1568 gtk_widget_size_request (GtkWidget      *widget,
1569                          GtkRequisition *requisition)
1570 {
1571   GtkWidgetAuxInfo *aux_info;
1572
1573   g_return_if_fail (widget != NULL);
1574
1575   gtk_widget_ref (widget);
1576   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
1577                    requisition);
1578   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1579   if (aux_info)
1580     {
1581       if (aux_info->width > 0)
1582         requisition->width = aux_info->width;
1583       if (aux_info->height > 0)
1584         requisition->height = aux_info->height;
1585     }
1586   gtk_widget_unref (widget);
1587 }
1588
1589 /*****************************************
1590  * gtk_widget_size_allocate:
1591  *
1592  *   arguments:
1593  *
1594  *   results:
1595  *****************************************/
1596
1597 void
1598 gtk_widget_size_allocate (GtkWidget     *widget,
1599                           GtkAllocation *allocation)
1600 {
1601   GtkWidgetAuxInfo *aux_info;
1602   GtkAllocation real_allocation;
1603
1604   g_return_if_fail (widget != NULL);
1605
1606   real_allocation = *allocation;
1607   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1608
1609   if (aux_info)
1610     {
1611       if (aux_info->x != -1)
1612         real_allocation.x = aux_info->x;
1613       if (aux_info->y != -1)
1614         real_allocation.y = aux_info->y;
1615     }
1616
1617   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
1618 }
1619
1620 /*****************************************
1621  * gtk_widget_install_accelerator:
1622  *
1623  *   arguments:
1624  *
1625  *   results:
1626  *****************************************/
1627
1628 void
1629 gtk_widget_install_accelerator (GtkWidget           *widget,
1630                                 GtkAcceleratorTable *table,
1631                                 const gchar         *signal_name,
1632                                 gchar                key,
1633                                 guint8               modifiers)
1634 {
1635   gint return_val;
1636
1637   g_return_if_fail (widget != NULL);
1638
1639   gtk_widget_ref (widget);
1640   return_val = TRUE;
1641   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[INSTALL_ACCELERATOR],
1642                    signal_name, key, modifiers, &return_val);
1643   if (return_val)
1644     gtk_accelerator_table_install (table,
1645                                    GTK_OBJECT (widget),
1646                                    signal_name,
1647                                    key,
1648                                    modifiers);
1649   gtk_widget_unref (widget);
1650 }
1651
1652 /*****************************************
1653  * gtk_widget_remove_accelerator:
1654  *
1655  *   arguments:
1656  *
1657  *   results:
1658  *****************************************/
1659
1660 void
1661 gtk_widget_remove_accelerator (GtkWidget           *widget,
1662                                GtkAcceleratorTable *table,
1663                                const gchar         *signal_name)
1664 {
1665   g_return_if_fail (widget != NULL);
1666
1667   gtk_widget_ref (widget);
1668   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REMOVE_ACCELERATOR],
1669                    signal_name);
1670   gtk_accelerator_table_remove (table, GTK_OBJECT (widget), signal_name);
1671   gtk_widget_unref (widget);
1672 }
1673
1674 /*****************************************
1675  * gtk_widget_event:
1676  *
1677  *   arguments:
1678  *
1679  *   results:
1680  *****************************************/
1681
1682 gint
1683 gtk_widget_event (GtkWidget *widget,
1684                   GdkEvent  *event)
1685 {
1686   gint return_val;
1687   gint signal_num;
1688
1689   g_return_val_if_fail (widget != NULL, FALSE);
1690
1691   gtk_widget_ref (widget);
1692   return_val = FALSE;
1693   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
1694                    &return_val);
1695   if (return_val)
1696     {
1697       gtk_widget_unref (widget);
1698       return TRUE;
1699     }
1700
1701   switch (event->type)
1702     {
1703     case GDK_NOTHING:
1704       signal_num = -1;
1705       break;
1706     case GDK_BUTTON_PRESS:
1707     case GDK_2BUTTON_PRESS:
1708     case GDK_3BUTTON_PRESS:
1709       signal_num = BUTTON_PRESS_EVENT;
1710       break;
1711     case GDK_BUTTON_RELEASE:
1712       signal_num = BUTTON_RELEASE_EVENT;
1713       break;
1714     case GDK_MOTION_NOTIFY:
1715       signal_num = MOTION_NOTIFY_EVENT;
1716       break;
1717     case GDK_DELETE:
1718       signal_num = DELETE_EVENT;
1719       break;
1720     case GDK_DESTROY:
1721       signal_num = DESTROY_EVENT;
1722       break;
1723     case GDK_EXPOSE:
1724       signal_num = EXPOSE_EVENT;
1725       break;
1726     case GDK_KEY_PRESS:
1727       signal_num = KEY_PRESS_EVENT;
1728       break;
1729     case GDK_KEY_RELEASE:
1730       signal_num = KEY_RELEASE_EVENT;
1731       break;
1732     case GDK_ENTER_NOTIFY:
1733       signal_num = ENTER_NOTIFY_EVENT;
1734       break;
1735     case GDK_LEAVE_NOTIFY:
1736       signal_num = LEAVE_NOTIFY_EVENT;
1737       break;
1738     case GDK_FOCUS_CHANGE:
1739       if (event->focus_change.in)
1740         signal_num = FOCUS_IN_EVENT;
1741       else
1742         signal_num = FOCUS_OUT_EVENT;
1743       break;
1744     case GDK_CONFIGURE:
1745       signal_num = CONFIGURE_EVENT;
1746       break;
1747     case GDK_MAP:
1748       signal_num = MAP_EVENT;
1749       break;
1750     case GDK_UNMAP:
1751       signal_num = UNMAP_EVENT;
1752       break;
1753     case GDK_PROPERTY_NOTIFY:
1754       signal_num = PROPERTY_NOTIFY_EVENT;
1755       break;
1756     case GDK_SELECTION_CLEAR:
1757       signal_num = SELECTION_CLEAR_EVENT;
1758       break;
1759     case GDK_SELECTION_REQUEST:
1760       signal_num = SELECTION_REQUEST_EVENT;
1761       break;
1762     case GDK_SELECTION_NOTIFY:
1763       signal_num = SELECTION_NOTIFY_EVENT;
1764       break;
1765     case GDK_PROXIMITY_IN:
1766       signal_num = PROXIMITY_IN_EVENT;
1767       break;
1768     case GDK_PROXIMITY_OUT:
1769       signal_num = PROXIMITY_OUT_EVENT;
1770       break;
1771     case GDK_DRAG_BEGIN:
1772       signal_num = DRAG_BEGIN_EVENT;
1773       break;
1774     case GDK_DRAG_REQUEST:
1775       signal_num = DRAG_REQUEST_EVENT;
1776       break;
1777     case GDK_DROP_ENTER:
1778       signal_num = DROP_ENTER_EVENT;
1779       break;
1780     case GDK_DROP_LEAVE:
1781       signal_num = DROP_LEAVE_EVENT;
1782       break;
1783     case GDK_DROP_DATA_AVAIL:
1784       signal_num = DROP_DATA_AVAILABLE_EVENT;
1785       break;
1786     case GDK_OTHER_EVENT:
1787       signal_num = OTHER_EVENT;
1788       break;
1789     case GDK_NO_EXPOSE:
1790       signal_num = NO_EXPOSE_EVENT;
1791       break;
1792     case GDK_CLIENT_EVENT:
1793       signal_num = CLIENT_EVENT;
1794       break;
1795     default:
1796       g_warning ("could not determine signal number for event: %d", event->type);
1797       gtk_widget_unref (widget);
1798       return return_val;
1799     }
1800
1801   if (signal_num != -1)
1802     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[signal_num], event, &return_val);
1803
1804   gtk_widget_unref (widget);
1805   return return_val;
1806 }
1807
1808 /*****************************************
1809  * gtk_widget_activate:
1810  *
1811  *   arguments:
1812  *
1813  *   results:
1814  *****************************************/
1815
1816 void
1817 gtk_widget_activate (GtkWidget *widget)
1818 {
1819   g_return_if_fail (widget != NULL);
1820   g_return_if_fail (GTK_IS_WIDGET (widget));
1821
1822   if (WIDGET_CLASS (widget)->activate_signal)
1823     gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
1824 }
1825
1826 /*****************************************
1827  * gtk_widget_reparent_container_child:
1828  *   assistent function to gtk_widget_reparent
1829  *
1830  *   arguments:
1831  *
1832  *   results:
1833  *****************************************/
1834
1835 static void
1836 gtk_widget_reparent_container_child(GtkWidget *widget,
1837                                    gpointer   client_data)
1838 {
1839   g_return_if_fail (widget != NULL);
1840   g_return_if_fail (client_data != NULL);
1841
1842   if (GTK_WIDGET_NO_WINDOW (widget))
1843     {
1844       if (widget->window)
1845         gdk_window_unref (widget->window);
1846       widget->window = (GdkWindow*) client_data;
1847       if (widget->window)
1848         gdk_window_ref (widget->window);
1849
1850       if (GTK_IS_CONTAINER (widget))
1851         gtk_container_foreach (GTK_CONTAINER (widget),
1852                                gtk_widget_reparent_container_child,
1853                                client_data);
1854     }
1855   else
1856     gdk_window_reparent (widget->window,
1857                          (GdkWindow*) client_data, 0, 0);
1858 }
1859
1860 /*****************************************
1861  * gtk_widget_reparent:
1862  *
1863  *   arguments:
1864  *
1865  *   results:
1866  *****************************************/
1867
1868 void
1869 gtk_widget_reparent (GtkWidget *widget,
1870                      GtkWidget *new_parent)
1871 {
1872   g_return_if_fail (widget != NULL);
1873   g_return_if_fail (new_parent != NULL);
1874   g_return_if_fail (GTK_IS_CONTAINER (new_parent));
1875
1876   if (widget->parent != new_parent)
1877     {
1878       /* First try to see if we can get away without unrealizing
1879        * the widget as we reparent it
1880        */
1881
1882       if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
1883         {
1884           /* Set a flag so that gtk_widget_unparent doesn't unrealize widget
1885            */
1886           GTK_PRIVATE_SET_FLAGS (widget, GTK_IN_REPARENT);
1887         }
1888
1889       gtk_widget_ref (widget);
1890       gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
1891       gtk_container_add (GTK_CONTAINER (new_parent), widget);
1892       gtk_widget_unref (widget);
1893
1894       if (GTK_WIDGET_IN_REPARENT (widget))
1895         {
1896           /* OK, now fix up the widget's window. (And that for any
1897            * children, if the widget is NO_WINDOW and a container)
1898            */
1899           if (GTK_WIDGET_NO_WINDOW (widget))
1900             {
1901               if (GTK_IS_CONTAINER (widget))
1902                 gtk_container_foreach (GTK_CONTAINER(widget),
1903                                        gtk_widget_reparent_container_child,
1904                                        gtk_widget_get_parent_window (widget));
1905               else
1906                 {
1907                   GdkWindow *parent_window;
1908
1909                   parent_window = gtk_widget_get_parent_window (widget);
1910                   if (parent_window != widget->window)
1911                     {
1912                       if (widget->window)
1913                         gdk_window_unref (widget->window);
1914                       widget->window = parent_window;
1915                       if (widget->window)
1916                         gdk_window_ref (widget->window);
1917                     }
1918                 }
1919             }
1920           else
1921             gdk_window_reparent (widget->window, gtk_widget_get_parent_window (widget), 0, 0);
1922
1923           GTK_PRIVATE_UNSET_FLAGS (widget, GTK_IN_REPARENT);
1924         }
1925     }
1926 }
1927
1928 /*****************************************
1929  * gtk_widget_popup:
1930  *
1931  *   arguments:
1932  *
1933  *   results:
1934  *****************************************/
1935
1936 void
1937 gtk_widget_popup (GtkWidget *widget,
1938                   gint       x,
1939                   gint       y)
1940 {
1941   g_return_if_fail (widget != NULL);
1942
1943   if (!GTK_WIDGET_VISIBLE (widget))
1944     {
1945       if (!GTK_WIDGET_REALIZED (widget))
1946         gtk_widget_realize (widget);
1947       if (!GTK_WIDGET_NO_WINDOW (widget))
1948         gdk_window_move (widget->window, x, y);
1949       gtk_widget_show (widget);
1950     }
1951 }
1952
1953 /*****************************************
1954  * gtk_widget_intersect:
1955  *
1956  *   arguments:
1957  *
1958  *   results:
1959  *****************************************/
1960
1961 gint
1962 gtk_widget_intersect (GtkWidget    *widget,
1963                       GdkRectangle *area,
1964                       GdkRectangle *intersection)
1965 {
1966   GdkRectangle *dest;
1967   GdkRectangle tmp;
1968   gint return_val;
1969
1970   g_return_val_if_fail (widget != NULL, FALSE);
1971   g_return_val_if_fail (area != NULL, FALSE);
1972
1973   if (intersection)
1974     dest = intersection;
1975   else
1976     dest = &tmp;
1977
1978   return_val = gdk_rectangle_intersect ((GdkRectangle*) &widget->allocation, area, dest);
1979
1980   if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
1981     {
1982       intersection->x -= widget->allocation.x;
1983       intersection->y -= widget->allocation.y;
1984     }
1985
1986   return return_val;
1987 }
1988
1989
1990 gint
1991 gtk_widget_basic (GtkWidget *widget)
1992 {
1993   GList *children;
1994   GList *tmp_list;
1995   gint return_val;
1996
1997   g_return_val_if_fail (widget != NULL, FALSE);
1998
1999   if (!GTK_WIDGET_BASIC (widget))
2000     return FALSE;
2001   else if (GTK_IS_CONTAINER (widget))
2002     {
2003       children = gtk_container_children (GTK_CONTAINER (widget));
2004       if (children)
2005         {
2006           return_val = TRUE;
2007           tmp_list = children;
2008
2009           while (tmp_list)
2010             {
2011               if (!gtk_widget_basic (GTK_WIDGET (tmp_list->data)))
2012                 {
2013                   return_val = FALSE;
2014                   break;
2015                 }
2016
2017               tmp_list = tmp_list->next;
2018             }
2019
2020           g_list_free (children);
2021           return return_val;
2022         }
2023     }
2024
2025   return TRUE;
2026 }
2027
2028
2029 /*****************************************
2030  * gtk_widget_grab_focus:
2031  *
2032  *   arguments:
2033  *
2034  *   results:
2035  *****************************************/
2036
2037 void
2038 gtk_widget_grab_focus (GtkWidget *widget)
2039 {
2040   GtkWidget *window;
2041   GtkWidget *child;
2042   gint window_type;
2043
2044   g_return_if_fail (widget != NULL);
2045
2046   window_type = gtk_window_get_type ();
2047   window = widget->parent;
2048   child = widget;
2049
2050   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2051     {
2052       GTK_CONTAINER (window)->focus_child = child;
2053       child = window;
2054       window = window->parent;
2055     }
2056
2057   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2058     {
2059       GTK_CONTAINER (window)->focus_child = child;
2060       gtk_window_set_focus (GTK_WINDOW (window), widget);
2061     }
2062 }
2063
2064 /*****************************************
2065  * gtk_widget_grab_default:
2066  *
2067  *   arguments:
2068  *
2069  *   results:
2070  *****************************************/
2071
2072 void
2073 gtk_widget_grab_default (GtkWidget *widget)
2074 {
2075   GtkWidget *window;
2076   gint window_type;
2077
2078   g_return_if_fail (widget != NULL);
2079   g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
2080
2081   window_type = gtk_window_get_type ();
2082   window = widget->parent;
2083
2084   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2085     window = window->parent;
2086
2087   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2088     gtk_window_set_default (GTK_WINDOW (window), widget);
2089 }
2090
2091 /*****************************************
2092  * gtk_widget_set_name:
2093  *
2094  *   arguments:
2095  *
2096  *   results:
2097  *****************************************/
2098
2099 void
2100 gtk_widget_set_name (GtkWidget   *widget,
2101                      const gchar *name)
2102 {
2103   GtkStyle *new_style;
2104
2105   g_return_if_fail (widget != NULL);
2106
2107   if (widget->name)
2108     g_free (widget->name);
2109   widget->name = g_strdup (name);
2110
2111   if (!GTK_WIDGET_USER_STYLE (widget))
2112     {
2113       new_style = gtk_rc_get_style (widget);
2114       gtk_widget_set_style_internal (widget, new_style);
2115     }
2116 }
2117
2118 /*****************************************
2119  * gtk_widget_get_name:
2120  *
2121  *   arguments:
2122  *
2123  *   results:
2124  *****************************************/
2125
2126 gchar*
2127 gtk_widget_get_name (GtkWidget *widget)
2128 {
2129   g_return_val_if_fail (widget != NULL, NULL);
2130
2131   if (widget->name)
2132     return widget->name;
2133   return gtk_type_name (GTK_WIDGET_TYPE (widget));
2134 }
2135
2136 /*****************************************
2137  * gtk_widget_set_state:
2138  *
2139  *   arguments:
2140  *     widget
2141  *     state
2142  *
2143  *   results:
2144  *****************************************/
2145
2146 void
2147 gtk_widget_set_state (GtkWidget           *widget,
2148                       GtkStateType         state)
2149 {
2150   g_return_if_fail (widget != NULL);
2151
2152   if (state == GTK_WIDGET_STATE (widget))
2153     return;
2154
2155   if (state == GTK_STATE_INSENSITIVE)
2156     gtk_widget_set_sensitive (widget, FALSE);
2157   else
2158     {
2159       GtkStateData data;
2160       GtkStateType old_state;
2161
2162       data.state = state;
2163       if (widget->parent)
2164         data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2165       else
2166         data.parent_sensitive = GTK_PARENT_SENSITIVE;
2167
2168       old_state = GTK_WIDGET_STATE (widget);
2169
2170       gtk_widget_propagate_state (widget, &data);
2171       if (old_state != GTK_WIDGET_STATE (widget))
2172         gtk_widget_queue_draw (widget);
2173     }
2174 }
2175
2176 /*****************************************
2177  * gtk_widget_set_sensitive:
2178  *
2179  *   arguments:
2180  *     widget
2181  *     boolean value for sensitivity
2182  *
2183  *   results:
2184  *****************************************/
2185
2186 void
2187 gtk_widget_set_sensitive (GtkWidget *widget,
2188                           gint       sensitive)
2189 {
2190   GtkStateData data;
2191   GtkStateType old_state;
2192
2193   g_return_if_fail (widget != NULL);
2194
2195   if (sensitive)
2196     {
2197       GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE);
2198       if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE)
2199         data.state = GTK_WIDGET_SAVED_STATE (widget);
2200       else
2201         data.state = GTK_WIDGET_STATE (widget);
2202     }
2203   else
2204     {
2205       GTK_WIDGET_UNSET_FLAGS (widget, GTK_SENSITIVE);
2206       data.state = GTK_WIDGET_STATE (widget);
2207     }
2208
2209   if (widget->parent)
2210     data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2211   else
2212     data.parent_sensitive = GTK_PARENT_SENSITIVE;
2213
2214   old_state = GTK_WIDGET_STATE (widget);
2215   gtk_widget_propagate_state (widget, &data);
2216   if (old_state != GTK_WIDGET_STATE (widget))
2217     gtk_widget_queue_draw (widget);
2218 }
2219
2220 /*****************************************
2221  * gtk_widget_set_parent:
2222  *
2223  *   arguments:
2224  *
2225  *   results:
2226  *****************************************/
2227
2228 void
2229 gtk_widget_set_parent (GtkWidget *widget,
2230                        GtkWidget *parent)
2231 {
2232   GtkStyle *style;
2233   GtkStateData data;
2234
2235   g_return_if_fail (widget != NULL);
2236   g_assert (widget->parent == NULL);
2237   g_return_if_fail (parent != NULL);
2238
2239   gtk_widget_ref (widget);
2240   gtk_object_sink (GTK_OBJECT(widget));
2241   widget->parent = parent;
2242
2243   if (GTK_WIDGET_STATE (parent) != GTK_STATE_NORMAL)
2244     data.state = GTK_WIDGET_STATE (parent);
2245   else
2246     data.state = GTK_WIDGET_STATE (widget);
2247   data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (parent);
2248
2249   gtk_widget_propagate_state (widget, &data);
2250
2251   while (parent->parent != NULL)
2252     parent = parent->parent;
2253
2254   if (GTK_WIDGET_TOPLEVEL (parent))
2255     {
2256       if (!GTK_WIDGET_USER_STYLE (widget))
2257         {
2258           style = gtk_rc_get_style (widget);
2259           if (style != widget->style)
2260             gtk_widget_set_style_internal (widget, style);
2261         }
2262
2263       if (GTK_IS_CONTAINER (widget))
2264         gtk_container_foreach (GTK_CONTAINER (widget),
2265                                gtk_widget_set_style_recurse,
2266                                NULL);
2267     }
2268 }
2269
2270 /*************************************************************
2271  * gtk_widget_set_parent_window:
2272  *     Set a non default parent window for widget
2273  *
2274  *   arguments:
2275  *     widget:
2276  *     parent_window
2277  *
2278  *   results:
2279  *************************************************************/
2280
2281 void
2282 gtk_widget_set_parent_window   (GtkWidget           *widget,
2283                                 GdkWindow           *parent_window)
2284 {
2285   GdkWindow *old_parent_window;
2286
2287   g_return_if_fail (widget != NULL);
2288
2289   old_parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2290                                            parent_window_key);
2291
2292   if (parent_window != old_parent_window)
2293     {
2294       gtk_object_set_data (GTK_OBJECT (widget), parent_window_key,
2295                            parent_window);
2296       if (old_parent_window)
2297         gdk_window_unref (old_parent_window);
2298       if (parent_window)
2299         gdk_window_ref (parent_window);
2300     }
2301 }
2302
2303 /*************************************************************
2304  * gtk_widget_get_parent_window:
2305  *     Get widget's parent window
2306  *
2307  *   arguments:
2308  *     widget:
2309  *
2310  *   results:
2311  *     parent window
2312  *************************************************************/
2313
2314 GdkWindow *
2315 gtk_widget_get_parent_window   (GtkWidget           *widget)
2316 {
2317   GdkWindow *parent_window;
2318
2319   g_return_val_if_fail (widget != NULL, NULL);
2320
2321   parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2322                                        parent_window_key);
2323
2324   return (parent_window != NULL) ? parent_window : widget->parent->window;
2325 }
2326
2327
2328 /*****************************************
2329  * gtk_widget_set_style:
2330  *
2331  *   arguments:
2332  *
2333  *   results:
2334  *****************************************/
2335
2336 void
2337 gtk_widget_set_style (GtkWidget *widget,
2338                       GtkStyle  *style)
2339 {
2340   g_return_if_fail (widget != NULL);
2341
2342   GTK_PRIVATE_SET_FLAGS (widget, GTK_USER_STYLE);
2343   gtk_widget_set_style_internal (widget, style);
2344 }
2345
2346 /*****************************************
2347  * gtk_widget_set_uposition:
2348  *
2349  *   arguments:
2350  *
2351  *   results:
2352  *****************************************/
2353
2354 void
2355 gtk_widget_set_uposition (GtkWidget *widget,
2356                           gint       x,
2357                           gint       y)
2358 {
2359   GtkWidgetAuxInfo *aux_info;
2360
2361   g_return_if_fail (widget != NULL);
2362
2363   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2364   if (!aux_info)
2365     {
2366       aux_info = gtk_widget_aux_info_new ();
2367       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2368     }
2369
2370   if (x > -2)
2371     aux_info->x = x;
2372   if (y > -2)
2373     aux_info->y = y;
2374
2375   if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
2376       (aux_info->x != -1) && (aux_info->y != -1))
2377     {
2378       gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
2379       gdk_window_move (widget->window, aux_info->x, aux_info->y);
2380     }
2381
2382   if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
2383     gtk_widget_size_allocate (widget, &widget->allocation);
2384 }
2385
2386 /*****************************************
2387  * gtk_widget_set_usize:
2388  *
2389  *   arguments:
2390  *
2391  *   results:
2392  *****************************************/
2393
2394 void
2395 gtk_widget_set_usize (GtkWidget *widget,
2396                       gint       width,
2397                       gint       height)
2398 {
2399   GtkWidgetAuxInfo *aux_info;
2400
2401   g_return_if_fail (widget != NULL);
2402
2403   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2404   if (!aux_info)
2405     {
2406       aux_info = gtk_widget_aux_info_new ();
2407       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2408     }
2409
2410   if (width > -1)
2411     aux_info->width = width;
2412   if (height > -1)
2413     aux_info->height = height;
2414
2415   if (GTK_WIDGET_VISIBLE (widget))
2416     gtk_widget_queue_resize (widget);
2417 }
2418
2419 /*****************************************
2420  * gtk_widget_set_events:
2421  *
2422  *   arguments:
2423  *
2424  *   results:
2425  *****************************************/
2426
2427 void
2428 gtk_widget_set_events (GtkWidget *widget,
2429                        gint       events)
2430 {
2431   gint *eventp;
2432
2433   g_return_if_fail (widget != NULL);
2434   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
2435   g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
2436
2437   eventp = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2438
2439   if (events)
2440     {
2441       if (!eventp)
2442         eventp = g_new (gint, 1);
2443
2444       *eventp = events;
2445       gtk_object_set_data (GTK_OBJECT (widget), event_key, eventp);
2446     }
2447   else
2448     {
2449       if (eventp)
2450         g_free (eventp);
2451
2452       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
2453     }
2454 }
2455
2456 /*****************************************
2457  * gtk_widget_set_extension_events:
2458  *
2459  *   arguments:
2460  *
2461  *   results:
2462  *****************************************/
2463
2464 void
2465 gtk_widget_set_extension_events (GtkWidget *widget,
2466                                  GdkExtensionMode mode)
2467 {
2468   GdkExtensionMode *modep;
2469
2470   g_return_if_fail (widget != NULL);
2471
2472   modep = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2473
2474   if (!modep)
2475     modep = g_new (GdkExtensionMode, 1);
2476
2477   *modep = mode;
2478   gtk_object_set_data (GTK_OBJECT (widget), extension_event_key, modep);
2479 }
2480
2481
2482 /*****************************************
2483  * gtk_widget_get_toplevel:
2484  *
2485  *   arguments:
2486  *
2487  *   results:
2488  *****************************************/
2489
2490 GtkWidget*
2491 gtk_widget_get_toplevel (GtkWidget *widget)
2492 {
2493   g_return_val_if_fail (widget != NULL, NULL);
2494
2495   while (widget->parent)
2496     widget = widget->parent;
2497
2498   return widget;
2499 }
2500
2501 /*****************************************
2502  * gtk_widget_get_ancestor:
2503  *
2504  *   arguments:
2505  *
2506  *   results:
2507  *****************************************/
2508
2509 GtkWidget*
2510 gtk_widget_get_ancestor (GtkWidget *widget,
2511                          gint       type)
2512 {
2513   g_return_val_if_fail (widget != NULL, NULL);
2514
2515   while (widget && !gtk_type_is_a (GTK_WIDGET_TYPE (widget), type))
2516     widget = widget->parent;
2517
2518   if (!(widget && gtk_type_is_a (GTK_WIDGET_TYPE (widget), type)))
2519     return NULL;
2520
2521   return widget;
2522 }
2523
2524 /*****************************************
2525  * gtk_widget_get_colormap:
2526  *
2527  *   arguments:
2528  *
2529  *   results:
2530  *****************************************/
2531
2532 GdkColormap*
2533 gtk_widget_get_colormap (GtkWidget *widget)
2534 {
2535   GdkColormap *colormap;
2536
2537   g_return_val_if_fail (widget != NULL, NULL);
2538
2539   if (!widget->window)
2540     {
2541       colormap = gtk_object_get_data (GTK_OBJECT (widget), colormap_key);
2542       if (colormap)
2543         return colormap;
2544       return gtk_widget_get_default_colormap ();
2545     }
2546
2547   return gdk_window_get_colormap (widget->window);
2548 }
2549
2550 /*****************************************
2551  * gtk_widget_get_visual:
2552  *
2553  *   arguments:
2554  *
2555  *   results:
2556  *****************************************/
2557
2558 GdkVisual*
2559 gtk_widget_get_visual (GtkWidget *widget)
2560 {
2561   GdkVisual *visual;
2562
2563   g_return_val_if_fail (widget != NULL, NULL);
2564
2565   if (!widget->window)
2566     {
2567       visual = gtk_object_get_data (GTK_OBJECT (widget), visual_key);
2568       if (visual)
2569         return visual;
2570       return gtk_widget_get_default_visual ();
2571     }
2572
2573   return gdk_window_get_visual (widget->window);
2574 }
2575
2576 /*****************************************
2577  * gtk_widget_get_style:
2578  *
2579  *   arguments:
2580  *
2581  *   results:
2582  *****************************************/
2583
2584 GtkStyle*
2585 gtk_widget_get_style (GtkWidget *widget)
2586 {
2587   g_return_val_if_fail (widget != NULL, NULL);
2588
2589   return widget->style;
2590 }
2591
2592 /*****************************************
2593  * gtk_widget_get_events:
2594  *
2595  *   arguments:
2596  *
2597  *   results:
2598  *****************************************/
2599
2600 gint
2601 gtk_widget_get_events (GtkWidget *widget)
2602 {
2603   gint *events;
2604
2605   g_return_val_if_fail (widget != NULL, 0);
2606
2607   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2608   if (events)
2609     return *events;
2610
2611   return 0;
2612 }
2613
2614 /*****************************************
2615  * gtk_widget_get_extension_events:
2616  *
2617  *   arguments:
2618  *
2619  *   results:
2620  *****************************************/
2621
2622 GdkExtensionMode
2623 gtk_widget_get_extension_events (GtkWidget *widget)
2624 {
2625   GdkExtensionMode *mode;
2626
2627   g_return_val_if_fail (widget != NULL, 0);
2628
2629   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2630   if (mode)
2631     return *mode;
2632
2633   return 0;
2634 }
2635
2636 /*****************************************
2637  * gtk_widget_get_pointer:
2638  *
2639  *   arguments:
2640  *
2641  *   results:
2642  *****************************************/
2643
2644 void
2645 gtk_widget_get_pointer (GtkWidget *widget,
2646                         gint      *x,
2647                         gint      *y)
2648 {
2649   g_return_if_fail (widget != NULL);
2650
2651   if (x)
2652     *x = -1;
2653   if (y)
2654     *y = -1;
2655
2656   if (GTK_WIDGET_REALIZED (widget))
2657     {
2658       gdk_window_get_pointer (widget->window, x, y, NULL);
2659
2660       if (GTK_WIDGET_NO_WINDOW (widget))
2661         {
2662           if (x)
2663             *x -= widget->allocation.x;
2664           if (y)
2665             *y -= widget->allocation.y;
2666         }
2667     }
2668 }
2669
2670 /*****************************************
2671  * gtk_widget_is_ancestor:
2672  *
2673  *   arguments:
2674  *
2675  *   results:
2676  *****************************************/
2677
2678 gint
2679 gtk_widget_is_ancestor (GtkWidget *widget,
2680                         GtkWidget *ancestor)
2681 {
2682   g_return_val_if_fail (widget != NULL, FALSE);
2683   g_return_val_if_fail (ancestor != NULL, FALSE);
2684
2685   while (widget)
2686     {
2687       if (widget->parent == ancestor)
2688         return TRUE;
2689       widget = widget->parent;
2690     }
2691
2692   return FALSE;
2693 }
2694
2695 /*****************************************
2696  * gtk_widget_is_child:
2697  *
2698  *   arguments:
2699  *
2700  *   results:
2701  *****************************************/
2702
2703 gint
2704 gtk_widget_is_child (GtkWidget *widget,
2705                      GtkWidget *child)
2706 {
2707   g_return_val_if_fail (widget != NULL, FALSE);
2708   g_return_val_if_fail (child != NULL, FALSE);
2709
2710   return (child->parent == widget);
2711 }
2712
2713 /*****************************************
2714  * gtk_widget_push_colormap:
2715  *
2716  *   arguments:
2717  *
2718  *   results:
2719  *****************************************/
2720
2721 void
2722 gtk_widget_push_colormap (GdkColormap *cmap)
2723 {
2724   colormap_stack = g_slist_prepend (colormap_stack, cmap);
2725 }
2726
2727 /*****************************************
2728  * gtk_widget_push_visual:
2729  *
2730  *   arguments:
2731  *
2732  *   results:
2733  *****************************************/
2734
2735 void
2736 gtk_widget_push_visual (GdkVisual *visual)
2737 {
2738   visual_stack = g_slist_prepend (visual_stack, visual);
2739 }
2740
2741 /*****************************************
2742  * gtk_widget_push_style:
2743  *
2744  *   arguments:
2745  *
2746  *   results:
2747  *****************************************/
2748
2749 void
2750 gtk_widget_push_style (GtkStyle *style)
2751 {
2752   gtk_style_ref (style);
2753   style_stack = g_slist_prepend (style_stack, style);
2754 }
2755
2756 /*****************************************
2757  * gtk_widget_pop_colormap:
2758  *
2759  *   arguments:
2760  *
2761  *   results:
2762  *****************************************/
2763
2764 void
2765 gtk_widget_pop_colormap ()
2766 {
2767   GSList *tmp;
2768
2769   if (colormap_stack)
2770     {
2771       tmp = colormap_stack;
2772       colormap_stack = colormap_stack->next;
2773       g_slist_free_1 (tmp);
2774     }
2775 }
2776
2777 /*****************************************
2778  * gtk_widget_pop_visual:
2779  *
2780  *   arguments:
2781  *
2782  *   results:
2783  *****************************************/
2784
2785 void
2786 gtk_widget_pop_visual ()
2787 {
2788   GSList *tmp;
2789
2790   if (visual_stack)
2791     {
2792       tmp = visual_stack;
2793       visual_stack = visual_stack->next;
2794       g_slist_free_1 (tmp);
2795     }
2796 }
2797
2798 /*****************************************
2799  * gtk_widget_pop_style:
2800  *
2801  *   arguments:
2802  *
2803  *   results:
2804  *****************************************/
2805
2806 void
2807 gtk_widget_pop_style ()
2808 {
2809   GSList *tmp;
2810
2811   if (style_stack)
2812     {
2813       tmp = style_stack;
2814       style_stack = style_stack->next;
2815       gtk_style_unref ((GtkStyle*) tmp->data);
2816       g_slist_free_1 (tmp);
2817     }
2818 }
2819
2820 /*****************************************
2821  * gtk_widget_set_default_colormap:
2822  *
2823  *   arguments:
2824  *
2825  *   results:
2826  *****************************************/
2827
2828 void
2829 gtk_widget_set_default_colormap (GdkColormap *colormap)
2830 {
2831   if (default_colormap != colormap)
2832     {
2833       if (default_colormap)
2834         gdk_colormap_unref (default_colormap);
2835       default_colormap = colormap;
2836       if (default_colormap)
2837         gdk_colormap_ref (default_colormap);
2838     }
2839 }
2840
2841 /*****************************************
2842  * gtk_widget_set_default_visual:
2843  *
2844  *   arguments:
2845  *
2846  *   results:
2847  *****************************************/
2848
2849 void
2850 gtk_widget_set_default_visual (GdkVisual *visual)
2851 {
2852   default_visual = visual;
2853 }
2854
2855 /*****************************************
2856  * gtk_widget_set_default_style:
2857  *
2858  *   arguments:
2859  *
2860  *   results:
2861  *****************************************/
2862
2863 void
2864 gtk_widget_set_default_style (GtkStyle *style)
2865 {
2866    if (style != default_style)
2867      {
2868        if (default_style)
2869          gtk_style_unref (default_style);
2870        default_style = style;
2871        if (default_style)
2872          gtk_style_ref (default_style);
2873      }
2874 }
2875
2876 /* Basically, send a message to all toplevel windows telling them
2877  * that a new _GTK_STYLE_COLORS property is available on the root
2878  * window
2879  */
2880 void
2881 gtk_widget_propagate_default_style (void)
2882 {
2883   GdkEventClient sev;
2884   int i;
2885
2886   /* Set the property on the root window */
2887   gdk_property_change(GDK_ROOT_PARENT(),
2888                       gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE),
2889                       gdk_atom_intern("STRING", FALSE),
2890                       8*sizeof(gushort),
2891                       GDK_PROP_MODE_REPLACE,
2892                       (guchar *)gtk_widget_get_default_style(),
2893                       GTK_STYLE_NUM_STYLECOLORS() * sizeof(GdkColor));
2894
2895   for(i = 0; i < 5; i++)
2896     sev.data.l[i] = 0;
2897   sev.data_format = 32;
2898   sev.message_type = gdk_atom_intern ("_GTK_STYLE_CHANGED", FALSE);
2899   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
2900 }
2901
2902 /*****************************************
2903  * gtk_widget_get_default_colormap:
2904  *
2905  *   arguments:
2906  *
2907  *   results:
2908  *****************************************/
2909
2910 GdkColormap*
2911 gtk_widget_get_default_colormap ()
2912 {
2913   if (!default_colormap)
2914     default_colormap = gdk_colormap_get_system ();
2915
2916   return default_colormap;
2917 }
2918
2919 /*****************************************
2920  * gtk_widget_get_default_visual:
2921  *
2922  *   arguments:
2923  *
2924  *   results:
2925  *****************************************/
2926
2927 GdkVisual*
2928 gtk_widget_get_default_visual ()
2929 {
2930   if (!default_visual)
2931     default_visual = gdk_visual_get_system ();
2932
2933   return default_visual;
2934 }
2935
2936 /*****************************************
2937  * gtk_widget_get_default_style:
2938  *
2939  *   arguments:
2940  *
2941  *   results:
2942  *****************************************/
2943
2944 GtkStyle*
2945 gtk_widget_get_default_style ()
2946 {
2947   if (!default_style)
2948     {
2949       default_style = gtk_style_new ();
2950       gtk_style_ref (default_style);
2951     }
2952
2953   return default_style;
2954 }
2955
2956
2957 /*****************************************
2958  * gtk_widget_marshal_signal_1:
2959  *
2960  *   arguments:
2961  *
2962  *   results:
2963  *****************************************/
2964
2965 static void
2966 gtk_widget_marshal_signal_1 (GtkObject      *object,
2967                              GtkSignalFunc   func,
2968                              gpointer        func_data,
2969                              GtkArg         *args)
2970 {
2971   GtkWidgetSignal1 rfunc;
2972
2973   rfunc = (GtkWidgetSignal1) func;
2974
2975   (* rfunc) (object, GTK_VALUE_POINTER (args[0]), func_data);
2976 }
2977
2978 /*****************************************
2979  * gtk_widget_marshal_signal_2:
2980  *
2981  *   arguments:
2982  *
2983  *   results:
2984  *****************************************/
2985
2986 static void
2987 gtk_widget_marshal_signal_2 (GtkObject      *object,
2988                              GtkSignalFunc   func,
2989                              gpointer        func_data,
2990                              GtkArg         *args)
2991 {
2992   GtkWidgetSignal2 rfunc;
2993   gint *return_val;
2994
2995   rfunc = (GtkWidgetSignal2) func;
2996   return_val = GTK_RETLOC_BOOL (args[3]);
2997
2998   *return_val = (* rfunc) (object, GTK_VALUE_STRING (args[0]),
2999                            GTK_VALUE_CHAR (args[1]), GTK_VALUE_INT (args[2]),
3000                            func_data);
3001 }
3002
3003 /*****************************************
3004  * gtk_widget_marshal_signal_3:
3005  *
3006  *   arguments:
3007  *
3008  *   results:
3009  *****************************************/
3010
3011 static void
3012 gtk_widget_marshal_signal_3 (GtkObject      *object,
3013                              GtkSignalFunc   func,
3014                              gpointer        func_data,
3015                              GtkArg         *args)
3016 {
3017   GtkWidgetSignal3 rfunc;
3018
3019   rfunc = (GtkWidgetSignal3) func;
3020
3021   (* rfunc) (object, GTK_VALUE_STRING (args[0]), func_data);
3022 }
3023
3024 /*****************************************
3025  * gtk_widget_marshal_signal_4:
3026  *
3027  *   arguments:
3028  *
3029  *   results:
3030  *****************************************/
3031
3032 static void
3033 gtk_widget_marshal_signal_4 (GtkObject      *object,
3034                              GtkSignalFunc   func,
3035                              gpointer        func_data,
3036                              GtkArg         *args)
3037 {
3038   GtkWidgetSignal4 rfunc;
3039   gint *return_val;
3040
3041   rfunc = (GtkWidgetSignal4) func;
3042   return_val = GTK_RETLOC_BOOL (args[1]);
3043
3044   *return_val = (* rfunc) (object, GTK_VALUE_BOXED (args[0]), func_data);
3045 }
3046
3047 /*****************************************
3048  * gtk_widget_marshal_signal_5:
3049  *
3050  *   arguments:
3051  *
3052  *   results:
3053  *****************************************/
3054
3055 static void
3056 gtk_widget_marshal_signal_5 (GtkObject      *object,
3057                              GtkSignalFunc   func,
3058                              gpointer        func_data,
3059                              GtkArg         *args)
3060 {
3061   GtkWidgetSignal5 rfunc;
3062   gint *return_val;
3063
3064   rfunc = (GtkWidgetSignal5) func;
3065   return_val = GTK_RETLOC_BOOL (args[1]);
3066
3067   (* rfunc) (object, GTK_VALUE_UINT (args[0]), func_data);
3068 }
3069
3070 static void
3071 gtk_widget_real_destroy (GtkObject *object)
3072 {
3073   GtkWidget *widget = GTK_WIDGET (object);
3074
3075   gtk_widget_ref (widget);
3076
3077   if (GTK_WIDGET_REDRAW_PENDING (widget))
3078     {
3079       gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
3080       GTK_PRIVATE_UNSET_FLAGS (widget, GTK_REDRAW_PENDING);
3081     }
3082
3083   if (GTK_CONTAINER_RESIZE_PENDING (widget))
3084     {
3085       gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
3086       GTK_PRIVATE_UNSET_FLAGS (widget, GTK_RESIZE_PENDING);
3087     }
3088
3089   if (GTK_WIDGET_RESIZE_NEEDED (widget))
3090     {
3091       GtkWidget *toplevel;
3092
3093       toplevel = gtk_widget_get_toplevel (widget);
3094       GTK_CONTAINER (toplevel)->resize_widgets =
3095         g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
3096       GTK_PRIVATE_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED);
3097     }
3098
3099   if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
3100     gtk_widget_shape_combine_mask (widget, NULL, -1, -1);
3101
3102   gtk_grab_remove (widget);
3103   gtk_selection_remove_all (widget);
3104   gtk_widget_unrealize (widget);
3105
3106   if (widget->parent)
3107     gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
3108
3109   if (GTK_OBJECT_CLASS (parent_class)->destroy)
3110     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
3111
3112   gtk_widget_unref (widget);
3113 }
3114
3115 static void
3116 gtk_widget_real_finalize (GtkObject *object)
3117 {
3118   GtkWidget *widget;
3119   GtkWidgetAuxInfo *aux_info;
3120   gint *events;
3121   GdkExtensionMode *mode;
3122
3123   g_return_if_fail (object != NULL);
3124   g_return_if_fail (GTK_IS_WIDGET (object));
3125
3126   widget = GTK_WIDGET (object);
3127
3128   if (widget->name)
3129     {
3130       g_free (widget->name);
3131       widget->name = NULL;
3132     }
3133
3134   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
3135   if (aux_info)
3136     {
3137       gtk_widget_aux_info_destroy (aux_info);
3138       gtk_object_remove_data (GTK_OBJECT (widget), aux_info_key);
3139     }
3140
3141   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
3142   if (events)
3143     {
3144       g_free (events);
3145       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
3146     }
3147
3148   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
3149   if (mode)
3150     {
3151       g_free (mode);
3152       gtk_object_remove_data (GTK_OBJECT (widget), extension_event_key);
3153     }
3154
3155   gtk_style_unref (widget->style);
3156   widget->style = NULL;
3157
3158   parent_class->finalize (object);
3159 }
3160
3161 /*****************************************
3162  * gtk_widget_real_show:
3163  *
3164  *   arguments:
3165  *
3166  *   results:
3167  *****************************************/
3168
3169 static void
3170 gtk_widget_real_show (GtkWidget *widget)
3171 {
3172   g_return_if_fail (widget != NULL);
3173   g_return_if_fail (GTK_IS_WIDGET (widget));
3174
3175   if (!GTK_WIDGET_VISIBLE (widget))
3176     {
3177       GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
3178
3179       if (widget->parent)
3180         {
3181           gtk_widget_queue_resize (widget);
3182
3183           if (GTK_WIDGET_MAPPED (widget->parent))
3184             gtk_widget_map (widget);
3185         }
3186     }
3187 }
3188
3189 /*****************************************
3190  * gtk_widget_real_hide:
3191  *
3192  *   arguments:
3193  *
3194  *   results:
3195  *****************************************/
3196
3197 static void
3198 gtk_widget_real_hide (GtkWidget *widget)
3199 {
3200   g_return_if_fail (widget != NULL);
3201   g_return_if_fail (GTK_IS_WIDGET (widget));
3202
3203   if (GTK_WIDGET_VISIBLE (widget))
3204     {
3205       GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
3206
3207       if (GTK_WIDGET_MAPPED (widget))
3208         gtk_widget_unmap (widget);
3209
3210       if (widget->parent)
3211         gtk_widget_queue_resize (widget);
3212     }
3213 }
3214
3215 /*****************************************
3216  * gtk_widget_real_map:
3217  *
3218  *   arguments:
3219  *
3220  *   results:
3221  *****************************************/
3222
3223 static void
3224 gtk_widget_real_map (GtkWidget *widget)
3225 {
3226   g_return_if_fail (widget != NULL);
3227   g_return_if_fail (GTK_IS_WIDGET (widget));
3228
3229   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
3230     {
3231       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
3232
3233       if (!GTK_WIDGET_NO_WINDOW (widget))
3234         gdk_window_show (widget->window);
3235       else
3236         gtk_widget_queue_draw (widget);
3237     }
3238 }
3239
3240 /*****************************************
3241  * gtk_widget_real_unmap:
3242  *
3243  *   arguments:
3244  *
3245  *   results:
3246  *****************************************/
3247
3248 static void
3249 gtk_widget_real_unmap (GtkWidget *widget)
3250 {
3251   g_return_if_fail (widget != NULL);
3252   g_return_if_fail (GTK_IS_WIDGET (widget));
3253
3254   if (GTK_WIDGET_MAPPED (widget))
3255     {
3256       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
3257
3258       if (GTK_WIDGET_NO_WINDOW (widget))
3259         gdk_window_clear_area (widget->window,
3260                                widget->allocation.x,
3261                                widget->allocation.y,
3262                                widget->allocation.width,
3263                                widget->allocation.height);
3264       else
3265         gdk_window_hide (widget->window);
3266     }
3267 }
3268
3269 /*****************************************
3270  * gtk_widget_real_realize:
3271  *
3272  *   arguments:
3273  *
3274  *   results:
3275  *****************************************/
3276
3277 static void
3278 gtk_widget_real_realize (GtkWidget *widget)
3279 {
3280   g_return_if_fail (widget != NULL);
3281   g_return_if_fail (GTK_IS_WIDGET (widget));
3282
3283   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
3284   if (widget->parent)
3285     {
3286       widget->window = gtk_widget_get_parent_window (widget);
3287       gdk_window_ref (widget->window);
3288     }
3289   widget->style = gtk_style_attach (widget->style, widget->window);
3290 }
3291
3292 /*****************************************
3293  * gtk_widget_real_unrealize:
3294  *
3295  *   arguments:
3296  *
3297  *   results:
3298  *****************************************/
3299
3300 static void
3301 gtk_widget_real_unrealize (GtkWidget *widget)
3302 {
3303   g_return_if_fail (widget != NULL);
3304   g_return_if_fail (GTK_IS_WIDGET (widget));
3305
3306   if (GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_MAPPED (widget))
3307     gtk_widget_real_unmap (widget);
3308
3309   GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
3310
3311   /* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT(widget)->klass->type));
3312    */
3313
3314   if (GTK_IS_CONTAINER (widget))
3315     gtk_container_foreach (GTK_CONTAINER (widget),
3316                            (GtkCallback)gtk_widget_unrealize,
3317                            NULL);
3318
3319   gtk_style_detach (widget->style);
3320   if (!GTK_WIDGET_NO_WINDOW (widget))
3321     {
3322       gdk_window_set_user_data (widget->window, NULL);
3323       gdk_window_destroy (widget->window);
3324     }
3325   else
3326     {
3327       gdk_window_unref (widget->window);
3328     }
3329   widget->window = NULL;
3330 }
3331
3332 /*****************************************
3333  * gtk_widget_real_draw:
3334  *
3335  *   arguments:
3336  *
3337  *   results:
3338  *****************************************/
3339
3340 static void
3341 gtk_widget_real_draw (GtkWidget    *widget,
3342                       GdkRectangle *area)
3343 {
3344   GdkEventExpose event;
3345
3346   g_return_if_fail (widget != NULL);
3347   g_return_if_fail (GTK_IS_WIDGET (widget));
3348   g_return_if_fail (area != NULL);
3349
3350   if (GTK_WIDGET_DRAWABLE (widget))
3351     {
3352       event.type = GDK_EXPOSE;
3353       event.window = widget->window;
3354       event.area = *area;
3355
3356       gdk_window_ref (event.window);
3357       gtk_widget_event (widget, (GdkEvent*) &event);
3358       gdk_window_unref (event.window);
3359     }
3360 }
3361
3362 /*****************************************
3363  * gtk_widget_real_queue_draw:
3364  *
3365  *   arguments:
3366  *
3367  *   results:
3368  *****************************************/
3369
3370 static gint
3371 gtk_widget_real_queue_draw (GtkWidget *widget)
3372 {
3373   g_return_val_if_fail (widget != NULL, FALSE);
3374   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3375
3376   GTK_PRIVATE_UNSET_FLAGS (widget, GTK_REDRAW_PENDING);
3377   gtk_widget_draw (widget, NULL);
3378
3379   return FALSE;
3380 }
3381
3382 /*****************************************
3383  * gtk_widget_real_queue_resize:
3384  *
3385  *   arguments:
3386  *
3387  *   results:
3388  *****************************************/
3389
3390 static gint
3391 gtk_widget_real_queue_resize (GtkWidget *widget)
3392 {
3393   g_return_val_if_fail (widget != NULL, FALSE);
3394   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3395
3396   GTK_PRIVATE_UNSET_FLAGS (widget, GTK_RESIZE_PENDING);
3397   gtk_container_need_resize (GTK_CONTAINER (widget));
3398
3399   return FALSE;
3400 }
3401
3402 /*****************************************
3403  * gtk_widget_real_size_allocate:
3404  *
3405  *   arguments:
3406  *
3407  *   results:
3408  *****************************************/
3409
3410 static void
3411 gtk_widget_real_size_allocate (GtkWidget     *widget,
3412                                GtkAllocation *allocation)
3413 {
3414   g_return_if_fail (widget != NULL);
3415   g_return_if_fail (GTK_IS_WIDGET (widget));
3416
3417   if (GTK_WIDGET_NO_WINDOW (widget) &&
3418       GTK_WIDGET_MAPPED (widget) &&
3419       ((widget->allocation.x != allocation->x) ||
3420        (widget->allocation.y != allocation->y) ||
3421        (widget->allocation.width != allocation->width) ||
3422        (widget->allocation.height != allocation->height)) &&
3423       (widget->allocation.width != 0) &&
3424       (widget->allocation.height != 0))
3425     gdk_window_clear_area (widget->window,
3426                            widget->allocation.x,
3427                            widget->allocation.y,
3428                            widget->allocation.width,
3429                            widget->allocation.height);
3430
3431   widget->allocation = *allocation;
3432
3433   if (GTK_WIDGET_REALIZED (widget) &&
3434       !GTK_WIDGET_NO_WINDOW (widget))
3435     gdk_window_move_resize (widget->window,
3436                             allocation->x, allocation->y,
3437                             allocation->width, allocation->height);
3438 }
3439
3440 /*****************************************
3441  * gtk_widget_peek_colormap:
3442  *
3443  *   arguments:
3444  *
3445  *   results:
3446  *****************************************/
3447
3448 static GdkColormap*
3449 gtk_widget_peek_colormap ()
3450 {
3451   if (colormap_stack)
3452     return (GdkColormap*) colormap_stack->data;
3453   return gtk_widget_get_default_colormap ();
3454 }
3455
3456 /*****************************************
3457  * gtk_widget_peek_visual:
3458  *
3459  *   arguments:
3460  *
3461  *   results:
3462  *****************************************/
3463
3464 static GdkVisual*
3465 gtk_widget_peek_visual ()
3466 {
3467   if (visual_stack)
3468     return (GdkVisual*) visual_stack->data;
3469   return gtk_widget_get_default_visual ();
3470 }
3471
3472 /*****************************************
3473  * gtk_widget_peek_style:
3474  *
3475  *   arguments:
3476  *
3477  *   results:
3478  *****************************************/
3479
3480 static GtkStyle*
3481 gtk_widget_peek_style ()
3482 {
3483   if (style_stack)
3484     return (GtkStyle*) style_stack->data;
3485   return gtk_widget_get_default_style ();
3486 }
3487
3488 /*************************************************************
3489  * gtk_widget_propagate_state:
3490  *     Propagate a change in the widgets state down the tree
3491  *
3492  *   arguments:
3493  *     widget
3494  *     GtkStateData: state
3495  *                   parent_sensitive
3496  *
3497  *   results:
3498  *************************************************************/
3499
3500 void
3501 gtk_widget_propagate_state (GtkWidget           *widget,
3502                             GtkStateData        *data)
3503 {
3504   guint8 old_state;
3505
3506   /* don't call this function with state=GTK_STATE_INSENSITIVE,
3507    * parent_sensitive=TRUE and a sensitive widget
3508    */
3509
3510   old_state = GTK_WIDGET_STATE (widget);
3511
3512   if (data->parent_sensitive)
3513     {
3514       GTK_WIDGET_SET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3515
3516       if (GTK_WIDGET_IS_SENSITIVE (widget))
3517         GTK_WIDGET_STATE (widget) = data->state;
3518       else
3519         {
3520           GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3521           if (data->state != GTK_STATE_INSENSITIVE)
3522             GTK_WIDGET_SAVED_STATE (widget) = data->state;
3523         }
3524     }
3525   else
3526     {
3527       GTK_WIDGET_UNSET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3528       GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3529       if (data->state != GTK_STATE_INSENSITIVE)
3530         GTK_WIDGET_SAVED_STATE (widget) = data->state;
3531     }
3532
3533   if (GTK_WIDGET_HAS_FOCUS (widget) && !GTK_WIDGET_IS_SENSITIVE (widget))
3534     {
3535       GtkWidget *window;
3536
3537       window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
3538       if (window)
3539         gtk_window_set_focus (GTK_WINDOW (window), NULL);
3540     }
3541
3542   if (old_state != GTK_WIDGET_STATE (widget))
3543     {
3544       gtk_widget_ref (widget);
3545       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[STATE_CHANGED], old_state);
3546
3547       if (GTK_IS_CONTAINER (widget))
3548         {
3549           data->parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
3550           data->state = GTK_WIDGET_STATE (widget);
3551           gtk_container_foreach (GTK_CONTAINER (widget),
3552                                  (GtkCallback) gtk_widget_propagate_state,
3553                                  data);
3554         }
3555       gtk_widget_unref (widget);
3556     }
3557 }
3558
3559 /*****************************************
3560  * gtk_widget_draw_children_recurse:
3561  *
3562  *   arguments:
3563  *
3564  *   results:
3565  *****************************************/
3566
3567 static void
3568 gtk_widget_draw_children_recurse (GtkWidget *widget,
3569                                   gpointer   client_data)
3570 {
3571   gtk_widget_draw (widget, NULL);
3572   gtk_widget_draw_children (widget);
3573 }
3574
3575 /*****************************************
3576  * gtk_widget_set_style_internal:
3577  *
3578  *   arguments:
3579  *
3580  *   results:
3581  *****************************************/
3582
3583 static void
3584 gtk_widget_set_style_internal (GtkWidget *widget,
3585                                GtkStyle  *style)
3586 {
3587   GtkRequisition old_requisition;
3588
3589   g_return_if_fail (widget != NULL);
3590
3591   if (widget->style != style)
3592     {
3593       if (GTK_WIDGET_REALIZED (widget))
3594         gtk_style_detach (widget->style);
3595
3596       gtk_style_unref (widget->style);
3597       widget->style = style;
3598       gtk_style_ref (widget->style);
3599
3600       if (GTK_WIDGET_REALIZED (widget))
3601         widget->style = gtk_style_attach (widget->style, widget->window);
3602
3603       if (widget->parent)
3604         {
3605           old_requisition = widget->requisition;
3606           gtk_widget_size_request (widget, &widget->requisition);
3607
3608           if ((old_requisition.width != widget->requisition.width) ||
3609               (old_requisition.height != widget->requisition.height))
3610             gtk_widget_queue_resize (widget);
3611           else if (GTK_WIDGET_DRAWABLE (widget))
3612             gtk_widget_queue_draw (widget);
3613         }
3614     }
3615 }
3616
3617 /*****************************************
3618  * gtk_widget_set_style_recurse:
3619  *
3620  *   arguments:
3621  *
3622  *   results:
3623  *****************************************/
3624
3625 static void
3626 gtk_widget_set_style_recurse (GtkWidget *widget,
3627                               gpointer   client_data)
3628 {
3629   GtkStyle *style;
3630
3631   style = gtk_rc_get_style (widget);
3632   if (style != widget->style)
3633     gtk_widget_set_style_internal (widget, style);
3634
3635   if (GTK_IS_CONTAINER (widget))
3636     gtk_container_foreach (GTK_CONTAINER (widget),
3637                            gtk_widget_set_style_recurse,
3638                            NULL);
3639 }
3640
3641 /*****************************************
3642  * gtk_widget_aux_info_new:
3643  *
3644  *   arguments:
3645  *
3646  *   results:
3647  *****************************************/
3648
3649 static GtkWidgetAuxInfo*
3650 gtk_widget_aux_info_new ()
3651 {
3652   GtkWidgetAuxInfo *aux_info;
3653
3654   if (!aux_info_mem_chunk)
3655     aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk",
3656                                           sizeof (GtkWidgetAuxInfo),
3657                                           1024, G_ALLOC_AND_FREE);
3658
3659   aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk);
3660
3661   aux_info->x = -1;
3662   aux_info->y = -1;
3663   aux_info->width = 0;
3664   aux_info->height = 0;
3665
3666   return aux_info;
3667 }
3668
3669 /*****************************************
3670  * gtk_widget_aux_info_destroy:
3671  *
3672  *   arguments:
3673  *
3674  *   results:
3675  *****************************************/
3676
3677 static void
3678 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
3679 {
3680   g_return_if_fail (aux_info != NULL);
3681
3682   g_mem_chunk_free (aux_info_mem_chunk, aux_info);
3683 }
3684
3685 /*****************************************
3686  * gtk_widget_shape_combine_mask:
3687  *   set a shape for this widgets' gdk window, this allows for
3688  *   transparent windows etc., see gdk_window_shape_combine_mask
3689  *   for more information
3690  *
3691  *   arguments:
3692  *
3693  *   results:
3694  *****************************************/
3695 void
3696 gtk_widget_shape_combine_mask (GtkWidget *widget,
3697                                GdkBitmap *shape_mask,
3698                                gint       offset_x,
3699                                gint       offset_y)
3700 {
3701   GtkWidgetShapeInfo* shape_info;
3702
3703   g_return_if_fail (widget != NULL);
3704   /*  set_shape doesn't work on widgets without gdk window */
3705   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
3706
3707   if (!shape_mask)
3708     {
3709       GTK_PRIVATE_UNSET_FLAGS (widget, GTK_HAS_SHAPE_MASK);
3710
3711       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3712       gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key);
3713       g_free (shape_info);
3714
3715       if (widget->window)
3716         {
3717           /* FIXME: we need gdk code here that removes the shape from a window
3718            */
3719         }
3720     }
3721   else
3722     {
3723       GTK_PRIVATE_SET_FLAGS (widget, GTK_HAS_SHAPE_MASK);
3724
3725       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3726       if (!shape_info)
3727         {
3728           shape_info = g_new (GtkWidgetShapeInfo, 1);
3729           gtk_object_set_data (GTK_OBJECT (widget), shape_info_key, shape_info);
3730         }
3731       shape_info->shape_mask = shape_mask;
3732       shape_info->offset_x = offset_x;
3733       shape_info->offset_y = offset_y;
3734
3735       /* set shape if widget has a gdk window allready.
3736        * otherwise the shape is scheduled to be set by gtk_widget_realize.
3737        */
3738       if (widget->window)
3739         gdk_window_shape_combine_mask (widget->window, shape_mask,
3740                                        offset_x, offset_y);
3741     }
3742 }
3743
3744 /*****************************************
3745  * gtk_widget_dnd_drag_add:
3746  *   when you get a DRAG_ENTER event, you can use this
3747  *   to tell Gtk ofother widgets that are to be dragged as well
3748  *
3749  *   arguments:
3750  *
3751  *   results:
3752  *****************************************/
3753 void
3754 gtk_widget_dnd_drag_add (GtkWidget *widget)
3755 {
3756 }
3757
3758 /*****************************************
3759  * gtk_widget_dnd_drag_set:
3760  *   these two functions enable drag and/or drop on a
3761  *   widget and also let Gtk know what data types will be accepted
3762  *   use MIME type naming,plus tacking "URL:" on the front for link
3763  *   dragging
3764  *
3765  *
3766  *   arguments:
3767  *
3768  *   results:
3769  *****************************************/
3770 void
3771 gtk_widget_dnd_drag_set (GtkWidget   *widget,
3772                          guint8       drag_enable,
3773                          gchar      **type_accept_list,
3774                          guint        numtypes)
3775 {
3776   g_return_if_fail(widget != NULL);
3777
3778   if (!widget->window)
3779     gtk_widget_realize (widget);
3780
3781   g_return_if_fail (widget->window != NULL);
3782   gdk_window_dnd_drag_set (widget->window,
3783                            drag_enable,
3784                            type_accept_list,
3785                            numtypes);
3786 }
3787
3788 /*****************************************
3789  * gtk_widget_dnd_drop_set:
3790  *
3791  *   arguments:
3792  *
3793  *   results:
3794  *****************************************/
3795 void
3796 gtk_widget_dnd_drop_set (GtkWidget   *widget,
3797                          guint8       drop_enable,
3798                          gchar      **type_accept_list,
3799                          guint        numtypes,
3800                          guint8       is_destructive_operation)
3801 {
3802   g_return_if_fail(widget != NULL);
3803
3804   if (!widget->window)
3805     gtk_widget_realize (widget);
3806
3807   g_return_if_fail (widget->window != NULL);
3808   gdk_window_dnd_drop_set (widget->window,
3809                            drop_enable,
3810                            type_accept_list,
3811                            numtypes,
3812                            is_destructive_operation);
3813 }
3814
3815 /*****************************************
3816  * gtk_widget_dnd_data_set:
3817  *
3818  *   arguments:
3819  *
3820  *   results:
3821  *****************************************/
3822 void
3823 gtk_widget_dnd_data_set (GtkWidget   *widget,
3824                          GdkEvent    *event,
3825                          gpointer     data,
3826                          gulong       data_numbytes)
3827 {
3828   g_return_if_fail (widget != NULL);
3829   g_return_if_fail (widget->window != NULL);
3830
3831   gdk_window_dnd_data_set (widget->window, event, data, data_numbytes);
3832 }