ControlTypes.h

#ifndef NEO_CONTROL_TYPES_H
#define NEO_CONTROL_TYPES_H

namespace neo
{

class Button : public Control
{
public:
    Button() {}
    Button(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, text, r, p);
    }

    void Create(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam());

    void SimulateClick();
    bool IsChecked() const;
    void SetChecked(bool checked);
    HBITMAP GetBitmap() const;
    void SetBitmap(HBITMAP bitmap);
    void Shrink();
};

class RadioButton : public Button
{
public:
    RadioButton() {}
    RadioButton(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, text, r, p);
    }

    void Create(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam());
};

class CheckBox : public Button
{
public:
    CheckBox() {}
    CheckBox(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, text, r, p);
    }

    void Create(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam());
};

class GroupBox : public Button
{
public:
    GroupBox() {}
    GroupBox(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, text, r, p);
    }

    void Create(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam());
};

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

    virtual HWND GetScrollBarHWND() const = 0;
    virtual int GetBarType() const = 0;

    int GetPos() const;
    int SetPos(int pos, bool redraw = TRUE);

    bool GetRange(int* minPos, int* maxPos) const;
    bool SetRange(int minPos, int maxPos, bool redraw = TRUE);

    bool GetScrollInfo(SCROLLINFO& info) const;
    int SetScrollInfo(SCROLLINFO& info, bool redraw = TRUE);
};

class ScrollBar : public Control, public ScrollBarIF
{
public:
    ScrollBar() {}
    ScrollBar(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    // ScrollBarIF
    virtual HWND GetScrollBarHWND() const override { return GetHandle(); }
    virtual int GetBarType() const override { return SB_CTL; }
};

class WindowScrollBar : public ScrollBarIF
{
public:
    WindowScrollBar(HWND w, int scrollBarType);

    // ScrollBarIF
    virtual HWND GetScrollBarHWND() const override { return window; }
    virtual int GetBarType() const override { return bar; }
private:
    HWND window;
    int bar;
};

class WindowScrollBarH : public WindowScrollBar
{
public:
    WindowScrollBarH(HWND w = 0) : WindowScrollBar(w, SB_HORZ) {}
};

class WindowScrollBarV : public WindowScrollBar
{
public:
    WindowScrollBarV(HWND w = 0) : WindowScrollBar(w, SB_VERT) {}
};

class StaticCtrl : public Control
{
public:
    StaticCtrl() {}
    StaticCtrl(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, text, r, p);
    }

    void Create(HWND parent, const tstring& text, const Rect& r, const ControlParam& p = ControlParam());

    void Shrink();

    HBITMAP GetBitmap() const;
    HBITMAP SetBitmap(HBITMAP bitmap);

    HCURSOR GetCursor() const;
    HCURSOR SetCursor(HCURSOR cursor);

    HENHMETAFILE GetMetaFile() const;
    HENHMETAFILE SetMetaFile(HENHMETAFILE metafile);

    HICON GetIcon() const;
    HICON SetIcon(HICON icon);
};

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

    virtual HWND GetEditHWND() const = 0;

    virtual void Copy();
    virtual void Cut();
    virtual void Paste();

    virtual void Undo();
    virtual void Redo();
    virtual bool CanUndo();
    virtual bool CanRedo();

    virtual void Replace(int from, int to, const tstring& text);
    virtual int GetLastPosition() const;
    virtual tstring GetTextRange(int from, int to);
    virtual void GetSelection(int& from, int& to);
    virtual void SetSelection(int from, int to);
    virtual void SelectAll();
    virtual void SelectNone();

    virtual void SetMaxLength(int len);

    virtual void SetHint(const tstring& hint);
    virtual tstring GetHint() const;

    virtual void SetMargin(int x);
    virtual int GetMargin() const;

    void Remove(int from, int to) { Replace(from, to, tstring()); }
    void SetInsertionPoint(int pos) { SetSelection(pos, pos); }
    void SetInsertionPointEnd() { SetInsertionPoint(GetLastPosition()); }
    int GetInsertionPoint() { int f,t; GetSelection(f, t); return f; }
    tstring GetTextSelection() { return GetTextRange(0, -1); }
};

class TextBox : public Control, public TextBoxIF
{
public:
    TextBox() {}
    TextBox(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    // TextBoxIF
    virtual HWND GetEditHWND() const override { return GetHandle(); }
    virtual int GetLastPosition() const override;

    int GetLineCount() const;
    int XYToPosition(int x, int y) const;
    bool PositionToXY(int pos, int& x, int& y);
    int GetLineLength(int lineIndex);
    tstring GetLineText(int lineIndex);

    bool IsReadOnly() const;
    void SetReadOnly(bool readonly);

    bool IsMultiLine() const;

    TCHAR GetPasswordChar();
    void SetPasswordChar(TCHAR c);
};

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

    virtual HWND GetListBoxHWND() const = 0;

    virtual void Clear();
    virtual void Delete(int i);
    virtual void SetItemData(int i, void* itemData);
    virtual void* GetItemData(int i);
    virtual int Append(const tstring& item);
    virtual int Append(const tstring& item, void* itemData);
    virtual int Insert(const tstring& item, int i);
    virtual int Insert(const tstring& item, int i, void* itemData);
    virtual void SetItem(const tstring& item, int i);
    virtual tstring GetItem(int i);
    virtual int GetItemCount();
    virtual bool IsEmpty();
    virtual int Find(const tstring& item);

    // single selection support
    virtual void SelectItem(int i);
    virtual void SelectNone();
    virtual bool IsSelected(int i);
    virtual int GetSelectedIndex();
    virtual tstring GetSelectedString();
};

class ListBox : public Control, public ListBoxIF
{
public:
    ListBox() {}
    ListBox(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    // ListBoxIF
    virtual HWND GetListBoxHWND() const override { return GetHandle(); }
    // multi selection support
    virtual void SelectItem(int i) override;
    virtual bool IsSelected(int i) override;

    virtual std::vector<int> GetSelectedIndices();
    bool SelectItem(int i, bool select);
    bool HasMultiSelect();
};

class ComboBox : public Control, public TextBoxIF, public ListBoxIF
{
public:
    ComboBox() {}
    ComboBox(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    // TextBoxIF
    virtual HWND GetEditHWND() const  override;

    // ListBoxIF
    virtual HWND GetListBoxHWND() const override;
};

class ProgressBar : public Control
{
public:
    ProgressBar() {}
    ProgressBar(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    void SetStepSize(int step);
    int GetStepSize();
    void Step();
    void Advance(int delta);

    void SetRange(int min, int max);
    int GetMin();
    int GetMax();

    void SetPos(int pos);
    int GetPos();

    void StateNormal();
    void StateError();
    void StatePaused();
    bool IsNormal();
    bool IsError();
    bool IsPaused();

    void SetMarquee(bool marquee);
    bool IsMarquee();
};

class StatusBar : public Control
{
public:
    StatusBar() {}
    StatusBar(HWND parent, const ControlParam& p = ControlParam())
    {
        Create(parent, p);
    }

    void Create(HWND parent, const ControlParam& p = ControlParam());

    Rect GetPaneRect(int i) const;
    void SetPanes(const int* paneWidths, int numPanes);

    tstring GetPaneText(int i) const;
    void SetPaneText(int i, const tstring& text, int drawingOperation = 0);

    HICON GetIcon(int i) const;
    void SetIcon(int i, HICON icon);

    tstring GetHint(int i) const;
    void SetHint(int i, const tstring& text);
};

class HeaderCtrl : public Control
{
public:
    HeaderCtrl() {}
    HeaderCtrl(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());
};

class ListCtrl : public Control
{
public:
    ListCtrl() {}
    ListCtrl(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    HeaderCtrl GetHeaderCtrl() const;
    
    struct ColumnData : public LVCOLUMN
    {
        ColumnData() { ZeroMemory(this, sizeof(ColumnData)); }

        ColumnData& GetFmt() { mask |= LVCF_FMT; return *this; }
        ColumnData& SetFmt(int pFmt) { mask |= LVCF_FMT; fmt = pFmt; return *this; }
        ColumnData& GetWidth() { mask |= LVCF_WIDTH; return *this; }
        ColumnData& SetWidth(int width) { mask |= LVCF_WIDTH; cx = width; return *this; }
        ColumnData& GetText(TCHAR* buffer, int bufferSize) { mask |= LVCF_TEXT; pszText = buffer; cchTextMax = bufferSize; return *this; }
        ColumnData& SetText(const TCHAR* text) { mask |= LVCF_TEXT; pszText = const_cast<TCHAR*>(text); return *this; }
        ColumnData& GetSubItem() { mask |= LVCF_SUBITEM; return *this; }
        ColumnData& SetSubItem(int subitem) { mask |= LVCF_SUBITEM; iSubItem = subitem; return *this; }
    };

    struct ItemData : public LVITEM
    {
        ItemData() { ZeroMemory(this, sizeof(ItemData)); }

        ItemData& Item(int item, int subItem) { iItem = item; iSubItem = subItem; return *this; }
        ItemData& GetText(TCHAR* buffer, int bufferSize) { mask |= LVIF_TEXT; pszText = buffer; cchTextMax = bufferSize; return *this; }
        ItemData& SetText(const TCHAR* text) { mask |= LVIF_TEXT; pszText = const_cast<TCHAR*>(text); return *this; }
        ItemData& GetParam() { mask |= LVIF_PARAM; return *this; }
        ItemData& SetParam(LPARAM param) { mask |= LVIF_PARAM; lParam = param; return *this; }
        ItemData& GetState(UINT pStateMask) { mask |= LVIF_STATE; stateMask = pStateMask; return *this; }
        ItemData& SetState(UINT pState, UINT pStateMask) { mask |= LVIF_STATE; state = pState; stateMask = pStateMask; return *this; }
    };

    int GetColumnCount() const;

    void GetColumn(int index, ColumnData& data) const;
    void SetColumn(int index, ColumnData& data);

    int InsertColumn(int index, ColumnData& data);
    int InsertColumn(int index, const tstring& text, int format = LVCFMT_LEFT, int width = LVSCW_AUTOSIZE_USEHEADER);

    int AppendColumn(const tstring& text, int format = LVCFMT_LEFT, int width = LVSCW_AUTOSIZE_USEHEADER);

    void DeleteColumn(int index);

    void SetColumnWidth(int index, int width);
    int GetColumnWidth(int index) const;

    void AutoSizeColumns(int col = -1);

    int GetItemCount() const;
    void SetItemCount(int count);

    void GetItem(ItemData& data);

    void SetItem(ItemData& data);
    void SetItem(int index, int column, const tstring& text);

    int InsertItem(ItemData& data);
    int InsertItem(int index, const tstring& text);

    int AppendItem(const tstring& text);

    void DeleteItem(int index);

    UINT GetItemState(int index, LPARAM stateMask) const;
    void SetItemState(int index, UINT state, UINT stateMask);

    tstring GetItemText(int index, int column = 0) const;
    void SetItemText(const tstring& text, int index, int column = 0);

    bool IsItemSelected(int item) const;
    void SelectItem(bool select, int item);

    HWND BeginEdit(int index);
    void EndEdit();

    COLORREF GetBkColor() const;
    void SetBkColor(COLORREF color);

    COLORREF GetTextColor() const;
    void SetTextColor(COLORREF color);

    COLORREF GetTextBkColor() const;
    void SetTextBkColor(COLORREF color);

    void EnsureVisible(int index, bool partialOk = false);

    DWORD GetExtendedListStyle() const;
    void SetExtendedListStyle(DWORD style);
};

class TabCtrl : public Control
{
public:
    TabCtrl();
    TabCtrl(HWND parent, const Rect& r, const ControlParam& p = ControlParam())
    {
        Create(parent, r, p);
    }

    void Create(HWND parent, const Rect& r, const ControlParam& p = ControlParam());

    Rect CalculateDisplayArea(const RECT& windowRect) const;
    Rect CurrentDisplayArea() const { return CalculateDisplayArea(GetRectOnParent()); }
    Rect CalculateWindowRect(const RECT& displayArea) const;

    int GetItemCount() const;

    int InsertItem(int index, const TCITEM& item);
    int InsertItem(int index, const tstring& text);

    int AppendItem(const tstring& text);

    void DeleteItem(int index);

    void DeleteAllItems();

    void GetItem(int index, TCITEM& item) const;

    void SetItem(int index, TCITEM& item);
    void SetItem(int index, const tstring& text);

    Rect GetItemRect(int index) const;

    void SetItemSize(int width, int height);

    void SetMinTabWidth(int width);

    void SetPadding(int width, int height);

    int GetRowCount() const;

    int GetSelection() const;
    int SetSelection(int index);

    int GetButtonFocus() const;
    void SetButtonFocus(int index);

    void DeselectAll(bool excludeFocus = true);
};

} // namespace neo

#endif