This widget organizes its children into resizable panes. Within each pane, multiple children can be put, and they will be accessible through a notebook.
<group>Layout containers</group>
All_Buttons : constant Child_Flags := Destroy_Button;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
type Allowed_Areas is (Central_Only, Sides_Only, Both);
Where is a child allowed to be moved ?
Always_Destroy_Float : constant Child_Flags := 2 ** 4;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
procedure Cancel_Child_Drag
(Child : not null access MDI_Child_Record'Class)
Cancel a drag operation started by Child_Drag_Begin. It doesn't call Child_Drag_Finished.
type Cb_GObject_MDI_Child_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Child : not null access MDI_Child_Record'Class);
type Cb_Gtkada_MDI_Window_MDI_Child_Void is not null access procedure
(Self : access MDI_Window_Record'Class;
Child : not null access MDI_Child_Record'Class);
procedure Change_Group
(Child : not null access MDI_Child_Record'Class;
Group : Child_Group)
Change the child's MDI group.
procedure Check_Interactive_Selection_Dialog
(MDI : access MDI_Window_Record;
Event : Gdk.Event.Gdk_Event;
Move_To_Next : Boolean;
Only_Group : Child_Group := Group_Any)
Open the interactive dialog for selecting windows. This dialog should be open as a result of a key press event. Move_To_Next indicates whether we want to select the next child (True) or the previous child (False). This dialog will be closed only when the key that opened it is fully released. For instance, if the dialog was opened as a result of pressing Ctrl-Tab, the dialog will only be closed when Ctrl itself is released. You can call this procedure even if a dialog is currently open. This simply forces a move to the next or previous child. In fact, it is your responsability to call this procedure when the user presses the keys to move between children.
If Event is null, then no dialog is displayed. Instead, the next or previous visible child is immediately selected. In such a mode, windows that are not on top of their respective notebook are ignored. This can be used to emulate Emacs's behavior for goto-other-window.
If Only_Group is specified, then only the windows from that group will be shown in the dialog.
procedure Child_Drag_Begin
(Child : not null access MDI_Child_Record'Class;
Event : Gdk.Event.Gdk_Event_Button;
Areas : Allowed_Areas)
Starts a drag-and-drop operation for the child, so that it can be put in some other place on the desktop. This should only be called when a handler for the "button_press_event" signal, passing the event itself in parameter. The Child is immediately raised and gains the focus. Areas indicates where the child can be dropped. This is in particular useful if Dnd_Data was overridden and some other child will be dropped instead.
procedure Child_Drag_Finished (Child : not null access MDI_Child_Record)
Called when a drag operation is either aborted or completed. It should be overridden if special cleanup should be done.
type Child_Flags is mod 2 ** 7;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
function Child_Get_Type return Glib.GType
Return the type describing the MDI or a MDI_Child
type Child_Group is new Positive;
This type can be used to help group windows by type within the MDI. Group_Default as a special status when computing the initial position for a window. But you can create your own groups as needed, so that for instance editors tend to be grouped with other editors, graphs with other graphs,... depending on your application. The group has an impact when the last window from a notebook is closed: If the window belongs to Group_Default, and it is the last of its group, then the space currently occupied by that window is not reclaimed, and therefore an empty area will exist in the MDI. The idea is that for instance editors typically play a special role in an integrated development environment, and the users like to have them in the center of the window. When closing the last editor, they do not want the side windows (browsers, consoles,...) to take up that space that should really only be used for editors. To get such a behavior, editors should belong to Group_Default, and all other windows to custom groups.
Do not use Group_Any, it is used internally with special meanings.
type Child_Iterator is private;
type Child_Position is
(Position_Automatic,
Position_Bottom,
Position_Top,
Position_Left,
Position_Right,
Position_Float);
The initial position of windows within the MDI. In all cases, the initial location for a window is computed with the following algorithm. This algorithm is designed with the notion of groups of windows in mind, so that some windows (typically editors) have a special status. - If Position_Float, make the window floating - If another window with the same Group is already in the MDI, the new window is put on top of it. - Otherwise, if Position_Automatic, if an empty area exists within the MDI, the new window is put in that area. - Else if the Position is Bottom .. Right, the new window is put below all others (resp. to the top, left or right) - Else the window is put on top of the currently selected window
procedure Child_Selected
(Self : not null access MDI_Window_Record'Class;
Child : access MDI_Child_Record'Class := null)
Emit the "child_selected" signal
procedure Close
(MDI : access MDI_Window_Record;
Child : access Gtk.Widget.Gtk_Widget_Record'Class;
Force : Boolean := False)
Close the child that contains Child, and remove its window from the MDI. See also Close_Child if you need to close a MDI_Child itself. This first checks through a delete_event callback whether the child accepts to be closed. "delete_event" is not sent, and the child is automatically closed, if Force is set to True.
procedure Close_Child
(Child : not null access MDI_Child_Record'Class;
Force : Boolean := False;
Focus_Same_Area : Boolean := True)
Same as Close, but applies directly to a MDI_Child. If Focus_Same_Area is True, the focus will return to the previously focused child in the same area / notebook as Child, and which is not Child itself. Otherwise, the focus will return to the previously focused child, no matter its area/notebook.
procedure Configure
(MDI : access MDI_Window_Record;
Opaque_Resize : Boolean := False;
Close_Floating_Is_Unfloat : Boolean := True;
Title_Font : Pango.Font.Pango_Font_Description := null;
Title_Bar_Color : Gdk.RGBA.Gdk_RGBA := Gdk.RGBA.Null_RGBA;
Focus_Title_Color : Gdk.RGBA.Gdk_RGBA := Gdk.RGBA.Null_RGBA;
Draw_Title_Bars : Title_Bars_Policy := Always;
Tabs_Position : Gtk.Enums.Gtk_Position_Type := Gtk.Enums.Pos_Top;
Show_Tabs_Policy : Show_Tabs_Policy_Enum := Automatic;
Homogeneous_Tabs : Boolean := True;
Tabs_Orientation : Tab_Orientation_Type := Automatic)
Change the setup of the MDI. Close_Floating_Is_Unfloat, if True, means that closing a floating child will put it back in the MDI instead of destroying it (unless its flag Always_Destroy_Float is set). Title_Font is the font used in the title bars (if null, "sans 8" is used). The colors, when Null_Color, will not change the current setup. If Draw_Title_Bars is False, then no extra title bar will be displayed for the MDI children when they are maximized. This saves space on the screen. However, the notebook tabs will be highlighted with Title_Bar_Color in exchange. Tabs_Position indicates where the notebook tabs should be put. Tabs_Orientation indicates how the notebook tabs should be rotated. Show_Tabs_Policy indicates when the notebook tabs should be displayed.
If Homogeneous_Tabs is true, then the notebook tabs will only use their natural size when they all fit in the notebook's width. Otherwise, they are resized (and ellipsized as needed) so that more of them show. Changing this setup requires a restart of the MDI.
Calling configure will define a default CSS to properly theme the MDI. This CSS relies on mainly two widget classes to behave:
mdifocused, corresponding to the notebook having the focus
mdititle, corresponding to the title bar
This default CSS renders the active tab of the active notebook with the color defined in Focus_Title_Color. Same for the color of the title bar (uses Title_Bar_Color for non-active title bar). This behavior can at any point be overridden by users by defining their own and load it at run-time.
Since the move to gtk3, the highlighting of the current tab is left to the gtk+ theme, rather than overwritten in this package. This permits a better integration with the user's theme. It is possible for applications to provide their own CSS, though, using Gtkada.Style.Load_Css_File. Here is an example of such a CSS, which highlights the current tab in the notebook that currently has the focus:
@define-color mdi-tab-color grey;
@define-color mdi-active-tab-color blue;
.mdititle {
border-width: 2px;
background-image: -gtk-gradient(
linear, left top, left bottom,
from(@mdi-tab-color), to(shade(@mdi-tab-color, 1.1)));
}
.mdifocused .mdititle {
background-image: -gtk-gradient(
linear, left top, left bottom,
from(@mdi-active-tab-color),
to(shade(@mdi-active-tab-color, 1.1)));
.mdi tab GtkLabel, .mdi tab GtkImage { opacity: 0.8 }
.mdifocused tab GtkLabel, .mdifocused tab GtkImage { opacity: 1.0}
procedure Create_Float_Window_For_Child
(Child : not null access MDI_Child_Record;
Win : out Gtk.Window.Gtk_Window;
Container : out Gtk.Container.Gtk_Container)
Creates the window to use when a child is made floating. This procedure provides reasonable default, but can be overridden in your application if you have special needs (like creating a window with specific menubar or decorations for instance). Win must be set to the window that has been created, and Container to the area of the window that will contain Child. The window's title will be set automatically. The window's size will be set by the MDI by calling Child.Set_Default_Size_For_Floating_Window.
function Current_Perspective
(MDI : access MDI_Window_Record'Class) return String
Return the name of the currently displayed perspective
function Desktop_Was_Loaded (MDI : access MDI_Window_Record) return Boolean
Return True if a desktop was loaded, False if the MDI is only the result of calls to Gtk_New and Put.
Destroy_Button : constant Child_Flags := 2 ** 2;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
function Dnd_Data
(Child : not null access MDI_Child_Record; Copy : Boolean)
return MDI_Child
When a drag-and-drop operation took place to move a child from one position to the next, this function is called to know what child should be moved. As a result, the implementor can choose whether a copy of the child should be returned (creating a new view for an editor for instance), or if the child itself should be moved (the default). The returned MDI_Child must have been added to the MDI before it is returned. Copy is set to true if a copy operation was requested, to False if a simple move operation was requested. It can be ignored if Child doesn't know how to create a copy of itself for instance.
function Find_MDI_Child
(MDI : access MDI_Window_Record;
Widget : access Gtk.Widget.Gtk_Widget_Record'Class) return MDI_Child
Return the MDI_Child that encapsulates Widget. Widget must be the exact same one you gave in argument to Put. If the child is currently not visible in the perspective (for instance it was created for another perspective, but is not present in the current one), it is inserted automatically back in the MDI.
function Find_MDI_Child_By_Name
(MDI : access MDI_Window_Record;
Name : String) return MDI_Child
Return the first child matching Name. If the child is currently not visible in the perspective (for instance it was created for another perspective, but is not present in the current one), it is inserted automatically back in the MDI.
function Find_MDI_Child_By_Tag
(MDI : access MDI_Window_Record;
Tag : Ada.Tags.Tag;
Visible_Only : Boolean := False) return MDI_Child
Return the first child matching Tag If the child is currently not visible in the perspective (for instance it was created for another perspective, but is not present in the current one), it is inserted automatically back in the MDI. If Visible_Only is True, an invisible child is not returned. This is useful to check whether a child is currently visible.
function Find_MDI_Child_From_Widget
(Widget : access Gtk.Widget.Gtk_Widget_Record'Class) return MDI_Child
Return the MDI child that encapsulate the parent of Widget. As opposed to Find_MDI_Child, Widget can be anywhere within the widget tree. This function properly handles floating children If the child is currently not visible in the perspective (for instance it was created for another perspective, but is not present in the current one), it is inserted automatically back in the MDI.
function First_Child
(MDI : access MDI_Window_Record;
Group_By_Notebook : Boolean := False;
Visible_Only : Boolean := True) return Child_Iterator
Return an access to the first child of the MDI.
If Group_By_Notebook is True, then the children are reported one after the other, but all the widget from the same notebook are reported in the same order as the notebook pages. Floating children do not belong to a notebook, and are also reported together. To find out to which notebook a child belongs, use Get_Notebook below.
If Group_By_Notebook is False, it is garanteed that the first child is the one that currently has the focus in the MDI. The children are returned in the order in which they last had the focus.
If Visible_Only is true, then only those children currently visible in the perspective are returned. The children that were part of a former perspective are not returned.
Float_As_Transient : constant Child_Flags := 2 ** 3;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
procedure Float_Child
(Child : not null access MDI_Child_Record'Class;
Float : Boolean;
Position_At_Mouse : Boolean := True;
X, Y : Gint := 0)
Change the floating state of a child. If Float is True: - if Position_At_Mouse is True, position the window under the mouse pointer. - if Position_At_Mouse is False, use position the window at X, Y.
Float_To_Main : constant Child_Flags := 2 ** 5;
Special flags to set up the widgets: The first is the buttons that should be displayed in the title bar of the MDI children. If Float_As_Transient is set, then the child will be set up as a transient window when floating: on most window managers, it will stay on top of the MDI, but the window will have less decorations in its title bar, in particular no destroy button. In such a case, <Esc> will close the window, or unfloat it depending on the MDI's setup, as is the case for all dialogs in GtkAda. The MDI's setup will be ignored (and the child always destroyed when Esc is pressed) if Always_Destroy_Float is true. Float_To_Main yields the same behavior as Float_As_Transient, except that the floated child will always be attached to the main window. What this means is that the child will stay on top of the MDI, and will persist if you close the current MDI child.
function Get (Iterator : Child_Iterator) return MDI_Child
Return the child pointed to by Iterator. If Iterator is no longer valid, null is returned.
function Get_Allowed_Areas
(Child : not null access MDI_Child_Record'Class) return Allowed_Areas
What areas the child can be put int
function Get_Child_Notebook
(Child : access MDI_Child_Record'Class) return Gtk.Notebook.Gtk_Notebook
Return the notebook that directly contains Child
function Get_Focus_Child
(MDI : access MDI_Window_Record) return MDI_Child
Return the child that currently has the MDI focus. null is returned if no child has the focus.
function Get_Icon
(Child : not null access MDI_Child_Record) return Gdk.Pixbuf.Gdk_Pixbuf
Returns the icon associated with Child. The returned pixbuf is owned by the MDI and must not be freed by the caller.
function Get_Icon_Name
(Child : not null access MDI_Child_Record) return String
Returns the icon associated with Child. The returned pixbuf is owned by the MDI and must not be freed by the caller.
function Get_MDI
(Child : not null access MDI_Child_Record) return MDI_Window
Return the MDI to which Child is associated. In Child is a floating child, it might not be in the MDI window itself.
function Get_Notebook
(Iterator : Child_Iterator) return Gtk.Notebook.Gtk_Notebook
Return the notebook to which the current child belongs. null is returned for floating children
function Get_Short_Title
(Child : not null access MDI_Child_Record) return UTF8_String
Return the name of the notebook tab used when children are maximized.
function Get_State
(Child : not null access MDI_Child_Record) return State_Type
Return the current state of the child
function Get_Tab_Label
(Child : not null access MDI_Child_Record'Class)
return Gtk.Label.Gtk_Label
Return the child's tab label
function Get_Tab_Orientation
(Child : not null access MDI_Child_Record'Class)
return Tab_Orientation_Type
Return the child's tab orientation
function Get_Title
(Child : not null access MDI_Child_Record) return UTF8_String
Return the title for a specific child
function Get_Tooltip
(Child : not null access MDI_Child_Record)
return String
Return the text to use in tooltips for the notebook tabs. The default (or if this function returns the empty string) the title of the child (Get_Title above).
function Get_Tooltip_Is_Markup
(Child : not null access MDI_Child_Record)
return Boolean
Should return True if Get_Tooltip returns a string with special markup like "<b>" for bold text. When this is True, special characters like "<" and ">" must be quoted with backslashes.
function Get_Type return Glib.GType
Return the type describing the MDI or a MDI_Child
function Get_Widget
(Child : access MDI_Child_Record) return Gtk.Widget.Gtk_Widget
Return the widget that Child encapsulates. This is the widget you initially Put() in MDI.
procedure Give_Focus_To_Previous_Child
(Child : access MDI_Child_Record'Class;
From_Same_Area : Boolean := True)
Give focus to the last child. If From_Same_Area is True, it will return the previously focused child in the same area / notebook as Child, and which is not Child itself. Otherwise, it will return the previously focused child, no matter its area/notebook.
Group_Any : constant Child_Group := Child_Group'Last;
This type can be used to help group windows by type within the MDI. Group_Default as a special status when computing the initial position for a window. But you can create your own groups as needed, so that for instance editors tend to be grouped with other editors, graphs with other graphs,... depending on your application. The group has an impact when the last window from a notebook is closed: If the window belongs to Group_Default, and it is the last of its group, then the space currently occupied by that window is not reclaimed, and therefore an empty area will exist in the MDI. The idea is that for instance editors typically play a special role in an integrated development environment, and the users like to have them in the center of the window. When closing the last editor, they do not want the side windows (browsers, consoles,...) to take up that space that should really only be used for editors. To get such a behavior, editors should belong to Group_Default, and all other windows to custom groups.
Do not use Group_Any, it is used internally with special meanings.
Group_Default : constant Child_Group := 1;
This type can be used to help group windows by type within the MDI. Group_Default as a special status when computing the initial position for a window. But you can create your own groups as needed, so that for instance editors tend to be grouped with other editors, graphs with other graphs,... depending on your application. The group has an impact when the last window from a notebook is closed: If the window belongs to Group_Default, and it is the last of its group, then the space currently occupied by that window is not reclaimed, and therefore an empty area will exist in the MDI. The idea is that for instance editors typically play a special role in an integrated development environment, and the users like to have them in the center of the window. When closing the last editor, they do not want the side windows (browsers, consoles,...) to take up that space that should really only be used for editors. To get such a behavior, editors should belong to Group_Default, and all other windows to custom groups.
Do not use Group_Any, it is used internally with special meanings.
procedure Gtk_New
(Child : out MDI_Child;
Widget : access Gtk.Widget.Gtk_Widget_Record'Class;
Flags : Child_Flags := All_Buttons;
Group : Child_Group := Group_Default;
Focus_Widget : Gtk.Widget.Gtk_Widget := null;
Areas : Allowed_Areas := Both)
Create a new MDI child that contains widget. Widget mustn't be of type Gtk_Window.
You shouldn't access Widget directly afterwards, but should manipulate Child only. However, as a special exception, you can still pass Widget as a parameter to the subprograms in this package to manipulate it (e.g. in Raise_Child, ...)
If Focus_Widget is not null, this is the widget that gets the keyboard focus when the child is selected.
procedure Gtk_New
(MDI : out MDI_Window;
Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class;
Independent_Perspectives : Boolean := False)
Create a new MDI window. Note that it is recommended that you modify the style (Set_Background in State_Normal) to have a different color. You should call Setup_Toplevel_Window once you have added the MDI to a toplevel widget, so that focus is correctly handled when the toplevel window gains the focus When Independent_Perspectives is True, switching perspectives will not preserve any window. Otherwise, the windows that are in the central area will be preserved in the new perspective.
function Has_Title_Bar
(Child : not null access MDI_Child_Record) return Boolean
Whether a title bar is currently displayed for Child
procedure Highlight_Child
(Child : not null access MDI_Child_Record; Highlight : Boolean := True)
Highlight the child until it is selected by the user. The color of its menu label and of the text in the notebook tabs is changed. Nothing is done if the child is already fully visible (either in the active page in one of the notebooks, or the child that has the selection in the layout). This is meant to be used as a graphical note to the user that the child has been updated and the user should look at it.
function Independent_Perspectives
(MDI : access MDI_Window_Record) return Boolean
Whether the MDI is using independent perspectives
procedure Initialize
(Child : access MDI_Child_Record'Class;
Widget : access Gtk.Widget.Gtk_Widget_Record'Class;
Flags : Child_Flags := All_Buttons;
Group : Child_Group := Group_Default;
Focus_Widget : Gtk.Widget.Gtk_Widget := null;
Areas : Allowed_Areas := Both)
Internal initialization function. See the section "Creating your own widgets" in the documentation.
procedure Initialize
(MDI : access MDI_Window_Record'Class;
Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class;
Independent_Perspectives : Boolean := False)
Internal initialization function. See the section "Creating your own widgets" in the documentation.
function Is_Floating
(Child : not null access MDI_Child_Record'Class) return Boolean
Return True if Child is currently in a separate window
function Is_Raised
(Child : not null access MDI_Child_Record'Class) return Boolean
Whether the child is currently raised, ie fully visible to the user
function List_Of_Perspectives
(MDI : access MDI_Window_Record)
return GNAT.Strings.String_List_Access
Return the list of perspectives known to the MDI. The caller must not free the list
procedure Lower_Child (Child : not null access MDI_Child_Record'Class)
Put Child in the background. If the children are maximized, this selected the next page from the notebook.
type MDI_Child is access all MDI_Child_Record'Class;
A child of the MDI, that encapsulates the widgets you have put in the MDI window. You can easily convert from this to the initial widget using the functions Find_MDI_Child and Get_Widget.
type MDI_Child_Array is array (Natural range <>) of MDI_Child;
type MDI_Child_Record is new Gtk.Event_Box.Gtk_Event_Box_Record
with private;
A child of the MDI, that encapsulates the widgets you have put in the MDI window. You can easily convert from this to the initial widget using the functions Find_MDI_Child and Get_Widget.
type MDI_Window is access all MDI_Window_Record'Class;
Although this widget is implemented as a gtk_layout, you shouldn't use the standard Gtk_Layout functions like Put and Move yourself.
type MDI_Window_Record is new Gtk.Widget.Gtk_Widget_Record with private;
Although this widget is implemented as a gtk_layout, you shouldn't use the standard Gtk_Layout functions like Put and Move yourself.
procedure Next (Iterator : in out Child_Iterator)
Move to the next child in the MDI
No_Children : constant MDI_Child_Array := (1 .. 0 => null);
procedure On_Before_Destroy_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Before_Destroy_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Before_Remove_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Before_Remove_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Before_Unfloat_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Before_Unfloat_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Child_Added
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Child_Added
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Child_Icon_Changed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Child_Icon_Changed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Child_Removed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Child_Removed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Child_Selected
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Child_Selected
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Child_Title_Changed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Child_Title_Changed
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Delete_Event
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Delete_Event
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Float_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Float_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure On_Unfloat_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_GObject_MDI_Child_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
procedure On_Unfloat_Child
(Self : not null access MDI_Window_Record'Class;
Call : Cb_Gtkada_MDI_Window_MDI_Child_Void;
After : Boolean := False)
procedure Put
(MDI : access MDI_Window_Record;
Child : access MDI_Child_Record'Class;
Initial_Position : Child_Position := Position_Automatic;
Position_At_Mouse : Boolean := True;
X, Y : Gint := 0)
Add a new child to the MDI window, and return its embedding widget. Calling Put does not give the focus to the newly inserted widget. To do that, you should call Set_Focus_Child. If Initial_Position is Position_Float, then position the floating window under the mouse cursor, unless Position_At_Mouse is False, in which case position the window at X, Y.
procedure Raise_Child
(Child : not null access MDI_Child_Record'Class;
Give_Focus : Boolean := True)
Put Child in the foreground. Note that this does not give the focus to this child, unless Give_Focus is set to True. If Child and the current focus child are in the same notebook, Child will always gain the focus, so that the focus is not left on an invisible window.
function Save_Desktop
(Self : not null access MDI_Child_Record) return Glib.Xml_Int.Node_Ptr
A function used to save a child into the desktop. This is similar to Save_Desktop_Function, but is specific to a child, and thus more efficient.
If this function returns some data, that data is saved into the XML for the desktop. If it returns null, however, the MDI will call each of the registered Save_Desktop_Function, until one returns some data.
The resulting node must have a tag that is unique for this type of widget, and this recognized by one of the Load_Desktop_Function so that the child can be recreated when the desktop is loaded from XML.
procedure Set_All_Floating_Mode
(MDI : access MDI_Window_Record; All_Floating : Boolean)
If All_Floating is set to true, the MDI will have a size of 0x0, and all children are set to floating. This can be used if you wish to let the window manager handle the windows. If All_Floating is True, children can no longer be maximized.
procedure Set_Default_Size_For_Floating_Window
(Child : not null access MDI_Child_Record;
Win : not null access Gtk.Window.Gtk_Window_Record'Class;
Width, Height : Glib.Gint)
Set the default size for a floating window. Width and Height are the values that have bee computed, from either the non-floating size of the child, or from the child's preferred size. This procedure can be overridden, though, to force other values, for instance if you would like to restore a specific size.
procedure Set_Dnd_Message
(MDI : access MDI_Window_Record;
Message : String)
Override the message that is displayed in the popup window while performing a drag. By default, this message mentions: "Use control to move the whole notebook" "Use shift to create a new view for editors" so might not be suitable for all applications. You can use markup like "<b>...</b>" to put keywords in bold.
Passing an empty string for Message will restore the default message.
procedure Set_Focus_Child
(MDI : access MDI_Window_Record;
Containing : access Gtk.Widget.Gtk_Widget_Record'Class)
Give the focus to the child containing Containing. This will not Grab_Focus for the child in all cases, since you might want to give the focus to some specific part of your widget (an entry field,...) in some cases. Call this with Containing = null to explicitly unset the current focus child.
procedure Set_Focus_Child (Child : not null access MDI_Child_Record)
Make Child the active widget, and raise it at the top.
procedure Set_Icon
(Child : not null access MDI_Child_Record;
Icon : Gdk.Pixbuf.Gdk_Pixbuf)
Associate an icon with Child. This icon is visible in the title bar, the notebook tabs, the Window menu and the interactive selection dialog. The icon is updated dynamically on the screen. The Icon can safely be unrefed by the caller (and should, if the pixbuf was newly allocated).
procedure Set_Icon_Name
(Child : not null access MDI_Child_Record;
Icon_Name : String)
Associate an icon with Child. This icon is visible in the title bar, the notebook tabs, the Window menu and the interactive selection dialog. The icon is updated dynamically on the screen. The Icon can safely be unrefed by the caller (and should, if the pixbuf was newly allocated).
procedure Set_Size
(MDI : access MDI_Window_Record;
Child : access MDI_Child_Record'Class;
Width : Glib.Gint;
Height : Glib.Gint;
Fixed_Size : Boolean := False)
Forces a new size for a child. If Width or Height is left to -1, the matching size will be computed from the child's requisition. If they are left to 0, the corresponding length is left to its current value. If Fixed_Size is True, then the widget will not be resized when the MDI itself is resized (unless the user has first moved one of the handles to manually resize it). Otherwise, it will grow proportionally with the rest of the MDI.
procedure Set_Tab_Contextual_Menu_Factory
(MDI : access MDI_Window_Record;
Factory : Tab_Contextual_Menu_Factory)
Set (or unset if Factory is null) the callback to create the contextual menu entries when the user clicks on a notebook tab. Factory should add entries to Menu (which already contains the default entries, but you can remove them if needed).
procedure Set_Title
(Child : not null access MDI_Child_Record;
Title : String;
Short_Title : String := "")
Set the title for a child. Title is the title put in titlebar of the children, whereas Short_Title is the name of the notebook tab when children are maximized. By default, it is the same as Title.
The default title is the empty string. This title will be the one used for the window when the child is set to floating state.
Title and Short_Title should preferably be UTF8-encoded, although this procedure will attempt to guess the encoding if the string is not valid UTF8.
Child should already be in the MDI at this point (via a call to Put), so that the "use_short_titles" preference is taken into account.
procedure Setup_Toplevel_Window
(MDI : access MDI_Window_Record;
Parent : access Gtk.Window.Gtk_Window_Record'Class)
Setup Parent to properly handle focus when the window manager changes the window that currently has the focus. Parent must be the toplevel window that contains the MDI.
type Show_Tabs_Policy_Enum is (Always, Never, Automatic);
subtype Side_Position is Child_Position
range Position_Bottom .. Position_Right;
The initial position of windows within the MDI. In all cases, the initial location for a window is computed with the following algorithm. This algorithm is designed with the notion of groups of windows in mind, so that some windows (typically editors) have a special status. - If Position_Float, make the window floating - If another window with the same Group is already in the MDI, the new window is put on top of it. - Otherwise, if Position_Automatic, if an empty area exists within the MDI, the new window is put in that area. - Else if the Position is Bottom .. Right, the new window is put below all others (resp. to the top, left or right) - Else the window is put on top of the currently selected window
Signal_Before_Destroy_Child : constant Signal_Name :=
"before_destroy_child";
Signal_Before_Remove_Child : constant Signal_Name := "before_remove_child";
Signal_Before_Unfloat_Child : constant Signal_Name :=
"before_unfloat_child";
Signal_Child_Added : constant Signal_Name := "child_added";
Signal_Child_Icon_Changed : constant Signal_Name := "child_icon_changed";
Signal_Child_Removed : constant Signal_Name := "child_removed";
Signal_Child_Selected : constant Signal_Name := "child_selected";
Signal_Child_State_Changed : constant Signal_Name := "child_state_changed";
Signal_Child_Title_Changed : constant Signal_Name := "child_title_changed";
Signal_Children_Reorganized : constant Signal_Name :=
"children_reorganized";
Signal_Delete_Event : constant Signal_Name := "delete_event";
Signal_Float_Child : constant Signal_Name := "float_child";
Signal_Maximize_Child : constant Signal_Name := "maximize_child";
Signal_Perspective_Changed : constant Signal_Name := "perspective_changed";
Signal_Perspectives_Added : constant Signal_Name := "perspectives_added";
Signal_Selected : constant Signal_Name := "selected";
Signal_Unfloat_Child : constant Signal_Name := "unfloat_child";
Signal_Unmaximize : constant Signal_Name := "unmaximize";
procedure Split
(MDI : access MDI_Window_Record;
Orientation : Gtk.Enums.Gtk_Orientation;
Child : MDI_Child := null;
Mode : Split_Mode := Before;
Width, Height : Glib.Gint := 0)
Split the notebook containing Child (by default, the current focus child). Mode indicates in which direction the splitting should occur. If you are splitting a child in the central area, splitting will never reuse a window outside of the central area. Width and Height indicate the desired geometry for the splitted area, 0 indicate a 50/50 split.
type Split_Mode is
(Before, Before_Reuse,
After, After_Reuse,
Any_Side_Reuse);
How a child should be split: If "Before", the child is put above or to the left of its current position. A new window is created to containing it. If the "_Reuse" version is used, and a window already exist at that position, the child will be put in it instead of creating a new one. Any_Side_Reuse indicates that the child will be put on either side, depending on where a window already exists. If there is no window on the side, a new one is created.
type State_Type is (Normal, Floating, Invisible);
This type indicates the state of an item in the MDI:
Normal: the item can be manipulated (moved and resized) by the user. It is found either in the middle notebook (maximized items), or in the layout.
Floating: the item has its own toplevel window, and is thus managed by the window manager.
Invisible: the child was part of a previously displayed perspective, but is no longer in the current perspective. We still keep it to reuse it when switching back to the previous perspective.
type Tab_Contextual_Menu_Factory is access procedure
(Child : access MDI_Child_Record'Class;
Menu : access Gtk.Menu.Gtk_Menu_Record'Class);
type Tab_Orientation_Type is
(Automatic, Horizontal, Bottom_To_Top, Top_To_Bottom);
type Title_Bars_Policy is (Always, Never, Central_Only);
procedure Use_Short_Titles_For_Floats
(MDI : access MDI_Window_Record; Short_Titles : Boolean)
If Short_Titles is set to true, only short titles will ever be used either in the title bars (in notebooks) or as the title for floating windows.