Fl_Draw Binding Map

Back to Index
Package name
Fl_Draw FLTK.Draw
Types
Fl_Line Line_Kind
  Cap_Kind
  Join_Kind
  Dash_Length
  Dash_Gap
  Dash_Gap_Array
  Text_Draw_Function
  Symbol_Draw_Function
  Area_Draw_Function
  Draw_Error
Functions and Procedures
int fl_add_symbol(const char *name, void(*drawit)(Fl_Color),
    int scalable);

procedure Add_Symbol
       (Text     : in String;
        Func     : in Symbol_Drawing_Function;
        Scalable : in Boolean);

void fl_arc(double x, double y, double r, double start, double end);

procedure Arc
       (X, Y, R, Start, Finish : in Long_Float);

void fl_arc(int x, int y, int w, int h, double a1, double a2);

procedure Arc
       (X, Y, W, H    : in Integer;
        Start, Finish : in Long_Float);

void fl_begin_complex_polygon();

procedure Begin_Complex_Polygon;

void fl_begin_line();

procedure Begin_Line;

void fl_begin_loop();

procedure Begin_Loop;

void fl_begin_points();

procedure Begin_Points;

void fl_begin_polygon();

procedure Begin_Polygon;

char fl_can_do_alpha_blending();

function Can_Do_Alpha_Blending
    return Boolean;

void fl_chord(int x, int y, int w, int h, double a1, double a2);

procedure Chord
       (X, Y, W, H     : in Integer;
        Angle1, Angle2 : in Long_Float);

void fl_circle(double x, double y, double r);

procedure Circle
       (X, Y, R : in Long_Float);

int fl_clip_box(int x, int y, int w, int h,
    int &X, int &Y, int &W, int &H);

function Clip_Box
       (X, Y, W, H     : in     Integer;
        BX, BY, BW, BH :    out Integer)
    return Boolean;

Fl_Region fl_clip_region();
Left unbound due to being OS-specific 
void fl_clip_region(Fl_Region r);
Left unbound due to being OS-specific 
Fl_Color fl_color();

function Get_Color
    return Color;

void fl_color(Fl_Color c);

procedure Set_Color
       (To : in Color);

void fl_color(int c);
Not applicable; original is deprecated. 
void fl_color(uchar r, uchar g, uchar b);

procedure Set_Color
       (R, G, B : in Color_Component);

void fl_cursor(Fl_Cursor);

procedure Set_Cursor
       (To : in Mouse_Cursor);

void fl_cursor(Fl_Cursor, Fl_Color fg, Fl_Color bg=FL_WHITE);

procedure Set_Cursor
       (To   : in Mouse_Cursor;
        Fore : in Color;
        Back : in Color := White_Color);

void fl_curve(double X0, double Y0, double X1, double Y1,
    double X2, double Y2, double X3, double Y3);

procedure Curve
       (X0, Y0 : in Long_Float;
        X1, Y1 : in Long_Float;
        X2, Y2 : in Long_Float;
        X3, Y3 : in Long_Float);

int fl_descent();

function Font_Descent
    return Integer;

void fl_draw(const char *str, int n, int x, int y);

void fl_draw(const char *str, int x, int y);

procedure Draw_Text
       (X, Y : in Integer;
        Text : in String);
with Pre => Text'Length > 0;

void fl_draw(const char *str, int x, int y, int w, int h,
    Fl_Align align, Fl_Image *img=0, int draw_symbols=1);

procedure Draw_Text
       (X, Y, W, H : in Integer;
        Text       : in String;
        Align      : in Alignment;
        Symbols    : in Boolean := True);

procedure Draw_Text
       (X, Y, W, H : in Integer;
        Text       : in String;
        Align      : in Alignment;
        Picture    : in FLTK.Images.Image'Class;
        Symbols    : in Boolean := True);

void fl_draw(const char *str, int x, int y, int w, int h,
    Fl_Align align, void (*callthis)(const char *, int, int, int),
    Fl_Image *img=0, int draw_symbols=1);

procedure Draw_Text
       (X, Y, W, H : in Integer;
        Text       : in String;
        Align      : in Alignment;
        Func       : in Text_Drawing_Function;
        Symbols    : in Boolean := True);

procedure Draw_Text
       (X, Y, W, H : in Integer;
        Text       : in String;
        Align      : in Alignment;
        Func       : in Text_Drawing_Function;
        Picture    : in FLTK.Images.Image'Class;
        Symbols    : in Boolean := True);

void fl_draw(int angle, const char *str, int n, int x, int y);

void fl_draw(int angle, const char *str, int x, int y);

procedure Draw_Text
       (X, Y  : in Integer;
        Text  : in String;
        Angle : in Integer);

void fl_draw_box(Fl_Boxtype, int x, int y, int w, int h, Fl_Color);

procedure Draw_Box
       (X, Y, W, H : in Integer;
        Kind       : in Box_Kind;
        Hue        : in Color);

void fl_draw_image(const uchar *buf, int X, int Y,
    int W, int H, int D=3, int L=0);

procedure Draw_Image
       (X, Y, W, H      : in Integer;
        Data            : in Color_Component_Array;
        Depth           : in Positive := 3;
        Line_Data       : in Natural := 0;
        Flip_Horizontal : in Boolean := False;
        Flip_Vertical   : in Boolean := False);

void fl_draw_image(Fl_Draw_Image_Cb cb, void *data,
    int X, int Y, int W, int H, int D=3);

procedure Draw_Image
       (X, Y, W, H : in Integer;
        Callback   : in Image_Draw_Function;
        Depth      : in Positive := 3);

void fl_draw_image_mono(const uchar *buf, int X, int Y,
    int W, int H, int D=1, int L=0);

procedure Draw_Image_Mono
       (X, Y, W, H      : in Integer;
        Data            : in Color_Component_Array;
        Depth           : in Positive := 1;
        Line_Data       : in Natural := 0;
        Flip_Horizontal : Boolean := False;
        Flip_Vertical   : Boolean := False);

void fl_draw_image_mono(Fl_Draw_Image_Cb cb, void *data,
    int X, int Y, int W, int H, int D=1);

procedure Draw_Image_Mono
       (X, Y, W, H : in Integer;
        Callback   : in Image_Draw_Function;
        Depth      : in Positive := 1);

int fl_draw_pixmap(char * const *data, int x, int y,
    Fl_Color=FL_GRAY);



int fl_draw_pixmap(const char * const *cdata, int x, int y,
    Fl_Color=FL_GRAY);



int fl_draw_symbol(const char *label, int x, int y,
    int w, int h, Fl_Color);

procedure Draw_Symbol
       (X, Y, W, H : in Integer;
        Name       : in String;
        Hue        : in Color);

void fl_end_complex_polygon();

procedure End_Complex_Polygon;

void fl_end_line();

procedure End_Line;

void fl_end_loop();

procedure End_Loop;

void fl_end_points();

procedure End_Points;

void fl_end_polygon();

procedure End_Polygon;

const char * fl_expand_text(const char *from, char *buf, int maxbuf,
    double maxw, int &n, double &width, int wrap, int draw_symbols=0);



Fl_Font fl_font();

function Get_Font
    return Font_Kind;

void fl_font(Fl_Font face, Fl_Fontsize fsize);

procedure Set_Font
       (Kind : in Font_Kind;
        Size : in Font_Size);

void fl_frame(const char *s, int x, int y, int w, int h);

void fl_frame2(const char *s, int x, int y, int w, int h);

procedure Frame
       (X, Y, W, H               : in Integer;
        Top, Left, Bottom, Right : in Greyscale);

void fl_gap();

procedure Gap;

int fl_height();

function Font_Line_Spacing
    return Integer;

int fl_height(int font, int size);

function Font_Height
       (Kind : in Font_Kind;
        Size : in Font_Size)
    return Natural;

const char * fl_latin1_to_local(const char *t, int n=-1);

function Latin1_To_Local
       (From : in String)
    return String;

void fl_line(int x, int y, int x1, int y1);

procedure Line
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer);

void fl_line(int x, int y, int x1, int y1, int x2, int y2);

procedure Line
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer;
        X2, Y2 : in Integer);

void fl_line_style(int style, int width=0, char *dashes=0);

procedure Set_Line_Style
       (Line   : in Line_Kind      := Solid_Line;
        Cap    : in Cap_Kind       := Default_Cap;
        Join   : in Join_Kind      := Default_Join;
        Width  : in Natural        := 0;
        Dashes : in Dash_Gap_Array := Empty_Dashes);

const char * fl_local_to_latin1(const char *t, int n=-1);

function Local_To_Latin1
       (From : in String)
    return String;

const char * fl_local_to_mac_roman(const char *t, int n=-1);

function Local_To_Mac_Roman
       (From : in String)
    return String;

void fl_loop(int x, int y, int x1, int y1, int x2, int y2);

procedure Outline
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer;
        X2, Y2 : in Integer);

void fl_loop(int x, int y, int x1, int y1,
    int x2, int y2, int x3, int y3);

procedure Outline
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer;
        X2, Y2 : in Integer;
        X3, Y3 : in Integer);

const char * fl_mac_roman_to_local(const char *t, int n=-1);

function Mac_Roman_To_Local
       (From : in String)
    return String;

void fl_measure(const char *str, int &x, int &y, int draw_symbols=1);

procedure Measure
       (Text    : in     String;
        W, H    :    out Natural;
        Symbols : in     Boolean := True;
        Wrap    : in     Natural := 0);

int fl_measure_pixmap(char *const *data, int &w, int &h);



int fl_measure_pixmap(const char *const *cdata, int &w, int &h);



void fl_mult_matrix(double a, double b, double c, double d,
    double x, double y);

procedure Mult_Matrix
       (A, B, C, D, X, Y : in Long_Float);

int fl_not_clipped(int x, int y, int w, int h);

function Clip_Intersects
       (X, Y, W, H : in Integer)
    return Boolean;

unsigned int fl_old_shortcut(const char *s);
Not applicable; original is legacy. 
void fl_overlay_clear();

procedure Overlay_Clear();

void fl_overlay_rect(int x, int y, int w, int h);

procedure Overlay_Rect
       (X, Y, W, H : in Integer);

void fl_pie(int x, int y, int w, int h, double a1, double a2);

procedure Pie
       (X, Y, W, H     : in Integer;
        Angle1, Angle2 : in Long_Float);

void fl_point(int x, int y);

procedure Point
       (X, Y : in Integer);

void fl_polygon(int x, int y, int x1, int y1, int x2, int y2);

procedure Polygon
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer;
        X2, Y2 : in Integer);

void fl_polygon(int x, int y, int x1, int y1,
    int x2, int y2, int x3, int y3);

procedure Polygon
       (X0, Y0 : in Integer;
        X1, Y1 : in Integer;
        X2, Y2 : in Integer;
        X3, Y3 : in Integer);

void fl_pop_clip();

procedure Pop_Clip();

void fl_pop_matrix();

procedure Pop_Matrix;

void fl_push_clip(int x, int y, int w, int h);

procedure Push_Clip
       (X, Y, W, H : in Integer);

void fl_push_matrix();

procedure Push_Matrix;

void fl_push_no_clip();

procedure Push_No_Clip;

uchar * fl_read_image(uchar *p, int X, int Y, int W, int H,
    int alpha=0);

function Read_Image
       (X, Y, W, H : in Integer;
        Alpha      : in Integer := 0)
    return Color_Component_Array
with Post =>
       (if Alpha = 0
        then Read_Image'Result'Length = W * H * 3
        else Read_Image'Result'Length = W * H * 4);

void fl_rect(int x, int y, int w, int h);

procedure Rect
       (X, Y, W, H : in Integer);

void fl_rect(int x, int y, int w, int h, Fl_Color c);

procedure Rect
       (X, Y, W, H : in Integer;
        Hue        : in Color);

void fl_rectf(int x, int y, int w, int h);

procedure Rect_Fill
       (X, Y, W, H : in Integer);

void fl_rectf(int x, int y, int w, int h, Fl_Color c);

procedure Rect_Fill
       (X, Y, W, H : in Integer;
        Hue        : in Color);

void fl_rectf(int x, int y, int w, int h, uchar r, uchar g, uchar b);

procedure Rect_Fill
       (X, Y, W, H : in Integer;
        R, G, B    : in Color_Component);

void fl_reset_spot();

procedure Reset_Spot;

void fl_restore_clip();

procedure Restore_Clip;

void fl_rotate(double d);

procedure Rotate
       (Angle : in Long_Float);

void fl_rtl_draw(const char *str, int n, int x, int y);

procedure Draw_Text_Right_Left
       (X, Y : in Integer;
        Text : in String);

void fl_scale(double x);

procedure Scale
       (Factor : in Long_Float);

void fl_scale(double x, double y);

procedure Scale
       (Factor_X, Factor_Y : in Long_Float);

void fl_scroll(int X, int Y, int W, int H, int dx, int dy,
    void(*draw_area)(void *, int, int, int, int), void *data);

procedure Scroll
       (X, Y, W, H : in Integer;
        DX, DY     : in Integer;
        Callback   : in Area_Draw_Function);

void fl_set_spot(int font, int size, int X, int Y,
    int W, int H, Fl_Window *win=0);

procedure Set_Spot
       (X, Y, W, H : in Integer;
        Font       : in Font_Kind;
        Size       : in Font_Size);

procedure Set_Spot
       (X, Y, W, H : in Integer;
        Font       : in Font_Kind;
        Size       : in Font_Size;
        Pane       : in FLTK.Widgets.Groups.Windows.Window'Class);

void fl_set_status(int X, int Y, int W, int H);

procedure Set_Status
       (X, Y, W, H : in Integer);

const char * fl_shortcut_label(unsigned int shortcut);

const char * fl_shortcut_label(unsigned int shortcut,
    const char **eom);

function Shortcut_Label
       (Keys : in Key_Combo)
    return String;

Fl_Fontsize fl_size();

function Get_Font_Size
    return Font_Size;

void fl_text_extents(const char *,
    int &dx, int &dy, int &w, int &h);

void fl_text_extents(const char *t, int n,
    int &dx, int &dy, int &w, int &h);

procedure Text_Extents
       (Text         : in     String;
        DX, DY, W, H :    out Integer);

double fl_transform_dx(double x, double y);

function Transform_DX
       (X, Y : in Long_Float)
    return Long_Float;

double fl_transform_dy(double x, double y);

function Transform_DY
       (X, Y : in Long_Float)
    return Long_Float;

double fl_transform_x(double x, double y);

function Transform_X
       (X, Y : in Long_Float)
    return Long_Float;

double fl_transform_y(double x, double y);

function Transform_Y
       (X, Y : in Long_Float)
    return Long_Float;

void fl_transformed_vertex(double xf, double yf);

procedure Transformed_Vertex
       (XF, YF : in Long_Float);

void fl_translate(double x, double y);

procedure Translate
       (X, Y : in Long_Float);

void fl_vertex(double x, double y);

procedure Vertex
       (X, Y : in Long_Float);

double fl_width(const char *txt);

double fl_width(const char *txt, int n);

function Width
       (Text : in String)
    return Long_Float;

double fl_width(unsigned int c);

function Width
       (Glyph : in Character)
    return Long_Float;

function Width
       (Glyph : in Wide_Character)
    return Long_Float;

function Width
       (Glyph : in Wide_Wide_Character)
    return Long_Float;

void fl_xyline(int x, int y, int x1);

procedure Ecks_Why_Line
       (X0, Y0, X1 : in Integer);

void fl_xyline(int x, int y, int x1, int y2);

procedure Ecks_Why_Line
       (X0, Y0, X1, Y2 : in Integer);

void fl_xyline(int x, int y, int x1, int y2, int x3);

procedure Ecks_Why_Line
       (X0, Y0, X1, Y2, X3 : in Integer);

void fl_yxline(int x, int y, int y1);

procedure Why_Ecks_Line
       (X0, Y0, Y1 : in Integer);

void fl_yxline(int x, int y, int y1, int x2);

procedure Why_Ecks_Line
       (X0, Y0, Y1, X2 : in Integer);

void fl_yxline(int x, int y, int y1, int x2, int y3);

procedure Why_Ecks_Line
       (X0, Y0, Y1, X2, Y3 : in Integer);