Fl_Text_Buffer(int requestedSize=0, int preferredGapSize=1024);

function Create
       (Requested_Size     : in Natural := 0;
        Preferred_Gap_Size : in Natural := 1024)
    return Text_Buffer;

void add_modify_callback(Fl_Text_Modify_Cb bufModifiedCB, void *cbArg);

procedure Add_Modify_Callback
       (This : in out Text_Buffer;
        Func : in     Modify_Callback);

void add_predelete_callback(Fl_Text_Predelete_Cb bufPredelCB, void *cbArg);

procedure Add_Predelete_Callback
       (This : in out Text_Buffer;
        Func : in     Predelete_Callback);

procedure Enable_Callbacks
       (This : in out Text_Buffer);

procedure Disable_Callbacks
       (This : in out Text_Buffer);

const char * address(int pos) const;

char * address(int pos);

void append(const char *t);

procedure Append_Text
       (This : in out Text_Buffer;
        Text : in     String);

int appendFile(const char *file, int buflen=128*1024);

procedure Append_File
       (This   : in out Text_Buffer;
        Name   : in     String;
        Buffer : in     Natural := 128 * 1024);

char byte_at(int pos) const;

function Byte_At
       (This  : in Text_Buffer;
        Place : in Position)
    return Character;

void call_modify_callbacks();

procedure Call_Modify_Callbacks
       (This : in out Text_Buffer);

void call_predelete_callbacks();

procedure Call_Predelete_Callbacks
       (This : in out Text_Buffer);

void canUndo(char flag=1);

procedure Can_Undo
       (This : in out Text_Buffer;
        Flag : in     Boolean);

unsigned int char_at(int pos) const;

function Character_At
       (This  : in Text_Buffer;
        Place : in Position)
    return Character;

void copy(Fl_Text_Buffer *fromBuf, int fromStart, int fromEnd, int toPos);

procedure Copy
       (This          : in out Text_Buffer;
        From          : in     Text_Buffer;
        Start, Finish : in     Position;
        Insert_Pos    : in     Position);

int count_displayed_characters(int lineStartPos, int targetPos) const;

function Count_Displayed_Characters
       (This          : in Text_Buffer;
        Start, Finish : in Position)
    return Integer;

int count_lines(int startPos, int endPos) const;

function Count_Lines
       (This          : in Text_Buffer;
        Start, Finish : in Position)
    return Integer;

int findchar_backward(int startPos, unsigned int searchChar, int *foundPos) const;

function Findchar_Backward
       (This     : in     Text_Buffer;
        Start_At : in     Position;
        Item     : in     Character;
        Found_At :    out Position)
    return Boolean;

int findchar_forward(int startPos, unsigned searchChar, int *foundPos) const;

function Findchar_Forward
       (This     : in     Text_Buffer;
        Start_At : in     Position;
        Item     : in     Character;
        Found_At :    out Position)
    return Boolean;

void highlight(int start, int end);

procedure Set_Highlight
       (This          : in out Text_Buffer;
        Start, Finish : in     Position);

procedure Get_Highlight
       (This          : in     Text_Buffer;
        Start, Finish :    out Position);

int highlight();

int highlight_position(int *start, int *end);

const Fl_Text_Selection * highlight_selection() const;

char * highlight_text();

function Get_Highlighted_Text
       (This : in Text_Buffer)
    return String;

void insert(int pos, const char *text);

procedure Insert_Text
       (This  : in out Text_Buffer;
        Place : in     Position;
        Text  : in     String);

int insertfile(const char *file, int pos, int buflen=128*1024);

procedure Insert_File
       (This   : in out Text_Buffer;
        Name   : in     String;
        Place  : in     Position;
        Buffer : in     Natural := 128 * 1024);

int length() const;

function Length
       (This : in Text_Buffer)
    return Natural;

int line_end(int pos) const;

function Line_End
       (This  : in Text_Buffer;
        Place : in Position)
    return Position;

int line_start(int pos) const;

function Line_Start
       (This  : in Text_Buffer;
        Place : in Position)
    return Position;

char * line_text(int pos) const;

function Line_Text
       (This  : in Text_Buffer;
        Place : in Position)
    return String;

int loadfile(const char *file, int buflen=128*1024);

procedure Load_File
       (This   : in out Text_Buffer;
        Name   : in     String;
        Buffer : in     Natural := 128 * 1024);

int next_char(int ix) const;

function Next_Char
       (This  : in Text_Buffer;
        Place : in Position)
    return Character;

int next_char_clipped(int ix) const;

int outputfile(const char *file, int start, int end, int buflen=128*1024);

procedure Output_File
       (This          : in Text_Buffer;
        Name          : in String;
        Start, Finish : in Position;
        Buffer        : in Natural := 128 * 1024);

int prev_char(int ix) const;

function Prev_Char
       (This  : in Text_Buffer;
        Place : in Position)
    return Character;

int prev_char_clipped(int ix) const;

const Fl_Text_Selection * primary_selection() const;

Fl_Text_Selection * primary_selection();

void remove(int start, int end);

procedure Remove_Text
       (This          : in out Text_Buffer;
        Start, Finish : in     Position);

void remove_modify_callback(Fl_Text_Modify_Cb bufModifiedCB, void *cbArg);

procedure Remove_Modify_Callback
       (This : in out Text_Buffer;
        Func : in     Modify_Callback);

void remove_predelete_callback(Fl_Text_Predelete_Cb predelCB, void *cbArg);

procedure Remove_Predelete_Callback
       (This : in out Text_Buffer;
        Func : in     Predelete_Callback);

void remove_secondary_selection();

procedure Remove_Secondary_Selection
       (This : in out Text_Buffer);

void remove_selection();

procedure Remove_Selection
       (This : in out Text_Buffer);

void replace(int start, int end, const char *text);

procedure Replace_Text
       (This          : in out Text_Buffer;
        Start, Finish : in     Position;
        Text          : in     String);

void replace_secondary_selection(const char *text);

procedure Replace_Secondary_Selection
       (This : in out Text_Buffer;
        Text : in     String);

void replace_selection(const char *text);

procedure Replace_Selection
       (This : in out Text_Buffer;
        Text : in     String);

int rewind_lines(int startPos, int nLines);

function Rewind_Lines
       (This  : in out Text_Buffer;
        Start : in     Position;
        Lines : in     Natural)
    return Position;

int savefile(const char *file, int buflen=128*1024);

procedure Save_File
       (This   : in Text_Buffer;
        Name   : in String;
        Buffer : in Natural := 128 * 1024);

int search_backward(int startPos, const char *searchString, int *foundPos, int matchCase=0) const;

function Search_Backward
       (This       : in     Text_Buffer;
        Start_At   : in     Position;
        Item       : in     String;
        Found_At   :    out Position;
        Match_Case : in     Boolean := False)
    return Boolean;

int search_forward(int startPos, const char *searchString, int *foundPos, int matchCase=0) const;

function Search_Forward
       (This       : in     Text_Buffer;
        Start_At   : in     Position;
        Item       : in     String;
        Found_At   :    out Position;
        Match_Case : in     Boolean := False)
    return Boolean;

void secondary_select(int start, int end);

procedure Set_Secondary_Selection
       (This          : in out Text_Buffer;
        Start, Finish : in     Position);

int secondary_selected();

function Has_Secondary_Selection
       (This : in Text_Buffer)
    return Boolean;

const Fl_Text_Selection * secondary_selection() const;

int secondary_selection_position(int *start, int *end);

function Get_Secondary_Selection
       (This          : in     Text_Buffer;
        Start, Finish :    out Position)
    return Boolean;

char * secondary_selection_text();

function Secondary_Selection_Text
       (This : in Text_Buffer)
    return String;

void secondary_unselect();

procedure Secondary_Unselect
       (This : in out Text_Buffer);

void select(int start, int end);

procedure Set_Selection
       (This          : in out Text_Buffer;
        Start, Finish : in     Position);

int selected() const;

function Has_Selection
       (This : in Text_Buffer)
    return Boolean;

int selection_position(int *start, int *end);

function Get_Selection
       (This          : in     Text_Buffer;
        Start, Finish :    out Position)
    return Boolean;

char * selection_text();

function Selection_Text
       (This : in Text_Buffer)
    return String;

int skip_displayed_characters(int lineStartPos, int nChars);

function Skip_Displayed_Characters
       (This  : in Text_Buffer;
        Start : in Position;
        Chars : in Natural)
    return Position;

int skip_lines(int startPos, int nLines);

function Skip_Lines
       (This  : in out Text_Buffer;
        Start : in     Position;
        Lines : in     Natural)
    return Position;

int tab_distance() const;

function Get_Tab_Width
       (This : in Text_Buffer)
    return Natural;

void tab_distance(int tabDist);

procedure Set_Tab_Width
       (This : in out Text_Buffer;
        To   : in     Natural);

char * text() const;

function Get_Entire_Text
       (This : in Text_Buffer)
    return String;

void text(const char *text);

procedure Set_Entire_Text
       (This : in out Text_Buffer;
        Text : in     String);

char * text_range(int start, int end) const;

function Text_At
       (This          : in Text_Buffer;
        Start, Finish : in Position)
    return String;

int undo(int *cp=0);

void unhighlight();

procedure Unhighlight
       (This : in out Text_Buffer);

void unselect();

procedure Unselect
       (This : in out Text_Buffer);

int utf8_align(int) const;

function UTF8_Align
       (This  : in Text_Buffer;
        Place : in Position)
    return Position;

int word_end(int pos) const;

function Word_End
       (This  : in Text_Buffer;
        Place : in Position)
    return Position;

int word_start(int pos) const;

function Word_Start
       (This  : in Text_Buffer;
        Place : in Position)
    return Position;