------------------------------------------------------------------------------ -- -- -- 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> -- Gtk.Scrolled_Window.Gtk_Scrolled_Window is a Gtk.Bin.Gtk_Bin subclass: -- it's a container the accepts a single child widget. -- Gtk.Scrolled_Window.Gtk_Scrolled_Window adds scrollbars to the child widget -- and optionally draws a beveled frame around the child widget. -- -- The scrolled window can work in two ways. Some widgets have native -- scrolling support; these widgets implement the -- Gtk.Scrollable.Gtk_Scrollable interface. Widgets with native scroll support -- include Gtk.Tree_View.Gtk_Tree_View, Gtk.Text_View.Gtk_Text_View, and -- Gtk.Layout.Gtk_Layout. -- -- For widgets that lack native scrolling support, the -- Gtk.Viewport.Gtk_Viewport widget acts as an adaptor class, implementing -- scrollability for child widgets that lack their own scrolling capabilities. -- Use Gtk.Viewport.Gtk_Viewport to scroll child widgets such as -- Gtk.Grid.Gtk_Grid, Gtk.Box.Gtk_Box, and so on. -- -- If a widget has native scrolling abilities, it can be added to the -- Gtk.Scrolled_Window.Gtk_Scrolled_Window with Gtk.Container.Add. If a widget -- does not, you must first add the widget to a Gtk.Viewport.Gtk_Viewport, -- then add the Gtk.Viewport.Gtk_Viewport to the scrolled window. -- Gtk.Container.Add will do this for you for widgets that don't implement -- Gtk.Scrollable.Gtk_Scrollable natively, so you can ignore the presence of -- the viewport. -- -- The position of the scrollbars is controlled by the scroll adjustments. -- See Gtk.Adjustment.Gtk_Adjustment for the fields in an adjustment - for -- Gtk.Scrollbar.Gtk_Scrollbar, used by -- Gtk.Scrolled_Window.Gtk_Scrolled_Window, the "value" field represents the -- position of the scrollbar, which must be between the "lower" field and -- "upper - page_size." The "page_size" field represents the size of the -- visible scrollable area. The "step_increment" and "page_increment" fields -- are used when the user asks to step down (using the small stepper arrows) -- or page down (using for example the PageDown key). -- -- If a Gtk.Scrolled_Window.Gtk_Scrolled_Window doesn't behave quite as you -- would like, or doesn't have exactly the right layout, it's very possible to -- set up your own scrolling with Gtk.Scrollbar.Gtk_Scrollbar and for example -- a Gtk.Grid.Gtk_Grid. -- -- </description> pragma Ada_2005; pragma Warnings (Off, "*is already use-visible*");
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Adjustment; use Gtk.Adjustment;
with Gtk.Bin; use Gtk.Bin;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Scrollbar; use Gtk.Scrollbar;
with Gtk.Widget; use Gtk.Widget;
package Gtk.Scrolled_Window is
type Gtk_Scrolled_Window_Record is new Gtk_Bin_Record with null record;
type Gtk_Scrolled_Window is access all Gtk_Scrolled_Window_Record'Class;
------------------ -- Constructors -- ------------------ procedure Gtk_New
(Scrolled_Window : out Gtk_Scrolled_Window;
Hadjustment : Gtk.Adjustment.Gtk_Adjustment := null;
Vadjustment : Gtk.Adjustment.Gtk_Adjustment := null);
procedure Initialize
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record'Class;
Hadjustment : Gtk.Adjustment.Gtk_Adjustment := null;
Vadjustment : Gtk.Adjustment.Gtk_Adjustment := null);
-- Creates a new scrolled window. -- The two arguments are the scrolled window's adjustments; these will be -- shared with the scrollbars and the child widget to keep the bars in sync -- with the child. Usually you want to pass null for the adjustments, which -- will cause the scrolled window to create them for you. -- "hadjustment": horizontal adjustment -- "vadjustment": vertical adjustment function Gtk_Scrolled_Window_New
(Hadjustment : Gtk.Adjustment.Gtk_Adjustment := null;
Vadjustment : Gtk.Adjustment.Gtk_Adjustment := null)
return Gtk_Scrolled_Window;
-- Creates a new scrolled window. -- The two arguments are the scrolled window's adjustments; these will be -- shared with the scrollbars and the child widget to keep the bars in sync -- with the child. Usually you want to pass null for the adjustments, which -- will cause the scrolled window to create them for you. -- "hadjustment": horizontal adjustment -- "vadjustment": vertical adjustment function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_scrolled_window_get_type");
------------- -- Methods -- ------------- procedure Add_With_Viewport
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class);
pragma Obsolescent (Add_With_Viewport);
-- Used to add children without native scrolling capabilities. This is -- simply a convenience function; it is equivalent to adding the -- unscrollable child to a viewport, then adding the viewport to the -- scrolled window. If a child has native scrolling, use Gtk.Container.Add -- instead of this function. -- The viewport scrolls the child by moving its Gdk.Gdk_Window, and takes -- the size of the child to be the size of its toplevel Gdk.Gdk_Window. -- This will be very wrong for most widgets that support native scrolling; -- for example, if you add a widget such as Gtk.Tree_View.Gtk_Tree_View -- with a viewport, the whole widget will scroll, including the column -- headings. Thus, widgets with native scrolling support should not be used -- with the Gtk.Viewport.Gtk_Viewport proxy. -- A widget supports scrolling natively if it implements the -- Gtk.Scrollable.Gtk_Scrollable interface. -- Deprecated since 3.8, Gtk.Container.Add will now automatically add a -- Gtk.Viewport.Gtk_Viewport if the child doesn't implement -- Gtk.Scrollable.Gtk_Scrollable. -- "child": the widget you want to scroll function Get_Capture_Button_Press
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Boolean; -- Return whether button presses are captured during kinetic scrolling. -- See Gtk.Scrolled_Window.Set_Capture_Button_Press. -- Since: gtk+ 3.4 procedure Set_Capture_Button_Press
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Capture_Button_Press : Boolean);
-- Changes the behaviour of Scrolled_Window wrt. to the initial event that -- possibly starts kinetic scrolling. When Capture_Button_Press is set to -- True, the event is captured by the scrolled window, and then later -- replayed if it is meant to go to the child widget. -- This should be enabled if any child widgets perform non-reversible -- actions on Gtk.Widget.Gtk_Widget::button-press-event. If they don't, and -- handle additionally handle Gtk.Widget.Gtk_Widget::grab-broken-event, it -- might be better to set Capture_Button_Press to False. -- This setting only has an effect if kinetic scrolling is enabled. -- Since: gtk+ 3.4 -- "capture_button_press": True to capture button presses function Get_Hadjustment
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Adjustment.Gtk_Adjustment;
-- Returns the horizontal scrollbar's adjustment, used to connect the -- horizontal scrollbar to the child widget's horizontal scroll -- functionality. procedure Set_Hadjustment
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Hadjustment : not null access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
-- Sets the Gtk.Adjustment.Gtk_Adjustment for the horizontal scrollbar. -- "hadjustment": horizontal scroll adjustment function Get_Hscrollbar
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Scrollbar.Gtk_Scrollbar;
-- Returns the horizontal scrollbar of Scrolled_Window. -- Since: gtk+ 2.8 function Get_Kinetic_Scrolling
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Boolean; -- Returns the specified kinetic scrolling behavior. -- Since: gtk+ 3.4 procedure Set_Kinetic_Scrolling
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Kinetic_Scrolling : Boolean);
-- Turns kinetic scrolling on or off. Kinetic scrolling only applies to -- devices with source GDK_SOURCE_TOUCHSCREEN. -- Since: gtk+ 3.4 -- "kinetic_scrolling": True to enable kinetic scrolling function Get_Min_Content_Height
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gint;
-- Gets the minimal content height of Scrolled_Window, or -1 if not set. -- Since: gtk+ 3.0 procedure Set_Min_Content_Height
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Height : Gint);
-- Sets the minimum height that Scrolled_Window should keep visible. Note -- that this can and (usually will) be smaller than the minimum size of the -- content. -- Since: gtk+ 3.0 -- "height": the minimal content height function Get_Min_Content_Width
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gint;
-- Gets the minimum content width of Scrolled_Window, or -1 if not set. -- Since: gtk+ 3.0 procedure Set_Min_Content_Width
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Width : Gint);
-- Sets the minimum width that Scrolled_Window should keep visible. Note -- that this can and (usually will) be smaller than the minimum size of the -- content. -- Since: gtk+ 3.0 -- "width": the minimal content width function Get_Placement
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Enums.Gtk_Corner_Type;
-- Gets the placement of the contents with respect to the scrollbars for -- the scrolled window. See Gtk.Scrolled_Window.Set_Placement. procedure Set_Placement
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Window_Placement : Gtk.Enums.Gtk_Corner_Type);
-- Sets the placement of the contents with respect to the scrollbars for -- the scrolled window. -- The default is Gtk.Enums.Corner_Top_Left, meaning the child is in the -- top left, with the scrollbars underneath and to the right. Other values -- in Gtk.Enums.Gtk_Corner_Type are Gtk.Enums.Corner_Top_Right, -- Gtk.Enums.Corner_Bottom_Left, and Gtk.Enums.Corner_Bottom_Right. -- See also Gtk.Scrolled_Window.Get_Placement and -- Gtk.Scrolled_Window.Unset_Placement. -- "window_placement": position of the child window procedure Get_Policy
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Hscrollbar_Policy : out Gtk.Enums.Gtk_Policy_Type;
Vscrollbar_Policy : out Gtk.Enums.Gtk_Policy_Type);
-- Retrieves the current policy values for the horizontal and vertical -- scrollbars. See Gtk.Scrolled_Window.Set_Policy. -- "hscrollbar_policy": location to store the policy for the horizontal -- scrollbar, or null. -- "vscrollbar_policy": location to store the policy for the vertical -- scrollbar, or null. procedure Set_Policy
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Hscrollbar_Policy : Gtk.Enums.Gtk_Policy_Type;
Vscrollbar_Policy : Gtk.Enums.Gtk_Policy_Type);
-- Sets the scrollbar policy for the horizontal and vertical scrollbars. -- The policy determines when the scrollbar should appear; it is a value -- from the Gtk.Enums.Gtk_Policy_Type enumeration. If -- Gtk.Enums.Policy_Always, the scrollbar is always present; if -- Gtk.Enums.Policy_Never, the scrollbar is never present; if -- Gtk.Enums.Policy_Automatic, the scrollbar is present only if needed -- (that is, if the slider part of the bar would be smaller than the trough -- - the display is larger than the page size). -- "hscrollbar_policy": policy for horizontal bar -- "vscrollbar_policy": policy for vertical bar function Get_Shadow_Type
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Enums.Gtk_Shadow_Type;
-- Gets the shadow type of the scrolled window. See -- Gtk.Scrolled_Window.Set_Shadow_Type. procedure Set_Shadow_Type
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
The_Type : Gtk.Enums.Gtk_Shadow_Type);
-- Changes the type of shadow drawn around the contents of -- Scrolled_Window. -- "type": kind of shadow to draw around scrolled window contents function Get_Vadjustment
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Adjustment.Gtk_Adjustment;
-- Returns the vertical scrollbar's adjustment, used to connect the -- vertical scrollbar to the child widget's vertical scroll functionality. procedure Set_Vadjustment
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record;
Vadjustment : not null access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
-- Sets the Gtk.Adjustment.Gtk_Adjustment for the vertical scrollbar. -- "vadjustment": vertical scroll adjustment function Get_Vscrollbar
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record)
return Gtk.Scrollbar.Gtk_Scrollbar;
-- Returns the vertical scrollbar of Scrolled_Window. -- Since: gtk+ 2.8 procedure Unset_Placement
(Scrolled_Window : not null access Gtk_Scrolled_Window_Record);
-- Unsets the placement of the contents with respect to the scrollbars for -- the scrolled window. If no window placement is set for a scrolled -- window, it obeys the "gtk-scrolled-window-placement" XSETTING. -- See also Gtk.Scrolled_Window.Set_Placement and -- Gtk.Scrolled_Window.Get_Placement. -- Since: gtk+ 2.10 ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Hadjustment_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Adjustment.Gtk_Adjustment Hscrollbar_Policy_Property : constant Gtk.Enums.Property_Gtk_Policy_Type;
Kinetic_Scrolling_Property : constant Glib.Properties.Property_Boolean;
-- The kinetic scrolling behavior flags. Kinetic scrolling only applies to -- devices with source GDK_SOURCE_TOUCHSCREEN Min_Content_Height_Property : constant Glib.Properties.Property_Int;
-- The minimum content height of Scrolled_Window, or -1 if not set. Min_Content_Width_Property : constant Glib.Properties.Property_Int;
-- The minimum content width of Scrolled_Window, or -1 if not set. Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type;
Vadjustment_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Adjustment.Gtk_Adjustment Vscrollbar_Policy_Property : constant Gtk.Enums.Property_Gtk_Policy_Type;
Window_Placement_Property : constant Gtk.Enums.Property_Gtk_Corner_Type;
Window_Placement_Set_Property : constant Glib.Properties.Property_Boolean;
-- Whether "window-placement" should be used to determine the location of -- the contents with respect to the scrollbars. Otherwise, the -- "gtk-scrolled-window-placement" setting is used. ------------- -- Signals -- ------------- type Cb_Gtk_Scrolled_Window_Gtk_Direction_Type_Void is not null access procedure
(Self : access Gtk_Scrolled_Window_Record'Class;
Direction_Type : Gtk.Enums.Gtk_Direction_Type); type Cb_GObject_Gtk_Direction_Type_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Direction_Type : Gtk.Enums.Gtk_Direction_Type); Signal_Move_Focus_Out : constant Glib.Signal_Name := "move-focus-out";
procedure On_Move_Focus_Out
(Self : not null access Gtk_Scrolled_Window_Record;
Call : Cb_Gtk_Scrolled_Window_Gtk_Direction_Type_Void;
After : Boolean := False);
procedure On_Move_Focus_Out
(Self : not null access Gtk_Scrolled_Window_Record;
Call : Cb_GObject_Gtk_Direction_Type_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::move-focus-out signal is a <link -- linkend="keybinding-signals">keybinding signal</link> which gets emitted -- when focus is moved away from the scrolled window by a keybinding. The -- Gtk.Widget.Gtk_Widget::move-focus signal is emitted with Direction_Type -- on this scrolled windows toplevel parent in the container hierarchy. The -- default bindings for this signal are ['Tab''Ctrl'] and -- ['Tab''Ctrl''Shift']. type Cb_Gtk_Scrolled_Window_Gtk_Scroll_Type_Boolean_Boolean is not null access function
(Self : access Gtk_Scrolled_Window_Record'Class;
Scroll : Gtk.Enums.Gtk_Scroll_Type; Horizontal : Boolean) return Boolean; type Cb_GObject_Gtk_Scroll_Type_Boolean_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Scroll : Gtk.Enums.Gtk_Scroll_Type; Horizontal : Boolean) return Boolean; Signal_Scroll_Child : constant Glib.Signal_Name := "scroll-child";
procedure On_Scroll_Child
(Self : not null access Gtk_Scrolled_Window_Record;
Call : Cb_Gtk_Scrolled_Window_Gtk_Scroll_Type_Boolean_Boolean;
After : Boolean := False);
procedure On_Scroll_Child
(Self : not null access Gtk_Scrolled_Window_Record;
Call : Cb_GObject_Gtk_Scroll_Type_Boolean_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::scroll-child signal is a <link -- linkend="keybinding-signals">keybinding signal</link> which gets emitted -- when a keybinding that scrolls is pressed. The horizontal or vertical -- adjustment is updated which triggers a signal that the scrolled windows -- child may listen to and scroll itself. -- -- Callback parameters: -- -- "scroll": a Gtk.Enums.Gtk_Scroll_Type describing how much to scroll -- -- "horizontal": whether the keybinding scrolls the child horizontally or -- -- not ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Scrolled_Window_Record, Gtk_Scrolled_Window);
function "+"
(Widget : access Gtk_Scrolled_Window_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Scrolled_Window
renames Implements_Gtk_Buildable.To_Object;
private Window_Placement_Set_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("window-placement-set");
Window_Placement_Property : constant Gtk.Enums.Property_Gtk_Corner_Type :=
Gtk.Enums.Build ("window-placement");
Vscrollbar_Policy_Property : constant Gtk.Enums.Property_Gtk_Policy_Type :=
Gtk.Enums.Build ("vscrollbar-policy");
Vadjustment_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("vadjustment");
Shadow_Type_Property : constant Gtk.Enums.Property_Gtk_Shadow_Type :=
Gtk.Enums.Build ("shadow-type");
Min_Content_Width_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("min-content-width");
Min_Content_Height_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("min-content-height");
Kinetic_Scrolling_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("kinetic-scrolling");
Hscrollbar_Policy_Property : constant Gtk.Enums.Property_Gtk_Policy_Type :=
Gtk.Enums.Build ("hscrollbar-policy");
Hadjustment_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("hadjustment");
end Gtk.Scrolled_Window;