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.Container Subprograms,  Prev: Gtk.Container Types,  Up: Package_Gtk.Container

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

function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Container.
procedure Set_Border_Width
       (Container          : access Gtk_Container_Record;
        Border_Width       :        Guint);

Modify the size of the frame that surrounds the widget.
The exact visual impact depends on the specific widget class.
function Get_Border_Width
       (Container          : access Gtk_Container_Record)
        return Guint;

Return the size of the frame that surrounds the widget.
procedure Add
       (Container          : access Gtk_Container_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class);

Add a new child to the container.
Note that some containers can have only one child. Nothing is done  if
there is already a child.   This basically sends the "add" signal (see
below)
procedure Remove
       (Container          : access Gtk_Container_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class);

Removes Widget from Container. Widget must be inside Container.
Note that Container will own a reference to Widget, and that this  may
be the last reference held; so removing a widget from its  container
can destroy that widget. If you want to use Widget  again, you need to
add a reference to it while it's not inside  a container, using
Glib.Object.Ref. If you don't want to use Widget  again it's usually
more efficient to simply destroy it directly  using Gtk.Widget.Destroy
since this will remove it from the  container and help break any
circular reference count cycles.
procedure Set_Resize_Mode
       (Container          : access Gtk_Container_Record;
        Resize_Mode        :        Gtk.Enums.Gtk_Resize_Mode);

Change the resizing behavior for the Container.
The default value is Resize_Parent.
function Get_Resize_Mode
       (Container          : access Gtk_Container_Record)
        return Gtk.Enums.Gtk_Resize_Mode;

Return the resizing behavior for the Container.
function Get_Children
       (Container          : access Gtk_Container_Record)
        return Gtk.Widget.Widget_List.Glist;

Return a list of all the children of the container.
The caller must free the returned list.
function Children
       (Container          : access Gtk_Container_Record)
        return Gtk.Widget.Widget_List.Glist;

This function is deprecated.
procedure Propagate_Expose
       (Container          : access Gtk_Container_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Event              :        Gdk.Event.Gdk_Event_Expose);

When a container receives an expose event, it must send synthetic
expose events to all children that don't have their own Gdk_Window.
This function provides a convenient way of doing this. A container,
when it receives an expose event, Propagate_Expose  once for each
child, passing in the event the container received.

   Propagate_Expose takes care of deciding whether  an expose event
needs to be sent to the child, intersecting  the event's area with the
child area, and sending the event.

   In most cases, a container can simply either simply inherit the
expose implementation from Gtk_Container, or, do some drawing  and then
chain to the expose implementation from Gtk_Container.
procedure Set_Focus_Chain
       (Container          : access Gtk_Container_Record;
        Focusable_Widgets  :        Gtk.Widget.Widget_List.Glist);

Set the chain of widgets that can take the focus for a given Container.
The list should be freed by the user
procedure Unset_Focus_Chain
       (Container          : access Gtk_Container_Record);

Unset the focus chain.
Foreach functions
-----------------

procedure Forall
       (Container          : access Gtk_Container_Record;
        Func               :        Forall_Function);

Execute Func for each of the children of Container.
See also the generic package Forall_Pkg if you want to pass some  extra
data to Func.
Widget-level methods
--------------------

procedure Set_Reallocate_Redraws
       (Container          : access Gtk_Container_Record;
        Needs_Redraws      :        Boolean := False);

Set the "needs_redraws" field.
If Needs_Redraws is True, then a "draw" signal is emitted for the
Container whenever one is emitted for a child.
procedure Set_Focus_Vadjustment
       (Container          : access Gtk_Container_Record;
        Adjustment         :        Gtk.Adjustment.Gtk_Adjustment);

Set the focus to the vertical adjustment.
Adjustment should have been created and displayed at some other  place
in your application.   Container will make sure that Adjustment always
matches the range  for the focus widget's position (y .. y + height).
procedure Set_Focus_Hadjustment
       (Container          : access Gtk_Container_Record;
        Adjustment         :        Gtk.Adjustment.Gtk_Adjustment);

Set the focus to the horizontal adjustment.
Adjustment should have been created and displayed at some other  place
in your application.   Container will make sure that Adjustment always
matches the range  for the focus widget's position (x .. x + width).
function Child_Type
       (Container          : access Gtk_Container_Record)
        return Gtk.Gtk_Type;

Return the type of the children in Container.
If Container can contain any type of widget, Gtk_Type_None is  returned.
procedure Resize_Children
       (Container          : access Gtk_Container_Record);

The container hasn't changed size but one of its children
queued a resize request. Which means that the allocation  is not
sufficient for the requisition of some child.   Run through the list of
widgets and reallocate their size appropriately.
Signals emission
----------------

procedure Check_Resize
       (Container          : access Gtk_Container_Record);

Emit the "check_resize" signal
procedure Set_Focus_Child
       (Container          : access Gtk_Container_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class);

Emit a "set_focus_child" signal.
function Get_Focus_Child
       (Container          : access Gtk_Container_Record)
        return Gtk.Widget.Gtk_Widget;

Return the child that currently has the keyboard focus. Note that null
can be returned.

File: gtkada_rm.info,  Node: Package_Gtk.Ctree,  Next: Package_Gtk.Curve,  Prev: Package_Gtk.Container,  Up: Top

Package Gtk.Ctree
*****************

This widget is deprecated. Use Gtk.Tree_View instead.

   This widget is similar to Gtk_Clist but it displays a tree with
expandable  nodes instead of a simple list. Gtk_Tree is a more flexible
tree widget  (it can have arbitrary widgets in the tree cells), but it
is less efficient  and is limited to 32768 pixels.

   If you need horizontal or vertical scrolling, you mustn't put this
widget  in a Gtk_Viewport, and then in a Gtk_Scrolled_Window. Put it
directly into  a Gtk_Scrolled_Window, or horizontal scrolling will be
disabled, and the  column headers will disappear when scrolling
vertically.

* Menu:

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


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

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_Clist       (*note Package_Gtk.Clist::)
                 \___ Gtk_Ctree    (*note Package_Gtk.Ctree::)


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

Signals
=======

   * "tree_collapse"

     procedure Handler (Ctree  : access Gtk_Clist_Record'Class;
     Node   : Gtk_Ctree_Node);
     Emitted when the subtree associated with a Node is collapsed.

   * "tree_expand"

     procedure Handler (Ctree  : access Gtk_Clist_Record'Class;
     Node   : Gtk_Ctree_Node);
     Emitted when the subtree associated with a Node is expanded.

   * "tree_move"

     procedure Handler (Ctree       : access Gtk_Clist_Record'Class;
     Node        : Gtk_Ctree_Node);
     New_Parent  : Gtk_Ctree_Node);
     New_Sibling : Gtk_Ctree_Node);
     Emitted when a Node is moved (e.g its parent and/or its sibling
     changed).

   * "tree_select_row"

     procedure Handler (Ctree  : access Gtk_Ctree_Record'Class;
     Node   : Gtk_Ctree_Node;
     Column : Gint);
     Emitted to request the selection of a node.  Column is the column
     number where the user clicked.

   * "tree_unselect_row"

     procedure Handler (Ctree  : access Gtk_Ctree_Record'Class;
     Node   : Gtk_Ctree_Node;
     Column : Gint);
     Emitted to request the unselection of a node.



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

Types
=====

type Gcompare_Func is access function
         (A, B : in Data_Type) return Boolean;

Function used to compare data types in the functions  Find_[All]
By_Row_Data_Custom.
type Gtk_Ctree_Compare_Drag_Func is access function
         (Ctree        : in Gtk_Ctree;
          Source_Node  : in Gtk_Ctree_Node;
          New_Parent   : in Gtk_Ctree_Node;
          New_Sibling  : in Gtk_Ctree_Node) return Boolean;

Function type used in Set_Drag_Compare_Func.
type Gtk_Ctree_Func is access procedure
         (Ctree : access Gtk_Ctree_Record'Class;
          Node  : in     Gtk_Ctree_Node;
          Data  : in     Data_Type_Access);

Function used by Post/Pre_Recursive functions below.
type Gtk_Ctree_Node is new Gdk.C_Proxy;


This type represents a node inside a Ctree.
type Gtk_Ctree_Row is new Gtk.Clist.Gtk_Clist_Row;


Similar to Clist_Row, but for a Ctree.

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

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

Creation, insertion, deletion
-----------------------------

Elements inside a Gtk_Ctree are not ordered from the top to the bottom
as is the case for Gtk_Clist. Instead, they are put in the ctree by
indicating where in the tree they should be placed. The position of an
element (called a node) is defined by a parent node and a sibling node.
The node will be attached in the parent subtree, on top of the sibling
node.

procedure Gtk_New
       (Widget             : out    Gtk_Ctree;
        Columns            : in     Gint;
        Tree_Column        : in     Gint := 0);

Create a ctree with Columns columns.
Tree_Column indicates in which column the tree will be displayed.
procedure Gtk_New
       (Widget             : out    Gtk_Ctree;
        Titles             : in     Chars_Ptr_Array;
        Tree_Column        : in     Gint := 0);

Create a ctree with Titles'Length columns.
Titles gives the title of each column.   Tree_Column indicates in which
column the tree will be displayed.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Ctree.
function Insert_Node
       (Ctree              : access Gtk_Ctree_Record;
        Parent             : in     Gtk_Ctree_Node;
        Sibling            : in     Gtk_Ctree_Node;
        Text               : in     Chars_Ptr_Array;
        Spacing            : in     Guint8;
        Pixmap_Closed      : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask_Closed        : in     Gdk.Bitmap.Gdk_Bitmap;
        Pixmap_Opened      : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask_Opened        : in     Gdk.Bitmap.Gdk_Bitmap;
        Is_Leaf            : in     Boolean;
        Expanded           : in     Boolean)
        return Gtk_Ctree_Node;

Insert a new node in the Ctree.
Parent is the parent node. If null, the new node is part of the root.
The new node will be inserted right on top of Sibling. If Sibling is
null, then it will be the first node in the subtree.   Text contains
the text for each cell of the node. Note that Insert_Node  expects the
length of the Text parameter to be equal to the number of  columns of
the Ctree.   Spacing is the number of pixels between the lines of the
tree and the  text in the same column.   If Is_Leaf is True, then the
node won't contain any subtree. If False,  the newly created node can
be used as the Parent for further node  creation. In this case,
Expanded indicates whether the subtree  associated with this node
should be initially visible.   In addition to the "+" or "-" sign
indicating whether the subtree is  expanded or not, it is possible to
put a pixmap giving this information.   Pixmap_Closed and Mask_Closed
represent the image and the mask used when  the subtree is closed;
similarly, Pixmap_Opened and Mask_Opened  represent the image and the
mask used when the subtree is opened.
procedure Remove_Node
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Remove Node from Ctree.
Tree, Node and Row basic manipulation
-------------------------------------

function Get_Tree_Column
       (Widget             : access Gtk.Ctree.Gtk_Ctree_Record'Class)
        return Gint;

Return the Tree_Column attribute of a given Node.
Tree_Column indicates in which column the tree will be displayed.
function Get_Node_List
       (Ctree              : access Gtk_Ctree_Record)
        return Node_List.Glist;

Return the list of nodes associated with a given Ctree.
Note: you need to extract the nodes with Node_List.Get_Gpointer.
function Get_Row_List
       (Ctree              : access Gtk_Ctree_Record)
        return Row_List.Glist;

Return the list of rows associated with a given Ctree.
function Get_Selection
       (Ctree              : access Gtk_Ctree_Record)
        return Node_List.Glist;

Return the list of nodes currently selected.
Extract the nodes with Node_List.Get_Data
function Node_Get_Row
       (Node               : in     Gtk_Ctree_Node)
        return Gtk_Ctree_Row;

Return the row of a given Node.
function Row_Get_Children
       (Row                : in     Gtk_Ctree_Row)
        return Gtk_Ctree_Node;

Return the children node of a given Row.
function Row_Get_Expanded
       (Row                : in     Gtk_Ctree_Row)
        return Boolean;

Return the expanded attribute of a given Row.
Note that Expanded can also be retrieved via Get_Node_Info,  this
function is just a quick accessor.
function Row_Get_Is_Leaf
       (Row                : in     Gtk_Ctree_Row)
        return Boolean;

Return the leaf attribute of a given Row.
Note that Is_Leaf can also be retrieved via Get_Node_Info,  this
function is just a quick accessor.
function Row_Get_Parent
       (Row                : in     Gtk_Ctree_Row)
        return Gtk_Ctree_Node;

Return the parent node of a given Row.
function Row_Get_Sibling
       (Row                : in     Gtk_Ctree_Row)
        return Gtk_Ctree_Node;

Return the sibling node of a given Row.
function Is_Created
       (Node               : in     Gtk_Ctree_Node)
        return Boolean;

Return True if Node is different from Null_Ctree_Node
Querying / finding tree information
-----------------------------------

function Is_Viewable
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node)
        return Boolean;

Return True if Node is viewable.
A Node is viewable if all the trees and subtrees containing it are
expanded.
function Last
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node)
        return Gtk_Ctree_Node;

Return the last node of a given subtree.
Starting at Node, this function will recursively look for the last
sibling of the last child.   Return an empty node is Node is empty.
function Find_Node_Ptr
       (Ctree              : access Gtk_Ctree_Record;
        Ctree_Row          : in     Gtk_Ctree_Row)
        return Gtk_Ctree_Node;

Return the node corresponding to a given row.
function Node_Nth
       (Ctree              : access Gtk_Ctree_Record;
        Row                : in     Guint)
        return Gtk_Ctree_Node;

Return the Node corresponding to the nth row of a given Ctree.
This can be used to retrieve the root node of the tree, by passing 0 for
Row.
function Find
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Child              : in     Gtk_Ctree_Node)
        return Boolean;

Recursively search for a given Child in a given subtree.
the subtree is determined by Node. If Node is empty, the search will
occur on the whole tree.   Return True if Child is found, False
otherwise.
function Is_Ancestor
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Child              : in     Gtk_Ctree_Node)
        return Boolean;

Indicate whether Node is an ancestor of Child.
It is assumed that Node is not empty.
function Is_Hot_Spot
       (Ctree              : access Gtk_Ctree_Record;
        X                  : in     Gint;
        Y                  : in     Gint)
        return Boolean;

Return True if the Ctree is centered on (x,y)
Tree signals: move, expand, collapse, (un)select
------------------------------------------------

procedure Move
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        New_Parent         : in     Gtk_Ctree_Node;
        New_Sibling        : in     Gtk_Ctree_Node);

Move a node in a Ctree.
After its creation, a node can be moved.   New_Parent points to the new
parent node that will contain Node.   If null, Node will be attached to
the root.   New_Sibling indicates under which node Node will be
inserted.   If New_Sibling is null, the new node will be the lowest in
its branch.
procedure Expand
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Expand the first level of the subtree associated with Node.
procedure Expand_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null);

Expand the whole subtree associated with Node.
procedure Expand_To_Depth
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null;
        Depth              : in     Gint);

Expand the subtree associated with Node and its descendants until Depth
levels of subtrees have been reached.
procedure Collapse
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Collapse the first level of the subtree associated with Node.
procedure Collapse_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null);

Collapse the whole subtree associated with Node.
procedure Collapse_To_Depth
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null;
        Depth              : in     Gint);

Collapse the subtree associated with Node and its descendants until
Depth levels of subtrees have been reached.
procedure Toggle_Expansion
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Change the state of the Ctree from expanded to collapsed and the other
way around on one level.
procedure Toggle_Expansion_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Change the state of the Ctree from expanded to collapsed and the other
way around for the whole subtree.
procedure Gtk_Select
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Select a specified Node, and only this one.
procedure Select_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null);

Select a specified Node, and its whole subtree.
procedure Unselect
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Unselect a specified Node, and only this one.
procedure Unselect_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null);

Unselect a specified Node, and its whole subtree.
procedure Real_Select_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null;
        Do_Select          : in     Boolean);

Similar to Select_Recursive or Unselect_Recursive.
If Do_Select is True, equivalent to Select_Recursive.   If Do_Select is
False, equivalent to Unselect_Recursive.
Analogs of Gtk_Clist functions
------------------------------

procedure Node_Set_Text
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Text               : in     UTF8_String);

Set the cell's text, replacing its current contents.
This changes the type of the cell to Cell_Text. The pixmap (if any)
will no longer be displayed.
function Node_Get_Text
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint)
        return UTF8_String;

Return the text contained in cell.
An empty string is returned if Column is invalid or if the Cell did not
contain any text (only a pixmap)
procedure Node_Set_Pixmap
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Pixmap             : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask               : in     Gdk.Bitmap.Gdk_Bitmap);

Set the cell's pixmap, replacing its current contents.
The type of the cell becomes Cell_Pixmap, and the text is no longer
displayed.
procedure Node_Get_Pixmap
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Pixmap             : out    Gdk.Pixmap.Gdk_Pixmap;
        Mask               : out    Gdk.Bitmap.Gdk_Bitmap;
        Success            : out    Boolean);

Return the Pixmap contained in a cell.
The type of the cell should be Cell_Pixmap.   The result is meaningful
only if Success is True. If the Cell did not  contain a pixmap, Success
is set to False.
procedure Node_Set_Pixtext
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Text               : in     UTF8_String;
        Spacing            : in     Guint8;
        Pixmap             : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask               : in     Gdk.Bitmap.Gdk_Bitmap);

Set both the Text and the Pixmap for the cell.
Replace its current contents. The type of the cell becomes Cell_Pixtext,
and both the text and the pixmap are displayed.
procedure Node_Get_Pixtext
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Text               : out    Interfaces.C.Strings.chars_ptr;
        Spacing            : out    Guint8;
        Pixmap             : out    Gdk.Pixmap.Gdk_Pixmap;
        Mask               : out    Gdk.Bitmap.Gdk_Bitmap;
        Success            : out    Boolean);

Return the Text and the Pixmap for the cell.
The result is not meaningful if Success is False.
procedure Node_Set_Shift
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Vertical           : in     Gint;
        Horizontal         : in     Gint);

Set a horizontal and vertical shift for drawing the content of the cell.
Both shifts can be either positive or negative.   This is particularly
useful for indenting items in a columns.
procedure Set_Node_Info
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Text               : in     UTF8_String;
        Spacing            : in     Guint8;
        Pixmap_Closed      : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask_Closed        : in     Gdk.Bitmap.Gdk_Bitmap;
        Pixmap_Opened      : in     Gdk.Pixmap.Gdk_Pixmap;
        Mask_Opened        : in     Gdk.Bitmap.Gdk_Bitmap;
        Is_Leaf            : in     Boolean;
        Expanded           : in     Boolean);

Set all the info related to a specific Node.
procedure Get_Node_Info
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Text               : out    Interfaces.C.Strings.chars_ptr;
        Spacing            : out    Guint8;
        Pixmap_Closed      : out    Gdk.Pixmap.Gdk_Pixmap;
        Mask_Closed        : out    Gdk.Bitmap.Gdk_Bitmap;
        Pixmap_Opened      : out    Gdk.Pixmap.Gdk_Pixmap;
        Mask_Opened        : out    Gdk.Bitmap.Gdk_Bitmap;
        Is_Leaf            : out    Boolean;
        Expanded           : out    Boolean;
        Success            : out    Boolean);

Return all the info related to a specific Node.
procedure Node_Set_Selectable
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Selectable         : in     Boolean := True);

Indicate whether the Node can be selected or not.
The default value is True.
function Node_Get_Selectable
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node)
        return Boolean;

Return the selectable status of the Node.
procedure Node_Set_Row_Style
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Style              : in     Gtk.Style.Gtk_Style);

Set the default style for the cells in the Node.
This can be overridden for each cell with Node_Set_Cell_Style.
function Node_Get_Row_Style
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node)
        return Gtk.Style.Gtk_Style;

Return the default style used for the Node.
procedure Node_Set_Cell_Style
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Style              : in     Gtk.Style.Gtk_Style);

Set the style (font, color, ...) used for the cell.
This overrides the Node's style.
function Node_Get_Cell_Style
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint)
        return Gtk.Style.Gtk_Style;

Return the style of the cell.
procedure Node_Set_Foreground
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Color              : in     Gdk.Color.Gdk_Color);

Set the foreground color for the Node.
The color must already be allocated.   If no such Node exists in the
tree, nothing is done.
procedure Node_Set_Background
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Color              : in     Gdk.Color.Gdk_Color);

Set the background color for the Node.
The color must already be allocated.   If no such Node exists in the
tree, nothing is done.
function Node_Get_Cell_Type
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint)
        return Gtk.Clist.Gtk_Cell_Type;

Return the type of the cell at Node/Column.
This indicates which of the functions Node_Get_Text. Node_Get_Pixmap,
etc. should be used with this cell.
procedure Node_Moveto
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node;
        Column             : in     Gint;
        Row_Align          : in     Gfloat := 0.5;
        Col_Align          : in     Gfloat := 0.5);

Make a Node visible.
Column indicates which column of the Node should be visible, if not
all columns can be displayed.   Row_Align and Col_Align are parameters
between 0.0 and 1.0, and  specify how the Node and the Column will be
centered in the Ctree  window. 0.0 means a Node on the top, and a
Column on the left.
function Node_Is_Visible
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node)
        return Gtk_Visibility;

Indicate the visibility of a Node.
Return Visibility_None if the Node is not visible in the Ctree window;
Visibility_Partial if the Node is partially visible; Visibility_Full
if the Node is entirely visible.   This function ignores the fact that
Node is in an expanded or collapsed  subtree.
Ctree specific functions
------------------------

procedure Set_Indent
       (Ctree              : access Gtk_Ctree_Record;
        Indent             : in     Gint := 20);

Change the indentation of the Ctree.
Each different level of a subtree is indented by a number of pixels.
By default, the indentation is 20 pixels, and can be changed using this
procedure.
function Get_Indent
       (Widget             : access Gtk.Ctree.Gtk_Ctree_Record'Class)
        return Gint;

Return the indentation of a Ctree.
procedure Set_Spacing
       (Ctree              : access Gtk_Ctree_Record;
        Spacing            : in     Gint := 5);

Set the spacing between the tree's icon and the additional pixmap.
The additional pixmap indicates whether the subtree is opened or closed.
The default value is 5 pixels.
function Get_Spacing
       (Widget             : access Gtk.Ctree.Gtk_Ctree_Record'Class)
        return Gint;

Return the spacing between the tree's icon and the additional pixmap.
procedure Set_Show_Stub
       (Ctree              : access Gtk_Ctree_Record;
        Show_Stub          : in     Boolean);

Set the Show_Stub attribute of Ctree.
function Get_Show_Stub
       (Ctree              : access Gtk_Ctree_Record)
        return Boolean;

Return the Show_Stub attribute of Ctree.
procedure Set_Line_Style
       (Ctree              : access Gtk_Ctree_Record;
        Line_Style         : in     Gtk_Ctree_Line_Style
                            := Ctree_Lines_Solid);

Change the style of the lines representing the tree of a given Ctree.
By default, solid lines are used.   See the description of
Gtk_Ctree_Line_Style for more details of the  possible values.
function Get_Line_Style
       (Ctree              : access Gtk_Ctree_Record)
        return Gtk_Ctree_Line_Style;

return the style of the lines representing the tree of a given Ctree.
procedure Set_Expander_Style
       (Ctree              : access Gtk_Ctree_Record;
        Expander_Style     : in     Gtk_Ctree_Expander_Style
                            := Ctree_Expander_Square);

Set the way a given Ctree can be expanded.
To expand a subtree, you can either double-click on a node, or click on
the "+/-" icon. This icon is by default included in a square pixmap.
This procedure can change the form of this pixmap.   See the
description of Gtk_Ctree_Expander_Style for more details.
function Get_Expander_Style
       (Ctree              : access Gtk_Ctree_Record)
        return Gtk_Ctree_Expander_Style;

Return the way a given Ctree can be expanded.
procedure Set_Drag_Compare_Func
       (Ctree              : access Gtk_Ctree_Record;
        Cmp_Func           : in     Gtk_Ctree_Compare_Drag_Func);

Set the drag compare function of a given Ctree.
This function is used when the Ctree receives a dragged data.
Tree sorting functions
----------------------

procedure Sort_Node
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node);

Sort the nodes of a given Ctree.
This procedure only sorts the first level of the tree.
procedure Sort_Recursive
       (Ctree              : access Gtk_Ctree_Record;
        Node               : in     Gtk_Ctree_Node := null);

Sort the nodes of a given Ctree recursively.
This procedure sorts the whole tree and subtrees associated with Ctree.
Set Node to null if you want to sort the whole tree starting from its
root.
Row_Data handling
-----------------

procedure Node_Set_Row_Data
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Data               : in     Data_Type);

Associate a Data with a Node.
function Node_Get_Row_Data
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node)
        return Data_Type;

Retrieve a data associated with a Node.
Error Handling:  Gtkada.Types.Data_Error is raised when trying to
retrieve  the data from a Node for which no data has been set  (using
Node_Set_Row_Data).
function Find_By_Row_Data
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Data               : in     Data_Type)
        return Gtk_Ctree_Node;

Find the first node containing a specified Data.
Node is the starting point of the search. If null, the search will
start from the root.   Return the first Node whose associated data is
Data, null if none  can be found.
function Find_All_By_Row_Data
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Data               : in     Data_Type)
        return Node_List.Glist;

Find all nodes containing a specified Data.
Node is the starting point of the search. If null, the search will
start from the root.
function Find_By_Row_Data_Custom
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Data               : in     Data_Type;
        Func               : in     Gcompare_Func)
        return Gtk_Ctree_Node;

Find the first node containing a specified Data.
Similar to Find_By_Row_Data but Func is used to allow a more flexible
(user defined) method to compare two nodes.
function Find_All_By_Row_Data_Custom
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Data               : in     Data_Type;
        Func               : in     Gcompare_Func)
        return Node_List.Glist;

Find all the nodes containing a specified Data.
Similar to Find_All_By_Row_Data but Func is used to allow a more
flexible (user defined) method to compare two nodes.
procedure Post_Recursive
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Func               : in     Gtk_Ctree_Func;
        Data               : in     Data_Type_Access);

Apply Func to each node of a subtree.
Node designates the root of the subtree.   Data will be passed as a
parameter to Func.   This procedure will first apply Func to the
children nodes.
procedure Post_Recursive_To_Depth
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Depth              : in     Gint;
        Func               : in     Gtk_Ctree_Func;
        Data               : in     Data_Type_Access);

Apply Func to each node of a subtree until a specified Depth.
Node designates the root of the subtree.   Data will be passed as a
parameter to Func.   This function is similar to Post_Recursive except
that it  stop at a specified subtree depth.
procedure Pre_Recursive
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Func               : in     Gtk_Ctree_Func;
        Data               : in     Data_Type_Access);

Apply Func to each node of a subtree.
Similar to Post_Recursive but will apply Func to the parent before
applying it to its children.
procedure Pre_Recursive_To_Depth
       (Ctree              : access Gtk_Ctree_Record'Class;
        Node               : in     Gtk_Ctree_Node;
        Depth              : in     Gint;
        Func               : in     Gtk_Ctree_Func;
        Data               : in     Data_Type_Access);

Apply Func to each node of a subtree until a specific Depth.
Similar to Post_Recursive_To_Depth but will apply Func to the parent
before applying it to its children.

File: gtkada_rm.info,  Node: Package_Gtk.Curve,  Next: Package_Gtk.Dialog,  Prev: Package_Gtk.Ctree,  Up: Top

Package Gtk.Curve
*****************

The Gtk_Curve widget allows the user to edit a curve covering a range of
values. It is typically used to fine-tune color balances in graphics
applications like the Gimp.

   The Gtk_Curve widget has 3 modes of operation: spline, linear and
free.   In spline mode the user places points on the curve which are
automatically  connected together into a smooth curve. In linear mode
the user places  points on the curve which are connected by straight
lines. In free mode the  user can draw the points of the curve freely,
and they are not connected at  all.

* Menu:

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


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

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_Curve       (*note Package_Gtk.Curve::)


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

Signals
=======

   * "curve-type-changed"

     procedure Handler (Curve : access Gtk_Curve_Record'Class);
     Emitted when the curve type has been changed. The curve type can be
     changed explicitly with a call to Set_Curve_Type. It is also
     changed as a side-effect of calling Reset or Set_Gamma.



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

Types
=====

type Property_Gtk_Curve_Type is new Curve_Type_Properties.Property;



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

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

procedure Gtk_New
       (Curve              : out    Gtk_Curve);

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


Return the internal value associated with a Gtk_Curve.
procedure Reset
       (Curve              : access Gtk_Curve_Record);

Reset the curve.
Reset to a straight line from the minimum x & y values to the maximum
x & y values (i.e. from the bottom-left to the top-right corners).
The curve type is not changed.
procedure Set_Gamma
       (Curve              : access Gtk_Curve_Record;
        Gamma              :        Gfloat);

Recompute the entire curve using the given gamma value.
A gamma value of 1.0 results in a straight line. Values greater than 1.0
result in a curve above the straight line. Values less than 1.0 result
in a curve below the straight line. The curve type is changed to
Curve_Type_Free.
procedure Set_Range
       (Curve              : access Gtk_Curve_Record;
        Min_X              :        Gfloat;
        Max_X              :        Gfloat;
        Min_Y              :        Gfloat;
        Max_Y              :        Gfloat);

Set the minimum and maximum x & y values of the curve.
The curve is also reset with a call to Reset.
procedure Set_Vector
       (Curve              : access Gtk_Curve_Record;
        Vector             :        Gfloat_Array);

Set the vector of points on the curve.
The curve type is set to Curve_Type_Free.
procedure Get_Vector
       (Curve              : access Gtk_Curve_Record;
        Vector             : out    Gfloat_Array);

Return a vector of points representing the curve.
procedure Set_Curve_Type
       (Curve              : access Gtk_Curve_Record;
        Curve_Type         :        Gtk_Curve_Type);

Set the type of the curve.
The curve will remain unchanged except when changing from a free curve
to a linear or spline curve, in which case the curve will be changed as
little as possible.

File: gtkada_rm.info,  Node: Package_Gtk.Dialog,  Next: Package_Gtk.Dnd,  Prev: Package_Gtk.Curve,  Up: Top

Package Gtk.Dialog
******************

Dialog boxes are a convenient way to prompt the user for a small amount
of  input, eg. to display a message, ask a question, or anything else
that does  not require extensive effort on the user's part.

   Gtkada treats a dialog as a window split horizontally. The top
section is a  Gtk_Vbox, and is where widgets such as a Gtk_Label or a
Gtk_Entry should be  packed. The second area is known as the
action_area. This is generally used  for packing buttons into the
dialog which may perform functions such as  cancel, ok, or apply. The
two areas are separated by a Gtk_Hseparator.

   If 'dialog' is a newly created dialog, the two primary areas of the
window  can be accessed using Get_Vbox and Get_Action_Area as can be
seen from the  example, below.

   A 'modal' dialog (that is, one which freezes the rest of the
application  from user input), can be created by calling Set_Modal on
the dialog.

   *note Package_Gtkada.Dialogs:: for a higher level dialog interface.

* Menu:

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


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

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_Dialog (*note Package_Gtk.Dialog::)


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

Signals
=======

   * "close"

     procedure Handler (Dialog : access Gtk_Fialog_Record'Class);
     Emit this signal to force a closing of the dialog.

   * "response"

     procedure Handler
     (Dialog      : access Gtk_Fialog_Record'Class;
     Response_Id : Gint);


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

Types
=====

type Gtk_Dialog_Flags is mod 3;


type Gtk_Response_Type is new Gint;


Type used for Response_Id's.   Positive values are totally
user-interpreted.   GtkAda will sometimes return Gtk_Response_None if
no Response_Id is  available.    Typical usage is:  if Gtk.Dialog.Run
(Dialog) = Gtk_Response_Accept then  blah;  end if;

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

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

Subprograms
-----------

procedure Gtk_New
       (Dialog             : out    Gtk_Dialog);

Create a new dialog.
Widgets should not be packed into this widget directly, but into the
vbox and action_area, as described above.
procedure Gtk_New
       (Dialog             : out    Gtk_Dialog;
        Title              :        UTF8_String;
        Parent             :        Gtk.Window.Gtk_Window;
        Flags              :        Gtk_Dialog_Flags);

Create a new dialog with a specific title, and specific attributes.
Parent is the transient parent for the dialog (ie the one that is  used
for reference for the flag Destroy_With_Parent, or to compute the
initial position of the dialog).
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Dialog.
function Get_Action_Area
       (Dialog             : access Gtk_Dialog_Record)
        return Gtk.Box.Gtk_Box;

Return the action area box associated with a Dialog.
function Get_Vbox
       (Dialog             : access Gtk_Dialog_Record)
        return Gtk.Box.Gtk_Box;

Return the vertical box associated with a Dialog.
procedure Add_Action_Widget
       (Dialog             : access Gtk_Dialog_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Response_Id        :        Gtk_Response_Type);

Add an activatable widget to the action area of Dialog.
When the widget is activated (ie emits the "activate" signal), Dialog
will emit the "response" signal with Response_Id.
function Add_Button
       (Dialog             : access Gtk_Dialog_Record;
        Text               :        UTF8_String;
        Response_Id        :        Gtk_Response_Type)
        return Gtk.Widget.Gtk_Widget;

Add a button with the given text to the dialog. Note that you can also
pass one of the constants defined in Gtk.Stock for the predefined
buttons.   When the button is clicked, Dialog will emit the "response"
signal.   The button widget is returned.
procedure Set_Response_Sensitive
       (Dialog             : access Gtk_Dialog_Record;
        Response_Id        :        Gtk_Response_Type;
        Setting            :        Boolean);

Call Gtk.Widget.Set_Sensitive for all the buttons in the dialog
associated with Response_Id.
procedure Set_Default_Response
       (Dialog             : access Gtk_Dialog_Record;
        Response_Id        :        Gtk_Response_Type);

Set the last widget in the dialog's action area with the given
Response_Id as the default widget for Dialog.   Pressing Enter will
activate this default widget.
procedure Set_Has_Separator
       (Dialog             : access Gtk_Dialog_Record;
        Setting            :        Boolean);

Set whether the dialog has a separator above the buttons.
function Get_Has_Separator
       (Dialog             : access Gtk_Dialog_Record)
        return Boolean;

Return True if the dialog has a separator above the buttons.
function Run
       (Dialog             : access Gtk_Dialog_Record)
        return Gtk_Response_Type;

Block in a recursive main loop until Dialog emits the "response"
signal, or is destroyed. If the dialog is destroyed, Gtk_Response_None
is returned. Otherwise, the response_id from the "response" signal is
returned.   Run will call Show on the dialog automatically. However, it
is your  responsability to call Show for any child you have inserted in
the  dialog.   The dialog is automatically set to modal when this
function is  called. You can exit at any time from this function by
emitting the  "response" signal directly.   When Run returns, you are
responsible for hiding or destroying the  dialog if necessary.
Signals
-------

procedure Response
       (Dialog             : access Gtk_Dialog_Record;
        Response_Id        :        Gtk_Response_Type);

Emit the "response" signal
