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

INFO-DIR-SECTION User Interface Toolkit
START-INFO-DIR-ENTRY
* GtkAda_Rm: (gtkada_rm).           Ada95 graphical tookit based on GTK+ (Reference Manual)
END-INFO-DIR-ENTRY


File: gtkada_rm.info,  Node: Gdk.Color Subprograms,  Next: Gdk.Color Example,  Prev: Gdk.Color Types,  Up: Package_Gdk.Color

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

function Gdk_Color_Type        return Glib.GType;


Return the internal gtk+ types associated with a color
function Gdk_Colormap_Type     return Glib.GType;


Return the internal gtk+ types associated with a colormap
Setting/Getting the fields of Gdk_Color
---------------------------------------

procedure Set_Rgb
       (Color              : out    Gdk_Color;
        Red, Green, Blue   :        Guint16);

Modify the fields of the color.
You then have to allocate the color with one of the Alloc* functions
above.
procedure Set_Pixel
       (Color              : in out Gdk_Color;
        Pixel              :        Guint32);

This function should almost never be used. Instead, use Alloc_Color.
function Red
       (Color              :        Gdk_Color)
        return Guint16;

Return the Red field of Color.
function Green
       (Color              :        Gdk_Color)
        return Guint16;

Return the Green field of Color.
function Blue
       (Color              :        Gdk_Color)
        return Guint16;

Return the Blue field of Color.
function Pixel
       (Color              :        Gdk_Color)
        return Guint32;

Return the Pixel field of Color.
Creating and Destroying colors
------------------------------

procedure Gdk_New
       (Colormap           : out    Gdk_Colormap;
        Visual             :        Gdk.Visual.Gdk_Visual;
        Private_Cmap       :        Boolean);

Create a new colormap for the visual.
If Private_Cmap is true, then the  colormap won't be modifiable outside
this scope. This might result in  some strange colors on the display...
procedure Ref
       (Colormap           :        Gdk_Colormap);

Increment the ref-count for the color.
procedure Unref
       (Colormap           :        Gdk_Colormap);

Unref is the only way to destroy a colormap once you no longer need it.
Note that because gtk+ uses reference counts, the colormap will not  be
actually destroyed while at least one object is using it.
procedure Change
       (Colormap           :        Gdk_Colormap;
        Ncolors            :        Gint);

Change the first Ncolors defined in Colormap.
procedure Alloc_Colors
       (Colormap           :        Gdk_Colormap;
        Colors             : in out Gdk_Color_Array;
        Writeable          :        Boolean := False;
        Best_Match         :        Boolean := True;
        Success            : out    Boolean_Array;
        Result             : out    Gint);

Allocate a set of colors.
The parameters are the same as for Alloc_Color  Result is the number of
colors not successfully allocated.

   The size of the Boolean_Array is equal to the length of the
Colors_Array. Usage of an array of a different size will  probably lead
to a Constraint_Error.
procedure Alloc_Color
       (Colormap           :        Gdk_Colormap;
        Color              : in out Gdk_Color;
        Writeable          :        Boolean := False;
        Best_Match         :        Boolean := True;
        Success            : out    Boolean);

Allocate a new color.
The fields RGB should have been set before calling this function.   If
Writeable is True, the color will be allocated read/write, that can  be
changed at any time. Not all visuals support this. On modern systems
this usage has become less useful than before, since redrawing the
screen with a new color is about as fast.   If Best_Match is True, and
the exact color can not be allocated, GtkAda  will find the closest
possible match, and modify the fields Red, Green  and Blue of Color.
Note that the allocation has more chances to succeed if Writeable is
False and Best_Match is True.   When you no longer use a color, you
should call Free.
procedure Free_Colors
       (Colormap           :        Gdk_Colormap;
        Colors             :        Gdk_Color_Array);

Free Colors, assuming they are allocated in Colormap.
procedure Get_Visual
       (Colormap           :        Gdk_Colormap;
        Visual             : out    Gdk.Visual.Gdk_Visual);

Get the visual associated with a colormap.
The main information you can get from there is the depth of the display.
procedure Copy
       (Source             :        Gdk_Color;
        Destination        : out    Gdk_Color);

Copy the Source color to Destination.
function Parse
       (Spec               :        String)
        return Gdk_Color;

Parse the string Spec, and get its Red/Green/Blue components.
The color is not allocated, and you need to call Alloc_Color.   If the
string could not be parsed to an existing color, Wrong_Color is  raised.
The string can be one of :

   * "RGB:FF/FF/FF" where the "FF" substrings are respectively the value
       of the red, green and blue components. Some other prefixes than
     RGB    are defined in the X11 definition, please see some X11
     documentation    (or the man page XParseColor on unix systems).

   * "color_name" which can be any color name defined in the file
     rgb.txt    of the user's system. You should always check that
     Wrong_Color was not    raised, in case the color was not known on
     the user's system. This    string is case insensitive. Color names
     are not supported on Windows    systems.

function Equal
       (Colora, Colorb     :        Gdk_Color)
        return Boolean;

True if the Red, Green and Blue components of both colors are equal.

File: gtkada_rm.info,  Node: Gdk.Color Example,  Prev: Gdk.Color Subprograms,  Up: Package_Gdk.Color

Example
=======

      --  Here is an example how you can allocate a new color, when you know
      --  its red/green/blue components: Note that we allocate white in fact
      --  since the maximal value for color components is 65535.
         Color   : Gdk_Color;
         Success : Boolean;
         Set_Rbg (Color, 65535, 65535, 65535);
         Alloc_Color (Colormap   => Gtk.Widget.Get_Default_Colormap,
                      Color      => Color,
                      Writeable  => False,
                      Best_Match => True,
                      Success    => Success);
         if not Success then
             ...;  --  allocation failed
         end if;


File: gtkada_rm.info,  Node: Package_Gdk.Cursor,  Next: Package_Gdk.Drawable,  Prev: Package_Gdk.Color,  Up: Top

Package Gdk.Cursor
******************

This package provides the capability to create predefined mouse cursors
as well as user defined ones.

* Menu:

* Gdk.Cursor Types::
* Gdk.Cursor Subprograms::


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

Types
=====

type Gdk_Cursor is new Gdk.C_Proxy;


type Gdk_Cursor_Type is
         (X_Cursor,
          Arrow,
          Based_Arrow_Down,
          Based_Arrow_Up,
          Boat,
          Bogosity,
          Bottom_Left_Corner,
          Bottom_Right_Corner,
          Bottom_Side,
          Bottom_Tee,
          Box_Spiral,
          Center_Ptr,
          Circle,
          Clock,
          Coffee_Mug,
          Cross,
          Cross_Reverse,
          Crosshair,
          Diamond_Cross,
          Dot,
          Dotbox,
          Double_Arrow,
          Draft_Large,
          Draft_Small,
          Draped_Box,
          Exchange,
          Fleur,
          Gobbler,
          Gumby,
          Hand1,
          Hand2,
          Heart,
          Icon,
          Iron_Cross,
          Left_Ptr,
          Left_Side,
          Left_Tee,
          Leftbutton,
          Ll_Angle,
          Lr_Angle,
          Man,
          Middlebutton,
          Mouse,
          Pencil,
          Pirate,
          Plus,
          Question_Arrow,
          Right_Ptr,
          Right_Side,
          Right_Tee,
          Rightbutton,
          Rtl_Logo,
          Sailboat,
          Sb_Down_Arrow,
          Sb_H_Double_Arrow,
          Sb_Left_Arrow,
          Sb_Right_Arrow,
          Sb_Up_Arrow,
          Sb_V_Double_Arrow,
          Shuttle,
          Sizing,
          Spider,
          Spraycan,
          Star,
          Target,
          Tcross,
          Top_Left_Arrow,
          Top_Left_Corner,
          Top_Right_Corner,
          Top_Side,
          Top_Tee,
          Trek,
          Ul_Angle,
          Umbrella,
          Ur_Angle,
          Watch,
          Xterm);


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

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

procedure Gdk_New
       (Widget             : out    Gdk_Cursor;
        Cursor_Type        :        Gdk_Cursor_Type);

Create a new standard cursor.
procedure Gdk_New
       (Widget             : out    Gdk_Cursor;
        Source             :        Gdk.Gdk_Pixmap;
        Mask               :        Gdk.Gdk_Pixmap;
        Fg                 :        Gdk.Color.Gdk_Color;
        Bg                 :        Gdk.Color.Gdk_Color;
        X                  :        Glib.Gint;
        Y                  :        Glib.Gint);

Create a new cursor from a given pixmap and mask.
Both the pixmap and mask must have a depth of 1 (i.e. each pixel has
only 2 values - on or off). The standard cursor size is 16 by 16 pixels.
   * Source is the pixmap specifying the cursor.

   * Mask is the pixmap specifying the mask, which must be the same size
      as source.

   * Fg is the foreground color, used for the bits in the source which
     are   enabled. The color does not have to be allocated first.

   * Bg is the background color, used for the bits in the source which
     are   disabled. The color does not have to be allocated first.

   * X is the horizontal offset of the 'hotspot' of the cursor.

   * Y is the vertical offset of the 'hotspot' of the cursor.

procedure Destroy
       (Cursor             :        Gdk_Cursor);

Destroy a cursor, freeing any resources allocated for it.
Deprecated, use Unref instead.
procedure Ref
       (Cursor             :        Gdk_Cursor);

Increment the reference counting for the cursor.
procedure Unref
       (Cursor             :        Gdk_Cursor);

Decrement the reference counting for the cursor.
When this reaches 0, the cursor is destroyed.

File: gtkada_rm.info,  Node: Package_Gdk.Drawable,  Next: Package_Gdk.Event,  Prev: Package_Gdk.Cursor,  Up: Top

Package Gdk.Drawable
********************

This package provides support for drawing points, lines, arcs and text
onto  what are called 'drawables'. Drawables, as the name suggests, are
things  which support drawing onto them, and are either Gdk_Window or
Gdk_Pixmap objects.

   Many of the drawing operations take a Gdk_GC argument, which
represents a  graphics context. This Gdk_GC contains a number of
drawing attributes such  as foreground color, background color and line
width, and is used to  reduce the number of arguments needed for each
drawing operation.   *note Package_Gdk.GC:: for more information.

* Menu:

* Gdk.Drawable Types::
* Gdk.Drawable Subprograms::
* Gdk.Drawable Example::


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

Types
=====

subtype Gdk_Drawable is Gdk.Gdk_Drawable;


A screen area that can be drawn upon.

File: gtkada_rm.info,  Node: Gdk.Drawable Subprograms,  Next: Gdk.Drawable Example,  Prev: Gdk.Drawable Types,  Up: Package_Gdk.Drawable

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

function Get_Type              return Glib.GType;


Return the internal value associated with a Gdk_Drawable.
procedure Get_Size
       (Drawable           :        Gdk_Drawable;
        Width              : out    Gint;
        Height             : out    Gint);

Return the width and height of a given drawable.
procedure Set_Colormap
       (Drawable           :        Gdk_Drawable;
        Colormap           :        Gdk.Gdk_Colormap);

function Get_Colormap
       (Drawable           :        Gdk_Drawable)
        return Gdk.Gdk_Colormap;

function Get_Visual
       (Drawable           :        Gdk_Drawable)
        return Gdk.Gdk_Visual;

function Get_Depth
       (Drawable           :        Gdk_Drawable)
        return Gint;

procedure Ref
       (Drawable           :        Gdk_Drawable);

procedure Unref
       (Drawable           :        Gdk_Drawable);

procedure Draw_Point
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        X                  :        Gint;
        Y                  :        Gint);

Draw a point, using the foreground color and other attributes of the Gc.
procedure Draw_Line
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        X1                 :        Gint;
        Y1                 :        Gint;
        X2                 :        Gint;
        Y2                 :        Gint);

Draw a line, using the foreground color and other attributes of the Gc.
(X1, Y1) is coordinate of the start point.   (X2, Y2) is coordinate of
the end point.
procedure Draw_Rectangle
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Filled             :        Boolean := False;
        X                  :        Gint;
        Y                  :        Gint;
        Width              :        Gint;
        Height             :        Gint);

Draw a rectangular outline or filled rectangle.
Note that a rectangle drawn filled is 1 pixel smaller in both dimensions
than a rectangle outlined. Calling  Draw_Rectangle (Window, Gc, True,
0, 0, 20, 20) results in a filled  rectangle 20 pixels wide and 20
pixels high. Calling  Draw_Rectangle (Window, Gc, False, 0, 0, 20, 20)
results in an outlined  rectangle with corners at (0, 0), (0, 20), (20,
20), and (20, 0), which  makes it 21 pixels wide and 21 pixels high.

   (X, Y) represents the coordinate of the top-left edge of the
rectangle.
procedure Draw_Arc
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Filled             :        Boolean := False;
        X                  :        Gint;
        Y                  :        Gint;
        Width              :        Gint;
        Height             :        Gint;
        Angle1             :        Gint;
        Angle2             :        Gint);

Draws an arc or a filled 'pie slice'.
The arc is defined by the bounding rectangle of the entire ellipse, and
the start and end angles of the part of the ellipse to be drawn.
Filled is True if the arc should be filled, producing a 'pie slice'.
(X, Y) represent the coordinate of the top-left edge of the bounding
rectangle.   Angle1 is the start angle of the arc, relative to the 3
o'clock  position, counter-clockwise, in 1/64ths of a degree.   Angle2
is the end angle of the arc, relative to angle1, in 1/64ths of a
degree.
procedure Draw_Polygon
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Filled             :        Boolean;
        Points             :        Gdk.Types.Gdk_Points_Array);

Draw an outlined or filled polygon.
Filled is True if the polygon should be filled. The polygon is closed
automatically, connecting the last point to the first point if
necessary.   Points is an array of Gdk_Point specifying the points
making up the  polygon.
procedure Draw_Text
       (Drawable           :        Gdk_Drawable;
        Font               :        Gdk.Gdk_Font;
        Gc                 :        Gdk.Gdk_GC;
        X                  :        Gint;
        Y                  :        Gint;
        Text               :        UTF8_String);

Draw a string in the given font or fontset.
X is the x coordinate of the left edge of the text.   Y is the y
coordinate of the baseline of the text.

   You should use Gtk.Widget.Create_Pango_Layout instead to handle
internationalization.
procedure Draw_Text
       (Drawable           :        Gdk_Drawable;
        Font               :        Gdk.Gdk_Font;
        Gc                 :        Gdk.Gdk_GC;
        X                  :        Gint;
        Y                  :        Gint;
        Wide_Text          :        Gdk.Types.Gdk_WString);

Draw a wide string in the given font of fontset.
If the font is a 1-byte font, the string is converted into 1-byte
characters (discarding the high bytes) before output.
procedure Draw_Drawable
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Src                :        Gdk_Drawable;
        Xsrc               :        Gint;
        Ysrc               :        Gint;
        Xdest              :        Gint;
        Ydest              :        Gint;
        Width              :        Gint := -1;
        Height             :        Gint := -1);

Draw a pixmap, or a part of a pixmap, onto another drawable.
Src is the source Gdk_Drawable to draw.   Xsrc is the left edge of the
source rectangle within Src.   Ysrc is the top of the source rectangle
within Src.   Xdest is the x coordinate of the destination within Src.
Ydest is the y coordinate of the destination within Src.   Width is
the width of the area to be copied, or -1 to make the area  extend to
the right edge of the source pixmap.   Height is the height of the area
to be copied, or -1 to make the area  extend to the bottom edge of the
source pixmap.
procedure Draw_Layout
       (Drawable           :        Gdk_Drawable;
        GC                 :        Gdk.Gdk_GC;
        X                  :        Gint;
        Y                  :        Gint;
        Layout             :        Pango.Layout.Pango_Layout);

Display the layout and its text in Drawable. This method should be
preferred over Draw_Text.
procedure Draw_Pixmap
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Src                :        Gdk_Drawable;
        Xsrc               :        Gint;
        Ysrc               :        Gint;
        Xdest              :        Gint;
        Ydest              :        Gint;
        Width              :        Gint := -1;
        Height             :        Gint := -1);

Deprecated, use Draw_Drawable instead.
procedure Draw_Image
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Image              :        Gdk.Gdk_Image;
        Xsrc               :        Gint;
        Ysrc               :        Gint;
        Xdest              :        Gint;
        Ydest              :        Gint;
        Width              :        Gint := -1;
        Height             :        Gint := -1);

Draw a Gdk_Image onto a Drawable.
The depth of the Gdk_Image must match the depth of the Gdk_Drawable.
Image is the Gdk_Image to draw.   Xsrc is the left edge of the source
rectangle within Image.   Ysrc is the top of the source rectangle
within Image.   Xdest is the x coordinate of the destination within
Drawable.   Ydest is the y coordinate of the destination within
Drawable.   Width is the width of the area to be copied, or -1 to make
the area  extend to the right edge of image.   Height is the height of
the area to be copied, or -1 to make the area  extend to the bottom
edge of image.
procedure Draw_Points
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Points             :        Gdk.Types.Gdk_Points_Array);

Draw a number of points.
Use the foreground color and other attributes of the Gc.
procedure Draw_Segments
       (Drawable           : in     Gdk_Drawable;
        Gc                 : in     Gdk.Gdk_GC;
        Segs               : in     Gdk.Types.Gdk_Segments_Array);

Draw a number of unconnected lines.
procedure Draw_Lines
       (Drawable           :        Gdk_Drawable;
        Gc                 :        Gdk.Gdk_GC;
        Points             :        Gdk.Types.Gdk_Points_Array);

Draw a series of lines connecting the given points.
The way in which joins between lines are drawn is determined by the
Cap_Style value in the Gdk_GC. This can be set with
Gdk.Gc.Set_Line_Attributes.
function Get_Image
       (Drawable           :        Gdk_Drawable;
        X                  :        Gint;
        Y                  :        Gint;
        Width              :        Gint;
        Height             :        Gint)
        return Gdk_Image;

function Get_Clip_Region
       (Drawable           :        Gdk_Drawable)
        return Gdk.Gdk_Region;

function Get_Visible_Region
       (Drawable           :        Gdk_Drawable)
        return Gdk.Gdk_Region;


File: gtkada_rm.info,  Node: Gdk.Drawable Example,  Prev: Gdk.Drawable Subprograms,  Up: Package_Gdk.Drawable

Example
=======


      with Glib;
      with Gdk.Window;
      with Gdk.Drawable;
      with Gdk.GC;
      with Gdk.Font;
      with Gtk.Drawing_Area;
     
      procedure Draw (Drawing : in out Gtk.Drawing_Area.Gtk_Drawing_Area) is
         Gdkw : Gdk.Window.Gdk_Window;
         GC   : Gdk.GC.Gdk_GC;
         Font : Gdk.Font.Gdk_Font;
         use type Glib.Gint;
     
      begin
         -- Get the Gdk window
     
         Gdkw := Gtk.Drawing_Area.Get_Window (Drawing);
     
         -- Clear the window
     
         Gdk.Window.Clear (Gdkw);
     
         -- Create a graphic context associated with this window
     
         Gdk.GC.Gdk_New (GC, Gdkw);
     
         -- Draw a line in this window
     
         Gdk.Drawable.Draw_Line
           (Drawable => Gdkw,
            GC => GC,
            X1 =>   0, Y1 =>   0,
            X2 => 100, Y2 => 100);
     
         -- Draw an arc
     
         Gdk.Drawable.Draw_Arc
           (Drawable => Gdkw,
            Gc       => GC,
            Filled   => True,
            X        => 100,
            Y        => 100,
            Width    => 200,
            Height   => 100,
            Angle1   => 0 * 64,
            Angle2   => 270 * 64);
     
         -- Ask for a given font
     
         Gdk.Font.Load (Font,
                        "-adobe-courier-medium-i-*-*-15-*-*-*-*-*-*-*");
         Gdk.Drawable.Draw_Text
           (Drawable    => Gdkw,
            Font        => Font,
            Gc          => GC,
            X           => 50,
            Y           => 50,
            Text        => "Hello World");
         Gdk.GC.Destroy (GC);
      end Draw;


File: gtkada_rm.info,  Node: Package_Gdk.Event,  Next: Package_Gdk.Font,  Prev: Package_Gdk.Drawable,  Up: Top

Package Gdk.Event
*****************

This package provides functions dealing with events from the window
system.   In GtkAda applications, the events are handled automatically
in  Gtk.Main.Do_Event, and passed on to the appropriate widgets, so
these  functions are rarely needed.

   !! Warning !! This is one of the only package that requires manual
memory management in some cases. If you use the function Allocate,  you
have to use the function Free too...

* Menu:

* Gdk.Event Types::
* Gdk.Event Subprograms::


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

Types
=====

type Event_Handler_Func is access procedure


type Gdk_Crossing_Mode is
         (Crossing_Normal, Crossing_Grab, Crossing_Ungrab);

type Gdk_Device_Id is new Guint32;


This type is specific to GtkAda. In Gdk, guint32 is used instead.
type Gdk_Event is new Gdk.C_Proxy;


subtype Gdk_Event_Any is Gdk_Event;


Change from GtkAda1.2.3: There is no longer a tagged type  hierarchy,
only one type.   However there are now a few runtime tests for each of
the  function, to check whether a given field is available or not.
Fields common to all events: Window, Send_Event, Event_Type
subtype Gdk_Event_Button is Gdk_Event;


A button was pressed or released.   Relevant fields: Time, X, Y, Axes,
State, Button, Device_Id,  X_Root, Y_Root, Window.   Type:
Button_Press, Gdk_2Button_Press, Gdk_3Button_Press or  Button_Release.
subtype Gdk_Event_Client is Gdk_Event;


This is an event used to send arbitrary data from one X application  to
another. This event too is almost never used, and is not documented
here. Please consult an X11 documentation for more information.
Relevant fields: Message_Type, Data  Type: Client_Event
type Gdk_Event_Client_Data_Format is
         (Char_Array, Short_Array, Long_Array);

subtype Gdk_Event_Configure is Gdk_Event;


The window configuration has changed: either it was remapped,  resized,
moved, ...   Note that you usually don't have to redraw your window
when you  receive such an event, since it is followed by an
Gdk_Event_Expose.   Relevant fields: X, Y, Width, Height  Type:
Configure
subtype Gdk_Event_Crossing is Gdk_Event;


The mouse has been moved in or out of the window  Relevant fields:
SubWindow, Time, X, Y, X_Root, Y_Root, Mode,  Detail, Focus, State
Type: Enter_Notify, Leave_Notify
subtype Gdk_Event_DND is Gdk_Event;


???   Relevant fields: Context, Time, X_Root, Y_Root  Type: Drag_Enter,
Drag_Leave, Drag_Motion, Drag_Status, Drop_Start,  Drop_Finished
subtype Gdk_Event_Expose is Gdk_Event;


The window needs to be redrawn. For efficiency, gtk gives you the
smallest area that you need to redraw.   Relevant fields: Area, Region,
Count  Type: Expose
subtype Gdk_Event_Focus is Gdk_Event;


The focus has changed for a window.   Relevant fields: in  Type:
Focus_Change
subtype Gdk_Event_Key is Gdk_Event;


A keyboard key was pressed  Relevant fields: Time, State, Key_Val,
String, Hardware_Keycode, Group  Type: Key_Press, Key_Release
type Gdk_Event_Mask is mod 2 ** 32;


Note that you need to change the event mask of a widget if you want  to
be able to get some events. To change this mask, the widget  must first
be Unrealized.
subtype Gdk_Event_Motion is Gdk_Event;


The mouse has moved  Relevant fields: Time, X, Y, Axes, State, Is_Hint,
Device_Id,  X_Root, Y_Root  Type: Motion_Notify
subtype Gdk_Event_No_Expose is Gdk_Event;


Indicate that the source region was completely available when parts of
a drawable were copied.   This is also emitted when a gc whose
"exposures" attribute is set to  False in a call to Copy_Area or
Draw_Pixmap. See the documentation for  Gdk.GC.Set_Exposures.   No
Relevent fields except the common ones  Type: No_Expose
subtype Gdk_Event_Property is Gdk_Event;


Some property of the window was modified. GtkAda provides a higher
level interface, and you almost never need to use this event.
Relevent fields: Atom, Time, Property_State  Type: Property_Notify
subtype Gdk_Event_Proximity is Gdk_Event;


This event type will be used pretty rarely. It only is  important for
XInput aware programs that are drawing their own  cursor. This is only
used with non standard input devices, like  graphic tablets.   Relevant
fields: Time, Device_Id  Type: Proximity_In, Proximity_Out
subtype Gdk_Event_Scroll is Gdk_Event;


A button was pressed or released.   Relevant fields: Time, X, Y, State,
Direction, Device_Id, X_Root, Y_Root  Type: Scroll
subtype Gdk_Event_Selection is Gdk_Event;


This is how X11 implements a simple cut-and-paste mechanism. However,
GtkAda provides a higher level interface to the selection mechanism,
so this event will almost never be used.   Relevant fields: Selection,
Target, Property, Time, Requestor  Type: Selection_Clear,
Selection_Request, Selection_Notify
subtype Gdk_Event_Setting is Gdk_Event;


???   Relevant fields: Action, Name.   Type: ???
type Gdk_Event_Type is
         (Nothing,
             -- No event occurred.
     
          Delete,
             -- A window delete event was sent by the window manager. The specified
             -- window should be deleted.
     
          Destroy,
             -- A window has been destroyed.
     
          Expose,
             -- Part of a window has been uncovered.
     
          Motion_Notify,
          Button_Press,
             -- A mouse button was pressed.
     
          Gdk_2button_Press,
             -- Double-click
     
          Gdk_3button_Press,
             -- Triple-click
     
          Button_Release,
             -- A mouse button was released.
     
          Key_Press,
             -- A key was pressed.
     
          Key_Release,
             -- A key was released.
     
          Enter_Notify,
             -- A window was entered.
     
          Leave_Notify,
             -- A window was exited.
     
          Focus_Change,
             -- The focus window has changed. (The focus window gets keyboard events)

subtype Gdk_Event_Visibility is Gdk_Event;


The visibility state of the window (partially visibly, fully visible,
hidden). This event almost never need to be used, since other events
are generated at the same time, like expose_events  Relevant fields:
Visibility_State  type: Visibility_Notify
subtype Gdk_Event_Window_State is Gdk_Event;


???   Relevant fields: Changed_Mask, New_Window_State.   Type: Delete,
Destroy, Map, Unmap ???
type Gdk_Notify_Type is
         (Notify_Ancestor,
          Notify_Virtual,
          Notify_Inferior,
          Notify_Non_Linear,
          Notify_Non_Linear_Virtual,
          Notify_Unknown);

type Gdk_Property_State is
         (Property_New_Value, Property_Delete);

type Gdk_Scroll_Direction is
         (Scroll_Up,
          Scroll_Down,
          Scroll_Left,
          Scroll_Right);

type Gdk_Setting_Action is
         (Setting_Action_New,
          Setting_Action_Changed,
          Setting_Action_Deleted);

type Gdk_Visibility_State is
         (Visibility_Unobscured,
          Visibility_Partial,
          Visibility_Fully_Obscured);

type Gdk_Window_State is mod 2 ** 32;


State of a Window. Default is 0.
type Property_Gdk_Event_Mask is new Event_Mask_Properties.Property;



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

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

Access to fields of the event
-----------------------------

The following functions can be used to retrieve some specific fields
from an event. Some of these fields do not exist for all the types of
events (see the description of each event for a list of the relevant
fields).   Note also that you can not pass a null event to them. The
parameter must  be a correct event, or the result is undefined.

function Get_Event_Type
       (Event              :        Gdk_Event)
        return Gdk_Event_Type;

The type of the event.
function Get_Send_Event
       (Event              :        Gdk_Event)
        return Boolean;

Set to true if the event was generated by the application, False
if generated by the X server/Win32.
function Get_Window
       (Event              :        Gdk_Event)
        return Gdk.Gdk_Window;

The window the event occured on.
function Get_Time
       (Event              :        Gdk_Event)
        return Guint32;

Time when the event occured.
function Get_X
       (Event              :        Gdk_Event)
        return Gdouble;

Horizontal coordinate of the mouse when the event occured.
The coordinates are relative to the parent window.
function Get_Y
       (Event              :        Gdk_Event)
        return Gdouble;

Vertical coordinate of the mouse when the event occured.
The coordinates are relative to the parent window.
function Get_X_Root
       (Event              :        Gdk_Event)
        return Gdouble;

Horizontal coordinate of the mouse when the event occured.
Relative to the root window.
function Get_Y_Root
       (Event              :        Gdk_Event)
        return Gdouble;

Vertical coordinate of the mouse when the event occured.
Relative to the root window.
function Get_Button
       (Event              :        Gdk_Event)
        return Guint;

Number of the button that was pressed.
function Get_State
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Modifier_Type;

State of the mouse buttons and keyboard keys just prior to the event.
function Get_Subwindow
       (Event              :        Gdk_Event)
        return Gdk.Gdk_Window;

Child window for the event.
For an Enter_Notify_Event, this is set to the initial window for the
pointer; for an Leave_Notify_Event this is set to the window occupied
by the pointer in its last position.
function Get_Mode
       (Event              :        Gdk_Event)
        return Gdk_Crossing_Mode;

Return the mode of an Event.
Set to indicate whether the events are normal events, pseudo-motion
events when a grab activates or pseudo-motion events when a grab
deativates.
function Get_Detail
       (Event              :        Gdk_Event)
        return Gdk_Notify_Type;

Set to indicate the notify details.
Most applications can ignore events with a Notify Virtual or a
Notify_Non_Linear_Virtual detail.
function Get_Focus
       (Event              :        Gdk_Event)
        return Boolean;

Set to true if the window for the event is the focus window.
function Get_Width
       (Event              :        Gdk_Event)
        return Gint;

Get the width in a configure event.
function Get_Height
       (Event              :        Gdk_Event)
        return Gint;

Get the height in a configure event.
function Get_Direction
       (Event              :        Gdk_Event)
        return Gdk_Scroll_Direction;

Get the direction in a scroll event.
function Get_Device_Id
       (Event              :        Gdk_Event)
        return Gdk_Device_Id;

Set to a constant for now in the gtk+ source... Probably useless.
Since multiple input devices can be used at the same time, like a mouse
and a graphic tablet, this indicates which one generated the event.
function Get_Area
       (Event              :        Gdk_Event)
        return Rectangle.Gdk_Rectangle;

The minimal area on which the event applies.
For Expose_Events, this is the minimal area to redraw.
function Get_Region
       (Event              :        Gdk_Event)
        return Gdk.Region.Gdk_Region;

Return the region to which the event applies.
Do not free the returned value
function Get_Count
       (Event              :        Gdk_Event)
        return Gint;

Number of Expose_Events that are to follow this one.
Most applications can ignore the event if Count is not 0, which also
allows for optimizations.
function Get_In
       (Event              :        Gdk_Event)
        return Boolean;

True if the window has gained the focus, False otherwise.
function Get_Is_Hint
       (Event              :        Gdk_Event)
        return Boolean;

???
function Get_Key_Val
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Key_Type;

Code of the key that was pressed (and that generated the event).
function Get_Group
       (Event              :        Gdk_Event)
        return Guint8;

Group of the key that was pressed;
function Get_Hardware_Keycode
       (Event              :        Gdk_Event)
        return Guint16;

Hardware key code of the key that was pressed.
function Get_String
       (Event              :        Gdk_Event)
        return String;

Symbol of the key that was pressed, as a string.
function Get_Atom
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Atom;

Indicate which property has changed.
??? Atom should not be a Guint
function Get_Property_State
       (Event              :        Gdk_Event)
        return Guint;

??? The return type should be changed.
function Get_Visibility_State
       (Event              :        Gdk_Event)
        return Gdk_Visibility_State;

Return the new visibility state for the window.
function Get_Selection
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Atom;

What was selected in the window...
function Get_Target
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Atom;

???
function Get_Property
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Atom;

???
function Get_Requestor
       (Event              :        Gdk_Event)
        return Guint32;

???
function Get_Message_Type
       (Event              :        Gdk_Event)
        return Gdk.Types.Gdk_Atom;

???
function Get_Data
       (Event              :        Gdk_Event)
        return Gdk_Event_Client_Data;

???
Modifying the fields of an event
--------------------------------

procedure Set_Window
       (Event              :        Gdk_Event;
        Win                :        Gdk.Gdk_Window);

Set the Window field of an event.
procedure Set_X
       (Event              :        Gdk_Event;
        X                  :        Gdouble);

Set the X field of an event.
procedure Set_Y
       (Event              :        Gdk_Event;
        Y                  :        Gdouble);

Set the Y field of an event.
procedure Set_Xroot
       (Event              :        Gdk_Event;
        Xroot              :        Gdouble);

Set the Xroot field of an event.
procedure Set_Yroot
       (Event              :        Gdk_Event;
        Yroot              :        Gdouble);

Set the Yroot field of an event.
procedure Set_Width
       (Event              :        Gdk_Event;
        Width              :        Gint);

Set the Width field of an event.
procedure Set_Height
       (Event              :        Gdk_Event;
        Height             :        Gint);

Set the Height field of an event.
procedure Set_Button
       (Event              :        Gdk_Event;
        Button             :        Guint);

Set the Button field of an event.
procedure Set_Time
       (Event              :        Gdk_Event;
        Time               :        Guint32);

Set the time for the event.
If Time is 0, then it is set to the current time.
procedure Set_State
       (Event              :        Gdk_Event;
        State              :        Gdk.Types.Gdk_Modifier_Type);

Set the State field of an event.
procedure Set_Subwindow
       (Event              :        Gdk_Event;
        Window             :        Gdk.Gdk_Window);

Set the Subwindow field of an event.
procedure Set_Mode
       (Event              :        Gdk_Event;
        Mode               :        Gdk_Crossing_Mode);

Set the Mode field of an event.
procedure Set_Detail
       (Event              :        Gdk_Event;
        Detail             :        Gdk_Notify_Type);

Set the Detail field of an event.
procedure Set_Focus
       (Event              :        Gdk_Event;
        Has_Focus          :        Boolean);

Set the Focus field of an event.
procedure Set_Area
       (Event              :        Gdk_Event;
        Area               :        Rectangle.Gdk_Rectangle);

Set the Area field of an event.
procedure Set_In
       (Event              :        Gdk_Event;
        Focus_In           :        Boolean);

Set the In field of an event.
procedure Set_Is_Hint
       (Event              :        Gdk_Event;
        Is_Hint            :        Boolean);

Set the Is_Hint field of an event.
procedure Set_Key_Val
       (Event              :        Gdk_Event;
        Key                :        Gdk.Types.Gdk_Key_Type);

Set the Key_Val field of an event.
procedure Set_Group
       (Event              :        Gdk_Event;
        Group              :        Guint8);

Set the group field of a key event.
procedure Set_Hardware_Keycode
       (Event              :        Gdk_Event;
        Keycode            :        Guint16);

Set the hardware key code field of a key event.
procedure Set_Direction
       (Event              :        Gdk_Event;
        Direction          :        Gdk_Scroll_Direction);

Set the direction field of a scroll event.
procedure Set_Atom
       (Event              :        Gdk_Event;
        Atom               :        Gdk.Types.Gdk_Atom);

Set the Atom field of an event.
procedure Set_Property_State
       (Event              :        Gdk_Event;
        State              :        Guint);

Set the Property_State field of an event.
procedure Set_Visibility_State
       (Event              :        Gdk_Event;
        State              :        Gdk_Visibility_State);

Set the Visibility_State field of an event.
procedure Set_Selection
       (Event              :        Gdk_Event;
        Selection          :        Gdk.Types.Gdk_Atom);

Set the Selection field of an event.
procedure Set_Target
       (Event              :        Gdk_Event;
        Target             :        Gdk.Types.Gdk_Atom);

Set the Target field of an event.
procedure Set_Property
       (Event              :        Gdk_Event;
        Property           :        Gdk.Types.Gdk_Atom);

Set the Property field of an event.
procedure Set_Requestor
       (Event              :        Gdk_Event;
        Requestor          :        Guint32);

Set the Requestor field of an event.
procedure Set_Message_Type
       (Event              :        Gdk_Event;
        Typ                :        Gdk.Types.Gdk_Atom);

Set the Message_Type field of an event.
procedure Set_String
       (Event              :        Gdk_Event;
        Str                :        String);

Set the string associated with an event.
General functions
-----------------

function Get_Type              return GType;


Return the type corresponding to a Gdk_Event.
procedure Deep_Copy
       (From               :        Gdk_Event;
        To                 : out    Gdk_Event);

Deep copy for an event. The C structure is itself duplicated.
You need to deallocated it yourself with a call to Free below.
procedure Get_Graphics_Expose
       (Event              : out    Gdk_Event_Expose;
        Window             :        Gdk.Gdk_Window);

Waits for a GraphicsExpose or NoExpose event
If it gets a GraphicsExpose event, it returns a pointer to it,
otherwise it returns an event for which Is_Created is False.

   This function can be used to implement scrolling: you must call
Gdk.GC.Set_Exposures with True on the GC you are using for the
drawing, so that a events are generated for obscured areas and every
time a new part of the widget is drawn. However, there is a race
condition if multiple scrolls happen before you have finished
processing the first one. A workaround is to call Get_Graphics_Expose
after every scroll until it returns a null event.
function Events_Pending        return Boolean;


Is there any event pending on the queue ?
procedure Get
       (Event              : out    Gdk_Event);

Get the next event on the queue.
procedure Peek
       (Event              : out    Gdk_Event);

Look at the next event on the queue, but leave if there.
procedure Put
       (Event              :        Gdk_Event);

Add an event on the queue - Better to use Gtk.Signal.Emit_By_Name
procedure Set_Show_Events
       (Show_Events        :        Boolean := True);

For debug purposes, you can choose whether you want to see the events
GtkAda receives.
function Get_Show_Events       return Boolean;


Return the current state of Show_Events.
procedure Send_Client_Message_To_All
       (Event              :        Gdk_Event);

Low level routine to send an Event to every window.
function Send_Client_Message
       (Event              :        Gdk_Event;
        Xid                :        Guint32)
        return Boolean;

Low level routine to send an Event to a specified X window.
procedure Allocate
       (Event              : out    Gdk_Event;
        Event_Type         :        Gdk_Event_Type;
        Window             :        Gdk.Gdk_Window);

Create an event, whose fields are uninitialized.
You need to use the function Set_* above to modify them, before you can
send the event with Emit_By_Name.   !!Note!!: The event has to be
freed if you have called this function.   Use the function Free below.
procedure Free
       (Event              : in out Gdk_Event);

Free the memory (and C structure) associated with an event.
You need to call this function only if the event was created through
Allocate, not if it was created by GtkAda itself (or you would get  a
segmentation fault).
procedure Event_Handler_Set
       (Func               :        Event_Handler_Func;
        Data               :        System.Address);

Set up a new event handler.
This handler replaces the default GtkAda event handler, and thus should
make sure that all events are correctly handled.

   Note that managing the memory for Data is your responsability, and
Data is passed as is to Func.
function From_Address
       (C                  :        System.Address)
        return Gdk_Event;

Convert a C handler to the matching Event structure.
function To_Address
       (C                  :        Gdk_Event)
        return System.Address;

Convert an event to the underlying C handler.
function Is_Created
       (E                  :        Gdk_Event)
        return Boolean;

Return True if the underlying C event has been created.
GValue support
--------------

function Get_Event
       (Value              :        Glib.Values.GValue)
        return Gdk_Event;

Convert a value into a Gdk_Event.
Event Recording
---------------

procedure Set_Follow_Events
       (Follow_Events      :        Boolean := True);

Set whether windows should follow events that they normally don't
(such as motion events) for event recording purposes.   This function
is used in cunjonction with GtkAda.Macro
function Get_Follow_Events     return Boolean;


Return follow_events value.
See Set_Follow_Events for more details.

File: gtkada_rm.info,  Node: Package_Gdk.Font,  Next: Package_Gdk.GC,  Prev: Package_Gdk.Event,  Up: Top

Package Gdk.Font
****************

!!! Important note !!!: this package is now considered as deprecated in
GtkAda 2.x. You should use the types and subprograms in the Pango
hierarchy, which correctly support internationalization, right-to-left
writings, easy resizing of fonts, truetype fonts....

   For backward compatibility, a new subprogram From_Description has
been  added to this package, which gives access to the more advanced
font  handling.

   This is the base package for handling fonts.   GtkAda knows about
bitmap and vectorial fonts, and can draw both.   The list of fonts
available to you depends on what is installed on  your system.

   The name of the font is indicated in the standard X11 fashion,
namely:  (example extracted from the Xlib manual):

   -adobe-courier-bold-o-normal-10-100-75-75-m-60-iso8859-1  where:
   * adobe     : foundry

   * courier   : font family

   * bold      : weight (e.g. bold, medium)

   * o         : slant (e.g. roman, italic, oblique)

   * normal    : set width (e.g. normal, condensed, narrow, double)

   * 10        : pixels

   * 100       : points (in tenths of a point)

   * 75        : horizontal resolution in dpi

   * 75        : vertical resolution in dpi

   * m         : spacing (e.g. monospace or proportional)

   * 60        : average width (in tenths of a pixel)

   * iso8859-1 : character set

    Any of the fields can have a '*' instead, so that the system will
automatically find a font that matches the rest of the string, and won't
care about that specific field.

   An easy way to select a font is by using some external programs,
for instance xfontsel, xlsfont, gfontsel, or even the font selection
dialog example in the testgtk/ directory of the GtkAda distribution.

   But the easiest way to create a font is to use a
Pango_Font_Description.   See package Pango.Font for more details about
this structure.

   Some of the functions below should be used only for wide-character
strings.   This is needed for languages with more than 256 characters.

   Wide character values between 0 and 127 are always identical in
meaning to  the ASCII character codes.   An alternative to wide
characters is multi-byte characters, which extend  normal char strings
to cope with larger character sets. As the name  suggests, multi-byte
characters use a different number of bytes to store  different
character codes. For example codes 0-127 (i.e. the ASCII codes)  often
use just one byte of memory, while other codes may use 2, 3 or even  4
bytes. Multi-byte characters have the advantage that they can often be
used in an application with little change, since strings are still
represented as arrays of char values. However multi-byte strings are
much  easier to manipulate since the character are all of the same size.

   On Unix systems, the external utility 'xfd' can be used to display
all  the characters in a font.

* Menu:

* Gdk.Font Types::
* Gdk.Font Subprograms::


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

Types
=====

subtype Gdk_Font is Gdk.Gdk_Font;


A font used to draw text.   This can represent a bitmap font, a
scalable (vectorial) font, or  a fontset. A fontset is a list of
comma-separated fonts, that permits  GtkAda to obtain the fonts needed
for a variety of locales from a  single locale-independent base font
name. The single base font name  should name a family of fonts whose
members are encoded in the various  charsets needed by the locales of
interest.   The algorithm used to select the font is described in the
manual page  for XCreateFontSet(3X).
