----------------------------------------------------------------------- -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2004 ACT-Europe -- -- -- -- This library is free software; you can redistribute it and/or -- -- modify it under the terms of the GNU General Public -- -- License as published by the Free Software Foundation; either -- -- version 2 of the License, or (at your option) any later version. -- -- -- -- This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of -- -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -- -- General Public License for more details. -- -- -- -- You should have received a copy of the GNU General Public -- -- License along with this library; if not, write to the -- -- Free Software Foundation, Inc., 59 Temple Place - Suite 330, -- -- Boston, MA 02111-1307, USA. -- -- -- -- As a special exception, if other files instantiate generics from -- -- this unit, or you link this unit with other files to produce an -- -- executable, this unit does not by itself cause the resulting -- -- executable to be covered by the GNU General Public License. This -- -- exception does not however invalidate any other reasons why the -- -- executable file might be covered by the GNU Public License. -- ----------------------------------------------------------------------- -- -- -- This widget is the base of the tree for displayable objects. -- (A displayable object is one which takes up some amount -- of screen real estate). It provides a common base and interface -- which actual widgets must adhere to. -- -- This package provides some services which might have been more appropriate -- in some other packages, but could not because of dependency circularities -- (there are for instance some functions relating to colors and colormaps). -- We have tried to reference these functions in the other packages as well. -- -- -- 1.3.11 with System; with Glib.Object; with Glib.Properties; with Glib.Glist; with Glib.GSlist; pragma Elaborate_All (Glib.GSlist); with Glib.Values; with Pango.Context; with Pango.Font; with Pango.Layout; with Gdk.Color; with Gdk.Event; with Gdk.Bitmap; with Gdk.Rectangle; with Gdk.Pixbuf; with Gdk.Types; with Gdk.Visual; with Gdk.Window; with Gtk.Accel_Group; with Gtk.Adjustment; with Gtk.Enums; with Gtk.Object; with Gtk.Style; package Gtk.Widget is type Gtk_Widget_Record is new Object.Gtk_Object_Record with private; type Gtk_Widget is access all Gtk_Widget_Record'Class; type Gtk_Requisition is record Width : Gint; Height : Gint; end record; -- Gtk_Requisition is the desired amount of screen real-estate a widget -- requests to the server. Its real allocated size might be different. -- See the section in the GtkAda user guide on how to create new widgets -- in Ada, and the examples/base_widget directory for an example on how to -- use this. pragma Convention (C, Gtk_Requisition); type Gtk_Requisition_Access is access all Gtk_Requisition; pragma Convention (C, Gtk_Requisition_Access); -- This type is used to create new widgets. type Gtk_Allocation is record X : Gint; Y : Gint; Width : Allocation_Int; Height : Allocation_Int; end record; -- Gtk_Allocation indicates a size and position a widget was allocated. -- See the section in the user guide on how to create new widgets for more -- information. pragma Convention (C, Gtk_Allocation); type Gtk_Allocation_Access is access all Gtk_Allocation; pragma Convention (C, Gtk_Allocation_Access); -- This type is used to create new widgets. function Get_Type return Glib.GType; -- Return the internal value associated with a Gtk_Widget. ------------------------- -- Widgets' life cycle -- ------------------------- procedure Destroy_Cb (Widget : access Gtk_Widget_Record'Class); -- This function should be used as a callback to destroy a widget. -- All it does is call Destroy on its argument, but its profile is -- compatible with the handlers found in Gtk.Handlers. -- procedure Unparent (Widget : access Gtk_Widget_Record'Class); -- This function is only for use in widget implementations. -- Should be called by implementations of the remove method -- on Gtk_Container, to dissociate a child from the container. -- Users should call Remove instead. -- This function might be dangereous: it correctly updates widget to -- reflect that it no longer belongs to its parent, however the parent -- keeps an internal pointer to the widget, which will result in a -- storage_error if you try to further access it. -- procedure Show (Widget : access Gtk_Widget_Record); -- Schedule the widget to be displayed on the screen when its parent is -- also shown (emits the "show" signal). -- If its ancestors are already mapped to the screen, then the widget is -- immediately displayed through a call to Map below. procedure Show_Now (Widget : access Gtk_Widget_Record); -- Show the widget. -- If it is an unmapped toplevel widget, wait for it to be mapped. This -- creates a recursive main_loop. procedure Hide (Widget : access Gtk_Widget_Record); -- Hide the widget from the screen (emits the "hide" signal). -- If Widget was visible, it is immediately hidden. -- If one of its ancestor is later shown on the screen, Widget won't -- appear. -- Note that on some window managers, including CDE, hiding an iconified -- window will not do anything. You should in addition call -- Gdk.Window.Withdraw to make sure the window is properly hidden. procedure Show_All (Widget : access Gtk_Widget_Record); -- Show Widget and all its children recursively. -- See also Set_Child_Visible below procedure Hide_All (Widget : access Gtk_Widget_Record); -- Hide Widget and all its children. -- Note that if you simply want to delete Widget from the screen, you can -- simply call the Hide subprogram on it. This procedure Hide_All should -- only be used if you want to unschedule a widget to be displayed later, -- not to remove an actual widget from the screen. -- See also Set_Child_Visible below. procedure Map (Widget : access Gtk_Widget_Record); -- Map a widget to the screen. -- A window is created for it on the screen (through a call to Realize) and -- Widget is then drawn on the screen (if its ancestors are also mapped). -- This function is recursive and will also map all the children of Widget. -- -- It is recommended to use the higher-level Show instead. procedure Unmap (Widget : access Gtk_Widget_Record); -- Unmap a widget from the screen. -- This results in the widget being hidden, but not destroyed. It can be -- shown again any time through a call to Map (provided its ancestors are -- also mapped). -- -- It is recommended to use the higher-level Hide instead. procedure Realize (Widget : access Gtk_Widget_Record); -- Create a window for Widget and its ancestors (emit the "realize" signal) -- This does not mean that the widget will appear on the screen, but -- resources such as colormaps, etc. become available. -- Some routines require that the widget is realized before any call. -- You must set the Event_Mask before calling this routine if you want to -- change it from its default value. procedure Unrealize (Widget : access Gtk_Widget_Record); -- Hide the widget from the screen and deletes the associated window. -- This does not destroy the widget itself, only its server-side -- resources. generic type Widget_Type is new Gtk_Widget_Record with private; with procedure Realize_Proc (Widget : access Widget_Type'Class); package Realize_Handling is procedure Set_Realize (Widget : access Gtk_Widget_Record'Class); -- Set the realize handler at the low level. -- This is needed to replace the default realize in new widgets. end Realize_Handling; function Hide_On_Delete (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Hide widget and return True. -- This function is intended to be used as a callback. procedure Set_Child_Visible (Widget : access Gtk_Widget_Record; Is_Visible : Boolean); -- Sets whether Widget should be mapped along with its parent when its -- parent is mapped and Widget has been shown with Show. -- -- "mapped" indicates the moment the window is actually shown on the -- screen. Show and Hide indicate your intention to show Widget on the -- scree or not, but if the parent of Widget is itself not shown at that -- time, the two commands Show and Hide have no immediate effect, and just -- set a flag to save your intent. -- Set_Child_Visible indicates that the widget shouldn't be part of the -- recursive processing done by Show_All and Hide_All on the parent. You -- have decided once and for all what the behavior should be, and you don't -- want it to be changed by future calls to Show_All and Hide_All. -- -- The child visibility can be set for widget before it is added to a -- container with 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 -- should generally not be called by an application. function Get_Child_Visible (Widget : access Gtk_Widget_Record) return Boolean; -- Return the value set by Set_Child_Visible ---------------------- -- Drawing a widget -- ---------------------- procedure Queue_Draw (Widget : access Gtk_Widget_Record); -- Add a drawing request to the event queue for the whole widget. -- This is more efficient than calling Draw directly, since GtkAda groups -- drawing requests as much as possible to speed up the drawing process. -- The actual drawing will take place as soon as GtkAda is not busy -- processing other events, but before idle events. procedure Queue_Draw_Area (Widget : access Gtk_Widget_Record; X : Gint; Y : Gint; Width : Gint; Height : Gint); -- Add a drawing request to the event queue for part of the widget. -- This is more efficient that calling Draw directly (see Queue_Draw). -- procedure Queue_Clear (Widget : access Gtk_Widget_Record); -- Add a clear request to the event queue for the whole widget. -- This is added to the same list as for Queue_Draw, and thus is coalesced -- as much as possible with other drawing requests. -- pragma Deprecated (Queue_Clear); procedure Queue_Clear_Area (Widget : access Gtk_Widget_Record; X : Gint; Y : Gint; Width : Gint; Height : Gint); -- Add a clear request to the event queue for part of the widget. -- This is added to the same list as for Queue_Draw, and thus is coalesced -- as much as possible with other drawing requests. -- pragma Deprecated (Queue_Clear_Area); -- procedure Queue_Resize (Widget : access Gtk_Widget_Record); -- Queue drawing requests after a resizing of the widget. -- This clears the widget, and its parent if any, so that everything is -- correctly redrawn. -- You should not have to call this function directly. -- For a Gtk_Window, check the procedure Gtk.Window.Resize instead. procedure Draw (Widget : access Gtk_Widget_Record; Area : Gdk.Rectangle.Gdk_Rectangle := Gdk.Rectangle.Full_Area); -- Emit a "draw" signal for a specific area of the widget. -- The visual aspect might be different whether the widget has the focus -- or not. -- pragma Deprecated (Draw); ----------------------- -- Size and position -- ----------------------- procedure Size_Request (Widget : access Gtk_Widget_Record; Requisition : in out Gtk_Requisition); -- Emit a "size_request" event for the widget procedure Set_Size_Request (Widget : access Gtk_Widget_Record; Width, Height : Gint := -1); -- Sets the minimum size of a widget; that is, the widget's size request -- will be Width by Height. You can use this function to force a widget to -- be either larger or smaller than it normally would be. -- -- In most cases, 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.Windo.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. -- -- Widgets can't actually be allocated a size less than 1 by 1, but -- you can pass 0,0 to this function to mean "as small as possible." procedure Size_Allocate (Widget : access Gtk_Widget_Record; Allocation : Gtk_Allocation); -- Emit a "size_allocate" event for the widget. -- Allocation'size is first constrained to a range between 1x1 and -- 32767x32767. -- A clear and draw request is also queued if required. function Get_Child_Requisition (Widget : access Gtk_Widget_Record) return Gtk_Requisition; -- Return the size requests by the widget. -- This is the ideal size for the widget, not necessarily its actual size. -- See the user guide's section on how to create new widgets for more -- information on the size requisition and allocation. procedure Set_UPosition (Widget : access Gtk_Widget_Record; X, Y : Gint); -- Modify the position of the widget. -- This should be used only for toplevel widgets (windows and dialogs), -- since other widgets' positions are handled by their parent. -- procedure Set_USize (Widget : access Gtk_Widget_Record; Width, Height : Gint); -- Modify the size of the widget. -- This sets an absolute size for the widget, no matter what its requested -- size would be. For Gtk_Windows, you should consider using -- Set_Default_Size instead, which sets a minimal size, but use the -- widget's requested size if it is bigger. -- If Width or Height is negative, they are ignored, and the widget's -- default width is kept. -- -- This procedure is now deprecated, and you should use Set_Size_Request -- instead. -- function Get_Allocation_Width (Widget : access Gtk_Widget_Record) return Allocation_Int; -- Return the current width of the widget. function Get_Allocation_Height (Widget : access Gtk_Widget_Record) return Allocation_Int; -- Return the current height of the widget. function Get_Allocation_X (Widget : access Gtk_Widget_Record) return Gint; -- Return the current position of the widget, relative to its parent. function Get_Allocation_Y (Widget : access Gtk_Widget_Record) return Gint; -- Return the current position of the widget, relative to its parent. ------------------ -- Accelerators -- ------------------ procedure Add_Accelerator (Widget : access Gtk_Widget_Record; Accel_Signal : String; Accel_Group : Gtk.Accel_Group.Gtk_Accel_Group; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type; Accel_Flags : Gtk.Accel_Group.Gtk_Accel_Flags); -- Add a new accelerator for the widget. -- The signal Accel_Signal will be sent to Widget when the matching -- key is pressed and the widget has the focus. -- Consider using Gtk.Accel_Map.Add_Entry instead, which is compatible with -- interactive change of accelerators by the user. procedure Remove_Accelerator (Widget : access Gtk_Widget_Record; Accel_Group : Gtk.Accel_Group.Gtk_Accel_Group; Accel_Key : Gdk.Types.Gdk_Key_Type; Accel_Mods : Gdk.Types.Gdk_Modifier_Type); -- Remove an accelerator for the widget. procedure Set_Accel_Path (Widget : access Gtk_Widget_Record; Accel_Path : UTF8_String; Group : Gtk.Accel_Group.Gtk_Accel_Group); -- Set the path that will be used to reference the widget in calls to the -- subprograms in Gtk.Accel_Map. This means, for instance, that the widget -- is fully setup for interactive modification of the shortcuts by the -- user, should he choose to activate this possibility in his themes (see -- gtk-accel_map.ads for more information). ------------------------- -- Events and signals -- ------------------------- function Event (Widget : access Gtk_Widget_Record'Class; Event : Gdk.Event.Gdk_Event) return Boolean; -- Emit a signal on the widget. -- The exact signal depends on the event type (i.e. if the type is -- Gdk_Button_Press, then a "button_press" signal is emitted). procedure Send_Expose (Widget : access Gtk_Widget_Record; Event : Gdk.Event.Gdk_Event_Expose); -- Emit an expose event signals 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_Expose. -- -- 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. procedure Activate (Widget : access Gtk_Widget_Record); -- Emit an activate signal on the widget. -- The exact signal emitted depends on the widget type (i.e. for a -- Gtk_Button this emits a "clicked" signal, for a Gtk_Editable this emits -- the "activate" signal, ...). procedure Grab_Focus (Widget : access Gtk_Widget_Record); -- Emit the "grab_focus" signal for the widget. -- This is sent when the widget gets the focus. Its visual aspect might -- change. -- The "Can_Focus" flag must have been set first. -- See also Gtk.Widget.Child_Focus, which should be used instead when -- writting new widgets in Ada function Child_Focus (Child : access Gtk_Widget_Record'Class; Direction : Gtk.Enums.Gtk_Direction_Type := Gtk.Enums.Dir_Tab_Forward) return Boolean; -- Used by custom widget implementations to indicate the focus child. -- If you're writing an app, you'd use 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. -- -- 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). Child_Focus invokes the "focus" signal on Child; -- widgets override the default handler for this signal in order to -- implement appropriate focus behavior. -- -- The "focus" default 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 Grab_Focus to place the -- focus accordingly; if returning False, they don't modify the current -- focus location. -- -- This function replaces Gtk.Container.Focus from GTK+ 1.2. It was -- necessary to check that the child was visible, sensitive, and focusable -- before calling Gtk.Container.Focus. Child_Focus returns False -- if the widget is not currently in a focusable state, so there's no need -- for those checks. -- -- Return value: True if focus ended up inside Child procedure Set_Events (Widget : access Gtk_Widget_Record; Events : Gdk.Event.Gdk_Event_Mask); -- Sets the event mask for the widget. -- Widget should not have been realized before, or nothing is done. -- This is the only way you can explicitly get mouse or keyboards events on -- widgets that do not automatically get them, as for instance in a -- Gtk_Drawing_Area. function Get_Events (Widget : access Gtk_Widget_Record) return Gdk.Event.Gdk_Event_Mask; -- Get the event mask for the widget. -- This indicates the list of events that the widget receives. procedure Add_Events (Widget : access Gtk_Widget_Record; Events : Gdk.Event.Gdk_Event_Mask); -- Add some events to the current event mask of the widget. procedure Set_Extension_Events (Widget : access Gtk_Widget_Record; Mode : Gdk.Types.Gdk_Extension_Mode); -- Set the extension event mask for the widget. -- This is used to activate some special input modes for other devices than -- keyboard and mouse. function Get_Extension_Events (Widget : access Gtk_Widget_Record) return Gdk.Types.Gdk_Extension_Mode; -- Return the current extension events mask. function Default_Motion_Notify_Event (Widget : access Gtk_Widget_Record'Class; Event : Gdk.Event.Gdk_Event) return Gint; -- Access to the standard default callback for motion events: -- This is mainly used for rulers in Gtk.Ruler (See the example in -- testgtk, with create_rulers.adb) function Has_Default_Motion_Notify_Handler (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Return True if Widget has a default handler for motion_notify events. -- Note that the function Default_Motion_Notify_Event should not be called -- if this one returns False, since it would create a segmentation fault. -------------------------- -- Colors and colormaps -- -------------------------- function Get_Colormap (Widget : access Gtk_Widget_Record) return Gdk.Color.Gdk_Colormap; -- Return the colormap used for the widget. This will generally be the -- same one for all widgets, but might be different if for instance a -- Gtk_Drawing_Area needs to display some different colors on a screen -- that only has a limited amount of colors. function Get_Visual (Widget : access Gtk_Widget_Record) return Gdk.Visual.Gdk_Visual; -- Get the visual used for the widget. -- I.e. the structure that indicates the depth of the widget (number of -- bits per pixel), and some information used internally by GtkAda to -- handle colors and colormaps. procedure Set_Colormap (Widget : access Gtk_Widget_Record; Cmap : Gdk.Color.Gdk_Colormap); -- Modify the colormap of the widget. -- The widget must not have been realized. procedure Push_Colormap (Cmap : Gdk.Color.Gdk_Colormap); -- Modify temporarily the default colormap set for newly created widgets. -- You should use this in pair with Pop_Colormap below (Push the new value, -- create the widget, and pop the value). procedure Pop_Colormap; -- See Push_Colormap for more information. function Get_Default_Colormap return Gdk.Color.Gdk_Colormap; -- Return the default colormap used when a widget is created. procedure Set_Default_Colormap (Cmap : Gdk.Color.Gdk_Colormap); -- Modify permanently the default colormap used when a widget is created. -- If you only want to modify this colormap temporarily for a few widgets, -- you should consider using Push_Colormap and Pop_Colormap instead. function Get_Default_Visual return Gdk.Visual.Gdk_Visual; -- Return the default visual used when a new widget is created. ------------ -- Styles -- ------------ procedure Push_Style (Style : Gtk.Style.Gtk_Style); -- Change the default values for styles. -- This is generally used just before creating a widget. You should use -- this procedure in pair with Pop_Style (Push the new value, create the -- widget then pop the value) procedure Pop_Style; -- Restore the default values for styles. -- This is generally used just after creating a widget. You should use -- this procedure in pair with Push_Style (Push the new value, create the -- widget then pop the value) procedure Set_Style (Widget : access Gtk_Widget_Record; Style : Gtk.Style.Gtk_Style); -- Set the style for a given widget. function Get_Style (Widget : access Gtk_Widget_Record) return Gtk.Style.Gtk_Style; -- Return the style of a given widget. function Get_Default_Style return Gtk.Style.Gtk_Style; -- Get the default global style. procedure Ensure_Style (Widget : access Gtk_Widget_Record); -- Make sure that the widget has a style associated to it. -- Either the default one as set by Set_Default_Style above or one set by -- the user with Set_Style. procedure Restore_Default_Style (Widget : access Gtk_Widget_Record); -- Restore the default style that was set for the widget. -- The default style is the first one that was set either by a call -- to Set_Style or Set_Default_Style. procedure Reset_Rc_Styles (Widget : access Gtk_Widget_Record); -- Restore the Rc style recursively for widget and its children. function Get_Pango_Context (Widget : access Gtk_Widget_Record) return Pango.Context.Pango_Context; -- Get a Pango_Context with the appropriate colormap, font description and -- base direction for this widget. Unlike the context returned by -- Create_Pango_Context, this context is owned by the widget (it can be -- used as long as widget exists), and will be updated to match any changes -- to the widget's attributes. -- -- If you create and keep a Pango_Layout using this context, you must deal -- with changes to the context by calling Pango_Layout.Context_Changed on -- the layout in response to the ::style_set and ::direction_set signals -- for the widget. function Create_Pango_Context (Widget : access Gtk_Widget_Record) return Pango.Context.Pango_Context; -- Create a new Pango_Context with the appropriate colormap, font -- description, and base direction for drawing text for this widget. See -- also Get_Pango_Context. -- The returned context must be freed by the caller. function Create_Pango_Layout (Widget : access Gtk_Widget_Record; Text : UTF8_String := "") return Pango.Layout.Pango_Layout; -- Return a new pango_layout that displays Text. This fully handles -- internationalization, and should be the preferred way to display text, -- rather than Gdk.Drawable.Draw_Text -- Text must be a valid Utf8 text, see Glib.Convert. procedure Modify_Fg (Widget : access Gtk_Widget_Record; State_Type : Enums.Gtk_State_Type; Color : Gdk.Color.Gdk_Color); -- Sets the foreground color for a widget in a particular state. All -- other style values are left untouched. procedure Modify_Bg (Widget : access Gtk_Widget_Record; State_Type : Enums.Gtk_State_Type; Color : Gdk.Color.Gdk_Color); -- Sets the background color for a widget in a particular state. All -- other style values are left untouched. procedure Modify_Text (Widget : access Gtk_Widget_Record; State_Type : Enums.Gtk_State_Type; Color : Gdk.Color.Gdk_Color); -- 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 Modify_Base) -- for widgets such as Gtk_Entry and Gtk_Text_View. procedure Modify_Base (Widget : access Gtk_Widget_Record; State_Type : Enums.Gtk_State_Type; Color : Gdk.Color.Gdk_Color); -- 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 Modify_Text) for widgets such as Gtk_Entry and Gtk_Text_View. procedure Modify_Font (Widget : access Gtk_Widget_Record; Desc : Pango.Font.Pango_Font_Description); -- Modify the font used for the widget. -- Desc must be freed by the caller to avoid memory leaks ------------------- -- Widgets' tree -- ------------------- procedure Set_Name (Widget : access Gtk_Widget_Record; Name : UTF8_String); -- Set the name for the widget. -- This name is used purely internally to identify the widget, and does not -- give any visual clue. function Get_Name (Widget : access Gtk_Widget_Record) return UTF8_String; -- Return the name of the widget if it was set by Set_Name. -- Return the name of its class otherwise. procedure Set_Parent (Widget : access Gtk_Widget_Record; Parent : access Gtk_Widget_Record'Class); -- Modify the parent for the widget. -- This is not the recommended way to do this, you should use -- Gtk.Container.Add or Gtk.Box.Pack_Start instead. procedure Set_Parent_Window (Widget : access Gtk_Widget_Record; Window : Gdk.Window.Gdk_Window); -- Set the parent window for the actual Gdk_Window of the widget. This sets -- up required internal fields, and should be used only when you implement -- your own container, as opposed to using one of the standard containers. function Get_Parent (Widget : access Gtk_Widget_Record) return Gtk_Widget; -- Return the parent of the widget, or null if Widget is a toplevel -- widget. function Get_Parent_Window (Widget : access Gtk_Widget_Record) return Gdk.Window.Gdk_Window; -- Return the widget's parent window. function Get_Toplevel (Widget : access Gtk_Widget_Record) return Gtk_Widget; -- Return the toplevel ancestor of the widget. -- This is the window or dialog in which the widget is included. -- The widget returned does not have any parent. function Get_Ancestor (Widget : access Gtk_Widget_Record; Ancestor_Type : Gtk_Type) return Gtk_Widget; -- Return the closest ancestor of Widget which is of type Ancestor_Type. -- Return null if there is none. function Is_Ancestor (Widget : access Gtk_Widget_Record; Ancestor : access Gtk_Widget_Record'Class) return Boolean; -- Return True if Ancestor is in the ancestor tree for Widget. -- I.e. if Widget is contained within Ancestor. procedure Reparent (Widget : access Gtk_Widget_Record; New_Parent : access Gtk_Widget_Record'Class); -- Change the parent of the widget dynamically. -- If both the new parent and the widget are shown, then the widget is -- visually redrawn in its new parent. procedure Translate_Coordinates (Src_Widget : Gtk_Widget; Dest_Widget : Gtk_Widget; Src_X : Gint; Src_Y : Gint; Dest_X : out Gint; Dest_Y : out Gint; 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. -- -- Result is set to False if either widget was not realized, or there -- was no common ancestor. In this case, nothing is stored in Dest_X and -- Dest_Y. Otherwise True. -------------------- -- Misc functions -- -------------------- procedure Set_Scroll_Adjustments (Widget : access Gtk_Widget_Record; Hadj : Gtk.Adjustment.Gtk_Adjustment; Vadj : Gtk.Adjustment.Gtk_Adjustment); -- Emit the "set_scroll_adjustments" signal. -- The exact signal emitted depends on the widget type (see -- Gtk.Object.Initialize_Class_Record). -- The handler creates the adjustments if null is passed as argument, and -- makes sure both adjustments are in the correct range. function Intersect (Widget : access Gtk_Widget_Record; Area : Gdk.Rectangle.Gdk_Rectangle; Intersection : access Gdk.Rectangle.Gdk_Rectangle) return Boolean; -- Return True if the widget intersects the screen area Area. -- The intersection area is returned in Intersection. procedure Grab_Default (Widget : access Gtk_Widget_Record); -- The widget becomes the default widget for its parent window or dialog. -- All keyboard events will be sent to it if no other widget has the focus. -- Note that the "Can_Default" flag must have been set first on WIDGET. procedure Set_State (Widget : access Gtk_Widget_Record; State : Enums.Gtk_State_Type); -- Modify the state of the widget. -- This modifies its visual aspect, and thus should be used only if you -- change its behavior at the same time, so as not to confuse the user. function Get_State (Widget : access Gtk_Widget_Record) return Enums.Gtk_State_Type; -- Return the state of the widget. procedure Set_Sensitive (Widget : access Gtk_Widget_Record; Sensitive : Boolean := True); -- Modify the sensitivity of the widget. -- An insensitive widget is generally grayed out, and can not be activated. -- For instance, an insensitive menu item is grayed, and can never be -- selected. procedure Set_App_Paintable (Widget : access Gtk_Widget_Record; App_Paintable : Boolean); -- Modify the "App_Paintable" flag for the widget. procedure Set_Double_Buffered (Widget : access Gtk_Widget_Record; Double_Buffered : Boolean := True); -- Modify the "Double_Buffered" flag for the widget. procedure Get_Pointer (Widget : access Gtk_Widget_Record; X : out Gint; Y : out Gint); -- Return the coordinates of the pointer (i.e. mouse) relative to Widget. procedure Set_Window (Widget : access Gtk_Widget_Record; Window : Gdk.Window.Gdk_Window); -- Set the Gdk window associated with the widget. function Get_Window (Widget : access Gtk_Widget_Record) return Gdk.Window.Gdk_Window; -- Get the Gdk window associated with the widget. -- You can use this window if you need to draw directly on the widget using -- the functions found in the Gdk hierarchy. procedure Shape_Combine_Mask (Widget : access Gtk_Widget_Record; Shape_Mask : Gdk.Bitmap.Gdk_Bitmap; Offset_X : Gint; Offset_Y : Gint); -- Modify the shape of the window that contains the widget. -- This allows for transparent windows, and requires the Xext library to be -- available on your system. If this library is not available, your program -- will still work. -- See the manual page for XShapeCombineMask(3x) for more information. function Render_Icon (Widget : access Gtk_Widget_Record; Stock_Id : String; Size : Gtk.Enums.Gtk_Icon_Size; Detail : UTF8_String := "") return Gdk.Pixbuf.Gdk_Pixbuf; -- A convenience function that uses the theme engine for Widget, to lookup -- a Stock_Id (see Gtk.Stock) and render it to a pixbuf (see Gdk.Pixbuf). -- Detail should be a string that identifies the widget or code doing the -- rendering, so that the theme engine can special-case rendering for that -- widget or code. It can be left to the empty stirng to get the default -- behavior. -- -- Null is returned if Stock_Id wasn't known. -------------------------- -- Creating new widgets -- -------------------------- -- Although the core subprogram for creating new widgets is -- Glib.Gobjects.Initialize_Class_Record, it is often useful to override -- some internal pointers to functions. -- The functions below are not needed unless you are writting your own -- widgets, and should be reserved for advanced customization of the -- standard widgets. procedure Set_Scroll_Adjustments_Signal (Widget : Glib.Object.GObject_Class; Signal : String); -- Modify the signal to be sent when the adjustments are modified. -- This is only useful when you are rewritting your own widget that can be -- embedded directly in a Gtk_Scrolled_Window, without any Gtk_Viewport. -- -- Signal is the name of the signal that will be emitted when Widget is -- put inside a Gtk_Scrolled_Window. -- -- Note that the handlers for this signal must take two arguments in -- addition to the widget (the horizontal and vertical adjustments to be -- used). See Gtk.Scrolled_Window and Gtk.Widget.Set_Scroll_Adjustment for -- more information on this signal. type Size_Allocate_Handler is access procedure (Widget : System.Address; Allocation : Gtk_Allocation); pragma Convention (C, Size_Allocate_Handler); -- 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_Handler (Klass : Glib.Object.GObject_Class; Handler : Size_Allocate_Handler); -- 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. procedure Set_Allocation (Widget : access Gtk_Widget_Record'Class; Alloc : Gtk_Allocation); -- Modifies directly the internal field of Widget to register the new -- allocation. -- Beware that the only use of this method is inside a callback set -- by Set_Default_Size_Allocate_Handler. If you simply want to resize -- or reposition a widget, use Size_Allocate instead. type Expose_Event_Handler is access function (Widget : System.Address; Event : Gdk.Event.Gdk_Event) return Boolean; function Default_Expose_Event_Handler (Klass : GObject_Class) return Expose_Event_Handler; -- Return the default expose event handler for the widget class Klass. The -- typical use for this function is when you are writting your own -- container class. You should then, from your own handler for -- expose_event, call the one of the parent class, so that all the children -- are automatically redrawn. ----------- -- Flags -- ----------- -- Some additional flags are defined for all the visual objects (widgets). -- They are defined in addition to the ones defined in Gtk.Object. -- These flags are important in that they define exactly the different -- states a widget can be in. -- -- - "Toplevel": -- Set if the widget is a toplevel widget, ie has no parent. This is -- mostly true for windows and dialogs. -- -- - "No_Window": -- Set if the widget does not have an associated X11 window, ie can not -- receive events directly. For instance, a Gtk_Toolbar does not have -- an associated window. These objects are more lightweight, but require -- more work from GtkAda. This flag is only set if the widget will never -- have a window, even after it is realized. -- -- - "Realized": -- Set if the widget has been realized, ie its associated X11 window has -- been created (providing the widget excepts a window, see the No_Window -- flag -- -- - "Mapped": -- Set if the widget is visible on the screen. This is only possible if -- the Visible flag is also set. -- -- - "Visible": -- Set if the widget will be displayed on the screen when mapped (see the -- functions Show and Hide in this package). -- -- - "Sensitive": -- Set if the widget is listening to events. See the function -- Set_Sensitive in this package. An insensitive widget will generally -- have a different visual aspect to clue that it is unavailable (for -- instance an insensitive item menu will be grayed) -- -- - "Parent_Sensitive": -- Set if the parent is sensitive. A widget is sensitive only if both -- the Sensitive and Parent_Sensitive are set. -- -- - "Can_Focus": -- Set if the widget can have the focus, ie get keyboard events. Most -- widgets can not have the focus. -- -- - "Has_Focus": -- Set if the widget currently has the focus. See the function Grab_Focus -- in this package. -- -- - "Can_Default": -- Set if the widget can be the default widget in a window, ie the one -- that will get the keyboard events by default. For instance, the -- default button in a dialog is the one that gets clicked on when the -- user pressed Enter anywhere in the dialog. -- -- - "Has_Default": -- Set if the widget is currently the default widget. See the function -- Grab_Default in this package. -- -- - "Has_Grab": -- Set if the widget currently grabs all mouse and keyboard events in -- the application, even if it does not have the focus. There can be only -- such widget per application at any given time. -- -- - "Rc_Style": -- Set if the widget's style is either the default style, or in a -- customization file. This is unset if the style has been modified by -- the user. -- -- - "Composite_Child": -- This indicates whether the widget is composed of other widgets -- -- - "No_Reparent": -- This flags is never used in gtk+. -- -- - "App_Paintable": -- For some containers (including Gtk_Window and Gtk_Layout), this is -- unset when the container itself has some special drawing routines. It -- indicates whether the application will paint directly on the widget. -- -- - "Receives_Default": -- Set when the widget receives the default at the time it receives the -- focus. This is how the default button in a dialog is automatically -- changed when you press another button. Toplevel : constant := 2 ** 4; No_Window : constant := 2 ** 5; Realized : constant := 2 ** 6; Mapped : constant := 2 ** 7; Visible : constant := 2 ** 8; Sensitive : constant := 2 ** 9; Parent_Sensitive : constant := 2 ** 10; Can_Focus : constant := 2 ** 11; Has_Focus : constant := 2 ** 12; Can_Default : constant := 2 ** 13; Has_Default : constant := 2 ** 14; Has_Grab : constant := 2 ** 15; Rc_Style : constant := 2 ** 16; Composite_Child : constant := 2 ** 17; No_Reparent : constant := 2 ** 18; App_Paintable : constant := 2 ** 19; Receives_Default : constant := 2 ** 20; Double_Buffered : constant := 2 ** 21; function Toplevel_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Toplevel flag is set. function No_Window_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the No_Window flag is set. function Realized_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Realized flag is set. function Mapped_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Mapped flag is set. function Visible_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Visible flag is set. function Drawable_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- True if the widget is both visible and mapped. -- In other words, if it does appear on the screen. function Is_Sensitive (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the widget is Sensitive. function Can_Focus_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Can_Focus flag is set. function Has_Focus_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Has_Focus flag is set. function Has_Default_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Has_Default flag is set. function Has_Grab_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Has_Grab flag is set. function Rc_Style_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Rc_Style flag is set. function Double_Buffered_Is_Set (Widget : access Gtk_Widget_Record'Class) return Boolean; -- Test whether the Double_Buffered flag is set. -------------------------------------- -- Definitions for lists of widgets -- -------------------------------------- -- function Convert (W : Gtk_Widget) return System.Address; function Convert (W : System.Address) return Gtk_Widget; package Widget_List is new Glib.Glist.Generic_List (Gtk_Widget); package Widget_SList is new Glib.GSlist.Generic_SList (Gtk_Widget); -- -------------------- -- GValue support -- -------------------- function Get_Requisition (Value : Glib.Values.GValue) return Gtk_Requisition_Access; -- Convert a value into a Gtk_Requisition_Access. function Get_Allocation (Value : Glib.Values.GValue) return Gtk_Allocation_Access; -- Convert a value into a Gtk_Allocation_Access. ---------------- -- Properties -- ---------------- -- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties. -- -- - Name: Name_Property -- Type: UTF8_String -- Flags: read-write -- Descr: The name of the widget -- See also: Set_Name procedure -- -- - Name: Parent_Property -- Type: Gtk_Container'Class -- Flags: read-write -- Descr: The parent widget of this widget. -- See also: Set_Parent or Add procecures -- -- - Name: X_Property -- Type: Gint -- Flags: read-write -- Descr: The x coordinate of the top-left corner of the widget, -- or -1 if not set -- -- - Name: Y_Property -- Type: Gint -- Flags: read-write -- Descr: The y coordinate of the top-left corner of the widget, -- or -1 if not set -- -- - Name: Width_Property -- Type: Gint -- Flags: read-write -- Descr: The width of the widget or -1 if not set -- See also: Set_USize -- -- - Name: Height_Property -- Type: Gint -- Flags: read-write -- Descr: The height of the widget or -1 if not set -- See also: Set_USize -- -- - Name: Visible_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget is visible -- See also: Hide and Show procedures -- -- - Name: Sensitive_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget responds to input -- See also: Set_Sensitive -- -- - Name: App_Paintable_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the application will paint directly on the widget -- See also: Set_App_Paintable -- -- - Name: Can_Focus_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget can accept the input focus (keyboard) -- See also: Set or unset the flag Can_Focus -- -- - Name: Has_Focus_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget has the input focus -- See also: Grab_Focus -- -- - Name: Can_Default_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget can be the default widget -- See also: Set or unset the flag Can_Default -- -- - Name: Has_Default_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget is the default widget -- See also: Grab_Default -- -- - Name: Receives_Default_Property -- Type: Boolean -- Flags: read-write -- Descr: If True, the widget will receive the default action when -- it is focused -- See also: Set or unset the flag Receives_Default -- -- - Name: Composite_Child_Property -- Type: Boolean -- Flags: read-write -- Descr: Whether the widget is composed of other widgets -- See also: Set or unset the flag Composite_Child -- -- - Name: Style_Property -- Type: Gtk_Style -- Flags: read-write -- Descr: The style of the widget, which contains information about how -- it will look (colors etc). -- See also: Set_Style -- -- - Name: Events_Property -- Type: flags -- Flags: read-write -- Descr: The event mask that decides what kind of GdkEvents this widget -- gets. -- See also: Set_Events -- -- - Name: Prop_Extensions_Events_Property -- Type: flags -- Flags: read-write -- Descr: The mask that decides what kind of extension events this widget -- gets. -- See also: Set_Extension_Events -- -- Name_Property : constant Glib.Properties.Property_String; Parent_Property : constant Glib.Properties.Property_Object; X_Property : constant Glib.Properties.Property_Int; Y_Property : constant Glib.Properties.Property_Int; Width_Property : constant Glib.Properties.Property_Int; Height_Property : constant Glib.Properties.Property_Int; Visible_Property : constant Glib.Properties.Property_Boolean; Sensitive_Property : constant Glib.Properties.Property_Boolean; App_Paintable_Property : constant Glib.Properties.Property_Boolean; Can_Focus_Property : constant Glib.Properties.Property_Boolean; Has_Focus_Property : constant Glib.Properties.Property_Boolean; Can_Default_Property : constant Glib.Properties.Property_Boolean; Has_Default_Property : constant Glib.Properties.Property_Boolean; Receives_Default_Property : constant Glib.Properties.Property_Boolean; Composite_Child_Property : constant Glib.Properties.Property_Boolean; Style_Property : constant Glib.Properties.Property_Object; Events_Property : constant Gdk.Event.Property_Gdk_Event_Mask; Prop_Extensions_Events_Property : constant Gdk.Types.Property_Gdk_Extension_Mode; ------------- -- Signals -- ------------- -- -- The following new signals are defined for this widget: -- -- - "show" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget is to be shown (see explanation for the Show -- subprogam). This schedules the widget to be displayed on the screen, -- and if this is a toplevel widget it actually appears on the screen -- and all its children that have been shown. -- -- - "hide" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget is to be hidden (see explanation for the Hide -- subprogram). Hides the widget from the screen, and if its parent is -- shown, the widget will not appear on the screen again. -- -- - "map" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget is mapped on the screen (the default handler -- simply emits the "show" signal). -- -- - "unmap" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget needs to be unmapped on the screen (the default -- handler simply emits the "hide" signal). -- -- - "realize" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget is realized. The default handler creates the -- Gdk window associated with the widget, and its ancestors. -- -- - "unrealize" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget is unrealized. The default handler destroys the -- Gdk windows of the widget and all its children. -- -- - "draw" -- procedure Handler (Widget : access Gtk_Widget_Record'Class; -- Area : Gdk.Rectangle.Gdk_Rectangle); -- -- Emitted when a widget needs to be drawn. The default handler emits -- the "expose" event. -- -- - "draw_focus" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget needs to be drawn and it has the focus. Some -- widgets might want to provide visual clues that they have the focus, -- like a black border. This is never called if the widget can not have -- the focus (ie the "Can_Focus" flag is unset). -- -- - "draw_default" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- Emitted when a widget needs to be drawn and it does not have the -- focus. This is never called if the widget can not have the focus -- (ie the "Can_Focus" flag is unset). -- -- - "size_request" -- procedure Handler (Widget : access Gtk_Widget_Record'Class; -- Requisition : access Gtk_Requisition); -- -- Should return (in Requisition) the ideal size the widget would like to -- have. It is not sure this is the size that will be assigned to it, -- since it depends on the size of its parent). -- -- - "size_allocate" -- procedure Handler (Widget : access Gtk_Widget_Record'Class; -- Allocation : Gtk_Allocation); -- -- A size and position were assigned to the widget. This is called every -- time the size of the widget changes. -- The default handler takes care of resizing and moving the widget. -- -- - "state_changed" -- procedure Handler (Widget : access Gtk_Widget_Record'Class; -- Previous_State : Gtk.Enums.Gtk_State_Type); -- -- The state of the widget has changed. -- -- - "parent_set" -- procedure Handler (Widget : access Gtk_Widget_Record'Class; -- Previous_Parent : access Gtk_Widget_Record'Class); -- -- A new parent has been set for the widget. The previous parent is -- given in arguments (if there was none, -- Gdk.Is_Created (Previous_Parent) returns False). -- -- - "style_set" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- Previous_Style : Gtk.Style.Gtk_Style); -- -- The widget's style has been changed (this is not call when some -- settings in the style are changed, only when the style itself is -- completely changed with a call to Set_Style or Set_Default_Style). -- -- - "add_accelerator" -- -- ??? -- -- - "remove_accelerator" -- -- ??? -- -- - "grab_focus" -- procedure Handler (Widget : access Gtk_Widget_Record'Class); -- -- The widget has got the focus, ie will now get the keyboard events -- sent to a window. This is only called if the "Can_Focus" flag is -- set. The "Has_Focus" flag might not be set when this signal is -- emitted. -- -- - "event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- Some event was sent to the widget. This covers all the cases -- below, and acts as a general handler. This is called in addition to -- the relevant specific handler below. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "button_press_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Button) -- return Boolean; -- -- A button was pressed while the pointer was inside the widget. -- To get this signal, some widgets by have to use the Set_Events -- subprogram first to get this event. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "button_release_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Button) -- return Boolean; -- -- A button was released while the pointer was inside the widget. -- Note that in some cases (Gtk_Buttons for instance), another "clicked" -- signal could be emitted). This "button_release_event" should mainly -- be used for widgets that don't already have specific signals to cover -- that case (Gtk_Drawing_Area for instance). -- -- To get this signal, some widgets may have to use the Set_Events -- subprogram first to get this event. -- -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "motion_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Motion) -- return Boolean; -- -- The pointer has moved while remaining inside the widget. -- The Set_Events subprogram has to be called first to get this event. -- -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "delete_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- The user has clicked on the "close" button in the window's frame -- (the button that is automatically set by the window manager). If the -- handler returns False, the widget will be destroyed (and the window -- closed), but if the handler returns True, nothing will be done. -- This is a good way to prevent the user from closing your application's -- window if there should be some clean ups first (like saving the -- document). -- -- - "destroy_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- This signal is apparently never emitted by Gtk+. You might want to -- use "destroy" instead, which is documented in Gtk.Object. -- -- - "expose_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Expose) -- return Boolean; -- -- The widget needs to be partly redrawn. The exact area to redraw is -- found in Event. For some widgets, you should rather connect to the -- "draw" signal. However, for instance for Gtk_Drawing_Area widgets, -- you have to use this, after setting the correct event mask with -- Set_Events. -- If the handler returns False, the event might be passed to the parent -- of widget (if no other handler of widget has returned True). -- -- - "key_press_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Key) -- return Boolean; -- -- A key has been pressed while Widget had the focus. Note that some -- widgets like Gtk_Editable provide some higher-level signals to handle -- this. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "key_release_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Key) -- return Boolean; -- -- A key has been released while Widget had the focus. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "enter_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Crossing) -- return Boolean; -- -- The pointer has just entered the widget. If the "Can_Focus" flag is -- set, Widget will gain the focus, and the widget might be drawn -- differently. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "leave_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Crossing) -- return Boolean; -- -- The pointer has just leaved the widget. If the "Can_Focus" flag is -- set, Widget will gain the focus, and the widget might be drawn -- differently. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "configure_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Configure) -- return Boolean; -- -- Some configuration of the window has changed (it has been -- moved or resized). -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "focus_in_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Focus) -- return Boolean; -- -- The widget has just gained the focus. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- This event is only emitted if you called Add_Events with a -- Enter_Notify_Mask parameter -- -- - "focus_out_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Focus) -- return Boolean; -- -- The widget has just lost the focus. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- This event is only emitted if you called Add_Events with a -- Leave_Notify_Mask parameter -- -- - "map_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- The widget has just been mapped. This is different from the "map" -- signal, which is called *before* the widget is actually mapped. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "unmap_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- The widget has just been unmapped. This is different from the "unmap" -- signal, which is called *before* the widget is actually unmapped. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "property_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Property) -- return Boolean; -- -- ??? -- -- - "selection_clear_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Selection) -- return Boolean; -- -- ??? -- -- - "selection_request_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Selection) -- return Boolean; -- -- ??? -- -- - "selection_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Selection) -- return Boolean; -- -- ??? -- -- - "selection_received" -- Related to the selection mechanism, see Gtk.Selection -- -- - "selection_get" -- Related to the selection mechanism, see Gtk.Selection -- -- - "proximity_in_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Proximity) -- return Boolean; -- -- Used for special input devices. See the description of -- Gdk.Event.Gdk_Event_Proximity. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "proximity_out_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Proximity) -- return Boolean; -- -- Used for special input devices. See the description of -- Gdk.Event.Gdk_Event_Proximity. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "drag_leave" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_begin" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_end" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_data_delete" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_motion" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_drop" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_data_get" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "drag_data_received" -- Event related to drag-and-drop support. See the Gtk.Dnd documentation. -- -- - "visibility_notify_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event_Visibility) -- return Boolean; -- -- The visibility state of the widget has changed (partially visible, -- fully visible, ...). You might want to use the "expose" signal -- instead. -- If the handler returns False, the event might be pass to the parent -- of widget (if no other handler of widget has returned True). -- -- - "client_event" -- -- ??? -- -- - "no_expose_event" -- function Handler (Widget : access Gtk_Widget_Record'Class; -- Event : Gdk.Event.Gdk_Event) -- return Boolean; -- -- ??? -- -- private type Gtk_Widget_Record is new Object.Gtk_Object_Record with null record; Name_Property : constant Glib.Properties.Property_String := Glib.Properties.Build ("name"); Parent_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("parent"); X_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("x"); Y_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("y"); Width_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("width"); Height_Property : constant Glib.Properties.Property_Int := Glib.Properties.Build ("height"); Visible_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("visible"); Sensitive_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("sensitive"); App_Paintable_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("app_paintable"); Can_Focus_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("can_focus"); Has_Focus_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("has_focus"); Can_Default_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("can_default"); Has_Default_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("has_default"); Receives_Default_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("receives_default"); Composite_Child_Property : constant Glib.Properties.Property_Boolean := Glib.Properties.Build ("composite_child"); Style_Property : constant Glib.Properties.Property_Object := Glib.Properties.Build ("style"); Events_Property : constant Gdk.Event.Property_Gdk_Event_Mask := Gdk.Event.Build ("events"); Prop_Extensions_Events_Property : constant Gdk.Types.Property_Gdk_Extension_Mode := Gdk.Types.Build ("extension_events"); pragma Import (C, Push_Style, "gtk_widget_push_style"); pragma Import (C, Pop_Style, "gtk_widget_pop_style"); pragma Import (C, Get_Default_Style, "gtk_widget_get_default_style"); pragma Import (C, Pop_Colormap, "gtk_widget_pop_colormap"); pragma Import (C, Get_Type, "gtk_widget_get_type"); pragma Import (C, Get_Default_Colormap, "gtk_widget_get_default_colormap"); pragma Import (C, Get_Default_Visual, "gtk_widget_get_default_visual"); pragma Import (C, Push_Colormap, "gtk_widget_push_colormap"); pragma Import (C, Set_Default_Colormap, "gtk_widget_set_default_colormap"); pragma Import (C, Set_Default_Size_Allocate_Handler, "ada_gtk_widget_set_default_size_allocate_handler"); pragma Import (C, Default_Expose_Event_Handler, "ada_gtk_default_expose_event_handler"); pragma Inline (Toplevel_Is_Set); pragma Inline (No_Window_Is_Set); pragma Inline (Realized_Is_Set); pragma Inline (Mapped_Is_Set); pragma Inline (Visible_Is_Set); pragma Inline (Drawable_Is_Set); pragma Inline (Is_Sensitive); pragma Inline (Can_Focus_Is_Set); pragma Inline (Has_Focus_Is_Set); pragma Inline (Has_Default_Is_Set); pragma Inline (Has_Grab_Is_Set); pragma Inline (Rc_Style_Is_Set); pragma Inline (Double_Buffered_Is_Set); end Gtk.Widget; -- missing: -- - gtk_widget_new <= low level, typically not needed -- - gtk_widget_destroy <= not needed, see Gtk.Object.Destroy -- - gtk_widget_destroyed -- - gtk_widget_get_parent_window <= mainly internal -- - gtk_widget_hide_on_delete <= used as callback -- - gtk_widget_set_composite_name -- - gtk_widget_get_composite_name -- - gtk_widget_push_composite_child -- - gtk_widget_pop_composite_child -- - gtk_widget_path -- - gtk_widget_class_path -- - gtk_widget_mnemonic_activate -- - gtk_widget_region_intersect -- - gtk_widget_is_focus -- - gtk_widget_class_install_style_property -- - gtk_widget_class_install_style_property_parser -- - gtk_widget_style_get_property -- - gtk_widget_style_get_valist -- - gtk_widget_style_get -- - gtk_widget_set_direction -- - gtk_widget_get_direction -- - gtk_widget_set_default_direction -- - gtk_widget_get_default_direction -- - gtk_widget_child_focus -- - gtk_widget_get_accessible