Index

Package: Multi_Paned

Description

package Gtkada.Multi_Paned is

This widget implements a multi-paned widget, similar to the standard Gtk_Paned widget, but which can contain several children side to side.

This widget can mix vertical and horizontal splits

<testgtk>create_splittable.adb</testgtk>

Classes

Gtkada_Multi_Paned_Record 

type Gtkada_Multi_Paned_Record is new Gtk.Fixed.Gtk_Fixed_Record
     with private;

Ancestors:

Primitive operations:

Glib.Object.Deallocate (Inherited)
Glib.Object.Get_Type (Inherited)
Glib.Object.Notify (Inherited)
Glib.Object.Ref (Inherited)
Glib.Object.Ref_Sink (Inherited)
Glib.Object.Unref (Inherited)
Gtk.Container.Add (Inherited)
Gtk.Container.Check_Resize (Inherited)
Gtk.Container.Child_Get_Property (Inherited)
Gtk.Container.Child_Set_Property (Inherited)
Gtk.Container.Child_Type (Inherited)
Gtk.Container.Forall (Inherited)
Gtk.Container.Foreach (Inherited)
Gtk.Container.Get_Border_Width (Inherited)
Gtk.Container.Get_Children (Inherited)
Gtk.Container.Get_Focus_Chain (Inherited)
Gtk.Container.Get_Focus_Child (Inherited)
Gtk.Container.Get_Focus_Hadjustment (Inherited)
Gtk.Container.Get_Focus_Vadjustment (Inherited)
Gtk.Container.Get_Resize_Mode (Inherited)
Gtk.Container.Propagate_Expose (Inherited)
Gtk.Container.Remove (Inherited)
Gtk.Container.Resize_Children (Inherited)
Gtk.Container.Set_Border_Width (Inherited)
Gtk.Container.Set_Focus_Chain (Inherited)
Gtk.Container.Set_Focus_Child (Inherited)
Gtk.Container.Set_Focus_Hadjustment (Inherited)
Gtk.Container.Set_Focus_Vadjustment (Inherited)
Gtk.Container.Set_Reallocate_Redraws (Inherited)
Gtk.Container.Set_Resize_Mode (Inherited)
Gtk.Container.Unset_Focus_Chain (Inherited)
Gtk.Fixed.Get_Has_Window (Inherited)
Gtk.Fixed.Move (Inherited)
Gtk.Fixed.Put (Inherited)
Gtk.Fixed.Set_Has_Window (Inherited)
Gtk.Widget.Activate (Inherited)
Gtk.Widget.Add_Accelerator (Inherited)
Gtk.Widget.Add_Events (Inherited)
Gtk.Widget.Add_Mnemonic_Label (Inherited)
Gtk.Widget.Can_Activate_Accel (Inherited)
Gtk.Widget.Child_Notify (Inherited)
Gtk.Widget.Class_Path (Inherited)
Gtk.Widget.Class_Path_Reversed (Inherited)
Gtk.Widget.Create_Pango_Context (Inherited)
Gtk.Widget.Create_Pango_Layout (Inherited)
Gtk.Widget.Destroy (Inherited)
Gtk.Widget.Draw (Inherited)
Gtk.Widget.Ensure_Style (Inherited)
Gtk.Widget.Error_Bell (Inherited)
Gtk.Widget.Flag_Is_Set (Inherited)
Gtk.Widget.Flags (Inherited)
Gtk.Widget.Freeze_Child_Notify (Inherited)
Gtk.Widget.Get_Allocation_Height (Inherited)
Gtk.Widget.Get_Allocation_Width (Inherited)
Gtk.Widget.Get_Allocation_X (Inherited)
Gtk.Widget.Get_Allocation_Y (Inherited)
Gtk.Widget.Get_Ancestor (Inherited)
Gtk.Widget.Get_Child_Requisition (Inherited)
Gtk.Widget.Get_Child_Visible (Inherited)
Gtk.Widget.Get_Colormap (Inherited)
Gtk.Widget.Get_Composite_Name (Inherited)
Gtk.Widget.Get_Direction (Inherited)
Gtk.Widget.Get_Events (Inherited)
Gtk.Widget.Get_Extension_Events (Inherited)
Gtk.Widget.Get_Has_Tooltip (Inherited)
Gtk.Widget.Get_Name (Inherited)
Gtk.Widget.Get_No_Show_All (Inherited)
Gtk.Widget.Get_Pango_Context (Inherited)
Gtk.Widget.Get_Parent (Inherited)
Gtk.Widget.Get_Parent_Window (Inherited)
Gtk.Widget.Get_Pointer (Inherited)
Gtk.Widget.Get_Root_Window (Inherited)
Gtk.Widget.Get_Size_Request (Inherited)
Gtk.Widget.Get_Snapshot (Inherited)
Gtk.Widget.Get_State (Inherited)
Gtk.Widget.Get_Style (Inherited)
Gtk.Widget.Get_Tooltip_Markup (Inherited)
Gtk.Widget.Get_Tooltip_Text (Inherited)
Gtk.Widget.Get_Tooltip_Window (Inherited)
Gtk.Widget.Get_Toplevel (Inherited)
Gtk.Widget.Get_Visual (Inherited)
Gtk.Widget.Get_Window (Inherited)
Gtk.Widget.Grab_Default (Inherited)
Gtk.Widget.Grab_Focus (Inherited)
Gtk.Widget.Has_Screen (Inherited)
Gtk.Widget.Hide (Inherited)
Gtk.Widget.Hide_All (Inherited)
Gtk.Widget.Input_Shape_Combine_Mask (Inherited)
Gtk.Widget.Intersect (Inherited)
Gtk.Widget.Is_Ancestor (Inherited)
Gtk.Widget.Is_Composited (Inherited)
Gtk.Widget.Is_Focus (Inherited)
Gtk.Widget.Keynav_Failed (Inherited)
Gtk.Widget.List_Mnemonic_Labels (Inherited)
Gtk.Widget.Map (Inherited)
Gtk.Widget.Mnemonic_Activate (Inherited)
Gtk.Widget.Modify_Base (Inherited)
Gtk.Widget.Modify_Bg (Inherited)
Gtk.Widget.Modify_Cursor (Inherited)
Gtk.Widget.Modify_Fg (Inherited)
Gtk.Widget.Modify_Font (Inherited)
Gtk.Widget.Modify_Text (Inherited)
Gtk.Widget.Path (Inherited)
Gtk.Widget.Path_Reversed (Inherited)
Gtk.Widget.Queue_Clear (Inherited)
Gtk.Widget.Queue_Clear_Area (Inherited)
Gtk.Widget.Queue_Draw (Inherited)
Gtk.Widget.Queue_Draw_Area (Inherited)
Gtk.Widget.Queue_Resize (Inherited)
Gtk.Widget.Queue_Resize_No_Redraw (Inherited)
Gtk.Widget.Realize (Inherited)
Gtk.Widget.Region_Intersect (Inherited)
Gtk.Widget.Remove_Accelerator (Inherited)
Gtk.Widget.Remove_Mnemonic_Label (Inherited)
Gtk.Widget.Render_Icon (Inherited)
Gtk.Widget.Reparent (Inherited)
Gtk.Widget.Reset_Rc_Styles (Inherited)
Gtk.Widget.Reset_Shapes (Inherited)
Gtk.Widget.Restore_Default_Style (Inherited)
Gtk.Widget.Send_Expose (Inherited)
Gtk.Widget.Set_Accel_Path (Inherited)
Gtk.Widget.Set_App_Paintable (Inherited)
Gtk.Widget.Set_Child_Visible (Inherited)
Gtk.Widget.Set_Colormap (Inherited)
Gtk.Widget.Set_Composite_Name (Inherited)
Gtk.Widget.Set_Direction (Inherited)
Gtk.Widget.Set_Double_Buffered (Inherited)
Gtk.Widget.Set_Events (Inherited)
Gtk.Widget.Set_Extension_Events (Inherited)
Gtk.Widget.Set_Flags (Inherited)
Gtk.Widget.Set_Has_Tooltip (Inherited)
Gtk.Widget.Set_Name (Inherited)
Gtk.Widget.Set_No_Show_All (Inherited)
Gtk.Widget.Set_Parent (Inherited)
Gtk.Widget.Set_Parent_Window (Inherited)
Gtk.Widget.Set_Redraw_On_Allocate (Inherited)
Gtk.Widget.Set_Scroll_Adjustments (Inherited)
Gtk.Widget.Set_Sensitive (Inherited)
Gtk.Widget.Set_Size_Request (Inherited)
Gtk.Widget.Set_State (Inherited)
Gtk.Widget.Set_Style (Inherited)
Gtk.Widget.Set_Tooltip_Markup (Inherited)
Gtk.Widget.Set_Tooltip_Text (Inherited)
Gtk.Widget.Set_Tooltip_Window (Inherited)
Gtk.Widget.Set_UPosition (Inherited)
Gtk.Widget.Set_USize (Inherited)
Gtk.Widget.Set_Window (Inherited)
Gtk.Widget.Shape_Combine_Mask (Inherited)
Gtk.Widget.Show (Inherited)
Gtk.Widget.Show_All (Inherited)
Gtk.Widget.Show_Now (Inherited)
Gtk.Widget.Size_Allocate (Inherited)
Gtk.Widget.Size_Request (Inherited)
Gtk.Widget.Style_Get_Property (Inherited)
Gtk.Widget.Thaw_Child_Notify (Inherited)
Gtk.Widget.Trigger_Tooltip_Query (Inherited)
Gtk.Widget.Unmap (Inherited)
Gtk.Widget.Unrealize (Inherited)
Gtk.Widget.Unset_Flags (Inherited)
Set_Opaque_Resizing
Splitted_Area

Types

Gtkada_Multi_Paned 

type Gtkada_Multi_Paned is access all Gtkada_Multi_Paned_Record'Class;

Pane 

type Pane is private;
An area of the window, which can is splitted either horizontally or vertically. It can contain one or several children, next to each other, or on top of one another.

Child_Iterator 

type Child_Iterator is private;

Constants & Global variables

Handle_Width 

Handle_Width : constant := 6;
Width, in pixels, of the resizing handles. ??? Should be read from theme with gtk_widget_style_get (gtk_paned, "handle_size", &handle_size, NULL)

Root_Pane (Pane) 

Root_Pane : constant Pane;
The root pane. If you split this one, the newly added window will be next to all other windows. For instance, if you split vertically with the main_pane the following window, you will get: +-----+------+ +-----+------+ | 1 | | | 1 | | +-----+ 3 | => +-----+ 3 | | 2 | | | 2 | | +-----+------+ +-----+------+ | 4 | +------------+

Subprograms & Entries

Gtk_New 

procedure Gtk_New 
(Win: out Gtkada_Multi_Paned);

Initialize 

procedure Initialize 
(Win: access Gtkada_Multi_Paned_Record'Class);
Create a new paned window.

Set_Opaque_Resizing 

procedure Set_Opaque_Resizing 
(Win: access Gtkada_Multi_Paned_Record;
Opaque: Boolean);
Whether resizing of the widgets should be opaque or not. The default is not to do opaque resizing for efficiency reasons

Add_Child 

procedure Add_Child 
(Win: access Gtkada_Multi_Paned_Record;
New_Child: access Gtk.Widget.Gtk_Widget_Record'Class;
Orientation: Gtk.Enums.Gtk_Orientation := Gtk.Enums.Orientation_Horizontal;
Fixed_Size: Boolean := False;
Width, Height: Glib.Gint := -1;
After: Boolean := True);
Add new child, splitting as needed. This should be used when there is no child yet The window is splitted in two by default. However, if Width and Height are specified (or left to -1 for automatic computation), the window is splitted so that amount of screen space is left to the widget (leaving some minimum amount of space to other children as needed). If Fixed_Size is true, then the size of the dock will not change when Win is resized. Otherwise, it will keep its relative size (x% of the total size of Win). This Fixed_Size setting will be reset to False as soon as the user has resized a pane with the mouse.

Split 

procedure Split 
(Win: access Gtkada_Multi_Paned_Record;
Ref_Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
New_Child: access Gtk.Widget.Gtk_Widget_Record'Class;
Orientation: Gtk.Enums.Gtk_Orientation;
Fixed_Size: Boolean := False;
Width, Height: Glib.Gint := -1;
After: Boolean := True);
Split the pane containing Ref_Widget, and add New_Child in the new pane (on the right or at the bottom if After is True, on the left or at the top if After is False).

Set_Size 

procedure Set_Size 
(Win: access Gtkada_Multi_Paned_Record;
Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
Width, Height: Glib.Gint := -1;
Fixed_Size: Boolean := False);
Force a specific size for Widget

Splitted_Area 

function Splitted_Area 
(Win: access Gtkada_Multi_Paned_Record;
Ref_Widget: access Gtk.Widget.Gtk_Widget_Record'Class;
Orientation: Gtk.Enums.Gtk_Orientation;
After: Boolean := True) return Gtk.Widget.Gtk_Widget;
Return the widget in the splitted area next to Ref_Widget if any exist. Orientation and After define which splitted area we are looking at. null is returned if there are no such splitted area.

Get_Pane 

function Get_Pane 
(Win: access Gtkada_Multi_Paned_Record;
Widget: access Gtk.Widget.Gtk_Widget_Record'Class) return Pane;

Get_Pane 

function Get_Pane 
(Current_Pane: Pane) return Pane;
Return the pane that contains the widget. See comment for Split below.

Split 

procedure Split 
(Win: access Gtkada_Multi_Paned_Record;
Ref_Pane: Pane;
New_Child: access Gtk.Widget.Gtk_Widget_Record'Class;
Orientation: Gtk.Enums.Gtk_Orientation;
Fixed_Size: Boolean := False;
Width, Height: Glib.Gint := -1;
After: Boolean := True);
Split Ref_Pane to display New_Child to one of its sides. See the comments for Root_Pane above. The examples below assume that you are using one of the two split procedures, either with a Ref_Pane or a Ref_Widget. In the former case, the pane is obtained with a call to Get_Pane(Ref_Widget). As you will see, the results are different (although they might appear similar sometimes on this simple example. In all these examples, we split either vertically or horizontally, and add a new widget "4". Given the following setup: +---+---+ | 1 | | +---+ 3 | | 2 | | +---+---+ Ref_Pane = Get_Pane ("1") Ref_Widget = "1" Split vertically After=True After=False After=True After=False +---+---+ +---+---+ +---+---+ +---+---+ | 1 | 3 | | 4 | 3 | | 1 | 3 | | 4 | 3 | +---+ | +---+ | +---+ | +---+ | | 2 | | | 1 | | | 4 | | | 1 | | +---+ | +---+ | +---+ | +---+ | | 4 | | | 2 | | | 2 | | | 2 | | +---+---+ +---+---+ +---+---+ +---+---+ Split horizontally After=True After=False After=True After=False +---+---+---+ +---+---+---+ +---+---+---+ +---+---+---+ | 1 | 4 | 3 | | 4 | 1 | 3 | | 1 | 4 | 3 | | 4 | 1 | 3 | +---+ | | | +---+ | +---+---+ | +---+---+ | | 2 | | | | | 2 | | | 2 | | | 2 | | +---+---+---+ +---+---+---+ +-------+---+ +-------+---+ Ref_Pane = Get_Pane ("3") Ref_Widget = "3" Split vertically After=True After=False After=True After=False +---+---+ +-------+ +---+---+ +---+---+ | 1 | 3 | | 4 | | 1 | 3 | | 1 | 4 | +---+ | +---+---+ +---+---+ +---+---+ | 2 | | | 1 | 3 | | 2 | 4 | | 2 | 3 | +---+---+ +---+ | +---+---+ +---+---+ | 4 | | 2 | | +-------+ +---+---+ Split horizontally After=True After=False After=True After=False +---+---+---+ +---+---+---+ +---+---+---+ +---+---+---+ | 1 | 3 | 4 | | 4 | 1 | 3 | | 1 | 3 | 4 | | 1 | 4 | 3 | +---+ | | | +---+ | +---+ | | +---+ | | | 2 | | | | | 2 | | | 2 | | | | 2 | | | +---+---+---+ +---+---+---+ +---+---+---+ +---+---+---+

Freeze 

procedure Freeze 
(Win: access Gtkada_Multi_Paned_Record);
Freeze the window, ie when a child is inserted, no computation of its size is done, and will not generate immediate resizing. You only need to call this procedure when restoring Win to a previously state saved, and never if you are using the GtkAda.MDI which takes care of it on its own.

Thaw 

procedure Thaw 
(Win: access Gtkada_Multi_Paned_Record);
Opposite of Freeze. You should call Size_Allocate on Win afterward to force a recomputation of the size

Start 

function Start 
(Win: access Gtkada_Multi_Paned_Record) return Child_Iterator;
Return an iterator to the first child of the window. This also returns children which are not widget, but are used to organize the window into horizontal and vertical panes

At_End 

function At_End 
(Iter: Child_Iterator) return Boolean;
True if there is no more child to be returned

Next 

procedure Next 
(Iter: in out Child_Iterator);
Move to the next child of Iterator

Get_Widget 

function Get_Widget 
(Iter: Child_Iterator) return Gtk.Widget.Gtk_Widget;
Return the widget embedded in the current child. This returns null if the current child is only used as a pane separator (horizontal or vertical). You mustn't remove the widget from the paned widget, or the iterator becomes invalid.

Get_Orientation 

function Get_Orientation 
(Iter: Child_Iterator) return Gtk.Enums.Gtk_Orientation;
Return the orientation of the current child. This is only relevant if the child doesn't contain a widget (and therefore Get_Widget has returned null).

Get_Depth 

function Get_Depth 
(Iter: Child_Iterator) return Natural;
Return the depth of the current child (0 means the child is at the toplevel, 1 that this is a child directly underneath,...). This can be used to detect when the Iter has finished traversing one of the panes.

Get_Size 

procedure Get_Size 
(Iter: Child_Iterator;
Width, Height: out Gint;
Parent_Width, Parent_Height: out Gint;
Parent_Orientation: out Gtk.Enums.Gtk_Orientation);
Return the size of the current element (pane or widget), as well as the parent's pane (the resizable area that contains notebooks or other panes). The parent size is the total size devoted to its children, omitting the size occupied by resize handles.

Dump 

procedure Dump 
(Split: access Gtkada_Multi_Paned_Record'Class);
Dump the configuration of Split to stdout. This is only intended for testing purposes. If you want to save and restore this configuration, you should look at Gtkada.MDI instead, which contains all the subprograms needed to handle desktops.