[Contents] [Back] [Prev] [Up] [Next] [Forward]

# 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. see section Package Gdk.GC for more information.

- Gdk.Drawable Types
- Gdk.Drawable Subprograms
- Gdk.Drawable Example

## Types

    subtype Gdk_Drawable is Gdk.Gdk_Drawable;

| A screen area that can be drawn upon.

## 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;

## 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;

[Contents] [Back] [Prev] [Up] [Next] [Forward]