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