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

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

procedure Gtk_New_Vbox
       (Box                : out    Gtk_Box;
        Homogeneous        :        Boolean := False;
        Spacing            :        Gint := 0);

Create a new vertical box.
Its children will be placed one above the other.   If Homogeneous is
True, all the children will be allocated exactly the  same screen
real-estate, whereas if it is False, each child can have  its own size.
Spacing is the space left between two adjacent children.
procedure Gtk_New_Hbox
       (Box                : out    Gtk_Box;
        Homogeneous        :        Boolean := False;
        Spacing            :        Gint := 0);

Create a new horizontal box.
Its children will be placed one besides the other.   If Homogeneous is
True, all the children will be allocated exactly the  same screen
real-estate, whereas if it is False, each child can have  its own size.
Spacing is the space left between two adjacent children.
procedure Initialize_Vbox
       (Box                : access Gtk_Box_Record'Class;
        Homogeneous        :        Boolean := False;
        Spacing            :        Gint := 0);

Internal initialization function.
See the section "Creating your own widgets" in the documentation.
procedure Initialize_Hbox
       (Box                : access Gtk_Box_Record'Class;
        Homogeneous        :        Boolean := False;
        Spacing            :        Gint := 0);

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


Return the internal value associated with a Gtk_Box.
function Get_Hbox_Type         return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_HBox.
function Get_Vbox_Type         return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_VBox.
procedure Pack_Start
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             :        Boolean := True;
        Fill               :        Boolean := True;
        Padding            :        Gint := 0);

Add a new child to the beginning of the box (ie left or top part).
It is added to the right (resp. the bottom) of the previous child added
to the beginning of the box. Note that a child added to the beginning
of  the box will always remain on the left (resp. top) of all the
children  added to the end of the box.

   If Expand is False, the size allocated for each size will be the one
requested by the widget (or the largest child if Homogeneous was set to
true when the box was created). Otherwise, the total size of the box is
divided between all the children. Note that this does not mean that the
children have to occupy all the space given to them...

   If Fill is True, then the widget will be resized so as to occupy all
the  space allocated to them. This is only relevant if Expand is True,
since  otherwise the space allocated is the same one as the child's
size.

   Padding is the amount of space left around the widget when it is
drawn.
procedure Pack_End
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             :        Boolean := True;
        Fill               :        Boolean := True;
        Padding            :        Gint := 0);

Add a new child to the end of the box (ie right or bottom part).
It is added to the left (resp. top) of the previous child added to the
end of the box. Note that a child added to the end of the box will
always remain on the right (resp. bottom) of all the children added to
the beginning of the box.

   See Pack_Start for an explanation of all the parameters.
procedure Pack_Start_Defaults
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class);

This is the same as Pack_Start if you use the default parameter values.
It is provided for backward compatibility only.
procedure Pack_End_Defaults
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class);

This is the same as Pack_End if you use the default parameter values.
It is provided for backward compatibility only.
procedure Set_Homogeneous
       (In_Box             : access Gtk_Box_Record;
        Homogeneous        :        Boolean);

Modify the homogeneous parameter for the box.
If the box is homogeneous, then all its children will be allocated the
same amount of space, even if they are not resized to occupy it
(depending on the parameters given to Pack_Start and Pack_End).
function Get_Homogeneous
       (In_Box             : access Gtk_Box_Record)
        return Boolean;

Return the homogeneous parameter of the box.
procedure Set_Spacing
       (In_Box             : access Gtk_Box_Record;
        Spacing            :        Gint);

Modify the spacing for the box.
I.e. the amount of space left between two adjacent children.
function Get_Spacing
       (In_Box             : access Gtk_Box_Record)
        return Gint;

Return the spacing of the box.
procedure Reorder_Child
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Pos                :        Guint);

Move the Child to a new position.
Nothing is done if Child is not in the box.   Pos starts at 0, and
indicates the position of the child relative to all  other children, no
matter where they were packed  (the beginning or the  end of the box).
procedure Query_Child_Packing
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             : out    Boolean;
        Fill               : out    Boolean;
        Padding            : out    Gint;
        PackType           : out    Gtk.Enums.Gtk_Pack_Type);

Get information on how the child was packed in the box.
The results are undefined if Child is not in the box.
procedure Set_Child_Packing
       (In_Box             : access Gtk_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Expand             :        Boolean;
        Fill               :        Boolean;
        Padding            :        Gint;
        Pack_Type          :        Gtk.Enums.Gtk_Pack_Type);

Modify the packing for a child.
function Get_Child
       (Box                : access Gtk_Box_Record;
        Num                :        Gint)
        return Gtk.Widget.Gtk_Widget;

Return the Num-th child of the box, or null if there is no such child.

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

Package Gtk.Button
******************

This package implements a general button widget. This button can  be
clicked on by the user to start any action.   This button does not have
multiple states, it can just be temporarily  pressed while the mouse is
on it, but does not keep its pressed state.

   The gtk+ sources provide the following drawing that explains the
role of  the various spacings that can be set for a button:

      +------------------------------------------------+
      |                   BORDER                       |
      |  +------------------------------------------+  |
      |  |\\\\\\\\\\\\\\\\DEFAULT\\\\\\\\\\\\\\\\\  |  |
      |  |\\+------------------------------------+  |  |
      |  |\\| |           SPACING       3      | |  |  |
      |  |\\| +--------------------------------+ |  |  |
      |  |\\| |########## FOCUS ###############| |  |  |
      |  |\\| |#+----------------------------+#| |  |  |
      |  |\\| |#|         RELIEF            \|#| |  |  |
      |  |\\| |#|  +-----------------------+\|#| |  |  |
      |  |\\|1|#|  +     THE TEXT          +\|#|2|  |  |
      |  |\\| |#|  +-----------------------+\|#| |  |  |
      |  |\\| |#| \\\\\ ythickness \\\\\\\\\\|#| |  |  |
      |  |\\| |#+----------------------------+#| |  |  |
      |  |\\| |########### 1 ##################| |  |  |
      |  |\\| +--------------------------------+ |  |  |
      |  |\\| |        default spacing   4     | |  |  |
      |  |\\+------------------------------------+  |  |
      |  |\            ythickness                   |  |
      |  +------------------------------------------+  |
      |                border_width                    |
      +------------------------------------------------+

* Menu:

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


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

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

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


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

Signals
=======

   * "clicked"

     procedure Handler (Button : access Gtk_Button_Record'Class);
     Emitted when the button has been clicked on by the user. This is
     the signal you should use to start your own actions.

   * "enter"

     procedure Handler (Button : access Gtk_Button_Record'Class);
     Emitted when the mouse enters the button. The clicked signal can
     only be emitted when the mouse is inside the button.

   * "leave"

     procedure Handler (Button : access Gtk_Button_Record'Class);
     Emitted when the mouse leaves the button.

   * "pressed"

     procedure Handler (Button : access Gtk_Button_Record'Class);
     Emitted when the user presses the mouse button on the widget. The
     default implementation modifies the widget state and its visual
     aspect.

   * "released"

     procedure Handler (Button : access Gtk_Button_Record'Class);
     Emitted when the user releases the mouse button and is inside of
     the widget. The default implementation modifies the widget state
     and its visual aspect. If the mouse is still inside the widget,
     then the "clicked" signal is emitted.



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

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

procedure Gtk_New
       (Button             : out    Gtk_Button;
        Label              :        UTF8_String := "");

Create a new button.
if Label is not the empty string, then the text appears in the  button
(and the child of the button is a Gtk_Label). On the other  hand, if
Label is the empty string, then no child is created for  the button and
it is your responsibility to add one. This is the  recommended way to
put a pixmap inside the button.
procedure Gtk_New_From_Stock
       (Button             : out    Gtk_Button;
        Stock_Id           :        String);

Create a new button containing the image and text from a stock item.
Some stock ids have predefined contants like Gtk.Stock.Stock_OK or
Gtk.Stock.Stock_Apply. See Gtk.Stock for a complete list of predefined
stock items.   Stock_Id: the name of the stock item.
procedure Gtk_New_With_Mnemonic
       (Button             : out    Gtk_Button;
        Label              :        UTF8_String);

Create a new button containing a label.
Label: The text of the button, with an underscore in front of the
 mnemonic character  If characters in Label are preceded by an
underscore, they are  underlined indicating that they represent a
keyboard accelerator called  a mnemonic. Pressing Alt and that key
activates the button.
procedure Initialize_From_Stock
       (Button             : access Gtk_Button_Record'Class;
        Stock_Id           :        String);

Internal initialization function.
procedure Initialize_With_Mnemonic
       (Button             : access Gtk_Button_Record'Class;
        Label              :        UTF8_String);

Internal initialization function.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Button.
procedure Set_Relief
       (Button             : access Gtk_Button_Record;
        New_Style          :        Gtk.Enums.Gtk_Relief_Style);

Modify the relief style for the button.
This modifies only its visual aspect, not its behavior.
function Get_Relief
       (Button             : access Gtk_Button_Record)
        return Gtk.Enums.Gtk_Relief_Style;

Get the current relief style for the button
procedure Set_Label
       (Button             : access Gtk_Button_Record;
        Label              :        UTF8_String);

Set the label of the button.
function Get_Label
       (Button             : access Gtk_Button_Record)
        return UTF8_String;

Return the label of the button.
procedure Set_Use_Underline
       (Button             : access Gtk_Button_Record;
        Use_Underline      :        Boolean);

Set whether underscore is used to designate an accelerator.
function Get_Use_Underline
       (Button             : access Gtk_Button_Record)
        return Boolean;

Return whether underscores are used to designate an accelerator.
procedure Set_Use_Stock
       (Button             : access Gtk_Button_Record;
        Use_Stock          :        Boolean);

Set whether a stock item is used by the button.
function Get_Use_Stock
       (Button             : access Gtk_Button_Record)
        return Boolean;

Return whether a stock item is used by the button.
Signals emission
----------------

procedure Pressed
       (Button             : access Gtk_Button_Record);

Send the "pressed" signal to the button
procedure Released
       (Button             : access Gtk_Button_Record);

Send the "release" signal to the button
procedure Clicked
       (Button             : access Gtk_Button_Record);

Send the "clicked" signal to the button
procedure Enter
       (Button             : access Gtk_Button_Record);

Send the "enter" signal to the button
procedure Leave
       (Button             : access Gtk_Button_Record);

Send the "leave" signal to the button

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

Example
=======

      +-----------------------------------------------+
      |                   BORDER                       |
      |  +-----------------------------------------+  |
      |  |\\\\\\\\\\\\\\\\DEFAULT\\\\\\\\\\\\\\\\\  |  |
      |  |\\+-----------------------------------+  |  |
      |  |\\| |           SPACING       3      | |  |  |
      |  |\\| +-------------------------------+ |  |  |
      |  |\\| |########## FOCUS ###############| |  |  |
      |  |\\| |#+---------------------------+#| |  |  |
      |  |\\| |#|         RELIEF            \|#| |  |  |
      |  |\\| |#|  +----------------------+\|#| |  |  |
      |  |\\|1|#|  +     THE TEXT          +\|#|2|  |  |
      |  |\\| |#|  +----------------------+\|#| |  |  |
      |  |\\| |#| \\\\\ ythickness \\\\\\\\\\|#| |  |  |
      |  |\\| |#+---------------------------+#| |  |  |
      |  |\\| |########### 1 ##################| |  |  |
      |  |\\| +-------------------------------+ |  |  |
      |  |\\| |        default spacing   4     | |  |  |
      |  |\\+-----------------------------------+  |  |
      |  |\            ythickness                   |  |
      |  +-----------------------------------------+  |
      |                border_width                    |
      +-----------------------------------------------+


File: gtkada_rm.info,  Node: Package_Gtk.Button_Box,  Next: Package_Gtk.Calendar,  Prev: Package_Gtk.Button,  Up: Top

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

A Gtk_Button_Box is a special type of Gtk_Box specially tailored to
contain  buttons.

   This is only a base class for Gtk_Hbutton_Box and Gtk_Vbutton_Box
which  provide a way to arrange their children horizontally (resp.
vertically).   You can not instantiate a Gtk_Button_Box directly, and
have to use one the  above two instead.

* Menu:

* Gtk.Button_Box Widget Hierarchy::
* Gtk.Button_Box Subprograms::


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


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

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

function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Button_Box.
procedure Set_Layout
       (Button_Box         : access Gtk_Button_Box_Record;
        Layout_Style       :        Enums.Gtk_Button_Box_Style);

Set the layout to use for the box.
There are four such styles:

   * Buttonbox_Spread: The children are spread regularly across the box

   * Buttonbox_Edge  : Same as Spread, except that the first and last
                       children are aligned on the border of the box.

   * Buttonbox_Start : The children are put as much to the left (resp.
     top)                      as possible in the box.

   * Buttonbox_End   : The children are put as much to the right
                  (resp. bottom) as possible in the box.

function Get_Layout
       (Button_Box         : access Gtk_Button_Box_Record)
        return Enums.Gtk_Button_Box_Style;

Return the layout used in the box.
procedure Set_Child_Secondary
       (Button_Box         : access Gtk_Button_Box_Record;
        Child              : access Gtk.Widget.Gtk_Widget_Record'Class;
        Is_Secondary       :        Boolean);

Set whether Child should appear in a secondary group of children.
A typical use of a secondary child is the help button in a dialog.

   This group appears after the other children if the style is
Buttonbox_Start, Buttonbox_Spread or Buttonbox_Edge, and before the
other children if the style is Buttonbox_End. For horizontal button
boxes, the definition of before/after depends on direction of the
widget. (See Gtk.Widget.Set_Direction) If the style is Buttonbox_Start,
or Buttonbox_End, then the secondary children are aligned at  the
other end of the button box from the main children. For the  other
styles, they appear immediately next to the main children.

   Is_Secondary: if True, the Child appears in a secondary group of the
              button box.

File: gtkada_rm.info,  Node: Package_Gtk.Calendar,  Next: Package_Gtk.Check_Button,  Prev: Package_Gtk.Button_Box,  Up: Top

Package Gtk.Calendar
********************

Gtk_Calendar is a widget that displays a calendar, one month at a time.
It can be created with Gtk_New.

   The month and year currently displayed can be altered with
Select_Month.   The exact day can be selected from the displayed month
using Select_Day.

   The way in which the calendar itself is displayed can be altered
using  Display_Options.

   The selected date can be retrieved from a Gtk_Calendar using
Get_Date.

   If performing many 'mark' operations, the calendar can be frozen to
prevent  flicker, using Freeze, and 'thawed' again using Thaw.

* Menu:

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


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Calendar       (*note Package_Gtk.Calendar::)


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

Signals
=======

   * "day_selected"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user selects a day on a calendar.

   * "day_selected_double_click"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user double clicks a day on a calendar.

   * "month_changed"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user clicks a button to change the selected month
     on a calendar.

   * "next_month"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user selects the next month on a calendar.

   * "next_year"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user selects the next year on a calendar.

   * "prev_month"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user selects the previous month on a calendar.

   * "prev_year"

     procedure Handler (Calendar : access Gtk_Calendar_Record'Class);
     Emitted when the user selects the previous year on a calendar.



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

Types
=====

type Gtk_Calendar_Display_Options is private;



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

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

function "and"
       (Left, Right        :        Gtk_Calendar_Display_Options)
        return Gtk_Calendar_Display_Options;

procedure Gtk_New
       (Widget             : out    Gtk_Calendar);

Create a new Calendar that points to the current date.
function Get_Type              return Gtk.Gtk_Type;


Return the internal value associated with a Gtk_Calendar.
function Select_Month
       (Calendar           : access Gtk_Calendar_Record;
        Month              :        Guint;
        Year               :        Guint)
        return Boolean;

Shift the calendar to a different month/year.
Return True if sucessful.
procedure Select_Day
       (Calendar           : access Gtk_Calendar_Record;
        Day                :        Guint);

Select a day from the current month.
Only one day can be selected at a time.
function Mark_Day
       (Calendar           : access Gtk_Calendar_Record;
        Day                :        Guint)
        return Boolean;

Set a specified Day as marked in the Calendar.
This is shown visually as a painted box around the Day.   Note that
several days can be marked.   Return True if successful.
function Unmark_Day
       (Calendar           : access Gtk_Calendar_Record;
        Day                :        Guint)
        return Boolean;

Undo the marking of Day.
Return True if sucessful.
procedure Clear_Marks
       (Calendar           : access Gtk_Calendar_Record);

Clear all the marks set by Mark_Day.
procedure Display_Options
       (Calendar           : access Gtk_Calendar_Record;
        Flags              :        Gtk_Calendar_Display_Options);

Change the display options.
See individual Display_Option flags for more details.
procedure Get_Date
       (Calendar           : access Gtk_Calendar_Record;
        Year               : out    Guint;
        Month              : out    Guint;
        Day                : out    Guint);

Return the date currently selected.
procedure Freeze
       (Calendar           : access Gtk_Calendar_Record);

Lock the display of the calendar until it is thawed.
procedure Thaw
       (Calendar           : access Gtk_Calendar_Record);

Defrost a calendar.
All the changes made since the last Freeze are displayed.

File: gtkada_rm.info,  Node: Package_Gtk.Check_Button,  Next: Package_Gtk.Check_Menu_Item,  Prev: Package_Gtk.Calendar,  Up: Top

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

A Gtk_Check_Button places a discrete Gtk_Toggle_Button next to a widget,
(usually a Gtk_Label).

* Menu:

* Gtk.Check_Button Widget Hierarchy::
* Gtk.Check_Button Subprograms::


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

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

     GObject                       (*note Package_Glib.Object::)
     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Bin         (*note Package_Gtk.Bin::)
                 \___ Gtk_Button   (*note Package_Gtk.Button::)
                    \___ Gtk_Toggle_Button (*note Package_Gtk.Toggle_Button::)
                       \___ Gtk_Check_Button (*note Package_Gtk.Check_Button::)


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

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

procedure Gtk_New
       (Check_Button       : out    Gtk_Check_Button;
        Label              :        UTF8_String := "");

Create a check button.
if Label is null, then no widget is associated with the button, and
any widget can be added to the button (with Gtk.Container.Add).
procedure Gtk_New_With_Mnemonic
       (Check_Button       : out    Gtk_Check_Button;
        Label              :        UTF8_String);

Create a new check button containing a label.
If characters in Label are preceded by an underscore, they are
underlined indicating that they represent a keyboard accelerator called
a mnemonic.   Pressing Alt and that key activates the checkbutton.
Label: The text of the button, with an underscore in front of the
 mnemonic character
procedure Initialize_With_Mnemonic
       (Check_Button       : access Gtk_Check_Button_Record'Class;
        Label              :        UTF8_String);

Internal initialization function.
function Get_Type              return Glib.GType;


Return the internal value associated with a Gtk_Check_Button.

File: gtkada_rm.info,  Node: Package_Gtk.Check_Menu_Item,  Next: Package_Gtk.Clist,  Prev: Package_Gtk.Check_Button,  Up: Top

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

A Gtk_Check_Menu_Item is a menu item that maintains the state of a
boolean  value in addition to a Gtk_Menu_Item's usual role in
activating application  code.

   A check box indicating the state of the boolean value is displayed
at the  left side of the Gtk_Menu_Item. Activating the Gtk_Menu_Item
toggles the  value.

* Menu:

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


File: gtkada_rm.info,  Node: Gtk.Check_Menu_Item Widget Hierarchy,  Next: Gtk.Check_Menu_Item Signals,  Up: Package_Gtk.Check_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_Check_Menu_Item (*note Package_Gtk.Check_Menu_Item::)


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

Signals
=======

   * "toggled"

     procedure Handler
     (Check_Menu_Item : access Gtk_Check_Menu_Item_Record'Class);
     Emitted when the state of the check box is changed.  A signal
     handler can call Get_Active to discover the new state.



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

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

procedure Gtk_New
       (Check_Menu_Item    : out    Gtk_Check_Menu_Item;
        Label              :        UTF8_String := "");

Create a new Gtk_Check_Menu_Item with a label, if label isn't null.
procedure Gtk_New_With_Mnemonic
       (Check_Menu_Item    : out    Gtk_Check_Menu_Item;
        Label              :        UTF8_String);

Create a new Gtk_Check_Menu_Item containing a label. The label
will be created will be created using Gtk.Label.New_With_Mnemonic,  so
underscores in the label indicate the mnemonic for the menu item.
procedure Initialize_With_Mnemonic
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record'Class;
        Label              :        UTF8_String);

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


Return the internal value associated with a Gtk_Calendar.
procedure Set_Active
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record;
        Is_Active          :        Boolean);

Set the active state of the menu item's check box.
function Get_Active
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record)
        return Boolean;

Return True if the Item is active
procedure Toggled
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record);

Emit the "toggled" signal.
procedure Set_Inconsistent
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record;
        Setting            :        Boolean);

If the user has selected a range of elements (such as some text or
spreadsheet cells) that are affected by a boolean setting, and the
current values in that range are inconsistent, you may want to  display
the check in an "in between" state. This function turns on  "in
between" display.  Normally you would turn off the inconsistent  state
again if the user explicitly selects a setting. This has to be  done
manually, Set_Inconsistent only affects visual appearance, it  doesn't
affect the semantics of the widget.
function Get_Inconsistent
       (Check_Menu_Item    : access Gtk_Check_Menu_Item_Record)
        return Boolean;

Return True if the Item is inconsistent.

File: gtkada_rm.info,  Node: Package_Gtk.Clist,  Next: Package_Gtk.Color_Selection,  Prev: Package_Gtk.Check_Menu_Item,  Up: Top

Package Gtk.Clist
*****************

This widget is deprecated. Use Gtk.Tree_View instead.

   This widget displays a multi-column list. Each line is made of  a
number of column, each being able to display any kind of widget.

   The intersection of a line and a column is called a Cell. Each cell
can  have a different type (Cell_Text, Cell_Pixmap, Cell_Pixtext), and
display  its contents depending on this type. For instance, the text is
not  displayed in the type is Cell_Pixmap.   Note that this type is
changed dynamically by some of the subprograms  below, like Set_Pixmap,
Set_Text, ... and Set_Cell_Contents

   This is one of the most powerful widgets in GtkAda, that can be used
to  display an kind of information. Look also into using Gtk_Ctree,
which is  a similar widget.

   You can add scrolling in a Gtk_Clist by adding it in a
Gtk_Scrolled_Window.

* Menu:

* Gtk.Clist Widget Hierarchy::
* Gtk.Clist Signals::
* Gtk.Clist Types::
* Gtk.Clist Subprograms::
* Gtk.Clist Example::


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

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


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

Signals
=======

   * "abort_column_resize"

     procedure Handler (Clist       : access Gtk_Clist_Record'Class);
     Aborts the current interactive resizing of the column by the user.
     This releases the grab done on the pointer. It is never emitted
     internally by GtkAda.

   * "click_column"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class;
     Column : Gint);
     Emitted when the user has clicked on one of the buttons at the top
     of a column. The first column has number 0.

   * "end_selection"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Ends the current selection process. This is never emitted
     internally by GtkAda, but acts as if the user had just released
     the mouse button.

   * "extend_selection"

     procedure Handler (Clist       : access Gtk_Clist_Record'Class;
     Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;
     Position    : Gfloat;
     Auto_Start_Selection : Boolean);
     Extends the current selection. Position is used only for certain
     values of Scroll_Type. It is never emitted internally by GtkAda. It
     has no effect if the selection mode is not Extended.

   * "resize_column"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class;
     Column : Gint;
     Width  : Gint);
     Emitted to request a new size for a given column. You should use
     Set_Column_Width instead.

   * "row_move"

     procedure Handler (Clist      : access Gtk_Clist_Record'Class;
     Source_Row : Gint;
     Dest_Row   : Gint);
     Emitted to request the change of a Source_Row to Dest_Row. You
     should use Row_Move instead.

   * "scroll_horizontal"

     procedure Handler (Clist       : access Gtk_Clist_Record'Class;
     Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;
     Position    : Gfloat);
     Scrolls the clist horizontally. This also modifies the selection.
     It is never emitted internally by GtkAda. You should consider using
     Moveto instead.

   * "scroll_vertical"

     procedure Handler (Clist       : access Gtk_Clist_Record'Class;
     Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;
     Position    : Gfloat);
     Scrolls the clist vertically. This also modifies the selection.
     It is never emitted internally by GtkAda. You should consider using
     Moveto instead.

   * "select_all"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Emitted to request the selection of all the rows in the Clist, if
     the selection mode allows. You should use Select_All instead.

   * "select_row"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class;
     Row    : Gint;
     Column : Gint;
     Event  : Gdk.Event.Gdk_Event);
     Emitted when a row is selected. Column contains the column number
     in which the user has clicked, or -1 if the selection was done
     internally by GtkAda.  Event will be null if the selection was not
     triggered by an event, eg if the row was selected through a call
     to Select_Row.

   * "start_selection"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Request the start of the selection. This signal is not emitted
     internally by GtkAda, but acts as if the user had clicked on the
     focus row (the exact visual modification depends on the selection
     mode).

   * "toggle_add_mode"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Changes the add_mode for the clist (indicates whether the next line
     clicked on will be added to the selection or will replace it).
     This is never emitted internally by GtkAda.

   * "toggle_focus_row"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Emitted to request the change of the selection status (selected/
     unselected) of the focus row. This signal is not emitted internally
     by GtkAda.

   * "undo_selection"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Emitted to request the cancellation of the last select/unselect
     operation. You should use Undo_Selection instead.

   * "unselect_all"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class);
     Emitted to request the unselection of all the rows in the Clist, if
     the selection mode is different from Browse. You should use
     Unselect_All instead.

   * "unselect_row"

     procedure Handler (Clist  : access Gtk_Clist_Record'Class;
     Row    : Gint;
     Column : Gint;
     Event  : Gdk.Event.Gdk_Event);
     Emitted to request the unselection of a row. Event will be null
     most of the time when the event is emitted directly by GtkAda. You
     should use Unselect_Row instead.



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

Types
=====

type Gtk_Button_Action is new Guint;


type Gtk_Cell_Type is
         (Cell_Empty,
          Cell_Text,
          Cell_Pixmap,
          Cell_Pixtext,
          Cell_Widget);

type Gtk_Clist_Compare_Func is access function
         (Clist : access Gtk_Clist_Record'Class;

type Gtk_Clist_Row is new Gdk.C_Proxy;


A row of the clist.   Application-specific data can be associated with
each row.   In the following subprograms, rows can also be accessed via
their  number, starting from 0.
type Gtk_Sort_Type is
         (Ascending, Descending);

