1997-11-24 22:37:52 +00:00
|
|
|
/* GTK - The GIMP Toolkit
|
|
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
1997-11-28 01:22:38 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
1997-11-24 22:37:52 +00:00
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
1998-04-13 02:02:47 +00:00
|
|
|
* License along with this library; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
1997-11-24 22:37:52 +00:00
|
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "gtkcontainer.h"
|
|
|
|
#include "gtkmain.h"
|
|
|
|
#include "gtkrc.h"
|
|
|
|
#include "gtkselection.h"
|
|
|
|
#include "gtksignal.h"
|
|
|
|
#include "gtkwidget.h"
|
|
|
|
#include "gtkwindow.h"
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
#include "gtkprivate.h"
|
1997-11-24 22:37:52 +00:00
|
|
|
#include "gdk/gdk.h"
|
|
|
|
#include "gdk/gdkx.h"
|
|
|
|
|
|
|
|
|
1997-11-28 01:22:38 +00:00
|
|
|
#define WIDGET_CLASS(w) GTK_WIDGET_CLASS (GTK_OBJECT (w)->klass)
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
SHOW,
|
|
|
|
HIDE,
|
|
|
|
MAP,
|
|
|
|
UNMAP,
|
|
|
|
REALIZE,
|
|
|
|
UNREALIZE,
|
|
|
|
DRAW,
|
|
|
|
DRAW_FOCUS,
|
|
|
|
DRAW_DEFAULT,
|
|
|
|
SIZE_REQUEST,
|
|
|
|
SIZE_ALLOCATE,
|
|
|
|
STATE_CHANGED,
|
1998-02-22 02:18:29 +00:00
|
|
|
PARENT_SET,
|
1998-02-26 01:48:28 +00:00
|
|
|
STYLE_SET,
|
1997-11-24 22:37:52 +00:00
|
|
|
INSTALL_ACCELERATOR,
|
|
|
|
REMOVE_ACCELERATOR,
|
|
|
|
EVENT,
|
|
|
|
BUTTON_PRESS_EVENT,
|
|
|
|
BUTTON_RELEASE_EVENT,
|
|
|
|
MOTION_NOTIFY_EVENT,
|
|
|
|
DELETE_EVENT,
|
|
|
|
DESTROY_EVENT,
|
|
|
|
EXPOSE_EVENT,
|
|
|
|
KEY_PRESS_EVENT,
|
|
|
|
KEY_RELEASE_EVENT,
|
|
|
|
ENTER_NOTIFY_EVENT,
|
|
|
|
LEAVE_NOTIFY_EVENT,
|
|
|
|
CONFIGURE_EVENT,
|
|
|
|
FOCUS_IN_EVENT,
|
|
|
|
FOCUS_OUT_EVENT,
|
|
|
|
MAP_EVENT,
|
|
|
|
UNMAP_EVENT,
|
|
|
|
PROPERTY_NOTIFY_EVENT,
|
|
|
|
SELECTION_CLEAR_EVENT,
|
|
|
|
SELECTION_REQUEST_EVENT,
|
|
|
|
SELECTION_NOTIFY_EVENT,
|
|
|
|
SELECTION_RECEIVED,
|
|
|
|
PROXIMITY_IN_EVENT,
|
|
|
|
PROXIMITY_OUT_EVENT,
|
|
|
|
DRAG_BEGIN_EVENT,
|
|
|
|
DRAG_REQUEST_EVENT,
|
1998-03-01 22:37:30 +00:00
|
|
|
DRAG_END_EVENT,
|
1997-11-24 22:37:52 +00:00
|
|
|
DROP_ENTER_EVENT,
|
|
|
|
DROP_LEAVE_EVENT,
|
|
|
|
DROP_DATA_AVAILABLE_EVENT,
|
|
|
|
OTHER_EVENT,
|
1997-11-28 06:47:01 +00:00
|
|
|
CLIENT_EVENT,
|
1998-01-30 23:47:09 +00:00
|
|
|
NO_EXPOSE_EVENT,
|
1997-11-24 22:37:52 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
1998-01-16 00:49:51 +00:00
|
|
|
enum {
|
|
|
|
ARG_0,
|
1998-03-15 21:14:28 +00:00
|
|
|
ARG_NAME,
|
|
|
|
ARG_PARENT,
|
1998-01-16 00:49:51 +00:00
|
|
|
ARG_X,
|
|
|
|
ARG_Y,
|
|
|
|
ARG_WIDTH,
|
|
|
|
ARG_HEIGHT,
|
|
|
|
ARG_VISIBLE,
|
|
|
|
ARG_SENSITIVE,
|
1998-01-18 03:09:42 +00:00
|
|
|
ARG_CAN_FOCUS,
|
1998-01-18 11:09:04 +00:00
|
|
|
ARG_HAS_FOCUS,
|
1998-01-18 03:09:42 +00:00
|
|
|
ARG_CAN_DEFAULT,
|
1998-01-18 11:09:04 +00:00
|
|
|
ARG_HAS_DEFAULT,
|
1998-01-16 00:49:51 +00:00
|
|
|
ARG_STYLE,
|
1998-03-15 21:14:28 +00:00
|
|
|
ARG_EVENTS,
|
|
|
|
ARG_EXTENSION_EVENTS
|
1998-01-16 00:49:51 +00:00
|
|
|
};
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
typedef void (*GtkWidgetSignal1) (GtkObject *object,
|
|
|
|
gpointer arg1,
|
|
|
|
gpointer data);
|
|
|
|
typedef gint (*GtkWidgetSignal2) (GtkObject *object,
|
|
|
|
gpointer arg1,
|
1997-11-28 01:22:38 +00:00
|
|
|
gchar arg2,
|
|
|
|
gchar arg3,
|
1997-11-24 22:37:52 +00:00
|
|
|
gpointer data);
|
|
|
|
typedef void (*GtkWidgetSignal3) (GtkObject *object,
|
|
|
|
gpointer arg1,
|
|
|
|
gpointer data);
|
|
|
|
typedef gint (*GtkWidgetSignal4) (GtkObject *object,
|
|
|
|
gpointer arg1,
|
|
|
|
gpointer data);
|
1998-01-20 23:58:42 +00:00
|
|
|
typedef void (*GtkWidgetSignal5) (GtkObject *object,
|
|
|
|
guint arg1,
|
|
|
|
gpointer data);
|
1998-02-18 04:09:13 +00:00
|
|
|
typedef void (*GtkWidgetSignal6) (GtkObject *object,
|
|
|
|
GtkObject *arg1,
|
|
|
|
gpointer data);
|
1998-02-27 16:31:06 +00:00
|
|
|
typedef void (*GtkWidgetSignal7) (GtkObject *object,
|
1998-03-01 23:29:40 +00:00
|
|
|
gpointer arg1,
|
1998-02-27 16:31:06 +00:00
|
|
|
gpointer data);
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
typedef struct _GtkStateData GtkStateData;
|
|
|
|
|
|
|
|
struct _GtkStateData
|
|
|
|
{
|
|
|
|
GtkStateType state;
|
1998-03-26 21:57:45 +00:00
|
|
|
guint state_restauration : 1;
|
|
|
|
guint parent_sensitive : 1;
|
1998-01-20 23:58:42 +00:00
|
|
|
};
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
1997-11-28 01:22:38 +00:00
|
|
|
static void gtk_widget_marshal_signal_1 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
|
|
|
static void gtk_widget_marshal_signal_2 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
|
|
|
static void gtk_widget_marshal_signal_3 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
|
|
|
static void gtk_widget_marshal_signal_4 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
1998-01-20 23:58:42 +00:00
|
|
|
static void gtk_widget_marshal_signal_5 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
1998-02-18 04:09:13 +00:00
|
|
|
static void gtk_widget_marshal_signal_6 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
1998-02-27 16:31:06 +00:00
|
|
|
static void gtk_widget_marshal_signal_7 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
|
|
|
static void gtk_widget_class_init (GtkWidgetClass *klass);
|
|
|
|
static void gtk_widget_init (GtkWidget *widget);
|
1998-01-16 00:49:51 +00:00
|
|
|
static void gtk_widget_set_arg (GtkWidget *widget,
|
|
|
|
GtkArg *arg,
|
|
|
|
guint arg_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
static void gtk_widget_get_arg (GtkWidget *widget,
|
|
|
|
GtkArg *arg,
|
|
|
|
guint arg_id);
|
1998-03-14 04:43:14 +00:00
|
|
|
static void gtk_widget_shutdown (GtkObject *object);
|
1998-01-30 23:47:09 +00:00
|
|
|
static void gtk_widget_real_destroy (GtkObject *object);
|
1998-03-14 04:43:14 +00:00
|
|
|
static void gtk_widget_finalize (GtkObject *object);
|
1998-01-30 23:47:09 +00:00
|
|
|
static void gtk_widget_real_show (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_hide (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_map (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_unmap (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_realize (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_unrealize (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_draw (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
GdkRectangle *area);
|
1998-01-30 23:47:09 +00:00
|
|
|
static gint gtk_widget_real_queue_draw (GtkWidget *widget);
|
|
|
|
static void gtk_widget_real_size_allocate (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
GtkAllocation *allocation);
|
1998-02-27 16:31:06 +00:00
|
|
|
static void gtk_widget_style_set (GtkWidget *widget,
|
|
|
|
GtkStyle *previous_style);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
static GdkColormap* gtk_widget_peek_colormap (void);
|
|
|
|
static GdkVisual* gtk_widget_peek_visual (void);
|
|
|
|
static GtkStyle* gtk_widget_peek_style (void);
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
static void gtk_widget_reparent_container_child (GtkWidget *widget,
|
|
|
|
gpointer client_data);
|
1998-01-20 23:58:42 +00:00
|
|
|
static void gtk_widget_propagate_state (GtkWidget *widget,
|
|
|
|
GtkStateData *data);
|
|
|
|
static void gtk_widget_draw_children_recurse (GtkWidget *widget,
|
|
|
|
gpointer client_data);
|
|
|
|
static void gtk_widget_set_style_internal (GtkWidget *widget,
|
1998-02-27 22:09:20 +00:00
|
|
|
GtkStyle *style,
|
|
|
|
gboolean initial_emission);
|
1998-01-20 23:58:42 +00:00
|
|
|
static void gtk_widget_set_style_recurse (GtkWidget *widget,
|
|
|
|
gpointer client_data);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-01-16 05:11:10 +00:00
|
|
|
extern GtkArg* gtk_object_collect_args (guint *nargs,
|
1997-11-28 01:22:38 +00:00
|
|
|
va_list args1,
|
|
|
|
va_list args2);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
static GtkWidgetAuxInfo* gtk_widget_aux_info_new (void);
|
1997-11-28 01:22:38 +00:00
|
|
|
static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
static GtkObjectClass *parent_class = NULL;
|
1998-03-09 15:16:28 +00:00
|
|
|
static guint widget_signals[LAST_SIGNAL] = { 0 };
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
static GMemChunk *aux_info_mem_chunk = NULL;
|
|
|
|
|
|
|
|
static GdkColormap *default_colormap = NULL;
|
|
|
|
static GdkVisual *default_visual = NULL;
|
|
|
|
static GtkStyle *default_style = NULL;
|
|
|
|
|
|
|
|
static GSList *colormap_stack = NULL;
|
|
|
|
static GSList *visual_stack = NULL;
|
|
|
|
static GSList *style_stack = NULL;
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
static GSList *gtk_widget_redraw_queue = NULL;
|
|
|
|
static GSList *gtk_widget_resize_queue = NULL;
|
|
|
|
|
1998-02-02 14:11:24 +00:00
|
|
|
static const gchar *aux_info_key = "gtk-aux-info";
|
1998-03-14 04:43:14 +00:00
|
|
|
static guint aux_info_key_id = 0;
|
1998-02-02 14:11:24 +00:00
|
|
|
static const gchar *event_key = "gtk-event-mask";
|
1998-03-14 04:43:14 +00:00
|
|
|
static guint event_key_id = 0;
|
1998-02-02 14:11:24 +00:00
|
|
|
static const gchar *extension_event_key = "gtk-extension-event-mode";
|
1998-03-14 04:43:14 +00:00
|
|
|
static guint extension_event_key_id = 0;
|
1998-02-02 14:11:24 +00:00
|
|
|
static const gchar *parent_window_key = "gtk-parent-window";
|
1998-03-14 04:43:14 +00:00
|
|
|
static guint parent_window_key_id = 0;
|
1998-02-28 19:09:20 +00:00
|
|
|
static const gchar *saved_default_style_key = "gtk-saved-default-style";
|
1998-03-14 04:43:14 +00:00
|
|
|
static guint saved_default_style_key_id = 0;
|
|
|
|
static const gchar *shape_info_key = "gtk-shape-info";
|
|
|
|
static const gchar *colormap_key = "gtk-colormap";
|
|
|
|
static const gchar *visual_key = "gtk-visual";
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_type:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
1998-05-01 04:23:59 +00:00
|
|
|
GtkType
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_widget_get_type ()
|
|
|
|
{
|
1998-05-01 04:23:59 +00:00
|
|
|
static GtkType widget_type = 0;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!widget_type)
|
|
|
|
{
|
|
|
|
GtkTypeInfo widget_info =
|
|
|
|
{
|
|
|
|
"GtkWidget",
|
|
|
|
sizeof (GtkWidget),
|
|
|
|
sizeof (GtkWidgetClass),
|
|
|
|
(GtkClassInitFunc) gtk_widget_class_init,
|
|
|
|
(GtkObjectInitFunc) gtk_widget_init,
|
1998-01-16 00:49:51 +00:00
|
|
|
(GtkArgSetFunc) gtk_widget_set_arg,
|
1998-01-18 03:09:42 +00:00
|
|
|
(GtkArgGetFunc) gtk_widget_get_arg,
|
1997-11-24 22:37:52 +00:00
|
|
|
};
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return widget_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_class_init:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_class_init (GtkWidgetClass *klass)
|
|
|
|
{
|
|
|
|
GtkObjectClass *object_class;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
object_class = (GtkObjectClass*) klass;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
parent_class = gtk_type_class (gtk_object_get_type ());
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-15 21:14:28 +00:00
|
|
|
gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT);
|
1998-02-19 07:18:42 +00:00
|
|
|
gtk_object_add_arg_type ("GtkWidget::x", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_X);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::y", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_Y);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WIDTH);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_HEIGHT);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::visible", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBLE);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::sensitive", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SENSITIVE);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::can_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_FOCUS);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_FOCUS);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_DEFAULT);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_DEFAULT);
|
1998-03-15 21:14:28 +00:00
|
|
|
gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, GTK_ARG_READWRITE, ARG_STYLE);
|
1998-02-19 07:18:42 +00:00
|
|
|
gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EVENTS);
|
|
|
|
gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EXTENSION_EVENTS);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget_signals[SHOW] =
|
|
|
|
gtk_signal_new ("show",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[HIDE] =
|
|
|
|
gtk_signal_new ("hide",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[MAP] =
|
|
|
|
gtk_signal_new ("map",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[UNMAP] =
|
|
|
|
gtk_signal_new ("unmap",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[REALIZE] =
|
|
|
|
gtk_signal_new ("realize",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[UNREALIZE] =
|
|
|
|
gtk_signal_new ("unrealize",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[DRAW] =
|
|
|
|
gtk_signal_new ("draw",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
|
|
|
|
gtk_widget_marshal_signal_1,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_POINTER);
|
|
|
|
widget_signals[DRAW_FOCUS] =
|
|
|
|
gtk_signal_new ("draw_focus",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[DRAW_DEFAULT] =
|
|
|
|
gtk_signal_new ("draw_default",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default),
|
|
|
|
gtk_signal_default_marshaller,
|
|
|
|
GTK_TYPE_NONE, 0);
|
|
|
|
widget_signals[SIZE_REQUEST] =
|
|
|
|
gtk_signal_new ("size_request",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request),
|
|
|
|
gtk_widget_marshal_signal_1,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_POINTER);
|
|
|
|
widget_signals[SIZE_ALLOCATE] =
|
|
|
|
gtk_signal_new ("size_allocate",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
|
|
|
|
gtk_widget_marshal_signal_1,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_POINTER);
|
|
|
|
widget_signals[STATE_CHANGED] =
|
|
|
|
gtk_signal_new ("state_changed",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
|
1998-01-20 23:58:42 +00:00
|
|
|
gtk_widget_marshal_signal_5,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_UINT);
|
1998-02-22 02:18:29 +00:00
|
|
|
widget_signals[PARENT_SET] =
|
|
|
|
gtk_signal_new ("parent_set",
|
1998-02-18 04:09:13 +00:00
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
1998-02-22 02:18:29 +00:00
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
|
1998-02-18 04:09:13 +00:00
|
|
|
gtk_widget_marshal_signal_6,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_OBJECT);
|
1998-02-26 01:48:28 +00:00
|
|
|
widget_signals[STYLE_SET] =
|
|
|
|
gtk_signal_new ("style_set",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
|
1998-02-27 16:31:06 +00:00
|
|
|
gtk_widget_marshal_signal_7,
|
1998-02-26 01:48:28 +00:00
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_BOXED);
|
1997-11-24 22:37:52 +00:00
|
|
|
widget_signals[INSTALL_ACCELERATOR] =
|
|
|
|
gtk_signal_new ("install_accelerator",
|
1998-04-24 00:26:01 +00:00
|
|
|
GTK_RUN_LAST,
|
1997-11-24 22:37:52 +00:00
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, install_accelerator),
|
|
|
|
gtk_widget_marshal_signal_2,
|
|
|
|
GTK_TYPE_BOOL, 3,
|
|
|
|
GTK_TYPE_STRING,
|
|
|
|
GTK_TYPE_CHAR,
|
|
|
|
GTK_TYPE_INT);
|
|
|
|
widget_signals[REMOVE_ACCELERATOR] =
|
|
|
|
gtk_signal_new ("remove_accelerator",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator),
|
|
|
|
gtk_widget_marshal_signal_3,
|
|
|
|
GTK_TYPE_NONE, 1,
|
|
|
|
GTK_TYPE_STRING);
|
|
|
|
widget_signals[EVENT] =
|
|
|
|
gtk_signal_new ("event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[BUTTON_PRESS_EVENT] =
|
|
|
|
gtk_signal_new ("button_press_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[BUTTON_RELEASE_EVENT] =
|
|
|
|
gtk_signal_new ("button_release_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[MOTION_NOTIFY_EVENT] =
|
|
|
|
gtk_signal_new ("motion_notify_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DELETE_EVENT] =
|
|
|
|
gtk_signal_new ("delete_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DESTROY_EVENT] =
|
|
|
|
gtk_signal_new ("destroy_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[EXPOSE_EVENT] =
|
|
|
|
gtk_signal_new ("expose_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[KEY_PRESS_EVENT] =
|
|
|
|
gtk_signal_new ("key_press_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[KEY_RELEASE_EVENT] =
|
|
|
|
gtk_signal_new ("key_release_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[ENTER_NOTIFY_EVENT] =
|
|
|
|
gtk_signal_new ("enter_notify_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[LEAVE_NOTIFY_EVENT] =
|
|
|
|
gtk_signal_new ("leave_notify_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[CONFIGURE_EVENT] =
|
|
|
|
gtk_signal_new ("configure_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[FOCUS_IN_EVENT] =
|
|
|
|
gtk_signal_new ("focus_in_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[FOCUS_OUT_EVENT] =
|
|
|
|
gtk_signal_new ("focus_out_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[MAP_EVENT] =
|
|
|
|
gtk_signal_new ("map_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[UNMAP_EVENT] =
|
|
|
|
gtk_signal_new ("unmap_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[PROPERTY_NOTIFY_EVENT] =
|
|
|
|
gtk_signal_new ("property_notify_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[SELECTION_CLEAR_EVENT] =
|
|
|
|
gtk_signal_new ("selection_clear_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[SELECTION_REQUEST_EVENT] =
|
|
|
|
gtk_signal_new ("selection_request_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[SELECTION_NOTIFY_EVENT] =
|
|
|
|
gtk_signal_new ("selection_notify_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[SELECTION_RECEIVED] =
|
|
|
|
gtk_signal_new ("selection_received",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
|
|
|
|
gtk_widget_marshal_signal_1,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[PROXIMITY_IN_EVENT] =
|
|
|
|
gtk_signal_new ("proximity_in_event",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[PROXIMITY_OUT_EVENT] =
|
|
|
|
gtk_signal_new ("proximity_out_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DRAG_BEGIN_EVENT] =
|
|
|
|
gtk_signal_new ("drag_begin_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DRAG_REQUEST_EVENT] =
|
|
|
|
gtk_signal_new ("drag_request_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_request_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
1998-03-01 22:37:30 +00:00
|
|
|
widget_signals[DRAG_END_EVENT] =
|
|
|
|
gtk_signal_new ("drag_end_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
1997-11-24 22:37:52 +00:00
|
|
|
widget_signals[DROP_ENTER_EVENT] =
|
|
|
|
gtk_signal_new ("drop_enter_event",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_enter_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DROP_LEAVE_EVENT] =
|
|
|
|
gtk_signal_new ("drop_leave_event",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_leave_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[DROP_DATA_AVAILABLE_EVENT] =
|
|
|
|
gtk_signal_new ("drop_data_available_event",
|
|
|
|
GTK_RUN_FIRST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass,
|
|
|
|
drop_data_available_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
|
|
|
widget_signals[OTHER_EVENT] =
|
|
|
|
gtk_signal_new ("other_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, other_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
1997-11-28 06:47:01 +00:00
|
|
|
widget_signals[CLIENT_EVENT] =
|
|
|
|
gtk_signal_new ("client_event",
|
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event),
|
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
1998-01-30 23:47:09 +00:00
|
|
|
widget_signals[NO_EXPOSE_EVENT] =
|
|
|
|
gtk_signal_new ("no_expose_event",
|
1998-01-06 01:17:10 +00:00
|
|
|
GTK_RUN_LAST,
|
|
|
|
object_class->type,
|
1998-01-30 23:47:09 +00:00
|
|
|
GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event),
|
1998-01-06 01:17:10 +00:00
|
|
|
gtk_widget_marshal_signal_4,
|
|
|
|
GTK_TYPE_BOOL, 1,
|
|
|
|
GTK_TYPE_GDK_EVENT);
|
1997-11-28 06:47:01 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
object_class->shutdown = gtk_widget_shutdown;
|
1998-01-30 23:47:09 +00:00
|
|
|
object_class->destroy = gtk_widget_real_destroy;
|
1998-03-14 04:43:14 +00:00
|
|
|
object_class->finalize = gtk_widget_finalize;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
klass->activate_signal = 0;
|
1998-01-30 23:47:09 +00:00
|
|
|
klass->show = gtk_widget_real_show;
|
|
|
|
klass->hide = gtk_widget_real_hide;
|
|
|
|
klass->show_all = gtk_widget_real_show;
|
|
|
|
klass->hide_all = gtk_widget_real_hide;
|
|
|
|
klass->map = gtk_widget_real_map;
|
|
|
|
klass->unmap = gtk_widget_real_unmap;
|
|
|
|
klass->realize = gtk_widget_real_realize;
|
|
|
|
klass->unrealize = gtk_widget_real_unrealize;
|
|
|
|
klass->draw = gtk_widget_real_draw;
|
1997-11-24 22:37:52 +00:00
|
|
|
klass->draw_focus = NULL;
|
|
|
|
klass->size_request = NULL;
|
1998-01-30 23:47:09 +00:00
|
|
|
klass->size_allocate = gtk_widget_real_size_allocate;
|
1997-11-24 22:37:52 +00:00
|
|
|
klass->state_changed = NULL;
|
1998-02-22 02:18:29 +00:00
|
|
|
klass->parent_set = NULL;
|
1998-02-27 16:31:06 +00:00
|
|
|
klass->style_set = gtk_widget_style_set;
|
1997-11-24 22:37:52 +00:00
|
|
|
klass->install_accelerator = NULL;
|
|
|
|
klass->remove_accelerator = NULL;
|
|
|
|
klass->event = NULL;
|
|
|
|
klass->button_press_event = NULL;
|
|
|
|
klass->button_release_event = NULL;
|
|
|
|
klass->motion_notify_event = NULL;
|
|
|
|
klass->delete_event = NULL;
|
|
|
|
klass->destroy_event = NULL;
|
|
|
|
klass->expose_event = NULL;
|
|
|
|
klass->key_press_event = NULL;
|
|
|
|
klass->key_release_event = NULL;
|
|
|
|
klass->enter_notify_event = NULL;
|
|
|
|
klass->leave_notify_event = NULL;
|
|
|
|
klass->configure_event = NULL;
|
|
|
|
klass->focus_in_event = NULL;
|
|
|
|
klass->focus_out_event = NULL;
|
|
|
|
klass->map_event = NULL;
|
|
|
|
klass->unmap_event = NULL;
|
|
|
|
klass->property_notify_event = gtk_selection_property_notify;
|
|
|
|
klass->selection_clear_event = gtk_selection_clear;
|
|
|
|
klass->selection_request_event = gtk_selection_request;
|
|
|
|
klass->selection_notify_event = gtk_selection_notify;
|
|
|
|
klass->selection_received = NULL;
|
|
|
|
klass->proximity_in_event = NULL;
|
|
|
|
klass->proximity_out_event = NULL;
|
|
|
|
klass->drag_begin_event = NULL;
|
|
|
|
klass->drag_request_event = NULL;
|
|
|
|
klass->drop_enter_event = NULL;
|
|
|
|
klass->drop_leave_event = NULL;
|
|
|
|
klass->drop_data_available_event = NULL;
|
|
|
|
klass->other_event = NULL;
|
1998-01-30 23:47:09 +00:00
|
|
|
klass->no_expose_event = NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-16 00:49:51 +00:00
|
|
|
* gtk_widget_set_arg:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-16 00:49:51 +00:00
|
|
|
gtk_widget_set_arg (GtkWidget *widget,
|
|
|
|
GtkArg *arg,
|
|
|
|
guint arg_id)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-03-26 21:57:45 +00:00
|
|
|
guint32 saved_flags;
|
|
|
|
|
1998-01-16 00:49:51 +00:00
|
|
|
switch (arg_id)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-03-15 21:14:28 +00:00
|
|
|
case ARG_NAME:
|
|
|
|
gtk_widget_set_name (widget, GTK_VALUE_STRING (*arg));
|
|
|
|
break;
|
|
|
|
case ARG_PARENT:
|
|
|
|
gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
|
|
|
|
break;
|
1998-01-16 00:49:51 +00:00
|
|
|
case ARG_X:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2);
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_Y:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_WIDTH:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -1);
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_HEIGHT:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_usize (widget, -1, GTK_VALUE_INT (*arg));
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_VISIBLE:
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_VALUE_BOOL(*arg))
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_show (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
else
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_hide (widget);
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_SENSITIVE:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_sensitive (widget, GTK_VALUE_BOOL (*arg));
|
|
|
|
break;
|
|
|
|
case ARG_CAN_FOCUS:
|
1998-03-26 21:57:45 +00:00
|
|
|
saved_flags = GTK_WIDGET_FLAGS (widget);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (GTK_VALUE_BOOL (*arg))
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
|
|
|
|
else
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
|
1998-03-26 21:57:45 +00:00
|
|
|
if (saved_flags != GTK_WIDGET_FLAGS (widget))
|
|
|
|
gtk_widget_queue_resize (widget);
|
1998-01-18 03:09:42 +00:00
|
|
|
break;
|
1998-01-18 11:09:04 +00:00
|
|
|
case ARG_HAS_FOCUS:
|
|
|
|
if (GTK_VALUE_BOOL (*arg))
|
|
|
|
gtk_widget_grab_focus (widget);
|
|
|
|
break;
|
1998-01-18 03:09:42 +00:00
|
|
|
case ARG_CAN_DEFAULT:
|
1998-03-26 21:57:45 +00:00
|
|
|
saved_flags = GTK_WIDGET_FLAGS (widget);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (GTK_VALUE_BOOL (*arg))
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
|
|
|
|
else
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
|
1998-03-26 21:57:45 +00:00
|
|
|
if (saved_flags != GTK_WIDGET_FLAGS (widget))
|
|
|
|
gtk_widget_queue_resize (widget);
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
1998-01-18 11:09:04 +00:00
|
|
|
case ARG_HAS_DEFAULT:
|
|
|
|
if (GTK_VALUE_BOOL (*arg))
|
|
|
|
gtk_widget_grab_default (widget);
|
|
|
|
break;
|
1998-03-15 21:14:28 +00:00
|
|
|
case ARG_STYLE:
|
|
|
|
gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg));
|
|
|
|
break;
|
1998-01-16 00:49:51 +00:00
|
|
|
case ARG_EVENTS:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_events (widget, GTK_VALUE_FLAGS (*arg));
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
|
|
|
case ARG_EXTENSION_EVENTS:
|
1998-01-18 03:09:42 +00:00
|
|
|
gtk_widget_set_extension_events (widget, GTK_VALUE_FLAGS (*arg));
|
1998-01-16 00:49:51 +00:00
|
|
|
break;
|
1998-01-21 23:03:11 +00:00
|
|
|
default:
|
|
|
|
arg->type = GTK_TYPE_INVALID;
|
|
|
|
break;
|
1998-01-18 03:09:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-20 23:58:42 +00:00
|
|
|
* gtk_widget_get_arg:
|
1998-01-18 03:09:42 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_get_arg (GtkWidget *widget,
|
|
|
|
GtkArg *arg,
|
|
|
|
guint arg_id)
|
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
|
|
|
gint *eventp;
|
|
|
|
GdkExtensionMode *modep;
|
|
|
|
|
|
|
|
switch (arg_id)
|
|
|
|
{
|
1998-03-15 21:14:28 +00:00
|
|
|
case ARG_NAME:
|
|
|
|
if (widget->name)
|
|
|
|
GTK_VALUE_STRING (*arg) = g_strdup (widget->name);
|
|
|
|
else
|
|
|
|
GTK_VALUE_STRING (*arg) = g_strdup ("");
|
|
|
|
break;
|
|
|
|
case ARG_PARENT:
|
|
|
|
GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
|
|
|
|
break;
|
1998-01-18 03:09:42 +00:00
|
|
|
case ARG_X:
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!aux_info)
|
|
|
|
GTK_VALUE_INT (*arg) = -2;
|
|
|
|
else
|
|
|
|
GTK_VALUE_INT (*arg) = aux_info->x;
|
|
|
|
break;
|
|
|
|
case ARG_Y:
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!aux_info)
|
|
|
|
GTK_VALUE_INT (*arg) = -2;
|
|
|
|
else
|
|
|
|
GTK_VALUE_INT (*arg) = aux_info->y;
|
|
|
|
break;
|
|
|
|
case ARG_WIDTH:
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!aux_info)
|
|
|
|
GTK_VALUE_INT (*arg) = -2;
|
|
|
|
else
|
|
|
|
GTK_VALUE_INT (*arg) = aux_info->width;
|
|
|
|
break;
|
|
|
|
case ARG_HEIGHT:
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!aux_info)
|
|
|
|
GTK_VALUE_INT (*arg) = -2;
|
|
|
|
else
|
|
|
|
GTK_VALUE_INT (*arg) = aux_info->height;
|
|
|
|
break;
|
|
|
|
case ARG_VISIBLE:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_VISIBLE (widget) != FALSE);
|
1998-01-18 03:09:42 +00:00
|
|
|
break;
|
|
|
|
case ARG_SENSITIVE:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_SENSITIVE (widget) != FALSE);
|
1998-01-18 03:09:42 +00:00
|
|
|
break;
|
|
|
|
case ARG_CAN_FOCUS:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_FOCUS (widget) != FALSE);
|
1998-01-18 03:09:42 +00:00
|
|
|
break;
|
1998-01-18 11:09:04 +00:00
|
|
|
case ARG_HAS_FOCUS:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_FOCUS (widget) != FALSE);
|
1998-01-18 11:09:04 +00:00
|
|
|
break;
|
1998-01-18 03:09:42 +00:00
|
|
|
case ARG_CAN_DEFAULT:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_DEFAULT (widget) != FALSE);
|
1998-01-18 03:09:42 +00:00
|
|
|
break;
|
1998-01-18 11:09:04 +00:00
|
|
|
case ARG_HAS_DEFAULT:
|
1998-03-17 23:07:30 +00:00
|
|
|
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE);
|
1998-01-18 11:09:04 +00:00
|
|
|
break;
|
1998-03-15 21:14:28 +00:00
|
|
|
case ARG_STYLE:
|
|
|
|
GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
|
|
|
|
break;
|
1998-01-18 03:09:42 +00:00
|
|
|
case ARG_EVENTS:
|
1998-03-14 04:43:14 +00:00
|
|
|
eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!eventp)
|
|
|
|
GTK_VALUE_FLAGS (*arg) = 0;
|
|
|
|
else
|
|
|
|
GTK_VALUE_FLAGS (*arg) = *eventp;
|
|
|
|
break;
|
|
|
|
case ARG_EXTENSION_EVENTS:
|
1998-03-14 04:43:14 +00:00
|
|
|
modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id);
|
1998-01-18 03:09:42 +00:00
|
|
|
if (!modep)
|
|
|
|
GTK_VALUE_FLAGS (*arg) = 0;
|
|
|
|
else
|
|
|
|
GTK_VALUE_FLAGS (*arg) = *modep;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
arg->type = GTK_TYPE_INVALID;
|
1998-01-21 23:03:11 +00:00
|
|
|
break;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_init:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_init (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GdkColormap *colormap;
|
|
|
|
GdkVisual *visual;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
GTK_PRIVATE_FLAGS (widget) = 0;
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->state = GTK_STATE_NORMAL;
|
|
|
|
widget->saved_state = GTK_STATE_NORMAL;
|
|
|
|
widget->name = NULL;
|
|
|
|
widget->requisition.width = 0;
|
|
|
|
widget->requisition.height = 0;
|
|
|
|
widget->allocation.x = -1;
|
|
|
|
widget->allocation.y = -1;
|
|
|
|
widget->allocation.width = 1;
|
|
|
|
widget->allocation.height = 1;
|
|
|
|
widget->window = NULL;
|
|
|
|
widget->parent = NULL;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE | GTK_PARENT_SENSITIVE);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->style = gtk_widget_peek_style ();
|
|
|
|
gtk_style_ref (widget->style);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
colormap = gtk_widget_peek_colormap ();
|
|
|
|
visual = gtk_widget_peek_visual ();
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
/* XXX - should we ref the colormap and visual, too? */
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (colormap != gtk_widget_get_default_colormap ())
|
1997-12-18 02:17:14 +00:00
|
|
|
{
|
|
|
|
/* gdk_colormap_ref (colormap); */
|
|
|
|
gtk_object_set_data (GTK_OBJECT (widget), colormap_key, colormap);
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (visual != gtk_widget_get_default_visual ())
|
1997-12-18 02:17:14 +00:00
|
|
|
{
|
|
|
|
/* gdk_visual_ref (visual); */
|
|
|
|
gtk_object_set_data (GTK_OBJECT (widget), visual_key, visual);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_new:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GtkWidget*
|
|
|
|
gtk_widget_new (guint type,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
GtkObject *obj;
|
|
|
|
GtkArg *args;
|
1998-01-16 05:11:10 +00:00
|
|
|
guint nargs;
|
1997-11-24 22:37:52 +00:00
|
|
|
va_list args1;
|
|
|
|
va_list args2;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
obj = gtk_type_new (type);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
va_start (args1, type);
|
|
|
|
va_start (args2, type);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
args = gtk_object_collect_args (&nargs, args1, args2);
|
|
|
|
gtk_object_setv (obj, nargs, args);
|
|
|
|
g_free (args);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
va_end (args1);
|
|
|
|
va_end (args2);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return GTK_WIDGET (obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_newv:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GtkWidget*
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_newv (guint type,
|
1998-01-16 05:11:10 +00:00
|
|
|
guint nargs,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkArg *args)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return GTK_WIDGET (gtk_object_newv (type, nargs, args));
|
|
|
|
}
|
|
|
|
|
1998-01-16 05:11:10 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_get (GtkWidget *widget,
|
|
|
|
GtkArg *arg)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (arg != NULL);
|
|
|
|
|
|
|
|
gtk_object_getv (GTK_OBJECT (widget), 1, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_getv:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_getv (GtkWidget *widget,
|
|
|
|
guint nargs,
|
|
|
|
GtkArg *args)
|
|
|
|
{
|
|
|
|
gtk_object_getv (GTK_OBJECT (widget), nargs, args);
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set (GtkWidget *widget,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
GtkArg *args;
|
1998-01-16 05:11:10 +00:00
|
|
|
guint nargs;
|
1997-11-24 22:37:52 +00:00
|
|
|
va_list args1;
|
|
|
|
va_list args2;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
va_start (args1, widget);
|
|
|
|
va_start (args2, widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
args = gtk_object_collect_args (&nargs, args1, args2);
|
|
|
|
gtk_object_setv (GTK_OBJECT (widget), nargs, args);
|
|
|
|
g_free (args);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
va_end (args1);
|
|
|
|
va_end (args2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_setv:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_setv (GtkWidget *widget,
|
1998-01-16 05:11:10 +00:00
|
|
|
guint nargs,
|
1997-11-28 01:22:38 +00:00
|
|
|
GtkArg *args)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
gtk_object_setv (GTK_OBJECT (widget), nargs, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-20 23:58:42 +00:00
|
|
|
* gtk_widget_unparent:
|
|
|
|
* do any cleanup necessary necessary
|
1998-02-03 14:13:05 +00:00
|
|
|
* for setting parent = NULL.
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_unparent (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkWidget *toplevel;
|
1998-02-18 04:09:13 +00:00
|
|
|
GtkWidget *old_parent;
|
1998-04-08 21:40:45 +00:00
|
|
|
GSList *tmp_list, *prev_list;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
if (widget->parent == NULL)
|
|
|
|
return;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-03 14:13:05 +00:00
|
|
|
/* keep this function in sync with gtk_menu_detach()
|
|
|
|
*/
|
|
|
|
|
1998-05-03 15:45:08 +00:00
|
|
|
/* unset focused and default children properly
|
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
toplevel = gtk_widget_get_toplevel (widget);
|
1998-05-03 15:45:08 +00:00
|
|
|
if (GTK_CONTAINER (widget->parent)->focus_child == widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-05-03 15:45:08 +00:00
|
|
|
gtk_container_set_focus_child (GTK_CONTAINER (widget->parent), NULL);
|
|
|
|
|
|
|
|
if (GTK_IS_WINDOW (toplevel))
|
|
|
|
{
|
|
|
|
GtkWidget *child;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-05-03 15:45:08 +00:00
|
|
|
child = GTK_WINDOW (toplevel)->focus_widget;
|
|
|
|
|
|
|
|
while (child && child != widget)
|
|
|
|
child = child->parent;
|
|
|
|
|
|
|
|
if (child == widget)
|
|
|
|
gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (GTK_IS_WINDOW (toplevel))
|
|
|
|
{
|
|
|
|
GtkWidget *child;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-04-13 00:20:17 +00:00
|
|
|
child = GTK_WINDOW (toplevel)->default_widget;
|
|
|
|
|
|
|
|
while (child && child != widget)
|
|
|
|
child = child->parent;
|
|
|
|
|
|
|
|
if (child == widget)
|
|
|
|
gtk_window_set_default (GTK_WINDOW (toplevel), NULL);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-02-10 04:17:10 +00:00
|
|
|
|
1998-04-08 21:40:45 +00:00
|
|
|
/* Remove the widget and all its children from toplevel->resize_widgets
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Three ways to make this prettier:
|
|
|
|
* Write a g_slist_conditional_remove (GSList, gboolean (*)(gpointer))
|
|
|
|
* Change resize_widgets to a GList
|
|
|
|
* Just bite the bullet and use g_slist_remove
|
|
|
|
*/
|
|
|
|
tmp_list = GTK_CONTAINER (toplevel)->resize_widgets;
|
|
|
|
prev_list = NULL;
|
|
|
|
while (tmp_list)
|
1998-02-10 04:17:10 +00:00
|
|
|
{
|
1998-04-08 21:40:45 +00:00
|
|
|
GSList *tmp = tmp_list;
|
|
|
|
GtkWidget *child = (GtkWidget *)tmp->data;
|
|
|
|
GtkWidget *parent = child;
|
|
|
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
|
|
|
while (parent && (parent != widget))
|
|
|
|
parent = parent->parent;
|
|
|
|
|
|
|
|
if (parent == widget)
|
|
|
|
{
|
|
|
|
GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED);
|
|
|
|
|
|
|
|
if (prev_list)
|
|
|
|
prev_list->next = tmp_list;
|
|
|
|
else
|
|
|
|
GTK_CONTAINER (toplevel)->resize_widgets = tmp_list;
|
|
|
|
|
|
|
|
tmp->next = NULL;
|
|
|
|
|
|
|
|
g_slist_free_1 (tmp);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
prev_list = tmp;
|
1998-02-10 04:17:10 +00:00
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->window &&
|
|
|
|
GTK_WIDGET_NO_WINDOW (widget) &&
|
|
|
|
GTK_WIDGET_DRAWABLE (widget))
|
|
|
|
gdk_window_clear_area (widget->window,
|
|
|
|
widget->allocation.x,
|
|
|
|
widget->allocation.y,
|
|
|
|
widget->allocation.width,
|
|
|
|
widget->allocation.height);
|
1998-02-01 02:28:14 +00:00
|
|
|
|
1998-03-30 23:04:51 +00:00
|
|
|
/* Reset the width and height here, to force reallocation if we
|
|
|
|
* get added back to a new parent. This won't work if our new
|
|
|
|
* allocation is smaller than 1x1 and we actually want a size of 1x1...
|
|
|
|
* (would 0x0 be OK here?)
|
|
|
|
*/
|
|
|
|
widget->allocation.width = 1;
|
|
|
|
widget->allocation.height = 1;
|
|
|
|
|
1998-02-01 02:28:14 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_IN_REPARENT (widget))
|
|
|
|
gtk_widget_unrealize (widget);
|
1998-02-18 04:09:13 +00:00
|
|
|
|
|
|
|
old_parent = widget->parent;
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->parent = NULL;
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_widget_set_parent_window (widget, NULL);
|
1998-02-22 02:18:29 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], old_parent);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_destroy:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_destroy (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1998-02-10 04:17:10 +00:00
|
|
|
|
1998-03-30 20:03:36 +00:00
|
|
|
gtk_object_destroy ((GtkObject*) widget);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
|
|
|
|
1998-02-10 04:17:10 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_destroyed:
|
|
|
|
* Utility function: sets widget_pointer
|
|
|
|
* to NULL when widget is destroyed.
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
void
|
|
|
|
gtk_widget_destroyed (GtkWidget *widget,
|
|
|
|
GtkWidget **widget_pointer)
|
|
|
|
{
|
1998-02-07 04:59:23 +00:00
|
|
|
/* Don't make any assumptions about the
|
|
|
|
* value of widget!
|
|
|
|
* Even check widget_pointer.
|
|
|
|
*/
|
1998-01-30 23:47:09 +00:00
|
|
|
if (widget_pointer)
|
|
|
|
*widget_pointer = NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_show:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_show (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_VISIBLE (widget))
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
|
|
|
|
}
|
|
|
|
|
1998-03-28 00:10:49 +00:00
|
|
|
|
|
|
|
/*************************************************************
|
|
|
|
* gtk_widget_show_now:
|
|
|
|
* Show a widget, and if it is an unmapped toplevel widget
|
|
|
|
* wait for the map_event before returning
|
|
|
|
*
|
|
|
|
* Warning: This routine will call the main loop recursively.
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_show_map_callback (GtkWidget *widget, GdkEvent *event, gint *flag)
|
|
|
|
{
|
|
|
|
*flag = TRUE;
|
|
|
|
gtk_signal_disconnect_by_data (GTK_OBJECT (widget), flag);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_show_now (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
gint flag = FALSE;
|
|
|
|
|
|
|
|
/* make sure we will get event */
|
|
|
|
if (!GTK_WIDGET_MAPPED (widget) &&
|
|
|
|
GTK_WIDGET_TOPLEVEL (widget))
|
|
|
|
{
|
|
|
|
gtk_widget_show (widget);
|
|
|
|
|
|
|
|
gtk_signal_connect (GTK_OBJECT (widget), "map_event",
|
|
|
|
GTK_SIGNAL_FUNC (gtk_widget_show_map_callback),
|
|
|
|
&flag);
|
|
|
|
|
|
|
|
while (!flag)
|
|
|
|
gtk_main_iteration();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
gtk_widget_show (widget);
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_hide:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_hide (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-03-12 21:54:39 +00:00
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_VISIBLE (widget))
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
|
|
|
|
}
|
|
|
|
|
1998-03-12 21:54:39 +00:00
|
|
|
gint
|
1998-03-13 17:45:16 +00:00
|
|
|
gtk_widget_hide_on_delete (GtkWidget *widget)
|
1998-03-12 21:54:39 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
|
1998-03-13 17:45:16 +00:00
|
|
|
|
1998-03-12 21:54:39 +00:00
|
|
|
gtk_widget_hide (widget);
|
1998-03-13 17:45:16 +00:00
|
|
|
|
1998-03-12 21:54:39 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
1998-01-02 20:22:38 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_show_all:
|
|
|
|
*
|
|
|
|
* Shows the widget and all children.
|
|
|
|
*
|
|
|
|
* Container classes overwrite
|
|
|
|
* show_all and hide_all to call
|
|
|
|
* show_all (hide_all) on both themselves
|
|
|
|
* and on their child widgets.
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_show_all (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkWidgetClass *widget_class;
|
|
|
|
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
|
|
|
|
/* show_all shouldn't be invoked through a signal,
|
|
|
|
because in this case it would be quite slow - there would
|
|
|
|
be a show and show_all signal emitted for every child widget.
|
|
|
|
*/
|
|
|
|
widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
|
|
|
|
widget_class->show_all (widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_hide_all:
|
|
|
|
*
|
|
|
|
* Hides the widget and all children.
|
|
|
|
* See gtk_widget_show_all.
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_hide_all (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
g_assert (widget->parent);
|
1998-01-02 20:22:38 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
if (GTK_WIDGET_RESIZE_NEEDED (widget))
|
|
|
|
{
|
|
|
|
GtkWidget *toplevel;
|
|
|
|
|
|
|
|
toplevel = gtk_widget_get_toplevel (widget);
|
1998-03-14 04:43:14 +00:00
|
|
|
GTK_CONTAINER (toplevel)->resize_widgets =
|
|
|
|
g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass)->hide_all (widget);
|
1998-01-02 20:22:38 +00:00
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_map:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_map (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_MAPPED (widget))
|
|
|
|
{
|
|
|
|
if (!GTK_WIDGET_REALIZED (widget))
|
|
|
|
gtk_widget_realize (widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_unmap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_unmap (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_MAPPED (widget))
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_realize:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_realize (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
gint events;
|
|
|
|
GdkExtensionMode mode;
|
|
|
|
GtkWidgetShapeInfo *shape_info;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_REALIZED (widget))
|
|
|
|
{
|
|
|
|
/*
|
1997-11-28 01:22:38 +00:00
|
|
|
if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
g_print ("%s\n", gtk_type_name (GTK_WIDGET_TYPE (widget)));
|
|
|
|
*/
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
|
|
|
|
gtk_widget_realize (widget->parent);
|
1998-02-27 16:31:06 +00:00
|
|
|
|
|
|
|
gtk_widget_ensure_style (widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REALIZE]);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1997-11-28 01:22:38 +00:00
|
|
|
shape_info = gtk_object_get_data (GTK_OBJECT (widget),
|
1997-11-24 22:37:52 +00:00
|
|
|
shape_info_key);
|
|
|
|
gdk_window_shape_combine_mask (widget->window,
|
|
|
|
shape_info->shape_mask,
|
|
|
|
shape_info->offset_x,
|
|
|
|
shape_info->offset_y);
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
mode = gtk_widget_get_extension_events (widget);
|
|
|
|
if (mode != GDK_EXTENSION_EVENTS_NONE)
|
|
|
|
{
|
|
|
|
events = gtk_widget_get_events (widget);
|
|
|
|
gdk_input_set_extension_events (widget->window, events, mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_unrealize:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_unrealize (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
if (GTK_WIDGET_REDRAW_PENDING (widget))
|
|
|
|
{
|
|
|
|
gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
|
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
|
|
|
|
gtk_widget_shape_combine_mask (widget, NULL, -1, -1);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget))
|
1998-03-21 22:11:26 +00:00
|
|
|
{
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_queue_draw:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
static gint
|
|
|
|
gtk_widget_idle_draw (void *data)
|
|
|
|
{
|
|
|
|
GSList *node;
|
|
|
|
|
|
|
|
node = gtk_widget_redraw_queue;
|
|
|
|
gtk_widget_redraw_queue = NULL;
|
|
|
|
while (node)
|
|
|
|
{
|
|
|
|
gtk_widget_real_queue_draw ((GtkWidget*) node->data);
|
|
|
|
node = node->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return gtk_widget_redraw_queue != NULL;
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
void
|
|
|
|
gtk_widget_queue_draw (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkWidget *parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
|
|
|
{
|
|
|
|
/* We queue the redraw if:
|
|
|
|
* a) the widget is not already queued for redraw and
|
|
|
|
* b) non of the widgets ancestors are queued for redraw.
|
|
|
|
*/
|
|
|
|
parent = widget;
|
|
|
|
while (parent)
|
|
|
|
{
|
|
|
|
if (GTK_WIDGET_REDRAW_PENDING (parent))
|
|
|
|
return;
|
|
|
|
parent = parent->parent;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_PENDING);
|
1998-01-30 23:47:09 +00:00
|
|
|
if (gtk_widget_redraw_queue == NULL)
|
1998-02-13 05:26:33 +00:00
|
|
|
gtk_idle_add_priority (GTK_PRIORITY_INTERNAL,
|
|
|
|
(GtkFunction) gtk_widget_idle_draw, NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_queue_resize:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
static gint
|
|
|
|
gtk_widget_idle_sizer (void *data)
|
|
|
|
{
|
1998-02-24 13:57:03 +00:00
|
|
|
GSList *slist, *free_slist;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1998-02-24 13:57:03 +00:00
|
|
|
free_slist = gtk_widget_resize_queue;
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_resize_queue = NULL;
|
1998-03-14 04:43:14 +00:00
|
|
|
|
|
|
|
for (slist = free_slist; slist; slist = slist->next)
|
1998-01-30 23:47:09 +00:00
|
|
|
{
|
1998-02-24 13:57:03 +00:00
|
|
|
GtkWidget *widget;
|
|
|
|
|
|
|
|
widget = slist->data;
|
|
|
|
|
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
|
|
|
|
if (gtk_container_need_resize (GTK_CONTAINER (widget)))
|
|
|
|
gtk_widget_queue_resize (widget);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
1998-02-24 13:57:03 +00:00
|
|
|
g_slist_free (free_slist);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
return gtk_widget_resize_queue != NULL;
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
void
|
|
|
|
gtk_widget_queue_resize (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkWidget *toplevel;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
toplevel = gtk_widget_get_toplevel (widget);
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
if (GTK_WIDGET_TOPLEVEL (toplevel))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
if (GTK_WIDGET_VISIBLE (toplevel))
|
|
|
|
{
|
1998-02-02 14:11:24 +00:00
|
|
|
if (!GTK_CONTAINER_RESIZE_PENDING (toplevel))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_SET_FLAG (toplevel, GTK_RESIZE_PENDING);
|
1998-01-30 23:47:09 +00:00
|
|
|
if (gtk_widget_resize_queue == NULL)
|
1998-02-13 05:26:33 +00:00
|
|
|
gtk_idle_add_priority (GTK_PRIORITY_INTERNAL,
|
|
|
|
(GtkFunction) gtk_widget_idle_sizer, NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, toplevel);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
if (!GTK_WIDGET_RESIZE_NEEDED (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
|
1998-01-30 23:47:09 +00:00
|
|
|
GTK_CONTAINER (toplevel)->resize_widgets =
|
|
|
|
g_slist_prepend (GTK_CONTAINER (toplevel)->resize_widgets, widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-01-30 23:47:09 +00:00
|
|
|
else
|
|
|
|
g_assert (g_slist_find (GTK_CONTAINER (toplevel)->resize_widgets, widget)); /* paranoid */
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_container_need_resize (GTK_CONTAINER (toplevel));
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_draw:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_draw (GtkWidget *widget,
|
|
|
|
GdkRectangle *area)
|
|
|
|
{
|
|
|
|
GdkRectangle temp_area;
|
1998-03-12 07:28:41 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1998-03-12 07:28:41 +00:00
|
|
|
|
1998-03-26 20:57:29 +00:00
|
|
|
if (GTK_WIDGET_REDRAW_PENDING (widget))
|
|
|
|
{
|
|
|
|
gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
|
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
|
1998-03-27 17:24:04 +00:00
|
|
|
|
|
|
|
area = NULL;
|
1998-03-26 20:57:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
if (!area)
|
|
|
|
{
|
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
temp_area.x = widget->allocation.x;
|
|
|
|
temp_area.y = widget->allocation.y;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
temp_area.x = 0;
|
|
|
|
temp_area.y = 0;
|
|
|
|
}
|
1998-03-12 07:28:41 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
temp_area.width = widget->allocation.width;
|
|
|
|
temp_area.height = widget->allocation.height;
|
|
|
|
area = &temp_area;
|
|
|
|
}
|
1998-03-12 07:28:41 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_draw_focus:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_draw_focus (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_FOCUS]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_draw_default:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_draw_default (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_DEFAULT]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_draw_children:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_draw_children (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_IS_CONTAINER (widget))
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
|
|
|
gtk_widget_draw_children_recurse,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_size_request:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_size_request (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkRequisition *requisition)
|
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
gtk_widget_ref (widget);
|
1998-02-27 22:09:20 +00:00
|
|
|
gtk_widget_ensure_style (widget);
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
|
|
|
|
requisition);
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1998-01-30 23:47:09 +00:00
|
|
|
if (aux_info)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-30 23:47:09 +00:00
|
|
|
if (aux_info->width > 0)
|
|
|
|
requisition->width = aux_info->width;
|
|
|
|
if (aux_info->height > 0)
|
|
|
|
requisition->height = aux_info->height;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_size_allocate:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_size_allocate (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkAllocation *allocation)
|
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
|
|
|
GtkAllocation real_allocation;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
real_allocation = *allocation;
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (aux_info)
|
|
|
|
{
|
|
|
|
if (aux_info->x != -1)
|
|
|
|
real_allocation.x = aux_info->x;
|
|
|
|
if (aux_info->y != -1)
|
|
|
|
real_allocation.y = aux_info->y;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_install_accelerator:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_install_accelerator (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkAcceleratorTable *table,
|
1997-11-28 01:22:38 +00:00
|
|
|
const gchar *signal_name,
|
|
|
|
gchar key,
|
|
|
|
guint8 modifiers)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
gint return_val;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
gtk_widget_ref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
return_val = TRUE;
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[INSTALL_ACCELERATOR],
|
|
|
|
signal_name, key, modifiers, &return_val);
|
|
|
|
if (return_val)
|
|
|
|
gtk_accelerator_table_install (table,
|
|
|
|
GTK_OBJECT (widget),
|
|
|
|
signal_name,
|
|
|
|
key,
|
|
|
|
modifiers);
|
|
|
|
gtk_widget_unref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_remove_accelerator:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_remove_accelerator (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkAcceleratorTable *table,
|
1997-11-28 01:22:38 +00:00
|
|
|
const gchar *signal_name)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
gtk_widget_ref (widget);
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REMOVE_ACCELERATOR],
|
|
|
|
signal_name);
|
|
|
|
gtk_accelerator_table_remove (table, GTK_OBJECT (widget), signal_name);
|
|
|
|
gtk_widget_unref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_event:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gtk_widget_event (GtkWidget *widget,
|
|
|
|
GdkEvent *event)
|
|
|
|
{
|
|
|
|
gint return_val;
|
|
|
|
gint signal_num;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
new function to perform the same actions as gtk_list_remove_items, but
Thu Feb 5 02:13:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtklist.h:
* gtk/gtklist.c (gtk_list_remove_items_no_unref): new function
to perform the same actions as gtk_list_remove_items, but
supply the removed widgets with an additional reference count.
* gtk/gtkmain.c (gtk_main_iteration_do): ignore events
with event_widget == NULL, since they are bogus events
from destroyed GdkWindows, exept for the case where
event->type==GDK_PROPERTY_NOTIFY. Always handle expired
timeout functions when returning from this function.
* gtk/gtkwidget.c (gtk_widget_event): ignore GDK_EXPOSE events
if event->window == NULL. Also, if this function couldn't handle
the event for any reason (including failing assumptions), make
the return value to look as if the event had been handled to
avoid further processing (and warnings).
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: remove gtk_widget_sink, because there is
no point in providing such a function.
* gdk/gdk.c (gdk_init): changed options `-name' and `-class'
to `--name' and `--class', because the old names would
confuse getopt(). these arguments have been introduced in the
changes from gtk+970916 to gtk+970925 without a ChangeLog entry,
changing argument names is painful, it would be nice if people
would care about compatibility and consistency in the first place!
1998-02-05 03:53:41 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, TRUE);
|
1998-02-17 02:19:30 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_ref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
return_val = FALSE;
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
|
|
|
|
&return_val);
|
1998-02-03 14:13:05 +00:00
|
|
|
if (return_val || GTK_OBJECT_DESTROYED (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (event->type)
|
|
|
|
{
|
|
|
|
case GDK_NOTHING:
|
|
|
|
signal_num = -1;
|
|
|
|
break;
|
|
|
|
case GDK_BUTTON_PRESS:
|
|
|
|
case GDK_2BUTTON_PRESS:
|
|
|
|
case GDK_3BUTTON_PRESS:
|
|
|
|
signal_num = BUTTON_PRESS_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_BUTTON_RELEASE:
|
|
|
|
signal_num = BUTTON_RELEASE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_MOTION_NOTIFY:
|
|
|
|
signal_num = MOTION_NOTIFY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DELETE:
|
|
|
|
signal_num = DELETE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DESTROY:
|
|
|
|
signal_num = DESTROY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_KEY_PRESS:
|
|
|
|
signal_num = KEY_PRESS_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_KEY_RELEASE:
|
|
|
|
signal_num = KEY_RELEASE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_ENTER_NOTIFY:
|
|
|
|
signal_num = ENTER_NOTIFY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_LEAVE_NOTIFY:
|
|
|
|
signal_num = LEAVE_NOTIFY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_FOCUS_CHANGE:
|
|
|
|
if (event->focus_change.in)
|
|
|
|
signal_num = FOCUS_IN_EVENT;
|
|
|
|
else
|
|
|
|
signal_num = FOCUS_OUT_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_CONFIGURE:
|
|
|
|
signal_num = CONFIGURE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_MAP:
|
|
|
|
signal_num = MAP_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_UNMAP:
|
|
|
|
signal_num = UNMAP_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_PROPERTY_NOTIFY:
|
|
|
|
signal_num = PROPERTY_NOTIFY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_SELECTION_CLEAR:
|
|
|
|
signal_num = SELECTION_CLEAR_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_SELECTION_REQUEST:
|
|
|
|
signal_num = SELECTION_REQUEST_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_SELECTION_NOTIFY:
|
|
|
|
signal_num = SELECTION_NOTIFY_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_PROXIMITY_IN:
|
|
|
|
signal_num = PROXIMITY_IN_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_PROXIMITY_OUT:
|
|
|
|
signal_num = PROXIMITY_OUT_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DRAG_BEGIN:
|
|
|
|
signal_num = DRAG_BEGIN_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DRAG_REQUEST:
|
|
|
|
signal_num = DRAG_REQUEST_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DROP_ENTER:
|
|
|
|
signal_num = DROP_ENTER_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DROP_LEAVE:
|
|
|
|
signal_num = DROP_LEAVE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_DROP_DATA_AVAIL:
|
|
|
|
signal_num = DROP_DATA_AVAILABLE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_OTHER_EVENT:
|
|
|
|
signal_num = OTHER_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_NO_EXPOSE:
|
|
|
|
signal_num = NO_EXPOSE_EVENT;
|
|
|
|
break;
|
|
|
|
case GDK_CLIENT_EVENT:
|
|
|
|
signal_num = CLIENT_EVENT;
|
|
|
|
break;
|
new function to perform the same actions as gtk_list_remove_items, but
Thu Feb 5 02:13:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtklist.h:
* gtk/gtklist.c (gtk_list_remove_items_no_unref): new function
to perform the same actions as gtk_list_remove_items, but
supply the removed widgets with an additional reference count.
* gtk/gtkmain.c (gtk_main_iteration_do): ignore events
with event_widget == NULL, since they are bogus events
from destroyed GdkWindows, exept for the case where
event->type==GDK_PROPERTY_NOTIFY. Always handle expired
timeout functions when returning from this function.
* gtk/gtkwidget.c (gtk_widget_event): ignore GDK_EXPOSE events
if event->window == NULL. Also, if this function couldn't handle
the event for any reason (including failing assumptions), make
the return value to look as if the event had been handled to
avoid further processing (and warnings).
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: remove gtk_widget_sink, because there is
no point in providing such a function.
* gdk/gdk.c (gdk_init): changed options `-name' and `-class'
to `--name' and `--class', because the old names would
confuse getopt(). these arguments have been introduced in the
changes from gtk+970916 to gtk+970925 without a ChangeLog entry,
changing argument names is painful, it would be nice if people
would care about compatibility and consistency in the first place!
1998-02-05 03:53:41 +00:00
|
|
|
case GDK_EXPOSE:
|
|
|
|
/* there is no sense in providing a widget with bogus expose events
|
|
|
|
*/
|
|
|
|
if (!event->any.window)
|
|
|
|
{
|
|
|
|
gtk_widget_unref (widget);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
signal_num = EXPOSE_EVENT;
|
|
|
|
break;
|
1998-01-30 23:47:09 +00:00
|
|
|
default:
|
|
|
|
g_warning ("could not determine signal number for event: %d", event->type);
|
|
|
|
gtk_widget_unref (widget);
|
1998-02-03 14:13:05 +00:00
|
|
|
return TRUE;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
if (signal_num != -1)
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[signal_num], event, &return_val);
|
|
|
|
|
1998-02-03 14:13:05 +00:00
|
|
|
return_val |= GTK_OBJECT_DESTROYED (widget);
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
1998-02-03 14:13:05 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_activate:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_activate (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (WIDGET_CLASS (widget)->activate_signal)
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-20 23:58:42 +00:00
|
|
|
* gtk_widget_reparent_container_child:
|
|
|
|
* assistent function to gtk_widget_reparent
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
static void
|
|
|
|
gtk_widget_reparent_container_child(GtkWidget *widget,
|
|
|
|
gpointer client_data)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (client_data != NULL);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
if (widget->window)
|
|
|
|
gdk_window_unref (widget->window);
|
|
|
|
widget->window = (GdkWindow*) client_data;
|
|
|
|
if (widget->window)
|
|
|
|
gdk_window_ref (widget->window);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
if (GTK_IS_CONTAINER (widget))
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
|
|
|
gtk_widget_reparent_container_child,
|
|
|
|
client_data);
|
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
else
|
1998-01-30 23:47:09 +00:00
|
|
|
gdk_window_reparent (widget->window,
|
|
|
|
(GdkWindow*) client_data, 0, 0);
|
1997-12-18 02:17:14 +00:00
|
|
|
}
|
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_reparent:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
void
|
|
|
|
gtk_widget_reparent (GtkWidget *widget,
|
|
|
|
GtkWidget *new_parent)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-02-03 14:13:05 +00:00
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (new_parent != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_CONTAINER (new_parent));
|
1998-02-03 14:13:05 +00:00
|
|
|
g_return_if_fail (widget->parent != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->parent != new_parent)
|
|
|
|
{
|
1998-02-01 02:28:14 +00:00
|
|
|
/* First try to see if we can get away without unrealizing
|
1998-02-04 00:06:29 +00:00
|
|
|
* the widget as we reparent it. if so we set a flag so
|
|
|
|
* that gtk_widget_unparent doesn't unrealize widget
|
1998-02-01 02:28:14 +00:00
|
|
|
*/
|
|
|
|
if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
|
1998-02-04 00:06:29 +00:00
|
|
|
GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_ref (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
|
|
|
|
gtk_container_add (GTK_CONTAINER (new_parent), widget);
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
|
|
|
|
1998-02-01 02:28:14 +00:00
|
|
|
if (GTK_WIDGET_IN_REPARENT (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-04 00:06:29 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_IN_REPARENT);
|
|
|
|
|
1998-02-01 02:28:14 +00:00
|
|
|
/* OK, now fix up the widget's window. (And that for any
|
|
|
|
* children, if the widget is NO_WINDOW and a container)
|
|
|
|
*/
|
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
if (GTK_IS_CONTAINER (widget))
|
1998-02-18 04:09:13 +00:00
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
1998-02-01 02:28:14 +00:00
|
|
|
gtk_widget_reparent_container_child,
|
|
|
|
gtk_widget_get_parent_window (widget));
|
|
|
|
else
|
1997-12-18 02:17:14 +00:00
|
|
|
{
|
1998-02-01 02:28:14 +00:00
|
|
|
GdkWindow *parent_window;
|
|
|
|
|
|
|
|
parent_window = gtk_widget_get_parent_window (widget);
|
|
|
|
if (parent_window != widget->window)
|
1998-01-30 23:47:09 +00:00
|
|
|
{
|
1998-02-01 02:28:14 +00:00
|
|
|
if (widget->window)
|
|
|
|
gdk_window_unref (widget->window);
|
|
|
|
widget->window = parent_window;
|
|
|
|
if (widget->window)
|
|
|
|
gdk_window_ref (widget->window);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else
|
1998-02-01 02:28:14 +00:00
|
|
|
gdk_window_reparent (widget->window, gtk_widget_get_parent_window (widget), 0, 0);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_popup:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_popup (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint x,
|
|
|
|
gint y)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_VISIBLE (widget))
|
|
|
|
{
|
|
|
|
if (!GTK_WIDGET_REALIZED (widget))
|
|
|
|
gtk_widget_realize (widget);
|
|
|
|
if (!GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
gdk_window_move (widget->window, x, y);
|
|
|
|
gtk_widget_show (widget);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_intersect:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gint
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_intersect (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GdkRectangle *area,
|
|
|
|
GdkRectangle *intersection)
|
|
|
|
{
|
|
|
|
GdkRectangle *dest;
|
|
|
|
GdkRectangle tmp;
|
|
|
|
gint return_val;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (area != NULL, FALSE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (intersection)
|
|
|
|
dest = intersection;
|
|
|
|
else
|
|
|
|
dest = &tmp;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return_val = gdk_rectangle_intersect ((GdkRectangle*) &widget->allocation, area, dest);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
intersection->x -= widget->allocation.x;
|
|
|
|
intersection->y -= widget->allocation.y;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
gint
|
|
|
|
gtk_widget_basic (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GList *children;
|
|
|
|
GList *tmp_list;
|
|
|
|
gint return_val;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_BASIC (widget))
|
|
|
|
return FALSE;
|
|
|
|
else if (GTK_IS_CONTAINER (widget))
|
|
|
|
{
|
|
|
|
children = gtk_container_children (GTK_CONTAINER (widget));
|
|
|
|
if (children)
|
|
|
|
{
|
|
|
|
return_val = TRUE;
|
|
|
|
tmp_list = children;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
while (tmp_list)
|
|
|
|
{
|
|
|
|
if (!gtk_widget_basic (GTK_WIDGET (tmp_list->data)))
|
|
|
|
{
|
|
|
|
return_val = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_list_free (children);
|
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_grab_focus:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_grab_focus (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-05-01 04:23:59 +00:00
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
|
|
|
if (GTK_WIDGET_CAN_FOCUS (widget))
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-05-03 15:45:08 +00:00
|
|
|
GtkWidget *parent;
|
1998-05-01 04:23:59 +00:00
|
|
|
GtkWidget *child;
|
|
|
|
GtkType window_type;
|
|
|
|
|
|
|
|
window_type = gtk_window_get_type ();
|
1998-05-03 15:45:08 +00:00
|
|
|
parent = widget->parent;
|
1998-05-01 04:23:59 +00:00
|
|
|
child = widget;
|
|
|
|
|
1998-05-03 15:45:08 +00:00
|
|
|
while (parent && !gtk_type_is_a (GTK_WIDGET_TYPE (parent), window_type))
|
1998-05-01 04:23:59 +00:00
|
|
|
{
|
1998-05-03 15:45:08 +00:00
|
|
|
gtk_container_set_focus_child (GTK_CONTAINER (parent), child);
|
|
|
|
child = parent;
|
|
|
|
parent = parent->parent;
|
1998-05-01 04:23:59 +00:00
|
|
|
}
|
|
|
|
|
1998-05-03 15:45:08 +00:00
|
|
|
if (parent && gtk_type_is_a (GTK_WIDGET_TYPE (parent), window_type))
|
1998-05-01 04:23:59 +00:00
|
|
|
{
|
1998-05-03 15:45:08 +00:00
|
|
|
gtk_container_set_focus_child (GTK_CONTAINER (parent), child);
|
|
|
|
gtk_window_set_focus (GTK_WINDOW (parent), widget);
|
1998-05-01 04:23:59 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_grab_default:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_grab_default (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkWidget *window;
|
1998-03-09 15:16:28 +00:00
|
|
|
GtkType window_type;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
window_type = gtk_window_get_type ();
|
|
|
|
window = widget->parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
|
|
|
|
window = window->parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
|
|
|
|
gtk_window_set_default (GTK_WINDOW (window), widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_name:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_set_name (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
const gchar *name)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->name)
|
|
|
|
g_free (widget->name);
|
|
|
|
widget->name = g_strdup (name);
|
1998-02-27 16:31:06 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_USER_STYLE (widget))
|
1998-02-27 16:31:06 +00:00
|
|
|
gtk_widget_set_rc_style (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_name:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gchar*
|
|
|
|
gtk_widget_get_name (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->name)
|
|
|
|
return widget->name;
|
|
|
|
return gtk_type_name (GTK_WIDGET_TYPE (widget));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_state:
|
|
|
|
*
|
|
|
|
* arguments:
|
1998-01-20 23:58:42 +00:00
|
|
|
* widget
|
|
|
|
* state
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
1998-01-20 23:58:42 +00:00
|
|
|
gtk_widget_set_state (GtkWidget *widget,
|
|
|
|
GtkStateType state)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1998-03-26 21:57:45 +00:00
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
if (state == GTK_WIDGET_STATE (widget))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (state == GTK_STATE_INSENSITIVE)
|
|
|
|
gtk_widget_set_sensitive (widget, FALSE);
|
|
|
|
else
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-20 23:58:42 +00:00
|
|
|
GtkStateData data;
|
|
|
|
|
|
|
|
data.state = state;
|
1998-03-26 21:57:45 +00:00
|
|
|
data.state_restauration = FALSE;
|
1998-01-20 23:58:42 +00:00
|
|
|
if (widget->parent)
|
1998-03-26 21:57:45 +00:00
|
|
|
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
|
1998-01-20 23:58:42 +00:00
|
|
|
else
|
1998-03-26 21:57:45 +00:00
|
|
|
data.parent_sensitive = TRUE;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
gtk_widget_propagate_state (widget, &data);
|
1998-03-26 21:57:45 +00:00
|
|
|
gtk_widget_queue_draw (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_sensitive:
|
|
|
|
*
|
|
|
|
* arguments:
|
1998-01-20 23:58:42 +00:00
|
|
|
* widget
|
|
|
|
* boolean value for sensitivity
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_sensitive (GtkWidget *widget,
|
1998-01-20 23:58:42 +00:00
|
|
|
gint sensitive)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-20 23:58:42 +00:00
|
|
|
GtkStateData data;
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1998-03-26 21:57:45 +00:00
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
|
|
|
|
sensitive = (sensitive != FALSE);
|
|
|
|
|
|
|
|
if (sensitive == (GTK_WIDGET_SENSITIVE (widget) != FALSE))
|
|
|
|
return;
|
1998-01-20 23:58:42 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (sensitive)
|
|
|
|
{
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE);
|
1998-03-26 21:57:45 +00:00
|
|
|
data.state = GTK_WIDGET_SAVED_STATE (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_SENSITIVE);
|
1998-01-20 23:58:42 +00:00
|
|
|
data.state = GTK_WIDGET_STATE (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-03-26 21:57:45 +00:00
|
|
|
data.state_restauration = TRUE;
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
if (widget->parent)
|
1998-03-26 21:57:45 +00:00
|
|
|
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
|
1998-01-20 23:58:42 +00:00
|
|
|
else
|
1998-03-26 21:57:45 +00:00
|
|
|
data.parent_sensitive = TRUE;
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
gtk_widget_propagate_state (widget, &data);
|
1998-03-26 21:57:45 +00:00
|
|
|
gtk_widget_queue_draw (widget);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_parent:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_parent (GtkWidget *widget,
|
|
|
|
GtkWidget *parent)
|
|
|
|
{
|
1998-01-20 23:58:42 +00:00
|
|
|
GtkStateData data;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
new function to perform the same actions as gtk_list_remove_items, but
Thu Feb 5 02:13:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtklist.h:
* gtk/gtklist.c (gtk_list_remove_items_no_unref): new function
to perform the same actions as gtk_list_remove_items, but
supply the removed widgets with an additional reference count.
* gtk/gtkmain.c (gtk_main_iteration_do): ignore events
with event_widget == NULL, since they are bogus events
from destroyed GdkWindows, exept for the case where
event->type==GDK_PROPERTY_NOTIFY. Always handle expired
timeout functions when returning from this function.
* gtk/gtkwidget.c (gtk_widget_event): ignore GDK_EXPOSE events
if event->window == NULL. Also, if this function couldn't handle
the event for any reason (including failing assumptions), make
the return value to look as if the event had been handled to
avoid further processing (and warnings).
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: remove gtk_widget_sink, because there is
no point in providing such a function.
* gdk/gdk.c (gdk_init): changed options `-name' and `-class'
to `--name' and `--class', because the old names would
confuse getopt(). these arguments have been introduced in the
changes from gtk+970916 to gtk+970925 without a ChangeLog entry,
changing argument names is painful, it would be nice if people
would care about compatibility and consistency in the first place!
1998-02-05 03:53:41 +00:00
|
|
|
g_return_if_fail (widget->parent == NULL);
|
|
|
|
g_return_if_fail (!GTK_WIDGET_TOPLEVEL (widget));
|
1998-01-30 23:47:09 +00:00
|
|
|
g_return_if_fail (parent != NULL);
|
|
|
|
|
1998-02-03 14:13:05 +00:00
|
|
|
/* keep this function in sync with gtk_menu_attach_to_widget()
|
|
|
|
*/
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_ref (widget);
|
1998-02-03 14:13:05 +00:00
|
|
|
gtk_object_sink (GTK_OBJECT (widget));
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->parent = parent;
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
if (GTK_WIDGET_STATE (parent) != GTK_STATE_NORMAL)
|
|
|
|
data.state = GTK_WIDGET_STATE (parent);
|
|
|
|
else
|
|
|
|
data.state = GTK_WIDGET_STATE (widget);
|
1998-03-26 21:57:45 +00:00
|
|
|
data.state_restauration = FALSE;
|
|
|
|
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (parent) != FALSE);
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
gtk_widget_propagate_state (widget, &data);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
while (parent->parent != NULL)
|
|
|
|
parent = parent->parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-01 23:29:40 +00:00
|
|
|
gtk_widget_set_style_recurse (widget, NULL);
|
1998-02-18 04:09:13 +00:00
|
|
|
|
1998-02-22 02:18:29 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], NULL);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
/*****************************************
|
|
|
|
* Widget styles
|
|
|
|
* see docs/styles.txt
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_set_style (GtkWidget *widget,
|
|
|
|
GtkStyle *style)
|
|
|
|
{
|
|
|
|
GtkStyle *default_style;
|
1998-02-27 22:09:20 +00:00
|
|
|
gboolean initial_emission;
|
1998-02-27 16:31:06 +00:00
|
|
|
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (style != NULL);
|
|
|
|
|
1998-02-27 22:09:20 +00:00
|
|
|
initial_emission = !GTK_WIDGET_RC_STYLE (widget) && !GTK_WIDGET_USER_STYLE (widget);
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE);
|
|
|
|
GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
|
1998-02-27 16:31:06 +00:00
|
|
|
if (!default_style)
|
|
|
|
{
|
|
|
|
gtk_style_ref (widget->style);
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!saved_default_style_key_id)
|
|
|
|
saved_default_style_key_id = gtk_object_data_force_id (saved_default_style_key);
|
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id, widget->style);
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
|
1998-02-27 22:09:20 +00:00
|
|
|
gtk_widget_set_style_internal (widget, style, initial_emission);
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_ensure_style (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
if (!GTK_WIDGET_USER_STYLE (widget) &&
|
|
|
|
!GTK_WIDGET_RC_STYLE (widget))
|
|
|
|
gtk_widget_set_rc_style (widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_rc_style (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkStyle *saved_style;
|
|
|
|
GtkStyle *new_style;
|
1998-02-27 22:09:20 +00:00
|
|
|
gboolean initial_emission;
|
1998-02-27 16:31:06 +00:00
|
|
|
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
|
1998-02-27 22:09:20 +00:00
|
|
|
initial_emission = !GTK_WIDGET_RC_STYLE (widget) && !GTK_WIDGET_USER_STYLE (widget);
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE);
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
|
1998-02-27 16:31:06 +00:00
|
|
|
new_style = gtk_rc_get_style (widget);
|
|
|
|
if (new_style)
|
|
|
|
{
|
|
|
|
if (!saved_style)
|
|
|
|
{
|
|
|
|
gtk_style_ref (widget->style);
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!saved_default_style_key_id)
|
|
|
|
saved_default_style_key_id = gtk_object_data_force_id (saved_default_style_key);
|
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id, widget->style);
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
1998-02-27 22:09:20 +00:00
|
|
|
gtk_widget_set_style_internal (widget, new_style, initial_emission);
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (saved_style)
|
|
|
|
{
|
1998-02-27 22:09:20 +00:00
|
|
|
g_assert (initial_emission == FALSE); /* FIXME: remove this line */
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
|
1998-02-27 22:09:20 +00:00
|
|
|
gtk_widget_set_style_internal (widget, saved_style, initial_emission);
|
1998-02-27 16:31:06 +00:00
|
|
|
gtk_style_unref (saved_style);
|
|
|
|
}
|
1998-02-27 22:09:20 +00:00
|
|
|
else
|
|
|
|
{
|
1998-03-01 23:29:40 +00:00
|
|
|
if (initial_emission)
|
|
|
|
gtk_widget_set_style_internal (widget, widget->style, TRUE);
|
1998-02-27 22:09:20 +00:00
|
|
|
}
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-03-01 17:44:24 +00:00
|
|
|
void
|
|
|
|
gtk_widget_restore_default_style (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GtkStyle *default_style;
|
|
|
|
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
|
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
default_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
|
1998-03-01 17:44:24 +00:00
|
|
|
if (default_style)
|
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
|
1998-03-01 17:44:24 +00:00
|
|
|
gtk_widget_set_style_internal (widget, default_style, FALSE);
|
|
|
|
gtk_style_unref (default_style);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
GtkStyle*
|
|
|
|
gtk_widget_get_style (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
|
|
|
|
|
|
|
return widget->style;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_style_set (GtkWidget *widget,
|
|
|
|
GtkStyle *previous_style)
|
|
|
|
{
|
|
|
|
if (GTK_WIDGET_REALIZED (widget) &&
|
|
|
|
!GTK_WIDGET_NO_WINDOW (widget))
|
1998-05-01 16:15:39 +00:00
|
|
|
{
|
|
|
|
gtk_style_set_background (widget->style, widget->window, widget->state);
|
|
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
|
|
|
gdk_window_clear (widget->window);
|
|
|
|
}
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_set_style_internal (GtkWidget *widget,
|
1998-02-27 22:09:20 +00:00
|
|
|
GtkStyle *style,
|
|
|
|
gboolean initial_emission)
|
1998-02-27 16:31:06 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (style != NULL);
|
|
|
|
|
|
|
|
if (widget->style != style)
|
|
|
|
{
|
|
|
|
GtkStyle *previous_style;
|
|
|
|
|
|
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
|
|
gtk_style_detach (widget->style);
|
|
|
|
|
|
|
|
previous_style = widget->style;
|
|
|
|
widget->style = style;
|
|
|
|
gtk_style_ref (widget->style);
|
|
|
|
|
|
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
|
|
widget->style = gtk_style_attach (widget->style, widget->window);
|
|
|
|
|
1998-02-27 22:09:20 +00:00
|
|
|
gtk_signal_emit (GTK_OBJECT (widget),
|
|
|
|
widget_signals[STYLE_SET],
|
|
|
|
initial_emission ? NULL : previous_style);
|
1998-02-27 16:31:06 +00:00
|
|
|
gtk_style_unref (previous_style);
|
|
|
|
|
1998-03-05 06:32:42 +00:00
|
|
|
if (widget->parent && !initial_emission)
|
1998-02-27 16:31:06 +00:00
|
|
|
{
|
|
|
|
GtkRequisition old_requisition;
|
|
|
|
|
|
|
|
old_requisition = widget->requisition;
|
|
|
|
gtk_widget_size_request (widget, &widget->requisition);
|
|
|
|
|
|
|
|
if ((old_requisition.width != widget->requisition.width) ||
|
|
|
|
(old_requisition.height != widget->requisition.height))
|
|
|
|
gtk_widget_queue_resize (widget);
|
|
|
|
else if (GTK_WIDGET_DRAWABLE (widget))
|
|
|
|
gtk_widget_queue_draw (widget);
|
|
|
|
}
|
|
|
|
}
|
1998-02-27 22:09:20 +00:00
|
|
|
else if (initial_emission)
|
|
|
|
{
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget),
|
|
|
|
widget_signals[STYLE_SET],
|
|
|
|
NULL);
|
|
|
|
}
|
1998-02-27 16:31:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_set_style_recurse (GtkWidget *widget,
|
|
|
|
gpointer client_data)
|
|
|
|
{
|
1998-03-01 23:29:40 +00:00
|
|
|
if (GTK_WIDGET_RC_STYLE (widget))
|
1998-02-27 16:31:06 +00:00
|
|
|
gtk_widget_set_rc_style (widget);
|
|
|
|
|
|
|
|
if (GTK_IS_CONTAINER (widget))
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
|
|
|
gtk_widget_set_style_recurse,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
1998-05-01 16:15:39 +00:00
|
|
|
void
|
|
|
|
gtk_widget_reset_rc_styles (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
gtk_widget_set_style_recurse (widget, NULL);
|
|
|
|
}
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
void
|
|
|
|
gtk_widget_set_default_style (GtkStyle *style)
|
|
|
|
{
|
|
|
|
if (style != default_style)
|
|
|
|
{
|
|
|
|
if (default_style)
|
|
|
|
gtk_style_unref (default_style);
|
|
|
|
default_style = style;
|
|
|
|
if (default_style)
|
|
|
|
gtk_style_ref (default_style);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
GtkStyle*
|
|
|
|
gtk_widget_get_default_style ()
|
|
|
|
{
|
|
|
|
if (!default_style)
|
|
|
|
{
|
|
|
|
default_style = gtk_style_new ();
|
|
|
|
gtk_style_ref (default_style);
|
|
|
|
}
|
|
|
|
|
|
|
|
return default_style;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_push_style (GtkStyle *style)
|
|
|
|
{
|
|
|
|
g_return_if_fail (style != NULL);
|
|
|
|
|
|
|
|
gtk_style_ref (style);
|
|
|
|
style_stack = g_slist_prepend (style_stack, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
static GtkStyle*
|
|
|
|
gtk_widget_peek_style ()
|
|
|
|
{
|
|
|
|
if (style_stack)
|
|
|
|
return (GtkStyle*) style_stack->data;
|
|
|
|
else
|
|
|
|
return gtk_widget_get_default_style ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_pop_style ()
|
|
|
|
{
|
|
|
|
GSList *tmp;
|
|
|
|
|
|
|
|
if (style_stack)
|
|
|
|
{
|
|
|
|
tmp = style_stack;
|
|
|
|
style_stack = style_stack->next;
|
|
|
|
gtk_style_unref ((GtkStyle*) tmp->data);
|
|
|
|
g_slist_free_1 (tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Basically, send a message to all toplevel windows telling them
|
|
|
|
* that a new _GTK_STYLE_COLORS property is available on the root
|
|
|
|
* window
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gtk_widget_propagate_default_style (void)
|
|
|
|
{
|
|
|
|
GdkEventClient sev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Set the property on the root window */
|
|
|
|
gdk_property_change(GDK_ROOT_PARENT(),
|
|
|
|
gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE),
|
|
|
|
gdk_atom_intern("STRING", FALSE),
|
|
|
|
8*sizeof(gushort),
|
|
|
|
GDK_PROP_MODE_REPLACE,
|
|
|
|
(guchar *)gtk_widget_get_default_style(),
|
|
|
|
GTK_STYLE_NUM_STYLECOLORS() * sizeof(GdkColor));
|
|
|
|
|
|
|
|
for(i = 0; i < 5; i++)
|
|
|
|
sev.data.l[i] = 0;
|
|
|
|
sev.data_format = 32;
|
|
|
|
sev.message_type = gdk_atom_intern ("_GTK_STYLE_CHANGED", FALSE);
|
|
|
|
gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
|
|
|
|
}
|
|
|
|
|
1998-01-18 15:09:10 +00:00
|
|
|
/*************************************************************
|
|
|
|
* gtk_widget_set_parent_window:
|
|
|
|
* Set a non default parent window for widget
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
* widget:
|
|
|
|
* parent_window
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_parent_window (GtkWidget *widget,
|
|
|
|
GdkWindow *parent_window)
|
|
|
|
{
|
|
|
|
GdkWindow *old_parent_window;
|
|
|
|
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
old_parent_window = gtk_object_get_data_by_id (GTK_OBJECT (widget),
|
|
|
|
parent_window_key_id);
|
1998-01-18 15:09:10 +00:00
|
|
|
|
|
|
|
if (parent_window != old_parent_window)
|
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!parent_window_key_id)
|
|
|
|
parent_window_key_id = gtk_object_data_force_id (parent_window_key);
|
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), parent_window_key_id,
|
|
|
|
parent_window);
|
1998-01-18 15:09:10 +00:00
|
|
|
if (old_parent_window)
|
|
|
|
gdk_window_unref (old_parent_window);
|
|
|
|
if (parent_window)
|
|
|
|
gdk_window_ref (parent_window);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************
|
|
|
|
* gtk_widget_get_parent_window:
|
|
|
|
* Get widget's parent window
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
* widget:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
* parent window
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
GdkWindow *
|
|
|
|
gtk_widget_get_parent_window (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GdkWindow *parent_window;
|
|
|
|
|
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1998-02-22 12:16:01 +00:00
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
|
|
|
|
g_return_val_if_fail (widget->parent != NULL, NULL);
|
1998-01-18 15:09:10 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
parent_window = gtk_object_get_data_by_id (GTK_OBJECT (widget),
|
|
|
|
parent_window_key_id);
|
1998-01-18 15:09:10 +00:00
|
|
|
|
|
|
|
return (parent_window != NULL) ? parent_window : widget->parent->window;
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_uposition:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_uposition (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint x,
|
|
|
|
gint y)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!aux_info)
|
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!aux_info_key_id)
|
|
|
|
aux_info_key_id = gtk_object_data_force_id (aux_info_key);
|
1997-11-24 22:37:52 +00:00
|
|
|
aux_info = gtk_widget_aux_info_new ();
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), aux_info_key_id, aux_info);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (x > -2)
|
|
|
|
aux_info->x = x;
|
|
|
|
if (y > -2)
|
|
|
|
aux_info->y = y;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
|
|
|
|
(aux_info->x != -1) && (aux_info->y != -1))
|
|
|
|
{
|
|
|
|
gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
|
|
|
|
gdk_window_move (widget->window, aux_info->x, aux_info->y);
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
|
|
|
|
gtk_widget_size_allocate (widget, &widget->allocation);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_usize:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_usize (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint width,
|
|
|
|
gint height)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!aux_info)
|
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!aux_info_key_id)
|
|
|
|
aux_info_key_id = gtk_object_data_force_id (aux_info_key);
|
1997-11-24 22:37:52 +00:00
|
|
|
aux_info = gtk_widget_aux_info_new ();
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), aux_info_key_id, aux_info);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (width > -1)
|
|
|
|
aux_info->width = width;
|
|
|
|
if (height > -1)
|
|
|
|
aux_info->height = height;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_VISIBLE (widget))
|
|
|
|
gtk_widget_queue_resize (widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_events:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_events (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint events)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
gint *eventp;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
|
|
|
|
g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (events)
|
|
|
|
{
|
|
|
|
if (!eventp)
|
|
|
|
eventp = g_new (gint, 1);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
*eventp = events;
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!event_key_id)
|
|
|
|
event_key_id = gtk_object_data_force_id (event_key);
|
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), event_key_id, eventp);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-03-14 04:43:14 +00:00
|
|
|
else if (eventp)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
g_free (eventp);
|
|
|
|
gtk_object_remove_data_by_id (GTK_OBJECT (widget), event_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_extension_events:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_extension_events (GtkWidget *widget,
|
|
|
|
GdkExtensionMode mode)
|
|
|
|
{
|
|
|
|
GdkExtensionMode *modep;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!modep)
|
|
|
|
modep = g_new (GdkExtensionMode, 1);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
*modep = mode;
|
1998-03-14 04:43:14 +00:00
|
|
|
if (!extension_event_key_id)
|
|
|
|
extension_event_key_id = gtk_object_data_force_id (extension_event_key);
|
|
|
|
gtk_object_set_data_by_id (GTK_OBJECT (widget), extension_event_key_id, modep);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_toplevel:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GtkWidget*
|
|
|
|
gtk_widget_get_toplevel (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
while (widget->parent)
|
|
|
|
widget = widget->parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return widget;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_ancestor:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GtkWidget*
|
|
|
|
gtk_widget_get_ancestor (GtkWidget *widget,
|
1998-03-09 15:16:28 +00:00
|
|
|
GtkType widget_type)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-09 15:16:28 +00:00
|
|
|
while (widget && !gtk_type_is_a (GTK_WIDGET_TYPE (widget), widget_type))
|
1997-11-24 22:37:52 +00:00
|
|
|
widget = widget->parent;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-09 15:16:28 +00:00
|
|
|
if (!(widget && gtk_type_is_a (GTK_WIDGET_TYPE (widget), widget_type)))
|
1997-11-24 22:37:52 +00:00
|
|
|
return NULL;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return widget;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GdkColormap*
|
|
|
|
gtk_widget_get_colormap (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GdkColormap *colormap;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!widget->window)
|
|
|
|
{
|
|
|
|
colormap = gtk_object_get_data (GTK_OBJECT (widget), colormap_key);
|
|
|
|
if (colormap)
|
|
|
|
return colormap;
|
|
|
|
return gtk_widget_get_default_colormap ();
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return gdk_window_get_colormap (widget->window);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GdkVisual*
|
|
|
|
gtk_widget_get_visual (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GdkVisual *visual;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!widget->window)
|
|
|
|
{
|
|
|
|
visual = gtk_object_get_data (GTK_OBJECT (widget), visual_key);
|
|
|
|
if (visual)
|
|
|
|
return visual;
|
|
|
|
return gtk_widget_get_default_visual ();
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return gdk_window_get_visual (widget->window);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_events:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gtk_widget_get_events (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
gint *events;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, 0);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
events = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (events)
|
|
|
|
return *events;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_extension_events:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GdkExtensionMode
|
|
|
|
gtk_widget_get_extension_events (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
GdkExtensionMode *mode;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_val_if_fail (widget != NULL, 0);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (mode)
|
|
|
|
return *mode;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_pointer:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_get_pointer (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint *x,
|
|
|
|
gint *y)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (x)
|
|
|
|
*x = -1;
|
|
|
|
if (y)
|
|
|
|
*y = -1;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
|
|
{
|
|
|
|
gdk_window_get_pointer (widget->window, x, y, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
if (x)
|
|
|
|
*x -= widget->allocation.x;
|
|
|
|
if (y)
|
|
|
|
*y -= widget->allocation.y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_is_ancestor:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gtk_widget_is_ancestor (GtkWidget *widget,
|
|
|
|
GtkWidget *ancestor)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (ancestor != NULL, FALSE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
while (widget)
|
|
|
|
{
|
|
|
|
if (widget->parent == ancestor)
|
|
|
|
return TRUE;
|
|
|
|
widget = widget->parent;
|
|
|
|
}
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_is_child:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gtk_widget_is_child (GtkWidget *widget,
|
|
|
|
GtkWidget *child)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (child != NULL, FALSE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return (child->parent == widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_push_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_push_colormap (GdkColormap *cmap)
|
|
|
|
{
|
1998-02-26 01:48:28 +00:00
|
|
|
g_return_if_fail (cmap != NULL);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
colormap_stack = g_slist_prepend (colormap_stack, cmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_push_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_push_visual (GdkVisual *visual)
|
|
|
|
{
|
1998-02-26 01:48:28 +00:00
|
|
|
g_return_if_fail (visual != NULL);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
visual_stack = g_slist_prepend (visual_stack, visual);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_pop_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_pop_colormap ()
|
|
|
|
{
|
|
|
|
GSList *tmp;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (colormap_stack)
|
|
|
|
{
|
|
|
|
tmp = colormap_stack;
|
|
|
|
colormap_stack = colormap_stack->next;
|
|
|
|
g_slist_free_1 (tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_pop_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_pop_visual ()
|
|
|
|
{
|
|
|
|
GSList *tmp;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (visual_stack)
|
|
|
|
{
|
|
|
|
tmp = visual_stack;
|
|
|
|
visual_stack = visual_stack->next;
|
|
|
|
g_slist_free_1 (tmp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_default_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_default_colormap (GdkColormap *colormap)
|
|
|
|
{
|
1997-12-18 02:17:14 +00:00
|
|
|
if (default_colormap != colormap)
|
|
|
|
{
|
|
|
|
if (default_colormap)
|
|
|
|
gdk_colormap_unref (default_colormap);
|
|
|
|
default_colormap = colormap;
|
|
|
|
if (default_colormap)
|
|
|
|
gdk_colormap_ref (default_colormap);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_set_default_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_set_default_visual (GdkVisual *visual)
|
|
|
|
{
|
|
|
|
default_visual = visual;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_default_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GdkColormap*
|
|
|
|
gtk_widget_get_default_colormap ()
|
|
|
|
{
|
|
|
|
if (!default_colormap)
|
|
|
|
default_colormap = gdk_colormap_get_system ();
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return default_colormap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_get_default_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
GdkVisual*
|
|
|
|
gtk_widget_get_default_visual ()
|
|
|
|
{
|
|
|
|
if (!default_visual)
|
|
|
|
default_visual = gdk_visual_get_system ();
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return default_visual;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_1:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_marshal_signal_1 (GtkObject *object,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkSignalFunc func,
|
1997-11-28 01:22:38 +00:00
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetSignal1 rfunc;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
rfunc = (GtkWidgetSignal1) func;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
(* rfunc) (object,
|
|
|
|
GTK_VALUE_POINTER (args[0]),
|
|
|
|
func_data);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_2:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_marshal_signal_2 (GtkObject *object,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkSignalFunc func,
|
1997-11-28 01:22:38 +00:00
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetSignal2 rfunc;
|
|
|
|
gint *return_val;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
rfunc = (GtkWidgetSignal2) func;
|
|
|
|
return_val = GTK_RETLOC_BOOL (args[3]);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
*return_val = (* rfunc) (object,
|
|
|
|
GTK_VALUE_STRING (args[0]),
|
|
|
|
GTK_VALUE_CHAR (args[1]),
|
|
|
|
GTK_VALUE_INT (args[2]),
|
1997-11-24 22:37:52 +00:00
|
|
|
func_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_3:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_marshal_signal_3 (GtkObject *object,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkSignalFunc func,
|
1997-11-28 01:22:38 +00:00
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetSignal3 rfunc;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
rfunc = (GtkWidgetSignal3) func;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
(* rfunc) (object,
|
|
|
|
GTK_VALUE_STRING (args[0]),
|
|
|
|
func_data);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_4:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1997-11-28 01:22:38 +00:00
|
|
|
gtk_widget_marshal_signal_4 (GtkObject *object,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkSignalFunc func,
|
1997-11-28 01:22:38 +00:00
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetSignal4 rfunc;
|
|
|
|
gint *return_val;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
rfunc = (GtkWidgetSignal4) func;
|
|
|
|
return_val = GTK_RETLOC_BOOL (args[1]);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
*return_val = (* rfunc) (object,
|
|
|
|
GTK_VALUE_BOXED (args[0]),
|
|
|
|
func_data);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_5:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_marshal_signal_5 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
|
|
|
{
|
|
|
|
GtkWidgetSignal5 rfunc;
|
|
|
|
|
|
|
|
rfunc = (GtkWidgetSignal5) func;
|
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
(* rfunc) (object,
|
|
|
|
GTK_VALUE_UINT (args[0]),
|
|
|
|
func_data);
|
1998-01-20 23:58:42 +00:00
|
|
|
}
|
|
|
|
|
1998-02-18 04:09:13 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_6:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_marshal_signal_6 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
|
|
|
{
|
|
|
|
GtkWidgetSignal6 rfunc;
|
|
|
|
|
|
|
|
rfunc = (GtkWidgetSignal6) func;
|
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
(* rfunc) (object,
|
|
|
|
GTK_VALUE_OBJECT (args[0]),
|
|
|
|
func_data);
|
1998-02-18 04:09:13 +00:00
|
|
|
}
|
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_marshal_signal_7:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_marshal_signal_7 (GtkObject *object,
|
|
|
|
GtkSignalFunc func,
|
|
|
|
gpointer func_data,
|
|
|
|
GtkArg *args)
|
|
|
|
{
|
|
|
|
GtkWidgetSignal7 rfunc;
|
|
|
|
|
|
|
|
rfunc = (GtkWidgetSignal7) func;
|
|
|
|
|
|
|
|
(* rfunc) (object,
|
|
|
|
GTK_VALUE_BOXED (args[0]),
|
|
|
|
func_data);
|
|
|
|
}
|
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
static void
|
|
|
|
gtk_widget_shutdown (GtkObject *object)
|
|
|
|
{
|
|
|
|
GtkWidget *widget;
|
|
|
|
|
|
|
|
/* gtk_object_destroy() will already hold a refcount on object
|
|
|
|
*/
|
|
|
|
widget = GTK_WIDGET (object);
|
|
|
|
|
|
|
|
if (widget->parent)
|
|
|
|
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
|
|
|
|
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
|
|
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
|
|
gtk_widget_unrealize (widget);
|
|
|
|
|
|
|
|
parent_class->shutdown (object);
|
|
|
|
}
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
static void
|
|
|
|
gtk_widget_real_destroy (GtkObject *object)
|
|
|
|
{
|
1998-03-14 04:43:14 +00:00
|
|
|
GtkWidget *widget;
|
1998-02-28 19:09:20 +00:00
|
|
|
GtkStyle *saved_style;
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
/* gtk_object_destroy() will already hold a refcount on object
|
|
|
|
*/
|
|
|
|
widget = GTK_WIDGET (object);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
1998-02-02 14:11:24 +00:00
|
|
|
if (GTK_CONTAINER_RESIZE_PENDING (widget))
|
1998-01-30 23:47:09 +00:00
|
|
|
{
|
|
|
|
gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gtk_grab_remove (widget);
|
|
|
|
gtk_selection_remove_all (widget);
|
1998-04-24 00:26:01 +00:00
|
|
|
gtk_accelerator_tables_delete (object);
|
|
|
|
|
|
|
|
saved_style = gtk_object_get_data_by_id (object, saved_default_style_key_id);
|
1998-02-28 19:09:20 +00:00
|
|
|
if (saved_style)
|
|
|
|
{
|
|
|
|
gtk_style_unref (saved_style);
|
1998-04-24 00:26:01 +00:00
|
|
|
gtk_object_remove_data_by_id (object, saved_default_style_key_id);
|
1998-02-28 19:09:20 +00:00
|
|
|
}
|
|
|
|
|
1998-02-26 01:48:28 +00:00
|
|
|
gtk_style_unref (widget->style);
|
|
|
|
widget->style = NULL;
|
|
|
|
|
|
|
|
parent_class->destroy (object);
|
1998-01-30 23:47:09 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
static void
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_widget_finalize (GtkObject *object)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidget *widget;
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
|
|
|
gint *events;
|
|
|
|
GdkExtensionMode *mode;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget = GTK_WIDGET (object);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->name)
|
1998-03-14 04:43:14 +00:00
|
|
|
g_free (widget->name);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (aux_info)
|
1998-03-14 04:43:14 +00:00
|
|
|
gtk_widget_aux_info_destroy (aux_info);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
events = gtk_object_get_data_by_id (GTK_OBJECT (widget), event_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (events)
|
1998-03-14 04:43:14 +00:00
|
|
|
g_free (events);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-03-14 04:43:14 +00:00
|
|
|
mode = gtk_object_get_data_by_id (GTK_OBJECT (widget), extension_event_key_id);
|
1997-11-24 22:37:52 +00:00
|
|
|
if (mode)
|
1998-03-14 04:43:14 +00:00
|
|
|
g_free (mode);
|
1998-01-30 23:47:09 +00:00
|
|
|
|
|
|
|
parent_class->finalize (object);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_show:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_show (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_VISIBLE (widget))
|
|
|
|
{
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->parent)
|
|
|
|
{
|
1998-03-21 22:11:26 +00:00
|
|
|
gtk_widget_queue_resize (widget->parent);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_MAPPED (widget->parent))
|
|
|
|
gtk_widget_map (widget);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_hide:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_hide (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_VISIBLE (widget))
|
|
|
|
{
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_MAPPED (widget))
|
|
|
|
gtk_widget_unmap (widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (widget->parent)
|
|
|
|
gtk_widget_queue_resize (widget);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_map:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_map (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
|
|
|
|
{
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
gdk_window_show (widget->window);
|
|
|
|
else
|
|
|
|
gtk_widget_queue_draw (widget);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_unmap:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_unmap (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_MAPPED (widget))
|
|
|
|
{
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
gdk_window_clear_area (widget->window,
|
|
|
|
widget->allocation.x,
|
|
|
|
widget->allocation.y,
|
|
|
|
widget->allocation.width,
|
|
|
|
widget->allocation.height);
|
|
|
|
else
|
|
|
|
gdk_window_hide (widget->window);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_realize:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_realize (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1998-02-19 07:18:42 +00:00
|
|
|
g_return_if_fail (GTK_WIDGET_NO_WINDOW (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
|
1998-01-30 23:47:09 +00:00
|
|
|
if (widget->parent)
|
|
|
|
{
|
|
|
|
widget->window = gtk_widget_get_parent_window (widget);
|
|
|
|
gdk_window_ref (widget->window);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->style = gtk_style_attach (widget->style, widget->window);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_unrealize:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_unrealize (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 06:47:01 +00:00
|
|
|
|
1998-02-02 05:35:59 +00:00
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_MAPPED (widget))
|
|
|
|
gtk_widget_real_unmap (widget);
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
|
1997-11-28 06:47:01 +00:00
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
/* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT(widget)->klass->type));
|
|
|
|
*/
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_style_detach (widget->style);
|
|
|
|
if (!GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
{
|
|
|
|
gdk_window_set_user_data (widget->window, NULL);
|
|
|
|
gdk_window_destroy (widget->window);
|
|
|
|
}
|
1998-01-30 23:47:09 +00:00
|
|
|
else
|
1998-02-02 05:35:59 +00:00
|
|
|
{
|
|
|
|
gdk_window_unref (widget->window);
|
|
|
|
}
|
1998-02-10 04:17:10 +00:00
|
|
|
|
|
|
|
/* Unrealize afterwards to improve visual effect */
|
|
|
|
|
|
|
|
if (GTK_IS_CONTAINER (widget))
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
|
|
|
(GtkCallback)gtk_widget_unrealize,
|
|
|
|
NULL);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->window = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_draw:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_draw (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GdkRectangle *area)
|
|
|
|
{
|
|
|
|
GdkEventExpose event;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
|
|
|
g_return_if_fail (area != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_DRAWABLE (widget))
|
|
|
|
{
|
|
|
|
event.type = GDK_EXPOSE;
|
1998-03-17 18:29:07 +00:00
|
|
|
event.send_event = TRUE;
|
1997-11-24 22:37:52 +00:00
|
|
|
event.window = widget->window;
|
|
|
|
event.area = *area;
|
1998-03-17 18:29:07 +00:00
|
|
|
event.count = 0;
|
|
|
|
|
1998-01-30 23:47:09 +00:00
|
|
|
gdk_window_ref (event.window);
|
1997-11-24 22:37:52 +00:00
|
|
|
gtk_widget_event (widget, (GdkEvent*) &event);
|
1998-01-30 23:47:09 +00:00
|
|
|
gdk_window_unref (event.window);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_queue_draw:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static gint
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_queue_draw (GtkWidget *widget)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_draw (widget, NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
1998-01-30 23:47:09 +00:00
|
|
|
* gtk_widget_real_size_allocate:
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_real_size_allocate (GtkWidget *widget,
|
1997-11-24 22:37:52 +00:00
|
|
|
GtkAllocation *allocation)
|
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_NO_WINDOW (widget) &&
|
|
|
|
GTK_WIDGET_MAPPED (widget) &&
|
|
|
|
((widget->allocation.x != allocation->x) ||
|
|
|
|
(widget->allocation.y != allocation->y) ||
|
|
|
|
(widget->allocation.width != allocation->width) ||
|
|
|
|
(widget->allocation.height != allocation->height)) &&
|
|
|
|
(widget->allocation.width != 0) &&
|
|
|
|
(widget->allocation.height != 0))
|
|
|
|
gdk_window_clear_area (widget->window,
|
|
|
|
widget->allocation.x,
|
|
|
|
widget->allocation.y,
|
|
|
|
widget->allocation.width,
|
|
|
|
widget->allocation.height);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
widget->allocation = *allocation;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (GTK_WIDGET_REALIZED (widget) &&
|
|
|
|
!GTK_WIDGET_NO_WINDOW (widget))
|
|
|
|
gdk_window_move_resize (widget->window,
|
|
|
|
allocation->x, allocation->y,
|
|
|
|
allocation->width, allocation->height);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_peek_colormap:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static GdkColormap*
|
|
|
|
gtk_widget_peek_colormap ()
|
|
|
|
{
|
|
|
|
if (colormap_stack)
|
|
|
|
return (GdkColormap*) colormap_stack->data;
|
|
|
|
return gtk_widget_get_default_colormap ();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_peek_visual:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static GdkVisual*
|
|
|
|
gtk_widget_peek_visual ()
|
|
|
|
{
|
|
|
|
if (visual_stack)
|
|
|
|
return (GdkVisual*) visual_stack->data;
|
|
|
|
return gtk_widget_get_default_visual ();
|
|
|
|
}
|
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
/*************************************************************
|
|
|
|
* gtk_widget_propagate_state:
|
|
|
|
* Propagate a change in the widgets state down the tree
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
1998-01-20 23:58:42 +00:00
|
|
|
* widget
|
|
|
|
* GtkStateData: state
|
|
|
|
* parent_sensitive
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* results:
|
1998-01-20 23:58:42 +00:00
|
|
|
*************************************************************/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-02-27 16:31:06 +00:00
|
|
|
static void
|
1998-01-20 23:58:42 +00:00
|
|
|
gtk_widget_propagate_state (GtkWidget *widget,
|
|
|
|
GtkStateData *data)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-20 23:58:42 +00:00
|
|
|
guint8 old_state;
|
|
|
|
|
1998-03-26 21:57:45 +00:00
|
|
|
/* don't call this function with state==GTK_STATE_INSENSITIVE,
|
|
|
|
* parent_sensitive==TRUE on a sensitive widget
|
1998-01-20 23:58:42 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
old_state = GTK_WIDGET_STATE (widget);
|
|
|
|
|
|
|
|
if (data->parent_sensitive)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GTK_WIDGET_SET_FLAGS (widget, GTK_PARENT_SENSITIVE);
|
1998-01-20 23:58:42 +00:00
|
|
|
|
|
|
|
if (GTK_WIDGET_IS_SENSITIVE (widget))
|
1998-03-26 21:57:45 +00:00
|
|
|
{
|
|
|
|
if (data->state_restauration)
|
|
|
|
GTK_WIDGET_STATE (widget) = GTK_WIDGET_SAVED_STATE (widget);
|
|
|
|
else
|
|
|
|
GTK_WIDGET_STATE (widget) = data->state;
|
|
|
|
}
|
1998-01-20 23:58:42 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
|
1998-03-26 21:57:45 +00:00
|
|
|
if (!data->state_restauration &&
|
|
|
|
data->state != GTK_STATE_INSENSITIVE)
|
1998-01-20 23:58:42 +00:00
|
|
|
GTK_WIDGET_SAVED_STATE (widget) = data->state;
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GTK_WIDGET_UNSET_FLAGS (widget, GTK_PARENT_SENSITIVE);
|
1998-03-26 21:57:45 +00:00
|
|
|
if (!data->state_restauration)
|
|
|
|
{
|
|
|
|
if (data->state != GTK_STATE_INSENSITIVE)
|
|
|
|
GTK_WIDGET_SAVED_STATE (widget) = data->state;
|
|
|
|
}
|
|
|
|
else if (GTK_WIDGET_STATE (widget) != GTK_STATE_INSENSITIVE)
|
|
|
|
GTK_WIDGET_SAVED_STATE (widget) = GTK_WIDGET_STATE (widget);
|
1998-01-20 23:58:42 +00:00
|
|
|
GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
if (GTK_WIDGET_HAS_FOCUS (widget) && !GTK_WIDGET_IS_SENSITIVE (widget))
|
|
|
|
{
|
|
|
|
GtkWidget *window;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
|
|
|
|
if (window)
|
|
|
|
gtk_window_set_focus (GTK_WINDOW (window), NULL);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
if (old_state != GTK_WIDGET_STATE (widget))
|
|
|
|
{
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_ref (widget);
|
|
|
|
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[STATE_CHANGED], old_state);
|
|
|
|
|
1998-01-20 23:58:42 +00:00
|
|
|
if (GTK_IS_CONTAINER (widget))
|
|
|
|
{
|
1998-03-26 21:57:45 +00:00
|
|
|
data->parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget) != FALSE);
|
1998-01-20 23:58:42 +00:00
|
|
|
data->state = GTK_WIDGET_STATE (widget);
|
|
|
|
gtk_container_foreach (GTK_CONTAINER (widget),
|
|
|
|
(GtkCallback) gtk_widget_propagate_state,
|
|
|
|
data);
|
|
|
|
}
|
1998-01-30 23:47:09 +00:00
|
|
|
gtk_widget_unref (widget);
|
1998-01-20 23:58:42 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_draw_children_recurse:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_draw_children_recurse (GtkWidget *widget,
|
|
|
|
gpointer client_data)
|
|
|
|
{
|
|
|
|
gtk_widget_draw (widget, NULL);
|
|
|
|
gtk_widget_draw_children (widget);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_aux_info_new:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static GtkWidgetAuxInfo*
|
|
|
|
gtk_widget_aux_info_new ()
|
|
|
|
{
|
|
|
|
GtkWidgetAuxInfo *aux_info;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!aux_info_mem_chunk)
|
|
|
|
aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk",
|
|
|
|
sizeof (GtkWidgetAuxInfo),
|
|
|
|
1024, G_ALLOC_AND_FREE);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
aux_info->x = -1;
|
|
|
|
aux_info->y = -1;
|
|
|
|
aux_info->width = 0;
|
|
|
|
aux_info->height = 0;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return aux_info;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_aux_info_destroy:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
|
|
|
|
static void
|
|
|
|
gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
|
|
|
|
{
|
|
|
|
g_return_if_fail (aux_info != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_mem_chunk_free (aux_info_mem_chunk, aux_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_shape_combine_mask:
|
|
|
|
* set a shape for this widgets' gdk window, this allows for
|
|
|
|
* transparent windows etc., see gdk_window_shape_combine_mask
|
|
|
|
* for more information
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_shape_combine_mask (GtkWidget *widget,
|
|
|
|
GdkBitmap *shape_mask,
|
1997-11-28 01:22:38 +00:00
|
|
|
gint offset_x,
|
|
|
|
gint offset_y)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GtkWidgetShapeInfo* shape_info;
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
/* set_shape doesn't work on widgets without gdk window */
|
|
|
|
g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
|
|
|
|
if (!shape_mask)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_UNSET_FLAG (widget, GTK_HAS_SHAPE_MASK);
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
|
1998-02-17 06:03:40 +00:00
|
|
|
if (widget->window)
|
|
|
|
gdk_window_shape_combine_mask (widget->window, NULL, 0, 0);
|
|
|
|
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
|
|
|
|
gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key);
|
|
|
|
g_free (shape_info);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1998-02-02 21:41:24 +00:00
|
|
|
GTK_PRIVATE_SET_FLAG (widget, GTK_HAS_SHAPE_MASK);
|
1998-02-17 06:03:40 +00:00
|
|
|
|
GTK_RESIZE_NEEDED is a private flag now.
Mon Feb 2 04:15:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtkcontainer.h:
* gtk/gtkcontainer.c: GTK_RESIZE_NEEDED is a private flag now.
(gtk_container_register_toplevel): new function.
(gtk_container_unregister_toplevel): new function.
* gtk/gtkmain.c: GTK_LEAVE_PENDING is a private flag now.
* gtk/gtkmenu.c: call gtk_container_register_toplevel in
gtk_menu_class_init instead of this dirty gtk_widget_set_parent(,NULL)
hack. new default handler gtk_menu_destroy for calling
gtk_container_unregister_toplevel. removed GTK_ANCHORED, GTK_UNMAPPED.
* gtk/gtkobject.h: macro cleanups, added GTK_DESTROYED flag.
* gtk/gtkobject.c: only emit DESTROY signal if !GTK_OBJECT_DESTROYED
(object).
* gtk/gtkprivate.h: new file that will not be automatically included.
it holds the private flags for GtkWidget along with it's SET/UNSET
and examination macros.
* gtk/gtkwidget.c: private flags: GTK_RESIZE_NEEDED, GTK_REDRAW_PENDING,
GTK_RESIZE_PENDING, GTK_IN_REPARENT, GTK_USER_STYLE. GTK_ANCHORED is
replaced by GTK_TOPLEVEL. added missing UNSET for GTK_IN_REPARENT.
removed the gtk_widget_set_parent(, NULL) hack for toplevels.
upon destroy free memory for widgets with GTK_WIDGET_HAS_SHAPE_MASK.
* gtk/gtkwidget.h: split up the widget flags into a public and a private
portion. added an extra field private_flags to GtkWidget without making
it bigger by using an alignment gap of 16 bit. macro cleanups.
* gtk/gtkwindow.c: removed GTK_ANCHORED. new function gtk_window_destroy
for calling gtk_container_unregister_toplevel. removed the
gtk_widget_set_parent(,NULL), call gtk_container_register_toplevel
instead. remove GTK_UNMAPPED. GTK_RESIZE_NEEDED is private now.
* gtk/gtksignal.c (gtk_signal_disconnect): removed a bug on
removal that cut off the handler list -> living_objects == 0
with testgtk. made some warnings more descriptive.
new function gtk_signal_connect_object_while_alive, which
will automatically destroy the connection once one of the objects
is destroyed. didn't include this before removal of the above
mentioned bug.
* reflected refcounting revolution in ChangeLog
1998-02-02 04:54:25 +00:00
|
|
|
shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
|
|
|
|
if (!shape_info)
|
|
|
|
{
|
|
|
|
shape_info = g_new (GtkWidgetShapeInfo, 1);
|
|
|
|
gtk_object_set_data (GTK_OBJECT (widget), shape_info_key, shape_info);
|
|
|
|
}
|
|
|
|
shape_info->shape_mask = shape_mask;
|
|
|
|
shape_info->offset_x = offset_x;
|
|
|
|
shape_info->offset_y = offset_y;
|
|
|
|
|
|
|
|
/* set shape if widget has a gdk window allready.
|
|
|
|
* otherwise the shape is scheduled to be set by gtk_widget_realize.
|
|
|
|
*/
|
|
|
|
if (widget->window)
|
|
|
|
gdk_window_shape_combine_mask (widget->window, shape_mask,
|
|
|
|
offset_x, offset_y);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_dnd_drag_add:
|
1997-11-28 01:22:38 +00:00
|
|
|
* when you get a DRAG_ENTER event, you can use this
|
1997-11-24 22:37:52 +00:00
|
|
|
* to tell Gtk ofother widgets that are to be dragged as well
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_dnd_drag_add (GtkWidget *widget)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_dnd_drag_set:
|
|
|
|
* these two functions enable drag and/or drop on a
|
|
|
|
* widget and also let Gtk know what data types will be accepted
|
|
|
|
* use MIME type naming,plus tacking "URL:" on the front for link
|
|
|
|
* dragging
|
1997-11-28 01:22:38 +00:00
|
|
|
*
|
1997-11-24 22:37:52 +00:00
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_dnd_drag_set (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
guint8 drag_enable,
|
|
|
|
gchar **type_accept_list,
|
|
|
|
guint numtypes)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail(widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!widget->window)
|
|
|
|
gtk_widget_realize (widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget->window != NULL);
|
|
|
|
gdk_window_dnd_drag_set (widget->window,
|
|
|
|
drag_enable,
|
|
|
|
type_accept_list,
|
|
|
|
numtypes);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_dnd_drop_set:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_dnd_drop_set (GtkWidget *widget,
|
1997-11-28 01:22:38 +00:00
|
|
|
guint8 drop_enable,
|
|
|
|
gchar **type_accept_list,
|
|
|
|
guint numtypes,
|
|
|
|
guint8 is_destructive_operation)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail(widget != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (!widget->window)
|
|
|
|
gtk_widget_realize (widget);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
g_return_if_fail (widget->window != NULL);
|
|
|
|
gdk_window_dnd_drop_set (widget->window,
|
|
|
|
drop_enable,
|
|
|
|
type_accept_list,
|
|
|
|
numtypes,
|
|
|
|
is_destructive_operation);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************
|
|
|
|
* gtk_widget_dnd_data_set:
|
|
|
|
*
|
|
|
|
* arguments:
|
|
|
|
*
|
|
|
|
* results:
|
|
|
|
*****************************************/
|
|
|
|
void
|
|
|
|
gtk_widget_dnd_data_set (GtkWidget *widget,
|
|
|
|
GdkEvent *event,
|
|
|
|
gpointer data,
|
1997-11-28 01:22:38 +00:00
|
|
|
gulong data_numbytes)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (widget->window != NULL);
|
1997-11-28 01:22:38 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
gdk_window_dnd_data_set (widget->window, event, data, data_numbytes);
|
|
|
|
}
|
1998-02-02 18:44:28 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_ref (GtkWidget *widget)
|
|
|
|
{
|
1998-03-30 20:03:36 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1998-03-15 21:14:28 +00:00
|
|
|
|
1998-03-30 20:03:36 +00:00
|
|
|
gtk_object_ref ((GtkObject*) widget);
|
1998-02-02 18:44:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gtk_widget_unref (GtkWidget *widget)
|
|
|
|
{
|
1998-03-30 20:03:36 +00:00
|
|
|
g_return_if_fail (widget != NULL);
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (widget));
|
1998-03-15 21:14:28 +00:00
|
|
|
|
1998-03-30 20:03:36 +00:00
|
|
|
gtk_object_unref ((GtkObject*) widget);
|
1998-02-02 18:44:28 +00:00
|
|
|
}
|