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


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

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

Creating a Data set
-------------------

procedure Gtk_New
     (Data               : out    Gtk_Plot_Data;
        Func               :        Plot_Function := null);

Creates a new data set. Its values can either be generated automatically
from Func, or will have to be set explicitely using the other
subprograms in this package.
function Get_Type              return Gtk.Gtk_Type;

Return the internal value associated with a Gtk_Plot_Data.
procedure Set_Name
     (Data               : access Gtk_Plot_Data_Record;
        Name               :        String);

Set the name used internally for that dataset.
This name does not appear anywhere on the screen, but it is easier to
find the dataset afterward by using this name.
Drawing a set
-------------

Although a set is basically a list of values, it is closely associated
with its representation on the screen (see the children of Gtk_Plot_Data
for various possible representations).   The Gtk.Extra packages are
designed so that the drawing can be done  either to the screen (through
a Gdk adapter), to a postscript file for  easy printing, or to any
other media.

procedure Paint
     (Data               : access Gtk_Plot_Data_Record);

Emits the "draw_data" signal to request a redrawing of the data set.
procedure Draw_Points
     (Data               : access Gtk_Plot_Data_Record;
        N                  :        Gint);

Draw at most N values of the Data set on the screen. If N is greater
than the actual number of values in Data, then they are all displayed.
procedure Draw_Symbol
     (Data               : access Gtk_Plot_Data_Record;
        X, Y               :        Gdouble);

Draw the current symbol (see Set_Symbol) at specific coordinates on
the screen.
Manipulating values
-------------------

procedure Set_Points
     (Data               : access Gtk_Plot_Data_Record;
        X                  :        Gdouble_Array_Access;
        Y                  :        Gdouble_Array_Access;
        Dx                 :        Gdouble_Array_Access;
        Dy                 :        Gdouble_Array_Access);

Set some explicit points in the set.
Note that the set must not be associated with a function, or the points
will simply be ignored.   All of the arrays must have the same length,
the behavior is undefined  otherwise.   X and Y are the list of
coordinates of the points.   Dx and Dy are the list of size (precision)
of these points. A bigger  symbol will be displayed for the point whose
(Dx, Dy) value is bigger.
procedure Get_Points
     (Data               : access Gtk_Plot_Data_Record;
        X                  : out    Points_Array;
        Y                  : out    Points_Array;
        Dx                 : out    Points_Array;
        Dy                 : out    Points_Array);

Return the value of the points in the set.
Null-length arrays are returned if the set is associated with a
function, since no explicit point has been set.   See Set_Points for a
definition of X, Y, Dx and Dy.
procedure Set_X
     (Data               : access Gtk_Plot_Data_Record;
        X                  :        Gdouble_Array_Access);

procedure Set_Z
     (Data               : access Gtk_Plot_Data_Record;
        Z                  :        Gdouble_Array_Access);

procedure Set_Dx
     (Data               : access Gtk_Plot_Data_Record;
        Dx                 :        Gdouble_Array_Access);

procedure Set_Dz
     (Data               : access Gtk_Plot_Data_Record;
        Dz                 :        Gdouble_Array_Access);

Set the precision of the points in the set. A bigger symbol is displayed
for the points whose (Dx, Dy, Dz) is bigger.   The array must have a
length of Get_Numpoints (if GtkAda was  compiled with assertions
enabled, an exception will be raised if the  length are different).
No copy of the array is made for efficiency reasons, thus modifying
the array content later on will also modify the plot.
procedure Set_Da
     (Data               : access Gtk_Plot_Data_Record;
        Da                 :        Gdouble_Array_Access);

Specifies the colors to use for the points.
The color of the symbols is detemined using the gradient. the gradient
has (min, max) values, and corresponding colors. The symbol's color is
interpolated between these values using hue/saturation/value depending
on the gradient_mask.
function Get_X
     (Data               : access Gtk_Plot_Data_Record)
        return Points_Array;

function Get_Z
     (Data               : access Gtk_Plot_Data_Record)
        return Points_Array;

function Get_Dx
     (Data               : access Gtk_Plot_Data_Record)
        return Points_Array;

function Get_Dz
     (Data               : access Gtk_Plot_Data_Record)
        return Points_Array;

procedure Set_Numpoints
     (Data               : access Gtk_Plot_Data_Record;
        Num                :        Gint);

Set the number of points that should be expected in the graph.
Note that this does not automatically resize all the internal structure,
it just indicates what size the parameters to Set_X, Set_Y,... should
have.
function Get_Numpoints
     (Data               : access Gtk_Plot_Data_Record)
        return Gint;

Return the number of points expected in the graph.
Labels
------

Each point in the data set can be associated with a label that describes
it. This is only relevant for data sets where you explicitely give
values, not when the values are generated by a function.

procedure Set_Labels
     (Data               : access Gtk_Plot_Data_Record;
        Labels             :        Gtkada.Types.Chars_Ptr_Array);

Set the labels associated which each point in the canvas.
There must be at least Get_Numpoints elements in Labels, or the
behavior is undefined
function Get_Labels
     (Data               : access Gtk_Plot_Data_Record)
        return Gtkada.Types.Chars_Ptr_Array;

Return the labels associated with the points in the data set.
Note that this returns a *copy* of the actual array, and thus might  be
expensive to call.
procedure Show_Labels
     (Data               : access Gtk_Plot_Data_Record;
        Show               :        Boolean);

Indicate whether the labels should be displayed next to each point in
the data set. This has no effect if no labels were specified.
procedure Labels_Set_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Font               :        String;
        Height             :        Gint;
        Angle              :        Gint;
        Foreground         :        Gdk.Color.Gdk_Color;
        Background         :        Gdk.Color.Gdk_Color);

Set the properties of the labels
Symbols and Connectors
----------------------

Each point that is explicitely set in the data set through the
Set_X, Set_Y,... subprograms is visually associated with a symbol. There
are several representations for the symbols.

   All these symbols are then connected by a line, a curve or any other
link. These are called connectors.

   Each symbol, in addition to being connected to the next one with a
connector, can also be linked to the axis X=0, Y=0 or Z=0 so that it is
easier to read its coordinates. These are called errbars, and they must
be explicitely shown.

procedure Set_Symbol
     (Data               : access Gtk_Plot_Data_Record;
        The_Type           :        Plot_Symbol_Type;
        Style              :        Plot_Symbol_Style;
        Size               :        Gint;
        Line_Width         :        Gfloat;
        Color              :        Gdk.Color.Gdk_Color;
        Border_Color       :        Gdk.Color.Gdk_Color);

Set the visual aspect of the symbols.
procedure Get_Symbol
     (Data               : access Gtk_Plot_Data_Record;
        The_Type           : out    Plot_Symbol_Type;
        Style              : out    Plot_Symbol_Style;
        Size               : out    Gint;
        Line_Width         : out    Gint;
        Color              : out    Gdk.Color.Gdk_Color;
        Border_Color       : out    Gdk.Color.Gdk_Color);

Return the visual characteristics of the symbols.
procedure Set_Connector
     (Data               : access Gtk_Plot_Data_Record;
        Connector          :        Plot_Connector);

Set the style of the connectors.
function Get_Connector
     (Data               : access Gtk_Plot_Data_Record)
        return Plot_Connector;

Return the connector style used for the data set.
procedure Set_Line_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Style              :        Plot_Line_Style;
        Width              :        Gfloat;
        Color              :        Gdk.Color.Gdk_Color);

Set the line style used for the connectors.
procedure Get_Line_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Style              : out    Plot_Line_Style;
        Width              : out    Gfloat;
        Color              : out    Gdk.Color.Gdk_Color);

Return the line attributes used for the connectors.
procedure Set_X_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Style              :        Plot_Line_Style;
        Width              :        Gfloat;
        Color              :        Gdk.Color.Gdk_Color);

Set the style of the lines used to connect the symbols to the X axis.
procedure Set_Y_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Style              :        Plot_Line_Style;
        Width              :        Gfloat;
        Color              :        Gdk.Color.Gdk_Color);

Set the style of the lines used to connect the symbols to the Y axis.
procedure Set_Z_Attributes
     (Data               : access Gtk_Plot_Data_Record;
        Style              :        Plot_Line_Style;
        Width              :        Gfloat;
        Color              :        Gdk.Color.Gdk_Color);

Set the style of the lines used to connect the symbols to the Z axis.
procedure Show_Xerrbars
     (Data               : access Gtk_Plot_Data_Record);

procedure Show_Zerrbars
     (Data               : access Gtk_Plot_Data_Record);

Indicate that each symbol should be connected to the various axis
procedure Hide_Xerrbars
     (Data               : access Gtk_Plot_Data_Record);

procedure Hide_Zerrbars
     (Data               : access Gtk_Plot_Data_Record);

Indicate the the symbol should not be connected to the axis.
procedure Fill_Area
     (Data               : access Gtk_Plot_Data_Record;
        Fill               :        Boolean);

Indicate whether the area between two points should be filled or not.
function Area_Is_Filled
     (Data               : access Gtk_Plot_Data_Record)
        return Boolean;

Indicate whether the area between two points is filled.
Legends
-------

In addition to the drawing corresponding to the data set, it is possible
to display a box that contains a legend. This is particulary useful when
multiple data sets are displayed on the same plot.

procedure Set_Legend
     (Data               : access Gtk_Plot_Data_Record;
        Legend             :        String);

Set the string printed in the legend for that data set.
Note that an entry can exist in the legend even if there is no name
associated with the graph.
procedure Show_Legend
     (Data               : access Gtk_Plot_Data_Record);

An entry will be made in the plot's legend for that dataset.
procedure Hide_Legend
     (Data               : access Gtk_Plot_Data_Record);

No entry will appear in the plot's legend for that dataset.
procedure Set_Legend_Precision
     (Data               : access Gtk_Plot_Data_Record;
        Precision          :        Gint);

Number of digits to display when the legends is associated with values,
as is the case for gradients.
function Get_Legend_Precision
     (Data               : access Gtk_Plot_Data_Record)
        return Gint;

Return the number of digits used for values in the legend
Gradients
---------

The symbols displayed in the plot can be assigned specific colors. But
they can also compute their own color by picking it in a gradient,
depending on the value.

procedure Set_Gradient_Mask
     (Data               : access Gtk_Plot_Data_Record;
        Mask               :        Plot_Gradient);

Indicates which component of the colors vary along the gradient.
function Get_Gradient_Mask
     (Data               : access Gtk_Plot_Data_Record)
        return Plot_Gradient;

Return the mask used for the gradient.
procedure Gradient_Set_Visible
     (Data               : access Gtk_Plot_Data_Record;
        Visible            :        Boolean);

Indicates whether the gradient should be visible
function Gradient_Visible
     (Data               : access Gtk_Plot_Data_Record)
        return Boolean;

Return True if the gradient is currently visible
procedure Set_Gradient_Colors
     (Data               : access Gtk_Plot_Data_Record;
        Min, Max           :        Gdk.Color.Gdk_Color);

Set the colors that define the gradient. The colors will vary from
Min to Max along the components specified in Set_Gradient_Mask.
procedure Get_Gradient_Colors
     (Data               : access Gtk_Plot_Data_Record;
        Min, Max           : out    Gdk.Color.Gdk_Color);

Return the colors that define the range
procedure Set_Gradient
     (Data               : access Gtk_Plot_Data_Record;
        Min, Max           :        Gdouble;
        Nlevels            :        Gint);

Define the values associated with the minimal color and the maximal
color. Any value in between will have a color computed in between.
Nlevels is the number of ticks to display in the gradient.
procedure Get_Gradient
     (Data               : access Gtk_Plot_Data_Record;
        Min, Max           : out    Gdouble;
        Nlevels            : out    Gint);

Return the values associated with the minimal and maximal colors.
procedure Get_Gradient_Level
     (Data               : access Gtk_Plot_Data_Record;
        Level              :        Gdouble;
        Color              : out    Gdk.Color.Gdk_Color);

Return the color associated with a specific level.
The color depends on the parameters to Set_Gradient and
Set_Gradient_Colors.
User Data
---------

It is possible to associated your own user data with a plot. This is
the mechanism provided by the C version of gtkextra. However, the best
way to do this in Ada is to inherit from Gtk_Plot_Data_Record (or one
of its children), and add your own fields.

procedure Set_Link
     (Data               : access Gtk_Plot_Data_Record;
        Link               :        System.Address);

Associate some user data with Data.
It is the responsability of the user to do some convert conversion to
System.Address.
function Get_Link
     (Data               : access Gtk_Plot_Data_Record)
        return System.Address;

Return the user data associated with Data, or Null_Address if there is
none.
procedure Remove_Link
     (Data               : access Gtk_Plot_Data_Record);

Remove the user data associated with Data.

File: gtkada_rm.info,  Node: Package_Gtk.Extra.Plot_Polar,  Next: Package_Gtk.Extra.Plot_Ps,  Prev: Package_Gtk.Extra.Plot_Data,  Up: Top

Package Gtk.Extra.Plot`_'Polar
******************************

This special type of data set displays itself in polar coordinates.

* Menu:

* Gtk.Extra.Plot_Polar Widget Hierarchy::
* Gtk.Extra.Plot_Polar Subprograms::


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

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

     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Plot           (*note Package_Gtk.Extra.Plot::)
              \___ Gtk_Plot_Polar  (*note Package_Gtk.Extra.Plot_Polar::)


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

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

procedure Gtk_New
     (Polar              : out    Gtk_Plot_Polar;
        Drawable           :        Gdk.Drawable.Gdk_Drawable
                            := null;
        Width, Height      :        Gdouble := 0.0);

Create a new polar plot.
If Width and Height are 0, they are left unspecified when calling the
C function.
function Get_Type              return Gtk.Gtk_Type;

Return the internal value associated with a Gtk_Box
procedure Rotate
     (Polar              : access Gtk_Plot_Polar_Record;
        Angle              :        Gdouble);

Rotate the graph by a given amount of radians.

File: gtkada_rm.info,  Node: Package_Gtk.Extra.Plot_Ps,  Next: Package_Gtk.Extra.Plot_Surface,  Prev: Package_Gtk.Extra.Plot_Polar,  Up: Top

Package Gtk.Extra.Plot`_'Ps
***************************

This package does not implement any new widget.   Instead, if provides
postscript support for Gtk_Plot widgets, and can  create a postscript
file from any Gtk_Plot widget.

* Menu:

* Gtk.Extra.Plot_Ps Types::
* Gtk.Extra.Plot_Ps Subprograms::


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

Types
=====

type Ps_Orientation is
     (Plot_Portrait,
          Plot_Landscape);

Portrait format means that the vertical size is longer than  the
horizontal size. Landscape is the reverse.
type Ps_Page_Size is
     (Plot_Letter,
          Plot_Legal,
          Plot_A4,
          Plot_Executive,
          Plot_Custom);

The formats that can be used for paper sizes.
type Ps_Units is
     (Plot_Inches,
          Plot_Mm,
          Plot_Cm,
          Plot_Pspoints);

Units of measure for paper sizes.

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

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

procedure Plot_Export_Ps
     (Plot               : access Gtk.Extra.Plot.Gtk_Plot_Record'Class;
        Psfile             : in     String;
        Orientation        : in     Ps_Orientation;
        Epsflag            : in     Boolean;
        Page_Size          : in     Ps_Page_Size);

Create a new postscript file PsFile with the content of Plot.
Epsflag should be true if the generated file should be in  Encapsulated
Postscript format instead of simple Postscript.
procedure Plot_Export_Ps_With_Size
     (Plot               : access Gtk.Extra.Plot.Gtk_Plot_Record'Class;
        Psfile             : in     String;
        Orientation        : in     Ps_Orientation;
        Epsflag            : in     Boolean;
        Units              : in     Ps_Units;
        Width              : in     Gint;
        Height             : in     Gint);

Create a new postscript file PsFile with the content of Plot.
Epsflag should be true if the generated file should be in  Encapsulated
Postscript format instead of simple Postscript.   The page has a custom
size.
procedure Plot_Canvas_Export_Ps
     (Canvas             : access Gtk_Plot_Canvas_Record'Class;
        File_Name          : in     String;
        Orientation        : in     Ps_Orientation;
        Epsflag            : in     Boolean;
        Page_Size          : in     Ps_Page_Size);

Create a new postscript file PsFile with the content of Layout.
Every plot on it is exported to the postscript file.   Epsflag should
be true if the generated file should be in  Encapsulated Postscript
format instead of simple Postscript.
procedure Plot_Canvas_Export_Ps_With_Size
     (Canvas             : access Gtk_Plot_Canvas_Record'Class;
        File_Name          : in     String;
        Orientation        : in     Ps_Orientation;
        Epsflag            : in     Boolean;
        Units              : in     Ps_Units;
        Width              : in     Gint;
        Height             : in     Gint);

Create a new postscript file PsFile with the content of Layout.
Every plot on it is exported to the postscript file.   Epsflag should
be true if the generated file should be in  Encapsulated Postscript
format instead of simple Postscript.   The page has a custom size.

File: gtkada_rm.info,  Node: Package_Gtk.Extra.Plot_Surface,  Next: Package_Gtk.Extra.PsFont,  Prev: Package_Gtk.Extra.Plot_Ps,  Up: Top

Package Gtk.Extra.Plot`_'Surface
********************************

A special kind of data set that stores three-dimensional data.

* Menu:

* Gtk.Extra.Plot_Surface Widget Hierarchy::
* Gtk.Extra.Plot_Surface Subprograms::


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

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

     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Plot_Data      (*note Package_Gtk.Extra.Plot_Data::)
              \___ Gtk_Plot_Surface (*note Package_Gtk.Extra.Plot_Surface::)


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

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

procedure Gtk_New
     (Widget             : out    Gtk_Plot_Surface;
        Func               :        Gtk.Extra.Plot.Plot3D_Function
                            := null);

Create a new surface.
If Func is null, you have to explicitely specify the set of points
found in the data set. Otherwise, the points will be generated
automatically from Func.
function Get_Type              return Gtk.Gtk_Type;

Return the internal value associated with this widget.
function Get_Grid_Visible
     (Data               : access Gtk_Plot_Surface_Record)
        return Boolean;

Return True if the grid is currently visible for this data set.
procedure Set_Grid_Visible
     (Data               : access Gtk_Plot_Surface_Record;
        Visible            :        Boolean);

Choose whether the grid should be visible
function Get_Mesh_Visible
     (Data               : access Gtk_Plot_Surface_Record)
        return Boolean;

Return True if the wireframe mesh should be drawn.
procedure Set_Mesh_Visible
     (Data               : access Gtk_Plot_Surface_Record;
        Visible            :        Boolean);

Indicate whether the wireframe mesh should be visible.
function Get_Nx
     (Data               : access Gtk_Plot_Surface_Record)
        return Gint;

procedure Set_Nx
     (Data               : access Gtk_Plot_Surface_Record;
        Nx                 :        Gint);

procedure Set_Points
     (Data               : access Gtk_Plot_Surface_Record;
        X                  :        Gdouble_Array_Access;
        Y                  :        Gdouble_Array_Access;
        Z                  :        Gdouble_Array_Access;
        Dx                 :        Gdouble_Array_Access;
        Dy                 :        Gdouble_Array_Access;
        Dz                 :        Gdouble_Array_Access);

Set all the values of the data set at once.
procedure Get_Points
     (Data               : access Gtk_Plot_Surface_Record;
        X                  : out    Points_Array;
        Y                  : out    Points_Array;
        Z                  : out    Points_Array;
        Dx                 : out    Points_Array;
        Dy                 : out    Points_Array;
        Dz                 : out    Points_Array);

Return the values contained in the data set.
function Get_X
     (Data               : access Gtk_Plot_Surface_Record)
        return Points_Array;

function Get_Z
     (Data               : access Gtk_Plot_Surface_Record)
        return Points_Array;

Return the values contained in the data set.
function Get_Xstep
     (Data               : access Gtk_Plot_Surface_Record)
        return Gdouble;

procedure Set_Xstep
     (Data               : access Gtk_Plot_Surface_Record;
        Step               :        Gdouble);

procedure Set_Color
     (Data               : access Gtk_Plot_Surface_Record;
        Color              :        Gdk.Color.Gdk_Color);

Set the color to use for the surface
procedure Set_Grid_Background
     (Data               : access Gtk_Plot_Surface_Record;
        Background         :        Gdk.Color.Gdk_Color);

Set the background color to use for the grid
procedure Set_Shadow
     (Data               : access Gtk_Plot_Surface_Record;
        Color              :        Gdk.Color.Gdk_Color);

Set the color to use for the shadows.
procedure Set_Grid_Foreground
     (Data               : access Gtk_Plot_Surface_Record;
        Foreground         :        Gdk.Color.Gdk_Color);

Set the foreground color to use for the grid
Lightning model
---------------

procedure Set_Ambient
     (Data               : access Gtk_Plot_Surface_Record;
        Ambient            :        Gdouble);

Set the ambient
procedure Set_Light
     (Data               : access Gtk_Plot_Surface_Record;
        X, Y, Z            :        Gdouble);

Set the orientation of the light vector

File: gtkada_rm.info,  Node: Package_Gtk.Extra.PsFont,  Next: Package_Gtk.Extra.Sheet,  Prev: Package_Gtk.Extra.Plot_Surface,  Up: Top

Package Gtk.Extra.PsFont
************************

This package does not provide any new widget.   Rather, it gives a set
of subprogram for postscript font handling,  and is used by most of the
Gtk.Extra.* packages.

   The following is the name of the 35 default Adobe fonts:
   * "Times-Roman",

   * "Times-Italic",

   * "Times-Bold",

   * "Times-BoldItalic",

   * "AvantGarde-Book",

   * "AvantGarde-BookOblique",

   * "AvantGarde-Demi",

   * "AvantGarde-DemiOblique",

   * "Bookman-Light",

   * "Bookman-LightItalic",

   * "Bookman-Demi",

   * "Bookman-DemiItalic",

   * "Courier",

   * "Courier-Oblique",

   * "Courier-Bold",

   * "Courier-BoldOblique",

   * "Helvetica",

   * "Helvetica-Oblique",

   * "Helvetica-Bold",

   * "Helvetica-BoldOblique",

   * "Helvetica-Narrow",

   * "Helvetica-Narrow-Oblique",

   * "Helvetica-Narrow-Bold",

   * "Helvetica-Narrow-BoldOblique",

   * "NewCenturySchoolbook-Roman",

   * "NewCenturySchoolbook-Italic",

   * "NewCenturySchoolbook-Bold",

   * "NewCenturySchoolbook-BoldItalic",

   * "Palatino-Roman",

   * "Palatino-Italic",

   * "Palatino-Bold",

   * "Palatino-BoldItalic",

   * "Symbol",

   * "ZapfChancery-MediumItalic",

   * "ZapfDingbats",


* Menu:

* Gtk.Extra.PsFont Types::
* Gtk.Extra.PsFont Subprograms::


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

Types
=====

type Gtk_PsFont is new Gdk.C_Proxy;

A postscript font.

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

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

function Getfont
     (Name               : in     String)
        return Gtk_PsFont;

Return the font structure associated with the font Name.
function Get_Gdkfont
     (Name               : in     String;
        Height             : in     Gint)
        return Gdk.Font.Gdk_Font;

Return the Gdk_Font that matches the postscript font Name.
Null_Font is returned if the corresponding font is not found  on your
system.
function Get_Psfontname
     (Name               : in     String)
        return String;

Return the real postscript name of the font.
In most cases this is the same as Name, except for a few cases.
procedure Add
     (Fontname           : in     String;
        Psname             : in     String;
        Family             : in     String;
        Xstring            : in     Gtkada.Types.Chars_Ptr_Array;
        Italic             : in     Boolean;
        Bold               : in     Boolean);

Add a new font to the list of recognized fonts.
The items in Xstring should be the standard X11 names for the fonts
that match that postscript font (and are used to convert from a
Gtk_PsFont to a Gdk_Font. This should be a Null terminated array.
function Find_By_Family
     (Name               : in     String;
        Italic             : in     Boolean;
        Bold               : in     Boolean)
        return Gtk_PsFont;

Return the first postscript font whose family is Name and whose
attributes match Italic and Bold.
function Get_Psname
     (Font               :        Gtk_PsFont)
        return String;

Return the name of the font.
This name can be give to Get_GdkFont above to get a font that can be
used anywhere in GtkAda.
function Init                  return Gint;

Initialize the internal list for Get_Families.
This function needs to be called before any call to Get_Families can
succeed. This list is reference counted, thus you need to call Unref
as many times as you called Init to free the memory correctly.   This
function returns 0 if it did not do anything (because the list was
already initialized), or 1 if it had to allocate some memory.
procedure Unref;

Free the memory used by the internal lists for Get_Families.
This procedure does not need to be call if you don't call Get_Families.

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

Package Gtk.Extra.Sheet
***********************

A Gtk_Sheet is a table like the one you can find in most spreadsheets.
Each cell can contain some text or any kind of widgets.

* Menu:

* Gtk.Extra.Sheet Widget Hierarchy::
* Gtk.Extra.Sheet Signals::
* Gtk.Extra.Sheet Types::
* Gtk.Extra.Sheet Subprograms::


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

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

     Gtk_Object                    (*note Package_Gtk.Object::)
        \___ Gtk_Widget            (*note Package_Gtk.Widget::)
           \___ Gtk_Container      (*note Package_Gtk.Container::)
              \___ Gtk_Sheet       (*note Package_Gtk.Extra.Sheet::)


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

Signals
=======

   * "activate"

     function Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Column : Gint)
     return Boolean;
     Emitted when the user wants to activate a specific cell. The
     callback should return True if the cell can be activated, False
     otherwise. See the subprogram Activate_Cell.

   * "changed"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Column : Gint);
     Emitted when the content of the cell is modified (either the text
     itself, or its properties, alignment,...)  A value of -1 for Row
     or Column means the row title, the column title, or their
     intersection.

   * "clear_cell"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Column : Gint);
     Emitted when the content of the cell has been deleted (the text is
     now the empty string).

   * "clip_range"

     procedure Handler (Sheet      : access Gtk_Sheet_Record'Class;
     Clip_Range : Gtk_Sheet_Range);
     Emitted when the clip area is set to a new value.

   * "deactivate"

     function Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Column : Gint)
     return Boolean;
     Emitted when the user wants to deactivate a specific cell. The
     callback should return True if the cell can be deactivated, False
     otherwise. See the subprogram Deactivate_Cell.

   * "move_range"

     procedure Handler (Sheet     : access Gtk_Sheet_Record'Class;
     Old_Range : Gtk_Sheet_Range;
     New_Range : Gtk_Sheet_Range);
     Emitted when the current range of selected cell is moved (ie the
     top-left cell is changed, but the size is not modified).

   * "new_column_width"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Column : Gint;
     Width  : Guint);
     Emitted whenever the width of the column is changed, either by the
     user or automatically if the cells should automatically resize
     themselves depending on their contents).

   * "new_row_height"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Height : Guint);
     Emitted whenever the height of the row is changed.

   * "resize_range"

     procedure Handler (Sheet     : access Gtk_Sheet_Record'Class;
     Old_Range : Gtk_Sheet_Range;
     New_Range : Gtk_Sheet_Range);
     Emitted when the current range of selected cell is resized (ie new
     cells are added to it or removed from it).

   * "select_column"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Column : Gint);
     Emitted when a new column is selected.

   * "select_range"

     procedure Handler (Sheet     : access Gtk_Sheet_Record'Class;
     The_Range : Gtk_Sheet_Range);
     Emitted when a new range of cells is selected.

   * "select_row"

     procedure Handler (Sheet : access Gtk_Sheet_Record'Class;
     Row   : Gint);
     Emitted when a new row is selected.

   * "set_cell"

     procedure Handler (Sheet  : access Gtk_Sheet_Record'Class;
     Row    : Gint;
     Column : Gint);
     Emitted from Hide_Active_Cell, when the cell is non-empty. ???

   * "set_scroll_adjustments"

     procedure Handler (Sheet : access Gtk_Sheet_Record'Class;
     Hadj  : Gtk_Adjustement;
     Vadj  : Gtk_Adjustment);
     Emitted when the adjustments used to indicate which area of the
     sheet is visible are set or changed. This is not called when their
     value is changed, only when a new one is set.

   * "traverse"

     function Handler (Sheet      : access Gtk_Sheet_Record'Class;
     Row        : Gint;
     Column     : Gint;
     New_Row    : Gint_Access;
     New_Column : Gint_Access)
     return Boolean;
     Emitted when the user wants to make a new cell active. The
     coordinates of the currently active cell are passed in (Row,
     Column), the coordinates of the cell that the user would like to
     select are passed in (New_Row, New_Column). The callback can
     modify the new values, and should return True if the new
     coordinates are accepted, False if the selection should be refused.



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

Types
=====

type Gtk_Sheet_Border is new Integer;

Mask that indicates which borders should be visible in a cell.
type Gtk_Sheet_Child is new Gdk.C_Proxy;

A widget insert in the sheet.   This structure includes both a widget
pointer and the position in the  table in which it is put.
type Sheet_State is
     (Sheet_Normal,
          Sheet_Row_Selected,
          Sheet_Column_Selected,
          Sheet_Range_Selected);

The state of the selection.
