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: Gdk.Pixmap Subprograms,  Prev: Gdk.Pixmap Types,  Up: Package_Gdk.Pixmap

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

procedure Gdk_New
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Width              :        Gint;
        Height             :        Gint;
        Depth              :        Gint := -1);

Create a new pixmap with a given size.
Window is used to determine default values for the new pixmap.   Can be
eventually null.   Width is the width of the new pixmap in pixels.
Height is the height of the new pixmap in pixels.   Depth is the depth
(number of bits per pixel) of the new pixmap.   If -1, and window is
not null, the depth of the new pixmap will be  equal to that of window.
Automatically reference the pixmap once.
function Get_Type              return Glib.GType;


Return the internal value associated with Gdk_Pixmap.
procedure Ref
       (Pixmap             :        Gdk_Pixmap);

Add a reference to a pixmap.
procedure Unref
       (Pixmap             :        Gdk_Pixmap);

This is the usual way to destroy a pixmap. The memory is freed when
there is no more reference
procedure Create_From_Data
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Data               :        String;
        Width              :        Gint;
        Height             :        Gint;
        Depth              :        Gint;
        Fg                 :        Color.Gdk_Color;
        Bg                 :        Color.Gdk_Color);

Create a pixmap from data in XBM format.
Window is used to determine default values for the new bitmap, can be
null in which case the root window is used.   Data is the XBM data.
Width is the width of the new bitmap in pixels.   Height is the height
of the new bitmap in pixels.   Depth is the depth (number of bits per
pixel) of the new pixmap.   Fg is the foreground color.   Bg is the
background color.
procedure Create_From_Xpm
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Mask               : in out Gdk.Bitmap.Gdk_Bitmap;
        Transparent        :        Gdk.Color.Gdk_Color;
        Filename           :        String);

Create a pixmap from a XPM file.
Window is used to determine default values for the new pixmap.   Mask
is a pointer to a place to store a bitmap representing the
transparency mask of the XPM file. Can be null, in which case
transparency will be ignored.   Transparent is the color to be used for
the pixels that are transparent  in the input file. Can be null, in
which case a default color will be  used.   Filename is the filename of
a file containing XPM data.
procedure Create_From_Xpm
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Colormap           :        Gdk.Color.Gdk_Colormap;
        Mask               : in out Gdk.Bitmap.Gdk_Bitmap;
        Transparent        :        Gdk.Color.Gdk_Color;
        Filename           :        String);

Create a pixmap from a XPM file using a particular colormap.
Window is used to determine default values for the new pixmap. Can be
null if colormap is given.   Colormap is the Gdk_Colormap that the new
pixmap will use. If omitted,  the colormap for window will be used.
Mask is a pointer to a place to store a bitmap representing the
transparency mask of the XPM file. Can be null, in which case
transparency will be ignored.   Transparent is the color to be used for
the pixels that are transparent  in the input file. Can be null, in
which case a default color will be  used.   Filename is the filename of
a file containing XPM data.
procedure Create_From_Xpm_D
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Mask               : in out Gdk.Bitmap.Gdk_Bitmap;
        Transparent        :        Gdk.Color.Gdk_Color;
        Data               :        Gtkada.Types.Chars_Ptr_Array);

Create a pixmap from data in XPM format.
Window is used to determine default values for the new pixmap.   Mask
is a pointer to a place to store a bitmap representing the
transparency mask of the XPM file. Can be null, in which case
transparency will be ignored.   Transparent will be used for the pixels
that are transparent in the  input file. Can be null in which case a
default color will be used.   Data is a pointer to a string containing
the XPM data.
procedure Create_From_Xpm_D
       (Pixmap             : out    Gdk_Pixmap;
        Window             :        Gdk.Window.Gdk_Window;
        Colormap           :        Gdk.Color.Gdk_Colormap;
        Mask               : in out Gdk.Bitmap.Gdk_Bitmap;
        Transparent        :        Gdk.Color.Gdk_Color;
        Data               :        Gtkada.Types.Chars_Ptr_Array);

Create a pixmap from data in XPM format using a particular colormap.
Window is used to determine default values for the new pixmap.
Colormap is the Gdk_Colormap that the new pixmap will be use. If
omitted, the colormap for window will be used.   Mask is a pointer to a
place to store a bitmap representing the  transparency mask of the XPM
file. Can be null, in which case  transparency will be ignored.
Transparent will be used for the pixels that are transparent in the
input file. Can be null in which case a default color will be used.
Data is a pointer to a string containing the XPM data.

File: gtkada_rm.info,  Node: Package_Gdk.Rgb,  Next: Package_Gdk.Threads,  Prev: Package_Gdk.Pixmap,  Up: Top

Package Gdk.Rgb
***************

This package implements a client-side pixmap. As opposed to the pixmaps
found in Gdk.Pixmap, this one simply implements a local buffer, which
can be manipulated at the pixel level easily. This buffer then needs to
be sent to the server.   The major efficiency difference is that the
same amount of data needs  to be sent to the server no matter how much
things were modified.   Gdk.Pixmaps requires one communication with the
server per drawing  function.   Some X servers are also optimized so
that the buffers in this package  can be implemented in shared memory
with the server, which of course  makes it much faster to transfer the
data.   This package is basically an implementation of XImage (on
X-Window),  which means that it handles transparently different depths,
byte  ordering,... It also provides some color dithering functions.

   See the commands Get_Visual and Get_Cmap below on how to use the
colormaps and visual with this package

   Dithering simulates a higher number of colors than what is available
on  the current visual (only for 8-bit and 16-bit displays).

* Menu:

* Gdk.Rgb Types::
* Gdk.Rgb Subprograms::


File: gtkada_rm.info,  Node: Gdk.Rgb Types,  Next: Gdk.Rgb Subprograms,  Up: Package_Gdk.Rgb

Types
=====

type Gdk_Rgb_Cmap is new Gdk.C_Proxy;


This is the full colormap, ie a set of 256 Rgb items.   You can extract
values using the functions Get or Set below.
type Gdk_Rgb_Dither is
         (Dither_None, Dither_Normal, Dither_Max);

The three kinds of dithering that are implemented in this package:  -
Dither_None: No dithering will be done  - Dither_Normal: Specifies
dithering on 8 bit displays, but not 16-bit.   Usually the best choice.
- Dither_Max: Specifies dithering on every kind of display    for
Gdk_Rgb_Dither'Size use Glib.Gint'Size;
type Rgb_Buffer is array (Natural) of Glib.Guchar;


type Rgb_Buffer_Access is access all Rgb_Buffer;


type Rgb_Cmap_Index is new Natural range 0 .. 255;


subtype Rgb_Item is Glib.Guint32;


This represents the coding for a rbg value. The exact encoding depends
on the visual used and its depth (pseudo-color, true-color, ...)

File: gtkada_rm.info,  Node: Gdk.Rgb Subprograms,  Prev: Gdk.Rgb Types,  Up: Package_Gdk.Rgb

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

function Get_Visual            return Gdk.Visual.Gdk_Visual;


See Get_Cmap.
function Get_Cmap              return Gdk.Color.Gdk_Colormap;


Return the visual and the color map used internally in this package.
Note that these are not the same as returned by Gtk.Widget or
Gdk.Window, and you should use these if you are using this package.

   The drawable you intend to copy the RGB buffer to must use this
visual  and this colormap. Therefore, before creating the widget, you
need to do  the following:
   * Gtk.Widget.Push_Visual (Gdk.Rgb.Get_Visual);

   * Gtk.Widget.Push_Colormap (Gdk.Rgb.Get_Cmap);

   * Gtk_New (....)

   * Gtk.Widget.Pop_Visual;

   * Gtk.Widget.Pop_Colormap;

Color manipulation
------------------

function Xpixel_From_Rgb
       (Value              : in     Rgb_Item)
        return Glib.Gulong;

Convert the Rgb representation to the usual one found in Gdk.Color.
pragma Deprecated (Xpixel_From_Rgb);
procedure GC_Set_Foreground
       (GC                 :        Gdk.GC.Gdk_GC;
        Value              :        Rgb_Item);

See GC_Set_Background.
pragma Deprecated (GC_Set_Foreground);
procedure GC_Set_Background
       (GC                 :        Gdk.GC.Gdk_GC;
        Value              :        Rgb_Item);

Modify the foreground and the background of a graphic context with a
value. These are exactly the same functions has found in Gdk.Gc, but do
not use the same parameters.   pragma Deprecated (GC_Set_Background);
Colormap manipulation
---------------------

function Get
       (Cmap               :        Gdk_Rgb_Cmap;
        Index              :        Rgb_Cmap_Index)
        return Rgb_Item;

Access an item in a colormap.
procedure Set
       (Cmap               :        Gdk_Rgb_Cmap;
        Index              :        Rgb_Cmap_Index;
        Value              :        Rgb_Item);

Set an item in Cmap.
procedure Gdk_New
       (Cmap               : out    Gdk_Rgb_Cmap;
        Colors             :        Glib.Guint32_Array);

Create a colormap.
procedure Free
       (Cmap               :        Gdk_Rgb_Cmap);

Free a colormap.
Drawing Images
--------------

procedure Draw_Rgb_Image
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint);

Render a Gdk buffer with 24 bit Data.
Such a buffer is a one dimensional array of bytes, where every byte
triplet makes up a pixel (byte 0 is red, byte 1 is green and byte 2 is
blue).

   * Width: Number of pixels (byte triplets) per row of the image.

   * Height: Number of rows in the image.

   * RowStride: Number of bytes between rows... (row n+1 will start at
     byte     row n + Rowstride). Gdk.Rgb is faster if both the source
     pointer and     the rowstride are aligned to a 4 byte boundary.

   * (X, Y, Width, Height): Define a region in the target to copy the
      buffer to.

procedure Draw_Rgb_Image_Dithalign
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint;
        Xdith, Ydith       :        Glib.Gint);

Same kind of function as above, but for different buffer types (???).
procedure Draw_Rgb_32_Image
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint);

Same kind of function as above, but for different buffer types (???).
procedure Draw_Rgb_32_Image_Dithalign
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint;
        Xdith, Ydith       :        Glib.Gint);

Same kind of function as above, but for different buffer types (???).
procedure Draw_Gray_Image
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint);

Same kind of function as above, but for different buffer types (???).
procedure Draw_Indexed_Image
       (Drawable           :        Gdk.Drawable.Gdk_Drawable;
        GC                 :        Gdk.GC.Gdk_GC;
        X, Y               :        Glib.Gint;
        Width, Height      :        Glib.Gint;
        Dith               :        Gdk_Rgb_Dither;
        Rgb_Buf            :        Rgb_Buffer;
        Rowstride          :        Glib.Gint;
        Cmap               :        Gdk_Rgb_Cmap);

Same kind of function as above, but for different buffer types (???).

File: gtkada_rm.info,  Node: Package_Gdk.Threads,  Next: Package_Glade,  Prev: Package_Gdk.Rgb,  Up: Top

Package Gdk.Threads
*******************

This package provides simple primitives to write multi-threaded
applications with GtkAda. See the GtkAda User's Guide for more details
(section Tasking with GtkAda).

* Menu:

* Gdk.Threads Subprograms::


File: gtkada_rm.info,  Node: Gdk.Threads Subprograms,  Up: Package_Gdk.Threads

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

procedure G_Init
       (Vtable             :        System.Address
                            := System.Null_Address);

Initialize the Glib internal threading support.
This procedure must be called before any call to Enter or Leave.   The
parameter Vtable should never be used for now.
procedure Init;


Initialize the Gdk internal threading support.
This function must be called after G_Init and before any call to  Enter
or Leave.
procedure Enter;


Take the GtkAda global lock.
See the GtkAda User's Guide for more details (section Tasking with
GtkAda).
procedure Leave;


Release the GtkAda global lock.
See the GtkAda User's Guide for more details (section Tasking with
GtkAda).

File: gtkada_rm.info,  Node: Package_Glade,  Next: Package_Glade.XML,  Prev: Package_Gdk.Threads,  Up: Top

Package Glade
*************

This package is a binding to the libglade library that provides routines
to create widgets dynamically from an XML definition file.   *note
Package_Glade.XML::.

* Menu:

* Glade Subprograms::


File: gtkada_rm.info,  Node: Glade Subprograms,  Up: Package_Glade

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

dynamic loading of libglade extensions
--------------------------------------

procedure Require
       (Library            :        String);

procedure Provide
       (Library            :        String);


File: gtkada_rm.info,  Node: Package_Glade.XML,  Next: Package_Glade_XML,  Prev: Package_Glade,  Up: Top

Package Glade.XML
*****************

This package is a binding to the libglade library that provides routines
to create widgets dynamically from an XML definition file.   *note
Package_Glade::.

* Menu:

* Glade.XML Subprograms::


File: gtkada_rm.info,  Node: Glade.XML Subprograms,  Up: Package_Glade.XML

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

procedure Gtk_New
       (XML                : out    Glade_XML;
        Fname              :        String;
        Root               :        String := "";
        Domain             :        String := "");

Create a new GladeXML object (and the corresponding widgets)
from the XML file fname. Optionally it will only build the  interface
from the widget node Root (if it is not empty). This  feature is useful
if you only want to build say a toolbar or  menu from the XML file, but
not the window it is embedded  in. Note also that the XML parse tree is
cached to speed up  creating another GladeXML object for the same file.

   Domain, if not null, is the international domain to use for  string
translation. *note Package_Gtkada.Intl:: for more  information.
procedure Gtk_New_From_Buffer
       (XML                : out    Glade_XML;
        Buffer             :        String;
        Root               :        String := "";
        Domain             :        String := "");

Create a new Glade_XML.
Similar to previous procedure, but the XML contents are read from memory
directly.
procedure Initialize_From_Buffer
       (XML                : access Glade_XML_Record'Class;
        Buffer             :        String;
        Root               :        String := "";
        Domain             :        String := "");

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 Glade_XML.
procedure Signal_Connect
       (XML                : access Glade_XML_Record;
        Handlername        :        String;
        Func               :        System.Address;
        User_Data          :        System.Address);

Warning: Func should be a lowel level C callback, taking a low level
C widget as the first parameter, e.g:  procedure Func (Widget :
Gtk.Item_Factory.Limited_Widget);
function Get_Widget
       (XML                : access Glade_XML_Record;
        Name               :        String)
        return Gtk_Widget;

This function is used to get the Gtk_Widget corresponding to
name in the interface description. You would use this if you  have to
do anything to the widget after loading.
function Relative_File
       (XML                : access Glade_XML_Record;
        Filename           :        String)
        return String;

This function resolves a relative pathname, using the directory
of the XML file as a base. If the pathname is absolute, then  the
original filename is returned.
function Get_Widget_Name
       (Widget             : access Gtk_Widget_Record'Class)
        return String;

function Get_Widget_Tree
       (Widget             : access Gtk_Widget_Record'Class)
        return Glade_XML;

This function is used to get the GladeXML object that built
this widget.

File: gtkada_rm.info,  Node: Package_Glade_XML,  Next: Package_Glib,  Prev: Package_Glade.XML,  Up: Top

Package Glade_XML
*****************


File: gtkada_rm.info,  Node: Package_Gtk,  Next: Package_Gtk.Accel_Label,  Prev: Package_Glib.XML,  Up: Top

Package Gtk
***********

This package provides some basic Gtk+ functionalities such as getting
the  version number.  For general GtkAda initializations,  *note
Package_Gtk.Main::.

* Menu:

* Gtk Types::
* Gtk Subprograms::


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

Types
=====

type Gtk_Notebook_Page is new Gdk.C_Proxy;


A page of the notebook.   It can contain a single child, and is also
associated with a tab  label used to select that page in the notebook.
subtype Gtk_Type is Glib.GType;


Renaming used for compatiblity.   Note: Gtk_Type_* constants have been
replaced by GType_* constants  in Glib.

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

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

function Major_Version         return Guint;


Return the major version number for Gtk+.
Note that this is not necessarily the same as for GtkAda.   If the
version is 1.2.6, returns 1.
function Minor_Version         return Guint;


Return the minor version number for Gtk+.
Note that this is not necessarily the same as for GtkAda.   If the
version is 1.2.6, returns 2.
function Micro_Version         return Guint;


Return the micro version number for Gtk+.
Note that this is not necessarily the same as for GtkAda.   If the
version is 1.2.6, returns 6.

File: gtkada_rm.info,  Node: Package_Gtk.Accel_Label,  Next: Package_Gtk.Adjustment,  Prev: Package_Gtk,  Up: Top

Package Gtk.Accel`_'Label
*************************

The Gtk_Accel_Label widget is a child of Gtk_Label that also displays an
accelerator key on the right of the label text, e.g. 'Ctl+S'. It is
commonly used in menus to show the keyboard short-cuts for commands.

   The accelerator key to display is not set explicitly. Instead, the
Gtk_Accel_Label displays the accelerators which have been added to a
particular widget. This widget is set by calling Set_Accel_Widget.

   For example, a Gtk_Menu_Item widget may have an accelerator added to
emit  the "activate" signal when the 'Ctl+S' key combination is pressed.
A Gtk_Accel_Label is created and added to the Gtk_Menu_Item, and
Set_Accel_Widget is called with the Gtk_Menu_Item as the second
argument.   The Gtk_Accel_Label will now display 'Ctl+S' after its
label.

   Note that creating a Gtk_Menu_Item with Gtk_New and a non null
"label"  parameter (ditto for Gtk_Check_Menu_Item and
Gtk_Radio_Menu_Item)  automatically adds a Gtk_Accel_Label to the
Gtk_Menu_Item and calls  Set_Accel_Widget to set it up for you.

   A Gtk_Accel_Label will only display accelerators which have the
Accel_Visible (see Gtk.Accel_Group) flag set. A Gtk_Accel_Label can
display  multiple accelerators and even signal names, though it is
almost always  used to display just one accelerator key.

* Menu:

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


File: gtkada_rm.info,  Node: Gtk.Accel_Label Widget Hierarchy,  Next: Gtk.Accel_Label Subprograms,  Up: Package_Gtk.Accel_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::)
                 \___ Gtk_Accel_Label (*note Package_Gtk.Accel_Label::)


File: gtkada_rm.info,  Node: Gtk.Accel_Label Subprograms,  Next: Gtk.Accel_Label Example,  Prev: Gtk.Accel_Label Widget Hierarchy,  Up: Package_Gtk.Accel_Label

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

procedure Gtk_New
       (Accel_Label        : out    Gtk_Accel_Label;
        Str                :        UTF8_String);

Create a new Gtk_Accel_Label.
Str is the label string.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Accel_Label.
function Get_Accel_Widget
       (Accel_Label        : access Gtk_Accel_Label_Record)
        return Gtk.Widget.Gtk_Widget;

Return the widget monitored by Accel_Label.
function Get_Accel_Width
       (Accel_Label        : access Gtk_Accel_Label_Record)
        return Guint;

Return the width needed to display the accelerator key(s).
This is used by menus to align all of the Gtk_Menu_Item widgets, and
shouldn't be needed by applications.
procedure Set_Accel_Widget
       (Accel_Label        : access Gtk_Accel_Label_Record;
        Accel_Widget       : access Gtk.Widget.Gtk_Widget_Record'Class);

Add an accelerator to a particular widget.
function Refetch
       (Accel_Label        : access Gtk_Accel_Label_Record)
        return Boolean;

Recreate the string representing the accelerator keys.
This should not be needed since the string is automatically updated
whenever accelerators are added or removed from the associated widget.
Always return False.

File: gtkada_rm.info,  Node: Gtk.Accel_Label Example,  Prev: Gtk.Accel_Label Subprograms,  Up: Package_Gtk.Accel_Label

Example
=======

      Creating a simple menu item with an accelerator key.
     
      Save_Item   : Gtk_Menu_Item;
      Accel_Group : Gtk_Accel_Group;
     
      --  Create a Gtk_Accel_Group and add it to the window.
      Gtk_New (Accel_Group);
      Add_Accel_Group (Window, Accel_Group);
     
      --  Create the menu item using the convenience function.
      Gtk_New (Save_Item, "Save");
      Show (Save_Item);
      Add (Menu, Save_Item);
     
      --  Now add the accelerator to the Gtk_Menu_Item. Note that since we called
      --  Gtk_New with a label to create the Gtk_Menu_Item the
      --  Gtk_Accel_Label is automatically set up to display the Gtk_Menu_Item
      --  accelerators. We just need to make sure we use Accel_Visible here.
     
      Add_Accelerator
        (Save_Item, "activate", Accel_Group,
         GDK_S, Control_Mask, Accel_Visible);


File: gtkada_rm.info,  Node: Package_Gtk.Adjustment,  Next: Package_Gtk.Alignment,  Prev: Package_Gtk.Accel_Label,  Up: Top

Package Gtk.Adjustment
**********************

This object represents an adjustable bounded value.   It is used in
many other widgets that have such internal values,  like Gtk_Scrollbar,
Gtk_Spin_Button, Gtk_Range, ...   Modifying the value of these widgets
is done through their  associated adjustments.

   The modification of the value is left to the user, who should  call
Value_Changed or Changed to emit the relevant signals.

   The meaning of the most important fields can be explained on the
following figure (imagine this is a scrollbar):

         [-------|=================|-------------------]
        lower    value        value + page_size       upper

* Menu:

* Gtk.Adjustment Widget Hierarchy::
* Gtk.Adjustment Signals::
* Gtk.Adjustment Subprograms::
* Gtk.Adjustment Example::


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Adjustment        (*note Package_Gtk.Adjustment::)


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

Signals
=======

   * "changed"

     procedure Handler (Adjustment : access
     Gtk_Adjustment_Record'Class);
     This signal is emitted every time one of the parameters is
     modified, except the value.

   * "value_changed"

     procedure Handler (Adjustment : access
     Gtk_Adjustment_Record'Class);
     This signal is emitted every time the value of the adjustment is
     modified



File: gtkada_rm.info,  Node: Gtk.Adjustment Subprograms,  Next: Gtk.Adjustment Example,  Prev: Gtk.Adjustment Signals,  Up: Package_Gtk.Adjustment

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

procedure Gtk_New
       (Adjustment         : out    Gtk_Adjustment;
        Value              :        Gdouble;
        Lower              :        Gdouble;
        Upper              :        Gdouble;
        Step_Increment     :        Gdouble;
        Page_Increment     :        Gdouble;
        Page_Size          :        Gdouble);

Create a new adjustment.
Value is the initial value of the adjustment. It must be in the  range
(Lower .. Upper) and the adjustment's value will never be  outside this
range.   Step_Increment is the value used to make minor adjustments,
such  as when the user clicks on the arrows of a scrollbar.
Page_Increment is used to make major adjustments, such as when  the
user clicks in the through on a scrollbar.   Page_Size is the size of
the area that is currently visible  (for instance in a
Gtk_Scrolled_Window).
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Adjustment.
Read functions
--------------

function Get_Value
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the current value of the adjustment.
function Get_Lower
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the lower bound of the adjustment.
function Get_Upper
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the upper bound of the adjustment.
function Get_Step_Increment
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the step increment of the adjustment.
function Get_Page_Increment
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the page increment of the adjustment.
function Get_Page_Size
       (Adjustment         : access Gtk_Adjustment_Record)
        return Gdouble;

Return the page size of the adjustment.
Write functions
---------------

procedure Set_Value
       (Adjustment         : access Gtk_Adjustment_Record;
        Value              :        Gdouble);

Modify the current value of the adjustment.
You do not need to call Value_Changed after modifying this value,  this
is done automatically.
procedure Set_Lower
       (Adjustment         : access Gtk_Adjustment_Record;
        Lower              :        Gdouble);

Modify the lower bound of the adjustment.
You should call Changed after modifying this value.
procedure Set_Upper
       (Adjustment         : access Gtk_Adjustment_Record;
        Upper              :        Gdouble);

Modify the upper bound of the adjustment.
You should call Changed after modifying this value.
procedure Set_Step_Increment
       (Adjustment         : access Gtk_Adjustment_Record;
        Step_Increment     :        Gdouble);

Modify the step increment of the adjustment.
You should call Changed after modifying this value.
procedure Set_Page_Increment
       (Adjustment         : access Gtk_Adjustment_Record;
        Page_Increment     :        Gdouble);

Modify the page increment of the adjustment.
You should call Changed after modifying this value.
procedure Set_Page_Size
       (Adjustment         : access Gtk_Adjustment_Record;
        Page_Size          :        Gdouble);

Modify the page size of the adjustment.
You should call Changed after modifying this value.
Misc functions
--------------

procedure Clamp_Page
       (Adjustment         : access Gtk_Adjustment_Record;
        Lower              :        Gdouble;
        Upper              :        Gdouble);

Update the Adjustment value to ensure that the range between Lower and
Upper is in the current page (i.e. between value and value +
page_size). If the range is larger than the page size, then only the
start of it will be in the current page.   A "value_changed" signal
will be emitted if the value is changed.
Signals emission
----------------

procedure Changed
       (Adjustment         : access Gtk_Adjustment_Record);

Emit the "changed" signal on Adjustment.
This warns any listener that some field other than the value has been
changed.
procedure Value_Changed
       (Adjustment         : access Gtk_Adjustment_Record);

Emit the "value_changed" signal on Adjustment.
This warns any listener that the value has been changed.

File: gtkada_rm.info,  Node: Gtk.Adjustment Example,  Prev: Gtk.Adjustment Subprograms,  Up: Package_Gtk.Adjustment

Example
=======

         [------|=================|------------------]
        lower    value        value + page_size       upper


File: gtkada_rm.info,  Node: Package_Gtk.Alignment,  Next: Package_Gtk.Arguments,  Prev: Package_Gtk.Adjustment,  Up: Top

Package Gtk.Alignment
*********************

A Gtk_Alignment controls the size and alignment of its single child
inside  the area allocated to the alignment widget.

   The scale/size settings indicate how much the child will expand to
fill  the container. The values should be in the range 0.0 (no
expansion) to 1.0  (full expansion). Note that the scale only indicates
the minimal size for  the child, it does not force an absolute size.

   The alignment settings indicate where in the alignment widget the
child  should be located. The values are in the range 0.0 (top or left)
to 1.0  (bottom or right). These settings are irrelevant if the child
is fully  expanded.

* Menu:

* Gtk.Alignment Widget Hierarchy::
* Gtk.Alignment Subprograms::


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

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_Alignment (*note Package_Gtk.Alignment::)


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

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

procedure Gtk_New
       (Alignment          : out    Gtk_Alignment;
        Xalign             :        Gfloat;
        Yalign             :        Gfloat;
        Xscale             :        Gfloat;
        Yscale             :        Gfloat);

Create a new alignment widget, with initial values for the settings.
See the description of the settings above.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Alignment.
procedure Set
       (Alignment          : access Gtk_Alignment_Record;
        Xalign             :        Gfloat;
        Yalign             :        Gfloat;
        Xscale             :        Gfloat;
        Yscale             :        Gfloat);

Modify the settings for the alignment.
See the description of the settings above.
function Get_Xalign
       (Alignment          : access Gtk_Alignment_Record)
        return Gfloat;

Return the X alignment value.
Its value is in the range 0.0 .. 1.0, from left to right.
function Get_Yalign
       (Alignment          : access Gtk_Alignment_Record)
        return Gfloat;

Return the Y alignment value.
Its value is in the range 0.0 .. 1.0, from top to bottom.
function Get_Xscale
       (Alignment          : access Gtk_Alignment_Record)
        return Gfloat;

Return the X expansion value, in the range 0.0 .. 1.0.
0.0 means no expansion while 1.0 means full expansion.
function Get_Yscale
       (Alignment          : access Gtk_Alignment_Record)
        return Gfloat;

Return the Y expansion value, in the range 0.0 .. 1.0
0.0 means no expansion while 1.0 means full expansion.

File: gtkada_rm.info,  Node: Package_Gtk.Arguments,  Next: Package_Gtk.Arrow,  Prev: Package_Gtk.Alignment,  Up: Top

Package Gtk.Arguments
*********************

This package is obsolete and replaced by Glib.Values  (*note
Package_Glib.Values::.   Future versions of GtkAda will no longer
provide this package.

   This package provides a convenient interface to C, providing easy
conversion from a C's (void*) pointer to any Ada type used in  GtkAda.
Although this package has been designed to be easily  reusable by being
as general as possible, these functions are mainly  used when writing
callbacks and/or marshallers (see Gtk.Marshallers  and Gtk.Handlers).

   Therefore, the main type in this package is Gtk_Args, which is the
equivalent of the C's (GtkArg*) array, i.e an array of unions.  This
package provides functions to extract the values from this type.

* Menu:


File: gtkada_rm.info,  Node: Package_Gtk.Arrow,  Next: Package_Gtk.Aspect_Frame,  Prev: Package_Gtk.Arguments,  Up: Top

Package Gtk.Arrow
*****************

Gtk_Arrow should be used to draw simple arrows that need to point in one
of the four cardinal directions (up, down, left, or right). The style
of  the arrow can be one of shadow in, shadow out, etched in, or etched
out.   Note that these directions and style types may be ammended in
versions of  Gtk to come.

   Gtk_Arrow will fill any space alloted to it, but since it is
inherited from  Gtk_Misc, it can be padded and/or aligned, to fill
exactly the space you  desire.

   Arrows are created with a call to Gtk_New. The direction or style of
an  arrow can be changed after creation by using Set.

* Menu:

* Gtk.Arrow Widget Hierarchy::
* Gtk.Arrow Subprograms::


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

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_Arrow       (*note Package_Gtk.Arrow::)


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

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

procedure Gtk_New
       (Arrow              : out    Gtk_Arrow;
        Arrow_Type         :        Gtk.Enums.Gtk_Arrow_Type;
        Shadow_Type        :        Gtk.Enums.Gtk_Shadow_Type);

Create a new arrow widget.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Arrow.
procedure Set
       (Arrow              : access Gtk_Arrow_Record;
        Arrow_Type         :        Gtk.Enums.Gtk_Arrow_Type;
        Shadow_Type        :        Gtk.Enums.Gtk_Shadow_Type);

Set the direction and style of the Arrow.

File: gtkada_rm.info,  Node: Package_Gtk.Aspect_Frame,  Next: Package_Gtk.Bin,  Prev: Package_Gtk.Arrow,  Up: Top

Package Gtk.Aspect`_'Frame
**************************

A Gtk_Aspect_Frame is the same type of widget as a frame, but it
constrains its child to a specific aspect ratio between its width  and
its height.

   This ratio can either be given explicitly by the user, or chosen
from the  widget's initial size request (might be different from the
one if was  actually given).

* Menu:

* Gtk.Aspect_Frame Widget Hierarchy::
* Gtk.Aspect_Frame Subprograms::


File: gtkada_rm.info,  Node: Gtk.Aspect_Frame Widget Hierarchy,  Next: Gtk.Aspect_Frame Subprograms,  Up: Package_Gtk.Aspect_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::)
                    \___ Gtk_Aspect_Frame (*note Package_Gtk.Aspect_Frame::)


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

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

procedure Gtk_New
       (Aspect_Frame       : out    Gtk_Aspect_Frame;
        Label              :        UTF8_String;
        Xalign             :        Gfloat;
        Yalign             :        Gfloat;
        Ratio              :        Gfloat;
        Obey_Child         :        Boolean);

Create a new Aspect_Frame.
If Label is the empty string, then the frame won't have any title.
Xalign and Yalign are constrained to the range 0.0 .. 1.0 and specify
the alignment of the child inside the frame (0.0 means either left or
top aligned, 1.0 means right or bottom aligned).   Ratio is the ratio
width/height for the child of the frame.   If Obey_Child is True, then
Ratio is ignored and the effective ratio  is taken from the child's
requisition (ie the ideal size it asked  for at creation time).
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Aspect_Frame.
procedure Set
       (Aspect_Frame       : access Gtk_Aspect_Frame_Record;
        Xalign             :        Gfloat;
        Yalign             :        Gfloat;
        Ratio              :        Gfloat;
        Obey_Child         :        Boolean);

Modify the frame's parameters (see the description of these parameters
for Gtk_New.
function Get_Ratio
       (Aspect_Frame       : access Gtk_Aspect_Frame_Record)
        return Gfloat;

Return the current ratio for the frame (width / height)
function Get_Xalign
       (Aspect_Frame       : access Gtk_Aspect_Frame_Record)
        return Gfloat;

Return the current X alignment for the frame.
0.0 means the child is left aligned, 1.0 that it is right aligned.
function Get_Yalign
       (Aspect_Frame       : access Gtk_Aspect_Frame_Record)
        return Gfloat;

Return the current Y alignment for the frame.
1.0 means the child is top aligned, 1.0 that it is bottom aligned.

File: gtkada_rm.info,  Node: Package_Gtk.Bin,  Next: Package_Gtk.Box,  Prev: Package_Gtk.Aspect_Frame,  Up: Top

Package Gtk.Bin
***************

Base class for containers that have only one child.   This widget can
not be instantiated directly.

* Menu:

* Gtk.Bin Widget Hierarchy::
* Gtk.Bin Subprograms::


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

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::)


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

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

function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Bin.
function Get_Child
       (Bin                : access Gtk_Bin_Record)
        return Gtk_Widget;

Return the child associated with Bin.

File: gtkada_rm.info,  Node: Package_Gtk.Box,  Next: Package_Gtk.Button,  Prev: Package_Gtk.Bin,  Up: Top

Package Gtk.Box
***************

A box is a container that can have multiple children, organized either
horizontally or vertically. Two subtypes are provided, Gtk_Hbox and
Gtk_Vbox, to conform to the C API. In Ada, you do not need to
distinguish between the two, but note that the Gtk_Box type is
conceptually  an abstract type: there is no way to create a "Gtk_Box",
only ways to  create either an horizontal box, or a vertical box.

   Children can be added to one of two positions in the box, either at
the  beginning (ie left or top) or at the end (ie right or bottom).
Each of  these positions can contain multiple widgets.

   Every time a child is added to the start, it is placed to the right
(resp. the bottom) of the previous widget added to the start.

   Every time a child is added to the end, it is placed to the left
(resp.   the top) of the previous widget added to the end.

   There are a number of parameters to specify the behavior of the box
when  it is resized, and how the children should be reorganized and/or
resized.

   See the testgtk example in the GtkAda distribution to see concrete
examples  on how all the parameters for the boxes work.

* Menu:

* Gtk.Box Widget Hierarchy::
* Gtk.Box Subprograms::


File: gtkada_rm.info,  Node: Gtk.Box Widget Hierarchy,  Next: Gtk.Box Subprograms,  Up: Package_Gtk.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::)

