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 /*****************************************
 957  * gtk_widget_newv:
 958  *
 959  *   arguments:
 960  *
 961  *   results:
 962  *****************************************/
 963
 964 GtkWidget*
 965 gtk_widget_newv (guint   type,
 966                  guint   nargs,
 967                  GtkArg *args)
 968 {
 969   g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
 970
 971   return GTK_WIDGET (gtk_object_newv (type, nargs, args));
 972 }
 973
 974 /*****************************************
 975  * gtk_widget_get:
 976  *
 977  *   arguments:
 978  *
 979  *   results:
 980  *****************************************/
 981
 982 void
 983 gtk_widget_get (GtkWidget       *widget,
 984                 GtkArg          *arg)
 985 {
 986   g_return_if_fail (widget != NULL);
 987   g_return_if_fail (arg != NULL);
 988
 989   gtk_object_getv (GTK_OBJECT (widget), 1, arg);
 990 }
 991
 992 /*****************************************
 993  * gtk_widget_getv:
 994  *
 995  *   arguments:
 996  *
 997  *   results:
 998  *****************************************/
 999
1000 void
1001 gtk_widget_getv (GtkWidget      *widget,
1002                  guint           nargs,
1003                  GtkArg         *args)
1004 {
1005   gtk_object_getv (GTK_OBJECT (widget), nargs, args);
1006 }
1007
1008 /*****************************************
1009  * gtk_widget_set:
1010  *
1011  *   arguments:
1012  *
1013  *   results:
1014  *****************************************/
1015
1016 void
1017 gtk_widget_set (GtkWidget *widget,
1018                 ...)
1019 {
1020   GtkArg *args;
1021   guint nargs;
1022   va_list args1;
1023   va_list args2;
1024
1025   g_return_if_fail (widget != NULL);
1026
1027   va_start (args1, widget);
1028   va_start (args2, widget);
1029
1030   args = gtk_object_collect_args (&nargs, args1, args2);
1031   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1032   g_free (args);
1033
1034   va_end (args1);
1035   va_end (args2);
1036 }
1037
1038 /*****************************************
1039  * gtk_widget_setv:
1040  *
1041  *   arguments:
1042  *
1043  *   results:
1044  *****************************************/
1045
1046 void
1047 gtk_widget_setv (GtkWidget *widget,
1048                  guint      nargs,
1049                  GtkArg    *args)
1050 {
1051   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1052 }
1053
1054 /*****************************************
1055  * gtk_widget_unparent:
1056  *   do any cleanup necessary necessary
1057  *   for setting parent = NULL.
1058  *
1059  *   arguments:
1060  *
1061  *   results:
1062  *****************************************/
1063
1064 void
1065 gtk_widget_unparent (GtkWidget *widget)
1066 {
1067   GtkWidget *toplevel;
1068   GtkWidget *child;
1069
1070   g_return_if_fail (widget != NULL);
1071   if (widget->parent == NULL)
1072     return;
1073
1074   /* keep this function in sync with gtk_menu_detach()
1075    */
1076
1077   toplevel = gtk_widget_get_toplevel (widget);
1078   if (GTK_IS_WINDOW (toplevel))
1079     {
1080       child = GTK_WINDOW (toplevel)->focus_widget;
1081
1082       while (child && child != widget)
1083         child = child->parent;
1084
1085       if (child == widget)
1086         gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
1087     }
1088
1089   if (GTK_WIDGET_RESIZE_NEEDED (widget))
1090     {
1091       GTK_CONTAINER (toplevel)->resize_widgets =
1092         g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1093       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1094     }
1095
1096   if (widget->window &&
1097       GTK_WIDGET_NO_WINDOW (widget) &&
1098       GTK_WIDGET_DRAWABLE (widget))
1099     gdk_window_clear_area (widget->window,
1100                            widget->allocation.x,
1101                            widget->allocation.y,
1102                            widget->allocation.width,
1103                            widget->allocation.height);
1104
1105   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_IN_REPARENT (widget))
1106     gtk_widget_unrealize (widget);
1107
1108   widget->parent = NULL;
1109
1110   gtk_widget_unref (widget);
1111 }
1112
1113 /*****************************************
1114  * gtk_widget_destroy:
1115  *
1116  *   arguments:
1117  *
1118  *   results:
1119  *****************************************/
1120
1121 void
1122 gtk_widget_destroy (GtkWidget *widget)
1123 {
1124   g_return_if_fail (widget != NULL);
1125   g_return_if_fail (GTK_IS_WIDGET (widget));
1126
1127   GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
1128   if (GTK_WIDGET_REALIZED (widget))
1129     gtk_widget_unrealize (widget);
1130
1131   gtk_object_destroy (GTK_OBJECT (widget));
1132 }
1133
1134 /*****************************************
1135  * gtk_widget_destroyed:
1136  *   Utility function: sets widget_pointer
1137  *   to NULL when widget is destroyed.
1138  *
1139  *   arguments:
1140  *
1141  *   results:
1142  *****************************************/
1143
1144 void
1145 gtk_widget_destroyed (GtkWidget      *widget,
1146                       GtkWidget      **widget_pointer)
1147 {
1148   /* Don't make any assumptions about the
1149    *  value of widget!
1150    *  Even check widget_pointer.
1151    */
1152   if (widget_pointer)
1153     *widget_pointer = NULL;
1154 }
1155
1156 /*****************************************
1157  * gtk_widget_show:
1158  *
1159  *   arguments:
1160  *
1161  *   results:
1162  *****************************************/
1163
1164 void
1165 gtk_widget_show (GtkWidget *widget)
1166 {
1167   g_return_if_fail (widget != NULL);
1168
1169   if (!GTK_WIDGET_VISIBLE (widget))
1170     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
1171 }
1172
1173 /*****************************************
1174  * gtk_widget_hide:
1175  *
1176  *   arguments:
1177  *
1178  *   results:
1179  *****************************************/
1180
1181 void
1182 gtk_widget_hide (GtkWidget *widget)
1183 {
1184   g_return_if_fail (widget != NULL);
1185
1186   if (GTK_WIDGET_VISIBLE (widget))
1187     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
1188 }
1189
1190 /*****************************************
1191  * gtk_widget_show_all:
1192  *
1193  *   Shows the widget and all children.
1194  *
1195  *   Container classes overwrite
1196  *   show_all and hide_all to call
1197  *   show_all (hide_all) on both themselves
1198  *   and on their child widgets.
1199  *
1200  *   arguments:
1201  *
1202  *   results:
1203  *****************************************/
1204
1205 void
1206 gtk_widget_show_all (GtkWidget *widget)
1207 {
1208   GtkWidgetClass *widget_class;
1209
1210   g_return_if_fail (widget != NULL);
1211
1212   /* show_all shouldn't be invoked through a signal,
1213      because in this case it would be quite slow - there would
1214      be a show and show_all signal emitted for every child widget.
1215    */
1216   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1217   widget_class->show_all (widget);
1218 }
1219
1220 /*****************************************
1221  * gtk_widget_hide_all:
1222  *
1223  *   Hides the widget and all children.
1224  *   See gtk_widget_show_all.
1225  *
1226  *   arguments:
1227  *
1228  *   results:
1229  *****************************************/
1230
1231 void
1232 gtk_widget_hide_all (GtkWidget *widget)
1233 {
1234   GtkWidgetClass *widget_class;
1235
1236   g_return_if_fail (widget != NULL);
1237   g_assert (widget->parent);
1238
1239   if (GTK_WIDGET_RESIZE_NEEDED (widget))
1240     {
1241       GtkWidget *toplevel;
1242
1243       toplevel = gtk_widget_get_toplevel (widget);
1244       if (toplevel != widget)
1245         GTK_CONTAINER (toplevel)->resize_widgets =
1246           g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1247       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1248     }
1249
1250   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1251   widget_class->hide_all (widget);
1252 }
1253
1254 /*****************************************
1255  * gtk_widget_map:
1256  *
1257  *   arguments:
1258  *
1259  *   results:
1260  *****************************************/
1261
1262 void
1263 gtk_widget_map (GtkWidget *widget)
1264 {
1265   g_return_if_fail (widget != NULL);
1266
1267   if (!GTK_WIDGET_MAPPED (widget))
1268     {
1269       if (!GTK_WIDGET_REALIZED (widget))
1270         gtk_widget_realize (widget);
1271
1272       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);
1273     }
1274 }
1275
1276 /*****************************************
1277  * gtk_widget_unmap:
1278  *
1279  *   arguments:
1280  *
1281  *   results:
1282  *****************************************/
1283
1284 void
1285 gtk_widget_unmap (GtkWidget *widget)
1286 {
1287   g_return_if_fail (widget != NULL);
1288
1289   if (GTK_WIDGET_MAPPED (widget))
1290     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
1291 }
1292
1293 /*****************************************
1294  * gtk_widget_realize:
1295  *
1296  *   arguments:
1297  *
1298  *   results:
1299  *****************************************/
1300
1301 void
1302 gtk_widget_realize (GtkWidget *widget)
1303 {
1304   GtkStyle *new_style;
1305   gint events;
1306   GdkExtensionMode mode;
1307   GtkWidgetShapeInfo *shape_info;
1308
1309   g_return_if_fail (widget != NULL);
1310
1311   if (!GTK_WIDGET_REALIZED (widget))
1312     {
1313       /*
1314         if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
1315           g_print ("%s\n", gtk_type_name (GTK_WIDGET_TYPE (widget)));
1316       */
1317
1318       if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
1319         gtk_widget_realize (widget->parent);
1320
1321       if (!GTK_WIDGET_USER_STYLE (widget))
1322         {
1323           new_style = gtk_rc_get_style (widget);
1324           if (new_style != widget->style)
1325             gtk_widget_set_style_internal (widget, new_style);
1326         }
1327
1328       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REALIZE]);
1329
1330       if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
1331         {
1332           shape_info = gtk_object_get_data (GTK_OBJECT (widget),
1333                                             shape_info_key);
1334           gdk_window_shape_combine_mask (widget->window,
1335                                          shape_info->shape_mask,
1336                                          shape_info->offset_x,
1337                                          shape_info->offset_y);
1338         }
1339
1340       if (!GTK_WIDGET_NO_WINDOW (widget))
1341         {
1342           mode = gtk_widget_get_extension_events (widget);
1343           if (mode != GDK_EXTENSION_EVENTS_NONE)
1344             {
1345               events = gtk_widget_get_events (widget);
1346               gdk_input_set_extension_events (widget->window, events, mode);
1347             }
1348         }
1349
1350     }
1351 }
1352
1353 /*****************************************
1354  * gtk_widget_unrealize:
1355  *
1356  *   arguments:
1357  *
1358  *   results:
1359  *****************************************/
1360
1361 void
1362 gtk_widget_unrealize (GtkWidget *widget)
1363 {
1364   g_return_if_fail (widget != NULL);
1365
1366   if (GTK_WIDGET_REALIZED (widget))
1367     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
1368 }
1369
1370 /*****************************************
1371  * gtk_widget_queue_draw:
1372  *
1373  *   arguments:
1374  *
1375  *   results:
1376  *****************************************/
1377
1378 static gint
1379 gtk_widget_idle_draw (void *data)
1380 {
1381   GSList *node;
1382
1383   node = gtk_widget_redraw_queue;
1384   gtk_widget_redraw_queue = NULL;
1385   while (node)
1386     {
1387       gtk_widget_real_queue_draw ((GtkWidget*) node->data);
1388       node = node->next;
1389     }
1390
1391   return gtk_widget_redraw_queue != NULL;
1392 }
1393
1394 void
1395 gtk_widget_queue_draw (GtkWidget *widget)
1396 {
1397   GtkWidget *parent;
1398
1399   g_return_if_fail (widget != NULL);
1400
1401   if (GTK_WIDGET_DRAWABLE (widget))
1402     {
1403       /* We queue the redraw if:
1404        *  a) the widget is not already queued for redraw and
1405        *  b) non of the widgets ancestors are queued for redraw.
1406        */
1407       parent = widget;
1408       while (parent)
1409         {
1410           if (GTK_WIDGET_REDRAW_PENDING (parent))
1411             return;
1412           parent = parent->parent;
1413         }
1414
1415       GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_PENDING);
1416       if (gtk_widget_redraw_queue == NULL)
1417         gtk_idle_add ((GtkFunction) gtk_widget_idle_draw, NULL);
1418
1419       gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
1420     }
1421 }
1422
1423 /*****************************************
1424  * gtk_widget_queue_resize:
1425  *
1426  *   arguments:
1427  *
1428  *   results:
1429  *****************************************/
1430
1431 static gint
1432 gtk_widget_idle_sizer (void *data)
1433 {
1434   GSList *node;
1435
1436   node = gtk_widget_resize_queue;
1437   gtk_widget_resize_queue = NULL;
1438   while (node)
1439     {
1440       gtk_widget_real_queue_resize ((GtkWidget *)node->data);
1441       node = node->next;
1442     }
1443
1444   return gtk_widget_resize_queue != NULL;
1445 }
1446
1447 void
1448 gtk_widget_queue_resize (GtkWidget *widget)
1449 {
1450   GtkWidget *toplevel;
1451
1452   g_return_if_fail (widget != NULL);
1453
1454   toplevel = gtk_widget_get_toplevel (widget);
1455   if (GTK_WIDGET_TOPLEVEL (toplevel))
1456     {
1457       if (GTK_WIDGET_VISIBLE (toplevel))
1458         {
1459           if (!GTK_CONTAINER_RESIZE_PENDING (toplevel))
1460             {
1461               GTK_PRIVATE_SET_FLAG (toplevel, GTK_RESIZE_PENDING);
1462               if (gtk_widget_resize_queue == NULL)
1463                 gtk_idle_add ((GtkFunction) gtk_widget_idle_sizer, NULL);
1464               gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, toplevel);
1465             }
1466
1467           if (!GTK_WIDGET_RESIZE_NEEDED (widget))
1468             {
1469               GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
1470               GTK_CONTAINER (toplevel)->resize_widgets =
1471                 g_slist_prepend (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1472             }
1473           else
1474             g_assert (g_slist_find (GTK_CONTAINER (toplevel)->resize_widgets, widget)); /* paranoid */
1475         }
1476       else
1477         gtk_container_need_resize (GTK_CONTAINER (toplevel));
1478     }
1479 }
1480
1481 /*****************************************
1482  * gtk_widget_draw:
1483  *
1484  *   arguments:
1485  *
1486  *   results:
1487  *****************************************/
1488
1489 void
1490 gtk_widget_draw (GtkWidget    *widget,
1491                  GdkRectangle *area)
1492 {
1493   GdkRectangle temp_area;
1494
1495   g_return_if_fail (widget != NULL);
1496
1497   if (GTK_WIDGET_DRAWABLE (widget) &&
1498       !GTK_WIDGET_REDRAW_PENDING (widget))
1499     {
1500       if (!area)
1501         {
1502           if (GTK_WIDGET_NO_WINDOW (widget))
1503             {
1504               temp_area.x = widget->allocation.x;
1505               temp_area.y = widget->allocation.y;
1506             }
1507           else
1508             {
1509               temp_area.x = 0;
1510               temp_area.y = 0;
1511             }
1512
1513           temp_area.width = widget->allocation.width;
1514           temp_area.height = widget->allocation.height;
1515           area = &temp_area;
1516         }
1517
1518       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
1519     }
1520 }
1521
1522 /*****************************************
1523  * gtk_widget_draw_focus:
1524  *
1525  *   arguments:
1526  *
1527  *   results:
1528  *****************************************/
1529
1530 void
1531 gtk_widget_draw_focus (GtkWidget *widget)
1532 {
1533   g_return_if_fail (widget != NULL);
1534
1535   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_FOCUS]);
1536 }
1537
1538 /*****************************************
1539  * gtk_widget_draw_default:
1540  *
1541  *   arguments:
1542  *
1543  *   results:
1544  *****************************************/
1545
1546 void
1547 gtk_widget_draw_default (GtkWidget *widget)
1548 {
1549   g_return_if_fail (widget != NULL);
1550
1551   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_DEFAULT]);
1552 }
1553
1554 /*****************************************
1555  * gtk_widget_draw_children:
1556  *
1557  *   arguments:
1558  *
1559  *   results:
1560  *****************************************/
1561
1562 void
1563 gtk_widget_draw_children (GtkWidget *widget)
1564 {
1565   g_return_if_fail (widget != NULL);
1566
1567   if (GTK_IS_CONTAINER (widget))
1568     gtk_container_foreach (GTK_CONTAINER (widget),
1569                            gtk_widget_draw_children_recurse,
1570                            NULL);
1571 }
1572
1573 /*****************************************
1574  * gtk_widget_size_request:
1575  *
1576  *   arguments:
1577  *
1578  *   results:
1579  *****************************************/
1580
1581 void
1582 gtk_widget_size_request (GtkWidget      *widget,
1583                          GtkRequisition *requisition)
1584 {
1585   GtkWidgetAuxInfo *aux_info;
1586
1587   g_return_if_fail (widget != NULL);
1588
1589   gtk_widget_ref (widget);
1590   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
1591                    requisition);
1592   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1593   if (aux_info)
1594     {
1595       if (aux_info->width > 0)
1596         requisition->width = aux_info->width;
1597       if (aux_info->height > 0)
1598         requisition->height = aux_info->height;
1599     }
1600   gtk_widget_unref (widget);
1601 }
1602
1603 /*****************************************
1604  * gtk_widget_size_allocate:
1605  *
1606  *   arguments:
1607  *
1608  *   results:
1609  *****************************************/
1610
1611 void
1612 gtk_widget_size_allocate (GtkWidget     *widget,
1613                           GtkAllocation *allocation)
1614 {
1615   GtkWidgetAuxInfo *aux_info;
1616   GtkAllocation real_allocation;
1617
1618   g_return_if_fail (widget != NULL);
1619
1620   real_allocation = *allocation;
1621   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1622
1623   if (aux_info)
1624     {
1625       if (aux_info->x != -1)
1626         real_allocation.x = aux_info->x;
1627       if (aux_info->y != -1)
1628         real_allocation.y = aux_info->y;
1629     }
1630
1631   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
1632 }
1633
1634 /*****************************************
1635  * gtk_widget_install_accelerator:
1636  *
1637  *   arguments:
1638  *
1639  *   results:
1640  *****************************************/
1641
1642 void
1643 gtk_widget_install_accelerator (GtkWidget           *widget,
1644                                 GtkAcceleratorTable *table,
1645                                 const gchar         *signal_name,
1646                                 gchar                key,
1647                                 guint8               modifiers)
1648 {
1649   gint return_val;
1650
1651   g_return_if_fail (widget != NULL);
1652
1653   gtk_widget_ref (widget);
1654   return_val = TRUE;
1655   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[INSTALL_ACCELERATOR],
1656                    signal_name, key, modifiers, &return_val);
1657   if (return_val)
1658     gtk_accelerator_table_install (table,
1659                                    GTK_OBJECT (widget),
1660                                    signal_name,
1661                                    key,
1662                                    modifiers);
1663   gtk_widget_unref (widget);
1664 }
1665
1666 /*****************************************
1667  * gtk_widget_remove_accelerator:
1668  *
1669  *   arguments:
1670  *
1671  *   results:
1672  *****************************************/
1673
1674 void
1675 gtk_widget_remove_accelerator (GtkWidget           *widget,
1676                                GtkAcceleratorTable *table,
1677                                const gchar         *signal_name)
1678 {
1679   g_return_if_fail (widget != NULL);
1680
1681   gtk_widget_ref (widget);
1682   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REMOVE_ACCELERATOR],
1683                    signal_name);
1684   gtk_accelerator_table_remove (table, GTK_OBJECT (widget), signal_name);
1685   gtk_widget_unref (widget);
1686 }
1687
1688 /*****************************************
1689  * gtk_widget_event:
1690  *
1691  *   arguments:
1692  *
1693  *   results:
1694  *****************************************/
1695
1696 gint
1697 gtk_widget_event (GtkWidget *widget,
1698                   GdkEvent  *event)
1699 {
1700   gint return_val;
1701   gint signal_num;
1702
1703   g_return_val_if_fail (widget != NULL, TRUE);
1704
1705   gtk_widget_ref (widget);
1706   return_val = FALSE;
1707   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
1708                    &return_val);
1709   if (return_val || GTK_OBJECT_DESTROYED (widget))
1710     {
1711       gtk_widget_unref (widget);
1712       return TRUE;
1713     }
1714
1715   switch (event->type)
1716     {
1717     case GDK_NOTHING:
1718       signal_num = -1;
1719       break;
1720     case GDK_BUTTON_PRESS:
1721     case GDK_2BUTTON_PRESS:
1722     case GDK_3BUTTON_PRESS:
1723       signal_num = BUTTON_PRESS_EVENT;
1724       break;
1725     case GDK_BUTTON_RELEASE:
1726       signal_num = BUTTON_RELEASE_EVENT;
1727       break;
1728     case GDK_MOTION_NOTIFY:
1729       signal_num = MOTION_NOTIFY_EVENT;
1730       break;
1731     case GDK_DELETE:
1732       signal_num = DELETE_EVENT;
1733       break;
1734     case GDK_DESTROY:
1735       signal_num = DESTROY_EVENT;
1736       break;
1737     case GDK_KEY_PRESS:
1738       signal_num = KEY_PRESS_EVENT;
1739       break;
1740     case GDK_KEY_RELEASE:
1741       signal_num = KEY_RELEASE_EVENT;
1742       break;
1743     case GDK_ENTER_NOTIFY:
1744       signal_num = ENTER_NOTIFY_EVENT;
1745       break;
1746     case GDK_LEAVE_NOTIFY:
1747       signal_num = LEAVE_NOTIFY_EVENT;
1748       break;
1749     case GDK_FOCUS_CHANGE:
1750       if (event->focus_change.in)
1751         signal_num = FOCUS_IN_EVENT;
1752       else
1753         signal_num = FOCUS_OUT_EVENT;
1754       break;
1755     case GDK_CONFIGURE:
1756       signal_num = CONFIGURE_EVENT;
1757       break;
1758     case GDK_MAP:
1759       signal_num = MAP_EVENT;
1760       break;
1761     case GDK_UNMAP:
1762       signal_num = UNMAP_EVENT;
1763       break;
1764     case GDK_PROPERTY_NOTIFY:
1765       signal_num = PROPERTY_NOTIFY_EVENT;
1766       break;
1767     case GDK_SELECTION_CLEAR:
1768       signal_num = SELECTION_CLEAR_EVENT;
1769       break;
1770     case GDK_SELECTION_REQUEST:
1771       signal_num = SELECTION_REQUEST_EVENT;
1772       break;
1773     case GDK_SELECTION_NOTIFY:
1774       signal_num = SELECTION_NOTIFY_EVENT;
1775       break;
1776     case GDK_PROXIMITY_IN:
1777       signal_num = PROXIMITY_IN_EVENT;
1778       break;
1779     case GDK_PROXIMITY_OUT:
1780       signal_num = PROXIMITY_OUT_EVENT;
1781       break;
1782     case GDK_DRAG_BEGIN:
1783       signal_num = DRAG_BEGIN_EVENT;
1784       break;
1785     case GDK_DRAG_REQUEST:
1786       signal_num = DRAG_REQUEST_EVENT;
1787       break;
1788     case GDK_DROP_ENTER:
1789       signal_num = DROP_ENTER_EVENT;
1790       break;
1791     case GDK_DROP_LEAVE:
1792       signal_num = DROP_LEAVE_EVENT;
1793       break;
1794     case GDK_DROP_DATA_AVAIL:
1795       signal_num = DROP_DATA_AVAILABLE_EVENT;
1796       break;
1797     case GDK_OTHER_EVENT:
1798       signal_num = OTHER_EVENT;
1799       break;
1800     case GDK_NO_EXPOSE:
1801       signal_num = NO_EXPOSE_EVENT;
1802       break;
1803     case GDK_CLIENT_EVENT:
1804       signal_num = CLIENT_EVENT;
1805       break;
1806     case GDK_EXPOSE:
1807       /* there is no sense in providing a widget with bogus expose events
1808        */
1809       if (!event->any.window)
1810         {
1811           gtk_widget_unref (widget);
1812           return TRUE;
1813         }
1814       signal_num = EXPOSE_EVENT;
1815       break;
1816     default:
1817       g_warning ("could not determine signal number for event: %d", event->type);
1818       gtk_widget_unref (widget);
1819       return TRUE;
1820     }
1821
1822   if (signal_num != -1)
1823     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[signal_num], event, &return_val);
1824
1825   return_val |= GTK_OBJECT_DESTROYED (widget);
1826
1827   gtk_widget_unref (widget);
1828
1829   return return_val;
1830 }
1831
1832 /*****************************************
1833  * gtk_widget_activate:
1834  *
1835  *   arguments:
1836  *
1837  *   results:
1838  *****************************************/
1839
1840 void
1841 gtk_widget_activate (GtkWidget *widget)
1842 {
1843   g_return_if_fail (widget != NULL);
1844   g_return_if_fail (GTK_IS_WIDGET (widget));
1845
1846   if (WIDGET_CLASS (widget)->activate_signal)
1847     gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
1848 }
1849
1850 /*****************************************
1851  * gtk_widget_reparent_container_child:
1852  *   assistent function to gtk_widget_reparent
1853  *
1854  *   arguments:
1855  *
1856  *   results:
1857  *****************************************/
1858
1859 static void
1860 gtk_widget_reparent_container_child(GtkWidget *widget,
1861                                    gpointer   client_data)
1862 {
1863   g_return_if_fail (widget != NULL);
1864   g_return_if_fail (client_data != NULL);
1865
1866   if (GTK_WIDGET_NO_WINDOW (widget))
1867     {
1868       if (widget->window)
1869         gdk_window_unref (widget->window);
1870       widget->window = (GdkWindow*) client_data;
1871       if (widget->window)
1872         gdk_window_ref (widget->window);
1873
1874       if (GTK_IS_CONTAINER (widget))
1875         gtk_container_foreach (GTK_CONTAINER (widget),
1876                                gtk_widget_reparent_container_child,
1877                                client_data);
1878     }
1879   else
1880     gdk_window_reparent (widget->window,
1881                          (GdkWindow*) client_data, 0, 0);
1882 }
1883
1884 /*****************************************
1885  * gtk_widget_reparent:
1886  *
1887  *   arguments:
1888  *
1889  *   results:
1890  *****************************************/
1891
1892 void
1893 gtk_widget_reparent (GtkWidget *widget,
1894                      GtkWidget *new_parent)
1895 {
1896   g_return_if_fail (widget != NULL);
1897   g_return_if_fail (GTK_IS_WIDGET (widget));
1898   g_return_if_fail (new_parent != NULL);
1899   g_return_if_fail (GTK_IS_CONTAINER (new_parent));
1900   g_return_if_fail (widget->parent != NULL);
1901
1902   if (widget->parent != new_parent)
1903     {
1904       /* First try to see if we can get away without unrealizing
1905        * the widget as we reparent it. if so we set a flag so
1906        * that gtk_widget_unparent doesn't unrealize widget
1907        */
1908       if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
1909         GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
1910
1911       gtk_widget_ref (widget);
1912       gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
1913       gtk_container_add (GTK_CONTAINER (new_parent), widget);
1914       gtk_widget_unref (widget);
1915
1916       if (GTK_WIDGET_IN_REPARENT (widget))
1917         {
1918           GTK_PRIVATE_UNSET_FLAG (widget, GTK_IN_REPARENT);
1919
1920           /* OK, now fix up the widget's window. (And that for any
1921            * children, if the widget is NO_WINDOW and a container)
1922            */
1923           if (GTK_WIDGET_NO_WINDOW (widget))
1924             {
1925               if (GTK_IS_CONTAINER (widget))
1926                 gtk_container_foreach (GTK_CONTAINER(widget),
1927                                        gtk_widget_reparent_container_child,
1928                                        gtk_widget_get_parent_window (widget));
1929               else
1930                 {
1931                   GdkWindow *parent_window;
1932
1933                   parent_window = gtk_widget_get_parent_window (widget);
1934                   if (parent_window != widget->window)
1935                     {
1936                       if (widget->window)
1937                         gdk_window_unref (widget->window);
1938                       widget->window = parent_window;
1939                       if (widget->window)
1940                         gdk_window_ref (widget->window);
1941                     }
1942                 }
1943             }
1944           else
1945             gdk_window_reparent (widget->window, gtk_widget_get_parent_window (widget), 0, 0);
1946         }
1947     }
1948 }
1949
1950 /*****************************************
1951  * gtk_widget_popup:
1952  *
1953  *   arguments:
1954  *
1955  *   results:
1956  *****************************************/
1957
1958 void
1959 gtk_widget_popup (GtkWidget *widget,
1960                   gint       x,
1961                   gint       y)
1962 {
1963   g_return_if_fail (widget != NULL);
1964
1965   if (!GTK_WIDGET_VISIBLE (widget))
1966     {
1967       if (!GTK_WIDGET_REALIZED (widget))
1968         gtk_widget_realize (widget);
1969       if (!GTK_WIDGET_NO_WINDOW (widget))
1970         gdk_window_move (widget->window, x, y);
1971       gtk_widget_show (widget);
1972     }
1973 }
1974
1975 /*****************************************
1976  * gtk_widget_intersect:
1977  *
1978  *   arguments:
1979  *
1980  *   results:
1981  *****************************************/
1982
1983 gint
1984 gtk_widget_intersect (GtkWidget    *widget,
1985                       GdkRectangle *area,
1986                       GdkRectangle *intersection)
1987 {
1988   GdkRectangle *dest;
1989   GdkRectangle tmp;
1990   gint return_val;
1991
1992   g_return_val_if_fail (widget != NULL, FALSE);
1993   g_return_val_if_fail (area != NULL, FALSE);
1994
1995   if (intersection)
1996     dest = intersection;
1997   else
1998     dest = &tmp;
1999
2000   return_val = gdk_rectangle_intersect ((GdkRectangle*) &widget->allocation, area, dest);
2001
2002   if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
2003     {
2004       intersection->x -= widget->allocation.x;
2005       intersection->y -= widget->allocation.y;
2006     }
2007
2008   return return_val;
2009 }
2010
2011
2012 gint
2013 gtk_widget_basic (GtkWidget *widget)
2014 {
2015   GList *children;
2016   GList *tmp_list;
2017   gint return_val;
2018
2019   g_return_val_if_fail (widget != NULL, FALSE);
2020
2021   if (!GTK_WIDGET_BASIC (widget))
2022     return FALSE;
2023   else if (GTK_IS_CONTAINER (widget))
2024     {
2025       children = gtk_container_children (GTK_CONTAINER (widget));
2026       if (children)
2027         {
2028           return_val = TRUE;
2029           tmp_list = children;
2030
2031           while (tmp_list)
2032             {
2033               if (!gtk_widget_basic (GTK_WIDGET (tmp_list->data)))
2034                 {
2035                   return_val = FALSE;
2036                   break;
2037                 }
2038
2039               tmp_list = tmp_list->next;
2040             }
2041
2042           g_list_free (children);
2043           return return_val;
2044         }
2045     }
2046
2047   return TRUE;
2048 }
2049
2050
2051 /*****************************************
2052  * gtk_widget_grab_focus:
2053  *
2054  *   arguments:
2055  *
2056  *   results:
2057  *****************************************/
2058
2059 void
2060 gtk_widget_grab_focus (GtkWidget *widget)
2061 {
2062   GtkWidget *window;
2063   GtkWidget *child;
2064   gint window_type;
2065
2066   g_return_if_fail (widget != NULL);
2067
2068   window_type = gtk_window_get_type ();
2069   window = widget->parent;
2070   child = widget;
2071
2072   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2073     {
2074       GTK_CONTAINER (window)->focus_child = child;
2075       child = window;
2076       window = window->parent;
2077     }
2078
2079   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2080     {
2081       GTK_CONTAINER (window)->focus_child = child;
2082       gtk_window_set_focus (GTK_WINDOW (window), widget);
2083     }
2084 }
2085
2086 /*****************************************
2087  * gtk_widget_grab_default:
2088  *
2089  *   arguments:
2090  *
2091  *   results:
2092  *****************************************/
2093
2094 void
2095 gtk_widget_grab_default (GtkWidget *widget)
2096 {
2097   GtkWidget *window;
2098   gint window_type;
2099
2100   g_return_if_fail (widget != NULL);
2101   g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
2102
2103   window_type = gtk_window_get_type ();
2104   window = widget->parent;
2105
2106   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2107     window = window->parent;
2108
2109   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2110     gtk_window_set_default (GTK_WINDOW (window), widget);
2111 }
2112
2113 /*****************************************
2114  * gtk_widget_set_name:
2115  *
2116  *   arguments:
2117  *
2118  *   results:
2119  *****************************************/
2120
2121 void
2122 gtk_widget_set_name (GtkWidget   *widget,
2123                      const gchar *name)
2124 {
2125   GtkStyle *new_style;
2126
2127   g_return_if_fail (widget != NULL);
2128
2129   if (widget->name)
2130     g_free (widget->name);
2131   widget->name = g_strdup (name);
2132
2133   if (!GTK_WIDGET_USER_STYLE (widget))
2134     {
2135       new_style = gtk_rc_get_style (widget);
2136       gtk_widget_set_style_internal (widget, new_style);
2137     }
2138 }
2139
2140 /*****************************************
2141  * gtk_widget_get_name:
2142  *
2143  *   arguments:
2144  *
2145  *   results:
2146  *****************************************/
2147
2148 gchar*
2149 gtk_widget_get_name (GtkWidget *widget)
2150 {
2151   g_return_val_if_fail (widget != NULL, NULL);
2152
2153   if (widget->name)
2154     return widget->name;
2155   return gtk_type_name (GTK_WIDGET_TYPE (widget));
2156 }
2157
2158 /*****************************************
2159  * gtk_widget_set_state:
2160  *
2161  *   arguments:
2162  *     widget
2163  *     state
2164  *
2165  *   results:
2166  *****************************************/
2167
2168 void
2169 gtk_widget_set_state (GtkWidget           *widget,
2170                       GtkStateType         state)
2171 {
2172   g_return_if_fail (widget != NULL);
2173
2174   if (state == GTK_WIDGET_STATE (widget))
2175     return;
2176
2177   if (state == GTK_STATE_INSENSITIVE)
2178     gtk_widget_set_sensitive (widget, FALSE);
2179   else
2180     {
2181       GtkStateData data;
2182       GtkStateType old_state;
2183
2184       data.state = state;
2185       if (widget->parent)
2186         data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2187       else
2188         data.parent_sensitive = GTK_PARENT_SENSITIVE;
2189
2190       old_state = GTK_WIDGET_STATE (widget);
2191
2192       gtk_widget_propagate_state (widget, &data);
2193       if (old_state != GTK_WIDGET_STATE (widget))
2194         gtk_widget_queue_draw (widget);
2195     }
2196 }
2197
2198 /*****************************************
2199  * gtk_widget_set_sensitive:
2200  *
2201  *   arguments:
2202  *     widget
2203  *     boolean value for sensitivity
2204  *
2205  *   results:
2206  *****************************************/
2207
2208 void
2209 gtk_widget_set_sensitive (GtkWidget *widget,
2210                           gint       sensitive)
2211 {
2212   GtkStateData data;
2213   GtkStateType old_state;
2214
2215   g_return_if_fail (widget != NULL);
2216
2217   if (sensitive)
2218     {
2219       GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE);
2220       if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE)
2221         data.state = GTK_WIDGET_SAVED_STATE (widget);
2222       else
2223         data.state = GTK_WIDGET_STATE (widget);
2224     }
2225   else
2226     {
2227       GTK_WIDGET_UNSET_FLAGS (widget, GTK_SENSITIVE);
2228       data.state = GTK_WIDGET_STATE (widget);
2229     }
2230
2231   if (widget->parent)
2232     data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2233   else
2234     data.parent_sensitive = GTK_PARENT_SENSITIVE;
2235
2236   old_state = GTK_WIDGET_STATE (widget);
2237   gtk_widget_propagate_state (widget, &data);
2238   if (old_state != GTK_WIDGET_STATE (widget))
2239     gtk_widget_queue_draw (widget);
2240 }
2241
2242 /*****************************************
2243  * gtk_widget_set_parent:
2244  *
2245  *   arguments:
2246  *
2247  *   results:
2248  *****************************************/
2249
2250 void
2251 gtk_widget_set_parent (GtkWidget *widget,
2252                        GtkWidget *parent)
2253 {
2254   GtkStyle *style;
2255   GtkStateData data;
2256
2257   g_return_if_fail (widget != NULL);
2258   g_return_if_fail (widget->parent == NULL);
2259   g_return_if_fail (!GTK_WIDGET_TOPLEVEL (widget));
2260   g_return_if_fail (parent != NULL);
2261
2262   /* keep this function in sync with gtk_menu_attach_to_widget()
2263    */
2264
2265   gtk_widget_ref (widget);
2266   gtk_object_sink (GTK_OBJECT (widget));
2267   widget->parent = parent;
2268
2269   if (GTK_WIDGET_STATE (parent) != GTK_STATE_NORMAL)
2270     data.state = GTK_WIDGET_STATE (parent);
2271   else
2272     data.state = GTK_WIDGET_STATE (widget);
2273   data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (parent);
2274
2275   gtk_widget_propagate_state (widget, &data);
2276
2277   while (parent->parent != NULL)
2278     parent = parent->parent;
2279
2280   if (GTK_WIDGET_TOPLEVEL (parent))
2281     {
2282       if (!GTK_WIDGET_USER_STYLE (widget))
2283         {
2284           style = gtk_rc_get_style (widget);
2285           if (style != widget->style)
2286             gtk_widget_set_style_internal (widget, style);
2287         }
2288
2289       if (GTK_IS_CONTAINER (widget))
2290         gtk_container_foreach (GTK_CONTAINER (widget),
2291                                gtk_widget_set_style_recurse,
2292                                NULL);
2293     }
2294 }
2295
2296 /*************************************************************
2297  * gtk_widget_set_parent_window:
2298  *     Set a non default parent window for widget
2299  *
2300  *   arguments:
2301  *     widget:
2302  *     parent_window
2303  *
2304  *   results:
2305  *************************************************************/
2306
2307 void
2308 gtk_widget_set_parent_window   (GtkWidget           *widget,
2309                                 GdkWindow           *parent_window)
2310 {
2311   GdkWindow *old_parent_window;
2312
2313   g_return_if_fail (widget != NULL);
2314
2315   old_parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2316                                            parent_window_key);
2317
2318   if (parent_window != old_parent_window)
2319     {
2320       gtk_object_set_data (GTK_OBJECT (widget), parent_window_key,
2321                            parent_window);
2322       if (old_parent_window)
2323         gdk_window_unref (old_parent_window);
2324       if (parent_window)
2325         gdk_window_ref (parent_window);
2326     }
2327 }
2328
2329 /*************************************************************
2330  * gtk_widget_get_parent_window:
2331  *     Get widget's parent window
2332  *
2333  *   arguments:
2334  *     widget:
2335  *
2336  *   results:
2337  *     parent window
2338  *************************************************************/
2339
2340 GdkWindow *
2341 gtk_widget_get_parent_window   (GtkWidget           *widget)
2342 {
2343   GdkWindow *parent_window;
2344
2345   g_return_val_if_fail (widget != NULL, NULL);
2346
2347   parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2348                                        parent_window_key);
2349
2350   return (parent_window != NULL) ? parent_window : widget->parent->window;
2351 }
2352
2353
2354 /*****************************************
2355  * gtk_widget_set_style:
2356  *
2357  *   arguments:
2358  *
2359  *   results:
2360  *****************************************/
2361
2362 void
2363 gtk_widget_set_style (GtkWidget *widget,
2364                       GtkStyle  *style)
2365 {
2366   g_return_if_fail (widget != NULL);
2367
2368   GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
2369   gtk_widget_set_style_internal (widget, style);
2370 }
2371
2372 /*****************************************
2373  * gtk_widget_set_uposition:
2374  *
2375  *   arguments:
2376  *
2377  *   results:
2378  *****************************************/
2379
2380 void
2381 gtk_widget_set_uposition (GtkWidget *widget,
2382                           gint       x,
2383                           gint       y)
2384 {
2385   GtkWidgetAuxInfo *aux_info;
2386
2387   g_return_if_fail (widget != NULL);
2388
2389   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2390   if (!aux_info)
2391     {
2392       aux_info = gtk_widget_aux_info_new ();
2393       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2394     }
2395
2396   if (x > -2)
2397     aux_info->x = x;
2398   if (y > -2)
2399     aux_info->y = y;
2400
2401   if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
2402       (aux_info->x != -1) && (aux_info->y != -1))
2403     {
2404       gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
2405       gdk_window_move (widget->window, aux_info->x, aux_info->y);
2406     }
2407
2408   if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
2409     gtk_widget_size_allocate (widget, &widget->allocation);
2410 }
2411
2412 /*****************************************
2413  * gtk_widget_set_usize:
2414  *
2415  *   arguments:
2416  *
2417  *   results:
2418  *****************************************/
2419
2420 void
2421 gtk_widget_set_usize (GtkWidget *widget,
2422                       gint       width,
2423                       gint       height)
2424 {
2425   GtkWidgetAuxInfo *aux_info;
2426
2427   g_return_if_fail (widget != NULL);
2428
2429   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2430   if (!aux_info)
2431     {
2432       aux_info = gtk_widget_aux_info_new ();
2433       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2434     }
2435
2436   if (width > -1)
2437     aux_info->width = width;
2438   if (height > -1)
2439     aux_info->height = height;
2440
2441   if (GTK_WIDGET_VISIBLE (widget))
2442     gtk_widget_queue_resize (widget);
2443 }
2444
2445 /*****************************************
2446  * gtk_widget_set_events:
2447  *
2448  *   arguments:
2449  *
2450  *   results:
2451  *****************************************/
2452
2453 void
2454 gtk_widget_set_events (GtkWidget *widget,
2455                        gint       events)
2456 {
2457   gint *eventp;
2458
2459   g_return_if_fail (widget != NULL);
2460   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
2461   g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
2462
2463   eventp = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2464
2465   if (events)
2466     {
2467       if (!eventp)
2468         eventp = g_new (gint, 1);
2469
2470       *eventp = events;
2471       gtk_object_set_data (GTK_OBJECT (widget), event_key, eventp);
2472     }
2473   else
2474     {
2475       if (eventp)
2476         g_free (eventp);
2477
2478       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
2479     }
2480 }
2481
2482 /*****************************************
2483  * gtk_widget_set_extension_events:
2484  *
2485  *   arguments:
2486  *
2487  *   results:
2488  *****************************************/
2489
2490 void
2491 gtk_widget_set_extension_events (GtkWidget *widget,
2492                                  GdkExtensionMode mode)
2493 {
2494   GdkExtensionMode *modep;
2495
2496   g_return_if_fail (widget != NULL);
2497
2498   modep = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2499
2500   if (!modep)
2501     modep = g_new (GdkExtensionMode, 1);
2502
2503   *modep = mode;
2504   gtk_object_set_data (GTK_OBJECT (widget), extension_event_key, modep);
2505 }
2506
2507
2508 /*****************************************
2509  * gtk_widget_get_toplevel:
2510  *
2511  *   arguments:
2512  *
2513  *   results:
2514  *****************************************/
2515
2516 GtkWidget*
2517 gtk_widget_get_toplevel (GtkWidget *widget)
2518 {
2519   g_return_val_if_fail (widget != NULL, NULL);
2520
2521   while (widget->parent)
2522     widget = widget->parent;
2523
2524   return widget;
2525 }
2526
2527 /*****************************************
2528  * gtk_widget_get_ancestor:
2529  *
2530  *   arguments:
2531  *
2532  *   results:
2533  *****************************************/
2534
2535 GtkWidget*
2536 gtk_widget_get_ancestor (GtkWidget *widget,
2537                          gint       type)
2538 {
2539   g_return_val_if_fail (widget != NULL, NULL);
2540
2541   while (widget && !gtk_type_is_a (GTK_WIDGET_TYPE (widget), type))
2542     widget = widget->parent;
2543
2544   if (!(widget && gtk_type_is_a (GTK_WIDGET_TYPE (widget), type)))
2545     return NULL;
2546
2547   return widget;
2548 }
2549
2550 /*****************************************
2551  * gtk_widget_get_colormap:
2552  *
2553  *   arguments:
2554  *
2555  *   results:
2556  *****************************************/
2557
2558 GdkColormap*
2559 gtk_widget_get_colormap (GtkWidget *widget)
2560 {
2561   GdkColormap *colormap;
2562
2563   g_return_val_if_fail (widget != NULL, NULL);
2564
2565   if (!widget->window)
2566     {
2567       colormap = gtk_object_get_data (GTK_OBJECT (widget), colormap_key);
2568       if (colormap)
2569         return colormap;
2570       return gtk_widget_get_default_colormap ();
2571     }
2572
2573   return gdk_window_get_colormap (widget->window);
2574 }
2575
2576 /*****************************************
2577  * gtk_widget_get_visual:
2578  *
2579  *   arguments:
2580  *
2581  *   results:
2582  *****************************************/
2583
2584 GdkVisual*
2585 gtk_widget_get_visual (GtkWidget *widget)
2586 {
2587   GdkVisual *visual;
2588
2589   g_return_val_if_fail (widget != NULL, NULL);
2590
2591   if (!widget->window)
2592     {
2593       visual = gtk_object_get_data (GTK_OBJECT (widget), visual_key);
2594       if (visual)
2595         return visual;
2596       return gtk_widget_get_default_visual ();
2597     }
2598
2599   return gdk_window_get_visual (widget->window);
2600 }
2601
2602 /*****************************************
2603  * gtk_widget_get_style:
2604  *
2605  *   arguments:
2606  *
2607  *   results:
2608  *****************************************/
2609
2610 GtkStyle*
2611 gtk_widget_get_style (GtkWidget *widget)
2612 {
2613   g_return_val_if_fail (widget != NULL, NULL);
2614
2615   return widget->style;
2616 }
2617
2618 /*****************************************
2619  * gtk_widget_get_events:
2620  *
2621  *   arguments:
2622  *
2623  *   results:
2624  *****************************************/
2625
2626 gint
2627 gtk_widget_get_events (GtkWidget *widget)
2628 {
2629   gint *events;
2630
2631   g_return_val_if_fail (widget != NULL, 0);
2632
2633   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2634   if (events)
2635     return *events;
2636
2637   return 0;
2638 }
2639
2640 /*****************************************
2641  * gtk_widget_get_extension_events:
2642  *
2643  *   arguments:
2644  *
2645  *   results:
2646  *****************************************/
2647
2648 GdkExtensionMode
2649 gtk_widget_get_extension_events (GtkWidget *widget)
2650 {
2651   GdkExtensionMode *mode;
2652
2653   g_return_val_if_fail (widget != NULL, 0);
2654
2655   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2656   if (mode)
2657     return *mode;
2658
2659   return 0;
2660 }
2661
2662 /*****************************************
2663  * gtk_widget_get_pointer:
2664  *
2665  *   arguments:
2666  *
2667  *   results:
2668  *****************************************/
2669
2670 void
2671 gtk_widget_get_pointer (GtkWidget *widget,
2672                         gint      *x,
2673                         gint      *y)
2674 {
2675   g_return_if_fail (widget != NULL);
2676
2677   if (x)
2678     *x = -1;
2679   if (y)
2680     *y = -1;
2681
2682   if (GTK_WIDGET_REALIZED (widget))
2683     {
2684       gdk_window_get_pointer (widget->window, x, y, NULL);
2685
2686       if (GTK_WIDGET_NO_WINDOW (widget))
2687         {
2688           if (x)
2689             *x -= widget->allocation.x;
2690           if (y)
2691             *y -= widget->allocation.y;
2692         }
2693     }
2694 }
2695
2696 /*****************************************
2697  * gtk_widget_is_ancestor:
2698  *
2699  *   arguments:
2700  *
2701  *   results:
2702  *****************************************/
2703
2704 gint
2705 gtk_widget_is_ancestor (GtkWidget *widget,
2706                         GtkWidget *ancestor)
2707 {
2708   g_return_val_if_fail (widget != NULL, FALSE);
2709   g_return_val_if_fail (ancestor != NULL, FALSE);
2710
2711   while (widget)
2712     {
2713       if (widget->parent == ancestor)
2714         return TRUE;
2715       widget = widget->parent;
2716     }
2717
2718   return FALSE;
2719 }
2720
2721 /*****************************************
2722  * gtk_widget_is_child:
2723  *
2724  *   arguments:
2725  *
2726  *   results:
2727  *****************************************/
2728
2729 gint
2730 gtk_widget_is_child (GtkWidget *widget,
2731                      GtkWidget *child)
2732 {
2733   g_return_val_if_fail (widget != NULL, FALSE);
2734   g_return_val_if_fail (child != NULL, FALSE);
2735
2736   return (child->parent == widget);
2737 }
2738
2739 /*****************************************
2740  * gtk_widget_push_colormap:
2741  *
2742  *   arguments:
2743  *
2744  *   results:
2745  *****************************************/
2746
2747 void
2748 gtk_widget_push_colormap (GdkColormap *cmap)
2749 {
2750   colormap_stack = g_slist_prepend (colormap_stack, cmap);
2751 }
2752
2753 /*****************************************
2754  * gtk_widget_push_visual:
2755  *
2756  *   arguments:
2757  *
2758  *   results:
2759  *****************************************/
2760
2761 void
2762 gtk_widget_push_visual (GdkVisual *visual)
2763 {
2764   visual_stack = g_slist_prepend (visual_stack, visual);
2765 }
2766
2767 /*****************************************
2768  * gtk_widget_push_style:
2769  *
2770  *   arguments:
2771  *
2772  *   results:
2773  *****************************************/
2774
2775 void
2776 gtk_widget_push_style (GtkStyle *style)
2777 {
2778   gtk_style_ref (style);
2779   style_stack = g_slist_prepend (style_stack, style);
2780 }
2781
2782 /*****************************************
2783  * gtk_widget_pop_colormap:
2784  *
2785  *   arguments:
2786  *
2787  *   results:
2788  *****************************************/
2789
2790 void
2791 gtk_widget_pop_colormap ()
2792 {
2793   GSList *tmp;
2794
2795   if (colormap_stack)
2796     {
2797       tmp = colormap_stack;
2798       colormap_stack = colormap_stack->next;
2799       g_slist_free_1 (tmp);
2800     }
2801 }
2802
2803 /*****************************************
2804  * gtk_widget_pop_visual:
2805  *
2806  *   arguments:
2807  *
2808  *   results:
2809  *****************************************/
2810
2811 void
2812 gtk_widget_pop_visual ()
2813 {
2814   GSList *tmp;
2815
2816   if (visual_stack)
2817     {
2818       tmp = visual_stack;
2819       visual_stack = visual_stack->next;
2820       g_slist_free_1 (tmp);
2821     }
2822 }
2823
2824 /*****************************************
2825  * gtk_widget_pop_style:
2826  *
2827  *   arguments:
2828  *
2829  *   results:
2830  *****************************************/
2831
2832 void
2833 gtk_widget_pop_style ()
2834 {
2835   GSList *tmp;
2836
2837   if (style_stack)
2838     {
2839       tmp = style_stack;
2840       style_stack = style_stack->next;
2841       gtk_style_unref ((GtkStyle*) tmp->data);
2842       g_slist_free_1 (tmp);
2843     }
2844 }
2845
2846 /*****************************************
2847  * gtk_widget_set_default_colormap:
2848  *
2849  *   arguments:
2850  *
2851  *   results:
2852  *****************************************/
2853
2854 void
2855 gtk_widget_set_default_colormap (GdkColormap *colormap)
2856 {
2857   if (default_colormap != colormap)
2858     {
2859       if (default_colormap)
2860         gdk_colormap_unref (default_colormap);
2861       default_colormap = colormap;
2862       if (default_colormap)
2863         gdk_colormap_ref (default_colormap);
2864     }
2865 }
2866
2867 /*****************************************
2868  * gtk_widget_set_default_visual:
2869  *
2870  *   arguments:
2871  *
2872  *   results:
2873  *****************************************/
2874
2875 void
2876 gtk_widget_set_default_visual (GdkVisual *visual)
2877 {
2878   default_visual = visual;
2879 }
2880
2881 /*****************************************
2882  * gtk_widget_set_default_style:
2883  *
2884  *   arguments:
2885  *
2886  *   results:
2887  *****************************************/
2888
2889 void
2890 gtk_widget_set_default_style (GtkStyle *style)
2891 {
2892    if (style != default_style)
2893      {
2894        if (default_style)
2895          gtk_style_unref (default_style);
2896        default_style = style;
2897        if (default_style)
2898          gtk_style_ref (default_style);
2899      }
2900 }
2901
2902 /* Basically, send a message to all toplevel windows telling them
2903  * that a new _GTK_STYLE_COLORS property is available on the root
2904  * window
2905  */
2906 void
2907 gtk_widget_propagate_default_style (void)
2908 {
2909   GdkEventClient sev;
2910   int i;
2911
2912   /* Set the property on the root window */
2913   gdk_property_change(GDK_ROOT_PARENT(),
2914                       gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE),
2915                       gdk_atom_intern("STRING", FALSE),
2916                       8*sizeof(gushort),
2917                       GDK_PROP_MODE_REPLACE,
2918                       (guchar *)gtk_widget_get_default_style(),
2919                       GTK_STYLE_NUM_STYLECOLORS() * sizeof(GdkColor));
2920
2921   for(i = 0; i < 5; i++)
2922     sev.data.l[i] = 0;
2923   sev.data_format = 32;
2924   sev.message_type = gdk_atom_intern ("_GTK_STYLE_CHANGED", FALSE);
2925   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
2926 }
2927
2928 /*****************************************
2929  * gtk_widget_get_default_colormap:
2930  *
2931  *   arguments:
2932  *
2933  *   results:
2934  *****************************************/
2935
2936 GdkColormap*
2937 gtk_widget_get_default_colormap ()
2938 {
2939   if (!default_colormap)
2940     default_colormap = gdk_colormap_get_system ();
2941
2942   return default_colormap;
2943 }
2944
2945 /*****************************************
2946  * gtk_widget_get_default_visual:
2947  *
2948  *   arguments:
2949  *
2950  *   results:
2951  *****************************************/
2952
2953 GdkVisual*
2954 gtk_widget_get_default_visual ()
2955 {
2956   if (!default_visual)
2957     default_visual = gdk_visual_get_system ();
2958
2959   return default_visual;
2960 }
2961
2962 /*****************************************
2963  * gtk_widget_get_default_style:
2964  *
2965  *   arguments:
2966  *
2967  *   results:
2968  *****************************************/
2969
2970 GtkStyle*
2971 gtk_widget_get_default_style ()
2972 {
2973   if (!default_style)
2974     {
2975       default_style = gtk_style_new ();
2976       gtk_style_ref (default_style);
2977     }
2978
2979   return default_style;
2980 }
2981
2982
2983 /*****************************************
2984  * gtk_widget_marshal_signal_1:
2985  *
2986  *   arguments:
2987  *
2988  *   results:
2989  *****************************************/
2990
2991 static void
2992 gtk_widget_marshal_signal_1 (GtkObject      *object,
2993                              GtkSignalFunc   func,
2994                              gpointer        func_data,
2995                              GtkArg         *args)
2996 {
2997   GtkWidgetSignal1 rfunc;
2998
2999   rfunc = (GtkWidgetSignal1) func;
3000
3001   (* rfunc) (object, GTK_VALUE_POINTER (args[0]), func_data);
3002 }
3003
3004 /*****************************************
3005  * gtk_widget_marshal_signal_2:
3006  *
3007  *   arguments:
3008  *
3009  *   results:
3010  *****************************************/
3011
3012 static void
3013 gtk_widget_marshal_signal_2 (GtkObject      *object,
3014                              GtkSignalFunc   func,
3015                              gpointer        func_data,
3016                              GtkArg         *args)
3017 {
3018   GtkWidgetSignal2 rfunc;
3019   gint *return_val;
3020
3021   rfunc = (GtkWidgetSignal2) func;
3022   return_val = GTK_RETLOC_BOOL (args[3]);
3023
3024   *return_val = (* rfunc) (object, GTK_VALUE_STRING (args[0]),
3025                            GTK_VALUE_CHAR (args[1]), GTK_VALUE_INT (args[2]),
3026                            func_data);
3027 }
3028
3029 /*****************************************
3030  * gtk_widget_marshal_signal_3:
3031  *
3032  *   arguments:
3033  *
3034  *   results:
3035  *****************************************/
3036
3037 static void
3038 gtk_widget_marshal_signal_3 (GtkObject      *object,
3039                              GtkSignalFunc   func,
3040                              gpointer        func_data,
3041                              GtkArg         *args)
3042 {
3043   GtkWidgetSignal3 rfunc;
3044
3045   rfunc = (GtkWidgetSignal3) func;
3046
3047   (* rfunc) (object, GTK_VALUE_STRING (args[0]), func_data);
3048 }
3049
3050 /*****************************************
3051  * gtk_widget_marshal_signal_4:
3052  *
3053  *   arguments:
3054  *
3055  *   results:
3056  *****************************************/
3057
3058 static void
3059 gtk_widget_marshal_signal_4 (GtkObject      *object,
3060                              GtkSignalFunc   func,
3061                              gpointer        func_data,
3062                              GtkArg         *args)
3063 {
3064   GtkWidgetSignal4 rfunc;
3065   gint *return_val;
3066
3067   rfunc = (GtkWidgetSignal4) func;
3068   return_val = GTK_RETLOC_BOOL (args[1]);
3069
3070   *return_val = (* rfunc) (object, GTK_VALUE_BOXED (args[0]), func_data);
3071 }
3072
3073 /*****************************************
3074  * gtk_widget_marshal_signal_5:
3075  *
3076  *   arguments:
3077  *
3078  *   results:
3079  *****************************************/
3080
3081 static void
3082 gtk_widget_marshal_signal_5 (GtkObject      *object,
3083                              GtkSignalFunc   func,
3084                              gpointer        func_data,
3085                              GtkArg         *args)
3086 {
3087   GtkWidgetSignal5 rfunc;
3088   gint *return_val;
3089
3090   rfunc = (GtkWidgetSignal5) func;
3091   return_val = GTK_RETLOC_BOOL (args[1]);
3092
3093   (* rfunc) (object, GTK_VALUE_UINT (args[0]), func_data);
3094 }
3095
3096 static void
3097 gtk_widget_real_destroy (GtkObject *object)
3098 {
3099   GtkWidget *widget = GTK_WIDGET (object);
3100
3101   gtk_widget_ref (widget);
3102
3103   if (GTK_WIDGET_REDRAW_PENDING (widget))
3104     {
3105       gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
3106       GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
3107     }
3108
3109   if (GTK_CONTAINER_RESIZE_PENDING (widget))
3110     {
3111       gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
3112       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
3113     }
3114
3115   if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
3116     gtk_widget_shape_combine_mask (widget, NULL, -1, -1);
3117
3118   gtk_grab_remove (widget);
3119   gtk_selection_remove_all (widget);
3120
3121   if (widget->parent)
3122     gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
3123
3124   if (GTK_OBJECT_CLASS (parent_class)->destroy)
3125     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
3126
3127   gtk_widget_unref (widget);
3128 }
3129
3130 static void
3131 gtk_widget_real_finalize (GtkObject *object)
3132 {
3133   GtkWidget *widget;
3134   GtkWidgetAuxInfo *aux_info;
3135   gint *events;
3136   GdkExtensionMode *mode;
3137
3138   g_return_if_fail (object != NULL);
3139   g_return_if_fail (GTK_IS_WIDGET (object));
3140
3141   widget = GTK_WIDGET (object);
3142
3143   if (widget->name)
3144     {
3145       g_free (widget->name);
3146       widget->name = NULL;
3147     }
3148
3149   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
3150   if (aux_info)
3151     {
3152       gtk_widget_aux_info_destroy (aux_info);
3153       gtk_object_remove_data (GTK_OBJECT (widget), aux_info_key);
3154     }
3155
3156   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
3157   if (events)
3158     {
3159       g_free (events);
3160       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
3161     }
3162
3163   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
3164   if (mode)
3165     {
3166       g_free (mode);
3167       gtk_object_remove_data (GTK_OBJECT (widget), extension_event_key);
3168     }
3169
3170   gtk_style_unref (widget->style);
3171   widget->style = NULL;
3172
3173   parent_class->finalize (object);
3174 }
3175
3176 /*****************************************
3177  * gtk_widget_real_show:
3178  *
3179  *   arguments:
3180  *
3181  *   results:
3182  *****************************************/
3183
3184 static void
3185 gtk_widget_real_show (GtkWidget *widget)
3186 {
3187   g_return_if_fail (widget != NULL);
3188   g_return_if_fail (GTK_IS_WIDGET (widget));
3189
3190   if (!GTK_WIDGET_VISIBLE (widget))
3191     {
3192       GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
3193
3194       if (widget->parent)
3195         {
3196           gtk_widget_queue_resize (widget);
3197
3198           if (GTK_WIDGET_MAPPED (widget->parent))
3199             gtk_widget_map (widget);
3200         }
3201     }
3202 }
3203
3204 /*****************************************
3205  * gtk_widget_real_hide:
3206  *
3207  *   arguments:
3208  *
3209  *   results:
3210  *****************************************/
3211
3212 static void
3213 gtk_widget_real_hide (GtkWidget *widget)
3214 {
3215   g_return_if_fail (widget != NULL);
3216   g_return_if_fail (GTK_IS_WIDGET (widget));
3217
3218   if (GTK_WIDGET_VISIBLE (widget))
3219     {
3220       GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
3221
3222       if (GTK_WIDGET_MAPPED (widget))
3223         gtk_widget_unmap (widget);
3224
3225       if (widget->parent)
3226         gtk_widget_queue_resize (widget);
3227     }
3228 }
3229
3230 /*****************************************
3231  * gtk_widget_real_map:
3232  *
3233  *   arguments:
3234  *
3235  *   results:
3236  *****************************************/
3237
3238 static void
3239 gtk_widget_real_map (GtkWidget *widget)
3240 {
3241   g_return_if_fail (widget != NULL);
3242   g_return_if_fail (GTK_IS_WIDGET (widget));
3243
3244   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
3245     {
3246       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
3247
3248       if (!GTK_WIDGET_NO_WINDOW (widget))
3249         gdk_window_show (widget->window);
3250       else
3251         gtk_widget_queue_draw (widget);
3252     }
3253 }
3254
3255 /*****************************************
3256  * gtk_widget_real_unmap:
3257  *
3258  *   arguments:
3259  *
3260  *   results:
3261  *****************************************/
3262
3263 static void
3264 gtk_widget_real_unmap (GtkWidget *widget)
3265 {
3266   g_return_if_fail (widget != NULL);
3267   g_return_if_fail (GTK_IS_WIDGET (widget));
3268
3269   if (GTK_WIDGET_MAPPED (widget))
3270     {
3271       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
3272
3273       if (GTK_WIDGET_NO_WINDOW (widget))
3274         gdk_window_clear_area (widget->window,
3275                                widget->allocation.x,
3276                                widget->allocation.y,
3277                                widget->allocation.width,
3278                                widget->allocation.height);
3279       else
3280         gdk_window_hide (widget->window);
3281     }
3282 }
3283
3284 /*****************************************
3285  * gtk_widget_real_realize:
3286  *
3287  *   arguments:
3288  *
3289  *   results:
3290  *****************************************/
3291
3292 static void
3293 gtk_widget_real_realize (GtkWidget *widget)
3294 {
3295   g_return_if_fail (widget != NULL);
3296   g_return_if_fail (GTK_IS_WIDGET (widget));
3297
3298   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
3299   if (widget->parent)
3300     {
3301       widget->window = gtk_widget_get_parent_window (widget);
3302       gdk_window_ref (widget->window);
3303     }
3304   widget->style = gtk_style_attach (widget->style, widget->window);
3305 }
3306
3307 /*****************************************
3308  * gtk_widget_real_unrealize:
3309  *
3310  *   arguments:
3311  *
3312  *   results:
3313  *****************************************/
3314
3315 static void
3316 gtk_widget_real_unrealize (GtkWidget *widget)
3317 {
3318   g_return_if_fail (widget != NULL);
3319   g_return_if_fail (GTK_IS_WIDGET (widget));
3320
3321   if (GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_MAPPED (widget))
3322     gtk_widget_real_unmap (widget);
3323
3324   GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
3325
3326   /* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT(widget)->klass->type));
3327    */
3328
3329   gtk_style_detach (widget->style);
3330   if (!GTK_WIDGET_NO_WINDOW (widget))
3331     {
3332       gdk_window_set_user_data (widget->window, NULL);
3333       gdk_window_destroy (widget->window);
3334     }
3335   else
3336     {
3337       gdk_window_unref (widget->window);
3338     }
3339
3340   /* Unrealize afterwards to improve visual effect */
3341
3342   if (GTK_IS_CONTAINER (widget))
3343     gtk_container_foreach (GTK_CONTAINER (widget),
3344                            (GtkCallback)gtk_widget_unrealize,
3345                            NULL);
3346
3347   widget->window = NULL;
3348 }
3349
3350 /*****************************************
3351  * gtk_widget_real_draw:
3352  *
3353  *   arguments:
3354  *
3355  *   results:
3356  *****************************************/
3357
3358 static void
3359 gtk_widget_real_draw (GtkWidget    *widget,
3360                       GdkRectangle *area)
3361 {
3362   GdkEventExpose event;
3363
3364   g_return_if_fail (widget != NULL);
3365   g_return_if_fail (GTK_IS_WIDGET (widget));
3366   g_return_if_fail (area != NULL);
3367
3368   if (GTK_WIDGET_DRAWABLE (widget))
3369     {
3370       event.type = GDK_EXPOSE;
3371       event.window = widget->window;
3372       event.area = *area;
3373
3374       gdk_window_ref (event.window);
3375       gtk_widget_event (widget, (GdkEvent*) &event);
3376       gdk_window_unref (event.window);
3377     }
3378 }
3379
3380 /*****************************************
3381  * gtk_widget_real_queue_draw:
3382  *
3383  *   arguments:
3384  *
3385  *   results:
3386  *****************************************/
3387
3388 static gint
3389 gtk_widget_real_queue_draw (GtkWidget *widget)
3390 {
3391   g_return_val_if_fail (widget != NULL, FALSE);
3392   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3393
3394   GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
3395   gtk_widget_draw (widget, NULL);
3396
3397   return FALSE;
3398 }
3399
3400 /*****************************************
3401  * gtk_widget_real_queue_resize:
3402  *
3403  *   arguments:
3404  *
3405  *   results:
3406  *****************************************/
3407
3408 static gint
3409 gtk_widget_real_queue_resize (GtkWidget *widget)
3410 {
3411   g_return_val_if_fail (widget != NULL, FALSE);
3412   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3413
3414   GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
3415   gtk_container_need_resize (GTK_CONTAINER (widget));
3416
3417   return FALSE;
3418 }
3419
3420 /*****************************************
3421  * gtk_widget_real_size_allocate:
3422  *
3423  *   arguments:
3424  *
3425  *   results:
3426  *****************************************/
3427
3428 static void
3429 gtk_widget_real_size_allocate (GtkWidget     *widget,
3430                                GtkAllocation *allocation)
3431 {
3432   g_return_if_fail (widget != NULL);
3433   g_return_if_fail (GTK_IS_WIDGET (widget));
3434
3435   if (GTK_WIDGET_NO_WINDOW (widget) &&
3436       GTK_WIDGET_MAPPED (widget) &&
3437       ((widget->allocation.x != allocation->x) ||
3438        (widget->allocation.y != allocation->y) ||
3439        (widget->allocation.width != allocation->width) ||
3440        (widget->allocation.height != allocation->height)) &&
3441       (widget->allocation.width != 0) &&
3442       (widget->allocation.height != 0))
3443     gdk_window_clear_area (widget->window,
3444                            widget->allocation.x,
3445                            widget->allocation.y,
3446                            widget->allocation.width,
3447                            widget->allocation.height);
3448
3449   widget->allocation = *allocation;
3450
3451   if (GTK_WIDGET_REALIZED (widget) &&
3452       !GTK_WIDGET_NO_WINDOW (widget))
3453     gdk_window_move_resize (widget->window,
3454                             allocation->x, allocation->y,
3455                             allocation->width, allocation->height);
3456 }
3457
3458 /*****************************************
3459  * gtk_widget_peek_colormap:
3460  *
3461  *   arguments:
3462  *
3463  *   results:
3464  *****************************************/
3465
3466 static GdkColormap*
3467 gtk_widget_peek_colormap ()
3468 {
3469   if (colormap_stack)
3470     return (GdkColormap*) colormap_stack->data;
3471   return gtk_widget_get_default_colormap ();
3472 }
3473
3474 /*****************************************
3475  * gtk_widget_peek_visual:
3476  *
3477  *   arguments:
3478  *
3479  *   results:
3480  *****************************************/
3481
3482 static GdkVisual*
3483 gtk_widget_peek_visual ()
3484 {
3485   if (visual_stack)
3486     return (GdkVisual*) visual_stack->data;
3487   return gtk_widget_get_default_visual ();
3488 }
3489
3490 /*****************************************
3491  * gtk_widget_peek_style:
3492  *
3493  *   arguments:
3494  *
3495  *   results:
3496  *****************************************/
3497
3498 static GtkStyle*
3499 gtk_widget_peek_style ()
3500 {
3501   if (style_stack)
3502     return (GtkStyle*) style_stack->data;
3503   return gtk_widget_get_default_style ();
3504 }
3505
3506 /*************************************************************
3507  * gtk_widget_propagate_state:
3508  *     Propagate a change in the widgets state down the tree
3509  *
3510  *   arguments:
3511  *     widget
3512  *     GtkStateData: state
3513  *                   parent_sensitive
3514  *
3515  *   results:
3516  *************************************************************/
3517
3518 void
3519 gtk_widget_propagate_state (GtkWidget           *widget,
3520                             GtkStateData        *data)
3521 {
3522   guint8 old_state;
3523
3524   /* don't call this function with state=GTK_STATE_INSENSITIVE,
3525    * parent_sensitive=TRUE and a sensitive widget
3526    */
3527
3528   old_state = GTK_WIDGET_STATE (widget);
3529
3530   if (data->parent_sensitive)
3531     {
3532       GTK_WIDGET_SET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3533
3534       if (GTK_WIDGET_IS_SENSITIVE (widget))
3535         GTK_WIDGET_STATE (widget) = data->state;
3536       else
3537         {
3538           GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3539           if (data->state != GTK_STATE_INSENSITIVE)
3540             GTK_WIDGET_SAVED_STATE (widget) = data->state;
3541         }
3542     }
3543   else
3544     {
3545       GTK_WIDGET_UNSET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3546       GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3547       if (data->state != GTK_STATE_INSENSITIVE)
3548         GTK_WIDGET_SAVED_STATE (widget) = data->state;
3549     }
3550
3551   if (GTK_WIDGET_HAS_FOCUS (widget) && !GTK_WIDGET_IS_SENSITIVE (widget))
3552     {
3553       GtkWidget *window;
3554
3555       window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
3556       if (window)
3557         gtk_window_set_focus (GTK_WINDOW (window), NULL);
3558     }
3559
3560   if (old_state != GTK_WIDGET_STATE (widget))
3561     {
3562       gtk_widget_ref (widget);
3563       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[STATE_CHANGED], old_state);
3564
3565       if (GTK_IS_CONTAINER (widget))
3566         {
3567           data->parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
3568           data->state = GTK_WIDGET_STATE (widget);
3569           gtk_container_foreach (GTK_CONTAINER (widget),
3570                                  (GtkCallback) gtk_widget_propagate_state,
3571                                  data);
3572         }
3573       gtk_widget_unref (widget);
3574     }
3575 }
3576
3577 /*****************************************
3578  * gtk_widget_draw_children_recurse:
3579  *
3580  *   arguments:
3581  *
3582  *   results:
3583  *****************************************/
3584
3585 static void
3586 gtk_widget_draw_children_recurse (GtkWidget *widget,
3587                                   gpointer   client_data)
3588 {
3589   gtk_widget_draw (widget, NULL);
3590   gtk_widget_draw_children (widget);
3591 }
3592
3593 /*****************************************
3594  * gtk_widget_set_style_internal:
3595  *
3596  *   arguments:
3597  *
3598  *   results:
3599  *****************************************/
3600
3601 static void
3602 gtk_widget_set_style_internal (GtkWidget *widget,
3603                                GtkStyle  *style)
3604 {
3605   GtkRequisition old_requisition;
3606
3607   g_return_if_fail (widget != NULL);
3608
3609   if (widget->style != style)
3610     {
3611       if (GTK_WIDGET_REALIZED (widget))
3612         gtk_style_detach (widget->style);
3613
3614       gtk_style_unref (widget->style);
3615       widget->style = style;
3616       gtk_style_ref (widget->style);
3617
3618       if (GTK_WIDGET_REALIZED (widget))
3619         widget->style = gtk_style_attach (widget->style, widget->window);
3620
3621       if (widget->parent)
3622         {
3623           old_requisition = widget->requisition;
3624           gtk_widget_size_request (widget, &widget->requisition);
3625
3626           if ((old_requisition.width != widget->requisition.width) ||
3627               (old_requisition.height != widget->requisition.height))
3628             gtk_widget_queue_resize (widget);
3629           else if (GTK_WIDGET_DRAWABLE (widget))
3630             gtk_widget_queue_draw (widget);
3631         }
3632     }
3633 }
3634
3635 /*****************************************
3636  * gtk_widget_set_style_recurse:
3637  *
3638  *   arguments:
3639  *
3640  *   results:
3641  *****************************************/
3642
3643 static void
3644 gtk_widget_set_style_recurse (GtkWidget *widget,
3645                               gpointer   client_data)
3646 {
3647   GtkStyle *style;
3648
3649   style = gtk_rc_get_style (widget);
3650   if (style != widget->style)
3651     gtk_widget_set_style_internal (widget, style);
3652
3653   if (GTK_IS_CONTAINER (widget))
3654     gtk_container_foreach (GTK_CONTAINER (widget),
3655                            gtk_widget_set_style_recurse,
3656                            NULL);
3657 }
3658
3659 /*****************************************
3660  * gtk_widget_aux_info_new:
3661  *
3662  *   arguments:
3663  *
3664  *   results:
3665  *****************************************/
3666
3667 static GtkWidgetAuxInfo*
3668 gtk_widget_aux_info_new ()
3669 {
3670   GtkWidgetAuxInfo *aux_info;
3671
3672   if (!aux_info_mem_chunk)
3673     aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk",
3674                                           sizeof (GtkWidgetAuxInfo),
3675                                           1024, G_ALLOC_AND_FREE);
3676
3677   aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk);
3678
3679   aux_info->x = -1;
3680   aux_info->y = -1;
3681   aux_info->width = 0;
3682   aux_info->height = 0;
3683
3684   return aux_info;
3685 }
3686
3687 /*****************************************
3688  * gtk_widget_aux_info_destroy:
3689  *
3690  *   arguments:
3691  *
3692  *   results:
3693  *****************************************/
3694
3695 static void
3696 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
3697 {
3698   g_return_if_fail (aux_info != NULL);
3699
3700   g_mem_chunk_free (aux_info_mem_chunk, aux_info);
3701 }
3702
3703 /*****************************************
3704  * gtk_widget_shape_combine_mask:
3705  *   set a shape for this widgets' gdk window, this allows for
3706  *   transparent windows etc., see gdk_window_shape_combine_mask
3707  *   for more information
3708  *
3709  *   arguments:
3710  *
3711  *   results:
3712  *****************************************/
3713 void
3714 gtk_widget_shape_combine_mask (GtkWidget *widget,
3715                                GdkBitmap *shape_mask,
3716                                gint       offset_x,
3717                                gint       offset_y)
3718 {
3719   GtkWidgetShapeInfo* shape_info;
3720
3721   g_return_if_fail (widget != NULL);
3722   /*  set_shape doesn't work on widgets without gdk window */
3723   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
3724
3725   if (!shape_mask)
3726     {
3727       GTK_PRIVATE_UNSET_FLAG (widget, GTK_HAS_SHAPE_MASK);
3728
3729       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3730       gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key);
3731       g_free (shape_info);
3732
3733       if (widget->window)
3734         {
3735           /* FIXME: we need gdk code here that removes the shape from a window
3736            */
3737         }
3738     }
3739   else
3740     {
3741       GTK_PRIVATE_SET_FLAG (widget, GTK_HAS_SHAPE_MASK);
3742
3743       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3744       if (!shape_info)
3745         {
3746           shape_info = g_new (GtkWidgetShapeInfo, 1);
3747           gtk_object_set_data (GTK_OBJECT (widget), shape_info_key, shape_info);
3748         }
3749       shape_info->shape_mask = shape_mask;
3750       shape_info->offset_x = offset_x;
3751       shape_info->offset_y = offset_y;
3752
3753       /* set shape if widget has a gdk window allready.
3754        * otherwise the shape is scheduled to be set by gtk_widget_realize.
3755        */
3756       if (widget->window)
3757         gdk_window_shape_combine_mask (widget->window, shape_mask,
3758                                        offset_x, offset_y);
3759     }
3760 }
3761
3762 /*****************************************
3763  * gtk_widget_dnd_drag_add:
3764  *   when you get a DRAG_ENTER event, you can use this
3765  *   to tell Gtk ofother widgets that are to be dragged as well
3766  *
3767  *   arguments:
3768  *
3769  *   results:
3770  *****************************************/
3771 void
3772 gtk_widget_dnd_drag_add (GtkWidget *widget)
3773 {
3774 }
3775
3776 /*****************************************
3777  * gtk_widget_dnd_drag_set:
3778  *   these two functions enable drag and/or drop on a
3779  *   widget and also let Gtk know what data types will be accepted
3780  *   use MIME type naming,plus tacking "URL:" on the front for link
3781  *   dragging
3782  *
3783  *
3784  *   arguments:
3785  *
3786  *   results:
3787  *****************************************/
3788 void
3789 gtk_widget_dnd_drag_set (GtkWidget   *widget,
3790                          guint8       drag_enable,
3791                          gchar      **type_accept_list,
3792                          guint        numtypes)
3793 {
3794   g_return_if_fail(widget != NULL);
3795
3796   if (!widget->window)
3797     gtk_widget_realize (widget);
3798
3799   g_return_if_fail (widget->window != NULL);
3800   gdk_window_dnd_drag_set (widget->window,
3801                            drag_enable,
3802                            type_accept_list,
3803                            numtypes);
3804 }
3805
3806 /*****************************************
3807  * gtk_widget_dnd_drop_set:
3808  *
3809  *   arguments:
3810  *
3811  *   results:
3812  *****************************************/
3813 void
3814 gtk_widget_dnd_drop_set (GtkWidget   *widget,
3815                          guint8       drop_enable,
3816                          gchar      **type_accept_list,
3817                          guint        numtypes,
3818                          guint8       is_destructive_operation)
3819 {
3820   g_return_if_fail(widget != NULL);
3821
3822   if (!widget->window)
3823     gtk_widget_realize (widget);
3824
3825   g_return_if_fail (widget->window != NULL);
3826   gdk_window_dnd_drop_set (widget->window,
3827                            drop_enable,
3828                            type_accept_list,
3829                            numtypes,
3830                            is_destructive_operation);
3831 }
3832
3833 /*****************************************
3834  * gtk_widget_dnd_data_set:
3835  *
3836  *   arguments:
3837  *
3838  *   results:
3839  *****************************************/
3840 void
3841 gtk_widget_dnd_data_set (GtkWidget   *widget,
3842                          GdkEvent    *event,
3843                          gpointer     data,
3844                          gulong       data_numbytes)
3845 {
3846   g_return_if_fail (widget != NULL);
3847   g_return_if_fail (widget->window != NULL);
3848
3849   gdk_window_dnd_data_set (widget->window, event, data, data_numbytes);
3850 }
3851
3852
3853 #undef  gtk_widget_ref
3854 #undef  gtk_widget_unref
3855
3856
3857 void
3858 gtk_widget_ref (GtkWidget *widget)
3859 {
3860   gtk_object_ref (GTK_OBJECT (widget));
3861 }
3862
3863 void
3864 gtk_widget_unref (GtkWidget *widget)
3865 {
3866   gtk_object_unref (GTK_OBJECT (widget));
3867 }
3868