Fl_Text_Display Binding Map

Back to Index
Package name
Fl_Text_Display FLTK.Widgets.Groups.Text_Displays
Types
Fl_Text_Display Text_Display
  Text_Display_Reference
enum { NORMAL_CURSOR, CARET_CURSOR, DIM_CURSOR, BLOCK_CURSOR, HEAVY_CURSOR, SIMPLE_CURSOR } Cursor_Style
enum { CURSOR_POS, CHARACTER_POS } Position_Kind
enum { DRAG_NONE = -2, DRAG_START_DND = -1, DRAG_CHAR = 0, DRAG_WORD = 1, DRAG_LINE = 2 }  
enum { WRAP_NONE, WRAP_AT_COLUMN, WRAP_AT_PIXEL, WRAP_AT_BOUNDS } Wrap_Mode
Unfinished_Style_Cb Unfinished_Style_Callback
Style_Table_Entry Style_Entry
uchar Style_Index
Style_Table_Entry * Style_Array
int Style_Mask
int Style_Info
Protected Attributes
Too many to list. None that look suited for public API usage.
Constructors
Fl_Text_Display(int X, int Y, int W, int H, const char *L=0);

function Create
       (X, Y, W, H : in Integer;
        Text       : in String := "")
    return Text_Display;
Rely on the automatic use of begin when a group is created, or use begin/end explicitly, or add each widget to its intended parent group manually. 
function Create
       (Parent     : in out Groups.Group'Class;
        X, Y, W, H : in     Integer;
        Text       : in     String := "")
    return Text_Display;
Functions and Procedures
void buffer(Fl_Text_Buffer *buf);

void buffer(Fl_Text_Buffer &buf);

procedure Set_Buffer
       (This : in out Text_Display;
        Buff : in out FLTK.Text_Buffers.Text_Buffer);

Fl_Text_Buffer * buffer() const;

function Get_Buffer
       (This : in Text_Display)
    return FLTK.Text_Buffers.Text_Buffer_Reference;

double col_to_x(double col) const;

function Col_To_X
       (This    : in Text_Display;
        Col_Num : in Integer)
    return Integer;

int count_lines(int start, int end,
    bool start_pos_is_line_start) const;

function Count_Lines
       (This                    : in Text_Display;
        Start, Finish           : in Natural;
        Start_Pos_Is_Line_Start : in Boolean := False)
    return Natural;

Fl_Color cursor_color() const;

function Get_Cursor_Color
       (This : in Text_Display)
    return Color;

void cursor_color(Fl_Color n);

procedure Set_Cursor_Color
       (This : in out Text_Display;
        Col  : in     Color);

void cursor_style(int style);

procedure Set_Cursor_Style
       (This  : in out Text_Display;
        Style : in     Cursor_Style);

virtual int handle(int e);

function Handle
       (This  : in out Text_Display;
        Event : in     Event_Kind)
    return Event_Outcome;

void hide_cursor();

procedure Hide_Cursor
       (This : in out Text_Display);

void highlight_data
   (Fl_Text_Buffer *styleBuffer,
    const Style_Table_Entry *styleTable,
    int nStyles,
    char unfinishedStyle,
    Unfinished_Style_Cb unfinishedHighlightCB,
    void *cbArg);

procedure Highlight_Data
       (This  : in out Text_Display;
        Buff  : in out FLTK.Text_Buffers.Text_Buffer;
        Table : in     Styles.Style_Array);

procedure Highlight_Data
       (This       : in out Text_Display;
        Buff       : in out FLTK.Text_Buffers.Text_Buffer;
        Table      : in     Styles.Style_Array;
        Unfinished : in     Styles.Style_Index;
        Callback   : in     Styles.Unfinished_Style_Callback);

int in_selection(int x, int y) const;

function In_Selection
       (This : in Text_Display;
        X, Y : in Integer)
    return Boolean;

void insert(const char *text);

procedure Insert_Text
       (This : in out Text_Display;
        Item : in     String);

void insert_position(int newPos);

procedure Set_Insert_Position
       (This : in out Text_Display;
        Pos  : in     Natural);

int insert_position() const;

function Get_Insert_Position
       (This : in Text_Display)
    return Natural;

int line_end(int startPos,
    bool startPosIsLineStart) const;

function Line_End
       (This                    : in Text_Display;
        Pos                     : in Natural;
        Start_Pos_Is_Line_Start : in Boolean := False)
    return Natural;

int line_start(int pos) const;

function Line_Start
       (This : in Text_Display;
        Pos  : in Natural)
    return Natural;

void linenumber_align(Fl_Align val);

procedure Set_Linenumber_Alignment
       (This : in out Text_Display;
        To   : in     Alignment);

Fl_Align linenumber_align() const;

function Get_Linenumber_Alignment
       (This : in Text_Display)
    return Alignment;

void linenumber_bgcolor(Fl_Color val);

procedure Set_Linenumber_Back_Color
       (This : in out Text_Display;
        To   : in     Color);

Fl_Color linenumber_bgcolor() const;

function Get_Linenumber_Back_Color
       (This : in Text_Display)
    return Color;

void linenumber_fgcolor(Fl_Color val);

procedure Set_Linenumber_Fore_Color
       (This : in out Text_Display;
        To   : in     Color);

Fl_Color linenumber_fgcolor() const;

function Get_Linenumber_Fore_Color
       (This : in Text_Display)
    return Color;

void linenumber_font(Fl_Font val);

procedure Set_Linenumber_Font
       (This : in out Text_Display;
        To   : in     Font_Kind);

Fl_Font linenumber_font() const;

function Get_Linenumber_Font
       (This : in Text_Display)
    return Font_Kind;

const char * linenumber_format() const;

function Get_Linenumber_Format
       (This : in Text_Display)
    return String;

void linenumber_format(const char *val);

procedure Set_Linenumber_Format
       (This  : in out Text_Display;
        Value : in     String);

void linenumber_size(Fl_Fontsize val);

procedure Set_Linenumber_Size
       (This : in out Text_Display;
        To   : in     Font_Size);

Fl_Fontsize linenumber_size() const;

function Get_Linenumber_Size
       (This : in Text_Display)
    return Font_Size;

void linenumber_width(int width);

procedure Set_Linenumber_Width
       (This  : in out Text_Display;
        Width : in     Natural);

int linenumber_width() const;

function Get_Linenumber_Width
       (This : in Text_Display)
    return Natural;

int move_down();

procedure Move_Down
       (This : in out Text_Display);

function Move_Down
       (This : in out Text_Display)
    return Boolean;

int move_left();

procedure Move_Left
       (This : in out Text_Display);

function Move_Left
       (This : in out Text_Display)
    return Boolean;

int move_right();

procedure Move_Right
       (This : in out Text_Display);

function Move_Right
       (This : in out Text_Display)
    return Boolean;

int move_up();

procedure Move_Up
       (This : in out Text_Display);

function Move_Up
       (This : in out Text_Display)
    return Boolean;

void next_word(void);

procedure Next_Word
       (This : in out Text_Display);

void overstrike(const char *text);

procedure Overstrike
       (This : in out Text_Display;
        Text : in     String);

int position_style(int lineStartPos, int lineLen,
    int lineIndex) const;

function Position_Style
       (This        : in Text_Display;
        Line_Start  : in Natural;
        Line_Length : in Natural;
        Line_Index  : in Natural)
    return Styles.Style_Info;

int position_to_xy(int pos, int *x, int *y) const;

procedure Position_To_XY
       (This     : in     Text_Display;
        Pos      : in     Integer;
        X, Y     :    out Integer;
        Vert_Out :    out Boolean);

void previous_word(void);

procedure Previous_Word
       (This : in out Text_Display);

void redisplay_range(int start, int end);

procedure Redisplay_Range
       (This          : in out Text_Display;
        Start, Finish : in     Natural);

virtual void resize(int X, int Y, int W, int H);

procedure Resize
       (This       : in out Text_Display;
        X, Y, W, H : in     Integer);

int rewind_lines(int startPos, int nLines);

function Rewind_Lines
       (This         : in Text_Display;
        Start, Lines : in Natural)
    return Natural;

void scroll(int topLineNum, int horizOffset);

procedure Scroll_To
       (This   : in out Text_Display;
        Line   : in     Natural;
        Column : in     Natural := 0);

Fl_Align scrollbar_align() const;

function Get_Scrollbar_Alignment
       (This : in Text_Display)
    return Alignment;

void scrollbar_align(Fl_Align a);

procedure Set_Scrollbar_Alignment
       (This  : in out Text_Display;
        Align : in     Alignment);

int scrollbar_width() const;

function Get_Scrollbar_Width
       (This : in Text_Display)
    return Natural;

void scrollbar_width(int W);

procedure Set_Scrollbar_Width
       (This  : in out Text_Display;
        Width : in     Natural);

int shortcut() const;

function Get_Shortcut
       (This : in Text_Display)
    return Key_Combo;

void shortcut(int s);

procedure Set_Shortcut
       (This  : in out Text_Display;
        Value : in     Key_Combo);

void show_cursor(int b=1);

procedure Show_Cursor
       (This : in out Text_Display);

void show_insert_position();

procedure Show_Insert_Position
       (This : in out Text_Display);

int skip_lines(int startPos, int nLines,
    bool startPosIsLineStart);

function Skip_Lines
       (This                    : in Text_Display;
        Start, Lines            : in Natural;
        Start_Pos_Is_Line_Start : in Boolean := False)
    return Natural;

Fl_Color textcolor() const;

function Get_Text_Color
       (This : in Text_Display)
    return Color;

void textcolor(Fl_Color n);

procedure Set_Text_Color
       (This : in out Text_Display;
        Col  : in     Color);

Fl_Font textfont() const;

function Get_Text_Font
       (This : in Text_Display)
    return Font_Kind;

void textfont(Fl_Font s);

procedure Set_Text_Font
       (This : in out Text_Display;
        Font : in     Font_Kind);

Fl_Fontsize textsize() const;

function Get_Text_Size
       (This : in Text_Display)
    return Font_Size;

void textsize(Fl_Fontsize s);

procedure Set_Text_Size
       (This : in out Text_Display;
        Size : in     Font_Size);

int word_end(int pos) const;

function Word_End
       (This : in out Text_Display;
        Pos  : in     Natural)
    return Natural;

int word_start(int pos) const;

function Word_Start
       (This : in out Text_Display;
        Pos  : in     Natural)
    return Natural;

void wrap_mode(int wrap, int wrap_margin);

procedure Set_Wrap_Mode
       (This   : in out Text_Display;
        Mode   : in     Wrap_Mode;
        Margin : in     Natural := 0);

int wrapped_column(int row, int column) const;

function Wrapped_Column
       (This        : in Text_Display;
        Row, Column : in Natural)
    return Natural;

int wrapped_row(int row) const;

function Wrapped_Row
       (This : in Text_Display;
        Row  : in Natural)
    return Natural;

double x_to_col(double x) const;

function X_To_Col
       (This  : in Text_Display;
        X_Pos : in Integer)
    return Integer;
Static Protected Functions and Procedures
static void buffer_modified_cb(int pos, int nInserted, int nDeleted,
    int nRestyled, const char *deletedText, void *cbArg);

procedure Buffer_Modified_Callback
       (This         : in out Text_Display;
        Action       : in     FLTK.Text_Buffers.Modification;
        Place        : in     FLTK.Text_Buffers.Position;
        Length       : in     Natural;
        Deleted_Text : in     String);

static void buffer_predelete_cb(int pos, int nDeleted, void *cbArg);

procedure Buffer_Predelete_Callback
       (This   : in out Text_Display;
        Place  : in     FLTK.Text_Buffers.Position;
        Length : in     Natural);

static void h_scrollbar_cb(Fl_Scrollbar *w, Fl_Text_Display *d);
Intentionally left unbound. 
static void scroll_timer_cb(void *);
Intentionally left unbound. 
static void v_scrollbar_cb(Fl_Scrollbar *w, Fl_Text_Display *d);
Intentionally left unbound.
Protected Functions and Procedures
void absolute_top_line_number(int oldFirstChar);

procedure Redo_Absolute_Top_Line
       (This      : in out Text_Display;
        Old_First : in     Natural);

void calc_last_char();

procedure Calculate_Last_Character
       (This : in out Text_Display);

void calc_line_starts(int startLine, int endLine);

procedure Calculate_Line_Starts
       (This          : in out Text_Display;
        Start, Finish : in     Natural);

void clear_rect(int style, int x, int y, int width,
    int height) const;

procedure Clear_Rect
       (This       : in out Text_Display;
        Style      : in     Styles.Style_Info;
        X, Y, W, H : in     Integer);

void display_insert();

procedure Display_Insert
       (This : in out Text_Display);

virtual void draw();

procedure Draw
       (This : in out Text_Display);

void draw_cursor(int, int);

procedure Draw_Cursor
       (This : in out Text_Display;
        X, Y : in     Integer);

void draw_line_numbers(bool clearAll);

procedure Draw_Line_Numbers
       (This  : in out Text_Display;
        Clear : in     Boolean :=  False);

void draw_range(int start, int end);

procedure Draw_Range
       (This          : in out Text_Display;
        Start, Finish : in     Natural);

void draw_string(int style, int x, int y, int toX,
    const char *string, int nChars) const;

procedure Draw_String
       (This      : in out Text_Display;
        Style     : in     Styles.Style_Info;
        X, Y      : in     Integer;
        Right     : in     Integer;
        Text      : in     String;
        Num_Chars : in     Natural);

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

procedure Draw_Text
       (This       : in out Text_Display;
        X, Y, W, H : in     Integer);

void draw_vline(int visLineNum, int leftClip, int rightClip,
    int leftCharIndex, int rightCharIndex);

procedure Draw_Visible_Line
       (This                  : in out Text_Display;
        Line                  : in     Natural;
        Left_Clip, Right_Clip : in     Integer;
        Left_Char, Right_Char : in     Natural);

int empty_vlines() const;

function Has_Empty_Visible_Lines
       (This : in Text_Display)
    return Boolean;

void extend_range_for_styles(int *start, int *end);
Intentionally left unbound. 
void find_line_end(int pos, bool start_pos_is_line_start,
    int *lineEnd, int *nextLineStart) const;

procedure Find_Line_End
       (This                    : in     Text_Display;
        Start                   : in     Natural;
        Start_Pos_Is_Line_Start : in     Boolean;
        Line_End                :    out Natural;
        Next_Line_Start         :    out Natural);

void find_wrap_range(const char *deletedText, int pos,
    int nInserted, int nDeleted, int *modRangeStart,
    int *modRangeEnd, int *linesInserted, int *linesDeleted);
Intentionally left unbound. 
int find_x(const char *s, int len, int style, int x) const;

function Find_Character
       (This  : in Text_Display;
        Text  : in String;
        Style : in Styles.Style_Index;
        X     : in Integer)
    return Natural;

int get_absolute_top_line_number() const;

function Get_Absolute_Top_Line
       (This : in Text_Display)
    return Natural;

int handle_vline(int mode, int lineStart, int lineLen,
    int leftChar, int rightChar, int topClip, int bottomClip,
    int leftClip, int rightClip) const;
Intentionally left unbound. 
int longest_vline() const;

function Get_Longest_Visible_Line
       (This : in Text_Display)
    return Natural;

void maintain_absolute_top_line_number(int state);

procedure Maintain_Absolute_Top_Line
       (This  : in out Text_Display;
        State : in     Boolean := True);

int maintaining_absolute_top_line_number() const;

function Maintaining_Absolute_Top_Line
       (This : in Text_Display)
    return Boolean;

void measure_deleted_lines(int pos, int nDeleted);
Intentionally left unbound. 
double measure_proportional_character(const char *s, int colNum,
    int pos) const;

function Measure_Character
       (This  : in Text_Display;
        Text  : in String;
        X     : in Integer;
        Index : in Positive)
    return Long_Float;

int measure_vline(int visLineNum) const;

function Measure_Visible_Line
       (This : in Text_Display;
        Line : in Natural)
    return Natural;

void offset_line_starts(int newTopLineNum);

procedure Offset_Line_Starts
       (This    : in out Text_Display;
        New_Top : in     Natural);

int position_to_line(int pos, int *lineNum) const;

function Position_To_Line
       (This     : in Text_Display;
        Position : in Natural)
    return Natural;

function Position_To_Line
       (This      : in     Text_Display;
        Position  : in     Natural;
        Displayed :    out Boolean)
    return Natural;

int position_to_linecol(int pos, int *lineNum, int *column) const;

procedure Position_To_Line_Column
       (This     : in     Text_Display;
        Position : in     Natural;
        Line     :    out Natural;
        Column   :    out Natural);

procedure Position_To_Line_Column
       (This      : in     Text_Display;
        Position  : in     Natural;
        Line      :    out Natural;
        Column    :    out Natural;
        Displayed :    out Boolean);

void reset_absolute_top_line_number();

procedure Reset_Absolute_Top_Line
       (This : in out Text_Display);

int scroll_(int topLineNum, int horizOffset);

function Scroll_To
       (This  : in out Text_Display;
        Line  : in     Natural;
        Pixel : in     Natural := 0)
    return Boolean;

double string_width(const char *string, int length,
    int style) const;

function Measure_String
       (This  : in Text_Display;
        Text  : in String;
        Style : in Styles.Style_Index)
    return Long_Float;

void update_h_scrollbar();

procedure Update_Horizontal_Scrollbar
       (This : in out Text_Display);

void update_line_starts(int pos, int charsInserted,
    int charsDeleted, int linesInserted, int linesDeleted,
    int *scrolled);
Intentionally left unbound. 
void update_v_scrollbar();

procedure Update_Vertical_Scrollbar
       (This : in out Text_Display);

int vline_length(int visLineNum) const;

function Visible_Line_Length
       (This : in Text_Display;
        Line : in Natural)
    return Natural;

int wrap_uses_character(int lineEndPos) const;

function Wrap_Uses_Character
       (This     : in Text_Display;
        Line_End : in Natural)
    return Boolean;

void wrapped_line_counter(Fl_Text_Buffer *buf, int startPos,
    int maxPos, int maxLines, bool startPosIsLineStart,
    int styleBufOffset, int *retPos, int *retLines,
    int *retLineStart, int *retLineEnd,
    bool countLastLineMissingNewLine=true) const;

procedure Count_Wrapped_Lines
       (This                       : in     Text_Display;
        Buffer                     : in     FLTK.Text_Buffers.Text_Buffer;
        Start                      : in     Natural;
        Max_Position, Max_Lines    : in     Natural;
        Start_Pos_Is_Line_Start    : in     Boolean;
        Style_Offset               : in     Natural;
        Finish, Line_Count         :    out Natural;
        End_Count_Line_Start       :    out Natural;
        Last_Line_End              :    out Natural;
        Count_Last_Missing_Newline : in     Boolean := True);

int xy_to_position(int x, int y, int PosType=CHARACTER_POS) const;

function XY_To_Position
       (This : in Text_Display;
        X, Y : in Integer;
        Kind : in Position_Kind := Character_Position)
    return Natural;

void xy_to_rowcol(int x, int y, int *row, int *column,
    int PosType=CHARACTER_POS) const;

procedure XY_To_Row_Column
       (This        : in     Text_Display;
        X, Y        : in     Integer;
        Row, Column :    out Natural;
        Kind        : in     Position_Kind := Character_Position);