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.Font_Selection Subprograms,  Prev: Gtk.Font_Selection Widget Hierarchy,  Up: Package_Gtk.Font_Selection

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

Font_Selection functions
------------------------

procedure Gtk_New
       (Widget             : out    Gtk_Font_Selection);

Create a new font selection widget.
It can be added to any existing container.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Font_Selection.
function Get_Font_Name
       (Fontsel            : access Gtk_Font_Selection_Record)
        return String;

Return the name of the font selected by the user.
It returns an empty string if not font is selected.   The string has
the same format as in Pango.Font.
function Set_Font_Name
       (Fontsel            : access Gtk_Font_Selection_Record;
        Fontname           :        String)
        return Boolean;

Set the name and attributes of the selected font in Fontsel.
Fontname should have the format described in Pango.Font.   Fontself
must have been displayed on the screen already
function Get_Preview_Text
       (Fontsel            : access Gtk_Font_Selection_Record)
        return UTF8_String;

Return the string used to preview the selected font in the dialog.
procedure Set_Preview_Text
       (Fontsel            : access Gtk_Font_Selection_Record;
        Text               :        UTF8_String);

Set the string to use to preview the selected font.
Font_Selection_Dialog functions
-------------------------------

procedure Gtk_New
       (Widget             : out    Gtk_Font_Selection_Dialog;
        Title              :        UTF8_String);

Create a new dialog to select a font.
The font selection widget has its own window, whose title is chosen  by
Title.
function Dialog_Get_Type       return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Font_Selection_Dialog.
function Get_Font_Name
       (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return String;

Return the name of the font selected by the user.
It returns an empty string if not font is selected.   The string has
the same format as excepted in the Gdk.Font package.   This is also the
standard format on X11 systems.
function Set_Font_Name
       (Fsd                : access Gtk_Font_Selection_Dialog_Record;
        Fontname           :        String)
        return Boolean;

Set the name and attributes of the selected font in Fontsel.
Fontname should have the standard format on X11 systems, that fully
describe the family, weight, size, slant, etc. of the font.
function Get_Preview_Text
       (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return UTF8_String;

Return the string used to preview the selected font in the dialog.
procedure Set_Preview_Text
       (Fsd                : access Gtk_Font_Selection_Dialog_Record;
        Text               :        UTF8_String);

Set the string to use to preview the selected font.
function Get_Cancel_Button
       (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return Gtk.Button.Gtk_Button;

Return the Id of the cancel button of the dialog.
You can use this to set up a callback on that button.   The callback
should close the dialog, and ignore any value that has been  set in it.
function Get_OK_Button
       (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return Gtk.Button.Gtk_Button;

Return the Id of the Ok button.
The callback set on this button should close the dialog if the selected
font is valid, and do whatever if should with it.
function Get_Apply_Button
       (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return Gtk.Button.Gtk_Button;

Return the Id of the Apply button.
The callback on this button should temporarily apply the font, but
should be able to cancel its effect if the Cancel button is selected.

File: gtkada_rm.info,  Node: Package_Gtk.Font_Selection_Dialog,  Next: Package_Gtk.Frame,  Prev: Package_Gtk.Font_Selection,  Up: Top

Package Gtk.Font_Selection_Dialog
*********************************


File: gtkada_rm.info,  Node: Package_Gtk.Frame,  Next: Package_Gtk.GEntry,  Prev: Package_Gtk.Font_Selection_Dialog,  Up: Top

Package Gtk.Frame
*****************

A Gtk_Frame is a simple border than can be added to any widget or
group of widget to enhance its visual aspect.   Optionally, a frame can
have a title.

   This is a very convenient widget to visually group related widgets
(like  groups of buttons for instance), possibly with a title to
explain the  purpose of this group.

   A Gtk_Frame has only one child, so you have to put a container like
for  instance a Gtk_Box inside if you want the frame to surround
multiple  widgets.

* Menu:

* Gtk.Frame Widget Hierarchy::
* Gtk.Frame Subprograms::


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

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_Frame    (*note Package_Gtk.Frame::)


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

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

procedure Gtk_New
       (Frame              : out    Gtk_Frame;
        Label              :        UTF8_String := "");

Create a new frame.
If Label is not the empty string, the frame will have a title.
function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Frame.
procedure Set_Label
       (Frame              : access Gtk_Frame_Record;
        Label              :        UTF8_String := "");

Change the label of the frame dynamically.
If Label is the empty string, the frame's label is deleted.
function Get_Label
       (Frame              : access Gtk_Frame_Record)
        return UTF8_String;

Return the label associated with the frame.
procedure Set_Label_Widget
       (Frame              : access Gtk_Frame_Record;
        Label_Widget       : access Gtk.Widget.Gtk_Widget_Record'Class);

Set the label widget for the frame.
This is the widget that will appear embedded in the top edge of the
frame as a title.
procedure Set_Label_Align
       (Frame              : access Gtk_Frame_Record;
        Xalign             :        Gfloat := 0.0;
        Yalign             :        Gfloat := 0.0);

Change the alignment of the title in the frame.
Xalign and Yalign are both percents that indicate the exact position
of the label relative to the top-left corner of the frame.   Note that
Yalign is currently ignored, and the label can only be  displayed on
the top of the frame (0.0 for Xalign means align the label  on the
left, 1.0 means align the label on the right).
procedure Get_Label_Align
       (Frame              : access Gtk_Frame_Record;
        Xalign             : out    Gfloat;
        Yalign             : out    Gfloat);

Return the X and Y alignments of the title in the frame.
procedure Set_Shadow_Type
       (Frame              : access Gtk_Frame_Record;
        The_Type           :        Gtk_Shadow_Type);

Change the visual aspect of the frame.
function Get_Shadow_Type
       (Frame              : access Gtk_Frame_Record)
        return Gtk_Shadow_Type;

Return the visual aspect of the frame.

File: gtkada_rm.info,  Node: Package_Gtk.GEntry,  Next: Package_Gtk.GLArea,  Prev: Package_Gtk.Frame,  Up: Top

Package Gtk.GEntry
******************

A Gtk_Entry is a single line text editing widget.   The text is
automatically scrolled if it is longer than can be displayed  on the
screen, so that the cursor position is visible at all times.

   See Gtk_Text_View for a multiple-line text editing widget.

* Menu:

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


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Editable       (*note Package_Gtk.Editable::)
              \___ Gtk_Entry       (*note Package_Gtk.GEntry::)


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

Signals
=======

   * "activate"

   * "copy_clipboard"

   * "cut_clipboard"

   * "delete_from_cursor"

   * "insert_at_cursor"

   * "move_cursor"

   * "paste_clipboard"

   * "populate_popup"

   * "toggle_overwrite"



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

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

procedure Gtk_New
       (Widget             : out    Gtk_Entry);

Create a new entry with no maximum length for the text
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Entry.
procedure Set_Visibility
       (The_Entry          : access Gtk_Entry_Record;
        Visible            :        Boolean);

Set the visibility of the characters in the entry.
If Visible is set to False, the characters will be replaced with  the
invisible character ('*' by default) in the display, and when the  text
is copied elsewhere.
function Get_Visibility
       (The_Entry          : access Gtk_Entry_Record)
        return Boolean;

Return the visibility of the characters in the entry.
procedure Set_Invisible_Char
       (The_Entry          : access Gtk_Entry_Record;
        Char               :        Gunichar);

Set the character to use in place of the actual text when
Set_Visibility has been called to set text visibility to False.   i.e.
this is the character used in "password mode" to  show the user how
many characters have been typed. The default  invisible char is an
asterisk ('*'). If you set the invisible char  to 0, then the user will
get no feedback at all; there will be  no text on the screen as they
type.
function Get_Invisible_Char
       (The_Entry          : access Gtk_Entry_Record)
        return Gunichar;

Retrieve the character displayed in place of the real characters
for entries with visisbility set to false. See Set_Invisible_Char.
procedure Set_Has_Frame
       (The_Entry          : access Gtk_Entry_Record;
        Setting            :        Boolean := True);

Set whether the entry has a beveled frame around it.
function Get_Has_Frame
       (The_Entry          : access Gtk_Entry_Record)
        return Boolean;

Return whether the entry has a beveled frame.
procedure Set_Max_Length
       (The_Entry          : access Gtk_Entry_Record;
        Max                :        Gint);

Set the maximum length for the text.
The current text is truncated if needed.
function Get_Max_Length
       (The_Entry          : access Gtk_Entry_Record)
        return Gint;

Return the maximum length for the text.
procedure Set_Activates_Default
       (The_Entry          : access Gtk_Entry_Record;
        Setting            :        Boolean);

If Setting is True, pressing Enter in the Entry will activate the
default widget for the window containing the entry. This usually means
that the dialog box containing the entry will be closed, since the
default widget is usually one of the dialog buttons.

   (For experts: if Setting is True, the entry calls
Gtk.Window.Activate_Default on the window containing the entry, in  the
default handler for the "activate" signal.)
function Get_Activates_Default
       (The_Entry          : access Gtk_Entry_Record)
        return Boolean;

Return whether the entry will activate the default widget.
procedure Set_Width_Chars
       (The_Entry          : access Gtk_Entry_Record'Class;
        Width              :        Gint);

Number of characters to leave space for in the entry, on the screen.
This is the number of visible characters, not the maximal number of
characters the entry can contain
function Get_Width_Chars
       (The_Entry          : access Gtk_Entry_Record'Class)
        return Gint;

Return number of characters to leave space for in the entry.
procedure Set_Text
       (The_Entry          : access Gtk_Entry_Record;
        Text               :        UTF8_String);

Modify the text in the entry.
The text is cut at the maximum length that was set when the entry was
created.   The text replaces the current contents.
function Get_Text
       (The_Entry          : access Gtk_Entry_Record)
        return UTF8_String;

Return the current text written in the entry.
procedure Get_Layout_Offsets
       (The_Entry          : access Gtk_Entry_Record;
        X                  : out    Gint;
        Y                  : out    Gint);

Obtain the position of the Pango_Layout used to render text
in the entry, in widget coordinates. Useful if you want to line  up the
text in an entry with some other text, e.g. when using the  entry to
implement editable cells in a sheet widget.

   Also useful to convert mouse events into coordinates inside the
Pango_Layout, e.g. to take some action if some part of the entry text
is clicked.

   Note that as the user scrolls around in the entry the offsets will
change; you'll need to connect to the "notify::scroll_offset"  signal
to track this. Remember when using the Pango_Layout  functions you need
to convert to and from pixels using  Pango_Pixels or Pango_Scale.
function Get_Layout
       (The_Entry          : access Gtk_Entry_Record)
        return Pango.Layout.Pango_Layout;

Return the widget that manages all the layout of text (left-to-right,
right-to-left, fonts,...). Changing the font used for the entry should
be done by changing the font using for this layout. Note that you should
also change the font in the Pango_Context returned by
Get_Pango_Context,  or the next keypress event in the entry will
restore the default initial  font.

   The layout is useful to e.g. convert text positions to pixel
positions,  in combination with Get_Layout_Offsets.  The returned
layout is owned by  the entry so need not be freed by the caller.

File: gtkada_rm.info,  Node: Package_Gtk.GLArea,  Next: Package_Gtk.GRange,  Prev: Package_Gtk.GEntry,  Up: Top

Package Gtk.GLArea
******************

This widget is derived from Gtk_Drawing_Area and provides an area where
it is possible to use the openGL API.

* Menu:

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


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Drawing_Area   (*note Package_Gtk.Drawing_Area::)
              \___ Gtk_GLArea      (*note Package_Gtk.GLArea::)


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

Types
=====

type Attributes_Array is array (Natural range <>) of GL_Configs;


Note: as opposed to what exists in C, you don't need to have  the last
element in the array be GDK_GL_NONE. This is done  transparently by
GtkAda itself.

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

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

procedure Gtk_New
       (Widget             : out    Gtk_GLArea;
        Attr_List          : in     Attributes_Array);

Make an OpenGL widget, Attr_List is passed to glXChooseVisual GLX call.
Attr_List specifies a list of Boolean attributes and enum/integer
attribute/value pairs.   See glXChooseVisual man page for more
explanation on Attr_List.   Widget is created with visual and colormap
of the  requested type and GLX context is created for this widget. You
can't do opengl calls on widget until it has X window. X window  is not
created until widget is realized.
procedure Gtk_New
       (Widget             : out    Gtk_GLArea;
        Attr_List          : in     Attributes_Array;
        Share              : access Gtk_GLArea_Record'Class);

Same as above.
Share specifies the widget with which to share display lists and
texture objects. A non initialized value indicates that no sharing is
to take place.
function Make_Current
       (Glarea             : access Gtk_GLArea_Record'Class)
        return Boolean;

Must be called before rendering into OpenGL widgets.
Return True if rendering to widget is possible. Rendering is not
possible if widget is not Gtk_GLArea widget or widget is not realized.
procedure Swap_Buffers
       (Glarea             : access Gtk_GLArea_Record'Class);

Promote contents of back buffer of Glarea to front buffer.
The contents of front buffer become undefined.

File: gtkada_rm.info,  Node: Package_Gtk.GRange,  Next: Package_Gtk.Gamma_Curve,  Prev: Package_Gtk.GLArea,  Up: Top

Package Gtk.GRange
******************

This widget provides a low level graphical representation of a range of
values. It is used by other widgets such as Gtk_Scale and
Gtk_Scrollbar.

* Menu:

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


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Range          (*note Package_Gtk.Grange::)


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

Types
=====

subtype Gtk_GRange is Gtk_Range;



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

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

function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Range.
procedure Set_Update_Policy
       (The_Range          : access Gtk_Range_Record;
        Policy             :        Gtk_Update_Type);

Set the update policy for the range.
Update_Continuous means that anytime the range slider is moved, the
range value will change and the value_changed signal will be emitted.
Update_Delayed means that the value will be updated after a brief
timeout where no slider motion occurs, so updates are spaced by a short
time rather than continuous.   Update_Discontinuous means that the
value will only be updated when the  user releases the button and ends
the slider drag operation.
function Get_Update_Policy
       (The_Range          : access Gtk_Range_Record)
        return Gtk_Update_Type;

Return the current update policy.
procedure Set_Adjustment
       (The_Range          : access Gtk_Range_Record;
        Adjustment         :        Gtk.Adjustment.Gtk_Adjustment);

Set the adjustment to be used as the "model" object for this range
widget. The adjustment indicates the current range value, the  minimum
and maximum range values, the step/page increments used  for
keybindings and scrolling, and the page size. The page size  is
normally 0 for Gtk_Scale and nonzero for Gtk_Scrollbar, and  indicates
the size of the visible area of the widget being scrolled.   The page
size affects the size of the scrollbar slider.
function Get_Adjustment
       (The_Range          : access Gtk_Range_Record)
        return Gtk.Adjustment.Gtk_Adjustment;

Return the adjustment associated with the range widget.
procedure Set_Inverted
       (The_Range          : access Gtk_Range_Record;
        Setting            :        Boolean := True);

Ranges normally move from lower to higher values as the slider moves
from top to bottom or left to right. Inverted ranges have higher values
at the top or on the right rather than on the bottom or left.
function Get_Inverted
       (The_Range          : access Gtk_Range_Record)
        return Boolean;

Return whether the range is inverted.
procedure Set_Increments
       (The_Range          : access Gtk_Range_Record;
        Step               :        Gdouble;
        Page               :        Gdouble);

Set the Step and the Page size for the range. The Step size is used when
the user clicks on the Gtk_Scrollbar arrows or moves the Gtk_Scale via
the arrow keys. The Page size is used when moving by pages via the
Page-Up and Page-Down keys for instance.
procedure Set_Range
       (The_Range          : access Gtk_Range_Record;
        Min                :        Gdouble;
        Max                :        Gdouble);

Set the allowable values in the Gtk_Range, and clamps the range value to
the between Min and Max.
procedure Set_Value
       (The_Range          : access Gtk_Range_Record;
        Value              :        Gdouble);

Set the current value of the given Range. If the value is outside the
minimum or the maximum value range, it will be clamped to fit inside
the range.   Cause the "value_changed" signal to be emitted if the
value is  different.
function Get_Value
       (The_Range          : access Gtk_Range_Record)
        return Gdouble;

Return the current value of the range.

File: gtkada_rm.info,  Node: Package_Gtk.Gamma_Curve,  Next: Package_Gtk.Grange,  Prev: Package_Gtk.GRange,  Up: Top

Package Gtk.Gamma`_'Curve
*************************

The Gtk_Gamma_Curve widget is a child of Gtk_Curve specifically for
editing  gamma curves, which are used in graphics applications such as
the Gimp.

   The Gamma_Curve widget shows a curve which the user can edit with
the mouse  just like a Gtk_Curve widget. On the right of the curve it
also displays 5  buttons, 3 of which change between the 3 curve modes
(spline, linear and  free), and the other 2 set the curve to a
particular gamma value, or reset  it to a straight line.

* Menu:

* Gtk.Gamma_Curve Widget Hierarchy::
* Gtk.Gamma_Curve Subprograms::


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

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_Box         (*note Package_Gtk.Box::)
                 \___ Gtk_Gamma_Curve (*note Package_Gtk.Gamma_Curve::)


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

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

procedure Gtk_New
       (Gamma_Curve        : out    Gtk_Gamma_Curve);

Create a new Gtk_Gamma_Curve.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Gamma_Curve.
function Get_Curve
       (Gamma_Curve        : access Gtk_Gamma_Curve_Record)
        return Gtk.Curve.Gtk_Curve;

Return the Curve widget associated with a Gamma_Curve.
function Get_Gamma
       (Gamma_Curve        : access Gtk_Gamma_Curve_Record)
        return Gfloat;

Return the Gamma value associated with a Gamma_Curve.

File: gtkada_rm.info,  Node: Package_Gtk.Grange,  Next: Package_Gtk.Handle_Box,  Prev: Package_Gtk.Gamma_Curve,  Up: Top

Package Gtk.Grange
******************


File: gtkada_rm.info,  Node: Package_Gtk.Handle_Box,  Next: Package_Gtk.Handlers,  Prev: Package_Gtk.Grange,  Up: Top

Package Gtk.Handle`_'Box
************************

The Gtk_Handle_Box widget allows a portion of a window to be "torn off".
It is a bin widget which displays its child and a handle that the user
can  drag to tear off a separate window (the float window) containing
the child  widget. A thin ghost is drawn in the original location of
the handlebox. By  dragging the separate window back to its original
location, it can be  reattached.

   When reattaching, the ghost and float window, must be aligned along
one of  the edges, the snap edge. This either can be specified by the
application  programmer explicitely, or GtkAda will pick a reasonable
default based on  the handle position.

   To make detaching and reattaching the handlebox as minimally
confusing as  possible to the user, it is important to set the snap
edge so that the snap  edge does not move when the handlebox is
detached. For instance, if the  handlebox is packed at the bottom of a
Vbox, then when the handlebox is  detached, the bottom edge of the
handlebox's allocation will remain fixed  as the height of the
handlebox shrinks, so the snap edge should be set to  Pos_Bottom.

* Menu:

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


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

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_Handle_Box (*note Package_Gtk.Handle_Box::)


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

Signals
=======

   * "child-attached"

     procedure Handler
     (Handle_Box : access Gtk_Handle_Box_Record'Class;
     Widget     : access Gtk_Widget_Record'Class);
     Emitted when the contents of the Handle_Box are reattached to the
     main window.  Widget is the child widget of the Handle_Box. (this
     argument provides no extra information and is here only for
     backwards-compatibility)

   * "child-detached"

     procedure Handler
     (Handle_Box : access Gtk_Handle_Box_Record'Class;
     Widget     : access Gtk_Widget_Record'Class);
     Emitted when the contents of the Handle_Box are detached from the
     main window. See "child-attached" for drtails on the parameters.



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

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

procedure Gtk_New
       (Handle_Box         : out    Gtk_Handle_Box);

Create a new Handle_Box.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Dialog.
procedure Set_Shadow_Type
       (Handle_Box         : access Gtk_Handle_Box_Record;
        Typ                :        Enums.Gtk_Shadow_Type);

Set the type of shadow to be drawn around the border of the Handle_Box.
function Get_Shadow_Type
       (Handle_Box         : access Gtk_Handle_Box_Record)
        return Enums.Gtk_Shadow_Type;

Return the shadow type of the handle box.
procedure Set_Handle_Position
       (Handle_Box         : access Gtk_Handle_Box_Record;
        Position           :        Enums.Gtk_Position_Type);

Set the side of the Handle_Box where the handle is drawn.
function Get_Handle_Position
       (Handle_Box         : access Gtk_Handle_Box_Record)
        return Enums.Gtk_Position_Type;

Return the side of the Handle_Box where the handle is drawn.
procedure Set_Snap_Edge
       (Handle_Box         : access Gtk_Handle_Box_Record;
        Edge               :        Enums.Gtk_Position_Type);

Set the snap edge of a Handle_Box.
The snap edge is the edge of the detached child that must be aligned
with the corresponding edge of the "ghost" left behind when the child
was detached to reattach the torn-off window. Usually, the snap edge
should be chosen so that it stays in the same place on the screen when
the Handle_Box is torn off.

   If the snap edge is not set, then an appropriate value will be
guessed  from the handle position. If the handle position is Pos_Right
or  Pos_Left, then the snap edge will be Pos_Top, otherwise it will be
Pos_Left.
function Get_Snap_Edge
       (Handle_Box         : access Gtk_Handle_Box_Record)
        return Enums.Gtk_Position_Type;

Return the snap edge of a Handle_Box.

File: gtkada_rm.info,  Node: Package_Gtk.Handlers,  Next: Package_Gtk.Hbutton_Box,  Prev: Package_Gtk.Handle_Box,  Up: Top

Package Gtk.Handlers
********************

The aim of this package is to provide some services to connect a
handler to a signal emitted by a Gtk Object. To understand the
services provided by this package, some definitions are necessary:

   Signal: A signal is a kind of message that an object wants to
broadcast. All GObjects can emit signals. These messages are
associated to certain events happening during the life of an    object.
For instance, when a user clicks on a button, the    "clicked" signal
is emitted by the button.

   Handler (or callback): A handler is a function or procedure that
the user "connects" to a signal for a particular object.     Connecting
a handler to a signal means associating this handler to    the signal.
When the signal is emitted, all connected handlers    are called back.
Usually, the role of those callbacks is to do    some processing
triggered by a user action. For instance, when    "clicked" signal is
emitted by the "OK" button of a dialog, the    connected handler can be
used to close the dialog or recompute    some value.

   In GtkAda, the handlers are defined in a form as general as
possible. The first argument is always an access to the object it
has been connected to. The second object is a table of values    (See
Glib.Values for more details about this table). It is the
responsibility of this handler to extract the values from it, and    to
convert them to the correct Ada type.

   Because such handlers are not very convenient to use, this package
also provides some services to connect a marshaller instead. It
will then do the extraction work before calling the more
programmer-friendly handler, as defined in Gtk.Marshallers (see
Gtk.Marshallers for more details).

   The subdivision of this package is identical to Gtk.Marshallers; it
is made of four generic sub-packages, each representing one of the
four possible kinds of handlers: they can return a value or not, and
they can have some user specific data associated to them or not.
Selecting the right package depends on the profile of the handler.
For example, the handler for the "delete_event" signal of a  Gtk_Window
has a return value, and has an extra parameter (a Gint).   All handlers
also have a user_data field by default, but its usage  is optional. To
connect a handler to this signal, if the user_data  field is not used,
the Return_Callback generic should be  instantiated. On the other hand,
if the user_data field is  necessary, then the User_Return_Callback
generic should be used.

   Note also that the real handler in Gtk+ should expect at least as
many arguments as in the marshaller you are using. If your  marshaller
has one argument, the C handler must have at least one  argument too.

   The common generic parameter to all sub-packages is the widget type,
which is the basic widget manipulated. This can be
Glib.Object.GObject_Record type if you want to reduce the number of
instantiations, but the conversion to the original type will have to be
done inside the handler.

   All sub-packages are organized in the same way.

   First, the type "Handler" is defined. It represents the general
form of the callbacks supported by the sub-package.

   The corresponding sub-package of Gtk.Marshallers is instantiated.

   A series of "Connect" procedures and functions is given. All cases
are covered: the functions return the Handler_Id of the newly
created association, while the procedures just connect the    handler,
dropping the Handler_Id; some services allow the user to    connect a
Handler while some others allow the usage of    Marshallers, which are
more convenient. Note that more than one    handler may be connected to
a signal; the handlers will then be    invoked in the order of
connection.

   Some "Connect_Object" services are also provided. Those services
never have a user_data. They accept an additional parameter called
Slot_Object. When the callback in invoked, the Gtk Object emitting
the signal is substituted by this Slot_Object.     These callbacks are
always automatically disconnected as soon as one    of the two widgets
involved is destroyed.

   There are several methods to connect a handler. For each method,
although the option of connecting a Handler is provided, the
recommended way is to use Marshallers. Each connect service is
documented below, in the first sub-package.

   A series of "To_Marshaller" functions are provided. They return
some marshallers for the most commonly used types in order to ease
the usage of this package. Most of the time, it will not be
necessary to use some other marshallers.

   As for the "To_Marshaller" functions, a series of "Emit_By_Name"
procedures are also provided for the same most common types, to
allow the user to easily emit signals. These procedures are mainly
intended for people building new GObjects.

   At the end of this package, some general services related to the
management of signals and handlers are also provided. Each one of  them
is documented individually below.

   IMPORTANT NOTE: These packages must be instantiated at library-level

* Menu:

* Gtk.Handlers Example::


File: gtkada_rm.info,  Node: Gtk.Handlers Example,  Up: Package_Gtk.Handlers

Example
=======

      --  This example connects the "delete_event" signal to a widget.
      --  The handlers for this signal get an extra argument which is
      --  the Gdk_Event that generated the signal.
     
      with Gtk.Handlers;    use Gtk.Handlers;
      with Gtk.Marshallers; use Gtk.Marshallers;
     
      function My_Cb (Widget : access Gtk_Widget_Record'Class;
                      Event  : Gdk.Event.Gdk_Event)
                      return Gint;
      --  your own function
     
      package Return_Widget_Cb is new Gtk.Handlers.Return_Callback
         (Gtk.Widget.Gtk_Widget_Record, Gint);
     
      Return_Widget_Cb.Connect (W, "delete_event",
         Return_Widget_Cb.To_Marshaller (My_Cb'Access));


File: gtkada_rm.info,  Node: Package_Gtk.Hbutton_Box,  Next: Package_Gtk.Image,  Prev: Package_Gtk.Handlers,  Up: Top

Package Gtk.Hbutton`_'Box
*************************

A Gtk_Hbutton_Box is a specific Gtk_Button_Box that organizes its
children horizontally.   The beginning of the box (when you add
children with Gtk.Box.Pack_Start)  is on the left of the box. Its end
(for Gtk.Box.Pack_End) is on the right.

* Menu:

* Gtk.Hbutton_Box Widget Hierarchy::
* Gtk.Hbutton_Box Subprograms::


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

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_Box         (*note Package_Gtk.Box::)
                 \___ Gtk_Button_Box (*note Package_Gtk.Button_Box::)
                    \___ Gtk_Hbutton_Box (*note Package_Gtk.Hbutton_Box::)


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

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

procedure Gtk_New
       (Widget             : out    Gtk_Hbutton_Box);

Create a new horizontal button box.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_HButton_Box.

File: gtkada_rm.info,  Node: Package_Gtk.Image,  Next: Package_Gtk.Image_Menu_Item,  Prev: Package_Gtk.Hbutton_Box,  Up: Top

Package Gtk.Image
*****************

The Gtk_Image widget displays a graphical image. The image is typically
created using Gdk.Image.Gdk_New.

   The pixels in a Gtk_Image may be manipulated by the application after
creation, as Gtk_Image store the pixel data on the client side. If you
wish  to store the pixel data on the server side (thus not allowing
manipulation  of the data after creation) you should use Gtk_Pixmap.

* Menu:

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


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Misc           (*note Package_Gtk.Misc::)
              \___ Gtk_Image       (*note Package_Gtk.Image::)


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

Types
=====

type Gtk_Image_Type is
         (Image_Empty,
          Image_Pixmap,
          Image_Image,
          Image_Pixbuf,
          Image_Stock,
          Image_Icon_Set,
          Image_Animation);


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

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

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Val                :        Gdk.Image.Gdk_Image;
        Mask               :        Gdk.Bitmap.Gdk_Bitmap);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Pixmap             :        Gdk.Pixmap.Gdk_Pixmap;
        Mask               :        Gdk.Bitmap.Gdk_Bitmap);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Filename           :        String);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Pixbuf             :        Gdk.Pixbuf.Gdk_Pixbuf);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Stock_Id           :        String;
        Size               :        Gtk.Enums.Gtk_Icon_Size);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Icon_Set           :        Gtk.Icon_Factory.Gtk_Icon_Set;
        Size               :        Gtk.Enums.Gtk_Icon_Size);

procedure Gtk_New
       (Image              : out    Gtk_Image;
        Animation          :        Gdk.Pixbuf.Gdk_Pixbuf_Animation);

Create a GtkImage displaying the given animation.
function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Image.
procedure Set
       (Image              : access Gtk_Image_Record;
        Pixmap             :        Gdk.Pixmap.Gdk_Pixmap;
        Mask               :        Gdk.Bitmap.Gdk_Bitmap);

Set the value of a Gtk_Image.
Mask indicates which parts of the image should be transparent.
procedure Set
       (Image              : access Gtk_Image_Record;
        Val                :        Gdk.Image.Gdk_Image;
        Mask               :        Gdk.Bitmap.Gdk_Bitmap);

Set the value of a Gtk_Image.
Mask indicates which parts of the image should be transparent.
procedure Set
       (Image              : access Gtk_Image_Record;
        File               :        String);

procedure Set
       (Image              : access Gtk_Image_Record;
        Pixbuf             :        Gdk.Pixbuf.Gdk_Pixbuf);

procedure Set
       (Image              : access Gtk_Image_Record;
        Stock_Id           :        String;
        Size               :        Gtk.Enums.Gtk_Icon_Size);

procedure Set
       (Image              : access Gtk_Image_Record;
        Icon_Set           :        Gtk.Icon_Factory.Gtk_Icon_Set;
        Size               :        Gtk.Enums.Gtk_Icon_Size);

procedure Set
       (Image              : access Gtk_Image_Record;
        Animation          :        Gdk.Pixbuf.Gdk_Pixbuf_Animation);

Cause the Image to display the given Animation.
function Get_Storage_Type
       (Image              : access Gtk_Image_Record)
        return Gtk_Image_Type;

procedure Get
       (Image              : access Gtk_Image_Record;
        Pixmap             : out    Gdk.Pixmap.Gdk_Pixmap;
        Mask               : out    Gdk.Bitmap.Gdk_Bitmap);

Get the values of a Gtk_Image.
Mask indicates which parts of the image should be transparent.
procedure Get
       (Image              : access Gtk_Image_Record;
        Val                : out    Gdk.Image.Gdk_Image;
        Mask               : out    Gdk.Bitmap.Gdk_Bitmap);

Get the values of a Gtk_Image.
Mask indicates which parts of the image should be transparent.
function Get
       (Image              : access Gtk_Image_Record)
        return Gdk.Pixbuf.Gdk_Pixbuf;

function Get
       (Image              : access Gtk_Image_Record;
        Size               : access Gtk.Enums.Gtk_Icon_Size)
        return String;

procedure Get
       (Image              : access Gtk_Image_Record;
        Icon_Set           : out    Gtk.Icon_Factory.Gtk_Icon_Set;
        Size               : out    Gtk.Enums.Gtk_Icon_Size);

function Get
       (Image              : access Gtk_Image_Record)
        return Gdk.Pixbuf.Gdk_Pixbuf_Animation;

Get the Pixbuf Animation being displayed by the given Image. The
reference counter for the returned animation is not incremented. This
must be done separately if needed.

File: gtkada_rm.info,  Node: Package_Gtk.Image_Menu_Item,  Next: Package_Gtk.Item,  Prev: Package_Gtk.Image,  Up: Top

Package Gtk.Image`_'Menu`_'Item
*******************************

This widget works like a normal menu_item, but you can insert a
arbitrary widget (most often a pixmap widget), which is displayed  at
the left side. The advantage is that indentation is handled the  same
way as GtkAda does (i.e if you create a menu with a
Gtk_Check_Menu_Item, all normal menu_items are automatically indented by
GtkAda - so if you use a normal menu_item to display pixmaps at the
left  side, the pixmaps will be indented, which is not what you want.
This widget  solves the problem).

* Menu:

* Gtk.Image_Menu_Item Widget Hierarchy::
* Gtk.Image_Menu_Item Subprograms::


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

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_Item     (*note Package_Gtk.Item::)
                    \___ Gtk_Menu_Item (*note Package_Gtk.Menu_Item::)
                       \___ Gtk_Image_Menu_Item (*note Package_Gtk.Image_Menu_Item::)


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

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

procedure Gtk_New
       (Widget             : out    Gtk_Image_Menu_Item;
        Label              :        UTF8_String);

Create a new Gtk_Image_Menu_Item.
If label is non null, set the label of the menu item.
procedure Gtk_New_From_Stock
       (Widget             : out    Gtk_Image_Menu_Item;
        Stock_Id           :        String);

Create a new Gtk_Image_Menu_Item from a stock item.
procedure Gtk_New
       (Widget             : out    Gtk_Image_Menu_Item;
        Stock_Id           :        String;
        Accel_Group        :        Gtk.Accel_Group.Gtk_Accel_Group);

Create a new Gtk_Image_Menu_Item with a label.
If label contains an underscore, a mnemonic is created accordingly.
procedure Gtk_New_With_Mnemonic
       (Widget             : out    Gtk_Image_Menu_Item;
        Label              :        UTF8_String);

Create a new Gtk_Image_Menu_Item with a label.
If label contains an underscore, a mnemonic is created accordingly.
procedure Initialize_With_Mnemonic
       (Widget             : access Gtk_Image_Menu_Item_Record'Class;
        Label              :        UTF8_String);

ditto.
procedure Initialize_From_Stock
       (Widget             : access Gtk_Image_Menu_Item_Record'Class;
        Stock_Id           :        String);

ditto.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with this widget.
procedure Set_Image
       (Menu_Item          : access Gtk_Image_Menu_Item_Record;
        Image              : access Gtk.Widget.Gtk_Widget_Record'Class);

function Get_Image
       (Menu_Item          : access Gtk_Image_Menu_Item_Record)
        return Gtk.Widget.Gtk_Widget;


File: gtkada_rm.info,  Node: Package_Gtk.Item,  Next: Package_Gtk.Label,  Prev: Package_Gtk.Image_Menu_Item,  Up: Top

Package Gtk.Item
****************


File: gtkada_rm.info,  Node: Package_Gtk.Label,  Next: Package_Gtk.Layout,  Prev: Package_Gtk.Item,  Up: Top

Package Gtk.Label
*****************

A Gtk_Label is a light widget associated with some text you want  to
display on the screen. You can change the text dynamically if  needed.

   The text can be on multiple lines if you separate each line with
the ASCII.LF character. However, this is not the recommended way  to
display long texts (see the Gtk_Text widget instead)

* Menu:

* Gtk.Label Widget Hierarchy::
* Gtk.Label Subprograms::


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Misc           (*note Package_Gtk.Misc::)
              \___ Gtk_Label       (*note Package_Gtk.Label::)

