This is gtkada_rm.info, produced by makeinfo version 4.5 from
gtkada_rm.texi.

INFO-DIR-SECTION User Interface Toolkit
START-INFO-DIR-ENTRY
* GtkAda_Rm: (gtkada_rm).           Ada95 graphical tookit based on GTK+ (Reference Manual)
END-INFO-DIR-ENTRY


File: gtkada_rm.info,  Node: Gtk.Misc Subprograms,  Prev: Gtk.Misc Widget Hierarchy,  Up: Package_Gtk.Misc

Subprograms
===========

function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Misc.
procedure Set_Alignment
       (Misc               : access Gtk_Misc_Record;
        Xalign             :        Gfloat;
        Yalign             :        Gfloat);

Modify the alignment for the widget.
Xalign and Yalign are both values between 0.0 and 1.0 that specify the
alignment: if Xalign is 0.0, the widget will be left aligned; if it is
0.5, the widget will be centered; if it is 1.0 the widget will be
right aligned. Yalign is from top (0.0) to bottom (1.0).   Both Xalign
and Yalign will be constrained to the range 0.0 .. 1.0  Note that if
the widget fills its allocated area, these two parameters  won't have
any effect.
procedure Get_Alignment
       (Misc               : access Gtk_Misc_Record;
        Xalign             : out    Gfloat;
        Yalign             : out    Gfloat);

Return the alignment of the widget.
procedure Set_Padding
       (Misc               : access Gtk_Misc_Record;
        Xpad               :        Gint;
        Ypad               :        Gint);

Set the padding (i.e. the extra spaces on the side of the widget).
If Xpad or Ypad is negative, they will be changed to 0.
procedure Get_Padding
       (Misc               : access Gtk_Misc_Record;
        Xpad               : out    Gint;
        Ypad               : out    Gint);

Return the padding of the widget.

File: gtkada_rm.info,  Node: Package_Gtk.Notebook,  Next: Package_Gtk.Object,  Prev: Package_Gtk.Misc,  Up: Top

Package Gtk.Notebook
********************

A Gtk_Notebook is a container that displays all of its children at the
same location on the screen. They are organized into pages, that can be
selected through tabs (either by clicking on them or by a contextual
menu).   This is the best way to organize complicated interfaces that
have a lot  of widgets, by putting the children into groups of coherent
widgets.

   You can hide some of the pages of the notebook by simply calling
Hide on  the widget that is contained in the page (or returned from
Get_Nth_Page).

* Menu:

* Gtk.Notebook Widget Hierarchy::
* Gtk.Notebook Signals::
* Gtk.Notebook Types::
* Gtk.Notebook Subprograms::


File: gtkada_rm.info,  Node: Gtk.Notebook Widget Hierarchy,  Next: Gtk.Notebook Signals,  Up: Package_Gtk.Notebook

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Notebook    (*note Package_Gtk.Notebook::)


File: gtkada_rm.info,  Node: Gtk.Notebook Signals,  Next: Gtk.Notebook Types,  Prev: Gtk.Notebook Widget Hierarchy,  Up: Package_Gtk.Notebook

Signals
=======

   * "focus_tab"

     ???
   * "select_page"

     ???
   * "switch_page"

     procedure Handler
     (Notebook : access Gtk_Notebook_Record'Class;
     Page     : Gtk_Notebook_Page;
     Page_Num : Guint);
     Notify when the current page is modified in the notebook.  This is
     called every time the user selected a new page, or the program
     selected a new page with Next_Page, Prev_Page, ...



File: gtkada_rm.info,  Node: Gtk.Notebook Types,  Next: Gtk.Notebook Subprograms,  Prev: Gtk.Notebook Signals,  Up: Package_Gtk.Notebook

Types
=====

subtype Gtk_Notebook_Page is Gtk.Gtk_Notebook_Page;


type Gtk_Notebook_Tab is
         (Notebook_Tab_First,
          Notebook_Tab_Last);


File: gtkada_rm.info,  Node: Gtk.Notebook Subprograms,  Prev: Gtk.Notebook Types,  Up: Package_Gtk.Notebook

Subprograms
===========

Creating a notebook and inserting pages
---------------------------------------

procedure Gtk_New
       (Widget             : out    Gtk_Notebook);

Create a new empty notebook.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Notebook.
procedure Append_Page
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class);

Insert a new page in Notebook.
The page is put at the end of the list of pages.   The user will select
it through a button that contains the  Tab_Label widget, which is
generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   No entry is associated with the page in the contextual menu.
procedure Append_Page
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class);

Same as above, but no label is specified.
procedure Append_Page_Menu
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class;
        Menu_Label         : access Gtk.Widget.Gtk_Widget_Record'Class);

Insert a new page in Notebook.
The page is put at the end of the list of pages.   The user will select
it through a button that contains the  Tab_Label widget, which is
generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   A new entry is inserted into the contextual menu. This new
entry is  made with Menu_Label.
procedure Prepend_Page
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class);

Insert a new page in Notebook.
The page is put at the beginning of the list of pages.   The user will
select it through a button that contains the  Tab_Label widget, which
is generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   No entry is associated with the page in the contextual menu.
procedure Prepend_Page_Menu
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class;
        Menu_Label         : access Gtk.Widget.Gtk_Widget_Record'Class);

Insert a new page in Notebook.
The page is put at the beginning of the list of pages.   The user will
select it through a button that contains the  Tab_Label widget, which
is generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   A new entry is inserted into the contextual menu. This new
entry is  made with Menu_Label.
procedure Insert_Page
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class;
        Position           :        Gint);

Insert a new page at a specific position in Notebook.
The page is put at the beginning of the list of pages.   The user will
select it through a button that contains the  Tab_Label widget, which
is generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   No entry is associated with the page in the contextual menu.
The first position in the list of pages is 0.
procedure Insert_Page_Menu
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class;
        Menu_Label         : access Gtk.Widget.Gtk_Widget_Record'Class;
        Position           :        Gint);

Insert a new page at a specific position in Notebook.
The page is put at the beginning of the list of pages.   The user will
select it through a button that contains the  Tab_Label widget, which
is generally a Gtk_Label, but could be a box  with a pixmap in it for
instance.   A new entry is inserted into the contextual menu. This new
entry is  made with Menu_Label.   The first position in the list of
pages is 0.
procedure Remove_Page
       (Notebook           : access Gtk_Notebook_Record;
        Page_Num           :        Gint);

Remove a page from the notebook.
The first position in the list of pages is 0.
Modifying and getting the current page
--------------------------------------

function Get_Current_Page
       (Notebook           : access Gtk_Notebook_Record)
        return Gint;

Get the number of the current page.
The first page has the number 0.
function Get_Nth_Page
       (Widget             : access Gtk_Notebook_Record'Class;
        Page_Num           :        Gint)
        return Gtk.Widget.Gtk_Widget;

Convert from a page number to the real page.
function Page_Num
       (Widget             : access Gtk_Notebook_Record'Class;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class)
        return Gint;

Convert from a child to a page number.
Note that Child is not the notebook page, but the widget you inserted
with Insert_Page, Append_Page,...
procedure Set_Current_Page
       (Notebook           : access Gtk_Notebook_Record;
        Page_Num           : in     Gint := -1);

Modify the current page.
The current page is the page that is currently visible on the screen.
Nothing happens if there is no such page.   Note also that the page has
to be visible on the screen (ie you must  have called Gtk.Widget.Show
on it first).   Use -1 to set the current page to the last one.

   Note: This call won't succeeded unless you have called Show on the
widget displayed in the page.
procedure Set_Page
       (Notebook           : access Gtk_Notebook_Record;
        Page_Num           : in     Gint := -1);

procedure Next_Page
       (Notebook           : access Gtk_Notebook_Record);

Display the next page on the screen.
procedure Prev_Page
       (Notebook           : access Gtk_Notebook_Record);

Display the previous page on the screen.
Style and visual aspect
-----------------------

procedure Set_Show_Border
       (Notebook           : access Gtk_Notebook_Record;
        Show_Border        :        Boolean := True);

Indicate whether the notebook should display borders.
This border gives a 3D aspect to the notebook.
function Get_Show_Border
       (Notebook           : access Gtk_Notebook_Record)
        return Boolean;

Return whether the notebook displays borders.
procedure Set_Show_Tabs
       (Notebook           : access Gtk_Notebook_Record;
        Show_Tabs          :        Boolean := True);

Indicate whether the tabs should be displayed.
If the tabs are not displayed, the only way for the user to select a
new page is through the contextual menu, and thus you should make sure
that the pages were created with the Insert_Page_Menu, ... subprograms.
function Get_Show_Tabs
       (Notebook           : access Gtk_Notebook_Record)
        return Boolean;

Return whether the tabs are displayed.
procedure Set_Tab_Pos
       (Notebook           : access Gtk_Notebook_Record;
        Pos                :        Gtk.Enums.Gtk_Position_Type);

Change the position of the tabs.
The tabs can be displayed on any of the four sides of the notebook.
function Get_Tab_Pos
       (Widget             : access Gtk_Notebook_Record)
        return Gtk.Enums.Gtk_Position_Type;

Return the current position of the tabs.
procedure Set_Scrollable
       (Notebook           : access Gtk_Notebook_Record;
        Scrollable         : in     Boolean := True);

Indicate whether Notebook display scrolling arrows when there are
too many tabs.   The default is not to display such scrolling arrows.
Note also that  a notebook with too many pages, even if the scrolling
is activated,  is sometimes hard to use for the user.
function Get_Scrollable
       (Notebook           : access Gtk_Notebook_Record)
        return Boolean;

Return whether Notebook is scrollable.
See Set_Scrollable for more details.
Popup Menu
----------

The pages of a notebook can be selected both via tabs and a contextual
menu (right mouse button). Note however that the menu is available only
if the pages were inserted with Insert_Page_Menu, Append_Page_Menu or
Prepend_Page_Menu.

procedure Popup_Enable
       (Notebook           : access Gtk_Notebook_Record);

Enable the popup menu.
When the user pressed the right mouse button, a menu is selected that
allows him to select a new page.
procedure Popup_Disable
       (Notebook           : access Gtk_Notebook_Record);

Disable the popup menu.
This menu won't be display any more when the user pressed the right
mouse button.
Page properties
---------------

function Get_Tab_Label
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class)
        return Gtk.Widget.Gtk_Widget;

Return the widget displayed in the tab used to select Page.
This widget is in fact the one given in argument to Insert_Page,etc.
when the page was created.
procedure Set_Tab_Label
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class);

Modify the widget displayed in the tab for the page that contains Child.
Tab_Label is generally a Gtk_Label, although it can also be a Gtk_Box
that contains a Gtk_Pixmap and a Gtk_Label if you want to show pixmaps.
procedure Set_Tab_Label_Text
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Tab_Text           :        UTF8_String);

Modify the text displayed in the tab for the page that contains Child.
This is a less general form of Set_Tab_Label above.
function Get_Tab_Label_Text
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class)
        return UTF8_String;

Return the text displayed in the tab for the page that contains Child.
procedure Set_Tab
       (Notebook           : access Gtk_Notebook_Record;
        Page_Num           :        Gint;
        Tab_Label          : access Gtk.Widget.Gtk_Widget_Record'Class);

Set Notebook tab widget for a given page number.
This function is mainly intended for use by Gate.
function Get_Menu_Label
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class)
        return Gtk.Widget.Gtk_Widget;

Return the widget displayed in the contextual menu for the Child.
This is the widget given in argument to Insert_Page_Menu,
Append_Page_Menu and Prepend_Page_Menu.
procedure Set_Menu_Label
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Menu_Label         : access Gtk.Widget.Gtk_Widget_Record'Class);

Modify the widget displayed in the contextual menu for the page
that contains Child.
procedure Set_Menu_Label_Text
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Menu_Text          :        UTF8_String);

Modify the text displayed in the contextual menu for the page that
contains Child.   This is a less general form of Set_Menu_Label above.
function Get_Menu_Label_Text
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class)
        return UTF8_String;

Return the text displayed in the contextual menu for the page that
contains Child.
procedure Query_Tab_Label_Packing
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             : out    Boolean;
        Fill               : out    Boolean;
        Pack_Type          : out    Gtk.Enums.Gtk_Pack_Type);

Return the packing used for the tab associated with the page
that contains Child.   See the Gtk.Box package for more information on
the parameters.
procedure Set_Tab_Label_Packing
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             :        Boolean;
        Fill               :        Boolean;
        Pack_Type          :        Gtk.Enums.Gtk_Pack_Type);

Modify the packing used for the tab associated with the page that
contains Child.
procedure Reorder_Child
       (Notebook           : access Gtk_Notebook_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Position           :        Gint);

Change the position of the page that contains Child.
List of pages
-------------

function Get_Children
       (Widget             : access Gtk_Notebook_Record)
        return Page_List.Glist;

Return the list of all pages in the notebook.
GValue support
--------------

function Get_Notebook_Page
       (Value              :        Glib.Values.GValue)
        return Gtk_Notebook_Page;

Convert a Value into a notebook page.

File: gtkada_rm.info,  Node: Package_Gtk.Object,  Next: Package_Gtk.Old_Editable,  Prev: Package_Gtk.Notebook,  Up: Top

Package Gtk.Object
******************

This is the base class of the widget hierarchy.   Everything in GtkAda
inherits from this class Gtk_Object, except for a few  structures in
the Gdk.* packages (low-level drawing routines).

   This class provides a set of handful features that you can choose to
reuse  in your applications:

   * Reference counting: an object is not deleted while there exists at
     least    one reference to it. Although GtkAda mostly takes care of
     that aspect    transparently, you might need in some obscure cases
     to increment or    decrement the reference counting for a widget
     manually, so that it is not    removed from memory while you still
     need it.

   * User data: any number of data can be attached to a Gtk_Object or
     one of    its children. Theses data are referenced by a String, in
     a hash-table.     GtkAda itself uses this feature to provide an
     easy conversion between C    and Ada widgets.     Although you
     might prefer to have a completely object-oriented    application
     (and thus associate data through class inheritance), it    might
     be convenient to directly attach some data to your objects.

   * It also contains the basic structures and subprograms required for
     signal    emission. This is of course used to implement the signal
     mechanism in    GtkAda itself, but can also be used to implement a
     Model/View/Controller    framework.

    Note that a lot of functions provided in the C interface are not
provided  here. They are used to emulate an object-oriented language in
C, which can  of course be done much more conveniently in Ada.
Therefore most of these  functions are not needed.

   Here is a brief explanation on how the reference counting and
destruction  process work. You should not have to understand all this
to use GtkAda, but  it might help anyway.

   When an object (descendant of Gtk.Object) is created, it has
initially a  ref_count of 1. A flag is set to say the object is
"floating".  See the  Flags functions in this package for how to
retrieve the status of this  flag.

   When the object gets a parent (ie Gtk.Widget.Set_Parent is called,
possibly  from other subprograms like Gtk.Container.Add,
Gtk.Box.Pack_Start, ...),  the ref_count of the object is incremented
to 2.   If the object was still "floating", it is also "sinked", ie its
ref_count  is decremented to 1, and the "floating" flag is cleared.

   The same behavior as above happens when the object is registered as a
top-level widget (i.e. we know it won't have any parent).

   Thus the normal life cycle of an object is to have a ref_count to 1,
and  not be a "floating" object.

   When the object is destroyed, the following happens:     A temporary
reference to the object is created (call to Ref), and        ref_count
to 2.      The object is shutdown:        It is removed from its parent
(if any), and its ref_count is          decremented to 1.         The
"destroy" signal is emitted, the user's handlers are called,
and then all the handlers connected to the object are destroyed.
The object is unref-ed. If its ref_count goes down to 0 (normal case),
     the memory used by the object and its user_data is freed.

* Menu:

* Gtk.Object Widget Hierarchy::
* Gtk.Object Signals::
* Gtk.Object Subprograms::


File: gtkada_rm.info,  Node: Gtk.Object Widget Hierarchy,  Next: Gtk.Object Signals,  Up: Package_Gtk.Object

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)


File: gtkada_rm.info,  Node: Gtk.Object Signals,  Next: Gtk.Object Subprograms,  Prev: Gtk.Object Widget Hierarchy,  Up: Package_Gtk.Object

Signals
=======

   * "destroy"

     procedure Handler (Object : access Gtk_Object_Record'Class);
     Raised when the object is about to be destroyed. The "destroyed"
     flag has been set on the object first. Handlers should not keep a
     reference on the object.  Note that when your destroy handlers are
     called, the user_data is still available.  The default
     implementation destroys all the handlers.



File: gtkada_rm.info,  Node: Gtk.Object Subprograms,  Prev: Gtk.Object Signals,  Up: Package_Gtk.Object

Subprograms
===========

procedure Sink
       (Object             : access Gtk_Object_Record);

Sink the object.
If the object is floating (does not have a parent yet), it is unref-ed
once and the floating flag is cleared.
procedure Destroy
       (Object             : access Gtk_Object_Record);

Destroy the object.
This emits a "destroy" signal, calls all your handlers, and then
unconnects them all. The object is then unref-ed, and if its reference
count goes down to 0, the memory associated with the object and its
user data is freed.   Note that when you destroy handlers are called,
the user_data is still  available.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Object internally.
function Get_Type
       (Object             : access Gtk_Object_Record)
        return Gtk_Type;

This function is now obsolete, and is temporarily kept for backward
compatibility only. Use Glib.Object.Get_Type instead.   ???
Flags
-----

Each object is associated with a set of flags, that reports the state
of the object.   The following flags are known by all objects:

   * "Destroyed":     Set if the object is marked as destroyed (if its
     reference count is     not yet 0, the memory has not been freed,
     but you should not use it     anyway).

   * "Floating":     The object has no parent yet, since it was just
     created. Its     reference count is still 1 (as it was initially).
     This flag is     cleared as soon as Set_Parent is called on the
     widget or the widget     is qualified as a toplevel widget (see
     Gtk.Container.Register_Toplevel).

function Flags
       (Object             : access Gtk_Object_Record)
        return Guint32;

Return the flags that are set for the object, as a binary mask.
procedure Set_Flags
       (Object             : access Gtk_Object_Record;
        Flags              :        Guint32);

Set some specific flags for the object.
Flags is a mask that will be added to the current flags of the object.
procedure Unset_Flags
       (Object             : access Gtk_Object_Record;
        Flags              :        Guint32);

Unset some specific flags for the object.
Flags is a mask that will be deleted from the current flags of the
object.
function Flag_Is_Set
       (Object             : access Gtk_Object_Record;
        Flag               :        Guint32)
        return Boolean;

Return True if the specific flag Flag is set for the object.
function In_Destruction_Is_Set
       (Object             : access Gtk_Object_Record'Class)
        return Boolean;

Test if the Destroyed flag is set for the object.
function Floating_Is_Set
       (Object             : access Gtk_Object_Record'Class)
        return Boolean;

Test if the Floating flag is set for the object.

File: gtkada_rm.info,  Node: Package_Gtk.Old_Editable,  Next: Package_Gtk.Option_Menu,  Prev: Package_Gtk.Object,  Up: Top

Package Gtk.Old`_'Editable
**************************

This widget is an abstract widget designed to support the common
functionalities of all widgets for editing text. It provides general
services to manipulate an editable widget, a large number of action
signals used for key bindings, and several signals that an  application
can connect to to modify the behavior of a widget.

* Menu:

* Gtk.Old_Editable Widget Hierarchy::
* Gtk.Old_Editable Signals::
* Gtk.Old_Editable Subprograms::


File: gtkada_rm.info,  Node: Gtk.Old_Editable Widget Hierarchy,  Next: Gtk.Old_Editable Signals,  Up: Package_Gtk.Old_Editable

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Old_Editable   (*note Package_Gtk.Old_Editable::)


File: gtkada_rm.info,  Node: Gtk.Old_Editable Signals,  Next: Gtk.Old_Editable Subprograms,  Prev: Gtk.Old_Editable Widget Hierarchy,  Up: Package_Gtk.Old_Editable

Signals
=======

   * "activate"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class);
     Emitted when the user has activated the widget in some fashion.

   * "changed"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class);
     emitted when the user has changed the text of the widget.

   * "copy_clipboard"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class);
     Emitting this signal will copy the current selection to the
     clipboard.

   * "cut_clipboard"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class);
     Emitting this signal will cut the current selection to the
     clipboard.

   * "delete_text"

     procedure Handler (Widget    : access
     Gtk_Old_Editable_Record'Class;
     Start_Pos : in Gint;
     End_Pos   : in Gint);
     Emitted when some text is deleted by the user. As for the
     "insert-text" handler, it is possible to override the default
     behavior by connecting a handler to this signal, and then stopping
     the signal.

   * "insert_text"

     procedure Handler (Widget   : access Gtk_Old_Editable_Record'Class;
     Text     : in UTF8_String;
     Length   : in Gint;
     Position : in Gint_Access);
     Emitted when some text is inserted inside the widget by the user.
     The default handler inserts the text into the widget.  By
     connecting a handler to this signal, and then by stopping the
     signal with Gtk.Handlers.Emit_Stop_By_Name, it is possible to
     modify the inserted text, or even prevent it from being inserted.
     Position.all should be modified by the callback, and indicates the
     new position of the cursor after the text has been inserted.

   * "kill_char"

     procedure Handler (Widget    : access
     Gtk_Old_Editable_Record'Class;
     Direction : in Gint);
     Emitting this signal deletes a single character. If Direction is
     positive, delete forward, else delete backward.

   * "kill_line"

     procedure Handler (Widget    : access
     Gtk_Old_Editable_Record'Class;
     Direction : in Gint);
     Emitting this signal deletes a single line. If Direction is
     positive, delete forward, otherwise delete backward.

   * "kill_word"

     procedure Handler (Widget    : access
     Gtk_Old_Editable_Record'Class;
     Direction : in Gint);
     Emitting this signal deletes a single word. If Direction is
     positive, delete forward, otherwise delete backward.

   * "move_cursor"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class;
     X, Y   : in Gint);
     Emitting this signal will move the cursor position for X
     characters horizontally, and Y characters vertically.

   * "move_page"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class;
     X, Y   : in Gint);
     Emitting this signal will move the cursor for X pages
     horizontally, and Y pages vertically.

   * "move_to_column"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class;
     Column : in Gint);
     Emitting this signal will move the cursor to the given column.

   * "move_to_row"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class;
     Row    : in Gint);
     Emitting this signal will move the cursor to the given row.

   * "move_word"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class;
     N      : in Gint);
     Emitting this signal will move the cursor by N words (N can be
     negative).

   * "paste_clipboard"

     procedure Handler (Widget : access Gtk_Old_Editable_Record'Class);
     Emitting this signal will paste the clipboard into the text of the
     widget at the current cursor position.

   * "set-editable"

     procedure Handler (Widget     : access
     Gtk_Old_Editable_Record'Class;
     Is_Editable: in Boolean);
     Emitting this signal is equivalent to calling Set_Old_Editable.



File: gtkada_rm.info,  Node: Gtk.Old_Editable Subprograms,  Prev: Gtk.Old_Editable Signals,  Up: Package_Gtk.Old_Editable

Subprograms
===========

function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Old_Editable.
procedure Changed
       (Editable           : access Gtk_Old_Editable_Record);

Cause the "changed" signal to be emitted.
procedure Claim_Selection
       (Editable           : access Gtk_Old_Editable_Record;
        Claim              : in     Boolean := True;
        Time               : in     Guint32);

If Claim is set to True, claim the ownership of the primary X selection.
Otherwise, release it. "Time" should be set to the  time of the
last-change time for the specified selection. It is  discarded if it is
earlier than the current last-change time, or  later than the current X
server time.
procedure Copy_Clipboard
       (Editable           : access Gtk_Old_Editable_Record;
        Time               : in     Guint32);

Copy the characters in the current selection to the clipboard.
procedure Cut_Clipboard
       (Editable           : access Gtk_Old_Editable_Record;
        Time               :        Guint32);

Copy the characters in the current selection to the clipboard.
The selection is then deleted.
procedure Delete_Selection
       (Editable           : access Gtk_Old_Editable_Record);

Disclaim and delete the current selection.
procedure Delete_Text
       (Editable           : access Gtk_Old_Editable_Record;
        Start_Pos          :        Gint := 0;
        End_Pos            :        Gint := -1);

Delete the characters from Start_Pos to End_Pos.
If End_Pos is negative, the characters are deleted from Start_Pos to the
end of the text.
function Get_Chars
       (Editable           : access Gtk_Old_Editable_Record;
        Start_Pos          :        Gint := 0;
        End_Pos            :        Gint := -1)
        return UTF8_String;

Get the text from Start_Pos to End_Pos.
If End_Pos is negative, the text from Start_Pos to the end is returned.
function Get_Clipboard_Text
       (Widget             : access Gtk_Old_Editable_Record)
        return UTF8_String;

Return the last text copied from the clipboard.
function Get_Editable
       (Widget             : access Gtk_Old_Editable_Record)
        return Boolean;

Return True if the widget is editable by the user.
procedure Set_Editable
       (Widget             : access Gtk_Old_Editable_Record;
        Editable           :        Boolean := True);

Set the editable status of the entry.
If Editable is False, the user can not modify the contents of the entry.
This does not affect the user of the insertion functions above.
function Get_Has_Selection
       (Widget             : access Gtk_Old_Editable_Record)
        return Boolean;

Return True if the selection is owned by the widget.
function Get_Selection_End_Pos
       (Widget             : access Gtk_Old_Editable_Record)
        return Guint;

Return the position of the end of the current selection.
function Get_Selection_Start_Pos
       (Widget             : access Gtk_Old_Editable_Record)
        return Guint;

Return the position of the beginning of the current selection.
procedure Insert_Text
       (Editable           : access Gtk_Old_Editable_Record;
        New_Text           :        UTF8_String;
        Position           : in out Gint);

Insert the given string at the given position.
Position is set to the new cursor position.
procedure Paste_Clipboard
       (Editable           : access Gtk_Old_Editable_Record;
        Time               :        Guint32);

The contents of the clipboard is pasted into the given widget at
the current cursor position.
procedure Select_Region
       (Editable           : access Gtk_Old_Editable_Record;
        Start              :        Gint;
        The_End            :        Gint := -1);

Select the region of text from Start to The_End.
The characters that are selected are those characters at positions
from Start up to, but not including The_End. If The_End_Pos is
negative, then the characters selected will be those characters  from
Start to the end of the text.
procedure Set_Position
       (Editable           : access Gtk_Old_Editable_Record;
        Position           :        Gint);

Change the position of the cursor in the entry.
The cursor is displayed before the character with the given  index in
the widget (the first character has index 0). The  value must be less
than or equal to the number of characters in the  widget. A value of -1
indicates that the position  should be set after the last character in
the entry.   Note that this position is in characters, not in bytes.
function Get_Position
       (Editable           : access Gtk_Old_Editable_Record)
        return Gint;

Return the position of the cursor.

File: gtkada_rm.info,  Node: Package_Gtk.Option_Menu,  Next: Package_Gtk.Paned,  Prev: Package_Gtk.Old_Editable,  Up: Top

Package Gtk.Option`_'Menu
*************************

A Gtk_Option_Menu is a widget that allows the user to choose from a
list of  valid choices. The Gtk_Option_Menu displays the selected
choice. When  activated, the Gtk_Option_Menu displays a popup Gtk_Menu
which allows the  user to make a new choice.

* Menu:

* Gtk.Option_Menu Widget Hierarchy::
* Gtk.Option_Menu Subprograms::


File: gtkada_rm.info,  Node: Gtk.Option_Menu Widget Hierarchy,  Next: Gtk.Option_Menu Subprograms,  Up: Package_Gtk.Option_Menu

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Bin         (*note Package_Gtk.Bin::)
                 \___ Gtk_Button   (*note Package_Gtk.Button::)
                    \___ Gtk_Option_Menu (*note Package_Gtk.Option_Menu::)


File: gtkada_rm.info,  Node: Gtk.Option_Menu Subprograms,  Prev: Gtk.Option_Menu Widget Hierarchy,  Up: Package_Gtk.Option_Menu

Subprograms
===========

procedure Gtk_New
       (Option_Menu        : out    Gtk_Option_Menu);

Create a new Gtk_Option_Menu.
function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Option_Menu.
function Get_Menu
       (Option_Menu        : access Gtk_Option_Menu_Record)
        return Gtk.Menu.Gtk_Menu;

Return the Gtk_Menu associated with the Gtk_Option_Menu.
procedure Set_Menu
       (Option_Menu        : access Gtk_Option_Menu_Record;
        Menu               : access Widget.Gtk_Widget_Record'Class);

Provide the Gtk_Menu that is popped up to allow the user to choose a new
value. You should provide a simple menu avoiding the use of tearoff menu
items, submenus, and accelerators.
procedure Remove_Menu
       (Option_Menu        : access Gtk_Option_Menu_Record;
        Menu               : access Widget.Gtk_Widget_Record'Class);

Remove the menu from the option menu.
function Get_History
       (Option_Menu        : access Gtk_Option_Menu_Record)
        return Gint;

Return the index corresponding to the menu item selected.
procedure Set_History
       (Option_Menu        : access Gtk_Option_Menu_Record;
        Index              :        Gint);

Select the menu item specified by index making it the newly selected
value for the option menu.

File: gtkada_rm.info,  Node: Package_Gtk.Paned,  Next: Package_Gtk.Plug,  Prev: Package_Gtk.Option_Menu,  Up: Top

Package Gtk.Paned
*****************

A Gtk_Paned is a container that organizes its two children either
horizontally or vertically.   The initial size allocated to the
children depends on the size  they request. However, the user has the
possibility to interactively  move a separation bar between the two to
enlarge one of the children,  while at the same time shrinking the
second one.   The bar can be moved by clicking with the mouse on a
small cursor  displayed in the bar, and then dragging the mouse.

   No additional decoration is provided around the children.

   Each child has two parameters, Resize and Shrink.

   If Shrink is True, then the widget can be made smaller than its
requisition size by the user. Set this to False if you want to  set a
minimum size.

   if Resize is True, this means that the child accepts to be resized,
and  will not require any size. Thus, the size allocated to it will be
the total size allocated to the container minus the size requested by
the other child.   If Resize is False, the child should ask for a
specific size, which it  will get. The other child will be resized
accordingly.   If both Child have the same value for Resize (either
True or False), then  the size allocated to each is a ratio between the
size requested by both.

   When you use Set_Position with a parameter other than -1, or the user
moves the handle to resize the widgets, the behavior of Resize is
canceled.

* Menu:

* Gtk.Paned Widget Hierarchy::
* Gtk.Paned Subprograms::


File: gtkada_rm.info,  Node: Gtk.Paned Widget Hierarchy,  Next: Gtk.Paned Subprograms,  Up: Package_Gtk.Paned

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Paned       (*note Package_Gtk.Paned::)


File: gtkada_rm.info,  Node: Gtk.Paned Subprograms,  Prev: Gtk.Paned Widget Hierarchy,  Up: Package_Gtk.Paned

Subprograms
===========

procedure Gtk_New_Vpaned
       (Widget             : out    Gtk_Paned);

Create a new vertical container.
The children will be displayed one on top of the other.
procedure Gtk_New_Hpaned
       (Widget             : out    Gtk_Paned);

Create a new horizontal container.
The children will be displayed one besides the other.
procedure Initialize_Vpaned
       (Widget             : access Gtk_Paned_Record'Class);

Internal initialization function.
See the section "Creating your own widgets" in the documentation.
procedure Initialize_Hpaned
       (Widget             : access Gtk_Paned_Record'Class);

Internal initialization function.
See the section "Creating your own widgets" in the documentation.
function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Paned.
function Get_Type_Vpaned       return Glib.GType;


Return the internal value associated with a vertical Gtk_Paned.
function Get_Type_Hpaned       return Glib.GType;


Return the internal value associated with a horizontal Gtk_Paned.
procedure Add1
       (Paned              : access Gtk_Paned_Record;
        Child              : access Gtk_Widget_Record'Class);

Add the first child of the container.
The child will be displayed either in the top or in the left pane,
depending on the orientation of the container.   This is equivalent to
using the Pack1 procedure with its default  parameters.
procedure Pack1
       (Paned              : access Gtk_Paned_Record;
        Child              : access Gtk_Widget_Record'Class;
        Resize             :        Boolean := False;
        Shrink             :        Boolean := True);

Add a child to the top or left pane.
You can not change dynamically the attributes Resize and Shrink.
Instead, you have to remove the child from the container, and put it
back with the new value of the attributes. You should also first  call
Gtk.Object.Ref on the child so as to be sure it is not destroyed  when
you remove it, and Gtk.Object.Unref it at the end. See the  example in
testgtk/ in the GtkAda distribution.
procedure Add2
       (Paned              : access Gtk_Paned_Record;
        Child              : access Gtk_Widget_Record'Class);

Add the second child of the container.
It will be displayed in the bottom or right pane, depending on the
container's orientation.   This is equivalent to using Pack2 with its
default parameters.
procedure Pack2
       (Paned              : access Gtk_Paned_Record;
        Child              : access Gtk_Widget_Record'Class;
        Resize             :        Boolean := False;
        Shrink             :        Boolean := False);

Add a child to the bottom or right pane.
function Get_Position
       (Paned              : access Gtk_Paned_Record)
        return Gint;

Return the position of the separator.
procedure Set_Position
       (Paned              : access Gtk_Paned_Record;
        Position           :        Gint);

Change the position of the separator.
If position is negative, the remembered position is forgotten,  and the
division is recomputed from the requisitions of the  children.
Position is in fact the size (either vertically or horizontally,
depending on the container) set for the first child.
function Get_Child1
       (Paned              : access Gtk_Paned_Record)
        return Gtk.Widget.Gtk_Widget;

Return the child displayed in the top or left pane.
function Get_Child2
       (Paned              : access Gtk_Paned_Record)
        return Gtk.Widget.Gtk_Widget;

Return the child displayed in the bottom or right pane.
function Get_Child1_Resize
       (Paned              : access Gtk_Paned_Record)
        return Boolean;

Get the value of the resize attribute for the first child.
function Get_Child2_Resize
       (Paned              : access Gtk_Paned_Record)
        return Boolean;

Get the value of the resize attribute for the second child.
function Get_Child1_Shrink
       (Paned              : access Gtk_Paned_Record)
        return Boolean;

Get the value of the shrink attribute for the first child.
function Get_Child2_Shrink
       (Paned              : access Gtk_Paned_Record)
        return Boolean;

Get the value of the shrink attribute for the second child.

File: gtkada_rm.info,  Node: Package_Gtk.Plug,  Next: Package_Gtk.Progress,  Prev: Package_Gtk.Paned,  Up: Top

Package Gtk.Plug
****************

Note that this package is currently not supported under Win32 systems.

   Together with Gtk_Socket, Gtk_Plug provides the ability to embed
widgets  from one process into another process in a fashion that is
transparent to  the user. One process creates a Gtk_Socket widget and,
passes the XID of  that widgets window to the other process, which then
creates a Gtk_Plug  window with that XID.   Any widgets contained in
the Gtk_Plug then will appear inside the first  applications window.

* Menu:

* Gtk.Plug Widget Hierarchy::
* Gtk.Plug Subprograms::


File: gtkada_rm.info,  Node: Gtk.Plug Widget Hierarchy,  Next: Gtk.Plug Subprograms,  Up: Package_Gtk.Plug

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Bin         (*note Package_Gtk.Bin::)
                 \___ Gtk_Window   (*note Package_Gtk.Window::)
                    \___ Gtk_Plug  (*note Package_Gtk.Plug::)


File: gtkada_rm.info,  Node: Gtk.Plug Subprograms,  Prev: Gtk.Plug Widget Hierarchy,  Up: Package_Gtk.Plug

Subprograms
===========

procedure Gtk_New
       (Plug               : out    Gtk_Plug;
        Socket_Id          :        Guint32);

Create a new plug widget inside the Gtk_Socket identified by socket_id.
Socket_Id is the XID of the socket's window.
function Get_Id
       (Plug               : access Gtk_Plug_Record)
        return Guint32;

Return the low level window id associated with Plug.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Plug.

File: gtkada_rm.info,  Node: Package_Gtk.Progress,  Next: Package_Gtk.Progress_Bar,  Prev: Package_Gtk.Plug,  Up: Top

Package Gtk.Progress
********************


File: gtkada_rm.info,  Node: Package_Gtk.Progress_Bar,  Next: Package_Gtk.Radio_Button,  Prev: Package_Gtk.Progress,  Up: Top

Package Gtk.Progress`_'Bar
**************************

The progress bar provides a convenient way of displaying a state of
completion for typically lengthy tasks.

* Menu:

* Gtk.Progress_Bar Widget Hierarchy::
* Gtk.Progress_Bar Types::
* Gtk.Progress_Bar Subprograms::


File: gtkada_rm.info,  Node: Gtk.Progress_Bar Widget Hierarchy,  Next: Gtk.Progress_Bar Types,  Up: Package_Gtk.Progress_Bar

Widget Hierarchy
================

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Progress       (*note Package_Gtk.Progress::)
              \___ Gtk_Progress_Bar (*note Package_Gtk.Progress_Bar::)


File: gtkada_rm.info,  Node: Gtk.Progress_Bar Types,  Next: Gtk.Progress_Bar Subprograms,  Prev: Gtk.Progress_Bar Widget Hierarchy,  Up: Package_Gtk.Progress_Bar

Types
=====

type Gtk_Progress_Bar_Orientation is
         (Progress_Left_To_Right,
          Progress_Right_To_Left,
          Progress_Bottom_To_Top,
          Progress_Top_To_Bottom);


File: gtkada_rm.info,  Node: Gtk.Progress_Bar Subprograms,  Prev: Gtk.Progress_Bar Types,  Up: Package_Gtk.Progress_Bar

Subprograms
===========

procedure Gtk_New
       (Progress_Bar       : out    Gtk_Progress_Bar);

Create a new progress bar.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Progress_Bar.
procedure Pulse
       (Progress_Bar       : access Gtk_Progress_Bar_Record);

Indicate that some progress is made, but you don't know how much.
Causes the progress bar to enter "activity mode," where a block
bounces back and forth. Each call to Pulse causes the block to move by
a little bit (the amount of movement per pulse is determined by
Set_Pulse_Step).
procedure Set_Text
       (Progress_Bar       : access Gtk_Progress_Bar_Record;
        Text               :        UTF8_String);

Causes the given Text to appear superimposed on the progress bar.
Text: a UTF-8 string.
procedure Set_Fraction
       (Progress_Bar       : access Gtk_Progress_Bar_Record;
        Fraction           :        Gdouble);

Cause the progress bar to "fill in" the given fraction of the bar.
The fraction should be between 0.0 and 1.0, inclusive.
procedure Set_Pulse_Step
       (Progress_Bar       : access Gtk_Progress_Bar_Record;
        Step               :        Gdouble);

Set the fraction of total progress bar length to move the
bouncing block for each call to Pulse.
procedure Set_Orientation
       (Progress_Bar       : access Gtk_Progress_Bar_Record;
        Orientation        :        Gtk_Progress_Bar_Orientation);

Cause the progress bar to switch to a different orientation
(left-to-right, right-to-left, top-to-bottom, or bottom-to-top).
function Get_Text
       (Progress_Bar       : access Gtk_Progress_Bar_Record)
        return UTF8_String;

Retrieve the text displayed superimposed on the progress bar.
function Get_Fraction
       (Progress_Bar       : access Gtk_Progress_Bar_Record)
        return Gdouble;

Return the current fraction of the task that's been completed.
function Get_Pulse_Step
       (Progress_Bar       : access Gtk_Progress_Bar_Record)
        return Gdouble;

Return the pulse step set with Set_Pulse_Step.
function Get_Orientation
       (Progress_Bar       : access Gtk_Progress_Bar_Record)
        return Gtk_Progress_Bar_Orientation;

Return the current progress bar orientation.

File: gtkada_rm.info,  Node: Package_Gtk.Radio_Button,  Next: Package_Gtk.Scrolled_Window,  Prev: Package_Gtk.Progress_Bar,  Up: Top

Package Gtk.Radio`_'Button
**************************

A Gtk_Radio_Button is a simple button that has two states, like a
Gtk_Toggle_Button.   However, Gtk_Radio_Buttons can be grouped together
to get a special  behavior: only one button in the group can be active
at any given time.   Thus, when the user selects one of the buttons
from the group, the button  that was previously selected is disabled.

   The radio buttons always belongs to a group, even if there is only
one in  this group

* Menu:

* Gtk.Radio_Button Widget Hierarchy::
* Gtk.Radio_Button Subprograms::
* Gtk.Radio_Button Example::

