File: gtk-widget.ads

------------------------------------------------------------------------------

--                                                                          --

--      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       --

--                     Copyright (C) 2000-2014, AdaCore                     --

--                                                                          --

-- This library is free software;  you can redistribute it and/or modify it --

-- under terms of the  GNU General Public License  as published by the Free --

-- Software  Foundation;  either version 3,  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 MERCHAN- --

-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            --

--                                                                          --

-- As a special exception under Section 7 of GPL version 3, you are granted --

-- additional permissions described in the GCC Runtime Library Exception,   --

-- version 3.1, as published by the Free Software Foundation.               --

--                                                                          --

-- You should have received a copy of the GNU General Public License and    --

-- a copy of the GCC Runtime Library Exception along with this program;     --

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --

-- <http://www.gnu.org/licenses/>.                                          --

--                                                                          --

------------------------------------------------------------------------------

```
 
```
```
--  <description> 
```

--  GtkWidget is the base class all widgets in GTK+ derive from. It manages

--  the widget lifecycle, states and style.

```
-- 
```

--  == Height-for-width Geometry Management ==

```
-- 
```

--  GTK+ uses a height-for-width (and width-for-height) geometry management

--  system. Height-for-width means that a widget can change how much vertical

--  space it needs, depending on the amount of horizontal space that it is

--  given (and similar for width-for-height). The most common example is a

--  label that reflows to fill up the available width, wraps to fewer lines,

```
--  and therefore needs less height. 
```
```
-- 
```

--  Height-for-width geometry management is implemented in GTK+ by way of five

```
--  virtual methods: 
```
```
-- 
```
```
--  
```
```
-- 
```

--     * Gtk.Widget.GObject_Class.get_request_mode

```
-- 
```

--     * Gtk.Widget.GObject_Class.get_preferred_width

```
-- 
```

--     * Gtk.Widget.GObject_Class.get_preferred_height

```
-- 
```

--     * Gtk.Widget.GObject_Class.get_preferred_height_for_width

```
-- 
```

--     * Gtk.Widget.GObject_Class.get_preferred_width_for_height

```
-- 
```

--  There are some important things to keep in mind when implementing

--  height-for-width and when using it in container implementations.

```
-- 
```

--  The geometry management system will query a widget hierarchy in only one

--  orientation at a time. When widgets are initially queried for their minimum

--  sizes it is generally done in two initial passes in the

--  Gtk.Enums.Gtk_Size_Request_Mode chosen by the toplevel.

```
-- 
```

--  For example, when queried in the normal Gtk.Enums.Height_For_Width mode:

--  First, the default minimum and natural width for each widget in the

--  interface will be computed using Gtk.Widget.Get_Preferred_Width. Because

--  the preferred widths for each container depend on the preferred widths of

--  their children, this information propagates up the hierarchy, and finally a

--  minimum and natural width is determined for the entire toplevel. Next, the

--  toplevel will use the minimum width to query for the minimum height

--  contextual to that width using Gtk.Widget.Get_Preferred_Height_For_Width,

--  which will also be a highly recursive operation. The minimum height for the

--  minimum width is normally used to set the minimum size constraint on the

--  toplevel (unless Gtk.Window.Set_Geometry_Hints is explicitly used instead).

```
-- 
```

--  After the toplevel window has initially requested its size in both

--  dimensions it can go on to allocate itself a reasonable size (or a size

--  previously specified with Gtk.Window.Set_Default_Size). During the

--  recursive allocation process it's important to note that request cycles

--  will be recursively executed while container widgets allocate their

--  children. Each container widget, once allocated a size, will go on to first

--  share the space in one orientation among its children and then request each

--  child's height for its target allocated width or its width for allocated

--  height, depending. In this way a Gtk.Widget.Gtk_Widget will typically be

--  requested its size a number of times before actually being allocated a

--  size. The size a widget is finally allocated can of course differ from the

--  size it has requested. For this reason, Gtk.Widget.Gtk_Widget caches a

--  small number of results to avoid re-querying for the same sizes in one

```
--  allocation cycle. 
```
```
-- 
```

--  See <link linkend="container-geometry-management">GtkContainer's geometry

--  management section</link> to learn more about how height-for-width

--  allocations are performed by container widgets.

```
-- 
```

--  If a widget does move content around to intelligently use up the allocated

--  size then it must support the request in both Gtk_Size_Request_Modes even

--  if the widget in question only trades sizes in a single orientation.

```
-- 
```

--  For instance, a Gtk.Label.Gtk_Label that does height-for-width word

```
--  wrapping will not expect to have 
```

--  Gtk.Widget.GObject_Class.get_preferred_height called because that call is

--  specific to a width-for-height request. In this case the label must return

--  the height required for its own minimum possible width. By following this

--  rule any widget that handles height-for-width or width-for-height requests

--  will always be allocated at least enough space to fit its own content.

```
-- 
```

--  Here are some examples of how a Gtk.Enums.Height_For_Width widget

--  generally deals with width-for-height requests, for

--  Gtk.Widget.GObject_Class.get_preferred_height it will do:

```
-- 
```
```
--    static void 
```

--    foo_widget_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height)

```
--    { 
```

--       if (i_am_in_height_for_width_mode)

```
--       { 
```
```
--          gint min_width; 
```

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL);

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width,

--             min_height, nat_height);

```
--       } 
```
```
--    else 
```
```
--       { 
```

--          ... some widgets do both. For instance, if a GtkLabel is rotated to 90 degrees

--          it will return the minimum and natural height for the rotated label here.

```
--       } 
```
```
--    } 
```
```
-- 
```

--  And in Gtk.Widget.GObject_Class.get_preferred_width_for_height it will

--  simply return the minimum and natural width:

```
-- 
```
```
--    static void 
```

--    foo_widget_get_preferred_width_for_height (GtkWidget *widget, gint for_height,

--       gint *min_width, gint *nat_width)

```
--    { 
```

--       if (i_am_in_height_for_width_mode)

```
--       { 
```

--          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width);

```
--       } 
```
```
--    else 
```
```
--       { 
```

--          ... again if a widget is sometimes operating in width-for-height mode

--            (like a rotated GtkLabel) it can go ahead and do its real width for

```
--          height calculation here. 
```
```
--       } 
```
```
--    } 
```
```
-- 
```

--  Often a widget needs to get its own request during size request or

--  allocation. For example, when computing height it may need to also compute

--  width. Or when deciding how to use an allocation, the widget may need to

--  know its natural size. In these cases, the widget should be careful to call

--  its virtual methods directly, like this:

```
-- 
```
```
--  
```
```
-- 
```

--  == Widget calling its own size request method. ==

```
-- 
```
```
--  
```
```
-- 
```

--    GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget),

```
--    &min, &natural); 
```
```
-- 
```

--  It will not work to use the wrapper functions, such as

--  Gtk.Widget.Get_Preferred_Width inside your own size request implementation.

--  These return a request adjusted by Gtk.Size_Group.Gtk_Size_Group and by the

--  Gtk.Widget.GObject_Class.adjust_size_request virtual method. If a widget

--  used the wrappers inside its virtual method implementations, then the

--  adjustments (such as widget margins) would be applied twice. GTK+ therefore

--  does not allow this and will warn if you try to do it.

```
-- 
```

--  Of course if you are getting the size request for *another* widget, such

--  as a child of a container, you *must* use the wrapper APIs. Otherwise, you

--  would not properly consider widget margins, Gtk.Size_Group.Gtk_Size_Group,

```
--  and so forth. 
```
```
-- 
```
```
--  == Style Properties == 
```
```
-- 
```

--  <structname>GtkWidget</structname> introduces 'style properties' - these

--  are basically object properties that are stored not on the object, but in

--  the style object associated to the widget. Style properties are set in

--  <link linkend="gtk-Resource-Files">resource files</link>. This mechanism is

--  used for configuring such things as the location of the scrollbar arrows

--  through the theme, giving theme authors more control over the look of

--  applications without the need to write a theme engine in C.

--  Use Gtk.Widget.Install_Style_Property to install style properties for a

--  widget class, Gtk.Widget.Find_Style_Property or

--  gtk_widget_class_list_style_properties to get information about existing

--  style properties and Gtk.Widget.Style_Get_Property, gtk_widget_style_get or

--  gtk_widget_style_get_valist to obtain the value of a style property.

```
-- 
```
```
--  == GtkWidget as GtkBuildable == 
```
```
-- 
```

--  The GtkWidget implementation of the GtkBuildable interface supports a

--  custom <accelerator> element, which has attributes named key, modifiers and

--  signal and allows to specify accelerators.

```
-- 
```

--  == A UI definition fragment specifying an accelerator ==

```
-- 
```
```
--    <object class="GtkButton"> 
```

--    <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>

```
--    </object> 
```

--  In addition to accelerators, <structname>GtkWidget</structname> also

--  support a custom <accessible> element, which supports actions and

--  relations. Properties on the accessible implementation of an object can be

--  set by accessing the internal child "accessible" of a

--  <structname>GtkWidget</structname>.

```
-- 
```

--  == A UI definition fragment specifying an accessible ==

```
-- 
```

--    <object class="GtkButton" id="label1"/>

--    <property name="label">I am a Label for a Button</property>

```
--    </object> 
```

--    <object class="GtkButton" id="button1">

```
--    <accessibility> 
```

--    <action action_name="click" translatable="yes">Click the button.</action>

--    <relation target="label1" type="labelled-by"/>

```
--    </accessibility> 
```

--    <child internal-child="accessible">

--    <object class="AtkObject" id="a11y-button1">

--    <property name="accessible-name">Clickable Button</property>

```
--    </object> 
```
```
--    </child> 
```
```
--    </object> 
```

--  Finally, GtkWidget allows style information such as style classes to be

--  associated with widgets, using the custom <style> element:

```
-- 
```

--  == A UI definition fragment specifying an style class ==

```
-- 
```

--    <object class="GtkButton" id="button1">

```
--    <style> 
```

--    <class name="my-special-button-class"/>

```
--    <class name="dark-button"/> 
```
```
--    </style> 
```
```
--    </object> 
```
```
--  </description> 
```
```
pragma Ada_2005; 
```
```
 
```

pragma Warnings (Off, "*is already use-visible*");

with CairoTo API doc
To spec
To body;                   use CairoTo API doc
To spec
To body;

with Cairo.RegionTo API doc
To spec
To body;            use Cairo.RegionTo API doc
To spec
To body;

with GdkTo API doc
To spec;                     use GdkTo API doc
To spec;

with Gdk.ColorTo API doc
To spec
To body;               use Gdk.ColorTo API doc
To spec
To body;

with Gdk.DeviceTo API doc
To spec
To body;              use Gdk.DeviceTo API doc
To spec
To body;

with Gdk.DisplayTo API doc
To spec
To body;             use Gdk.DisplayTo API doc
To spec
To body;

with Gdk.Drag_ContextsTo API doc
To spec
To body;       use Gdk.Drag_ContextsTo API doc
To spec
To body;

with Gdk.EventTo API doc
To spec
To body;               use Gdk.EventTo API doc
To spec
To body;

with Gdk.Frame_ClockTo API doc
To spec
To body;         use Gdk.Frame_ClockTo API doc
To spec
To body;

with Gdk.PixbufTo API doc
To spec
To body;              use Gdk.PixbufTo API doc
To spec
To body;

with Gdk.RGBATo API doc
To spec
To body;                use Gdk.RGBATo API doc
To spec
To body;

with Gdk.RectangleTo API doc
To spec
To body;           use Gdk.RectangleTo API doc
To spec
To body;

with Gdk.ScreenTo API doc
To spec
To body;              use Gdk.ScreenTo API doc
To spec
To body;

with Gdk.TypesTo API doc
To spec;               use Gdk.TypesTo API doc
To spec;

with Gdk.VisualTo API doc
To spec
To body;              use Gdk.VisualTo API doc
To spec
To body;

with GlibTo API doc
To spec
To body;                    use GlibTo API doc
To spec
To body;

with Glib.GSlistTo API doc
To spec
To body;             use Glib.GSlistTo API doc
To spec
To body;

with Glib.Generic_PropertiesTo API doc
To spec
To body; use Glib.Generic_PropertiesTo API doc
To spec
To body;

with Glib.GlistTo API doc
To spec
To body;              use Glib.GlistTo API doc
To spec
To body;

with Glib.ObjectTo API doc
To spec
To body;             use Glib.ObjectTo API doc
To spec
To body;

with Glib.PropertiesTo API doc
To spec
To body;         use Glib.PropertiesTo API doc
To spec
To body;

with Glib.ValuesTo API doc
To spec
To body;             use Glib.ValuesTo API doc
To spec
To body;

with Gtk.Accel_GroupTo API doc
To spec
To body;         use Gtk.Accel_GroupTo API doc
To spec
To body;

with Gtk.EnumsTo API doc
To spec
To body;               use Gtk.EnumsTo API doc
To spec
To body;

with Gtk.Selection_DataTo API doc
To spec
To body;      use Gtk.Selection_DataTo API doc
To spec
To body;

with Gtk.StyleTo API doc
To spec
To body;               use Gtk.StyleTo API doc
To spec
To body;

with Pango.ContextTo API doc
To spec
To body;           use Pango.ContextTo API doc
To spec
To body;

with Pango.FontTo API doc
To spec
To body;              use Pango.FontTo API doc
To spec
To body;

with Pango.LayoutTo API doc
To spec
To body;            use Pango.LayoutTo API doc
To spec
To body;

```
 
```

package Gtk.WidgetTo API doc
To spec
To body is

```
 
```

   type Gtk_Widget_Record is new GObject_RecordTo API doc
To spec
To body with null record;

   type Gtk_Widget is access all Gtk_Widget_RecordTo API doc
To spec'Class;

```
 
```
```
   type Gtk_Align is ( 
```
```
      Align_Fill, 
```
```
      Align_Start, 
```
```
      Align_End, 
```
```
      Align_Center); 
```

   pragma Convention (C, Gtk_AlignTo API doc
To spec);

   --  Controls how a widget deals with extra space in a single (x or y)

```
   --  dimension. 
```
```
   -- 
```

   --  Alignment only matters if the widget receives a "too large" allocation,

   --  for example if you packed the widget with the

   --  Gtk.Widget.Gtk_Widget:expand flag inside a Gtk.Box.Gtk_Box, then the

   --  widget might get extra space. If you have for example a 16x16 icon

   --  inside a 32x32 space, the icon could be scaled and stretched, it could

   --  be centered, or it could be positioned to one side of the space.

```
   -- 
```

   --  Note that in horizontal context Gtk_Align_Start and Gtk_Align_End are

   --  interpreted relative to text direction.

```
 
```
```
   type Gtk_Widget_Help_Type is ( 
```
```
      Widget_Help_Tooltip, 
```
```
      Widget_Help_Whats_This); 
```

   pragma Convention (C, Gtk_Widget_Help_TypeTo API doc
To spec);

```
 
```
```
 
```
```
   type Gtk_Requisition is record 
```
```
      Width : GintTo API doc
To spec; 
```
```
      Height : GintTo API doc
To spec; 
```
```
   end record; 
```

   pragma Convention (C, Gtk_RequisitionTo API doc
To spec);

```
 
```

   function From_Object_FreeTo API doc
To body (B : access Gtk_RequisitionTo API doc
To spec) return Gtk_RequisitionTo API doc
To spec;

   pragma Inline (From_Object_FreeTo API doc
To spec
To body);

   --  A <structname>GtkRequisition</structname> represents the desired size

   --  of a widget. See <xref linkend="geometry-management"/> for more

```
   --  information. 
```
```
 
```

   type Gtk_Widget_Path is new Glib.C_ProxyTo API doc
To spec;

   function From_Object_FreeTo API doc
To body (B : access Gtk_Widget_PathTo API doc
To spec) return Gtk_Widget_PathTo API doc
To spec;

   pragma Inline (From_Object_FreeTo API doc
To spec
To body);

   --  GtkWidgetPath is a boxed type that represents a widget hierarchy from

   --  the topmost widget, typically a toplevel, to any child. This widget path

   --  abstraction is used in Gtk.Style_Context.Gtk_Style_Context on behalf of

   --  the real widget in order to query style information.

```
   -- 
```

   --  If you are using GTK+ widgets, you probably will not need to use this

   --  API directly, as there is Gtk.Widget.Get_Path, and the style context

   --  returned by gtk_widget_get_style_context will be automatically updated

```
   --  on widget hierarchy changes. 
```
```
   -- 
```

   --  The widget path generation is generally simple:

```
   -- 
```

   --  == Defining a button within a window ==

```
   -- 
```
```
   --    { 
```
```
   --       GtkWidgetPath *path; 
```

   --       path = gtk_widget_path_new ();

   --       gtk_widget_path_append_type (path, GTK_TYPE_WINDOW);

   --       gtk_widget_path_append_type (path, GTK_TYPE_BUTTON);

```
   --    } 
```
```
   -- 
```

   --  Although more complex information, such as widget names, or different

   --  classes (property that may be used by other widget types) and

   --  intermediate regions may be included:

```
   -- 
```

   --  == Defining the first tab widget in a notebook ==

```
   -- 
```
```
   --    { 
```
```
   --       GtkWidgetPath *path; 
```
```
   --       guint pos; 
```

   --       path = gtk_widget_path_new ();

   --       pos = gtk_widget_path_append_type (path, GTK_TYPE_NOTEBOOK);

   --       gtk_widget_path_iter_add_region (path, pos, "tab", GTK_REGION_EVEN | GTK_REGION_FIRST);

   --       pos = gtk_widget_path_append_type (path, GTK_TYPE_LABEL);

   --       gtk_widget_path_iter_set_name (path, pos, "first tab label");

```
   --    } 
```
```
   -- 
```

   --  All this information will be used to match the style information that

   --  applies to the described widget.

```
 
```

   function ConvertTo API doc
To body (R : Gtk.Widget.Gtk_WidgetTo API doc
To spec) return System.Address;

   function ConvertTo API doc
To body (R : System.Address) return Gtk.Widget.Gtk_WidgetTo API doc
To spec;

   package Widget_List is new Generic_ListTo API doc
To spec
To body (Gtk.Widget.Gtk_WidgetTo API doc
To spec);

```
 
```

   package Widget_SList is new Generic_SListTo API doc
To spec
To body (Gtk.Widget.Gtk_WidgetTo API doc
To spec);

```
 
```

   subtype Gtk_Allocation is Gdk.Rectangle.Gdk_RectangleTo API doc
To spec;

```
 
```
```
   --------------- 
```
```
   -- Callbacks -- 
```
```
   --------------- 
```
```
 
```

   type Gtk_Tick_Callback is access function

     (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec'Class;

      Frame_Clock : not null access Gdk.Frame_Clock.Gdk_Frame_Clock_RecordTo API doc
To spec'Class)

```
   return Boolean; 
```

   --  Callback type for adding a function to update animations. See

```
   --  Gtk.Widget.Add_Tick_Callback. 
```
```
   --  Since: gtk+ 3.8 
```
```
   --  "widget": the widget 
```

   --  "frame_clock": the frame clock for the widget (same as calling

```
   --  gtk_widget_get_frame_clock) 
```
```
 
```
```
   ---------------------------- 
```
```
   -- Enumeration Properties -- 
```
```
   ---------------------------- 
```
```
 
```
```
   package Gtk_Align_Properties is 
```

      new Generic_Internal_Discrete_PropertyTo API doc
To spec
To body (Gtk_AlignTo API doc
To spec);

   type Property_Gtk_Align is new Gtk_Align_Properties.PropertyTo API doc
To spec;

```
 
```

   package Gtk_Widget_Help_Type_Properties is

      new Generic_Internal_Discrete_PropertyTo API doc
To spec
To body (Gtk_Widget_Help_TypeTo API doc
To spec);

   type Property_Gtk_Widget_Help_Type is new Gtk_Widget_Help_Type_Properties.PropertyTo API doc
To spec;

```
 
```
```
   ------------------ 
```
```
   -- Constructors -- 
```
```
   ------------------ 
```
```
 
```

   function Get_TypeTo API doc
To body return Glib.GTypeTo API doc
To spec;

   pragma Import (C, Get_TypeTo API doc
To spec, "gtk_widget_get_type");

```
 
```
```
   ------------- 
```
```
   -- Methods -- 
```
```
   ------------- 
```
```
 
```
```
   function ActivateTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  For widgets that can be "activated" (buttons, menu items, etc.) this

   --  function activates them. Activation is what happens when you press Enter

   --  on a widget during key navigation. If Widget isn't activatable, the

```
   --  function returns False. 
```
```
 
```

   procedure Add_AcceleratorTo API doc
To body

      (Widget       : not null access Gtk_Widget_RecordTo API doc
To spec;

       Accel_Signal : UTF8_StringTo API doc
To spec;

       Accel_Group  : not null access Gtk.Accel_Group.Gtk_Accel_Group_RecordTo API doc
To spec'Class;

       Accel_Key    : Gdk.Types.Gdk_Key_TypeTo API doc
To spec;

       Accel_Mods   : Gdk.Types.Gdk_Modifier_TypeTo API doc
To spec;

       Accel_Flags  : Gtk.Accel_Group.Gtk_Accel_FlagsTo API doc
To spec);

   --  Installs an accelerator for this Widget in Accel_Group that causes

   --  Accel_Signal to be emitted if the accelerator is activated. The

   --  Accel_Group needs to be added to the widget's toplevel via

   --  Gtk.Window.Add_Accel_Group, and the signal must be of type

   --  G_SIGNAL_ACTION. Accelerators added through this function are not user

   --  changeable during runtime. If you want to support accelerators that can

   --  be changed by the user, use Gtk.Accel_Map.Add_Entry and

   --  Gtk.Widget.Set_Accel_Path or Gtk.Menu_Item.Set_Accel_Path instead.

   --  "accel_signal": widget signal to emit on accelerator activation

   --  "accel_group": accel group for this widget, added to its toplevel

   --  "accel_key": GDK keyval of the accelerator

   --  "accel_mods": modifier key combination of the accelerator

   --  "accel_flags": flag accelerators, e.g. Gtk.Target_List.Accel_Visible

```
 
```

   procedure Add_Device_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class;

       Events : Gdk.Event.Gdk_Event_MaskTo API doc
To spec);

   --  Adds the device events in the bitfield Events to the event mask for

   --  Widget. See Gtk.Widget.Set_Device_Events for details.

```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

   --  "events": an event mask, see Gdk.Event.Gdk_Event_Mask

```
 
```

   procedure Add_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Events : Gdk.Event.Gdk_Event_MaskTo API doc
To spec);

   --  Adds the events in the bitfield Events to the event mask for Widget.

   --  See Gtk.Widget.Set_Events for details.

   --  "events": an event mask, see Gdk.Event.Gdk_Event_Mask

```
 
```

   procedure Add_Mnemonic_LabelTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Label  : not null access Gtk_Widget_RecordTo API doc
To spec'Class);

   --  Adds a widget to the list of mnemonic labels for this widget. (See

   --  Gtk.Widget.List_Mnemonic_Labels). Note the list of mnemonic labels for

   --  the widget is cleared when the widget is destroyed, so the caller must

   --  make sure to update its internal state at this point as well, by using a

   --  connection to the Gtk.Widget.Gtk_Widget::destroy signal or a weak

```
   --  notifier. 
```
```
   --  Since: gtk+ 2.4 
```

   --  "label": a Gtk.Widget.Gtk_Widget that acts as a mnemonic label for

```
   --  Widget 
```
```
 
```

   function Add_Tick_CallbackTo API doc
To body

      (Widget   : not null access Gtk_Widget_RecordTo API doc
To spec;

       Callback : Gtk_Tick_CallbackTo API doc
To spec;

       Notify   : Glib.G_Destroy_Notify_AddressTo API doc
To spec) return GuintTo API doc
To spec;

   --  Queues a animation frame update and adds a callback to be called before

   --  each frame. Until the tick callback is removed, it will be called

   --  frequently (usually at the frame rate of the output device or as quickly

   --  as the application an be repainted, whichever is slower). For this

   --  reason, is most suitable for handling graphics that change every frame

   --  or every few frames. The tick callback does not automatically imply a

   --  relayout or repaint. If you want a repaint or relayout, and aren't

   --  changing widget properties that would trigger that (for example,

   --  changing the text of a Gtk.Label.Gtk_Label), then you will have to call

   --  Gtk.Widget.Queue_Resize or Gtk.Widget.Queue_Draw_Area yourself.

   --  Gdk.Frame_Clock.Get_Frame_Time should generally be used for timing

```
   --  continuous animations and 
```

   --  Gdk.Frame_Timings.Get_Predicted_Presentation_Time if you are trying to

   --  display isolated frames at particular times.

   --  This is a more convenient alternative to connecting directly to the

   --  Gdk.Frame_Clock.Gdk_Frame_Clock::update signal of

   --  Gdk.Frame_Clock.Gdk_Frame_Clock, since you don't have to worry about

   --  when a Gdk.Frame_Clock.Gdk_Frame_Clock is assigned to a widget.

```
   --  Since: gtk+ 3.8 
```

   --  "callback": function to call for updating animations

   --  "notify": function to call to free User_Data when the callback is

```
   --  removed. 
```
```
 
```
```
   generic 
```

      type User_Data_Type (<>) is private;

      with procedure Destroy (Data : in out User_Data_TypeTo API doc
To spec) is null;

   package Add_Tick_Callback_User_DataTo API doc
To body is

```
 
```

      type Gtk_Tick_Callback is access function

        (Widget      : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class;

         Frame_Clock : not null access Gdk.Frame_Clock.Gdk_Frame_Clock_RecordTo API doc
To spec'Class;

         User_Data   : User_Data_TypeTo API doc
To spec) return Boolean;

      --  Callback type for adding a function to update animations. See

      --  Gtk.Widget.Add_Tick_Callback.

```
      --  Since: gtk+ 3.8 
```
```
      --  "widget": the widget 
```

      --  "frame_clock": the frame clock for the widget (same as calling

```
      --  gtk_widget_get_frame_clock) 
```

      --  "user_data": user data passed to Gtk.Widget.Add_Tick_Callback.

```
 
```

      function Add_Tick_CallbackTo API doc
To body

         (Widget    : not null access Gtk.Widget.Gtk_Widget_RecordTo API doc
To spec'Class;

          Callback  : Gtk_Tick_CallbackTo API doc
To spec;

          User_Data : User_Data_TypeTo API doc
To spec;

          Notify    : Glib.G_Destroy_Notify_AddressTo API doc
To spec) return GuintTo API doc
To spec;

      --  Queues a animation frame update and adds a callback to be called

      --  before each frame. Until the tick callback is removed, it will be

      --  called frequently (usually at the frame rate of the output device or

      --  as quickly as the application an be repainted, whichever is slower).

      --  For this reason, is most suitable for handling graphics that change

      --  every frame or every few frames. The tick callback does not

      --  automatically imply a relayout or repaint. If you want a repaint or

      --  relayout, and aren't changing widget properties that would trigger

      --  that (for example, changing the text of a Gtk.Label.Gtk_Label), then

      --  you will have to call Gtk.Widget.Queue_Resize or

      --  Gtk.Widget.Queue_Draw_Area yourself.

      --  Gdk.Frame_Clock.Get_Frame_Time should generally be used for timing

```
      --  continuous animations and 
```

      --  Gdk.Frame_Timings.Get_Predicted_Presentation_Time if you are trying

      --  to display isolated frames at particular times.

      --  This is a more convenient alternative to connecting directly to the

      --  Gdk.Frame_Clock.Gdk_Frame_Clock::update signal of

      --  Gdk.Frame_Clock.Gdk_Frame_Clock, since you don't have to worry about

      --  when a Gdk.Frame_Clock.Gdk_Frame_Clock is assigned to a widget.

```
      --  Since: gtk+ 3.8 
```

      --  "callback": function to call for updating animations

      --  "user_data": data to pass to Callback

      --  "notify": function to call to free User_Data when the callback is

```
      --  removed. 
```
```
 
```

   end Add_Tick_Callback_User_DataTo API doc
To spec
To body;

```
 
```

   function Can_Activate_AccelTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       Signal_Id : GuintTo API doc
To spec) return Boolean;

   --  Determines whether an accelerator that activates the signal identified

   --  by Signal_Id can currently be activated. This is done by emitting the

   --  Gtk.Widget.Gtk_Widget::can-activate-accel signal on Widget; if the

   --  signal isn't overridden by a handler or in a derived widget, then the

   --  default check is that the widget must be sensitive, and the widget and

```
   --  all its ancestors mapped. 
```
```
   --  Since: gtk+ 2.4 
```

   --  "signal_id": the ID of a signal installed on Widget

```
 
```

   function Child_FocusTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       DirectionTo API doc
To body : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec) return Boolean;

   --  This function is used by custom widget implementations; if you're

   --  writing an app, you'd use Gtk.Widget.Grab_Focus to move the focus to a

   --  particular widget, and Gtk.Container.Set_Focus_Chain to change the focus

   --  tab order. So you may want to investigate those functions instead.

   --  Gtk.Widget.Child_Focus is called by containers as the user moves around

   --  the window using keyboard shortcuts. Direction indicates what kind of

   --  motion is taking place (up, down, left, right, tab forward, tab

   --  backward). Gtk.Widget.Child_Focus emits the Gtk.Widget.Gtk_Widget::focus

   --  signal; widgets override the default handler for this signal in order to

   --  implement appropriate focus behavior.

   --  The default ::focus handler for a widget should return True if moving

   --  in Direction left the focus on a focusable location inside that widget,

   --  and False if moving in Direction moved the focus outside the widget. If

   --  returning True, widgets normally call Gtk.Widget.Grab_Focus to place the

   --  focus accordingly; if returning False, they don't modify the current

```
   --  focus location. 
```

   --  "direction": direction of focus movement

```
 
```

   procedure Child_NotifyTo API doc
To body

      (Widget         : not null access Gtk_Widget_RecordTo API doc
To spec;

       Child_Property : UTF8_StringTo API doc
To spec);

   --  Emits a Gtk.Widget.Gtk_Widget::child-notify signal for the <link

   --  linkend="child-properties">child property</link> Child_Property on

```
   --  Widget. 
```

   --  This is the analogue of g_object_notify for child properties.

   --  Also see Gtk.Container.Child_Notify.

   --  "child_property": the name of a child property installed on the class

```
   --  of Widget's parent 
```
```
 
```

   function Compute_ExpandTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       OrientationTo API doc
To body : Gtk.Enums.Gtk_OrientationTo API doc
To spec) return Boolean;

   --  Computes whether a container should give this widget extra space when

   --  possible. Containers should check this, rather than looking at

   --  Gtk.Widget.Get_Hexpand or Gtk.Widget.Get_Vexpand.

   --  This function already checks whether the widget is visible, so

   --  visibility does not need to be checked separately. Non-visible widgets

```
   --  are not expanded. 
```

   --  The computed expand value uses either the expand setting explicitly set

   --  on the widget itself, or, if none has been explicitly set, the widget

   --  may expand if some of its children do.

```
   --  "orientation": expand direction 
```
```
 
```

   function Create_Pango_ContextTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Pango.Context.Pango_ContextTo API doc
To spec;

   --  Creates a new Pango.Context.Pango_Context with the appropriate font

   --  map, font description, and base direction for drawing text for this

   --  widget. See also Gtk.Widget.Get_Pango_Context.

```
 
```

   function Create_Pango_LayoutTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Text   : UTF8_StringTo API doc
To spec := "") return Pango.Layout.Pango_LayoutTo API doc
To spec;

   --  Creates a new Pango.Layout.Pango_Layout with the appropriate font map,

   --  font description, and base direction for drawing text for this widget.

   --  If you keep a Pango.Layout.Pango_Layout created in this way around, you

   --  need to re-create it when the widget Pango.Context.Pango_Context is

   --  replaced. This can be tracked by using the

   --  Gtk.Widget.Gtk_Widget::screen-changed signal on the widget.

   --  "text": text to set on the layout (can be null)

```
 
```

   procedure DestroyTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
   --  Destroys a widget. 
```

   --  When a widget is destroyed, it will break any references it holds to

   --  other objects. If the widget is inside a container, the widget will be

   --  removed from the container. If the widget is a toplevel (derived from

   --  Gtk.Window.Gtk_Window), it will be removed from the list of toplevels,

   --  and the reference GTK+ holds to it will be removed. Removing a widget

   --  from its container or the list of toplevels results in the widget being

   --  finalized, unless you've added additional references to the widget with

```
   --  g_object_ref. 
```

   --  In most cases, only toplevel widgets (windows) require explicit

   --  destruction, because when you destroy a toplevel its children will be

```
   --  destroyed as well. 
```
```
 
```

   procedure DestroyedTo API doc
To body

      (Widget         : not null access Gtk_Widget_RecordTo API doc
To spec;

       Widget_Pointer : in out Gtk_WidgetTo API doc
To spec);

   --  This function sets *Widget_Pointer to null if Widget_Pointer != null.

   --  It's intended to be used as a callback connected to the "destroy" signal

   --  of a widget. You connect Gtk.Widget.Destroyed as a signal handler, and

   --  pass the address of your widget variable as user data. Then when the

   --  widget is destroyed, the variable will be set to null. Useful for

   --  example to avoid multiple copies of the same dialog.

   --  "widget_pointer": address of a variable that contains Widget

```
 
```

   function Device_Is_ShadowedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class)

```
       return Boolean; 
```

   --  Returns True if Device has been shadowed by a GTK+ device grab on

   --  another widget, so it would stop sending events to Widget. This may be

   --  used in the Gtk.Widget.Gtk_Widget::grab-notify signal to check for

   --  specific devices. See Gtk.Main.Device_Grab_Add.

```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

```
 
```

   function Drag_Check_ThresholdTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       Start_X   : GintTo API doc
To spec;

       Start_Y   : GintTo API doc
To spec;

       Current_X : GintTo API doc
To spec;

       Current_Y : GintTo API doc
To spec) return Boolean;

   --  "start_x": X coordinate of start of drag

   --  "start_y": Y coordinate of start of drag

   --  "current_x": current X coordinate

   --  "current_y": current Y coordinate

```
 
```

   procedure Drag_Dest_Add_Image_TargetsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Dest_Add_Text_TargetsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Dest_Add_Uri_TargetsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   function Drag_Dest_Get_Track_MotionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

```
 
```

   procedure Drag_Dest_Set_Track_MotionTo API doc
To body

      (Widget       : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Track_Motion : Boolean); 
```

   --  "track_motion": whether to accept all targets

```
 
```

   procedure Drag_Dest_Set_ProxyTo API doc
To body

      (Widget          : not null access Gtk_Widget_RecordTo API doc
To spec;

       Proxy_Window    : Gdk.Gdk_WindowTo API doc
To spec;

       ProtocolTo API doc
To body        : Gdk.Drag_Contexts.Gdk_Drag_ProtocolTo API doc
To spec;

```
       Use_Coordinates : Boolean); 
```

   --  "proxy_window": the window to which to forward drag events

   --  "protocol": the drag protocol which the Proxy_Window accepts (You can

   --  use gdk_drag_get_protocol to determine this)

   --  "use_coordinates": If True, send the same coordinates to the

   --  destination, because it is an embedded subwindow.

```
 
```

   procedure Drag_Dest_UnsetTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Get_DataTo API doc
To body

      (Widget  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

       Target  : Gdk.Types.Gdk_AtomTo API doc
To spec;

       Time    : Guint32To API doc
To spec);

```
   --  "context": the drag context 
```

   --  "target": the target (form of the data) to retrieve.

   --  "time_": a timestamp for retrieving the data. This will generally be

   --  the time received in a Gtk.Widget.Gtk_Widget::drag-motion" or

   --  Gtk.Widget.Gtk_Widget::drag-drop" signal.

```
 
```

   procedure Drag_HighlightTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Source_Add_Image_TargetsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Source_Add_Uri_TargetsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_Source_Set_Icon_PixbufTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_RecordTo API doc
To spec
To body'Class);

   --  "pixbuf": the Gdk.Pixbuf.Gdk_Pixbuf for the drag icon

```
 
```

   procedure Drag_Source_UnsetTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```

   procedure Drag_UnhighlightTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

```
 
```
```
   procedure DrawTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Cr     : Cairo.Cairo_ContextTo API doc
To spec);

   --  Draws Widget to Cr. The top left corner of the widget will be drawn to

   --  the currently set origin point of Cr.

   --  You should pass a cairo context as Cr argument that is in an original

   --  state. Otherwise the resulting drawing is undefined. For example

   --  changing the operator using cairo_set_operator or the line width using

   --  cairo_set_line_width might have unwanted side effects. You may however

   --  change the context's transform matrix - like with cairo_scale,

   --  cairo_translate or cairo_set_matrix and clip region with cairo_clip

   --  prior to calling this function. Also, it is fine to modify the context

   --  with cairo_save and cairo_push_group prior to calling this function.

```
   --  Note: 
```

   --  Special purpose widgets may contain special code for rendering to the

   --  screen and might appear differently on screen and when rendered using

```
   --  Gtk.Widget.Draw. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "cr": a cairo context to draw to

```
 
```

   procedure Ensure_StyleTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   pragma Obsolescent (Ensure_StyleTo API doc
To spec
To body);

   --  Ensures that Widget has a style (Widget->style).

   --  Not a very useful function; most of the time, if you want the style,

   --  the widget is realized, and realized widgets are guaranteed to have a

```
   --  style already. 
```

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead

```
 
```

   procedure Error_BellTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Notifies the user about an input-related error on this widget. If the

   --  Gtk.Settings.Gtk_Settings:gtk-error-bell setting is True, it calls

   --  Gdk.Window.Beep, otherwise it does nothing.

   --  Note that the effect of Gdk.Window.Beep can be configured in many ways,

   --  depending on the windowing backend and the desktop environment or window

```
   --  manager that is used. 
```
```
   --  Since: gtk+ 2.12 
```
```
 
```
```
   function EventTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Event  : Gdk.Event.Gdk_EventTo API doc
To spec) return Boolean;

   --  Rarely-used function. This function is used to emit the event signals

   --  on a widget (those signals should never be emitted without using this

   --  function to do so). If you want to synthesize an event though, don't use

   --  this function; instead, use Gtk.Main.Main_Do_Event so the event will

   --  behave as if it were in the event queue. Don't synthesize expose events;

   --  instead, use Gdk.Window.Invalidate_Rect to invalidate a region of the

```
   --  window. 
```
```
   --  "event": a Gdk.Event.Gdk_Event 
```
```
 
```

   procedure Freeze_Child_NotifyTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Stops emission of Gtk.Widget.Gtk_Widget::child-notify signals on

   --  Widget. The signals are queued until Gtk.Widget.Thaw_Child_Notify is

```
   --  called on Widget. 
```

   --  This is the analogue of g_object_freeze_notify for child properties.

```
 
```

   function Get_Allocated_HeightTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Returns the height that has currently been allocated to Widget. This

   --  function is intended to be used when implementing handlers for the

   --  Gtk.Widget.Gtk_Widget::draw function.

```
 
```

   function Get_Allocated_WidthTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Returns the width that has currently been allocated to Widget. This

   --  function is intended to be used when implementing handlers for the

   --  Gtk.Widget.Gtk_Widget::draw function.

```
 
```

   procedure Get_AllocationTo API doc
To body

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

       AllocationTo API doc
To body : out Gtk_AllocationTo API doc
To spec);

   --  Retrieves the widget's allocation.

   --  Note, when implementing a Gtk.Container.Gtk_Container: a widget's

   --  allocation will be its "adjusted" allocation, that is, the widget's

   --  parent container typically calls Gtk.Widget.Size_Allocate with an

   --  allocation, and that allocation is then adjusted (to handle margin and

   --  alignment for example) before assignment to the widget.

   --  Gtk.Widget.Get_Allocation returns the adjusted allocation that was

   --  actually assigned to the widget. The adjusted allocation is guaranteed

   --  to be completely contained within the Gtk.Widget.Size_Allocate

   --  allocation, however. So a Gtk.Container.Gtk_Container is guaranteed that

   --  its children stay inside the assigned bounds, but not that they have

   --  exactly the bounds the container assigned. There is no way to get the

   --  original allocation assigned by Gtk.Widget.Size_Allocate, since it isn't

   --  stored; if a container implementation needs that information it will

```
   --  have to track it itself. 
```
```
   --  Since: gtk+ 2.18 
```

   --  "allocation": a pointer to a Gtk_Allocation to copy to

```
 
```

   procedure Set_AllocationTo API doc
To body

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

       AllocationTo API doc
To body : in out Gtk_AllocationTo API doc
To spec);

   --  Sets the widget's allocation. This should not be used directly, but

   --  from within a widget's size_allocate method.

   --  The allocation set should be the "adjusted" or actual allocation. If

   --  you're implementing a Gtk.Container.Gtk_Container, you want to use

   --  Gtk.Widget.Size_Allocate instead of Gtk.Widget.Set_Allocation. The

   --  GtkWidgetClass::adjust_size_allocation virtual method adjusts the

   --  allocation inside Gtk.Widget.Size_Allocate to create an adjusted

```
   --  allocation. 
```
```
   --  Since: gtk+ 2.18 
```

   --  "allocation": a pointer to a Gtk_Allocation to copy from

```
 
```

   function Get_AncestorTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       Widget_Type : GTypeTo API doc
To spec) return Gtk_WidgetTo API doc
To spec;

   --  Gets the first ancestor of Widget with type Widget_Type. For example,

   --  'gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)' gets the first

   --  Gtk.Box.Gtk_Box that's an ancestor of Widget. No reference will be added

   --  to the returned widget; it should not be unreferenced. See note about

   --  checking for a toplevel Gtk.Window.Gtk_Window in the docs for

```
   --  Gtk.Widget.Get_Toplevel. 
```

   --  Note that unlike Gtk.Widget.Is_Ancestor, Gtk.Widget.Get_Ancestor

   --  considers Widget to be an ancestor of itself.

```
   --  "widget_type": ancestor type 
```
```
 
```

   function Get_App_PaintableTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether the application intends to draw on the widget in an

   --  Gtk.Widget.Gtk_Widget::draw handler.

   --  See Gtk.Widget.Set_App_Paintable

```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_App_PaintableTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       App_Paintable : Boolean); 
```

   --  Sets whether the application intends to draw on the widget in an

   --  Gtk.Widget.Gtk_Widget::draw handler.

   --  This is a hint to the widget and does not affect the behavior of the

   --  GTK+ core; many widgets ignore this flag entirely. For widgets that do

   --  pay attention to the flag, such as Gtk.Event_Box.Gtk_Event_Box and

   --  Gtk.Window.Gtk_Window, the effect is to suppress default themed drawing

   --  of the widget's background. (Children of the widget will still be

   --  drawn.) The application is then entirely responsible for drawing the

```
   --  widget background. 
```

   --  Note that the background is still drawn when the widget is mapped.

   --  "app_paintable": True if the application will paint on the widget

```
 
```

   function Get_Can_DefaultTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget can be a default widget. See

```
   --  Gtk.Widget.Set_Can_Default. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_Can_DefaultTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Can_Default : Boolean); 
```

   --  Specifies whether Widget can be a default widget. See

   --  Gtk.Widget.Grab_Default for details about the meaning of "default".

```
   --  Since: gtk+ 2.18 
```

   --  "can_default": whether or not Widget can be a default widget.

```
 
```

   function Get_Can_FocusTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget can own the input focus. See

```
   --  Gtk.Widget.Set_Can_Focus. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_Can_FocusTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Can_Focus : Boolean); 
```

   --  Specifies whether Widget can own the input focus. See

   --  Gtk.Widget.Grab_Focus for actually setting the input focus on a widget.

```
   --  Since: gtk+ 2.18 
```

   --  "can_focus": whether or not Widget can own the input focus.

```
 
```

   procedure Get_Child_RequisitionTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       RequisitionTo API doc
To body : out Gtk_RequisitionTo API doc
To spec);

   pragma Obsolescent (Get_Child_RequisitionTo API doc
To spec
To body);

   --  This function is only for use in widget implementations. Obtains

   --  Widget->requisition, unless someone has forced a particular geometry on

   --  the widget (e.g. with Gtk.Widget.Set_Size_Request), in which case it

   --  returns that geometry instead of the widget's requisition.

   --  This function differs from Gtk.Widget.Size_Request in that it retrieves

   --  the last size request value from Widget->requisition, while

   --  Gtk.Widget.Size_Request actually calls the "size_request" method on

   --  Widget to compute the size request and fill in Widget->requisition, and

   --  only then returns Widget->requisition.

   --  Because this function does not call the "size_request" method, it can

   --  only be used when you know that Widget->requisition is up-to-date, that

   --  is, Gtk.Widget.Size_Request has been called since the last time a resize

   --  was queued. In general, only container implementations have this

   --  information; applications should use Gtk.Widget.Size_Request.

   --  Deprecated since 3.0, Use Gtk.Widget.Get_Preferred_Size instead.

   --  "requisition": a Gtk.Widget.Gtk_Requisition to be filled in

```
 
```

   function Get_Child_VisibleTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Gets the value set with Gtk.Widget.Set_Child_Visible. If you feel a

   --  need to use this function, your code probably needs reorganization.

   --  This function is only useful for container implementations and never

   --  should be called by an application.

```
 
```

   procedure Set_Child_VisibleTo API doc
To body

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Is_Visible : Boolean); 
```

   --  Sets whether Widget should be mapped along with its when its parent is

   --  mapped and Widget has been shown with Gtk.Widget.Show.

   --  The child visibility can be set for widget before it is added to a

   --  container with Gtk.Widget.Set_Parent, to avoid mapping children

   --  unnecessary before immediately unmapping them. However it will be reset

   --  to its default state of True when the widget is removed from a

```
   --  container. 
```

   --  Note that changing the child visibility of a widget does not queue a

   --  resize on the widget. Most of the time, the size of a widget is computed

   --  from all visible children, whether or not they are mapped. If this is

   --  not the case, the container can queue a resize itself.

   --  This function is only useful for container implementations and never

   --  should be called by an application.

   --  "is_visible": if True, Widget should be mapped along with its parent.

```
 
```

   function Get_Composite_NameTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return UTF8_StringTo API doc
To spec;

   --  Obtains the composite name of a widget.

```
 
```

   procedure Set_Composite_NameTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Name   : UTF8_StringTo API doc
To spec);

   --  Sets a widgets composite name. The widget must be a composite child of

   --  its parent; see Gtk.Widget.Push_Composite_Child.

```
   --  "name": the name to set 
```
```
 
```

   function Get_Device_EnabledTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class)

```
       return Boolean; 
```

   --  Returns whether Device can interact with Widget and its children. See

```
   --  Gtk.Widget.Set_Device_Enabled. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

```
 
```

   procedure Set_Device_EnabledTo API doc
To body

      (Widget  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device  : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class;

```
       Enabled : Boolean); 
```

   --  Enables or disables a Gdk.Device.Gdk_Device to interact with Widget and

```
   --  all its children. 
```

   --  It does so by descending through the Gdk.Gdk_Window hierarchy and

   --  enabling the same mask that is has for core events (i.e. the one that

```
   --  Gdk.Window.Get_Events returns). 
```
```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

   --  "enabled": whether to enable the device

```
 
```

   function Get_Device_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class)

       return Gdk.Event.Gdk_Event_MaskTo API doc
To spec;

   --  Returns the events mask for the widget corresponding to an specific

   --  device. These are the events that the widget will receive when Device

```
   --  operates on it. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

```
 
```

   procedure Set_Device_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Device : not null access Gdk.Device.Gdk_Device_RecordTo API doc
To spec'Class;

       Events : Gdk.Event.Gdk_Event_MaskTo API doc
To spec);

   --  Sets the device event mask (see Gdk.Event.Gdk_Event_Mask) for a widget.

   --  The event mask determines which events a widget will receive from

   --  Device. Keep in mind that different widgets have different default event

   --  masks, and by changing the event mask you may disrupt a widget's

   --  functionality, so be careful. This function must be called while a

   --  widget is unrealized. Consider Gtk.Widget.Add_Device_Events for widgets

   --  that are already realized, or if you want to preserve the existing event

   --  mask. This function can't be used with GTK_NO_WINDOW widgets; to get

   --  events on those widgets, place them inside a Gtk.Event_Box.Gtk_Event_Box

   --  and receive events on the event box.

```
   --  Since: gtk+ 3.0 
```

   --  "device": a Gdk.Device.Gdk_Device

```
   --  "events": event mask 
```
```
 
```

   function Get_DirectionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec;

   --  Gets the reading direction for a particular widget. See

```
   --  Gtk.Widget.Set_Direction. 
```
```
 
```

   procedure Set_DirectionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       DirTo API doc
To body    : Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec);

   --  Sets the reading direction on a particular widget. This direction

   --  controls the primary direction for widgets containing text, and also the

   --  direction in which the children of a container are packed. The ability

   --  to set the direction is present in order so that correct localization

   --  into languages with right-to-left reading directions can be done.

   --  Generally, applications will let the default reading direction present,

   --  except for containers where the containers are arranged in an order that

   --  is explicitely visual rather than logical (such as buttons for text

```
   --  justification). 
```

   --  If the direction is set to Gtk.Enums.Text_Dir_None, then the value set

   --  by Gtk.Widget.Set_Default_Direction will be used.

```
   --  "dir": the new direction 
```
```
 
```

   function Get_DisplayTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gdk.Display.Gdk_DisplayTo API doc
To spec;

   --  Get the Gdk.Display.Gdk_Display for the toplevel window associated with

   --  this widget. This function can only be called after the widget has been

   --  added to a widget hierarchy with a Gtk.Window.Gtk_Window at the top.

   --  In general, you should only create display specific resources when a

   --  widget has been realized, and you should free those resources when the

```
   --  widget is unrealized. 
```
```
   --  Since: gtk+ 2.2 
```
```
 
```

   function Get_Double_BufferedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether the widget is double buffered.

   --  See Gtk.Widget.Set_Double_Buffered

```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_Double_BufferedTo API doc
To body

      (Widget          : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Double_Buffered : Boolean); 
```

   --  Widgets are double buffered by default; you can use this function to

   --  turn off the buffering. "Double buffered" simply means that

   --  Gdk.Window.Begin_Paint_Region and Gdk.Window.End_Paint are called

   --  automatically around expose events sent to the widget.

   --  Gdk.Window.Begin_Paint_Region diverts all drawing to a widget's window

   --  to an offscreen buffer, and Gdk.Window.End_Paint draws the buffer to the

   --  screen. The result is that users see the window update in one smooth

   --  step, and don't see individual graphics primitives being rendered.

   --  In very simple terms, double buffered widgets don't flicker, so you

   --  would only use this function to turn off double buffering if you had

   --  special needs and really knew what you were doing.

   --  Note: if you turn off double-buffering, you have to handle expose

   --  events, since even the clearing to the background color or pixmap will

   --  not happen automatically (as it is done in

```
   --  Gdk.Window.Begin_Paint_Region). 
```

   --  "double_buffered": True to double-buffer a widget

```
 
```

   function Get_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gdk.Event.Gdk_Event_MaskTo API doc
To spec;

   --  Returns the event mask for the widget (a bitfield containing flags from

   --  the Gdk.Event.Gdk_Event_Mask enumeration). These are the events that the

```
   --  widget will receive. 
```
```
 
```

   procedure Set_EventsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Events : Gdk.Event.Gdk_Event_MaskTo API doc
To spec);

   --  Sets the event mask (see Gdk.Event.Gdk_Event_Mask) for a widget. The

   --  event mask determines which events a widget will receive. Keep in mind

   --  that different widgets have different default event masks, and by

   --  changing the event mask you may disrupt a widget's functionality, so be

   --  careful. This function must be called while a widget is unrealized.

   --  Consider Gtk.Widget.Add_Events for widgets that are already realized, or

   --  if you want to preserve the existing event mask. This function can't be

   --  used with GTK_NO_WINDOW widgets; to get events on those widgets, place

   --  them inside a Gtk.Event_Box.Gtk_Event_Box and receive events on the

```
   --  event box. 
```
```
   --  "events": event mask 
```
```
 
```

   function Get_Frame_ClockTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gdk.Frame_Clock.Gdk_Frame_ClockTo API doc
To spec;

   --  Obtains the frame clock for a widget. The frame clock is a global

   --  "ticker" that can be used to drive animations and repaints. The most

   --  common reason to get the frame clock is to call

   --  Gdk.Frame_Clock.Get_Frame_Time, in order to get a time to use for

   --  animating. For example you might record the start of the animation with

   --  an initial value from Gdk.Frame_Clock.Get_Frame_Time, and then update

   --  the animation by calling Gdk.Frame_Clock.Get_Frame_Time again during

```
   --  each repaint. 
```

   --  Gdk.Frame_Clock.Request_Phase will result in a new frame on the clock,

   --  but won't necessarily repaint any widgets. To repaint a widget, you have

   --  to use Gtk.Widget.Queue_Draw which invalidates the widget (thus

   --  scheduling it to receive a draw on the next frame).

   --  Gtk.Widget.Queue_Draw will also end up requesting a frame on the

```
   --  appropriate frame clock. 
```

   --  A widget's frame clock will not change while the widget is mapped.

   --  Reparenting a widget (which implies a temporary unmap) can change the

```
   --  widget's frame clock. 
```

   --  Unrealized widgets do not have a frame clock.

```
   --  Since: gtk+ 3.8 
```
```
 
```

   function Get_HalignTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_AlignTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:halign property.

```
 
```

   procedure Set_HalignTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       AlignTo API doc
To body  : Gtk_AlignTo API doc
To spec);

   --  Sets the horizontal alignment of Widget. See the

   --  Gtk.Widget.Gtk_Widget:halign property.

   --  "align": the horizontal alignment

```
 
```

   function Get_Has_TooltipTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns the current value of the has-tooltip property. See

   --  Gtk.Widget.Gtk_Widget:has-tooltip for more information.

```
   --  Since: gtk+ 2.12 
```
```
 
```

   procedure Set_Has_TooltipTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Has_Tooltip : Boolean); 
```

   --  Sets the has-tooltip property on Widget to Has_Tooltip. See

   --  Gtk.Widget.Gtk_Widget:has-tooltip for more information.

```
   --  Since: gtk+ 2.12 
```

   --  "has_tooltip": whether or not Widget has a tooltip.

```
 
```

   function Get_Has_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget has a Gdk.Gdk_Window of its own. See

```
   --  Gtk.Widget.Set_Has_Window. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_Has_WindowTo API doc
To body

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Has_Window : Boolean); 
```

   --  Specifies whether Widget has a Gdk.Gdk_Window of its own. Note that all

   --  realized widgets have a non-null "window" pointer (gtk_widget_get_window

   --  never returns a null window when a widget is realized), but for many of

   --  them it's actually the Gdk.Gdk_Window of one of its parent widgets.

   --  Widgets that do not create a %window for themselves in

   --  Gtk.Widget.Gtk_Widget::realize must announce this by calling this

   --  function with Has_Window = False.

   --  This function should only be called by widget implementations, and they

   --  should call it in their init function.

```
   --  Since: gtk+ 2.18 
```

   --  "has_window": whether or not Widget has a window.

```
 
```

   function Get_HexpandTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Gets whether the widget would like any available extra horizontal

   --  space. When a user resizes a Gtk.Window.Gtk_Window, widgets with

   --  expand=TRUE generally receive the extra space. For example, a list or

   --  scrollable area or document in your window would often be set to expand.

   --  Containers should use Gtk.Widget.Compute_Expand rather than this

   --  function, to see whether a widget, or any of its children, has the

   --  expand flag set. If any child of a widget wants to expand, the parent

```
   --  may ask to expand also. 
```

   --  This function only looks at the widget's own hexpand flag, rather than

   --  computing whether the entire widget tree rooted at this widget wants to

```
   --  expand. 
```
```
 
```

   procedure Set_HexpandTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Expand : Boolean); 
```

   --  Sets whether the widget would like any available extra horizontal

   --  space. When a user resizes a Gtk.Window.Gtk_Window, widgets with

   --  expand=TRUE generally receive the extra space. For example, a list or

   --  scrollable area or document in your window would often be set to expand.

   --  Call this function to set the expand flag if you would like your widget

   --  to become larger horizontally when the window has extra room.

   --  By default, widgets automatically expand if any of their children want

   --  to expand. (To see if a widget will automatically expand given its

   --  current children and state, call Gtk.Widget.Compute_Expand. A container

   --  can decide how the expandability of children affects the expansion of

   --  the container by overriding the compute_expand virtual method on

```
   --  Gtk.Widget.Gtk_Widget.). 
```

   --  Setting hexpand explicitly with this function will override the

```
   --  automatic expand behavior. 
```

   --  This function forces the widget to expand or not to expand, regardless

   --  of children. The override occurs because Gtk.Widget.Set_Hexpand sets the

   --  hexpand-set property (see Gtk.Widget.Set_Hexpand_Set) which causes the

   --  widget's hexpand value to be used, rather than looking at children and

```
   --  widget state. 
```
```
   --  "expand": whether to expand 
```
```
 
```

   function Get_Hexpand_SetTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Gets whether Gtk.Widget.Set_Hexpand has been used to explicitly set the

```
   --  expand flag on this widget. 
```

   --  If hexpand is set, then it overrides any computed expand value based on

   --  child widgets. If hexpand is not set, then the expand value depends on

   --  whether any children of the widget would like to expand.

   --  There are few reasons to use this function, but it's here for

```
   --  completeness and consistency. 
```
```
 
```

   procedure Set_Hexpand_SetTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Set    : Boolean); 
```

   --  Sets whether the hexpand flag (see Gtk.Widget.Get_Hexpand) will be

```
   --  used. 
```

   --  The hexpand-set property will be set automatically when you call

   --  Gtk.Widget.Set_Hexpand to set hexpand, so the most likely reason to use

   --  this function would be to unset an explicit expand flag.

   --  If hexpand is set, then it overrides any computed expand value based on

   --  child widgets. If hexpand is not set, then the expand value depends on

   --  whether any children of the widget would like to expand.

   --  There are few reasons to use this function, but it's here for

```
   --  completeness and consistency. 
```

   --  "set": value for hexpand-set property

```
 
```

   function Get_MappedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

```
   --  Whether the widget is mapped. 
```
```
   --  Since: gtk+ 2.20 
```
```
 
```

   procedure Set_MappedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Mapped : Boolean); 
```

   --  Marks the widget as being realized.

   --  This function should only ever be called in a derived widget's "map" or

```
   --  "unmap" implementation. 
```
```
   --  Since: gtk+ 2.20 
```

   --  "mapped": True to mark the widget as mapped

```
 
```

   function Get_Margin_BottomTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-bottom property.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Set_Margin_BottomTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Margin : GintTo API doc
To spec);

   --  Sets the bottom margin of Widget. See the

   --  Gtk.Widget.Gtk_Widget:margin-bottom property.

```
   --  Since: gtk+ 3.0 
```
```
   --  "margin": the bottom margin 
```
```
 
```

   function Get_Margin_LeftTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-left property.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Set_Margin_LeftTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Margin : GintTo API doc
To spec);

   --  Sets the left margin of Widget. See the

   --  Gtk.Widget.Gtk_Widget:margin-left property.

```
   --  Since: gtk+ 3.0 
```
```
   --  "margin": the left margin 
```
```
 
```

   function Get_Margin_RightTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-right property.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Set_Margin_RightTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Margin : GintTo API doc
To spec);

   --  Sets the right margin of Widget. See the

   --  Gtk.Widget.Gtk_Widget:margin-right property.

```
   --  Since: gtk+ 3.0 
```
```
   --  "margin": the right margin 
```
```
 
```

   function Get_Margin_TopTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GintTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-top property.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Set_Margin_TopTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Margin : GintTo API doc
To spec);

   --  Sets the top margin of Widget. See the Gtk.Widget.Gtk_Widget:margin-top

```
   --  property. 
```
```
   --  Since: gtk+ 3.0 
```
```
   --  "margin": the top margin 
```
```
 
```

   function Get_Modifier_MaskTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       IntentTo API doc
To body : Gdk_Modifier_IntentTo API doc
To spec) return Gdk.Types.Gdk_Modifier_TypeTo API doc
To spec;

   --  Returns the modifier mask the Widget's windowing system backend uses

```
   --  for a particular purpose. 
```

   --  See gdk_keymap_get_modifier_mask.

```
   --  Since: gtk+ 3.4 
```

   --  "intent": the use case for the modifier mask

```
 
```
```
   function Get_NameTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return UTF8_StringTo API doc
To spec;

   --  Retrieves the name of a widget. See Gtk.Widget.Set_Name for the

```
   --  significance of widget names. 
```
```
 
```
```
   procedure Set_NameTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Name   : UTF8_StringTo API doc
To spec);

   --  Widgets can be named, which allows you to refer to them from a CSS

   --  file. You can apply a style to widgets with a particular name in the CSS

   --  file. See the documentation for the CSS syntax (on the same page as the

   --  docs for Gtk.Style_Context.Gtk_Style_Context).

   --  Note that the CSS syntax has certain special characters to delimit and

   --  represent elements in a selector (period, &num;, >, *...), so using

   --  these will make your widget impossible to match by name. Any combination

   --  of alphanumeric symbols, dashes and underscores will suffice.

```
   --  "name": name for the widget 
```
```
 
```

   function Get_No_Show_AllTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns the current value of the Gtk.Widget.Gtk_Widget:no-show-all

   --  property, which determines whether calls to Gtk.Widget.Show_All will

```
   --  affect this widget. 
```
```
   --  Since: gtk+ 2.4 
```
```
 
```

   procedure Set_No_Show_AllTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       No_Show_All : Boolean); 
```

   --  Sets the Gtk.Widget.Gtk_Widget:no-show-all property, which determines

   --  whether calls to Gtk.Widget.Show_All will affect this widget.

   --  This is mostly for use in constructing widget hierarchies with

   --  externally controlled visibility, see Gtk.UI_Manager.Gtk_UI_Manager.

```
   --  Since: gtk+ 2.4 
```

   --  "no_show_all": the new value for the "no-show-all" property

```
 
```

   function Get_OpacityTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return GdoubleTo API doc
To spec;

   --  Fetches the requested opacity for this widget. See

```
   --  Gtk.Widget.Set_Opacity. 
```
```
   --  Since: gtk+ 3.8 
```
```
 
```

   procedure Set_OpacityTo API doc
To body

      (Widget  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Opacity : GdoubleTo API doc
To spec);

   --  Request the Widget to be rendered partially transparent, with opacity 0

   --  being fully transparent and 1 fully opaque. (Opacity values are clamped

   --  to the [0,1] range.). This works on both toplevel widget, and child

   --  widgets, although there are some limitations:

   --  For toplevel widgets this depends on the capabilities of the windowing

   --  system. On X11 this has any effect only on X screens with a compositing

   --  manager running. See Gtk.Widget.Is_Composited. On Windows it should work

   --  always, although setting a window's opacity after the window has been

   --  shown causes it to flicker once on Windows.

   --  For child widgets it doesn't work if any affected widget has a native

   --  window, or disables double buffering.

```
   --  Since: gtk+ 3.8 
```

   --  "opacity": desired opacity, between 0 and 1

```
 
```

   function Get_Pango_ContextTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Pango.Context.Pango_ContextTo API doc
To spec;

   --  Gets a Pango.Context.Pango_Context with the appropriate font map, font

   --  description, and base direction for this widget. Unlike the context

   --  returned by Gtk.Widget.Create_Pango_Context, this context is owned by

   --  the widget (it can be used until the screen for the widget changes or

   --  the widget is removed from its toplevel), and will be updated to match

   --  any changes to the widget's attributes. This can be tracked by using the

   --  Gtk.Widget.Gtk_Widget::screen-changed signal on the widget.

```
 
```

   function Get_ParentTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_WidgetTo API doc
To spec;

   --  Returns the parent container of Widget.

```
 
```

   procedure Set_ParentTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Parent : not null access Gtk_Widget_RecordTo API doc
To spec'Class);

   --  This function is useful only when implementing subclasses of

   --  Gtk.Container.Gtk_Container. Sets the container as the parent of Widget,

   --  and takes care of some details such as updating the state and style of

   --  the child to reflect its new location. The opposite function is

```
   --  Gtk.Widget.Unparent. 
```
```
   --  "parent": parent container 
```
```
 
```

   function Get_Parent_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gdk.Gdk_WindowTo API doc
To spec;

```
   --  Gets Widget's parent window. 
```
```
 
```

   procedure Set_Parent_WindowTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Parent_Window : Gdk.Gdk_WindowTo API doc
To spec);

   --  Sets a non default parent window for Widget.

   --  For GtkWindow classes, setting a Parent_Window effects whether the

   --  window is a toplevel window or can be embedded into other widgets.

```
   --  Note: 
```

   --  For GtkWindow classes, this needs to be called before the window is

```
   --  realized. 
```

   --  "parent_window": the new parent window.

```
 
```
```
   function Get_PathTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_Widget_PathTo API doc
To spec;

   --  Returns the Gtk.Widget.Gtk_Widget_Path representing Widget, if the

   --  widget is not connected to a toplevel widget, a partial path will be

```
   --  created. 
```
```
 
```

   procedure Get_PointerTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       X      : out GintTo API doc
To spec;

       Y      : out GintTo API doc
To spec);

   pragma Obsolescent (Get_PointerTo API doc
To spec
To body);

   --  Obtains the location of the mouse pointer in widget coordinates. Widget

   --  coordinates are a bit odd; for historical reasons, they are defined as

   --  Widget->window coordinates for widgets that are not GTK_NO_WINDOW

   --  widgets, and are relative to Widget->allocation.x, Widget->allocation.y

   --  for widgets that are GTK_NO_WINDOW widgets.

   --  Deprecated since 3.4, Use Gdk.Window.Get_Device_Position instead.

   --  "x": return location for the X coordinate, or null

   --  "y": return location for the Y coordinate, or null

```
 
```

   procedure Get_Preferred_HeightTo API doc
To body

      (Widget         : not null access Gtk_Widget_RecordTo API doc
To spec;

       Minimum_Height : out GintTo API doc
To spec;

       Natural_Height : out GintTo API doc
To spec);

   --  Retrieves a widget's initial minimum and natural height.

```
   --  Note: 
```

   --  This call is specific to width-for-height requests.

   --  The returned request will be modified by the

   --  GtkWidgetClass::adjust_size_request virtual method and by any

   --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is,

   --  the returned request is the one that should be used for layout, not

   --  necessarily the one returned by the widget itself.

```
   --  Since: gtk+ 3.0 
```

   --  "minimum_height": location to store the minimum height, or null

   --  "natural_height": location to store the natural height, or null

```
 
```

   procedure Get_Preferred_Height_For_WidthTo API doc
To body

      (Widget         : not null access Gtk_Widget_RecordTo API doc
To spec;

       Width          : GintTo API doc
To spec;

       Minimum_Height : out GintTo API doc
To spec;

       Natural_Height : out GintTo API doc
To spec);

   --  Retrieves a widget's minimum and natural height if it would be given

```
   --  the specified Width. 
```

   --  The returned request will be modified by the

   --  GtkWidgetClass::adjust_size_request virtual method and by any

   --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is,

   --  the returned request is the one that should be used for layout, not

   --  necessarily the one returned by the widget itself.

```
   --  Since: gtk+ 3.0 
```

   --  "width": the width which is available for allocation

   --  "minimum_height": location for storing the minimum height, or null

   --  "natural_height": location for storing the natural height, or null

```
 
```

   procedure Get_Preferred_SizeTo API doc
To body

      (Widget       : not null access Gtk_Widget_RecordTo API doc
To spec;

       Minimum_SizeTo API doc
To body : out Gtk_RequisitionTo API doc
To spec;

       Natural_SizeTo API doc
To body : out Gtk_RequisitionTo API doc
To spec);

   --  Retrieves the minimum and natural size of a widget, taking into account

   --  the widget's preference for height-for-width management.

   --  This is used to retrieve a suitable size by container widgets which do

   --  not impose any restrictions on the child placement. It can be used to

   --  deduce toplevel window and menu sizes as well as child widgets in

   --  free-form containers such as GtkLayout.

```
   --  Note: 
```

   --  Handle with care. Note that the natural height of a height-for-width

   --  widget will generally be a smaller size than the minimum height, since

   --  the required height for the natural width is generally smaller than the

   --  required height for the minimum width.

```
   --  Since: gtk+ 3.0 
```

   --  "minimum_size": location for storing the minimum size, or null

   --  "natural_size": location for storing the natural size, or null

```
 
```

   procedure Get_Preferred_WidthTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Minimum_Width : out GintTo API doc
To spec;

       Natural_Width : out GintTo API doc
To spec);

   --  Retrieves a widget's initial minimum and natural width.

```
   --  Note: 
```

   --  This call is specific to height-for-width requests.

   --  The returned request will be modified by the

   --  GtkWidgetClass::adjust_size_request virtual method and by any

   --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is,

   --  the returned request is the one that should be used for layout, not

   --  necessarily the one returned by the widget itself.

```
   --  Since: gtk+ 3.0 
```

   --  "minimum_width": location to store the minimum width, or null

   --  "natural_width": location to store the natural width, or null

```
 
```

   procedure Get_Preferred_Width_For_HeightTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Height        : GintTo API doc
To spec;

       Minimum_Width : out GintTo API doc
To spec;

       Natural_Width : out GintTo API doc
To spec);

   --  Retrieves a widget's minimum and natural width if it would be given the

```
   --  specified Height. 
```

   --  The returned request will be modified by the

   --  GtkWidgetClass::adjust_size_request virtual method and by any

   --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is,

   --  the returned request is the one that should be used for layout, not

   --  necessarily the one returned by the widget itself.

```
   --  Since: gtk+ 3.0 
```

   --  "height": the height which is available for allocation

   --  "minimum_width": location for storing the minimum width, or null

   --  "natural_width": location for storing the natural width, or null

```
 
```

   function Get_RealizedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget is realized.

```
   --  Since: gtk+ 2.20 
```
```
 
```

   procedure Set_RealizedTo API doc
To body

      (Widget   : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Realized : Boolean); 
```

   --  Marks the widget as being realized.

   --  This function should only ever be called in a derived widget's

   --  "realize" or "unrealize" implementation.

```
   --  Since: gtk+ 2.20 
```

   --  "realized": True to mark the widget as realized

```
 
```

   function Get_Receives_DefaultTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget is always treated as the default widget

   --  within its toplevel when it has the focus, even if another widget is the

```
   --  default. 
```

   --  See Gtk.Widget.Set_Receives_Default.

```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_Receives_DefaultTo API doc
To body

      (Widget           : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Receives_Default : Boolean); 
```

   --  Specifies whether Widget will be treated as the default widget within

   --  its toplevel when it has the focus, even if another widget is the

```
   --  default. 
```

   --  See Gtk.Widget.Grab_Default for details about the meaning of "default".

```
   --  Since: gtk+ 2.18 
```

   --  "receives_default": whether or not Widget can be a default widget.

```
 
```

   function Get_Request_ModeTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gtk.Enums.Gtk_Size_Request_ModeTo API doc
To spec;

   --  Gets whether the widget prefers a height-for-width layout or a

```
   --  width-for-height layout. 
```
```
   --  Note: 
```

   --  Gtk.Bin.Gtk_Bin widgets generally propagate the preference of their

   --  child, container widgets need to request something either in context of

   --  their children or in context of their allocation capabilities.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Get_RequisitionTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       RequisitionTo API doc
To body : out Gtk_RequisitionTo API doc
To spec);

   pragma Obsolescent (Get_RequisitionTo API doc
To spec
To body);

   --  Retrieves the widget's requisition.

   --  This function should only be used by widget implementations in order to

   --  figure whether the widget's requisition has actually changed after some

   --  internal state change (so that they can call Gtk.Widget.Queue_Resize

   --  instead of Gtk.Widget.Queue_Draw).

   --  Normally, Gtk.Widget.Size_Request should be used.

```
   --  Since: gtk+ 2.20 
```

   --  Deprecated since 3.0, The Gtk.Widget.Gtk_Requisition cache on the

   --  widget was removed, If you need to cache sizes across requests and

   --  allocations, add an explicit cache to the widget in question instead.

   --  "requisition": a pointer to a Gtk.Widget.Gtk_Requisition to copy to

```
 
```

   function Get_Root_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gdk.Gdk_WindowTo API doc
To spec;

   --  Get the root window where this widget is located. This function can

   --  only be called after the widget has been added to a widget hierarchy

   --  with Gtk.Window.Gtk_Window at the top.

   --  The root window is useful for such purposes as creating a popup

   --  Gdk.Gdk_Window associated with the window. In general, you should only

   --  create display specific resources when a widget has been realized, and

   --  you should free those resources when the widget is unrealized.

```
   --  Since: gtk+ 2.2 
```
```
 
```

   function Get_ScreenTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gdk.Screen.Gdk_ScreenTo API doc
To spec;

   --  Get the Gdk.Screen.Gdk_Screen from the toplevel window associated with

   --  this widget. This function can only be called after the widget has been

   --  added to a widget hierarchy with a Gtk.Window.Gtk_Window at the top.

   --  In general, you should only create screen specific resources when a

   --  widget has been realized, and you should free those resources when the

```
   --  widget is unrealized. 
```
```
   --  Since: gtk+ 2.2 
```
```
 
```

   function Get_SensitiveTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns the widget's sensitivity (in the sense of returning the value

   --  that has been set using Gtk.Widget.Set_Sensitive).

   --  The effective sensitivity of a widget is however determined by both its

   --  own and its parent widget's sensitivity. See Gtk.Widget.Is_Sensitive.

```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_SensitiveTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Sensitive : Boolean := True); 
```

   --  Sets the sensitivity of a widget. A widget is sensitive if the user can

   --  interact with it. Insensitive widgets are "grayed out" and the user

   --  can't interact with them. Insensitive widgets are known as "inactive",

   --  "disabled", or "ghosted" in some other toolkits.

   --  "sensitive": True to make the widget sensitive

```
 
```

   procedure Get_Size_RequestTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Width  : out GintTo API doc
To spec;

       Height : out GintTo API doc
To spec);

   --  Gets the size request that was explicitly set for the widget using

   --  Gtk.Widget.Set_Size_Request. A value of -1 stored in Width or Height

   --  indicates that that dimension has not been set explicitly and the

   --  natural requisition of the widget will be used intead. See

   --  Gtk.Widget.Set_Size_Request. To get the size a widget will actually

   --  request, call Gtk.Widget.Get_Preferred_Size instead of this function.

   --  "width": return location for width, or null

   --  "height": return location for height, or null

```
 
```

   procedure Set_Size_RequestTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Width  : GintTo API doc
To spec := -1;

       Height : GintTo API doc
To spec := -1);

   --  Sets the minimum size of a widget; that is, the widget's size request

   --  will be at least Width by Height. You can use this function to force a

   --  widget to be larger than it normally would be.

   --  In most cases, Gtk.Window.Set_Default_Size is a better choice for

   --  toplevel windows than this function; setting the default size will still

   --  allow users to shrink the window. Setting the size request will force

   --  them to leave the window at least as large as the size request. When

   --  dealing with window sizes, Gtk.Window.Set_Geometry_Hints can be a useful

```
   --  function as well. 
```

   --  Note the inherent danger of setting any fixed size - themes,

   --  translations into other languages, different fonts, and user action can

   --  all change the appropriate size for a given widget. So, it's basically

   --  impossible to hardcode a size that will always be correct.

   --  The size request of a widget is the smallest size a widget can accept

   --  while still functioning well and drawing itself correctly. However in

   --  some strange cases a widget may be allocated less than its requested

   --  size, and in many cases a widget may be allocated more space than it

```
   --  requested. 
```

   --  If the size request in a given direction is -1 (unset), then the

   --  "natural" size request of the widget will be used instead.

   --  The size request set here does not include any margin from the

   --  Gtk.Widget.Gtk_Widget properties margin-left, margin-right, margin-top,

   --  and margin-bottom, but it does include pretty much all other padding or

   --  border properties set by any subclass of Gtk.Widget.Gtk_Widget.

   --  "width": width Widget should request, or -1 to unset

   --  "height": height Widget should request, or -1 to unset

```
 
```

   procedure Size_RequestTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       RequisitionTo API doc
To body : out Gtk_RequisitionTo API doc
To spec);

   pragma Obsolescent (Size_RequestTo API doc
To spec
To body);

   --  This function is typically used when implementing a

   --  Gtk.Container.Gtk_Container subclass. Obtains the preferred size of a

   --  widget. The container uses this information to arrange its child widgets

   --  and decide what size allocations to give them with

```
   --  Gtk.Widget.Size_Allocate. 
```

   --  You can also call this function from an application, with some caveats.

   --  Most notably, getting a size request requires the widget to be

   --  associated with a screen, because font information may be needed.

   --  Multihead-aware applications should keep this in mind.

   --  Also remember that the size request is not necessarily the size a

   --  widget will actually be allocated.

   --  Deprecated since 3.0, Use Gtk.Widget.Get_Preferred_Size instead.

   --  "requisition": a Gtk.Widget.Gtk_Requisition to be filled in

```
 
```
```
   function Get_StateTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gtk.Enums.Gtk_State_TypeTo API doc
To spec;

   pragma Obsolescent (Get_StateTo API doc
To spec
To body);

   --  Returns the widget's state. See Gtk.Widget.Set_State.

```
   --  Since: gtk+ 2.18 
```

   --  Deprecated since None, 3.0. Use Gtk.Widget.Get_State_Flags instead.

```
 
```

   procedure Set_StateTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       StateTo API doc
To body  : Gtk.Enums.Gtk_State_TypeTo API doc
To spec);

   pragma Obsolescent (Set_StateTo API doc
To spec
To body);

   --  This function is for use in widget implementations. Sets the state of a

   --  widget (insensitive, prelighted, etc.) Usually you should set the state

   --  using wrapper functions such as Gtk.Widget.Set_Sensitive.

   --  Deprecated since None, 3.0. Use Gtk.Widget.Set_State_Flags instead.

```
   --  "state": new state for Widget 
```
```
 
```

   function Get_State_FlagsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gtk.Enums.Gtk_State_FlagsTo API doc
To spec;

   --  Returns the widget state as a flag set. It is worth mentioning that the

   --  effective Gtk.Enums.Gtk_State_Flag_Insensitive state will be returned,

   --  that is, also based on parent insensitivity, even if Widget itself is

```
   --  sensitive. 
```
```
   --  Since: gtk+ 3.0 
```
```
 
```

   procedure Set_State_FlagsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Flags  : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec;

```
       Clear  : Boolean); 
```

   --  This function is for use in widget implementations. Turns on flag

   --  values in the current widget state (insensitive, prelighted, etc.).

   --  It is worth mentioning that any other state than

   --  Gtk.Enums.Gtk_State_Flag_Insensitive, will be propagated down to all

   --  non-internal children if Widget is a Gtk.Container.Gtk_Container, while

   --  Gtk.Enums.Gtk_State_Flag_Insensitive itself will be propagated down to

   --  all Gtk.Container.Gtk_Container children by different means than turning

   --  on the state flag down the hierarchy, both Gtk.Widget.Get_State_Flags

   --  and Gtk.Widget.Is_Sensitive will make use of these.

```
   --  Since: gtk+ 3.0 
```
```
   --  "flags": State flags to turn on 
```

   --  "clear": Whether to clear state before turning on Flags

```
 
```
```
   function Get_StyleTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gtk.Style.Gtk_StyleTo API doc
To spec;

   pragma Obsolescent (Get_StyleTo API doc
To spec
To body);

   --  Simply an accessor function that returns Widget->style.

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead

```
 
```

   procedure Set_StyleTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Style  : access Gtk.Style.Gtk_Style_RecordTo API doc
To spec'Class);

   pragma Obsolescent (Set_StyleTo API doc
To spec
To body);

   --  Used to set the Gtk.Style.Gtk_Style for a widget (Widget->style). Since

   --  GTK 3, this function does nothing, the passed in style is ignored.

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead

   --  "style": a Gtk.Style.Gtk_Style, or null to remove the effect of a

   --  previous call to Gtk.Widget.Set_Style and go back to the default style

```
 
```

   function Get_Support_MultideviceTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns True if Widget is multiple pointer aware. See

   --  Gtk.Widget.Set_Support_Multidevice for more information.

```
 
```

   procedure Set_Support_MultideviceTo API doc
To body

      (Widget              : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Support_Multidevice : Boolean); 
```

   --  Enables or disables multiple pointer awareness. If this setting is

   --  True, Widget will start receiving multiple, per device enter/leave

   --  events. Note that if custom Gdk.Gdk_Window<!-- -->s are created in

   --  Gtk.Widget.Gtk_Widget::realize, Gdk.Window.Set_Support_Multidevice will

   --  have to be called manually on them.

```
   --  Since: gtk+ 3.0 
```

   --  "support_multidevice": True to support input from multiple devices.

```
 
```

   function Get_Tooltip_MarkupTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return UTF8_StringTo API doc
To spec;

   --  Gets the contents of the tooltip for Widget.

```
   --  Since: gtk+ 2.12 
```
```
 
```

   procedure Set_Tooltip_MarkupTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Markup : UTF8_StringTo API doc
To spec := "");

   --  Sets Markup as the contents of the tooltip, which is marked up with the

   --  <link linkend="PangoMarkupFormat">Pango text markup language</link>.

   --  This function will take care of setting

   --  Gtk.Widget.Gtk_Widget:has-tooltip to True and of the default handler for

   --  the Gtk.Widget.Gtk_Widget::query-tooltip signal.

   --  See also the Gtk.Widget.Gtk_Widget:tooltip-markup property and

```
   --  Gtk.Tooltip.Set_Markup. 
```
```
   --  Since: gtk+ 2.12 
```

   --  "markup": the contents of the tooltip for Widget, or null

```
 
```

   function Get_Tooltip_TextTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return UTF8_StringTo API doc
To spec;

   --  Gets the contents of the tooltip for Widget.

```
   --  Since: gtk+ 2.12 
```
```
 
```

   procedure Set_Tooltip_TextTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Text   : UTF8_StringTo API doc
To spec := "");

   --  Sets Text as the contents of the tooltip. This function will take care

   --  of setting Gtk.Widget.Gtk_Widget:has-tooltip to True and of the default

   --  handler for the Gtk.Widget.Gtk_Widget::query-tooltip signal.

   --  See also the Gtk.Widget.Gtk_Widget:tooltip-text property and

```
   --  Gtk.Tooltip.Set_Text. 
```
```
   --  Since: gtk+ 2.12 
```

   --  "text": the contents of the tooltip for Widget

```
 
```

   function Get_Tooltip_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_WidgetTo API doc
To spec;

   --  Returns the Gtk.Window.Gtk_Window of the current tooltip. This can be

   --  the GtkWindow created by default, or the custom tooltip window set using

```
   --  Gtk.Widget.Set_Tooltip_Window. 
```
```
   --  Since: gtk+ 2.12 
```
```
 
```

   procedure Set_Tooltip_WindowTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Custom_Window : access Gtk_Widget_RecordTo API doc
To spec'Class);

   --  Replaces the default, usually yellow, window used for displaying

   --  tooltips with Custom_Window. GTK+ will take care of showing and hiding

   --  Custom_Window at the right moment, to behave likewise as the default

   --  tooltip window. If Custom_Window is null, the default tooltip window

```
   --  will be used. 
```

   --  If the custom window should have the default theming it needs to have

   --  the name "gtk-tooltip", see Gtk.Widget.Set_Name.

```
   --  Since: gtk+ 2.12 
```

   --  "custom_window": a Gtk.Window.Gtk_Window, or null

```
 
```

   function Get_ToplevelTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_WidgetTo API doc
To spec;

   --  This function returns the topmost widget in the container hierarchy

   --  Widget is a part of. If Widget has no parent widgets, it will be

   --  returned as the topmost widget. No reference will be added to the

   --  returned widget; it should not be unreferenced.

   --  Note the difference in behavior vs. Gtk.Widget.Get_Ancestor;

   --  'gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)' would return null if

   --  Widget wasn't inside a toplevel window, and if the window was inside a

   --  Gtk.Window.Gtk_Window<!-- -->-derived widget which was in turn inside

   --  the toplevel Gtk.Window.Gtk_Window. While the second case may seem

   --  unlikely, it actually happens when a Gtk_Plug is embedded inside a

   --  Gtk_Socket within the same application.

   --  To reliably find the toplevel Gtk.Window.Gtk_Window, use

   --  Gtk.Widget.Get_Toplevel and check if the TOPLEVEL flags is set on the

   --  result. |[ GtkWidget *toplevel = gtk_widget_get_toplevel (widget); if

   --  (gtk_widget_is_toplevel (toplevel)) { /* Perform action on toplevel. */

```
   --  } ]| 
```
```
 
```

   function Get_ValignTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gtk_AlignTo API doc
To spec;

   --  Gets the value of the Gtk.Widget.Gtk_Widget:valign property.

```
 
```

   procedure Set_ValignTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       AlignTo API doc
To body  : Gtk_AlignTo API doc
To spec);

   --  Sets the vertical alignment of Widget. See the

   --  Gtk.Widget.Gtk_Widget:valign property.

```
   --  "align": the vertical alignment 
```
```
 
```

   function Get_VexpandTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Gets whether the widget would like any available extra vertical space.

   --  See Gtk.Widget.Get_Hexpand for more detail.

```
 
```

   procedure Set_VexpandTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Expand : Boolean); 
```

   --  Sets whether the widget would like any available extra vertical space.

   --  See Gtk.Widget.Set_Hexpand for more detail.

```
   --  "expand": whether to expand 
```
```
 
```

   function Get_Vexpand_SetTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Gets whether Gtk.Widget.Set_Vexpand has been used to explicitly set the

```
   --  expand flag on this widget. 
```

   --  See Gtk.Widget.Get_Hexpand_Set for more detail.

```
 
```

   procedure Set_Vexpand_SetTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Set    : Boolean); 
```

   --  Sets whether the vexpand flag (see Gtk.Widget.Get_Vexpand) will be

```
   --  used. 
```

   --  See Gtk.Widget.Set_Hexpand_Set for more detail.

   --  "set": value for vexpand-set property

```
 
```

   function Get_VisibleTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether the widget is visible. If you want to take into

   --  account whether the widget's parent is also marked as visible, use

```
   --  Gtk.Widget.Is_Visible instead. 
```

   --  This function does not check if the widget is obscured in any way.

```
   --  See Gtk.Widget.Set_Visible. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   procedure Set_VisibleTo API doc
To body

      (Widget  : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Visible : Boolean); 
```

   --  Sets the visibility state of Widget. Note that setting this to True

   --  doesn't mean the widget is actually viewable, see

```
   --  Gtk.Widget.Get_Visible. 
```

   --  This function simply calls Gtk.Widget.Show or Gtk.Widget.Hide but is

   --  nicer to use when the visibility of the widget depends on some

```
   --  condition. 
```
```
   --  Since: gtk+ 2.18 
```

   --  "visible": whether the widget should be shown or not

```
 
```

   function Get_VisualTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec)

       return Gdk.Visual.Gdk_VisualTo API doc
To spec;

   --  Gets the visual that will be used to render Widget.

```
 
```

   procedure Set_VisualTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Visual : Gdk.Visual.Gdk_VisualTo API doc
To spec);

   --  Sets the visual that should be used for by widget and its children for

   --  creating Gdk_Windows. The visual must be on the same

   --  Gdk.Screen.Gdk_Screen as returned by Gtk.Widget.Get_Screen, so handling

   --  the Gtk.Widget.Gtk_Widget::screen-changed signal is necessary.

   --  Setting a new Visual will not cause Widget to recreate its windows, so

   --  you should call this function before Widget is realized.

   --  "visual": visual to be used or null to unset a previous one

```
 
```

   function Get_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Gdk.Gdk_WindowTo API doc
To spec;

   --  Returns the widget's window if it is realized, null otherwise

```
   --  Since: gtk+ 2.14 
```
```
 
```

   procedure Set_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Window : Gdk.Gdk_WindowTo API doc
To spec);

   --  Sets a widget's window. This function should only be used in a widget's

   --  Gtk.Widget.Gtk_Widget::realize implementation. The %window passed is

   --  usually either new window created with gdk_window_new, or the window of

   --  its parent widget as returned by Gtk.Widget.Get_Parent_Window.

   --  Widgets must indicate whether they will create their own Gdk.Gdk_Window

   --  by calling Gtk.Widget.Set_Has_Window. This is usually done in the

```
   --  widget's init function. 
```
```
   --  Note: 
```

   --  This function does not add any reference to Window.

```
   --  Since: gtk+ 2.18 
```
```
   --  "window": a Gdk.Gdk_Window 
```
```
 
```

   procedure Grab_AddTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Makes Widget the current grabbed widget.

   --  This means that interaction with other widgets in the same application

   --  is blocked and mouse as well as keyboard events are delivered to this

```
   --  widget. 
```

   --  If Widget is not sensitive, it is not set as the current grabbed widget

```
   --  and this function does nothing. 
```
```
 
```

   procedure Grab_DefaultTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Causes Widget to become the default widget. Widget must be able to be a

   --  default widget; typically you would ensure this yourself by calling

   --  Gtk.Widget.Set_Can_Default with a True value. The default widget is

   --  activated when the user presses Enter in a window. Default widgets must

   --  be activatable, that is, Gtk.Widget.Activate should affect them. Note

   --  that Gtk.GEntry.Gtk_Entry widgets require the "activates-default"

   --  property set to True before they activate the default widget when Enter

   --  is pressed and the Gtk.GEntry.Gtk_Entry is focused.

```
 
```

   procedure Grab_FocusTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Causes Widget to have the keyboard focus for the Gtk.Window.Gtk_Window

   --  it's inside. Widget must be a focusable widget, such as a

   --  Gtk.GEntry.Gtk_Entry; something like Gtk.Frame.Gtk_Frame won't work.

   --  More precisely, it must have the GTK_CAN_FOCUS flag set. Use

   --  Gtk.Widget.Set_Can_Focus to modify that flag.

   --  The widget also needs to be realized and mapped. This is indicated by

   --  the related signals. Grabbing the focus immediately after creating the

   --  widget will likely fail and cause critical warnings.

```
 
```

   procedure Grab_RemoveTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Removes the grab from the given widget.

   --  You have to pair calls to Gtk.Widget.Grab_Add and

```
   --  Gtk.Widget.Grab_Remove. 
```

   --  If Widget does not have the grab, this function does nothing.

```
 
```

   function Has_DefaultTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget is the current default widget within its

   --  toplevel. See Gtk.Widget.Set_Can_Default.

```
   --  Since: gtk+ 2.18 
```
```
 
```
```
   function Has_FocusTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines if the widget has the global input focus. See

   --  Gtk.Widget.Is_Focus for the difference between having the global input

   --  focus, and only having the focus within a toplevel.

```
   --  Since: gtk+ 2.18 
```
```
 
```
```
   function Has_GrabTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether the widget is currently grabbing events, so it is

   --  the only widget receiving input events (keyboard and mouse).

```
   --  See also Gtk.Widget.Grab_Add. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   function Has_Rc_StyleTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   pragma Obsolescent (Has_Rc_StyleTo API doc
To spec
To body);

   --  Determines if the widget style has been looked up through the rc

```
   --  mechanism. 
```
```
   --  Since: gtk+ 2.20 
```

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead

```
 
```

   function Has_ScreenTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Checks whether there is a Gdk.Screen.Gdk_Screen is associated with this

   --  widget. All toplevel widgets have an associated screen, and all widgets

   --  added into a hierarchy with a toplevel window at the top.

```
   --  Since: gtk+ 2.2 
```
```
 
```

   function Has_Visible_FocusTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines if the widget should show a visible indication that it has

   --  the global input focus. This is a convenience function for use in ::draw

   --  handlers that takes into account whether focus indication should

   --  currently be shown in the toplevel window of Widget. See

   --  Gtk.Window.Get_Focus_Visible for more information about focus

```
   --  indication. 
```

   --  To find out if the widget has the global input focus, use

```
   --  Gtk.Widget.Has_Focus. 
```
```
   --  Since: gtk+ 3.2 
```
```
 
```

   procedure HideTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Reverses the effects of Gtk.Widget.Show, causing the widget to be

```
   --  hidden (invisible to the user). 
```
```
 
```

   function Hide_On_DeleteTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Utility function; intended to be connected to the

   --  Gtk.Widget.Gtk_Widget::delete-event signal on a Gtk.Window.Gtk_Window.

   --  The function calls Gtk.Widget.Hide on its argument, then returns True.

   --  If connected to ::delete-event, the result is that clicking the close

   --  button for a window (on the window frame, top right corner usually) will

   --  hide but not destroy the window. By default, GTK+ destroys windows when

```
   --  ::delete-event is received. 
```
```
 
```

   function In_DestructionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns whether the widget is currently being destroyed. This

   --  information can sometimes be used to avoid doing unnecessary work.

```
 
```

   procedure Input_Shape_Combine_RegionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Region : Cairo.Region.Cairo_RegionTo API doc
To spec);

   --  Sets an input shape for this widget's GDK window. This allows for

   --  windows which react to mouse click in a nonrectangular region, see

   --  Gdk.Window.Input_Shape_Combine_Region for more information.

```
   --  Since: gtk+ 3.0 
```

   --  "region": shape to be added, or null to remove an existing shape

```
 
```
```
   function IntersectTo API doc
To body 
```

      (Widget       : not null access Gtk_Widget_RecordTo API doc
To spec;

       AreaTo API doc
To body         : Gdk.Rectangle.Gdk_RectangleTo API doc
To spec;

       Intersection : access Gdk.Rectangle.Gdk_RectangleTo API doc
To spec) return Boolean;

   --  Computes the intersection of a Widget's area and Area, storing the

   --  intersection in Intersection, and returns True if there was an

   --  intersection. Intersection may be null if you're only interested in

   --  whether there was an intersection.

```
   --  "area": a rectangle 
```

   --  "intersection": rectangle to store intersection of Widget and Area

```
 
```

   function Is_AncestorTo API doc
To body

      (Widget   : not null access Gtk_Widget_RecordTo API doc
To spec;

       Ancestor : not null access Gtk_Widget_RecordTo API doc
To spec'Class) return Boolean;

   --  Determines whether Widget is somewhere inside Ancestor, possibly with

```
   --  intermediate containers. 
```

   --  "ancestor": another Gtk.Widget.Gtk_Widget

```
 
```

   function Is_CompositedTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Whether Widget can rely on having its alpha channel drawn correctly. On

   --  X11 this function returns whether a compositing manager is running for

```
   --  Widget's screen. 
```

   --  Please note that the semantics of this call will change in the future

   --  if used on a widget that has a composited window in its hierarchy (as

   --  set by Gdk.Window.Set_Composited).

```
   --  Since: gtk+ 2.10 
```
```
 
```

   function Is_DrawableTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget can be drawn to. A widget can be drawn to if

```
   --  it is mapped and visible. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```
```
   function Is_FocusTo API doc
To body 
```

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines if the widget is the focus widget within its toplevel. (This

   --  does not mean that the HAS_FOCUS flag is necessarily set; HAS_FOCUS will

   --  only be set if the toplevel widget additionally has the global input

```
   --  focus.) 
```
```
 
```

   function Is_SensitiveTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Returns the widget's effective sensitivity, which means it is sensitive

   --  itself and also its parent widget is sensitive

```
   --  Since: gtk+ 2.18 
```
```
 
```

   function Is_ToplevelTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether Widget is a toplevel widget.

   --  Currently only Gtk.Window.Gtk_Window and Gtk.Invisible.Gtk_Invisible

   --  (and out-of-process Gtk_Plugs) are toplevel widgets. Toplevel widgets

```
   --  have no parent widget. 
```
```
   --  Since: gtk+ 2.18 
```
```
 
```

   function Is_VisibleTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Boolean;

   --  Determines whether the widget and all its parents are marked as

```
   --  visible. 
```

   --  This function does not check if the widget is obscured in any way.

   --  See also Gtk.Widget.Get_Visible and Gtk.Widget.Set_Visible

```
   --  Since: gtk+ 3.8 
```
```
 
```

   function Keynav_FailedTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       DirectionTo API doc
To body : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec) return Boolean;

   --  This function should be called whenever keyboard navigation within a

   --  single widget hits a boundary. The function emits the

   --  Gtk.Widget.Gtk_Widget::keynav-failed signal on the widget and its return

   --  value should be interpreted in a way similar to the return value of

```
   --  Gtk.Widget.Child_Focus: 
```

   --  When True is returned, stay in the widget, the failed keyboard

   --  navigation is Ok and/or there is nowhere we can/should move the focus

```
   --  to. 
```

   --  When False is returned, the caller should continue with keyboard

   --  navigation outside the widget, e.g. by calling Gtk.Widget.Child_Focus on

```
   --  the widget's toplevel. 
```

   --  The default ::keynav-failed handler returns True for

   --  Gtk.Enums.Dir_Tab_Forward and Gtk.Enums.Dir_Tab_Backward. For the other

   --  values of Gtk.Enums.Gtk_Direction_Type, it looks at the

   --  Gtk.Settings.Gtk_Settings:gtk-keynav-cursor-only setting and returns

   --  False if the setting is True. This way the entire user interface becomes

   --  cursor-navigatable on input devices such as mobile phones which only

   --  have cursor keys but no tab key.

   --  Whenever the default handler returns True, it also calls

   --  Gtk.Widget.Error_Bell to notify the user of the failed keyboard

```
   --  navigation. 
```

   --  A use case for providing an own implementation of ::keynav-failed

   --  (either by connecting to it or by overriding it) would be a row of

   --  Gtk.GEntry.Gtk_Entry widgets where the user should be able to navigate

   --  the entire row with the cursor keys, as e.g. known from user interfaces

   --  that require entering license keys.

```
   --  Since: gtk+ 2.12 
```

   --  "direction": direction of focus movement

```
 
```

   function List_Mnemonic_LabelsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec) return Widget_List.GlistTo API doc
To spec
To body;

   --  Returns a newly allocated list of the widgets, normally labels, for

   --  which this widget is the target of a mnemonic (see for example,

```
   --  Gtk.Label.Set_Mnemonic_Widget). 
```

   --  The widgets in the list are not individually referenced. If you want to

   --  iterate through the list and perform actions involving callbacks that

   --  might destroy the widgets, you *must* call 'g_list_foreach (result,

   --  (GFunc)g_object_ref, NULL)' first, and then unref all the widgets

```
   --  afterwards. 
```
```
   --  Since: gtk+ 2.4 
```
```
 
```

   procedure MapTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function is only for use in widget implementations. Causes a

   --  widget to be mapped if it isn't already.

```
 
```

   function Mnemonic_ActivateTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Group_Cycling : Boolean) return Boolean;

   --  Emits the Gtk.Widget.Gtk_Widget::mnemonic-activate signal.

   --  The default handler for this signal activates the Widget if

   --  Group_Cycling is False, and just grabs the focus if Group_Cycling is

```
   --  True. 
```

   --  "group_cycling": True if there are other widgets with the same mnemonic

```
 
```

   procedure Modify_BaseTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       StateTo API doc
To body  : Gtk.Enums.Gtk_State_TypeTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.Color.Gdk_ColorTo API doc
To spec
To body);

   pragma Obsolescent (Modify_BaseTo API doc
To spec
To body);

   --  Sets the base color for a widget in a particular state. All other style

   --  values are left untouched. The base color is the background color used

   --  along with the text color (see Gtk.Widget.Modify_Text) for widgets such

   --  as Gtk.GEntry.Gtk_Entry and Gtk.Text_View.Gtk_Text_View. See also

```
   --  gtk_widget_modify_style. 
```
```
   --  Note: 
```

   --  Note that "no window" widgets (which have the GTK_NO_WINDOW flag set)

   --  draw on their parent container's window and thus may not draw any

   --  background themselves. This is the case for e.g. Gtk.Label.Gtk_Label.

   --  To modify the background of such widgets, you have to set the base

   --  color on their parent; if you want to set the background of a

   --  rectangular area around a label, try placing the label in a

   --  Gtk.Event_Box.Gtk_Event_Box widget and setting the base color on that.

   --  Deprecated since 3.0, Use Gtk.Widget.Override_Background_Color instead

   --  "state": the state for which to set the base color

   --  "color": the color to assign (does not need to be allocated), or null

   --  to undo the effect of previous calls to of Gtk.Widget.Modify_Base.

```
 
```

   procedure Modify_BgTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       StateTo API doc
To body  : Gtk.Enums.Gtk_State_TypeTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.Color.Gdk_ColorTo API doc
To spec
To body);

   pragma Obsolescent (Modify_BgTo API doc
To spec
To body);

   --  Sets the background color for a widget in a particular state.

   --  All other style values are left untouched. See also

```
   --  gtk_widget_modify_style. 
```
```
   --  Note: 
```

   --  Note that "no window" widgets (which have the GTK_NO_WINDOW flag set)

   --  draw on their parent container's window and thus may not draw any

   --  background themselves. This is the case for e.g. Gtk.Label.Gtk_Label.

   --  To modify the background of such widgets, you have to set the

   --  background color on their parent; if you want to set the background of a

   --  rectangular area around a label, try placing the label in a

   --  Gtk.Event_Box.Gtk_Event_Box widget and setting the background color on

```
   --  that. 
```

   --  Deprecated since 3.0, Use Gtk.Widget.Override_Background_Color instead

   --  "state": the state for which to set the background color

   --  "color": the color to assign (does not need to be allocated), or null

   --  to undo the effect of previous calls to of Gtk.Widget.Modify_Bg.

```
 
```

   procedure Modify_CursorTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       PrimaryTo API doc
To body   : Gdk.Color.Gdk_ColorTo API doc
To spec
To body;

       SecondaryTo API doc
To body : Gdk.Color.Gdk_ColorTo API doc
To spec
To body);

   pragma Obsolescent (Modify_CursorTo API doc
To spec
To body);

   --  Sets the cursor color to use in a widget, overriding the

   --  Gtk.Widget.Gtk_Widget:cursor-color and

   --  Gtk.Widget.Gtk_Widget:secondary-cursor-color style properties.

   --  All other style values are left untouched. See also

```
   --  gtk_widget_modify_style. 
```
```
   --  Since: gtk+ 2.12 
```

   --  Deprecated since None, 3.0. Use Gtk.Widget.Override_Cursor instead.

   --  "primary": the color to use for primary cursor (does not need to be

   --  allocated), or null to undo the effect of previous calls to of

```
   --  Gtk.Widget.Modify_Cursor. 
```

   --  "secondary": the color to use for secondary cursor (does not need to be

   --  allocated), or null to undo the effect of previous calls to of

```
   --  Gtk.Widget.Modify_Cursor. 
```
```
 
```

   procedure Modify_FgTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       StateTo API doc
To body  : Gtk.Enums.Gtk_State_TypeTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.Color.Gdk_ColorTo API doc
To spec
To body);

   pragma Obsolescent (Modify_FgTo API doc
To spec
To body);

   --  Sets the foreground color for a widget in a particular state.

   --  All other style values are left untouched. See also

```
   --  gtk_widget_modify_style. 
```

   --  Deprecated since 3.0, Use Gtk.Widget.Override_Color instead

   --  "state": the state for which to set the foreground color

   --  "color": the color to assign (does not need to be allocated), or null

   --  to undo the effect of previous calls to of Gtk.Widget.Modify_Fg.

```
 
```

   procedure Modify_FontTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       Font_Desc : Pango.Font.Pango_Font_DescriptionTo API doc
To spec);

   pragma Obsolescent (Modify_FontTo API doc
To spec
To body);

   --  Sets the font to use for a widget.

   --  All other style values are left untouched. See also

```
   --  gtk_widget_modify_style. 
```

   --  Deprecated since 3.0, Use Gtk.Widget.Override_Font instead

   --  "font_desc": the font description to use, or null to undo the effect of

   --  previous calls to Gtk.Widget.Modify_Font

```
 
```

   procedure Modify_TextTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       StateTo API doc
To body  : Gtk.Enums.Gtk_State_TypeTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.Color.Gdk_ColorTo API doc
To spec
To body);

   pragma Obsolescent (Modify_TextTo API doc
To spec
To body);

   --  Sets the text color for a widget in a particular state.

   --  All other style values are left untouched. The text color is the

   --  foreground color used along with the base color (see

   --  Gtk.Widget.Modify_Base) for widgets such as Gtk.GEntry.Gtk_Entry and

   --  Gtk.Text_View.Gtk_Text_View. See also gtk_widget_modify_style.

   --  Deprecated since 3.0, Use Gtk.Widget.Override_Color instead

   --  "state": the state for which to set the text color

   --  "color": the color to assign (does not need to be allocated), or null

   --  to undo the effect of previous calls to of Gtk.Widget.Modify_Text.

```
 
```

   procedure Override_Background_ColorTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       State  : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.RGBA.Gdk_RGBATo API doc
To spec);

   --  Sets the background color to use for a widget.

   --  All other style values are left untouched. See

```
   --  Gtk.Widget.Override_Color. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "state": the state for which to set the background color

   --  "color": the color to assign, or null to undo the effect of previous

   --  calls to Gtk.Widget.Override_Background_Color

```
 
```

   procedure Override_ColorTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       State  : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.RGBA.Gdk_RGBATo API doc
To spec);

   --  Sets the color to use for a widget.

   --  All other style values are left untouched.

```
   --  Note: 
```

   --  This API is mostly meant as a quick way for applications to change a

   --  widget appearance. If you are developing a widgets library and intend

   --  this change to be themeable, it is better done by setting meaningful CSS

   --  classes and regions in your widget/container implementation through

   --  Gtk.Style_Context.Add_Class and Gtk.Style_Context.Add_Region.

   --  This way, your widget library can install a

   --  Gtk.Css_Provider.Gtk_Css_Provider with the

   --  GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order to provide a

   --  default styling for those widgets that need so, and this theming may

   --  fully overridden by the user's theme.

```
   --  Note: 
```

   --  Note that for complex widgets this may bring in undesired results (such

   --  as uniform background color everywhere), in these cases it is better to

   --  fully style such widgets through a Gtk.Css_Provider.Gtk_Css_Provider

   --  with the GTK_STYLE_PROVIDER_PRIORITY_APPLICATION priority.

```
   --  Since: gtk+ 3.0 
```

   --  "state": the state for which to set the color

   --  "color": the color to assign, or null to undo the effect of previous

   --  calls to Gtk.Widget.Override_Color

```
 
```

   procedure Override_CursorTo API doc
To body

      (Widget           : not null access Gtk_Widget_RecordTo API doc
To spec;

       CursorTo API doc
To body           : Gdk.RGBA.Gdk_RGBATo API doc
To spec;

       Secondary_CursorTo API doc
To body : Gdk.RGBA.Gdk_RGBATo API doc
To spec);

   --  Sets the cursor color to use in a widget, overriding the

   --  Gtk.Widget.Gtk_Widget:cursor-color and

   --  Gtk.Widget.Gtk_Widget:secondary-cursor-color style properties. All other

   --  style values are left untouched. See also gtk_widget_modify_style.

   --  Note that the underlying properties have the Gdk.Color.Gdk_Color type,

   --  so the alpha value in Primary and Secondary will be ignored.

```
   --  Since: gtk+ 3.0 
```

   --  "cursor": the color to use for primary cursor (does not need to be

   --  allocated), or null to undo the effect of previous calls to of

```
   --  Gtk.Widget.Override_Cursor. 
```

   --  "secondary_cursor": the color to use for secondary cursor (does not

   --  need to be allocated), or null to undo the effect of previous calls to

```
   --  of Gtk.Widget.Override_Cursor. 
```
```
 
```

   procedure Override_FontTo API doc
To body

      (Widget    : not null access Gtk_Widget_RecordTo API doc
To spec;

       Font_Desc : Pango.Font.Pango_Font_DescriptionTo API doc
To spec);

   --  Sets the font to use for a widget. All other style values are left

   --  untouched. See Gtk.Widget.Override_Color.

```
   --  Since: gtk+ 3.0 
```

   --  "font_desc": the font descriptiong to use, or null to undo the effect

   --  of previous calls to Gtk.Widget.Override_Font

```
 
```

   procedure Override_Symbolic_ColorTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Name   : UTF8_StringTo API doc
To spec;

       ColorTo API doc
To body  : Gdk.RGBA.Gdk_RGBATo API doc
To spec);

   --  Sets a symbolic color for a widget.

   --  All other style values are left untouched. See

   --  Gtk.Widget.Override_Color for overriding the foreground or background

```
   --  color. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "name": the name of the symbolic color to modify

   --  "color": the color to assign (does not need to be allocated), or null

   --  to undo the effect of previous calls to

   --  Gtk.Widget.Override_Symbolic_Color

```
 
```

   procedure Queue_Compute_ExpandTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Mark Widget as needing to recompute its expand flags. Call this

   --  function when setting legacy expand child properties on the child of a

```
   --  container. 
```
```
   --  See Gtk.Widget.Compute_Expand. 
```
```
 
```

   procedure Queue_DrawTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Equivalent to calling Gtk.Widget.Queue_Draw_Area for the entire area of

```
   --  a widget. 
```
```
 
```

   procedure Queue_Draw_AreaTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       X      : GintTo API doc
To spec; 
```
```
       Y      : GintTo API doc
To spec; 
```
```
       Width  : GintTo API doc
To spec; 
```

       Height : GintTo API doc
To spec);

   --  Convenience function that calls Gtk.Widget.Queue_Draw_Region on the

   --  region created from the given coordinates.

   --  The region here is specified in widget coordinates. Widget coordinates

   --  are a bit odd; for historical reasons, they are defined as

   --  Widget->window coordinates for widgets that are not GTK_NO_WINDOW

   --  widgets, and are relative to Widget->allocation.x, Widget->allocation.y

   --  for widgets that are GTK_NO_WINDOW widgets.

   --  "x": x coordinate of upper-left corner of rectangle to redraw

   --  "y": y coordinate of upper-left corner of rectangle to redraw

   --  "width": width of region to draw

   --  "height": height of region to draw

```
 
```

   procedure Queue_Draw_RegionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Region : Cairo.Region.Cairo_RegionTo API doc
To spec);

   --  Invalidates the rectangular area of Widget defined by Region by calling

   --  Gdk.Window.Invalidate_Region on the widget's window and all its child

   --  windows. Once the main loop becomes idle (after the current batch of

   --  events has been processed, roughly), the window will receive expose

   --  events for the union of all regions that have been invalidated.

   --  Normally you would only use this function in widget implementations.

   --  You might also use it to schedule a redraw of a

   --  Gtk.Drawing_Area.Gtk_Drawing_Area or some portion thereof.

```
   --  Since: gtk+ 3.0 
```
```
   --  "region": region to draw 
```
```
 
```

   procedure Queue_ResizeTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function is only for use in widget implementations. Flags a widget

   --  to have its size renegotiated; should be called when a widget for some

   --  reason has a new size request. For example, when you change the text in

   --  a Gtk.Label.Gtk_Label, Gtk.Label.Gtk_Label queues a resize to ensure

   --  there's enough space for the new text.

```
   --  Note: 
```

   --  You cannot call Gtk.Widget.Queue_Resize on a widget from inside its

   --  implementation of the GtkWidgetClass::size_allocate virtual method.

   --  Calls to Gtk.Widget.Queue_Resize from inside

   --  GtkWidgetClass::size_allocate will be silently ignored.

```
 
```

   procedure Queue_Resize_No_RedrawTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function works like Gtk.Widget.Queue_Resize, except that the

```
   --  widget is not invalidated. 
```
```
   --  Since: gtk+ 2.4 
```
```
 
```

   procedure RealizeTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Creates the GDK (windowing system) resources associated with a widget.

   --  For example, Widget->window will be created when a widget is realized.

   --  Normally realization happens implicitly; if you show a widget and all

   --  its parent containers, then the widget will be realized and mapped

```
   --  automatically. 
```

   --  Realizing a widget requires all the widget's parent widgets to be

   --  realized; calling Gtk.Widget.Realize realizes the widget's parents in

   --  addition to Widget itself. If a widget is not yet inside a toplevel

   --  window when you realize it, bad things will happen.

   --  This function is primarily used in widget implementations, and isn't

   --  very useful otherwise. Many times when you think you might need it, a

   --  better approach is to connect to a signal that will be called after the

   --  widget is realized automatically, such as Gtk.Widget.Gtk_Widget::draw.

   --  Or simply g_signal_connect () to the Gtk.Widget.Gtk_Widget::realize

```
   --  signal. 
```
```
 
```

   function Region_IntersectTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Region : Cairo.Region.Cairo_RegionTo API doc
To spec) return Cairo.Region.Cairo_RegionTo API doc
To spec;

   --  Computes the intersection of a Widget's area and Region, returning the

   --  intersection. The result may be empty, use cairo_region_is_empty to

```
   --  check. 
```

   --  "region": a cairo_region_t, in the same coordinate system as

   --  Widget->allocation. That is, relative to Widget->window for NO_WINDOW

   --  widgets; relative to the parent window of Widget->window for widgets

```
   --  with their own window. 
```
```
 
```

   procedure Register_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Window : Gdk.Gdk_WindowTo API doc
To spec);

   --  Registers a Gdk.Gdk_Window with the widget and sets it up so that the

   --  widget recieves events for it. Call Gtk.Widget.Unregister_Window when

```
   --  destroying the window. 
```

   --  Before 3.8 you needed to call Gdk.Window.Set_User_Data directly to set

   --  this up. This is now deprecated and you should use

   --  Gtk.Widget.Register_Window instead. Old code will keep working as is,

   --  although some new features like transparency might not work perfectly.

```
   --  Since: gtk+ 3.8 
```
```
   --  "window": a Gdk.Gdk_Window 
```
```
 
```

   function Remove_AcceleratorTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_RecordTo API doc
To spec'Class;

       Accel_Key   : Gdk.Types.Gdk_Key_TypeTo API doc
To spec;

       Accel_Mods  : Gdk.Types.Gdk_Modifier_TypeTo API doc
To spec) return Boolean;

   --  Removes an accelerator from Widget, previously installed with

```
   --  Gtk.Widget.Add_Accelerator. 
```

   --  "accel_group": accel group for this widget

   --  "accel_key": GDK keyval of the accelerator

   --  "accel_mods": modifier key combination of the accelerator

```
 
```

   procedure Remove_Mnemonic_LabelTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Label  : not null access Gtk_Widget_RecordTo API doc
To spec'Class);

   --  Removes a widget from the list of mnemonic labels for this widget. (See

   --  Gtk.Widget.List_Mnemonic_Labels). The widget must have previously been

   --  added to the list with Gtk.Widget.Add_Mnemonic_Label.

```
   --  Since: gtk+ 2.4 
```

   --  "label": a Gtk.Widget.Gtk_Widget that was previously set as a mnemnic

   --  label for Widget with Gtk.Widget.Add_Mnemonic_Label.

```
 
```

   procedure Remove_Tick_CallbackTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Id     : GuintTo API doc
To spec);

   --  Removes a tick callback previously registered with

```
   --  Gtk.Widget.Add_Tick_Callback. 
```
```
   --  Since: gtk+ 3.8 
```

   --  "id": an id returned by Gtk.Widget.Add_Tick_Callback

```
 
```

   function Render_IconTo API doc
To body

      (Widget   : not null access Gtk_Widget_RecordTo API doc
To spec;

       Stock_Id : UTF8_StringTo API doc
To spec;

       Size     : Gtk.Enums.Gtk_Icon_SizeTo API doc
To spec;

       Detail   : UTF8_StringTo API doc
To spec := "") return Gdk.Pixbuf.Gdk_PixbufTo API doc
To spec;

   pragma Obsolescent (Render_IconTo API doc
To spec
To body);

   --  A convenience function that uses the theme settings for Widget to look

   --  up Stock_Id and render it to a pixbuf. Stock_Id should be a stock icon

   --  ID such as GTK_STOCK_OPEN or GTK_STOCK_OK. Size should be a size such as

   --  GTK_ICON_SIZE_MENU. Detail should be a string that identifies the widget

   --  or code doing the rendering, so that theme engines can special-case

   --  rendering for that widget or code.

   --  The pixels in the returned Gdk.Pixbuf.Gdk_Pixbuf are shared with the

   --  rest of the application and should not be modified. The pixbuf should be

   --  freed after use with g_object_unref.

   --  Deprecated since 3.0, Use Gtk.Widget.Render_Icon_Pixbuf instead.

```
   --  "stock_id": a stock ID 
```

   --  "size": a stock size. A size of (GtkIconSize)-1 means render at the

   --  size of the source and don't scale (if there are multiple source sizes,

   --  GTK+ picks one of the available sizes).

   --  "detail": render detail to pass to theme engine

```
 
```

   function Render_Icon_PixbufTo API doc
To body

      (Widget   : not null access Gtk_Widget_RecordTo API doc
To spec;

       Stock_Id : UTF8_StringTo API doc
To spec;

       Size     : Gtk.Enums.Gtk_Icon_SizeTo API doc
To spec) return Gdk.Pixbuf.Gdk_PixbufTo API doc
To spec;

   --  A convenience function that uses the theme engine and style settings

   --  for Widget to look up Stock_Id and render it to a pixbuf. Stock_Id

   --  should be a stock icon ID such as GTK_STOCK_OPEN or GTK_STOCK_OK. Size

   --  should be a size such as GTK_ICON_SIZE_MENU.

   --  The pixels in the returned Gdk.Pixbuf.Gdk_Pixbuf are shared with the

   --  rest of the application and should not be modified. The pixbuf should be

   --  freed after use with g_object_unref.

```
   --  Since: gtk+ 3.0 
```
```
   --  "stock_id": a stock ID 
```

   --  "size": a stock size. A size of (GtkIconSize)-1 means render at the

   --  size of the source and don't scale (if there are multiple source sizes,

   --  GTK+ picks one of the available sizes).

```
 
```
```
   procedure ReparentTo API doc
To body 
```

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

       New_Parent : not null access Gtk_Widget_RecordTo API doc
To spec'Class);

   --  Moves a widget from one Gtk.Container.Gtk_Container to another,

   --  handling reference count issues to avoid destroying the widget.

   --  "new_parent": a Gtk.Container.Gtk_Container to move the widget into

```
 
```

   procedure Reset_Rc_StylesTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   pragma Obsolescent (Reset_Rc_StylesTo API doc
To spec
To body);

   --  Reset the styles of Widget and all descendents, so when they are looked

   --  up again, they get the correct values for the currently loaded RC file

```
   --  settings. 
```

   --  This function is not useful for applications.

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead,

```
   --  and Gtk.Widget.Reset_Style 
```
```
 
```

   procedure Reset_StyleTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Updates the style context of Widget and all descendents by updating its

   --  widget path. Gtk.Container.Gtk_Container<!-- -->s may want to use this

   --  on a child when reordering it in a way that a different style might

   --  apply to it. See also Gtk.Container.Get_Path_For_Child.

```
   --  Since: gtk+ 3.0 
```
```
 
```

   function Send_ExposeTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Event  : Gdk.Event.Gdk_EventTo API doc
To spec) return GintTo API doc
To spec;

   --  Very rarely-used function. This function is used to emit an expose

   --  event on a widget. This function is not normally used directly. The only

   --  time it is used is when propagating an expose event to a child NO_WINDOW

   --  widget, and that is normally done using Gtk.Container.Propagate_Draw.

   --  If you want to force an area of a window to be redrawn, use

   --  Gdk.Window.Invalidate_Rect or Gdk.Window.Invalidate_Region. To cause the

   --  redraw to be done immediately, follow that call with a call to

```
   --  Gdk.Window.Process_Updates. 
```

   --  "event": a expose Gdk.Event.Gdk_Event

```
 
```

   function Send_Focus_ChangeTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Event  : Gdk.Event.Gdk_EventTo API doc
To spec) return Boolean;

   --  Sends the focus change Event to Widget

   --  This function is not meant to be used by applications. The only time it

   --  should be used is when it is necessary for a Gtk.Widget.Gtk_Widget to

   --  assign focus to a widget that is semantically owned by the first widget

   --  even though it's not a direct child - for instance, a search entry in a

   --  floating window similar to the quick search in

```
   --  Gtk.Tree_View.Gtk_Tree_View. 
```
```
   --  An example of its usage is: 
```

   --  |[ GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);

   --  fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.in =

   --  TRUE; fevent->focus_change.window = gtk_widget_get_window (widget); if

   --  (fevent->focus_change.window != NULL) g_object_ref

```
   --  (fevent->focus_change.window); 
```

   --  gtk_widget_send_focus_change (widget, fevent);

```
   --  gdk_event_free (event); ]| 
```
```
   --  Since: gtk+ 2.20 
```

   --  "event": a Gdk.Event.Gdk_Event of type GDK_FOCUS_CHANGE

```
 
```

   procedure Set_Accel_PathTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       Accel_Path  : UTF8_StringTo API doc
To spec := "";

       Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_RecordTo API doc
To spec'Class);

   --  Given an accelerator group, Accel_Group, and an accelerator path,

   --  Accel_Path, sets up an accelerator in Accel_Group so whenever the key

   --  binding that is defined for Accel_Path is pressed, Widget will be

   --  activated. This removes any accelerators (for any accelerator group)

   --  installed by previous calls to Gtk.Widget.Set_Accel_Path. Associating

   --  accelerators with paths allows them to be modified by the user and the

   --  modifications to be saved for future use. (See Gtk.Accel_Map.Save.)

   --  This function is a low level function that would most likely be used by

   --  a menu creation system like Gtk.UI_Manager.Gtk_UI_Manager. If you use

   --  Gtk.UI_Manager.Gtk_UI_Manager, setting up accelerator paths will be done

```
   --  automatically. 
```

   --  Even when you you aren't using Gtk.UI_Manager.Gtk_UI_Manager, if you

   --  only want to set up accelerators on menu items

   --  Gtk.Menu_Item.Set_Accel_Path provides a somewhat more convenient

```
   --  interface. 
```

   --  Note that Accel_Path string will be stored in a Glib.GQuark. Therefore,

   --  if you pass a static string, you can save some memory by interning it

   --  first with g_intern_static_string.

   --  "accel_path": path used to look up the accelerator

   --  "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group.

```
 
```

   procedure Set_Redraw_On_AllocateTo API doc
To body

      (Widget             : not null access Gtk_Widget_RecordTo API doc
To spec;

```
       Redraw_On_Allocate : Boolean); 
```

   --  Sets whether the entire widget is queued for drawing when its size

   --  allocation changes. By default, this setting is True and the entire

   --  widget is redrawn on every size change. If your widget leaves the upper

   --  left unchanged when made bigger, turning this setting off will improve

```
   --  performance. 
```

   --  Note that for NO_WINDOW widgets setting this flag to False turns off

   --  all allocation on resizing: the widget will not even redraw if its

   --  position changes; this is to allow containers that don't draw anything

   --  to avoid excess invalidations. If you set this flag on a NO_WINDOW

   --  widget that *does* draw on Widget->window, you are responsible for

   --  invalidating both the old and new allocation of the widget when the

   --  widget is moved and responsible for invalidating regions newly when the

```
   --  widget increases size. 
```

   --  "redraw_on_allocate": if True, the entire widget will be redrawn when

   --  it is allocated to a new size. Otherwise, only the new portion of the

```
   --  widget will be redrawn. 
```
```
 
```

   procedure Shape_Combine_RegionTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Region : Cairo.Region.Cairo_RegionTo API doc
To spec);

   --  Sets a shape for this widget's GDK window. This allows for transparent

   --  windows etc., see Gdk.Window.Shape_Combine_Region for more information.

```
   --  Since: gtk+ 3.0 
```

   --  "region": shape to be added, or null to remove an existing shape

```
 
```

   procedure ShowTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Flags a widget to be displayed. Any widget that isn't shown will not

   --  appear on the screen. If you want to show all the widgets in a

   --  container, it's easier to call Gtk.Widget.Show_All on the container,

   --  instead of individually showing the widgets.

   --  Remember that you have to show the containers containing a widget, in

   --  addition to the widget itself, before it will appear onscreen.

   --  When a toplevel container is shown, it is immediately realized and

   --  mapped; other shown widgets are realized and mapped when their toplevel

   --  container is realized and mapped.

```
 
```

   procedure Show_AllTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Recursively shows a widget, and any child widgets (if the widget is a

```
   --  container). 
```
```
 
```

   procedure Show_NowTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Shows a widget. If the widget is an unmapped toplevel widget (i.e. a

   --  Gtk.Window.Gtk_Window that has not yet been shown), enter the main loop

   --  and wait for the window to actually be mapped. Be careful; because the

   --  main loop is running, anything can happen during this function.

```
 
```

   procedure Size_AllocateTo API doc
To body

      (Widget     : not null access Gtk_Widget_RecordTo API doc
To spec;

       AllocationTo API doc
To body : Gtk_AllocationTo API doc
To spec);

   --  This function is only used by Gtk.Container.Gtk_Container subclasses,

   --  to assign a size and position to their child widgets.

   --  In this function, the allocation may be adjusted. It will be forced to

   --  a 1x1 minimum size, and the adjust_size_allocation virtual method on the

   --  child will be used to adjust the allocation. Standard adjustments

   --  include removing the widget's margins, and applying the widget's

   --  Gtk.Widget.Gtk_Widget:halign and Gtk.Widget.Gtk_Widget:valign

```
   --  properties. 
```

   --  "allocation": position and size to be allocated to Widget

```
 
```

   procedure Style_AttachTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   pragma Obsolescent (Style_AttachTo API doc
To spec
To body);

   --  This function attaches the widget's Gtk.Style.Gtk_Style to the widget's

   --  Gdk.Gdk_Window. It is a replacement for

   --    widget->style = gtk_style_attach (widget->style, widget->window);

   --  and should only ever be called in a derived widget's "realize"

   --  implementation which does not chain up to its parent class' "realize"

   --  implementation, because one of the parent classes (finally

   --  Gtk.Widget.Gtk_Widget) would attach the style itself.

```
   --  Since: gtk+ 2.20 
```

   --  Deprecated since None, 3.0. This step is unnecessary with

   --  Gtk.Style_Context.Gtk_Style_Context.

```
 
```

   procedure Style_Get_PropertyTo API doc
To body

      (Widget        : not null access Gtk_Widget_RecordTo API doc
To spec;

       Property_Name : UTF8_StringTo API doc
To spec;

       ValueTo API doc
To body         : in out Glib.Values.GValueTo API doc
To spec
To body);

   --  Gets the value of a style property of Widget.

   --  "property_name": the name of a style property

   --  "value": location to return the property value

```
 
```

   procedure Thaw_Child_NotifyTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Reverts the effect of a previous call to

   --  Gtk.Widget.Freeze_Child_Notify. This causes all queued

   --  Gtk.Widget.Gtk_Widget::child-notify signals on Widget to be emitted.

```
 
```

   procedure Translate_CoordinatesTo API doc
To body

      (Widget      : not null access Gtk_Widget_RecordTo API doc
To spec;

       Dest_Widget : not null access Gtk_Widget_RecordTo API doc
To spec'Class;

       Src_X       : GintTo API doc
To spec;

       Src_Y       : GintTo API doc
To spec;

       Dest_X      : out GintTo API doc
To spec;

       Dest_Y      : out GintTo API doc
To spec;

```
       Result      : out Boolean); 
```

   --  Translate coordinates relative to Src_Widget's allocation to

   --  coordinates relative to Dest_Widget's allocations. In order to perform

   --  this operation, both widgets must be realized, and must share a common

```
   --  toplevel. 
```

   --  "dest_widget": a Gtk.Widget.Gtk_Widget

   --  "src_x": X position relative to Src_Widget

   --  "src_y": Y position relative to Src_Widget

   --  "dest_x": location to store X position relative to Dest_Widget

   --  "dest_y": location to store Y position relative to Dest_Widget

```
 
```

   procedure Trigger_Tooltip_QueryTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  Triggers a tooltip query on the display where the toplevel of Widget is

   --  located. See Gtk.Tooltip.Trigger_Tooltip_Query for more information.

```
   --  Since: gtk+ 2.12 
```
```
 
```

   procedure UnmapTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function is only for use in widget implementations. Causes a

   --  widget to be unmapped if it's currently mapped.

```
 
```

   procedure UnparentTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function is only for use in widget implementations. Should be

   --  called by implementations of the remove method on

   --  Gtk.Container.Gtk_Container, to dissociate a child from the container.

```
 
```

   procedure UnrealizeTo API doc
To body (Widget : not null access Gtk_Widget_RecordTo API doc
To spec);

   --  This function is only useful in widget implementations. Causes a widget

   --  to be unrealized (frees all GDK resources associated with the widget,

```
   --  such as Widget->window). 
```
```
 
```

   procedure Unregister_WindowTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Window : Gdk.Gdk_WindowTo API doc
To spec);

   --  Unregisters a Gdk.Gdk_Window from the widget that was previously set up

   --  with Gtk.Widget.Register_Window. You need to call this when the window

   --  is no longer used by the widget, such as when you destroy it.

```
   --  Since: gtk+ 3.8 
```
```
   --  "window": a Gdk.Gdk_Window 
```
```
 
```

   procedure Unset_State_FlagsTo API doc
To body

      (Widget : not null access Gtk_Widget_RecordTo API doc
To spec;

       Flags  : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec);

   --  This function is for use in widget implementations. Turns off flag

   --  values for the current widget state (insensitive, prelighted, etc.). See

```
   --  Gtk.Widget.Set_State_Flags. 
```
```
   --  Since: gtk+ 3.0 
```

   --  "flags": State flags to turn off

```
 
```

   function Find_Style_PropertyTo API doc
To body

      (Self          : GObject_ClassTo API doc
To spec;

       Property_Name : UTF8_StringTo API doc
To spec) return Glib.Param_SpecTo API doc
To spec;

   --  Finds a style property of a widget class by name.

```
   --  Since: gtk+ 2.2 
```

   --  "property_name": the name of the style property to find

```
 
```

   procedure Install_Style_PropertyTo API doc
To body

      (Self  : GObject_ClassTo API doc
To spec;

       Pspec : Glib.Param_SpecTo API doc
To spec);

   pragma Import (C, Install_Style_PropertyTo API doc
To spec, "gtk_widget_class_install_style_property");

   --  Installs a style property on a widget class. The parser for the style

   --  property is determined by the value type of Pspec.

   --  "pspec": the Glib.Param_Spec for the property

```
 
```
```
   ---------------------- 
```
```
   -- GtkAda additions -- 
```
```
   ---------------------- 
```
```
 
```

   ------------------------------------

   -- Override default size handling --

   ------------------------------------

```
 
```

   type Gtk_Requisition_Access is access all Gtk_RequisitionTo API doc
To spec;

   type Gtk_Allocation_Access is access all Gtk_AllocationTo API doc
To spec;

   pragma Convention (C, Gtk_Requisition_AccessTo API doc
To spec);

   pragma Convention (C, Gtk_Allocation_AccessTo API doc
To spec);

```
 
```

   function Get_RequisitionTo API doc
To body

     (ValueTo API doc
To body : Glib.Values.GValueTo API doc
To spec
To body) return Gtk_Requisition_AccessTo API doc
To spec;

   function Get_AllocationTo API doc
To body

     (ValueTo API doc
To body : Glib.Values.GValueTo API doc
To spec
To body) return Gtk_Allocation_AccessTo API doc
To spec;

   --  Convert values received as callback parameters

```
 
```

   type Size_Allocate_Handler is access procedure

     (Widget : System.Address; Allocation : Gtk_AllocationTo API doc
To spec);

   pragma Convention (C, Size_Allocate_HandlerTo API doc
To spec);

   --  Widget is the gtk+ C widget, that needs to be converted to Ada through

```
   --  a call to: 
```
```
   --    declare 
```

   --       Stub : Gtk_Widget_Record; --  or the exact type you expect

```
   --    begin 
```

   --       My_Widget := Gtk_Widget (Glib.Object.Get_User_Data (Widget, Stub);

```
   --    end; 
```
```
 
```

   procedure Set_Default_Size_Allocate_HandlerTo API doc
To body

     (Klass   : Glib.Object.Ada_GObject_ClassTo API doc
To spec;

      Handler : Size_Allocate_HandlerTo API doc
To spec);

   pragma Import (C, Set_Default_Size_Allocate_HandlerTo API doc
To spec,

      "ada_WIDGET_CLASS_override_size_allocate");

   --  Override the default size_allocate handler for this class. This handler

   --  is automatically called in several cases (when a widget is dynamically

   --  resized for instance), not through a signal. Thus, if you need to

   --  override the default behavior provided by one of the standard

   --  containers, you can not simply use Gtk.Handlers.Emit_Stop_By_Name, and

   --  you must override the default handler. Note also that this handler

   --  is automatically inherited by children of this class.

```
   -- 
```

   --  This function is not needed unless you are writting your own

   --  widgets, and should be reserved for advanced customization of the

```
   --  standard widgets. 
```
```
 
```

   type Preferred_Size_Handler is access procedure

```
     (Widget       : System.Address; 
```

      Minimum_Size : out Glib.GintTo API doc
To spec;

      Natural_Size : out Glib.GintTo API doc
To spec);

   pragma Convention (C, Preferred_Size_HandlerTo API doc
To spec);

```
 
```

   procedure Set_Default_Get_Preferred_Width_HandlerTo API doc
To body

     (Klass   : Glib.Object.Ada_GObject_ClassTo API doc
To spec;

      Handler : Preferred_Size_HandlerTo API doc
To spec);

   procedure Set_Default_Get_Preferred_Height_HandlerTo API doc
To body

     (Klass   : Glib.Object.Ada_GObject_ClassTo API doc
To spec;

      Handler : Preferred_Size_HandlerTo API doc
To spec);

   pragma Import (C, Set_Default_Get_Preferred_Width_HandlerTo API doc
To spec,

      "ada_WIDGET_CLASS_override_get_preferred_width");

   pragma Import (C, Set_Default_Get_Preferred_Height_HandlerTo API doc
To spec,

      "ada_WIDGET_CLASS_override_get_preferred_height");

   --  Override the computation of a widget's preferred sizes.

   --  You will only need to override this computation if you are writting

```
   --  your own container widgets. 
```
```
 
```

   procedure Inherited_Get_Preferred_WidthTo API doc
To body

     (KlassTo API doc
To body      : Ada_GObject_ClassTo API doc
To spec;

      Widget     : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Minimum_Size, Natural_Size : out Glib.GintTo API doc
To spec);

   procedure Inherited_Get_Preferred_HeightTo API doc
To body

     (KlassTo API doc
To body      : Ada_GObject_ClassTo API doc
To spec;

      Widget     : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Minimum_Size, Natural_Size : out Glib.GintTo API doc
To spec);

```
   --  Call the default implementation 
```
```
 
```

   procedure Inherited_Size_AllocateTo API doc
To body

     (KlassTo API doc
To body      : Ada_GObject_ClassTo API doc
To spec;

      Widget     : access Gtk_Widget_RecordTo API doc
To spec'Class;

      AllocationTo API doc
To body : Gtk_AllocationTo API doc
To spec);

   --  Call the inherited size_allocate. This is useful if you have overloaded it in

   --  your own class, but still need to call the standard implementation.

```
 
```
```
   --------------------------- 
```
```
   -- Override Draw handler -- 
```
```
   --------------------------- 
```
```
 
```
```
   generic 
```
```
   with function Draw 
```

     (W  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Cr : Cairo.Cairo_ContextTo API doc
To spec) return Boolean;

   function Proxy_DrawTo API doc
To body

     (W  : System.Address; Cr : Cairo.Cairo_ContextTo API doc
To spec) return GbooleanTo API doc
To spec;

   pragma Convention (C, Proxy_DrawTo API doc
To spec
To body);

```
 
```

   type Draw_Handler is access function

```
     (W  : System.Address; 
```

      Cr : Cairo.Cairo_ContextTo API doc
To spec) return GbooleanTo API doc
To spec;

   pragma Convention (C, Draw_HandlerTo API doc
To spec);

   --  A function responsible for drawing a widget.

```
 
```

   procedure Set_Default_Draw_HandlerTo API doc
To body

     (KlassTo API doc
To body : Glib.Object.Ada_GObject_ClassTo API doc
To spec; Handler : Draw_HandlerTo API doc
To spec);

   --  Override the default drawing function. This in general gives more

   --  control than connection to Signal_Draw, however a widget is responsible

```
   --  for drawing its children. 
```

   --  Use the generic Proxy_Draw to create a suitable callback.

```
 
```

   function Inherited_DrawTo API doc
To body

     (KlassTo API doc
To body  : Ada_GObject_ClassTo API doc
To spec;

      Widget : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Cr     : Cairo.Cairo_ContextTo API doc
To spec) return Boolean;

   --  Call the inherited draw. This is useful if you have overloaded draw in

   --  your own class, but still need to draw the child widgets that do not

   --  have their own window (the others will already get their own "draw"

```
   --  event. 
```

   --  See http://developer.gnome.org/gtk3/3.0/chap-drawing-model.html

   --  for an explanation of the gtk+ drawing model.

```
 
```
```
   --------------- 
```
```
   -- Functions -- 
```
```
   --------------- 
```
```
 
```

   function Get_Default_DirectionTo API doc
To body return Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec;

   --  Obtains the current default reading direction. See

   --  Gtk.Widget.Set_Default_Direction.

```
 
```

   procedure Set_Default_DirectionTo API doc
To body (DirTo API doc
To body : Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec);

   --  Sets the default reading direction for widgets where the direction has

   --  not been explicitly set by Gtk.Widget.Set_Direction.

   --  "dir": the new default direction. This cannot be

```
   --  Gtk.Enums.Text_Dir_None. 
```
```
 
```

   function Get_Default_StyleTo API doc
To body return Gtk.Style.Gtk_StyleTo API doc
To spec;

   pragma Obsolescent (Get_Default_StyleTo API doc
To spec
To body);

   --  Returns the default style used by all widgets initially.

   --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead,

   --  and Gtk.Css_Provider.Get_Default to obtain a

   --  Gtk.Style_Provider.Gtk_Style_Provider with the default widget style

```
   --  information. 
```
```
 
```

   procedure Pop_Composite_ChildTo API doc
To body;

   --  Cancels the effect of a previous call to

   --  Gtk.Widget.Push_Composite_Child.

```
 
```

   procedure Push_Composite_ChildTo API doc
To body;

   --  Makes all newly-created widgets as composite children until the

   --  corresponding Gtk.Widget.Pop_Composite_Child call.

   --  A composite child is a child that's an implementation detail of the

   --  container it's inside and should not be visible to people using the

   --  container. Composite children aren't treated differently by GTK (but see

   --  Gtk.Container.Foreach vs. Gtk.Container.Forall), but e.g. GUI builders

   --  might want to treat them in a different way.

   --  Here is a simple example: |[ gtk_widget_push_composite_child ();

   --  scrolled_window->hscrollbar = gtk_scrollbar_new

   --  (GTK_ORIENTATION_HORIZONTAL, hadjustment); gtk_widget_set_composite_name

   --  (scrolled_window->hscrollbar, "hscrollbar");

   --  gtk_widget_pop_composite_child (); gtk_widget_set_parent

   --  (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));

   --  g_object_ref (scrolled_window->hscrollbar); ]|

```
 
```

   procedure Transform_To_WindowTo API doc
To body

      (Cr     : Cairo.Cairo_ContextTo API doc
To spec;

       Widget : not null access Gtk_Widget_RecordTo API doc
To spec'Class;

       Window : Gdk.Gdk_WindowTo API doc
To spec);

   --  Transforms the given cairo context Cr that from Widget-relative

   --  coordinates to Window-relative coordinates. If the Widget's window is

   --  not an ancestor of Window, no modification will be applied.

   --  This is the inverse to the transformation GTK applies when preparing an

   --  expose event to be emitted with the Gtk.Widget.Gtk_Widget::draw signal.

   --  It is intended to help porting multiwindow widgets from GTK+ 2 to the

   --  rendering architecture of GTK+ 3.

```
   --  Since: gtk+ 3.0 
```

   --  "cr": the cairo context to transform

   --  "widget": the widget the context is currently centered for

   --  "window": the window to transform the context to

```
 
```

   function Should_Draw_WindowTo API doc
To body

      (Cr     : Cairo.Cairo_ContextTo API doc
To spec;

       Window : Gdk.Gdk_WindowTo API doc
To spec) return Boolean;

   --  This function is supposed to be called in Gtk.Widget.Gtk_Widget::draw

   --  implementations for widgets that support multiple windows. Cr must be

   --  untransformed from invoking of the draw function. This function will

   --  return True if the contents of the given Window are supposed to be drawn

   --  and False otherwise. Note that when the drawing was not initiated by the

   --  windowing system this function will return True for all windows, so you

   --  need to draw the bottommost window first. Also, do not use "else if"

   --  statements to check which window should be drawn.

```
   --  Since: gtk+ 3.0 
```
```
   --  "cr": a cairo context 
```

   --  "window": the window to check. Window may not be an input-only window.

```
 
```
```
   ---------------- 
```
```
   -- Properties -- 
```
```
   ---------------- 
```

   --  The following properties are defined for this widget. See

   --  Glib.Properties for more information on properties)

```
 
```

   App_Paintable_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Can_Default_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Can_Focus_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Composite_Child_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Double_Buffered_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether the widget is double buffered.

```
 
```

   Events_Property : constant Gdk.Event.Property_Gdk_Event_MaskTo API doc
To spec;

```
   --  Type: Gdk.Event.Gdk_Event_Mask 
```
```
 
```

   Expand_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether to expand in both directions. Setting this sets both

   --  Gtk.Widget.Gtk_Widget:hexpand and Gtk.Widget.Gtk_Widget:vexpand

```
 
```

   Halign_Property : constant Gtk.Widget.Property_Gtk_AlignTo API doc
To spec;

```
   --  Type: Gtk_Align 
```

   --  How to distribute horizontal space if widget gets extra space, see

```
   --  Gtk.Widget.Gtk_Align 
```
```
 
```

   Has_Default_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Has_Focus_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Has_Tooltip_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Enables or disables the emission of

   --  Gtk.Widget.Gtk_Widget::query-tooltip on Widget. A value of True

   --  indicates that Widget can have a tooltip, in this case the widget will

   --  be queried using Gtk.Widget.Gtk_Widget::query-tooltip to determine

   --  whether it will provide a tooltip or not.

```
   -- 
```

   --  Note that setting this property to True for the first time will change

   --  the event masks of the GdkWindows of this widget to include leave-notify

   --  and motion-notify events. This cannot and will not be undone when the

```
   --  property is set to False again. 
```
```
 
```

   Height_Request_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

```
 
```

   Hexpand_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether to expand horizontally. See Gtk.Widget.Set_Hexpand.

```
 
```

   Hexpand_Set_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether to use the Gtk.Widget.Gtk_Widget:hexpand property. See

```
   --  Gtk.Widget.Get_Hexpand_Set. 
```
```
 
```

   Is_Focus_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Margin_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

   --  Sets all four sides' margin at once. If read, returns max margin on any

```
   --  side. 
```
```
 
```

   Margin_Bottom_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

   --  Margin on bottom side of widget.

```
   -- 
```

   --  This property adds margin outside of the widget's normal size request,

   --  the margin will be added in addition to the size from

   --  Gtk.Widget.Set_Size_Request for example.

```
 
```

   Margin_Left_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

```
   --  Margin on left side of widget. 
```
```
   -- 
```

   --  This property adds margin outside of the widget's normal size request,

   --  the margin will be added in addition to the size from

   --  Gtk.Widget.Set_Size_Request for example.

```
 
```

   Margin_Right_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

```
   --  Margin on right side of widget. 
```
```
   -- 
```

   --  This property adds margin outside of the widget's normal size request,

   --  the margin will be added in addition to the size from

   --  Gtk.Widget.Set_Size_Request for example.

```
 
```

   Margin_Top_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

```
   --  Margin on top side of widget. 
```
```
   -- 
```

   --  This property adds margin outside of the widget's normal size request,

   --  the margin will be added in addition to the size from

   --  Gtk.Widget.Set_Size_Request for example.

```
 
```

   Name_Property : constant Glib.Properties.Property_StringTo API doc
To spec;

```
 
```

   No_Show_All_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Opacity_Property : constant Glib.Properties.Property_DoubleTo API doc
To spec;

```
   --  Type: Gdouble 
```

   --  The requested opacity of the widget. See Gtk.Widget.Set_Opacity for

   --  more details about window opacity.

```
   -- 
```

   --  Before 3.8 this was only availible in GtkWindow

```
 
```

   Parent_Property : constant Glib.Properties.Property_ObjectTo API doc
To spec;

   --  Type: Gtk.Container.Gtk_Container

```
 
```

   Receives_Default_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Sensitive_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Style_Property : constant Glib.Properties.Property_ObjectTo API doc
To spec;

```
   --  Type: Gtk.Style.Gtk_Style 
```
```
 
```

   Tooltip_Markup_Property : constant Glib.Properties.Property_StringTo API doc
To spec;

   --  Sets the text of tooltip to be the given string, which is marked up

   --  with the <link linkend="PangoMarkupFormat">Pango text markup

   --  language</link>. Also see Gtk.Tooltip.Set_Markup.

```
   -- 
```

   --  This is a convenience property which will take care of getting the

   --  tooltip shown if the given string is not null:

   --  Gtk.Widget.Gtk_Widget:has-tooltip will automatically be set to True and

   --  there will be taken care of Gtk.Widget.Gtk_Widget::query-tooltip in the

```
   --  default signal handler. 
```
```
 
```

   Tooltip_Text_Property : constant Glib.Properties.Property_StringTo API doc
To spec;

   --  Sets the text of tooltip to be the given string.

```
   -- 
```
```
   --  Also see Gtk.Tooltip.Set_Text. 
```
```
   -- 
```

   --  This is a convenience property which will take care of getting the

   --  tooltip shown if the given string is not null:

   --  Gtk.Widget.Gtk_Widget:has-tooltip will automatically be set to True and

   --  there will be taken care of Gtk.Widget.Gtk_Widget::query-tooltip in the

```
   --  default signal handler. 
```
```
 
```

   Valign_Property : constant Gtk.Widget.Property_Gtk_AlignTo API doc
To spec;

```
   --  Type: Gtk_Align 
```

   --  How to distribute vertical space if widget gets extra space, see

```
   --  Gtk.Widget.Gtk_Align 
```
```
 
```

   Vexpand_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether to expand vertically. See Gtk.Widget.Set_Vexpand.

```
 
```

   Vexpand_Set_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

   --  Whether to use the Gtk.Widget.Gtk_Widget:vexpand property. See

```
   --  Gtk.Widget.Get_Vexpand_Set. 
```
```
 
```

   Visible_Property : constant Glib.Properties.Property_BooleanTo API doc
To spec;

```
 
```

   Width_Request_Property : constant Glib.Properties.Property_IntTo API doc
To spec;

```
 
```

   Window_Property : constant Glib.Properties.Property_BoxedTo API doc
To spec;

```
   --  Type: Gdk.Window 
```

   --  The widget's window if it is realized, null otherwise.

```
 
```
```
   ------------- 
```
```
   -- Signals -- 
```
```
   ------------- 
```
```
 
```

   type Cb_Gtk_Widget_Void is not null access procedure (Self : access Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Void is not null access procedure

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class);

```
 
```

   Signal_Accel_Closures_Changed : constant Glib.Signal_NameTo API doc
To spec := "accel-closures-changed";

   procedure On_Accel_Closures_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Accel_Closures_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Button_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_ButtonTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Button_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_ButtonTo API doc
To spec) return Boolean;

```
 
```

   Signal_Button_Press_Event : constant Glib.Signal_NameTo API doc
To spec := "button-press-event";

   procedure On_Button_Press_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Button_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Button_Press_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Button_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::button-press-event signal will be emitted when a button

   --  (typically from a mouse) is pressed.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_BUTTON_PRESS_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Button which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Button_Release_Event : constant Glib.Signal_NameTo API doc
To spec := "button-release-event";

   procedure On_Button_Release_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Button_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Button_Release_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Button_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::button-release-event signal will be emitted when a button

   --  (typically from a mouse) is released.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_BUTTON_RELEASE_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Button which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Guint_Boolean is not null access function

     (Self      : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Signal_Id : GuintTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Guint_Boolean is not null access function

     (Self      : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Signal_Id : GuintTo API doc
To spec) return Boolean;

```
 
```

   Signal_Can_Activate_Accel : constant Glib.Signal_NameTo API doc
To spec := "can-activate-accel";

   procedure On_Can_Activate_AccelTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Guint_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Can_Activate_AccelTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Guint_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Determines whether an accelerator that activates the signal identified

   --  by Signal_Id can currently be activated. This signal is present to allow

   --  applications and derived widgets to override the default

   --  Gtk.Widget.Gtk_Widget handling for determining whether an accelerator

```
   --  can be activated. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "signal_id": the ID of a signal installed on Widget

   --    --  Returns True if the signal can be activated.

```
 
```

   type Cb_Gtk_Widget_Param_Spec_Void is not null access procedure

     (Self           : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Child_Property : Glib.Param_SpecTo API doc
To spec);

```
 
```

   type Cb_GObject_Param_Spec_Void is not null access procedure

     (Self           : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Child_Property : Glib.Param_SpecTo API doc
To spec);

```
 
```

   Signal_Child_Notify : constant Glib.Signal_NameTo API doc
To spec := "child-notify";

   procedure On_Child_NotifyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Param_Spec_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Child_NotifyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Param_Spec_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::child-notify signal is emitted for each <link

   --  linkend="child-properties">child property</link> that has changed on an

   --  object. The signal's detail holds the property name.

```
 
```

   Signal_Composited_Changed : constant Glib.Signal_NameTo API doc
To spec := "composited-changed";

   procedure On_Composited_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Composited_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::composited-changed signal is emitted when the composited status

   --  of Widget<!-- -->s screen changes. See Gdk.Screen.Is_Composited.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Configure_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_ConfigureTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Configure_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_ConfigureTo API doc
To spec) return Boolean;

```
 
```

   Signal_Configure_Event : constant Glib.Signal_NameTo API doc
To spec := "configure-event";

   procedure On_Configure_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Configure_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Configure_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Configure_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::configure-event signal will be emitted when the size, position or

   --  stacking of the Widget's window has changed.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask

   --  automatically for all new windows.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Configure which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Expose_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_ExposeTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Expose_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_ExposeTo API doc
To spec) return Boolean;

```
 
```

   Signal_Damage_Event : constant Glib.Signal_NameTo API doc
To spec := "damage-event";

   procedure On_Damage_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Expose_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Damage_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Expose_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Emitted when a redirected window belonging to Widget gets drawn into.

   --  The region/area members of the event shows what area of the redirected

```
   --  drawable was drawn into. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Expose event

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_EventTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_EventTo API doc
To spec) return Boolean;

```
 
```

   Signal_Delete_Event : constant Glib.Signal_NameTo API doc
To spec := "delete-event";

   procedure On_Delete_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Delete_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::delete-event signal is emitted if a user requests that a toplevel

   --  window is closed. The default handler for this signal destroys the

   --  window. Connecting Gtk.Widget.Hide_On_Delete to this signal will cause

   --  the window to be hidden instead, so that it can later be shown again

```
   --  without reconstructing it. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the event which triggered this signal

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Destroy : constant Glib.Signal_NameTo API doc
To spec := "destroy";

   procedure On_DestroyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_DestroyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Signals that all holders of a reference to the widget should release

   --  the reference that they hold. May result in finalization of the widget

```
   --  if all references are released. 
```
```
 
```

   Signal_Destroy_Event : constant Glib.Signal_NameTo API doc
To spec := "destroy-event";

   procedure On_Destroy_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Destroy_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::destroy-event signal is emitted when a Gdk.Gdk_Window is

   --  destroyed. You rarely get this signal, because most widgets disconnect

   --  themselves from their window before they destroy it, so no widget owns

```
   --  the window at destroy time. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask

   --  automatically for all new windows.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the event which triggered this signal

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gtk_Text_Direction_Void is not null access procedure

     (Self               : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Previous_Direction : Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec);

```
 
```

   type Cb_GObject_Gtk_Text_Direction_Void is not null access procedure

     (Self               : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Previous_Direction : Gtk.Enums.Gtk_Text_DirectionTo API doc
To spec);

```
 
```

   Signal_Direction_Changed : constant Glib.Signal_NameTo API doc
To spec := "direction-changed";

   procedure On_Direction_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Text_Direction_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Direction_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Text_Direction_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::direction-changed signal is emitted when the text direction of a

```
   --  widget changes. 
```
```
 
```

   type Cb_Gtk_Widget_Drag_Context_Void is not null access procedure

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Drag_Context_Void is not null access procedure

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Drag_Begin : constant Glib.Signal_NameTo API doc
To spec := "drag-begin";

   procedure On_Drag_BeginTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_BeginTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-begin signal is emitted on the drag source when a drag is

   --  started. A typical reason to connect to this signal is to set up a

   --  custom drag icon with e.g. Gtk.Widget.Drag_Source_Set_Icon_Pixbuf.

```
   -- 
```

   --  Note that some widgets set up a drag icon in the default handler of

   --  this signal, so you may have to use g_signal_connect_after to override

```
   --  what the default handler did. 
```
```
 
```

   Signal_Drag_Data_Delete : constant Glib.Signal_NameTo API doc
To spec := "drag-data-delete";

   procedure On_Drag_Data_DeleteTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_Data_DeleteTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-data-delete signal is emitted on the drag source when a drag

   --  with the action Gdk.Drag_Contexts.Action_Move is successfully completed.

   --  The signal handler is responsible for deleting the data that has been

   --  dropped. What "delete" means depends on the context of the drag

```
   --  operation. 
```
```
 
```

   type Cb_Gtk_Widget_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Data    : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

      Info    : GuintTo API doc
To spec;

      Time    : GuintTo API doc
To spec);

```
 
```

   type Cb_GObject_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Data    : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

      Info    : GuintTo API doc
To spec;

      Time    : GuintTo API doc
To spec);

```
 
```

   Signal_Drag_Data_Get : constant Glib.Signal_NameTo API doc
To spec := "drag-data-get";

   procedure On_Drag_Data_GetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_Data_GetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-data-get signal is emitted on the drag source when the drop

   --  site requests the data which is dragged. It is the responsibility of the

   --  signal handler to fill Data with the data in the format which is

   --  indicated by Info. See gtk_selection_data_set and

```
   --  Gtk.Selection_Data.Set_Text. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "data": the Gtk.Selection_Data.Gtk_Selection_Data to be filled with the

```
   --    --  dragged data 
```

   --    --  "info": the info that has been registered with the target in the

   --    --  Gtk.Target_List.Gtk_Target_List

   --    --  "time": the timestamp at which the data was requested

```
 
```

   type Cb_Gtk_Widget_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

```
      X       : GintTo API doc
To spec; 
```
```
      Y       : GintTo API doc
To spec; 
```

      Data    : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

      Info    : GuintTo API doc
To spec;

      Time    : GuintTo API doc
To spec);

```
 
```

   type Cb_GObject_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

```
      X       : GintTo API doc
To spec; 
```
```
      Y       : GintTo API doc
To spec; 
```

      Data    : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

      Info    : GuintTo API doc
To spec;

      Time    : GuintTo API doc
To spec);

```
 
```

   Signal_Drag_Data_Received : constant Glib.Signal_NameTo API doc
To spec := "drag-data-received";

   procedure On_Drag_Data_ReceivedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_Data_ReceivedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-data-received signal is emitted on the drop site when the

   --  dragged data has been received. If the data was received in order to

   --  determine whether the drop will be accepted, the handler is expected to

   --  call gdk_drag_status and *not* finish the drag. If the data was received

   --  in response to a Gtk.Widget.Gtk_Widget::drag-drop signal (and this is

   --  the last target to be received), the handler for this signal is expected

   --  to process the received data and then call gtk_drag_finish, setting the

   --  Success parameter depending on whether the data was processed

```
   --  successfully. 
```
```
   -- 
```

   --  The handler may inspect the selected action with

   --  Gdk.Drag_Contexts.Get_Selected_Action before calling gtk_drag_finish,

   --  e.g. to implement Gdk.Drag_Contexts.Action_Ask as shown in the following

   --  example: |[ void drag_data_received (GtkWidget *widget, GdkDragContext

   --  *context, gint x, gint y, GtkSelectionData *data, guint info, guint

   --  time) { if ((data->length >= 0) && (data->format == 8)) { GdkDragAction

```
   --  action; 
```
```
   -- 
```
```
   --  /* handle data here */ 
```
```
   -- 
```

   --  action = gdk_drag_context_get_selected_action (context); if (action ==

   --  GDK_ACTION_ASK) { GtkWidget *dialog; gint response;

```
   -- 
```

   --  dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL |

   --  GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_YES_NO,

   --  "Move the data ?\n"); response = gtk_dialog_run (GTK_DIALOG (dialog));

```
   --  gtk_widget_destroy (dialog); 
```
```
   -- 
```

   --  if (response == GTK_RESPONSE_YES) action = GDK_ACTION_MOVE; else action

```
   --  = GDK_ACTION_COPY; } 
```
```
   -- 
```

   --  gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time); }

   --  else gtk_drag_finish (context, FALSE, FALSE, time); } ]|

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "x": where the drop happened

   --    --  "y": where the drop happened

```
   --    --  "data": the received data 
```

   --    --  "info": the info that has been registered with the target in the

   --    --  Gtk.Target_List.Gtk_Target_List

   --    --  "time": the timestamp at which the data was received

```
 
```

   type Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_Boolean is not null access function

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

```
      X       : GintTo API doc
To spec; 
```
```
      Y       : GintTo API doc
To spec; 
```

      Time    : GuintTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Drag_Context_Gint_Gint_Guint_Boolean is not null access function

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

```
      X       : GintTo API doc
To spec; 
```
```
      Y       : GintTo API doc
To spec; 
```

      Time    : GuintTo API doc
To spec) return Boolean;

```
 
```

   Signal_Drag_Drop : constant Glib.Signal_NameTo API doc
To spec := "drag-drop";

   procedure On_Drag_DropTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_DropTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Gint_Gint_Guint_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-drop signal is emitted on the drop site when the user drops

   --  the data onto the widget. The signal handler must determine whether the

   --  cursor position is in a drop zone or not. If it is not in a drop zone,

   --  it returns False and no further processing is necessary. Otherwise, the

   --  handler returns True. In this case, the handler must ensure that

   --  gtk_drag_finish is called to let the source know that the drop is done.

   --  The call to gtk_drag_finish can be done either directly or in a

   --  Gtk.Widget.Gtk_Widget::drag-data-received handler which gets triggered

   --  by calling Gtk.Widget.Drag_Get_Data to receive the data for one or more

```
   --  of the supported targets. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "x": the x coordinate of the current cursor position

   --    --  "y": the y coordinate of the current cursor position

   --    --  "time": the timestamp of the motion event

   --    --  Returns whether the cursor position is in a drop zone

```
 
```

   Signal_Drag_End : constant Glib.Signal_NameTo API doc
To spec := "drag-end";

   procedure On_Drag_EndTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_EndTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-end signal is emitted on the drag source when a drag is

   --  finished. A typical reason to connect to this signal is to undo things

   --  done in Gtk.Widget.Gtk_Widget::drag-begin.

```
 
```

   type Cb_Gtk_Widget_Drag_Context_Gtk_Drag_Result_Boolean is not null access function

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Result  : Gtk.Enums.Gtk_Drag_ResultTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Drag_Context_Gtk_Drag_Result_Boolean is not null access function

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Result  : Gtk.Enums.Gtk_Drag_ResultTo API doc
To spec) return Boolean;

```
 
```

   Signal_Drag_Failed : constant Glib.Signal_NameTo API doc
To spec := "drag-failed";

   procedure On_Drag_FailedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Gtk_Drag_Result_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_FailedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Gtk_Drag_Result_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-failed signal is emitted on the drag source when a drag has

   --  failed. The signal handler may hook custom code to handle a failed DND

   --  operation based on the type of error, it returns True is the failure has

   --  been already handled (not showing the default "drag operation failed"

   --  animation), otherwise it returns False.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "result": the result of the drag operation

   --    --  Returns True if the failed drag operation has been already handled.

```
 
```

   type Cb_Gtk_Widget_Drag_Context_Guint_Void is not null access procedure

     (Self    : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Time    : GuintTo API doc
To spec);

```
 
```

   type Cb_GObject_Drag_Context_Guint_Void is not null access procedure

     (Self    : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Context : not null access Gdk.Drag_Contexts.Drag_Context_RecordTo API doc
To spec'Class;

      Time    : GuintTo API doc
To spec);

```
 
```

   Signal_Drag_Leave : constant Glib.Signal_NameTo API doc
To spec := "drag-leave";

   procedure On_Drag_LeaveTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Guint_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_LeaveTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Guint_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-leave signal is emitted on the drop site when the cursor

   --  leaves the widget. A typical reason to connect to this signal is to undo

   --  things done in Gtk.Widget.Gtk_Widget::drag-motion, e.g. undo

   --  highlighting with Gtk.Widget.Drag_Unhighlight

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "time": the timestamp of the motion event

```
 
```

   Signal_Drag_Motion : constant Glib.Signal_NameTo API doc
To spec := "drag-motion";

   procedure On_Drag_MotionTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Drag_MotionTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Drag_Context_Gint_Gint_Guint_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::drag-motion signal is emitted on the drop site when the user

   --  moves the cursor over the widget during a drag. The signal handler must

   --  determine whether the cursor position is in a drop zone or not. If it is

   --  not in a drop zone, it returns False and no further processing is

   --  necessary. Otherwise, the handler returns True. In this case, the

   --  handler is responsible for providing the necessary information for

   --  displaying feedback to the user, by calling gdk_drag_status.

```
   -- 
```

   --  If the decision whether the drop will be accepted or rejected can't be

   --  made based solely on the cursor position and the type of the data, the

   --  handler may inspect the dragged data by calling Gtk.Widget.Drag_Get_Data

   --  and defer the gdk_drag_status call to the

   --  Gtk.Widget.Gtk_Widget::drag-data-received handler. Note that you cannot

   --  not pass GTK_DEST_DEFAULT_DROP, GTK_DEST_DEFAULT_MOTION or

   --  GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set when using the drag-motion

```
   --  signal that way. 
```
```
   -- 
```

   --  Also note that there is no drag-enter signal. The drag receiver has to

   --  keep track of whether he has received any drag-motion signals since the

   --  last Gtk.Widget.Gtk_Widget::drag-leave and if not, treat the drag-motion

   --  signal as an "enter" signal. Upon an "enter", the handler will typically

   --  highlight the drop site with Gtk.Widget.Drag_Highlight. |[ static void

   --  drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y,

```
   --  guint time) { GdkAtom target; 
```
```
   -- 
```

   --  PrivateData *private_data = GET_PRIVATE_DATA (widget);

```
   -- 
```

   --  if (!private_data->drag_highlight) { private_data->drag_highlight = 1;

```
   --  gtk_drag_highlight (widget); } 
```
```
   -- 
```

   --  target = gtk_drag_dest_find_target (widget, context, NULL); if (target

   --  == GDK_NONE) gdk_drag_status (context, 0, time); else {

   --  private_data->pending_status = gdk_drag_context_get_suggested_action

   --  (context); gtk_drag_get_data (widget, context, target, time); }

```
   -- 
```
```
   --  return TRUE; } 
```
```
   -- 
```

   --  static void drag_data_received (GtkWidget *widget, GdkDragContext

   --  *context, gint x, gint y, GtkSelectionData *selection_data, guint info,

   --  guint time) { PrivateData *private_data = GET_PRIVATE_DATA (widget);

```
   -- 
```

   --  if (private_data->suggested_action) { private_data->suggested_action =

```
   --  0; 
```
```
   -- 
```

   --  /* We are getting this data due to a request in drag_motion, * rather

   --  than due to a request in drag_drop, so we are just * supposed to call

   --  gdk_drag_status, not actually paste in * the data. */ str =

   --  gtk_selection_data_get_text (selection_data); if (!data_is_acceptable

   --  (str)) gdk_drag_status (context, 0, time); else gdk_drag_status

   --  (context, private_data->suggested_action, time); } else { /* accept the

```
   --  drop */ } } ]| 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "context": the drag context

   --    --  "x": the x coordinate of the current cursor position

   --    --  "y": the y coordinate of the current cursor position

   --    --  "time": the timestamp of the motion event

   --    --  Returns whether the cursor position is in a drop zone

```
 
```

   type Cb_Gtk_Widget_Cairo_Context_Boolean is not null access function

     (Self : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Cr   : Cairo.Cairo_ContextTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Cairo_Context_Boolean is not null access function

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Cr   : Cairo.Cairo_ContextTo API doc
To spec) return Boolean;

```
 
```

   Signal_Draw : constant Glib.Signal_NameTo API doc
To spec := "draw";

```
   procedure On_DrawTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Cairo_Context_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_DrawTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Cairo_Context_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  This signal is emitted when a widget is supposed to render itself. The

   --  Widget's top left corner must be painted at the origin of the passed in

   --  context and be sized to the values returned by

   --  Gtk.Widget.Get_Allocated_Width and Gtk.Widget.Get_Allocated_Height.

```
   -- 
```

   --  Signal handlers connected to this signal can modify the cairo context

   --  passed as Cr in any way they like and don't need to restore it. The

   --  signal emission takes care of calling cairo_save before and

   --  cairo_restore after invoking the handler.

```
   -- 
```

   --  The signal handler will get a Cr with a clip region already set to the

   --  widget's dirty region, i.e. to the area that needs repainting.

   --  Complicated widgets that want to avoid redrawing themselves completely

   --  can get the full extents of the clip region with

   --  gdk_cairo_get_clip_rectangle, or they can get a finer-grained

   --  representation of the dirty region with cairo_copy_clip_rectangle_list.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "cr": the cairo context to draw to

   --    --  Returns True to stop other handlers from being invoked for the event. % False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Crossing_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_CrossingTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Crossing_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_CrossingTo API doc
To spec) return Boolean;

```
 
```

   Signal_Enter_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "enter-notify-event";

   procedure On_Enter_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Crossing_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Enter_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Crossing_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::enter-notify-event will be emitted when the pointer enters the

```
   --  Widget's window. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_ENTER_NOTIFY_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Crossing which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Event : constant Glib.Signal_NameTo API doc
To spec := "event";

```
   procedure On_EventTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_EventTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The GTK+ main loop will emit three signals for each GDK event delivered

   --  to a widget: one generic ::event signal, another, more specific, signal

   --  that matches the type of event delivered (e.g.

   --  Gtk.Widget.Gtk_Widget::key-press-event) and finally a generic

   --  Gtk.Widget.Gtk_Widget::event-after signal.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event which triggered this signal

   --    --  Returns True to stop other handlers from being invoked for the event and to cancel the emission of the second specific ::event signal. False to propagate the event further and to allow the emission of the second signal. The ::event-after signal is emitted regardless of the return value.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Void is not null access procedure

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_EventTo API doc
To spec);

```
 
```

   type Cb_GObject_Gdk_Event_Void is not null access procedure

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_EventTo API doc
To spec);

```
 
```

   Signal_Event_After : constant Glib.Signal_NameTo API doc
To spec := "event-after";

   procedure On_Event_AfterTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Event_AfterTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  After the emission of the Gtk.Widget.Gtk_Widget::event signal and

   --  (optionally) the second more specific signal, ::event-after will be

   --  emitted regardless of the previous two signals handlers return values.

```
 
```

   type Cb_Gtk_Widget_Gtk_Direction_Type_Boolean is not null access function

     (Self      : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Direction : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gtk_Direction_Type_Boolean is not null access function

     (Self      : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Direction : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec) return Boolean;

```
 
```

   Signal_Focus : constant Glib.Signal_NameTo API doc
To spec := "focus";

```
   procedure On_FocusTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Direction_Type_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_FocusTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Direction_Type_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Focus_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_FocusTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Focus_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_FocusTo API doc
To spec) return Boolean;

```
 
```

   Signal_Focus_In_Event : constant Glib.Signal_NameTo API doc
To spec := "focus-in-event";

   procedure On_Focus_In_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Focus_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Focus_In_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Focus_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::focus-in-event signal will be emitted when the keyboard focus

```
   --  enters the Widget's window. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_FOCUS_CHANGE_MASK mask.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Focus which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Focus_Out_Event : constant Glib.Signal_NameTo API doc
To spec := "focus-out-event";

   procedure On_Focus_Out_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Focus_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Focus_Out_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Focus_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::focus-out-event signal will be emitted when the keyboard focus

```
   --  leaves the Widget's window. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_FOCUS_CHANGE_MASK mask.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Focus which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Grab_Broken_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_Grab_BrokenTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Grab_Broken_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_Grab_BrokenTo API doc
To spec) return Boolean;

```
 
```

   Signal_Grab_Broken_Event : constant Glib.Signal_NameTo API doc
To spec := "grab-broken-event";

   procedure On_Grab_Broken_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Grab_Broken_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Grab_Broken_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Grab_Broken_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Emitted when a pointer or keyboard grab on a window belonging to Widget

```
   --  gets broken. 
```
```
   -- 
```

   --  On X11, this happens when the grab window becomes unviewable (i.e. it

   --  or one of its ancestors is unmapped), or if the same application grabs

```
   --  the pointer or keyboard again. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Grab_Broken event

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Grab_Focus : constant Glib.Signal_NameTo API doc
To spec := "grab-focus";

   procedure On_Grab_FocusTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Grab_FocusTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Boolean_Void is not null access procedure

     (Self        : access Gtk_Widget_RecordTo API doc
To spec'Class;

```
      Was_Grabbed : Boolean); 
```
```
 
```

   type Cb_GObject_Boolean_Void is not null access procedure

     (Self        : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
      Was_Grabbed : Boolean); 
```
```
 
```

   Signal_Grab_Notify : constant Glib.Signal_NameTo API doc
To spec := "grab-notify";

   procedure On_Grab_NotifyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Boolean_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Grab_NotifyTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Boolean_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::grab-notify signal is emitted when a widget becomes shadowed by a

   --  GTK+ grab (not a pointer or keyboard grab) on another widget, or when it

   --  becomes unshadowed due to a grab being removed.

```
   -- 
```

   --  A widget is shadowed by a Gtk.Widget.Grab_Add when the topmost grab

   --  widget in the grab stack of its window group is not its ancestor.

```
 
```

   Signal_Hide : constant Glib.Signal_NameTo API doc
To spec := "hide";

```
   procedure On_HideTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_HideTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gtk_Widget_Void is not null access procedure

     (Self              : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Previous_Toplevel : access Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gtk_Widget_Void is not null access procedure

     (Self              : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Previous_Toplevel : access Gtk_Widget_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Hierarchy_Changed : constant Glib.Signal_NameTo API doc
To spec := "hierarchy-changed";

   procedure On_Hierarchy_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Hierarchy_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Widget_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::hierarchy-changed signal is emitted when the anchored state of a

   --  widget changes. A widget is 'anchored' when its toplevel ancestor is a

   --  Gtk.Window.Gtk_Window. This signal is emitted when a widget changes from

   --  un-anchored to anchored or vice-versa.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Key_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_KeyTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Key_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_KeyTo API doc
To spec) return Boolean;

```
 
```

   Signal_Key_Press_Event : constant Glib.Signal_NameTo API doc
To spec := "key-press-event";

   procedure On_Key_Press_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Key_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Key_Press_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Key_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::key-press-event signal is emitted when a key is pressed. The

   --  signal emission will reoccur at the key-repeat rate when the key is kept

```
   --  pressed. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_KEY_PRESS_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Key which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Key_Release_Event : constant Glib.Signal_NameTo API doc
To spec := "key-release-event";

   procedure On_Key_Release_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Key_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Key_Release_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Key_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::key-release-event signal is emitted when a key is released.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_KEY_RELEASE_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Key which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Keynav_Failed : constant Glib.Signal_NameTo API doc
To spec := "keynav-failed";

   procedure On_Keynav_FailedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Direction_Type_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Keynav_FailedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Direction_Type_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Gets emitted if keyboard navigation fails. See Gtk.Widget.Keynav_Failed

```
   --  for details. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "direction": the direction of movement

   --    --  Returns True if stopping keyboard navigation is fine, False if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

```
 
```

   Signal_Leave_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "leave-notify-event";

   procedure On_Leave_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Crossing_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Leave_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Crossing_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::leave-notify-event will be emitted when the pointer leaves the

```
   --  Widget's window. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_LEAVE_NOTIFY_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Crossing which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Map : constant Glib.Signal_NameTo API doc
To spec := "map";

```
   procedure On_MapTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_MapTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Any_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_AnyTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Any_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_AnyTo API doc
To spec) return Boolean;

```
 
```

   Signal_Map_Event : constant Glib.Signal_NameTo API doc
To spec := "map-event";

   procedure On_Map_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Any_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Map_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Any_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::map-event signal will be emitted when the Widget's window is

   --  mapped. A window is mapped when it becomes visible on the screen.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask

   --  automatically for all new windows.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Any which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Boolean_Boolean is not null access function

     (Self : access Gtk_Widget_RecordTo API doc
To spec'Class;

```
      Arg1 : Boolean) return Boolean; 
```
```
 
```

   type Cb_GObject_Boolean_Boolean is not null access function

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
      Arg1 : Boolean) return Boolean; 
```
```
 
```

   Signal_Mnemonic_Activate : constant Glib.Signal_NameTo API doc
To spec := "mnemonic-activate";

   procedure On_Mnemonic_ActivateTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Boolean_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Mnemonic_ActivateTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Boolean_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Motion_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_MotionTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Motion_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_MotionTo API doc
To spec) return Boolean;

```
 
```

   Signal_Motion_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "motion-notify-event";

   procedure On_Motion_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Motion_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Motion_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Motion_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::motion-notify-event signal is emitted when the pointer moves over

```
   --  the widget's Gdk.Gdk_Window. 
```
```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_POINTER_MOTION_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Motion which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gtk_Direction_Type_Void is not null access procedure

     (Self      : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Direction : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec);

```
 
```

   type Cb_GObject_Gtk_Direction_Type_Void is not null access procedure

     (Self      : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Direction : Gtk.Enums.Gtk_Direction_TypeTo API doc
To spec);

```
 
```

   Signal_Move_Focus : constant Glib.Signal_NameTo API doc
To spec := "move-focus";

   procedure On_Move_FocusTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Direction_Type_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Move_FocusTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Direction_Type_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   Signal_Parent_Set : constant Glib.Signal_NameTo API doc
To spec := "parent-set";

   procedure On_Parent_SetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Parent_SetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Widget_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::parent-set signal is emitted when a new parent has been set on a

```
   --  widget. 
```
```
 
```

   type Cb_Gtk_Widget_Boolean is not null access function

     (Self : access Gtk_Widget_RecordTo API doc
To spec'Class) return Boolean;

```
 
```

   type Cb_GObject_Boolean is not null access function

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class)

```
   return Boolean; 
```
```
 
```

   Signal_Popup_Menu : constant Glib.Signal_NameTo API doc
To spec := "popup-menu";

   procedure On_Popup_MenuTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Popup_MenuTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  This signal gets emitted whenever a widget should pop up a context

   --  menu. This usually happens through the standard key binding mechanism;

   --  by pressing a certain key while a widget is focused, the user can cause

   --  the widget to pop up a menu. For example, the Gtk.GEntry.Gtk_Entry

   --  widget creates a menu with clipboard commands. See <xref

   --  linkend="checklist-popup-menu"/> for an example of how to use this

```
   --  signal. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  Returns True if a menu was activated

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Property_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_PropertyTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Property_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_PropertyTo API doc
To spec) return Boolean;

```
 
```

   Signal_Property_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "property-notify-event";

   procedure On_Property_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Property_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Property_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Property_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::property-notify-event signal will be emitted when a property on

   --  the Widget's window has been changed or deleted.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_PROPERTY_CHANGE_MASK mask.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Property which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Proximity_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_ProximityTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Proximity_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_ProximityTo API doc
To spec) return Boolean;

```
 
```

   Signal_Proximity_In_Event : constant Glib.Signal_NameTo API doc
To spec := "proximity-in-event";

   procedure On_Proximity_In_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Proximity_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Proximity_In_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Proximity_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  To receive this signal the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_PROXIMITY_IN_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Proximity which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Proximity_Out_Event : constant Glib.Signal_NameTo API doc
To spec := "proximity-out-event";

   procedure On_Proximity_Out_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Proximity_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Proximity_Out_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Proximity_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  To receive this signal the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_PROXIMITY_OUT_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Proximity which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gint_Gint_Boolean_GObject_Boolean is not null access function

     (Self          : access Gtk_Widget_RecordTo API doc
To spec'Class;

      X             : GintTo API doc
To spec;

      Y             : GintTo API doc
To spec;

```
      Keyboard_Mode : Boolean; 
```

      Tooltip       : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class)

```
   return Boolean; 
```
```
 
```

   type Cb_GObject_Gint_Gint_Boolean_GObject_Boolean is not null access function

     (Self          : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      X             : GintTo API doc
To spec;

      Y             : GintTo API doc
To spec;

```
      Keyboard_Mode : Boolean; 
```

      Tooltip       : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class)

```
   return Boolean; 
```
```
 
```

   Signal_Query_Tooltip : constant Glib.Signal_NameTo API doc
To spec := "query-tooltip";

   procedure On_Query_TooltipTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gint_Gint_Boolean_GObject_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Query_TooltipTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gint_Gint_Boolean_GObject_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  Emitted when Gtk.Widget.Gtk_Widget:has-tooltip is True and the

   --  Gtk.Settings.Gtk_Settings:gtk-tooltip-timeout has expired with the

   --  cursor hovering "above" Widget; or emitted when Widget got focus in

```
   --  keyboard mode. 
```
```
   -- 
```

   --  Using the given coordinates, the signal handler should determine

   --  whether a tooltip should be shown for Widget. If this is the case True

   --  should be returned, False otherwise. Note that if Keyboard_Mode is True,

   --  the values of X and Y are undefined and should not be used.

```
   -- 
```

   --  The signal handler is free to manipulate Tooltip with the therefore

```
   --  destined function calls. 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "x": the x coordinate of the cursor position where the request has been

   --    --  emitted, relative to Widget's left side

   --    --  "y": the y coordinate of the cursor position where the request has been

   --    --  emitted, relative to Widget's top

   --    --  "keyboard_mode": True if the tooltip was trigged using the keyboard

   --    --  "tooltip": a Gtk.Tooltip.Gtk_Tooltip

   --    --  Returns True if Tooltip should be shown right now, False otherwise.

```
 
```

   Signal_Realize : constant Glib.Signal_NameTo API doc
To spec := "realize";

   procedure On_RealizeTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_RealizeTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gdk_Screen_Void is not null access procedure

     (Self            : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Previous_Screen : access Gdk.Screen.Gdk_Screen_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gdk_Screen_Void is not null access procedure

     (Self            : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Previous_Screen : access Gdk.Screen.Gdk_Screen_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Screen_Changed : constant Glib.Signal_NameTo API doc
To spec := "screen-changed";

   procedure On_Screen_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Screen_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Screen_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Screen_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::screen-changed signal gets emitted when the screen of a widget

```
   --  has changed. 
```
```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Scroll_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_ScrollTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Scroll_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_ScrollTo API doc
To spec) return Boolean;

```
 
```

   Signal_Scroll_Event : constant Glib.Signal_NameTo API doc
To spec := "scroll-event";

   procedure On_Scroll_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Scroll_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Scroll_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Scroll_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::scroll-event signal is emitted when a button in the 4 to 7 range

   --  is pressed. Wheel mice are usually configured to generate button press

   --  events for buttons 4 and 5 when the wheel is turned.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_SCROLL_MASK mask.

```
   -- 
```

   --  This signal will be sent to the grab widget if there is one.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Scroll which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Selection_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_SelectionTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Selection_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_SelectionTo API doc
To spec) return Boolean;

```
 
```

   Signal_Selection_Clear_Event : constant Glib.Signal_NameTo API doc
To spec := "selection-clear-event";

   procedure On_Selection_Clear_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Selection_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Selection_Clear_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Selection_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::selection-clear-event signal will be emitted when the the

   --  Widget's window has lost ownership of a selection.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Selection which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Data : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

```
      Info : GuintTo API doc
To spec; 
```
```
      Time : GuintTo API doc
To spec); 
```
```
 
```

   type Cb_GObject_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Data : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

```
      Info : GuintTo API doc
To spec; 
```
```
      Time : GuintTo API doc
To spec); 
```
```
 
```

   Signal_Selection_Get : constant Glib.Signal_NameTo API doc
To spec := "selection-get";

   procedure On_Selection_GetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Selection_GetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Selection_Data_Guint_Guint_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```
```
 
```

   Signal_Selection_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "selection-notify-event";

   procedure On_Selection_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Selection_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Selection_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Selection_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Void is not null access procedure

     (Self : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Data : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

```
      Time : GuintTo API doc
To spec); 
```
```
 
```

   type Cb_GObject_Gtk_Selection_Data_Guint_Void is not null access procedure

     (Self : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Data : Gtk.Selection_Data.Gtk_Selection_DataTo API doc
To spec;

```
      Time : GuintTo API doc
To spec); 
```
```
 
```

   Signal_Selection_Received : constant Glib.Signal_NameTo API doc
To spec := "selection-received";

   procedure On_Selection_ReceivedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Selection_Data_Guint_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Selection_ReceivedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Selection_Data_Guint_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```
```
 
```

   Signal_Selection_Request_Event : constant Glib.Signal_NameTo API doc
To spec := "selection-request-event";

   procedure On_Selection_Request_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Selection_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Selection_Request_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Selection_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::selection-request-event signal will be emitted when another

   --  client requests ownership of the selection owned by the Widget's window.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Selection which triggered this signal.

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Show : constant Glib.Signal_NameTo API doc
To spec := "show";

```
   procedure On_ShowTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_ShowTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gtk_Widget_Help_Type_Boolean is not null access function

     (Self      : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Help_Type : Gtk_Widget_Help_TypeTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gtk_Widget_Help_Type_Boolean is not null access function

     (Self      : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Help_Type : Gtk_Widget_Help_TypeTo API doc
To spec) return Boolean;

```
 
```

   Signal_Show_Help : constant Glib.Signal_NameTo API doc
To spec := "show-help";

   procedure On_Show_HelpTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Widget_Help_Type_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Show_HelpTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Widget_Help_Type_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
   --  
```
```
   --  Callback parameters: 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Cairo_Rectangle_Int_Void is not null access procedure

     (Self       : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Allocation : Cairo.Region.Cairo_Rectangle_IntTo API doc
To spec);

```
 
```

   type Cb_GObject_Cairo_Rectangle_Int_Void is not null access procedure

     (Self       : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Allocation : Cairo.Region.Cairo_Rectangle_IntTo API doc
To spec);

```
 
```

   Signal_Size_Allocate : constant Glib.Signal_NameTo API doc
To spec := "size-allocate";

   procedure On_Size_AllocateTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Cairo_Rectangle_Int_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Size_AllocateTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Cairo_Rectangle_Int_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gtk_State_Type_Void is not null access procedure

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      State : Gtk.Enums.Gtk_State_TypeTo API doc
To spec);

```
 
```

   type Cb_GObject_Gtk_State_Type_Void is not null access procedure

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      State : Gtk.Enums.Gtk_State_TypeTo API doc
To spec);

```
 
```

   Signal_State_Changed : constant Glib.Signal_NameTo API doc
To spec := "state-changed";

   procedure On_State_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_State_Type_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_State_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_State_Type_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::state-changed signal is emitted when the widget state changes.

```
   --  See Gtk.Widget.Get_State. 
```
```
 
```

   type Cb_Gtk_Widget_Gtk_State_Flags_Void is not null access procedure

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Flags : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec);

```
 
```

   type Cb_GObject_Gtk_State_Flags_Void is not null access procedure

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Flags : Gtk.Enums.Gtk_State_FlagsTo API doc
To spec);

```
 
```

   Signal_State_Flags_Changed : constant Glib.Signal_NameTo API doc
To spec := "state-flags-changed";

   procedure On_State_Flags_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_State_Flags_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_State_Flags_ChangedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_State_Flags_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::state-flags-changed signal is emitted when the widget state

   --  changes, see Gtk.Widget.Get_State_Flags.

```
 
```

   type Cb_Gtk_Widget_Gtk_Style_Void is not null access procedure

     (Self           : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Previous_Style : access Gtk.Style.Gtk_Style_RecordTo API doc
To spec'Class);

```
 
```

   type Cb_GObject_Gtk_Style_Void is not null access procedure

     (Self           : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Previous_Style : access Gtk.Style.Gtk_Style_RecordTo API doc
To spec'Class);

```
 
```

   Signal_Style_Set : constant Glib.Signal_NameTo API doc
To spec := "style-set";

   procedure On_Style_SetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gtk_Style_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Style_SetTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gtk_Style_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::style-set signal is emitted when a new style has been set on a

   --  widget. Note that style-modifying functions like Gtk.Widget.Modify_Base

   --  also cause this signal to be emitted.

```
   -- 
```

   --  Note that this signal is emitted for changes to the deprecated

   --  Gtk.Style.Gtk_Style. To track changes to the

   --  Gtk.Style_Context.Gtk_Style_Context associated with a widget, use the

   --  Gtk.Widget.Gtk_Widget::style-updated signal.

```
 
```

   Signal_Style_Updated : constant Glib.Signal_NameTo API doc
To spec := "style-updated";

   procedure On_Style_UpdatedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Style_UpdatedTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::style-updated signal is emitted when the

   --  Gtk.Style_Context.Gtk_Style_Context of a widget is changed. Note that

   --  style-modifying functions like Gtk.Widget.Override_Color also cause this

```
   --  signal to be emitted. 
```
```
 
```

   Signal_Touch_Event : constant Glib.Signal_NameTo API doc
To spec := "touch-event";

   procedure On_Touch_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Touch_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   Signal_Unmap : constant Glib.Signal_NameTo API doc
To spec := "unmap";

```
   procedure On_UnmapTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```
```
   procedure On_UnmapTo API doc
To body 
```

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   Signal_Unmap_Event : constant Glib.Signal_NameTo API doc
To spec := "unmap-event";

   procedure On_Unmap_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Any_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Unmap_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Any_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::unmap-event signal will be emitted when the Widget's window is

   --  unmapped. A window is unmapped when it becomes invisible on the screen.

```
   -- 
```

   --  To receive this signal, the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask

   --  automatically for all new windows.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Any which triggered this signal

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   Signal_Unrealize : constant Glib.Signal_NameTo API doc
To spec := "unrealize";

   procedure On_UnrealizeTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_VoidTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_UnrealizeTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_VoidTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```
```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Visibility_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_VisibilityTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Visibility_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_VisibilityTo API doc
To spec) return Boolean;

```
 
```

   Signal_Visibility_Notify_Event : constant Glib.Signal_NameTo API doc
To spec := "visibility-notify-event";

   procedure On_Visibility_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Visibility_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Visibility_Notify_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Visibility_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::visibility-notify-event will be emitted when the Widget's window

```
   --  is obscured or unobscured. 
```
```
   -- 
```

   --  To receive this signal the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_VISIBILITY_NOTIFY_MASK mask.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Visibility which triggered this

```
   --    --  signal. 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```

   type Cb_Gtk_Widget_Gdk_Event_Window_State_Boolean is not null access function

     (Self  : access Gtk_Widget_RecordTo API doc
To spec'Class;

      Event : Gdk.Event.Gdk_Event_Window_StateTo API doc
To spec) return Boolean;

```
 
```

   type Cb_GObject_Gdk_Event_Window_State_Boolean is not null access function

     (Self  : access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

      Event : Gdk.Event.Gdk_Event_Window_StateTo API doc
To spec) return Boolean;

```
 
```

   Signal_Window_State_Event : constant Glib.Signal_NameTo API doc
To spec := "window-state-event";

   procedure On_Window_State_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_Gtk_Widget_Gdk_Event_Window_State_BooleanTo API doc
To spec;

```
       After : Boolean := False); 
```

   procedure On_Window_State_EventTo API doc
To body

      (Self  : not null access Gtk_Widget_RecordTo API doc
To spec;

       Call  : Cb_GObject_Gdk_Event_Window_State_BooleanTo API doc
To spec;

       Slot  : not null access Glib.Object.GObject_RecordTo API doc
To spec
To body'Class;

```
       After : Boolean := False); 
```

   --  The ::window-state-event will be emitted when the state of the toplevel

   --  window associated to the Widget changes.

```
   -- 
```

   --  To receive this signal the Gdk.Gdk_Window associated to the widget

   --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask

   --  automatically for all new windows.

```
   --  
```
```
   --  Callback parameters: 
```

   --    --  "event": the Gdk.Event.Gdk_Event_Window_State which triggered this

```
   --    --  signal. 
```

   --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further.

```
 
```
```
private 
```

   Window_PropertyTo API doc
To spec : constant Glib.Properties.Property_BoxedTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("window");

   Width_Request_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("width-request");

   Visible_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("visible");

   Vexpand_Set_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("vexpand-set");

   Vexpand_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("vexpand");

   Valign_PropertyTo API doc
To spec : constant Gtk.Widget.Property_Gtk_AlignTo API doc
To spec :=

     Gtk.Widget.BuildTo API doc
To spec
To body ("valign");

   Tooltip_Text_PropertyTo API doc
To spec : constant Glib.Properties.Property_StringTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("tooltip-text");

   Tooltip_Markup_PropertyTo API doc
To spec : constant Glib.Properties.Property_StringTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("tooltip-markup");

   Style_PropertyTo API doc
To spec : constant Glib.Properties.Property_ObjectTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("style");

   Sensitive_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("sensitive");

   Receives_Default_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("receives-default");

   Parent_PropertyTo API doc
To spec : constant Glib.Properties.Property_ObjectTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("parent");

   Opacity_PropertyTo API doc
To spec : constant Glib.Properties.Property_DoubleTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("opacity");

   No_Show_All_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("no-show-all");

   Name_PropertyTo API doc
To spec : constant Glib.Properties.Property_StringTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("name");

   Margin_Top_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("margin-top");

   Margin_Right_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("margin-right");

   Margin_Left_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("margin-left");

   Margin_Bottom_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("margin-bottom");

   Margin_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("margin");

   Is_Focus_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("is-focus");

   Hexpand_Set_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("hexpand-set");

   Hexpand_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("hexpand");

   Height_Request_PropertyTo API doc
To spec : constant Glib.Properties.Property_IntTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("height-request");

   Has_Tooltip_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("has-tooltip");

   Has_Focus_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("has-focus");

   Has_Default_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("has-default");

   Halign_PropertyTo API doc
To spec : constant Gtk.Widget.Property_Gtk_AlignTo API doc
To spec :=

     Gtk.Widget.BuildTo API doc
To spec
To body ("halign");

   Expand_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("expand");

   Events_PropertyTo API doc
To spec : constant Gdk.Event.Property_Gdk_Event_MaskTo API doc
To spec :=

     Gdk.Event.BuildTo API doc
To spec
To body ("events");

   Double_Buffered_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("double-buffered");

   Composite_Child_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("composite-child");

   Can_Focus_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("can-focus");

   Can_Default_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("can-default");

   App_Paintable_PropertyTo API doc
To spec : constant Glib.Properties.Property_BooleanTo API doc
To spec :=

     Glib.Properties.BuildTo API doc
To spec
To body ("app-paintable");

end Gtk.WidgetTo API doc
To spec
To body;

Documentation