tb_style_edit.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TBStyleEdit_H
#define TBStyleEdit_H

#include "tb_core.h"
#include "tb_linklist.h"
#include "tb_widgets_common.h"
#include "tb_list.h"

namespace tb {

class TBStyleEdit;
class TBBlock;
class TBTextFragment;
class TBTextFragmentContent;
class TBTextFragmentContentFactory;

class TBStyleEditListener
{
public:
    virtual ~TBStyleEditListener() {}

    virtual void OnChange() {};
    virtual bool OnEnter() { return false; };
    virtual void Invalidate(const TBRect &rect) = 0;
    virtual void DrawString(int32_t x, int32_t y, TBFontFace *font, const TBColor &color, const char *str, int32_t len = TB_ALL_TO_TERMINATION) = 0;
    virtual void DrawRect(const TBRect &rect, const TBColor &color) = 0;
    virtual void DrawRectFill(const TBRect &rect, const TBColor &color) = 0;
    virtual void DrawTextSelectionBg(const TBRect &rect) = 0;
    virtual void DrawContentSelectionFg(const TBRect &rect) = 0;
    virtual void DrawCaret(const TBRect &rect) = 0;
    virtual void Scroll(int32_t dx, int32_t dy) = 0;
    virtual void UpdateScrollbars() = 0;
    virtual void CaretBlinkStart() = 0;
    virtual void CaretBlinkStop() = 0;
};

class TBTextFragmentContentFactory
{
public:
    virtual ~TBTextFragmentContentFactory() {}
    virtual int GetContent(const char *text);

    virtual TBTextFragmentContent *CreateFragmentContent(const char *text, int text_len);
};

class TBTextOfs
{
public:
    TBTextOfs() : block(nullptr), ofs(0) {}
    TBTextOfs(TBBlock *block, int32_t ofs) : block(block), ofs(ofs) {}

    void Set(TBBlock *new_block, int32_t new_ofs) { block = new_block; ofs = new_ofs; }
    void Set(const TBTextOfs &pos) { block = pos.block; ofs = pos.ofs; }

    int32_t GetGlobalOfs(TBStyleEdit *se) const;
    bool SetGlobalOfs(TBStyleEdit *se, int32_t gofs);

public:
    TBBlock *block;
    int32_t ofs;
};

class TBSelection
{
public:
    TBSelection(TBStyleEdit *styledit);
    TBSelection(const TBStyleEdit *styledit);
    void Invalidate() const;
    void Select(const TBTextOfs &new_start, const TBTextOfs &new_stop);
    void Select(const TBPoint &from, const TBPoint &to);
    void Select(int glob_ofs_from, int glob_ofs_to);
    void SelectToCaret(TBBlock *old_caret_block, int32_t old_caret_ofs);
    void SelectAll();
    void SelectNothing();
    void CorrectOrder();
    void CopyToClipboard();
    bool IsBlockSelected(TBBlock *block) const;
    bool IsFragmentSelected(TBTextFragment *elm) const;
    bool IsSelected() const;
    void RemoveContent();
    bool GetText(TBStr &text) const;
public:
    TBStyleEdit *styledit;
    TBTextOfs start, stop;
    bool m_const;
};

enum TB_CARET_POS {
    TB_CARET_POS_BEGINNING,
    TB_CARET_POS_END
};

class TBCaret
{
public:
    TBCaret(TBStyleEdit *styledit);
    void Invalidate();
    void UpdatePos();
    bool Move(bool forward, bool word);
    bool Place(const TBPoint &point);
    bool Place(TBBlock *block, int ofs, bool allow_snap = true, bool snap_forward = false);
    void Place(TB_CARET_POS place);
    void AvoidLineBreak();
    void Paint(int32_t translate_x, int32_t translate_y);
    void ResetBlink();
    void UpdateWantedX();

    int32_t GetGlobalOfs() const { return pos.GetGlobalOfs(styledit); }
    void SetGlobalOfs(int32_t gofs, bool allow_snap = true, bool snap_forward = false);

    TBTextFragment *GetFragment();
private:
    void SwitchBlock(bool second);
public:
    TBStyleEdit *styledit;
    int32_t x, y; 
    int32_t width;
    int32_t height;
    int32_t wanted_x;
    bool on;
    bool prefer_first;
    TBTextOfs pos;
};

class TBTextProps
{
public:
    class Data : public TBLinkOf<Data>
    {
    public:
        TBFontDescription font_desc;
        TBColor text_color;
        bool underline;
    };
    TBTextProps(const TBFontDescription &font_desc, const TBColor &text_color);

    Data *Push();
    void Pop();

    TBFontFace *GetFont();
public:
    TBLinkListOf<Data> data_list;
    Data base_data;
    Data *data;
};

class TBBlock : public TBLinkOf<TBBlock>
{
public:
    TBBlock(TBStyleEdit *styledit);
    ~TBBlock();

    void Clear();
    void Set(TBStr newstr);
    void SetAlign(TB_TEXT_ALIGN align);

    int32_t InsertText(int32_t ofs, const char * text, int32_t len, bool allow_line_recurse);
    void RemoveContent(int32_t ofs, int32_t len);

    void Split();

    void Merge();

    void Layout(bool update_fragments, bool propagate_height);

    void SetSize(int32_t old_w, int32_t new_w, int32_t new_h, bool propagate_height);

    TBTextFragment *FindFragment(int32_t ofs, bool prefer_first = false) const;
    TBTextFragment *FindFragment(int32_t x, int32_t y) const;

    int32_t CalculateStringWidth(TBFontFace *font, const char * str, int len = TB_ALL_TO_TERMINATION) const;
    int32_t CalculateTabWidth(TBFontFace *font, int32_t xpos) const;
    int32_t CalculateLineHeight(TBFontFace *font) const;
    int32_t CalculateBaseline(TBFontFace *font) const;

    void Invalidate() const;
    void BuildSelectionRegion(int32_t translate_x, int32_t translate_y, TBTextProps *props,
        TBRegion &bg_region, TBRegion &fg_region);
    void Paint(int32_t translate_x, int32_t translate_y, TBTextProps *props);
public:
    TBStyleEdit *styledit;
    TBLinkListOf<TBTextFragment> fragments;

    int32_t ypos;
    int16_t height;
    int8_t align;
    int line_width_max;

    TBStr str;
    int32_t str_len;

private:
    int GetStartIndentation(TBFontFace *font, int first_line_len) const;
};

class TBUndoEvent
{
public:
    int32_t gofs;
    TBStr text;
    bool insert;
};

class TBUndoRedoStack
{
public:
    TBUndoRedoStack() : applying(false) {}
    ~TBUndoRedoStack();

    void Undo(TBStyleEdit *styledit);
    void Redo(TBStyleEdit *styledit);
    void Clear(bool clear_undo, bool clear_redo);

    TBUndoEvent *Commit(TBStyleEdit *styledit, int32_t gofs, int32_t len, const char *text, bool insert);
public:
    TBListOf<TBUndoEvent> undos;
    TBListOf<TBUndoEvent> redos;
    bool applying;
private:
    void Apply(TBStyleEdit *styledit, TBUndoEvent *e, bool reverse);
};

class TBTextFragment : public TBLinkOf<TBTextFragment>
{
public:
    TBTextFragment(TBTextFragmentContent *content = nullptr)
                : xpos(0)
                , ypos(0)
                , ofs(0)
                , len(0)
                , line_ypos(0)
                , line_height(0)
                , block(nullptr)
                , content(content) {}
    ~TBTextFragment();

    void Init(TBBlock *block, uint16_t ofs, uint16_t len);

    void UpdateContentPos();

    void BuildSelectionRegion(int32_t translate_x, int32_t translate_y, TBTextProps *props,
        TBRegion &bg_region, TBRegion &fg_region);
    void Paint(int32_t translate_x, int32_t translate_y, TBTextProps *props);
    void Click(int button, uint32_t modifierkeys);

    bool IsText() const                 { return !IsEmbedded(); }
    bool IsEmbedded() const             { return content ? true : false; }
    bool IsBreak() const;
    bool IsSpace() const;
    bool IsTab() const;

    int32_t GetCharX(TBFontFace *font, int32_t ofs);
    int32_t GetCharOfs(TBFontFace *font, int32_t x);

    int32_t GetStringWidth(TBFontFace *font, const char *str, int len);

    bool GetAllowBreakBefore() const;
    bool GetAllowBreakAfter() const;

    const char *Str() const         { return block->str.CStr() + ofs; }

    int32_t GetWidth(TBFontFace *font);
    int32_t GetHeight(TBFontFace *font);
    int32_t GetBaseline(TBFontFace *font);
public:
    int16_t xpos, ypos;
    uint16_t ofs, len;
    uint16_t line_ypos;
    uint16_t line_height;
    TBBlock *block;
    TBTextFragmentContent *content;
};

class TBStyleEdit
{
public:
    TBStyleEdit();
    virtual ~TBStyleEdit();

    void SetListener(TBStyleEditListener *listener);
    void SetContentFactory(TBTextFragmentContentFactory *content_factory);

    void SetFont(const TBFontDescription &font_desc);

    void Paint(const TBRect &rect, const TBFontDescription &font_desc, const TBColor &text_color);
    bool KeyDown(int key, SPECIAL_KEY special_key, MODIFIER_KEYS modifierkeys);
    bool MouseDown(const TBPoint &point, int button, int clicks, MODIFIER_KEYS modifierkeys, bool touch);
    bool MouseUp(const TBPoint &point, int button, MODIFIER_KEYS modifierkeys, bool touch);
    bool MouseMove(const TBPoint &point);
    void Focus(bool focus);

    void Clear(bool init_new = true);
    bool SetText(const TBStr & text, TB_CARET_POS pos = TB_CARET_POS_BEGINNING);
    //bool SetText(const TBStr & text, int text_len, TB_CARET_POS pos = TB_CARET_POS_BEGINNING);
    bool GetText(TBStr &text) const;
    bool IsEmpty() const;

    void SetAlign(TB_TEXT_ALIGN align);
    void SetMultiline(bool multiline = true);
    void SetStyling(bool styling = true);
    void SetReadOnly(bool readonly = true);
    void SetSelection(bool selection = true);
    void SetPassword(bool password = true);
    void SetWrapping(bool wrapping = true);

    void SetWindowsStyleBreak(bool win_style_br) { packed.win_style_br = win_style_br; }

    void Cut();
    void Copy();
    void Paste();
    void Delete();

    void Undo();
    void Redo();
    bool CanUndo() const { return undoredo.undos.GetNumItems() ? true : false; }
    bool CanRedo() const { return undoredo.redos.GetNumItems() ? true : false; }

    void InsertText(const char *text, int32_t len = TB_ALL_TO_TERMINATION,
                    bool after_last = false, bool clear_undo_redo = false);
    void AppendText(const char *text, int32_t len = TB_ALL_TO_TERMINATION,
                    bool clear_undo_redo = false) { InsertText(text, len, true, clear_undo_redo); }
    void InsertBreak();

    TBBlock *FindBlock(int32_t y) const;

    void ScrollIfNeeded(bool x = true, bool y = true);
    void SetScrollPos(int32_t x, int32_t y);
    void SetLayoutSize(int32_t width, int32_t height, bool is_virtual_reformat);
    void Reformat(bool update_fragments);

    int32_t GetContentWidth();
    int32_t GetContentHeight() const;

    int32_t GetOverflowX() const { return MAX(content_width - layout_width, 0); }
    int32_t GetOverflowY() const { return MAX(content_height - layout_height, 0); }
public:
    TBStyleEditListener *listener;
    TBTextFragmentContentFactory default_content_factory;
    TBTextFragmentContentFactory *content_factory;
    int32_t layout_width;
    int32_t layout_height;
    int32_t content_width;
    int32_t content_height;

    TBLinkListOf<TBBlock> blocks;

    TBCaret caret;
    TBSelection selection;
    TBUndoRedoStack undoredo;

    int32_t scroll_x;
    int32_t scroll_y;

    int8_t select_state;
    TBPoint mousedown_point;
    TBTextFragment *mousedown_fragment;

    TBFontFace *font;
    TBFontDescription font_desc;

    TB_TEXT_ALIGN align;
    union { struct {
        uint32_t multiline_on : 1;
        uint32_t styling_on : 1;
        uint32_t read_only : 1;
        uint32_t selection_on : 1;
        uint32_t show_whitespace : 1;
        uint32_t password_on : 1;
        uint32_t wrapping : 1;
        uint32_t win_style_br : 1;
        uint32_t calculate_content_width_needed : 1;    
        uint32_t lock_scrollbars_counter : 5;           
    } packed;
    uint32_t packed_init;
    };

    void BeginLockScrollbars();
    void EndLockScrollbars();

    bool GetSizeAffectsLayout() const;
};

} // namespace tb

#endif