PageRenderTime 19ms CodeModel.GetById 3ms app.highlight 7ms RepoModel.GetById 1ms app.codeStats 1ms

/src/wrappers/gtk/library/gtk_widget.e

http://github.com/tybor/Liberty
Specman e | 1503 lines | 550 code | 176 blank | 777 comment | 2 complexity | 5d5d34741c218d57eb93a3455ac78cf4 MD5 | raw file
   1indexing
   2	description: "GtkWidget -- Base class for all widgets"
   3	copyright: "[
   4					Copyright (C) 2006 eiffel-libraries team, GTK+ team
   5					
   6					This library is free software; you can redistribute it and/or
   7					modify it under the terms of the GNU Lesser General Public License
   8					as published by the Free Software Foundation; either version 2.1 of
   9					the License, or (at your option) any later version.
  10					
  11					This library is distributed in the hope that it will be useful, but
  12					WITHOUT ANY WARRANTY; without even the implied warranty of
  13					MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14					Lesser General Public License for more details.
  15
  16					You should have received a copy of the GNU Lesser General Public
  17					License along with this library; if not, write to the Free Software
  18					Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19					02110-1301 USA
  20				]"
  21	license: "LGPL v2 or later"
  22	date: "$Date:$"
  23	revision "$REvision:$"
  24
  25deferred class GTK_WIDGET
  26
  27inherit GTK_OBJECT
  28
  29insert
  30	GTK_WIDGET_EXTERNALS
  31	GDK_DRAG_ACTION
  32	GTK_DEST_DEFAULTS
  33	GDK_MODIFIER_TYPE
  34	GDK_EVENT_MASK
  35
  36feature -- Access
  37
  38	hide is
  39			-- Reverses the effects of `show' causing the widget to be hidden
  40			-- (invisible to the user).
  41		do
  42			gtk_widget_hide (handle)
  43		end
  44
  45	style: GTK_STYLE is
  46			-- Returns the style for this widget
  47		do
  48			create Result.from_external_pointer (gtk_widget_get_style (handle))
  49		end
  50
  51	is_sensitive: BOOLEAN is
  52			-- Returns True if this widget is sensitive.
  53		do
  54			Result := gtk_widget_is_sensitive (handle).to_boolean
  55		end
  56
  57
  58feature -- Operation
  59
  60	set_style (a_style: GTK_STYLE) is
  61			-- Sets the GTK_STYLE for a widget (widget.style).
  62			-- You probably don't want to use this function;
  63			-- it interacts badly with themes, because themes work by
  64			-- replacing the GtkStyle. Instead, use modify_style(). (NOT IMPLEMENTED)
  65		require
  66			valid_style: a_style /= Void
  67		do
  68			gtk_widget_set_style (handle, a_style.handle)
  69		end
  70
  71	show is
  72			-- Flags widget to be displayed.
  73		do
  74			debug 
  75				std_error.put_string(once "Showing a ")
  76				std_error.put_string(create {STRING}.from_external_copy
  77											(g_object_type_name(handle)))
  78				std_error.put_string(once ", handle ")
  79				std_error.put_pointer(handle)
  80				std_error.put_new_line
  81			end
  82			gtk_widget_show (handle)
  83		end
  84
  85	show_all is
  86			-- Recursively shows a widget, and any child widgets (if the
  87			-- widget is a container).
  88		do
  89			gtk_widget_show_all (handle)
  90		end
  91
  92	set_drag_destination, drag_dest_set (a_flags, an_actions: INTEGER) is
  93			-- Sets a widget as a potential drop destination.
  94			-- TODO: GtkTargetEntry isn't wrapped yet, use add_text_targets() and such..
  95		require
  96			is_valid_gtk_dest_defaults (a_flags)
  97			is_valid_gdk_drag_action (an_actions)
  98		do
  99			gtk_drag_dest_set (handle, a_flags, default_pointer, 0, an_actions)
 100		end
 101
 102	set_drag_source, drag_source_set (a_modifier, an_actions: INTEGER) is
 103			-- Sets up a widget so that GTK+ will start a drag operation when
 104			-- the user clicks and drags on the widget. The widget must have a
 105			-- window.
 106			-- TODO: GtkTargetEntry isn't wrapped yet, use add_text_targets() and such...
 107		require
 108			is_valid_gdk_modifier_type (a_modifier)
 109			is_valid_gdk_drag_action (an_actions)
 110		do
 111			gtk_drag_source_set (handle, a_modifier, default_pointer, 0, an_actions)
 112		end
 113
 114	drag_dest_add_text_targets is
 115			-- Add the text targets supported by GtkSelection to the target
 116			-- list of the drag destination. The targets are added with
 117			-- info = 0. If you need another value, use
 118			-- drag_dest_set_target_list
 119		do
 120			gtk_drag_dest_add_text_targets (handle)
 121		end
 122
 123	drag_dest_add_image_targets is
 124			-- Add the image targets supported by GtkSelection to the target
 125			-- list of the drag destination. The targets are added with
 126			-- info = 0. If you need another value, use
 127			-- drag_dest_set_target_list
 128		do
 129			gtk_drag_dest_add_image_targets (handle)
 130		end
 131
 132	drag_dest_add_uri_targets is
 133			-- Add the URI targets supported by GtkSelection to the target
 134			-- list of the drag destination. The targets are added with
 135			-- info = 0. If you need another value, use
 136			-- drag_dest_set_target_list
 137		do
 138			gtk_drag_dest_add_uri_targets (handle)
 139		end
 140
 141	drag_source_add_text_targets is
 142			-- Add the text targets supported by GtkSelection to the target
 143			-- list of the drag source. The targets are added with info = 0.
 144			-- If you need another value, use drag_source_set_target_list
 145		do
 146			gtk_drag_source_add_text_targets (handle)
 147		end
 148
 149	drag_source_add_image_targets is
 150			-- Add the writable image targets supported by GtkSelection to the
 151			-- target list of the drag source. The targets are added with
 152			-- info = 0. If you need another value, use
 153			-- drag_source_set_target_list
 154		do
 155			gtk_drag_source_add_image_targets (handle)
 156		end
 157
 158	drag_source_add_uri_targets is
 159			-- Add the URI targets supported by GtkSelection to the target list
 160			-- of the drag source. The targets are added with info = 0. If you
 161			-- need another value, use drag_source_set_target_list
 162		do
 163			gtk_drag_source_add_uri_targets (handle)
 164		end
 165
 166	drag_source_set_icon_pixbuf (a_pixbuf: GDK_PIXBUF) is
 167			-- Sets the icon that will be used for drags from a particular
 168			-- widget from a GdkPixbuf. GTK+ retains a reference for pixbuf
 169			-- and will release it when it is no longer needed.
 170		do
 171			gtk_drag_source_set_icon_pixbuf (handle, a_pixbuf.handle)
 172		end
 173
 174	drag_source_set_icon_stock (a_stock_id: STRING) is
 175			-- Sets the icon that will be used for drags from a particular
 176			-- source to a stock icon.
 177		do
 178			gtk_drag_source_set_icon_stock  (handle, a_stock_id.to_external)
 179		end
 180
 181	drag_source_set_icon_name (an_icon_name: STRING) is
 182			-- Sets the icon that will be used for drags from a particular
 183			-- source to a themed icon. See the docs for GtkIconTheme for
 184			-- more details.
 185		do
 186			gtk_drag_source_set_icon_name (handle, an_icon_name.to_external)
 187		end
 188
 189	set_events (some_events: INTEGER) is
 190			-- Sets the event mask (see GDK_EVENT_MASK) for this widget.
 191			-- The event mask determines which events the widget will receive.
 192			-- Keep in mind that different widgets have different default event
 193			-- masks, and by changing the event mask you may disrupt a widget's
 194			-- functionality, so be careful. This function must be called while
 195			-- a widget is unrealized. Consider add_events() for widgets that
 196			-- are already realized, or if you want to preserve the existing
 197			-- event mask. This function can't be used with GTK_NO_WINDOW
 198			-- widgets; to get events on those widgets, place them inside a
 199			-- GTK_EVENT_BOX and receive events on the event box.
 200		require
 201			is_valid_gdk_event_mask (some_events)
 202		do
 203			gtk_widget_set_events (handle, some_events)
 204		end
 205
 206	add_events (some_events: INTEGER) is
 207			-- Adds the events in the bitfield events to the event mask for
 208			-- this widget. See set_events() for details.
 209		require
 210			is_valid_gdk_event_mask (some_events)
 211		do
 212			gtk_widget_add_events (handle, some_events)
 213		end
 214
 215-- #define     GTK_WIDGET_TYPE                 (wid)
 216-- #define     GTK_WIDGET_STATE                (wid)
 217-- #define     GTK_WIDGET_SAVED_STATE          (wid)
 218-- #define     GTK_WIDGET_FLAGS                (wid)
 219-- #define     GTK_WIDGET_TOPLEVEL             (wid)
 220-- #define     GTK_WIDGET_NO_WINDOW            (wid)
 221
 222	is_realized: BOOLEAN is
 223		do
 224			Result := gtk_widget_realized (handle).to_boolean
 225		end
 226
 227	is_mapped: BOOLEAN is
 228		do
 229			Result := gtk_widget_mapped (handle).to_boolean
 230		end
 231
 232	is_visible: BOOLEAN is
 233		do
 234			Result := gtk_widget_visible (handle).to_boolean
 235		end
 236
 237	is_drawable: BOOLEAN is
 238		do
 239			Result := gtk_widget_drawable (handle).to_boolean
 240		end
 241
 242-- #define     GTK_WIDGET_SENSITIVE            (wid)
 243-- #define     GTK_WIDGET_PARENT_SENSITIVE     (wid)
 244-- #define     GTK_WIDGET_CAN_FOCUS            (wid)
 245-- #define     GTK_WIDGET_HAS_FOCUS            (wid)
 246-- #define     GTK_WIDGET_CAN_DEFAULT          (wid)
 247-- #define     GTK_WIDGET_RECEIVES_DEFAULT     (wid)
 248-- #define     GTK_WIDGET_HAS_DEFAULT          (wid)
 249-- #define     GTK_WIDGET_HAS_GRAB             (wid)
 250-- #define     GTK_WIDGET_RC_STYLE             (wid)
 251-- #define     GTK_WIDGET_COMPOSITE_CHILD      (wid)
 252-- #define     GTK_WIDGET_APP_PAINTABLE        (wid)
 253-- #define     GTK_WIDGET_DOUBLE_BUFFERED      (wid)
 254-- #define     GTK_WIDGET_SET_FLAGS            (wid,flag)
 255-- #define     GTK_WIDGET_UNSET_FLAGS          (wid,flag)
 256-- void        (*GtkCallback)                  (GtkWidget *widget,
 257--                                              gpointer data);
 258--             GtkRequisition;
 259-- struct      GtkAllocation;
 260--             GtkSelectionData;
 261--             GtkWidgetAuxInfo;
 262--             GtkWidgetShapeInfo;
 263-- enum        GtkWidgetHelpType;
 264-- GtkWidget*  gtk_widget_new                  (GType type,
 265--                                              const gchar *first_property_name,
 266--                                              ...);
 267-- GtkWidget*  gtk_widget_ref                  (GtkWidget *widget);
 268-- void        gtk_widget_unref                (GtkWidget *widget);
 269-- void        gtk_widget_destroy              (GtkWidget *widget);
 270-- void        gtk_widget_destroyed            (GtkWidget *widget,
 271--                                              GtkWidget **widget_pointer);
 272-- void        gtk_widget_set                  (GtkWidget *widget,
 273--                                              const gchar *first_property_name,
 274--                                              ...);
 275-- void        gtk_widget_unparent             (GtkWidget *widget);
 276-- void        gtk_widget_show_now             (GtkWidget *widget);
 277-- void        gtk_widget_hide_all             (GtkWidget *widget);
 278-- void        gtk_widget_map                  (GtkWidget *widget);
 279-- void        gtk_widget_unmap                (GtkWidget *widget);
 280
 281	realize is
 282			-- Creates the GDK (windowing system) resources associated with a widget. For example,
 283			-- 'window' will be created when a widget is realized. Normally realization happens
 284			-- implicitly; if you show a widget and all its parent containers, then the widget
 285			-- will be realized and mapped automatically.
 286			--
 287			-- Realizing a widget requires all the widget's parent widgets to be realized; calling
 288			-- 'realize' realizes the widget's parents in addition to widget itself. If a widget
 289			-- is not yet inside a toplevel window when you realize it, bad things will happen.
 290			--
 291			-- This function is primarily used in widget implementations, and isn't very useful
 292			-- otherwise. Many times when you think you might need it, a better approach is to
 293			-- connect to a signal that will be called after the widget is realized automatically,
 294			-- such as "expose_event". Or simply g_signal_connect_after() to the "realize" signal.
 295		require
 296			not is_realized
 297		do
 298			gtk_widget_realize (handle)
 299		end
 300
 301	unrealize is
 302			-- This function is only useful in widget implementations. Causes a widget to be
 303			-- unrealized (frees all GDK resources associated with the widget, such as 'window').
 304		require
 305			is_realized
 306		do
 307			gtk_widget_unrealize (handle)
 308		end
 309
 310-- void        gtk_widget_queue_resize         (GtkWidget *widget);
 311-- void        gtk_widget_queue_resize_no_redraw
 312--                                             (GtkWidget *widget);
 313-- void        gtk_widget_draw                 (GtkWidget *widget,
 314--                                              GdkRectangle *area);
 315
 316	actual_size_request: GTK_REQUISITION is
 317		do
 318			create Result.make
 319			gtk_widget_size_request (handle, Result.handle)
 320		ensure
 321			Result /= Void
 322		end
 323
 324-- void        gtk_widget_get_child_requisition
 325--                                             (GtkWidget *widget,
 326--                                              GtkRequisition *requisition);
 327-- void        gtk_widget_size_allocate        (GtkWidget *widget,
 328--                                              GtkAllocation *allocation);
 329-- void        gtk_widget_add_accelerator      (GtkWidget *widget,
 330--                                              const gchar *accel_signal,
 331--                                              GtkAccelGroup *accel_group,
 332--                                              guint accel_key,
 333--                                              GdkModifierType accel_mods,
 334--                                              GtkAccelFlags accel_flags);
 335-- gboolean    gtk_widget_remove_accelerator   (GtkWidget *widget,
 336--                                              GtkAccelGroup *accel_group,
 337--                                              guint accel_key,
 338--                                              GdkModifierType accel_mods);
 339-- void        gtk_widget_set_accel_path       (GtkWidget *widget,
 340--                                              const gchar *accel_path,
 341--                                              GtkAccelGroup *accel_group);
 342-- GList*      gtk_widget_list_accel_closures  (GtkWidget *widget);
 343-- gboolean    gtk_widget_can_activate_accel   (GtkWidget *widget,
 344--                                              guint signal_id);
 345-- gboolean    gtk_widget_event                (GtkWidget *widget,
 346--                                              GdkEvent *event);
 347-- gboolean    gtk_widget_activate             (GtkWidget *widget);
 348-- void        gtk_widget_reparent             (GtkWidget *widget,
 349--                                              GtkWidget *new_parent);
 350-- gboolean    gtk_widget_intersect            (GtkWidget *widget,
 351--                                              GdkRectangle *area,
 352--                                              GdkRectangle *intersection);
 353	-- gboolean    gtk_widget_is_focus             (GtkWidget *widget);
 354	
 355	grab_focus is
 356			-- Causes widget to have the keyboard focus for the GtkWindow
 357			-- it's inside. Current widget must be a focusable widget,
 358			-- such as a GTK_ENTRY; something like GtkFrame won't
 359			-- work. (More precisely, it must have the GTK_CAN_FOCUS flag
 360			-- set.)
 361		require focusable: can_focus
 362		do
 363			gtk_widget_grab_focus (handle)
 364		end
 365	
 366	grab_default is
 367			-- Causes widget to become the default widget. widget must have
 368			-- the GTK_CAN_DEFAULT flag set; typically you have to set this 
 369			-- flag yourself by calling 
 370			-- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT). The default
 371			-- widget is activated when the user presses Enter in a window.
 372			-- Default widgets must be activatable, that is, gtk_widget_activate()
 373			-- should affect them.
 374		require defaultable: can_default
 375		do
 376			gtk_widget_grab_default (handle)
 377		end
 378	
 379	set_name (a_name: STRING) is
 380			-- Widgets can be named, which allows you to refer to them from
 381			-- a gtkrc file. You can apply a style to widgets with a particular
 382			-- name in the gtkrc file. See the documentation for gtkrc files
 383			-- (on the same page as the docs for GtkRcStyle).
 384			--
 385			-- Note that widget names are separated by periods in paths (see
 386			-- `path'), so names with embedded periods may cause confusion.
 387			--
 388			-- a_name : name for the widget
 389		do
 390			gtk_widget_set_name (handle, a_name.to_external)
 391		end
 392
 393	name: STRING is
 394			-- Retrieves the name of a widget. See `set_name' for the
 395			-- significance of widget names.
 396			--
 397			-- Returns : name of the widget.
 398		do
 399			create Result.from_external_copy (gtk_widget_get_name (handle))
 400		end
 401
 402-- void        gtk_widget_set_state            (GtkWidget *widget,
 403--                                              GtkStateType state);
 404-- void        gtk_widget_set_parent           (GtkWidget *widget,
 405--                                              GtkWidget *parent);
 406-- void        gtk_widget_set_parent_window    (GtkWidget *widget,
 407--                                              GdkWindow *parent_window);
 408
 409	window: GDK_WINDOW is
 410			-- Result can be void if window isn't realized yet
 411		local factory: G_OBJECT_EXPANDED_FACTORY [GDK_WINDOW]
 412		do
 413			Result := factory.wrapper_or_void (gtk_widget_get_window (handle))
 414		end
 415
 416	parent_window: GDK_WINDOW is
 417		local factory: G_OBJECT_EXPANDED_FACTORY [GDK_WINDOW]
 418		do
 419			Result := factory.wrapper_or_void (gtk_widget_get_parent_window (handle))
 420		end
 421
 422-- void        gtk_widget_set_uposition        (GtkWidget *widget,
 423--                                              gint x,
 424--                                              gint y);
 425-- void        gtk_widget_set_usize            (GtkWidget *widget,
 426--                                              gint width,
 427--                                              gint height);
 428-- void        gtk_widget_set_events           (GtkWidget *widget,
 429--                                              gint events);
 430-- void        gtk_widget_add_events           (GtkWidget *widget,
 431--                                              gint events);
 432-- void        gtk_widget_set_extension_events (GtkWidget *widget,
 433--                                              GdkExtensionMode mode);
 434-- GdkExtensionMode gtk_widget_get_extension_events
 435--                                             (GtkWidget *widget);
 436-- GtkWidget*  gtk_widget_get_ancestor         (GtkWidget *widget,
 437--                                              GType widget_type);
 438-- GdkColormap* gtk_widget_get_colormap        (GtkWidget *widget);
 439-- void        gtk_widget_set_colormap         (GtkWidget *widget,
 440--                                              GdkColormap *colormap);
 441-- GdkVisual*  gtk_widget_get_visual           (GtkWidget *widget);
 442-- gint        gtk_widget_get_events           (GtkWidget *widget);
 443-- void        gtk_widget_get_pointer          (GtkWidget *widget,
 444--                                              gint *x,
 445--                                              gint *y);
 446-- gboolean    gtk_widget_is_ancestor          (GtkWidget *widget,
 447--                                              GtkWidget *ancestor);
 448-- gboolean    gtk_widget_translate_coordinates
 449--                                             (GtkWidget *src_widget,
 450--                                              GtkWidget *dest_widget,
 451--                                              gint src_x,
 452--                                              gint src_y,
 453--                                              gint *dest_x,
 454--                                              gint *dest_y);
 455-- gboolean    gtk_widget_hide_on_delete       (GtkWidget *widget);
 456-- #define     gtk_widget_set_rc_style         (widget)
 457-- void        gtk_widget_ensure_style         (GtkWidget *widget);
 458-- #define     gtk_widget_restore_default_style(widget)
 459-- void        gtk_widget_reset_rc_styles      (GtkWidget *widget);
 460-- void        gtk_widget_push_colormap        (GdkColormap *cmap);
 461-- void        gtk_widget_pop_colormap         (void);
 462-- void        gtk_widget_set_default_colormap (GdkColormap *colormap);
 463-- GtkStyle*   gtk_widget_get_default_style    (void);
 464-- GdkColormap* gtk_widget_get_default_colormap
 465--                                             (void);
 466-- GdkVisual*  gtk_widget_get_default_visual   (void);
 467-- void        gtk_widget_set_direction        (GtkWidget *widget,
 468--                                              GtkTextDirection dir);
 469-- enum        GtkTextDirection;
 470-- GtkTextDirection gtk_widget_get_direction   (GtkWidget *widget);
 471-- void        gtk_widget_set_default_direction
 472--                                             (GtkTextDirection dir);
 473-- GtkTextDirection gtk_widget_get_default_direction
 474--                                             (void);
 475-- void        gtk_widget_shape_combine_mask   (GtkWidget *widget,
 476--                                              GdkBitmap *shape_mask,
 477--                                              gint offset_x,
 478--                                              gint offset_y);
 479-- void        gtk_widget_path                 (GtkWidget *widget,
 480--                                              guint *path_length,
 481--                                              gchar **path,
 482--                                              gchar **path_reversed);
 483-- void        gtk_widget_class_path           (GtkWidget *widget,
 484--                                              guint *path_length,
 485--                                              gchar **path,
 486--                                              gchar **path_reversed);
 487-- gchar*      gtk_widget_get_composite_name   (GtkWidget *widget);
 488-- void        gtk_widget_modify_style         (GtkWidget *widget,
 489--                                              GtkRcStyle *style);
 490-- GtkRcStyle* gtk_widget_get_modifier_style   (GtkWidget *widget);
 491-- void        gtk_widget_modify_fg            (GtkWidget *widget,
 492--                                              GtkStateType state,
 493--                                              const GdkColor *color);
 494-- void        gtk_widget_modify_bg            (GtkWidget *widget,
 495--                                              GtkStateType state,
 496--                                              const GdkColor *color);
 497-- void        gtk_widget_modify_text          (GtkWidget *widget,
 498--                                              GtkStateType state,
 499--                                              const GdkColor *color);
 500-- void        gtk_widget_modify_base          (GtkWidget *widget,
 501--                                              GtkStateType state,
 502--                                              const GdkColor *color);
 503-- void        gtk_widget_modify_font          (GtkWidget *widget,
 504--                                              PangoFontDescription *font_desc);
 505-- PangoContext* gtk_widget_get_pango_context  (GtkWidget *widget);
 506-- PangoLayout* gtk_widget_create_pango_layout (GtkWidget *widget,
 507--                                              const gchar *text);
 508-- GdkPixbuf*  gtk_widget_render_icon          (GtkWidget *widget,
 509--                                              const gchar *stock_id,
 510--                                              GtkIconSize size,
 511--                                              const gchar *detail);
 512-- void        gtk_widget_pop_composite_child  (void);
 513-- void        gtk_widget_push_composite_child (void);
 514-- void        gtk_widget_queue_clear          (GtkWidget *widget);
 515-- void        gtk_widget_queue_clear_area     (GtkWidget *widget,
 516--                                              gint x,
 517--                                              gint y,
 518--                                              gint width,
 519--                                              gint height);
 520-- void        gtk_widget_queue_draw_area      (GtkWidget *widget,
 521--                                              gint x,
 522--                                              gint y,
 523--                                              gint width,
 524--                                              gint height);
 525-- void        gtk_widget_reset_shapes         (GtkWidget *widget);
 526-- void        gtk_widget_set_app_paintable    (GtkWidget *widget,
 527--                                              gboolean app_paintable);
 528-- void        gtk_widget_set_double_buffered  (GtkWidget *widget,
 529--                                              gboolean double_buffered);
 530-- void        gtk_widget_set_redraw_on_allocate
 531--                                             (GtkWidget *widget,
 532--                                              gboolean redraw_on_allocate);
 533-- void        gtk_widget_set_composite_name   (GtkWidget *widget,
 534--                                              const gchar *name);
 535-- gboolean    gtk_widget_set_scroll_adjustments
 536--                                             (GtkWidget *widget,
 537--                                              GtkAdjustment *hadjustment,
 538--                                              GtkAdjustment *vadjustment);
 539-- gboolean    gtk_widget_mnemonic_activate    (GtkWidget *widget,
 540--                                              gboolean group_cycling);
 541-- void        gtk_widget_class_install_style_property
 542--                                             (GtkWidgetClass *klass,
 543--                                              GParamSpec *pspec);
 544-- void        gtk_widget_class_install_style_property_parser
 545--                                             (GtkWidgetClass *klass,
 546--                                              GParamSpec *pspec,
 547--                                              GtkRcPropertyParser parser);
 548-- GParamSpec* gtk_widget_class_find_style_property
 549--                                             (GtkWidgetClass *klass,
 550--                                              const gchar *property_name);
 551-- GParamSpec** gtk_widget_class_list_style_properties
 552--                                             (GtkWidgetClass *klass,
 553--                                              guint *n_properties);
 554-- GdkRegion*  gtk_widget_region_intersect     (GtkWidget *widget,
 555--                                              GdkRegion *region);
 556-- gint        gtk_widget_send_expose          (GtkWidget *widget,
 557--                                              GdkEvent *event);
 558-- void        gtk_widget_style_get            (GtkWidget *widget,
 559--                                              const gchar *first_property_name,
 560--                                              ...);
 561-- void        gtk_widget_style_get_property   (GtkWidget *widget,
 562--                                              const gchar *property_name,
 563--                                              GValue *value);
 564-- void        gtk_widget_style_get_valist     (GtkWidget *widget,
 565--                                              const gchar *first_property_name,
 566--                                              va_list var_args);
 567-- AtkObject*  gtk_widget_get_accessible       (GtkWidget *widget);
 568-- gboolean    gtk_widget_child_focus          (GtkWidget *widget,
 569--                                              GtkDirectionType direction);
 570-- void        gtk_widget_child_notify         (GtkWidget *widget,
 571--                                              const gchar *child_property);
 572-- void        gtk_widget_freeze_child_notify  (GtkWidget *widget);
 573-- gboolean    gtk_widget_get_child_visible    (GtkWidget *widget);
 574-- GtkWidget*  gtk_widget_get_parent           (GtkWidget *widget);
 575-- GtkSettings* gtk_widget_get_settings        (GtkWidget *widget);
 576-- GtkClipboard* gtk_widget_get_clipboard      (GtkWidget *widget,
 577--                                              GdkAtom selection);
 578-- GdkDisplay* gtk_widget_get_display          (GtkWidget *widget);
 579-- GdkWindow*  gtk_widget_get_root_window      (GtkWidget *widget);
 580-- GdkScreen*  gtk_widget_get_screen           (GtkWidget *widget);
 581-- gboolean    gtk_widget_has_screen           (GtkWidget *widget);
 582
 583-- #define     gtk_widget_pop_visual           ()
 584-- #define     gtk_widget_push_visual          (visual)
 585-- void        gtk_widget_set_child_visible    (GtkWidget *widget,
 586--                                              gboolean is_visible);
 587-- #define     gtk_widget_set_default_visual   (visual)
 588-- #define     gtk_widget_set_visual           (widget,visual)
 589-- void        gtk_widget_thaw_child_notify    (GtkWidget *widget);
 590-- void        gtk_widget_set_no_show_all      (GtkWidget *widget,
 591--                                              gboolean no_show_all);
 592-- gboolean    gtk_widget_get_no_show_all      (GtkWidget *widget);
 593-- GList*      gtk_widget_list_mnemonic_labels (GtkWidget *widget);
 594-- void        gtk_widget_add_mnemonic_label   (GtkWidget *widget,
 595--                                              GtkWidget *label);
 596-- void        gtk_widget_remove_mnemonic_label
 597--                                             (GtkWidget *widget,
 598--                                              GtkWidget *label);
 599
 600-- GtkRequisition* gtk_requisition_copy        (const GtkRequisition *requisition);
 601-- void        gtk_requisition_free            (GtkRequisition *requisition);
 602
 603
 604
 605-- Object Hierarchy
 606
 607--   GObject
 608--    +----GtkObject
 609--          +----GtkWidget
 610--                +----GtkContainer
 611--                +----GtkMisc
 612--                +----GtkCalendar
 613--                +----GtkCellView
 614--                +----GtkDrawingArea
 615--                +----GtkEntry
 616--                +----GtkRuler
 617--                +----GtkRange
 618--                +----GtkSeparator
 619--                +----GtkInvisible
 620--                +----GtkOldEditable
 621--                +----GtkPreview
 622--                +----GtkProgress
 623
 624-- Known Derived Interfaces
 625
 626-- GtkWidget is required by GtkFileChooser and GtkCellEditable.
 627-- Implemented Interfaces
 628
 629-- GtkWidget implements AtkImplementorIface.
 630-- Properties
 631
 632--   "app-paintable"        gboolean              : Read / Write
 633--   "can-default"          gboolean              : Read / Write
 634--   "can-focus"            gboolean              : Read / Write
 635--   "composite-child"      gboolean              : Read
 636--   "events"               GdkEventMask          : Read / Write
 637--   "extension-events"     GdkExtensionMode      : Read / Write
 638--   "has-default"          gboolean              : Read / Write
 639--   "has-focus"            gboolean              : Read / Write
 640--   "height-request"       gint                  : Read / Write
 641--   "is-focus"             gboolean              : Read / Write
 642--   "name"                 gchararray            : Read / Write
 643--   "no-show-all"          gboolean              : Read / Write
 644--   "parent"               GtkContainer          : Read / Write
 645--   "receives-default"     gboolean              : Read / Write
 646--   "sensitive"            gboolean              : Read / Write
 647--   "style"                GtkStyle              : Read / Write
 648--   "visible"              gboolean              : Read / Write
 649--   "width-request"        gint                  : Read / Write
 650
 651-- Style Properties
 652
 653--   "cursor-aspect-ratio"  gfloat                : Read
 654--   "cursor-color"         GdkColor              : Read
 655--   "draw-border"          GtkBorder             : Read
 656--   "focus-line-pattern"   gchararray            : Read
 657--   "focus-line-width"     gint                  : Read
 658--   "focus-padding"        gint                  : Read
 659--   "interior-focus"       gboolean              : Read
 660--   "secondary-cursor-color" GdkColor              : Read
 661
 662feature -- Signals
 663
 664-- "accel-closures-changed"
 665--             void        user_function      (GtkWidget *widget,
 666--                                             gpointer   user_data)      : 
 667-- "can-activate-accel"
 668--             gboolean    user_function      (GtkWidget *widget,
 669--                                             guint      signal_id,
 670--                                             gpointer   user_data)      : Run last
 671-- "child-notify"
 672--             void        user_function      (GtkWidget  *widget,
 673--                                             GParamSpec *pspec,
 674--                                             gpointer    user_data)      : Run first / No recursion / Has details / No hooks
 675-- "client-event"
 676--             gboolean    user_function      (GtkWidget      *widget,
 677--                                             GdkEventClient *event,
 678--                                             gpointer        user_data)      : Run last
 679-- "configure-event"
 680--             gboolean    user_function      (GtkWidget         *widget,
 681--                                             GdkEventConfigure *event,
 682--                                             gpointer           user_data)      : Run last
 683
 684feature -- delete-event signal
 685
 686	delete_event_signal_name: STRING is "delete-event"
 687
 688	enable_on_delete_event is
 689			-- Connects "delete-event" signal to `on_delete_event' feature.
 690		do
 691			connect (Current, delete_event_signal_name, $on_delete_event)
 692		end
 693
 694	on_delete_event: INTEGER is
 695			-- Built-in delete-event signal handler; empty by design; redefine it.
 696
 697			-- The `delete-event' signal is emitted if a user requests that a
 698			-- toplevel window is closed. The default handler for this signal
 699			-- destroys the window.
 700			-- finish with "Result := 1" to stop other handlers.
 701		do
 702		end
 703
 704	connect_agent_to_delete_event_signal (a_function: FUNCTION[ANY, TUPLE [GTK_WIDGET, GDK_EVENT], BOOLEAN]) is
 705		require
 706			valid_function: a_function /= Void
 707			wrapper_is_stored: is_eiffel_wrapper_stored
 708		local
 709			delete_event_callback: DELETE_EVENT_CALLBACK
 710		do
 711			create delete_event_callback.make
 712			delete_event_callback.connect (Current, a_function)
 713		end
 714
 715-- "direction-changed"
 716--             void        user_function      (GtkWidget       *widget,
 717--                                             GtkTextDirection arg1,
 718--                                             gpointer         user_data)      : Run first
 719
 720feature -- drag-begin signal
 721
 722	drag_begin_signal_name: STRING is "drag-begin"
 723		-- "drag-begin"
 724		--             void        user_function      (GtkWidget      *widget,
 725		--                                             GdkDragContext *drag_context,
 726		--                                             gpointer        user_data)         : Run last
 727
 728	enable_on_drag_begin is
 729			-- Connects "drag-begin" signal to `on_drag_begin' feature.
 730		do
 731			connect (Current, drag_begin_signal_name, $on_drag_begin)
 732		end
 733
 734	on_drag_begin: INTEGER is
 735			-- Built-in drag-begin signal handler; empty by design; redefine it.
 736
 737			-- The `drag-begin' signal is emitted on the drag source
 738			-- when a drag is started. A typical reason to connect to this
 739			-- signal is to set up a custom drag icon with
 740			-- gtk_drag_source_set_icon().
 741		do
 742		end
 743
 744	connect_agent_to_drag_begin_signal (a_procedure: PROCEDURE[ANY, TUPLE [GDK_DRAG_CONTEXT, GTK_WIDGET]]) is
 745			-- widget : 	the object which received the signal.
 746			-- drag_context : 	the drag context
 747		require
 748			valid_procedure: a_procedure /= Void
 749			wrapper_is_stored: is_eiffel_wrapper_stored
 750		local
 751			drag_begin_callback: DRAG_BEGIN_CALLBACK
 752		do
 753			create drag_begin_callback.make
 754			drag_begin_callback.connect (Current, a_procedure)
 755		end
 756
 757feature -- drag-data-delete signal
 758
 759	drag_data_delete_signal_name: STRING is "drag-data-delete"
 760		-- "drag-data-delete"
 761		--             void        user_function      (GtkWidget      *widget,
 762		--                                             GdkDragContext *drag_context,
 763		--                                             gpointer        user_data)         : Run last
 764
 765	enable_on_drag_data_delete is
 766			-- Connects "drag-data-delete" signal to `on_drag_data_delete' feature.
 767		do
 768			connect (Current, drag_data_delete_signal_name, $on_drag_data_delete)
 769		end
 770
 771	on_drag_data_delete: INTEGER is
 772			-- Built-in drag-data-delete signal handler; empty by design; redefine it.
 773
 774			-- The `drag-data-delete' signal is emitted on the drag
 775			-- source when a drag with the action GDK_ACTION_MOVE is
 776			-- successfully completed. The signal handler is responsible
 777			-- for deleting the data that has been dropped. What "delete"
 778			-- means, depends on the context of the drag operation
 779		do
 780		end
 781
 782	connect_agent_to_drag_data_delete_signal (a_procedure: PROCEDURE[ANY, TUPLE [GDK_DRAG_CONTEXT, GTK_WIDGET]]) is
 783			-- widget : 	the object which received the signal.
 784			-- drag_context : 	the drag context
 785		require
 786			valid_procedure: a_procedure /= Void
 787			wrapper_is_stored: is_eiffel_wrapper_stored
 788		local
 789			drag_data_delete_callback: DRAG_DATA_DELETE_CALLBACK
 790		do
 791			create drag_data_delete_callback.make
 792			drag_data_delete_callback.connect (Current, a_procedure)
 793		end
 794
 795feature -- drag-data-get signal
 796
 797	drag_data_get_signal_name: STRING is "drag-data-get"
 798		-- "drag-data-get"
 799		--             void        user_function      (GtkWidget        *widget,
 800		--                                             GdkDragContext   *drag_context,
 801		--                                             GtkSelectionData *data,
 802		--                                             guint             info,
 803		--                                             guint             time,
 804		--                                             gpointer          user_data)         : Run last
 805
 806	enable_on_drag_data_get is
 807			-- Connects "drag-data-get" signal to `on_drag_data_get' feature.
 808		do
 809			connect (Current, drag_data_get_signal_name, $on_drag_data_get)
 810		end
 811
 812	on_drag_data_get: INTEGER is
 813			-- Built-in drag-data-get signal handler; empty by design; redefine it.
 814
 815			-- The `drag-data-get' signal is emitted on the drag source
 816			-- when the drop site requests the data which is dragged. It is
 817			-- the responsibility of the signal handler to fill data with
 818			-- the data in the format which is indicated by info. See
 819			-- gtk_selection_data_set() and gtk_selection_data_set_text().
 820		do
 821		end
 822
 823	connect_agent_to_drag_data_get_signal (a_procedure: PROCEDURE[ANY,
 824																					  TUPLE [GDK_DRAG_CONTEXT, GTK_SELECTION_DATA,
 825																								INTEGER, INTEGER, GTK_WIDGET]]) is
 826			-- widget : 	the object which received the signal.
 827			-- drag_context : 	the drag context
 828			-- data : 	the GtkSelectionData to be filled with the dragged data
 829			-- info : 	the info that has been registered with the target in the GtkTargetList.
 830			-- time : 	the timestamp at which the data was requested
 831		require
 832			valid_procedure: a_procedure /= Void
 833			wrapper_is_stored: is_eiffel_wrapper_stored
 834		local
 835			drag_data_get_callback: DRAG_DATA_GET_CALLBACK
 836		do
 837			create drag_data_get_callback.make
 838			drag_data_get_callback.connect (Current, a_procedure)
 839		end
 840
 841feature -- drag-data-received signal
 842
 843	drag_data_received_signal_name: STRING is "drag-data-received"
 844		-- "drag-data-received"
 845		--             void        user_function      (GtkWidget        *widget,
 846		--                                             GdkDragContext   *drag_context,
 847		--                                             gint              x,
 848		--                                             gint              y,
 849		--                                             GtkSelectionData *data,
 850		--                                             guint             info,
 851		--                                             guint             time,
 852		--                                             gpointer          user_data)         : Run last
 853
 854	enable_on_drag_data_received is
 855			-- Connects "drag-data-received" signal to `on_drag_data_received' feature.
 856		do
 857			connect (Current, drag_data_received_signal_name, $on_drag_data_received)
 858		end
 859
 860	on_drag_data_received: INTEGER is
 861			-- Built-in drag-data-received signal handler; empty by design; redefine it.
 862
 863			-- The `drag-data-received' signal is emitted on the drop
 864			-- site when the dragged data has been received. If the data
 865			-- was received in order to determine whether the drop will be
 866			-- accepted, the handler is expected to call gdk_drag_status()
 867			-- and not finish the drag. If the data was received in
 868			-- response to a `drag-drop' signal (and this is the last
 869			-- target to be received), the handler for this signal is
 870			-- expected to process the received data and then call
 871			-- gtk_drag_finish(), setting the success parameter depending
 872			-- on whether the data was processed successfully.
 873
 874			-- The handler may inspect and modify drag_context->action
 875			-- before calling gtk_drag_finish(), e.g. to implement
 876			-- GDK_ACTION_ASK as shown in the following example:
 877			-- (see http://developer.gnome.org/doc/API/2.0/gtk/GtkWidget.html#GtkWidget-drag-data-received)
 878		do
 879		end
 880
 881	connect_agent_to_drag_data_received_signal (a_procedure: PROCEDURE[ANY,
 882																							 TUPLE [GDK_DRAG_CONTEXT, INTEGER, INTEGER,
 883																									  GTK_SELECTION_DATA, INTEGER, INTEGER,
 884																									  GTK_WIDGET]]) is
 885			-- widget : 	the object which received the signal.
 886			-- drag_context : 	the drag context
 887			-- x : 	where the drop happened
 888			-- y : 	where the drop happened
 889			-- data : 	the received data
 890			-- info : 	the info that has been registered with the target in the GtkTargetList.
 891			-- time : 	the timestamp at which the data was received
 892		require
 893			valid_procedure: a_procedure /= Void
 894			wrapper_is_stored: is_eiffel_wrapper_stored
 895		local
 896			drag_data_received_callback: DRAG_DATA_RECEIVED_CALLBACK
 897		do
 898			create drag_data_received_callback.make
 899			drag_data_received_callback.connect (Current, a_procedure)
 900		end
 901
 902feature -- drag-drop signal
 903
 904	drag_drop_signal_name: STRING is "drag-drop"
 905		-- "drag-drop" gboolean    user_function      (GtkWidget      *widget,
 906		--                                             GdkDragContext *drag_context,
 907		--                                             gint            x,
 908		--                                             gint            y,
 909		--                                             guint           time,
 910		--                                             gpointer        user_data)         : Run last
 911
 912	enable_on_drag_drop is
 913			-- Connects "drag-drop" signal to `on_drag_drop' feature.
 914		do
 915			connect (Current, drag_drop_signal_name, $on_drag_drop)
 916		end
 917
 918	on_drag_drop: INTEGER is
 919			-- Built-in drag-drop signal handler; empty by design; redefine it.
 920
 921			-- The `drag-drop signal' is emitted on the drop site when
 922			-- the user drops the data onto the widget. The signal handler
 923			-- must determine whether the cursor position is in a drop zone
 924			-- or not. If it is not in a drop zone, it returns FALSE and no
 925			-- further processing is necessary. Otherwise, the handler
 926			-- returns TRUE. In this case, the handler must ensure that
 927			-- gtk_drag_finish() is called to let the source know that the
 928			-- drop is done. The call to gtk_drag_finish() can be done
 929			-- either directly or in a ::drag-data-received handler which
 930			-- gets triggered by calling gtk_drop_get_data() to receive the
 931			-- data for one or more of the supported targets.
 932		do
 933		end
 934
 935	connect_agent_to_drag_drop_signal (a_function: FUNCTION[ANY, TUPLE [GDK_DRAG_CONTEXT, INTEGER, INTEGER,
 936																							  INTEGER, GTK_WIDGET], BOOLEAN]) is
 937			-- widget : 	the object which received the signal.
 938			-- drag_context : 	the drag context
 939			-- x : 	the x coordinate of the current cursor position
 940			-- y : 	the y coordinate of the current cursor position
 941			-- time : 	the timestamp of the motion event
 942			-- returns : 	whether the cursor position is in a drop zone
 943		require
 944			valid_function: a_function /= Void
 945			wrapper_is_stored: is_eiffel_wrapper_stored
 946		local
 947			drag_drop_callback: DRAG_DROP_CALLBACK
 948		do
 949			create drag_drop_callback.make
 950			drag_drop_callback.connect (Current, a_function)
 951		end
 952
 953feature -- drag-end signal
 954
 955	drag_end_signal_name: STRING is "drag-end"
 956		-- "drag-end"  void        user_function      (GtkWidget      *widget,
 957		--                                             GdkDragContext *drag_context,
 958		--                                             gpointer        user_data)         : Run last
 959
 960	enable_on_drag_end is
 961			-- Connects "drag-end" signal to `on_drag_end' feature.
 962		do
 963			connect (Current, drag_end_signal_name, $on_drag_end)
 964		end
 965
 966	on_drag_end: INTEGER is
 967			-- Built-in drag-end signal handler; empty by design; redefine it.
 968
 969			-- The `drag-end' signal is emitted on the drag source when
 970			-- a drag is finished. A typical reason to connect to this
 971			-- signal is to undo things done in `drag-begin'.
 972		do
 973		end
 974
 975	connect_agent_to_drag_end_signal (a_procedure: PROCEDURE[ANY, TUPLE [GDK_DRAG_CONTEXT, GTK_WIDGET]]) is
 976			-- widget : 	the object which received the signal.
 977			-- drag_context : 	the drag context
 978		require
 979			valid_procedure: a_procedure /= Void
 980			wrapper_is_stored: is_eiffel_wrapper_stored
 981		local
 982			drag_end_callback: DRAG_END_CALLBACK
 983		do
 984			create drag_end_callback.make
 985			drag_end_callback.connect (Current, a_procedure)
 986		end
 987
 988feature -- drag-leave signal
 989
 990	drag_leave_signal_name: STRING is "drag-leave"
 991		-- "drag-leave"
 992		--             void        user_function      (GtkWidget      *widget,
 993		--                                             GdkDragContext *drag_context,
 994		--                                             guint           time,
 995		--                                             gpointer        user_data)         : Run last
 996
 997	enable_on_drag_leave is
 998			-- Connects "drag-leave" signal to `on_drag_leave' feature.
 999		do
1000			connect (Current, drag_leave_signal_name, $on_drag_leave)
1001		end
1002
1003	on_drag_leave: INTEGER is
1004			-- Built-in drag-leave signal handler; empty by design; redefine it.
1005
1006			-- The `drag-leave' signal is emitted on the drop site when
1007			-- the cursor leaves the widget. A typical reason to connect to
1008			-- this signal is to undo things done in `drag-motion', e.g.
1009			-- undo highlighting with gtk_drag_unhighlight()
1010		do
1011		end
1012
1013	connect_agent_to_drag_leave_signal (a_procedure: PROCEDURE[ANY, TUPLE [GDK_DRAG_CONTEXT, INTEGER, GTK_WIDGET]]) is
1014			-- widget : 	the object which received the signal.
1015			-- drag_context : 	the drag context
1016			-- time : 	the timestamp of the motion event
1017		require
1018			valid_procedure: a_procedure /= Void
1019			wrapper_is_stored: is_eiffel_wrapper_stored
1020		local
1021			drag_leave_callback: DRAG_LEAVE_CALLBACK
1022		do
1023			create drag_leave_callback.make
1024			drag_leave_callback.connect (Current, a_procedure)
1025		end
1026
1027feature -- drag-motion signal
1028
1029	drag_motion_signal_name: STRING is "drag-motion"
1030		-- "drag-motion"
1031		--             gboolean    user_function      (GtkWidget      *widget,
1032		--                                             GdkDragContext *drag_context,
1033		--                                             gint            x,
1034		--                                             gint            y,
1035		--                                             guint           time,
1036		--                                             gpointer        user_data)         : Run last
1037
1038	enable_on_drag_motion is
1039			-- Connects "drag-motion" signal to `on_drag_motion' feature.
1040		do
1041			connect (Current, drag_motion_signal_name, $on_drag_motion)
1042		end
1043
1044	on_drag_motion: INTEGER is
1045			-- Built-in drag-motion signal handler; empty by design; redefine it.
1046
1047			-- The `drag-motion' signal is emitted on the drop site when
1048			-- the user moves the cursor over the widget during a drag. The
1049			-- signal handler must determine whether the cursor position is
1050			-- in a drop zone or not. If it is not in a drop zone, it
1051			-- returns FALSE and no further processing is necessary.
1052			-- Otherwise, the handler returns TRUE. In this case, the
1053			-- handler is responsible for providing the necessary
1054			-- information for displaying feedback to the user, by calling
1055			-- gdk_drag_status(). If the decision whether the drop will be
1056			-- accepted or rejected can't be made based solely on the
1057			-- cursor position and the type of the data, the handler may
1058			-- inspect the dragged data by calling gtk_drag_get_data() and
1059			-- defer the gdk_drag_status() call to the `drag-data-received'
1060			-- handler.
1061
1062			-- Note that there is no `drag-enter' signal. The drag
1063			-- receiver has to keep track of whether he has received any
1064			-- `drag-motion' signals since the last `drag-leave' and if
1065			-- not, treat the `drag-motion' signal as an "enter" signal.
1066			-- Upon an "enter", the handler will typically highlight the
1067			-- drop site with gtk_drag_highlight().
1068			-- See an example here: http://developer.gnome.org/doc/API/2.0/gtk/GtkWidget.html#GtkWidget-drag-motion.
1069		do
1070		end
1071
1072	connect_agent_to_drag_motion_signal (a_function: FUNCTION[ANY, TUPLE [GDK_DRAG_CONTEXT, INTEGER, INTEGER,
1073																								 INTEGER, GTK_WIDGET], BOOLEAN]) is
1074			-- widget : 	the object which received the signal.
1075			-- drag_context : 	the drag context
1076			-- x : 	the x coordinate of the current cursor position
1077			-- y : 	the y coordinate of the current cursor position
1078			-- time : 	the timestamp of the motion event
1079			-- returns : 	whether the cursor position is in a drop zone
1080		require
1081			valid_function: a_function /= Void
1082			wrapper_is_stored: is_eiffel_wrapper_stored
1083		local
1084			drag_motion_callback: DRAG_MOTION_CALLBACK
1085		do
1086			create drag_motion_callback.make
1087			drag_motion_callback.connect (Current, a_function)
1088		end
1089
1090feature -- enter-notify-event signal
1091
1092	enter_notify_event_signal_name: STRING is "enter-notify-event"
1093			-- "enter-notify-event"
1094			--  gboolean user_function (GtkWidget        *widget,
1095			--                          GdkEventCrossing *event,
1096			--                          gpointer          user_data)  : Run last
1097
1098	enable_on_enter_notify_event is
1099			-- Connects "enter-notify-event" signal to `on_enter_notify_event' feature.
1100		do
1101			connect (Current, enter_notify_event_signal_name, $on_enter_notify_event)
1102		end
1103
1104	on_enter_notify_event (an_event_crossing: GDK_EVENT_CROSSING; a_widget: GTK_WIDGET): BOOLEAN is
1105			-- Built-in enter-notify-event signal handler; empty by design; redefine it.
1106		do
1107		end
1108
1109	connect_agent_to_enter_notify_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_CROSSING, GTK_WIDGET], BOOLEAN]) is
1110			-- widget : 	the object which received the signal.
1111			-- event : 	
1112			-- user_data : 	user data set when the signal handler was connected.
1113			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1114		require
1115			valid_function: a_function /= Void
1116			wrapper_is_stored: is_eiffel_wrapper_stored
1117		local
1118			enter_notify_event_callback: ENTER_NOTIFY_EVENT_CALLBACK
1119		do
1120			create enter_notify_event_callback.make
1121			enter_notify_event_callback.connect (Current, a_function)
1122		end
1123
1124
1125-- "event"     gboolean    user_function      (GtkWidget *widget,
1126--                                             GdkEvent  *event,
1127--                                             gpointer   user_data)      : Run last
1128-- "event-after"
1129--             void        user_function      (GtkWidget *widget,
1130--                                             GdkEvent  *event,
1131--                                             gpointer   user_data)      : 
1132
1133--             gboolean    user_function      (GtkWidget      *widget,
1134--                                             GdkEventExpose *event,
1135--                                             gpointer        user_data)      : Run last
1136
1137feature -- "expose-event"
1138	connect_agent_to_expose_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_EXPOSE, GTK_WIDGET], BOOLEAN]) is
1139			-- The ::expose-event signal is emitted when an area of a previously
1140			-- obscured GdkWindow is made visible and needs to be redrawn.
1141			-- GTK_NO_WINDOW widgets will get a synthesized event from their
1142			-- parent widget.
1143			--
1144			-- To receive this signal, the GdkWindow associated to the widget
1145			-- needs to enable the GDK_EXPOSURE_MASK mask.
1146		require
1147			valid_function: a_function /= Void
1148			wrapper_is_stored: is_eiffel_wrapper_stored
1149		local
1150			expose_event_callback: EXPOSE_EVENT_CALLBACK
1151		do
1152			create expose_event_callback.make
1153			expose_event_callback.connect (Current, a_function)
1154		end
1155
1156-- "focus"     gboolean    user_function      (GtkWidget       *widget,
1157--                                             GtkDirectionType arg1,
1158--                                             gpointer         user_data)      : Run last
1159-- "focus-in-event"
1160--             gboolean    user_function      (GtkWidget     *widget,
1161--                                             GdkEventFocus *event,
1162--                                             gpointer       user_data)      : Run last
1163feature -- focus-out-event signal
1164
1165	focus_out_event_signal_name: STRING is "focus-out-event"
1166		-- "focus-out-event"
1167		--             gboolean    user_function      (GtkWidget     *widget,
1168		--                                             GdkEventFocus *event,
1169		--                                             gpointer       user_data)      : Run last
1170
1171	enable_on_focus_out_event is
1172			-- Connects "kry-press-event" signal to `on_focus_out_event' feature.
1173		do
1174			connect (Current, focus_out_event_signal_name, $on_focus_out_event)
1175		end
1176
1177	on_focus_out_event: INTEGER is
1178			-- Built-in focus-out-event signal handler; empty by design; redefine it.
1179		do
1180		end
1181
1182	connect_agent_to_focus_out_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_FOCUS, GTK_WIDGET], BOOLEAN]) is
1183			-- The `focus-out-event' signal will be emitted when the keyboard focus
1184			-- leaves the widget's window.
1185
1186			-- To receive this signal, the GdkWindow associated to the widget needs to
1187			-- enable the GDK_FOCUS_CHANGE_MASK mask.
1188
1189			-- widget: the object which received the signal
1190			-- event: the GdkEventFocus which triggered this signal
1191			-- Returns: True to stop other handlers from being invoked for the
1192			--          event. False to propagate the event further.
1193		require
1194			valid_function: a_function /= Void
1195			wrapper_is_stored: is_eiffel_wrapper_stored
1196		local
1197			focus_out_event_callback: FOCUS_OUT_EVENT_CALLBACK
1198		do
1199			create focus_out_event_callback.make
1200			focus_out_event_callback.connect (Current, a_function)
1201		end
1202
1203-- "grab-broken-event"
1204--             gboolean    user_function      (GtkWidget *widget,
1205--                                             GdkEvent  *event,
1206--                                             gpointer   user_data)      : Run last
1207-- "grab-focus"
1208--             void        user_function      (GtkWidget *widget,
1209--                                             gpointer   user_data)      : Run last / Action
1210-- "grab-notify"
1211--             void        user_function      (GtkWidget *widget,
1212--                                             gboolean   arg1,
1213--                                             gpointer   user_data)      : Run first
1214-- "hide"      void        user_function      (GtkWidget *widget,
1215--                                             gpointer   user_data)      : Run first
1216-- "hierarchy-changed"
1217--             void        user_function      (GtkWidget *widget,
1218--                                             GtkWidget *widget2,
1219--                                             gpointer   user_data)      : Run last
1220feature -- key-press-event signal
1221
1222	key_press_event_signal_name: STRING is "key-press-event"
1223		-- "key-press-event" signal
1224		-- gboolean    user_function                  (GtkWidget       *widget,
1225		--											   GdkEventKey     *event,
1226		--											   gpointer        user_data)      : Run last
1227
1228	enable_on_key_press_event is
1229			-- Connects "kry-press-event" signal to `on_key_press_event' feature.
1230		do
1231			connect (Current, key_press_event_signal_name, $on_key_press_event)
1232		end
1233
1234	on_key_press_event: INTEGER is
1235			-- Built-in key-press-event signal handler; empty by design; redefine it.
1236		do
1237		end
1238
1239	connect_agent_to_key_press_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_KEY, GTK_WIDGET], BOOLEAN]) is
1240			-- widget : 	the object which received the signal.
1241			-- event :
1242			-- user_data : 	user data set when the signal handler was connected.
1243			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1244		require
1245			valid_function: a_function /= Void
1246			wrapper_is_stored: is_eiffel_wrapper_stored
1247		local
1248			key_press_event_callback: KEY_PRESS_EVENT_CALLBACK
1249		do
1250			create key_press_event_callback.make
1251			key_press_event_callback.connect (Current, a_function)
1252		end
1253
1254-- "key-release-event"
1255--             gboolean    user_function      (GtkWidget   *widget,
1256--                                             GdkEventKey *event,
1257--                                             gpointer     user_data)      : Run last
1258
1259feature -- leave-notify-event signal
1260
1261	leave_notify_event_signal_name: STRING is "leave-notify-event"
1262			-- "leave-notify-event"
1263			--  gboolean user_function (GtkWidget        *widget,
1264			--                          GdkEventCrossing *event,
1265			--                          gpointer          user_data)  : Run last
1266
1267	enable_on_leave_notify_event is
1268			-- Connects "leave-notify-event" signal to `on_leave_notify_event' feature.
1269		do
1270			connect (Current, leave_notify_event_signal_name, $on_leave_notify_event)
1271		end
1272
1273	on_leave_notify_event (an_event_crossing: GDK_EVENT_CROSSING; a_widget: GTK_WIDGET): BOOLEAN is
1274			-- Built-in leave-notify-event signal handler; empty by design; redefine it.
1275		do
1276		end
1277
1278	connect_agent_to_leave_notify_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_CROSSING, GTK_WIDGET], BOOLEAN]) is
1279			-- widget : 	the object which received the signal.
1280			-- event : 	
1281			-- user_data : 	user data set when the signal handler was connected.
1282			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1283		require
1284			valid_function: a_function /= Void
1285			wrapper_is_stored: is_eiffel_wrapper_stored
1286		local
1287			leave_notify_event_callback: LEAVE_NOTIFY_EVENT_CALLBACK
1288		do
1289			create leave_notify_event_callback.make
1290			leave_notify_event_callback.connect (Current, a_function)
1291		end
1292
1293
1294-- "map"       void        user_function      (GtkWidget *widget,
1295--                                             gpointer   user_data)      : Run first
1296-- "map-event" gboolean    user_function      (GtkWidget *widget,
1297--                                             GdkEvent  *event,
1298--                                             gpointer   user_data)      : Run last
1299-- "mnemonic-activate"
1300--             gboolean    user_function      (GtkWidget *widget,
1301--                                             gboolean   arg1,
1302--                                             gpointer   user_data)      : Run last
1303
1304feature -- motion-notify-event signal
1305
1306	motion_notify_event_signal_name: STRING is "motion-notify-event"
1307		-- "motion-notify-event"
1308		--             gboolean    user_function      (GtkWidget      *widget,
1309		--                                             GdkEventMotion *event,
1310		--                                             gpointer        user_data)      : Run last
1311
1312	enable_on_motion_notify_event is
1313			-- Connects "motion-notify-event" signal to `on_motion_notify_event' feature.
1314		do
1315			connect (Current, motion_notify_event_signal_name, $on_motion_notify_event)
1316		end
1317
1318	on_motion_notify_event (a_event_motion: GDK_EVENT_MOTION; a_widet: GTK_WIDGET): BOOLEAN is
1319			-- Built-in motion-notify-event signal handler; empty by design; redefine it.
1320		do
1321		end
1322
1323	connect_agent_to_motion_notify_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_MOTION, GTK_WIDGET], BOOLEAN]) is
1324			-- widget : 	the object which received the signal.
1325			-- event : 	
1326			-- user_data : 	user data set when the signal handler was connected.
1327			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1328		require
1329			valid_function: a_function /= Void
1330			wrapper_is_stored: is_eiffel_wrapper_stored
1331		local
1332			motion_notify_event_callback: MOTION_NOTIFY_EVENT_CALLBACK
1333		do
1334			create motion_notify_event_callback.make
1335			motion_notify_event_callback.connect (Current, a_function)
1336		end
1337
1338feature -- button-release-event signal
1339
1340	button_release_event_signal_name: STRING is "button-release-event"
1341		-- "button-release-event" signal
1342		-- gboolean    user_function                  (GtkWidget      *widget,
1343		--											   GdkEventButton *event,
1344		--											   gpointer        user_data)      : Run last
1345
1346	enable_on_button_release_event is
1347			-- Connects "button-release-event" signal to `on_button_release_event' feature.
1348		do
1349			connect (Current, button_release_event_signal_name, $on_button_release_event)
1350		end
1351
1352	on_button_release_event (event: GDK_EVENT_BUTTON; a_widget: GTK_WIDGET): BOOLEAN is
1353			-- Built-in button-release-event signal handler; empty by design; redefine it.
1354		do
1355		end
1356
1357	connect_agent_to_button_release_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_BUTTON, GTK_WIDGET], BOOLEAN]) is
1358			-- widget : 	the object which received the signal.
1359			-- event :
1360			-- user_data : 	user data set when the signal handler was connected.
1361			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1362		require
1363			valid_function: a_function /= Void
1364			wrapper_is_stored: is_eiffel_wrapper_stored
1365		local
1366			button_release_event_callback: BUTTON_RELEASE_EVENT_CALLBACK
1367		do
1368			create button_release_event_callback.make
1369			button_release_event_callback.connect (Current, a_function)
1370		end
1371
1372feature -- button-press-event signal
1373
1374	button_press_event_signal_name: STRING is "button-press-event"
1375		-- "button-press-event" signal
1376		-- gboolean    user_function                  (GtkWidget      *widget,
1377		--											   GdkEventButton *event,
1378		--											   gpointer        user_data)      : Run last
1379
1380	enable_on_button_press_event is
1381			-- Connects "button-press-event" signal to `on_button_press_event' feature.
1382		do
1383			connect (Current, button_press_event_signal_name, $on_button_press_event)
1384		end
1385
1386	on_button_press_event (event: GDK_EVENT_BUTTON; a_widget: GTK_WIDGET): BOOLEAN is
1387			-- Built-in button-press-event signal handler; empty by design; redefine it.
1388		do
1389		end
1390
1391	connect_agent_to_button_press_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_BUTTON, GTK_WIDGET], BOOLEAN]) is
1392			-- widget : 	the object which received the signal.
1393			-- event :
1394			-- user_data : 	user data set when the signal handler was connected.
1395			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1396		require
1397			valid_function: a_function /= Void
1398			wrapper_is_stored: is_eiffel_wrapper_stored
1399		local
1400			button_press_event_callback: BUTTON_PRESS_EVENT_CALLBACK
1401		do
1402			create button_press_event_callback.make
1403			button_press_event_callback.connect (Current, a_function)
1404		end
1405
1406-- "no-expose-event"
1407--             gboolean    user_function      (GtkWidget        *widget,
1408--                                             GdkEventNoExpose *event,
1409--                                             gpointer          user_data)      : Run last
1410-- "parent-set"
1411--             void        user_function      (GtkWidget *widget,
1412--                                             GtkObject *old_parent,
1413--                                             gpointer   user_data)       : Run first
1414-- "popup-menu"
1415--             gboolean    user_function      (GtkWidget *widget,
1416--                                             gpointer   user_data)      : Run last / Action
1417-- "property-notify-event"
1418--             gboolean    user_function      (GtkWidget        *widget,
1419--                                             GdkEventProperty *event,
1420--                                             gpointer          user_data)      : Run last
1421-- "proximity-in-event"
1422--             gboolean    user_function      (GtkWidget         *widget,
1423--                                             GdkEventProximity *event,
1424--                                             gpointer           user_data)      : Run last
1425-- "proximity-out-event"
1426--             gboolean    user_function      (GtkWidget         *widget,
1427--                                             GdkEventProximity *event,
1428--                                             gpointer           user_data)      : Run last
1429
1430feature -- realize signal
1431
1432	realize_signal_name: STRING is "realize"
1433-- "realize"   void        user_function      (GtkWidget *widget,
1434--                                             gpointer   user_data)      : Run first
1435
1436	enable_on_realize is
1437			-- Connects "realize" signal to `on_realize' feature.
1438		do
1439			connect (Current, realize_signal_name, $on_realize)
1440		end
1441
1442	on_realize is
1443			-- Built-in realize signal handler; empty by design; redefine it.
1444		do
1445		end
1446
1447	connect_agent_to_realize_signal (a_procedure: PROCEDURE[ANY, TUPLE [GTK_WIDGET]]) is
1448			-- widget : 	the object which received the signal.
1449		require
1450			valid_procedure: a_procedure /= Void
1451			wrapper_is_stored: is_eiffel_wrapper_stored
1452		local
1453			realize_callback: REALIZE_CALLBACK
1454		do
1455			create realize_callback.make
1456			realize_callback.connect (Current, a_procedure)
1457		end
1458
1459-- "screen-changed"
1460--             void        user_function      (GtkWidget *widget,
1461--                                             GdkScreen *arg1,
1462--                                             gpointer   user_data)      : Run last
1463
1464feature -- scroll-event signal
1465
1466	scroll_event_signal_name: STRING is "scroll-event"
1467		--             gboolean    user_function      (GtkWidget      *widget,
1468		--                                             GdkEventScroll *event,
1469		--                                             gpointer        user_data)      : Run last
1470
1471
1472	enable_on_scroll_event is
1473			-- Connects "scroll-event" signal to `on_scroll_event' feature.
1474		do
1475			connect (Current, scroll_event_signal_name, $on_scroll_event)
1476		end
1477
1478	on_scroll_event (event: POINTER; a_widget: POINTER): BOOLEAN is
1479			-- Built-in button-release-event signal handler; empty by design; redefine it.
1480		do
1481		end
1482
1483	connect_agent_to_scroll_event_signal (a_function: FUNCTION[ANY, TUPLE [GDK_EVENT_SCROLL, GTK_WIDGET], BOOLEAN]) is
1484			-- widget : 	the object which received the signal.
1485			-- event :
1486			-- user_data : 	user data set when the signal handler was connected.
1487			-- Returns : 	TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
1488		require
1489			valid_function: a_function /= Void
1490			wrapper_is_stored: is_eiffel_wrapper_stored
1491		local
1492			scroll_event_callback: SCROLL_EVENT_CALLBACK
1493		do
1494			create scroll_event_callback.make
1495			scroll_event_callback.connect (Current, a_function)
1496		end
1497
1498-- "selection-clear-event"
1499--             gboolean    user_function      (GtkWidget         *widget,
1500--                                             GdkEventSelection *event,
1501--                                             gpointer           user_data)      : Run last
1502-- "selection-get"
1503--             void        user_fun