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


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

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

Creation and modification
-------------------------

procedure Gtk_New
     (Sheet              : out    Gtk_Sheet;
        Rows               : in     Guint;
        Columns            : in     Guint;
        Title              : in     String := "";
        Entry_Type         : in     Gtk_Type := Gtk_Type_Invalid);

Create a new sheet with a specific number of rows and columns.
You can fully specify which type the entry used to modify the value of
cells should have. The value of Entry_Type can be found by using one
of the Get_Type subprograms in the GtkAda packages.   The Title is
internal, and does not appear on the screen.
procedure Gtk_New_Browser
     (Sheet              : out    Gtk_Sheet;
        Rows               : in     Guint;
        Columns            : in     Guint;
        Title              : in     String := "");

Create a new sheet browser with a specific number of rows and columns.
This is a standard Gtk_Sheet, except that it is read-only and that its
cells will automatically resize themselves depending on their contents.
procedure Initialize_Browser
     (Sheet              : access Gtk_Sheet_Record'Class;
        Rows               : in     Guint;
        Columns            : in     Guint;
        Title              : in     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_Sheet.
procedure Set_Hadjustment
     (Sheet              : access Gtk_Sheet_Record;
        Adjustment         : access Gtk_Adjustment_Record'Class);

Change the horizontal adjustment.
It indicates what range of columns is visible.
procedure Set_Vadjustment
     (Sheet              : access Gtk_Sheet_Record;
        Adjustment         : access Gtk_Adjustment_Record'Class);

Change the vertical adjustment.
It indicates what range of rows is visible.
function Get_Vadjustment
     (Sheet              : access Gtk_Sheet_Record)
        return Gtk.Adjustment.Gtk_Adjustment;

Return the adjustment used to indicate the range of visible rows.
function Get_Hadjustment
     (Sheet              : access Gtk_Sheet_Record)
        return Gtk.Adjustment.Gtk_Adjustment;

Return the adjustment used to indicate the range of visible columns.
procedure Change_Entry
     (Sheet              : access Gtk_Sheet_Record;
        Entry_Type         : in     Gtk_Type);

Change the type of widget used to interactively modify the value of
the cells.
function Get_Entry
     (Sheet              : access Gtk_Sheet_Record)
        return Gtk.Widget.Gtk_Widget;

Return the entry used to modify the content of the cells.
procedure Set_Title
     (Sheet              : access Gtk_Sheet_Record;
        Title              : in     String);

Change the title of the sheet.
procedure Freeze
     (Sheet              : access Gtk_Sheet_Record);

Freeze all visual updates of the sheet, until you thaw it.
The update will occur in a more efficient way.
procedure Thaw
     (Sheet              : access Gtk_Sheet_Record);

Thaw the sheet, so that visual updates occur again.
Note that you have to call Thaw as many times as you have called
Freeze to actually thaw the widget.
procedure Moveto
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Column             : in     Gint;
        Row_Align          : in     Gfloat;
        Col_Align          : in     Gfloat);

Scroll the viewing area to (Row, Column).
(Row_Align, Col_Align) represent the location on the screen that the
cell should appear at. (0.0, 0.0) is at the top-left of the screen,
whereas (1.0, 1.0) is at the bottom-right corner.   If Row or Column is
negative, there is no change.
Selection and Clipping
----------------------

function Get_State
     (Sheet              : access Gtk_Sheet_Record)
        return Sheet_State;

Return the status of the selection in the sheet.
function Get_Range
     (Sheet              : access Gtk_Sheet_Record)
        return Gtk_Sheet_Range;

Return the selected range.
procedure Get_Visible_Range
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : out    Gtk_Sheet_Range);

Return the range visible on the screen.
procedure Set_Selection_Mode
     (Sheet              : access Gtk_Sheet_Record;
        Mode               : in     Gtk.Enums.Gtk_Selection_Mode);

Change the selection mode.
procedure Select_Column
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint);

Replace the current selection with a specific column.
The range is highlighted.
procedure Select_Row
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint);

Replace the current selection with a specific row.
The range is highlighted.
procedure Select_Range
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range);

Select a new range of cells.
procedure Unselect_Range
     (Sheet              : access Gtk_Sheet_Record);

Unselect a specific range of cells.
If null is passed, the current selected range is used.
procedure Clip_Range
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range);

Create a new clip range.
That range is flashed on the screen.
procedure Unclip_Range
     (Sheet              : access Gtk_Sheet_Record);

Destroy the clip area.
function Set_Active_Cell
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Column             : in     Gint)
        return Boolean;

Set active cell where the entry will be displayed.
Returns FALSE if the current cell can not be deactivated or if the
requested cell can't be activated.
procedure Get_Active_Cell
     (Sheet              : access Gtk_Sheet_Record;
        Row                : out    Gint;
        Column             : out    Gint);

Return the coordinates of the active cell.
This is the cell that the user is currently editing.
Columns
-------

procedure Set_Column_Title
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Title              : in     String);

Modify the title of a column.
The first column on the left has the number 0.   Note that this title
does not appear on the screen, and can only be  used internally to find
a specific column.
function Get_Column_Title
     (Sheet              : access Gtk_Sheet_Record;
        Column             :        Gint)
        return String;

Return the title of a specific column.
procedure Set_Column_Titles_Height
     (Sheet              : access Gtk_Sheet_Record;
        Height             : in     Guint);

Modify the height of the row in which the column titles appear.
procedure Column_Button_Add_Label
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Label              : in     String);

Modify the label of the button that appears at the top of each column.
procedure Column_Button_Justify
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Justification      : in     Gtk.Enums.Gtk_Justification);

Modify the justification for the label in the column button.
procedure Show_Column_Titles
     (Sheet              : access Gtk_Sheet_Record);

Show the row in which the column titles appear.
procedure Hide_Column_Titles
     (Sheet              : access Gtk_Sheet_Record);

Hide the row in which the column titles appear.
procedure Columns_Set_Sensitivity
     (Sheet              : access Gtk_Sheet_Record;
        Sensitive          : in     Boolean);

Modify the sensitivity of all the columns.
If Sensitive is False, the columns can not be resized dynamically.
This also modifies the sensitivity of the button at the top of the
columns.
procedure Column_Set_Sensitivity
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Sensitive          : in     Boolean);

Modify the sensitivity of a specific column and its title button.
If Sensitive if False, the column can not be dynamically resized.
procedure Column_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Visible            : in     Boolean);

Change the visibility of a column.
procedure Column_Label_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Visible            : in     Boolean := True);

Change the visibility of the label in a given column.
procedure Columns_Labels_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Visible            :        Boolean := True);

Change the visibility for all the column labels.
procedure Set_Column_Width
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Width              : in     Guint);

Modify the width in pixels of a specific column.
function Get_Column_Width
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint)
        return Gint;

Return the width in pixels of the Column-nth in Sheet.
procedure Add_Column
     (Sheet              : access Gtk_Sheet_Record;
        Ncols              : in     Guint);

Add some empty columns at the end of the sheet.
procedure Insert_Columns
     (Sheet              : access Gtk_Sheet_Record;
        Col                : in     Guint;
        Ncols              : in     Guint);

Add Ncols empty columns just before the columns number Col.
procedure Delete_Columns
     (Sheet              : access Gtk_Sheet_Record;
        Col                : in     Guint;
        Ncols              : in     Guint);

Delete Ncols columns starting from Col.
procedure Column_Set_Justification
     (Sheet              : access Gtk_Sheet_Record;
        Column             : in     Gint;
        Justification      : in     Gtk.Enums.Gtk_Justification);

Set the default justification for the cells in the specific column.
function Get_Columns_Count
     (Sheet              : access Gtk_Sheet_Record)
        return Guint;

Return the maximum column number of the displayed cells.
Rows
----

procedure Set_Row_Title
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Title              : in     String);

Modify the title of a row.
The first row at the top has the number 0.   Note that this title does
not appear on the screen, and can only be  used internally to find a
specific row.
function Get_Row_Title
     (Sheet              : access Gtk_Sheet_Record;
        Row                :        Gint)
        return String;

Return the title of a specific row.
procedure Set_Row_Titles_Width
     (Sheet              : access Gtk_Sheet_Record;
        Width              : in     Guint);

Modify the width of the column that has the row titles.
procedure Row_Button_Add_Label
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Label              : in     String);

Modify the label of the button that appears at the left of each row.
procedure Row_Button_Justify
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Justification      : in     Gtk.Enums.Gtk_Justification);

Modify the justification for the label of the row button.
procedure Show_Row_Titles
     (Sheet              : access Gtk_Sheet_Record);

Show the column in which the row titles appear.
procedure Hide_Row_Titles
     (Sheet              : access Gtk_Sheet_Record);

Hide the column in which the row titles appear.
procedure Rows_Set_Sensitivity
     (Sheet              : access Gtk_Sheet_Record;
        Sensitive          : in     Boolean);

Modify the sensitivity of all the rows.
If Sensitive is False, the rows can not be resized dynamically.   This
also modifies the sensitivity of the button at the left of the  row.
procedure Row_Set_Sensitivity
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Sensitive          : in     Boolean);

Modify the sensitivity of a specific row and its title button.
If Sensitive if False, the row can not be dynamically resized.
procedure Row_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Visible            : in     Boolean);

Modify the visibility of a specific row
procedure Row_Label_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Visible            : in     Boolean := True);

Change the visibility of the label in a given Row.
procedure Rows_Labels_Set_Visibility
     (Sheet              : access Gtk_Sheet_Record;
        Visible            :        Boolean := True);

Change the visibility for all the row labels.
procedure Set_Row_Height
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Height             : in     Guint);

Set the height in pixels of a specific row.
function Get_Row_Height
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint)
        return Gint;

Return the height in pixels of the Row-th row in Sheet.
procedure Add_Row
     (Sheet              : access Gtk_Sheet_Record;
        Nrows              : in     Guint);

Append Nrows row at the end of the sheet.
procedure Insert_Rows
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Guint;
        Nrows              : in     Guint);

Add Nrows empty rows just before the row number Row.
procedure Delete_Rows
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Guint;
        Nrows              : in     Guint);

Delete Nrows rows starting from Row.
function Get_Rows_Count
     (Sheet              : access Gtk_Sheet_Record)
        return Guint;

Return the maximum row number of displayed cells.
Range
-----

function Range_Get_Type        return Gtk.Gtk_Type;

Return the internal value associate with a Gtk_Sheet_Range
procedure Range_Clear
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range);

Clear the content of the range.
procedure Range_Delete
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range);

Clear the content of the range and delete all the links (user_data)
procedure Range_Set_Background
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Color              : in     Gdk.Color.Gdk_Color);

Set the background color for the cells in a specific range.
procedure Range_Set_Foreground
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Color              : in     Gdk.Color.Gdk_Color);

Set the foreground color for the cells in a specific range.
procedure Range_Set_Justification
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Justification      : in     Gtk.Enums.Gtk_Justification);

Set the text justification for the cells in the range.
procedure Range_Set_Editable
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Editable           : in     Boolean);

Set whether the cells in the range are editable.
procedure Range_Set_Visible
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Visible            : in     Boolean);

Set whether the cells in the range are visible.
procedure Range_Set_Border
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Mask               : in     Gtk_Sheet_Border;
        Width              : in     Guint;
        Line_Style         : in     Gdk.Types.Gdk_Line_Style);

Set the style of the border for the cells in the range.
procedure Range_Set_Border_Color
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Color              : in     Gdk.Color.Gdk_Color);

Change the color for the borders of the cells in the range.
procedure Range_Set_Font
     (Sheet              : access Gtk_Sheet_Record;
        The_Range          : in     Gtk_Sheet_Range;
        Font               : in     Gdk.Font.Gdk_Font);

Change the font of the cells in the range.
Cells
-----

procedure Set_Cell
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint;
        Justification      : in     Gtk.Enums.Gtk_Justification;
        Text               : in     String);

Set the cell contents.
Set Text to the empty string to delete the content of the cell.
procedure Set_Cell_Text
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint;
        Text               : in     String);

Set the cell contents.
The justification used is the previous one used in that cell.
function Cell_Get_Text
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint)
        return String;

Return the text put in a specific cell.
The empty string is returned if there is no text in that cell.
procedure Cell_Clear
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint);

Clear the contents of the cell.
procedure Cell_Delete
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint);

Clear the contents of the cell and remove the user data associated
with it.
function Cell_Get_State
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint)
        return Gtk.Enums.Gtk_State_Type;

Return the state of the cell (normal or selected).
procedure Get_Pixel_Info
     (Sheet              : access Gtk_Sheet_Record;
        X                  : in     Gint;
        Y                  : in     Gint;
        Row                : out    Gint;
        Column             : out    Gint);

Return the row and column matching a given pixel on the screen.
Constraint_Error is raised if no such cell exists.
procedure Get_Cell_Area
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Column             : in     Gint;
        Area               : out    Gdk.Rectangle.Gdk_Rectangle);

Get the area of the screen that a cell is mapped to.
Constraint_Error is raised if no such cell exists;
Children
--------

A Gtk_Sheet can contain some children, attached to some specific
cells.

procedure Put
     (Sheet              : access Gtk_Sheet_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        X                  : in     Gint;
        Y                  : in     Gint);

Put a new child at a specific location (in pixels) in the sheet.
procedure Attach
     (Sheet              : access Gtk_Sheet_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        Row                : in     Gint;
        Col                : in     Gint;
        X_Align            : in     Gfloat;
        Y_Align            : in     Gfloat);

Attach a child to a specific Cell in the sheet.
X_Align and Y_Align should be between 0.0 and 1.0, indicating that  the
child should be aligned from the Left (resp. Top) to the Right  (resp.
Bottom) of the cell.
procedure Move_Child
     (Sheet              : access Gtk_Sheet_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        X                  : in     Gint;
        Y                  : in     Gint);

Move a child of the table to a specific location in pixels.
A warning is printed if Widget is not already a child of Sheet.
function Get_Child_At
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint)
        return Gtk_Sheet_Child;

Return the widget associated with the cell.
function Get_Widget
     (Child              :        Gtk_Sheet_Child)
        return Gtk.Widget.Gtk_Widget;

Return the widget in the child.
procedure Button_Attach
     (Sheet              : access Gtk_Sheet_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        Row                : in     Gint;
        Col                : in     Gint;
        X_Align            : in     Gfloat;
        Y_Align            : in     Gfloat);

Attach a new button in the row or column title.
One of Row or Col must be negative (but only one).   This can be used
to modify the standard buttons that appear at the top  of each column,
or on the left of each row.
Links / User_Data
-----------------

You can associate any kind of data with a cell, just like you
can associate user_data with all the widgets.   Note that this uses a
generic package, which must be instantiated at  library level since it
has internal clean up functions.

procedure Link_Cell
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint;
        Link               : in     Data_Type);

Associate some user specific data with a given cell.
function Get_Link
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint)
        return Data_Type_Access;

Return the user data associated with the cell.
null is returned if the cell has no user data.
procedure Remove_Link
     (Sheet              : access Gtk_Sheet_Record;
        Row                : in     Gint;
        Col                : in     Gint);

Delete the user data associated with the cell.
Flags
-----

Some flags are defined for this widget. You can not access them through
the usual interface in Gtk.Object.Flag_Is_Set since this widget is not
part of the standard gtk+ packages. Instead, use the functions below.

   * "Is_Locked"    Set if the cells are editable

   * "Is_Frozen"    Set if the sheet is temporary frozen, ie does not
     redisplay itself    after each modification. See the subprograms
     Freeze and Thaw.

   * "In_Xdrag"    Set while a column is being dynamically resized by
     the user.

   * "In_Ydrag"    Set while a row is being dynamically resized by the
     user.

   * "In_Drag"    Set while the active cell's is being dragged.

   * "In_Selection"    Set while the user is selecting a block of cells.

   * "In_Resize"    Set while the sheet itself is being dynamically
     resized by the user.

   * "In_Clip"    See the subprograms Clip_Range and Unclip_Range.

   * "Row_Frozen"    Set when the user can not dynamically resize the
     rows.

   * "Column_Frozen"    Set when the user can not dynamically resize
     the columns.

   * "Auto_Resize"    Set when the columns automatically resize
     themselves when their    content is longer than their width.

   * "Clip_Text"    Set when the text contained in the cells is
     automatically clipped to    their width.

   * "Row_Titles_Visible"    Set when a special column is added to the
     left to show the title of    the rows.

   * "Column_Titles_Visible"    Set when a special row is added at the
     top to show the title of the    columns.

   * "Auto_Scroll"    Set when the sheet should automatically scroll to
     show the active    cell at all times.

   * "Justify_Entry"    Set when the justification attribute for
     entries should be taken into    account

function Sheet_Flag_Is_Set
     (Sheet              : access Gtk_Sheet_Record;
        Flag               :        Guint16)
        return Boolean;

Test whether one of the flags for a Gtk_Sheet widget or its children
is set. This can only be used for the flags defined in the
Gtk.Extra.Gtk_Sheet package.
procedure Sheet_Set_Flags
     (Sheet              : access Gtk_Sheet_Record;
        Flags              :        Guint16);

Set the flags for a Gtk_Sheet widget or its children. Note that the
flags currently set are not touched by this function. This can only be
used for the flags defined in the Gtk.Extra.Gtk_Sheet package.
procedure Sheet_Unset_Flags
     (Sheet              : access Gtk_Sheet_Record;
        Flags              :        Guint16);

Unset the flags in the widget.

File: gtkada_rm.info,  Node: Package_Gtk.File_Selection,  Next: Package_Gtk.Fixed,  Prev: Package_Gtk.Extra.Sheet,  Up: Top

Package Gtk.File`_'Selection
****************************

A Gtk_File_Selection is a general widget to interactively select file.
It displays a dialog in which the user can navigate through
directories,  select a file, and even manipulate files with operations
like removing,  renaming,...   Currently, only one file can be selected
in the dialog.

* Menu:

* Gtk.File_Selection Widget Hierarchy::
* Gtk.File_Selection Subprograms::


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

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

     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_File_Selection (*note Package_Gtk.File_Selection::)


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

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

Operations on the dialog
------------------------

procedure Gtk_New
     (File_Selection     : out    Gtk_File_Selection;
        Title              : in     String);

Create a new file selection dialog.
Title is the name of the dialog, as displayed in its title bar.
function Get_Type              return Gtk.Gtk_Type;

Return the internal value associated with a Gtk_File_Selection.
procedure Set_Filename
     (File_Selection     : access Gtk_File_Selection_Record;
        Filename           : in     String);

Highlight the given file in the dialog.
Note that this does not close the dialog.   You can also use this
procedure to select the directory to be displayed  in the dialog. Along
with Complete, this allows you to set some filters  in the dialog.
function Get_Filename
     (File_Selection     : access Gtk_File_Selection_Record)
        return String;

Get the selected file name.
procedure Complete
     (File_Selection     : access Gtk_File_Selection_Record;
        Pattern            : in     String);

Set the filter used to display the files.
The pattern is displayed in the entry at the bottom of the dialog, and
the list of files displayed in the list.
procedure Show_Fileop_Buttons
     (File_Selection     : access Gtk_File_Selection_Record);

When this function is called, the dialog includes a series of buttons
for file operations (create directory, rename a file, delete a file).
procedure Hide_Fileop_Buttons
     (File_Selection     : access Gtk_File_Selection_Record);

Hide the buttons for file operations.
procedure Set_Show_File_Op_Buttons
     (File_Selection     : access Gtk_File_Selection_Record;
        Flag               :        Boolean);

Choose whether to display or not the file operation buttons.
This button is kept for backward compatibility only.

   If Flag is true, calls Show_Fileop_Buttons, otherwise calls
Hide_Fileop_Buttons.
Getting the fields
------------------

The following functions are provided to access the fields of the
file selection dialog.   This dialog is divided into two main areas,
the Action_Area which is  the top part that contains the list of files,
and the button area which  is the bottom part that contains the OK and
Cancel buttons.

function Get_Action_Area
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Box.Gtk_Box;

Return the action area.
This is the area that contains the list of files, the filter entry,etc.
function Get_Button_Area
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Box.Gtk_Box;

Return the button area.
This is the area that contains the OK and Cancel buttons.
function Get_Dir_List
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Widget.Gtk_Widget;

Return the list that display the list of directories.
function Get_File_List
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Widget.Gtk_Widget;

Return the list that display the list of files in the selected directory
function Get_Cancel_Button
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Button.Gtk_Button;

Return the Cancel button.
To remove this button from the dialog, call Hide on the return value.
The callbacks on this button should simply close the dialog, but should
ignore the file selected by the user.
function Get_Help_Button
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Button.Gtk_Button;

Return the Help button.
To remove this button from the dialog, call Hide on the return value.
The callbacks on this button should display a new dialog that explain
what file the user should select.
function Get_Ok_Button
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Button.Gtk_Button;

Return the OK button.
The callbacks on this button should close the dialog and do something
with the file selected by the user.
function Get_History_Pulldown
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Widget.Gtk_Widget;

Return the menu that display the history of directories
for easy access by the user.
function Get_Selection_Entry
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Widget.Gtk_Widget;

Return the entry used to set the filter on the list of directories.
The simplest way to insert text in this entry is to use the  Complete
procedure above.
function Get_Selection_Text
     (File_Selection     : access Gtk_File_Selection_Record)
        return Gtk.Widget.Gtk_Widget;

Return the text displayed just above the Selection_Entry.

File: gtkada_rm.info,  Node: Package_Gtk.Fixed,  Next: Package_Gtk.Font_Selection,  Prev: Package_Gtk.File_Selection,  Up: Top

Package Gtk.Fixed
*****************

The Gtk_Fixed widget is a container which can place child widgets at
fixed  positions and with fixed sizes, given in pixels.

   Note that it is usually bad practice to use the Gtk_Fixed container
in  GtkAda. Instead, you should consider using one of the other many
containers  available, that will allow you to handle resizing of your
windows, as well  as font size changes easily.

* Menu:

* Gtk.Fixed Widget Hierarchy::
* Gtk.Fixed Subprograms::


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

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

     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Fixed       (*note Package_Gtk.Fixed::)


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

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

procedure Gtk_New
     (Fixed              : out    Gtk_Fixed);

Create a new fixed container.
function Get_Type              return Gtk.Gtk_Type;

Return the internal value associated with a Gtk_Fixed.
function Get_Children
     (Fixed              : access Gtk_Fixed_Record)
        return Widget.Widget_List.Glist;

Return the list of Widgets contained in a Gtk_Fixed.
procedure Move
     (Fixed              : access Gtk_Fixed_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        X                  : in     Gint16;
        Y                  : in     Gint16);

Move a child of a GtkFixed container to the given position.
X indicates the horizontal position to place the widget at.   Y is the
vertical position to place the widget at.
procedure Put
     (Fixed              : access Gtk_Fixed_Record;
        Widget             : access Gtk.Widget.Gtk_Widget_Record'Class;
        X                  : in     Gint16;
        Y                  : in     Gint16);

Add Widget to a Fixed container at the given position.
X indicates the horizontal position to place the widget at.   Y is the
vertical position to place the widget at.

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

Package Gtk.Font`_'Selection
****************************

This widget provides a nice way for the user of your application to
select fonts.   It first searches on your system for the list of fonts
available, and  displays a set of boxes to select them based on their
name, their  weight, their size, etc.   This widget is provided in two
forms, one widget that can be embedded  in any container, a
Gtk_Font_Selection, whereas the other one comes  directly in its own
separate window (to be popped up as a dialog).

   Some filters can be applied to the widget, when you want the user to
select only a font only among a specific subset (like bitmap or
true-type fonts for instance).   There are two kinds of filters: a base
filter, set in your application  and that the user can not change; a
user filter that can be modified  interactively by the user.

* Menu:

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


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

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

     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_Font_Selection_Dialog (*note Package_Gtk.Font_Selection_Dialog::)


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

Types
=====

type Gtk_Font_Filter_Type is
     (Font_Filter_Base,
          Font_Filter_User);

These are the two types of filter available - base and user. The  base
filter is set by the application and can't be changed by the  user.
type Gtk_Font_Metric_Type is
     (Font_Metric_Pixels,
          Font_Metric_Points);

Used to determine whether point or pixel sizes are used.
subtype Gtk_Font_Type is Gint;

Used for determining the type of a font style (bitmap, scalable,...),
and also for setting filters.  These can be combined if a style has
bitmaps and scalable fonts available.

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

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

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

procedure Gtk_New
     (Widget             : out    Gtk_Font_Selection);

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

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

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

Allocate and return the font selected by the user.
This newly created font can be used as is by all the drawing functions
in the Gdk.Drawable package.   If not font has been selected,
Gdk.Font.Null_Font is returned.
function Set_Font_Name
     (Fontsel            : access Gtk_Font_Selection_Record;
        Fontname           : in     String)
        return Boolean;

Set the name and attributes of the selected font in Fontsel.
Fontname should have the standard format on X11 systems, that fully
describe the family, weight, size, slant, etc. of the font.
procedure Set_Filter
     (Fsd                : access Gtk_Font_Selection_Record;
        Filter_Type        : in     Gtk_Font_Filter_Type;
        Font_Type          : in     Gtk_Font_Type := Font_All;
        Foundries          : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Weights            : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Slants             : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Setwidths          : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Spacings           : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Charsets           : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array);

Set up one of the filters used to display the fonts.
As described above, there are two types of filters, one of which,
Font_Filter_Base, can not be modified by the user.   All the properties
are given in an array (no need to have a NULL  terminated array as in
C).   See the example in the testgtk/ directory in the GtkAda
distribution for  the possible values you can give to the parameters.
The strings are  case sensitive.   You can also free the strings when
you are done with them, since gtk+  keeps a copy of the information it
needs.   The default values for parameters are set so that there is in
fact no  filter.   Note that this call will succeed only if Fsd has
been added to a window  first.
function Get_Preview_Text
     (Fontsel            : access Gtk_Font_Selection_Record)
        return String;

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

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

procedure Gtk_New
     (Widget             : out    Gtk_Font_Selection_Dialog;
        Title              : in     String);

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

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

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

Allocate and return the font selected by the user.
This newly created font can be used as is by all the drawing functions
in the Gdk.Drawable package.   If not font has been selected,
Gdk.Font.Null_Font is returned.
function Set_Font_Name
     (Fsd                : access Gtk_Font_Selection_Dialog_Record;
        Fontname           : in     String)
        return Boolean;

Set the name and attributes of the selected font in Fontsel.
Fontname should have the standard format on X11 systems, that fully
describe the family, weight, size, slant, etc. of the font.
procedure Set_Filter
     (Fsd                : access Gtk_Font_Selection_Dialog_Record;
        Filter_Type        : in     Gtk_Font_Filter_Type;
        Font_Type          : in     Gtk_Font_Type := Font_All;
        Foundries          : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Weights            : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Slants             : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Setwidths          : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Spacings           : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array;
        Charsets           : in     Gtkada.Types.Chars_Ptr_Array
                            := Gtkada.Types.Null_Array);

Set up one of the filters used to display the fonts.
As described above, there are two types of filters, one of which,
Font_Filter_Base, can not be modified by the user.   All the properties
are given in an array (no need to have a NULL  terminated array as in
C).   See the example in the testgtk/ directory in the GtkAda
distribution for  the possible values you can give to the parameters.
The strings are  case sensitive.   You can also free the strings when
you are done with them, since gtk+  keeps a copy of the information it
needs.   The default values for parameters are set so that there is in
fact no  filter.
function Get_Preview_Text
     (Fsd                : access Gtk_Font_Selection_Dialog_Record)
        return String;

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

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

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

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

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

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

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


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

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

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

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

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

* Menu:

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


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

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

     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Bin         (*note Package_Gtk.Bin::)
                 \___ Gtk_Frame    (*note Package_Gtk.Frame::)


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

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

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

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

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

Change the label of the frame dynamically.
If Label is the empty string, the frame's label is deleted.
procedure Set_Label_Align
     (Frame              : access Gtk_Frame_Record;
        Xalign             : in     Gfloat := 0.0;
        Yalign             : in     Gfloat := 0.0);

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

Change the visual aspect of the frame.

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

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

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

   See also Gtk_Text for a multiple-line text editing widget.

   Note that this widget does not currently support wide-character, or
character sets that require multiple-byte encoding.

* Menu:

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


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

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

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


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

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

procedure Gtk_New
     (Widget             : out    Gtk_Entry;
        Max                : in     Guint16);

Create a new entry with a maximum length for the text.
The text can never be longer than Max characters.
procedure Gtk_New
     (Widget             : out    Gtk_Entry);

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

Return the internal value associated with a Gtk_Entry.
procedure Set_Text
     (The_Entry          : access Gtk_Entry_Record;
        Text               : in     String);

Modify the text in the entry.
The text is cut at the maximum length that was set when the entry was
created.   The text replaces the current contents.
procedure Append_Text
     (The_Entry          : access Gtk_Entry_Record;
        Text               : in     String);

Append a new string at the end of the existing one.
procedure Prepend_Text
     (The_Entry          : access Gtk_Entry_Record;
        Text               : in     String);

Insert some text at the beginning of the entry.
procedure Set_Visibility
     (The_Entry          : access Gtk_Entry_Record;
        Visible            : in     Boolean);

Set the visibility of the characters in the entry.
If Visible is set to False, the characters will be replaced with
starts ('*') in the display, and when the text is copied elsewhere.
procedure Set_Max_Length
     (The_Entry          : access Gtk_Entry_Record;
        Max                : in     Guint16);

Set the maximum length for the text.
The current text is truncated if needed.

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

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

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

* Menu:

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


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

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

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


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

Types
=====

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

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