CListView.h

/*
╔══════════════════════════════════════════════════════════════════════════════╗
║                       SIMPLY POWERFUL TOOLKIT (SPTK)                         ║
╟──────────────────────────────────────────────────────────────────────────────╢
║  copyright            © 1999-2022 Alexey Parshin. All rights reserved.       ║
║  email                alexeyp@gmail.com                                      ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│   This library is free software; you can redistribute it and/or modify it    │
│   under the terms of the GNU Library General Public License as published by  │
│   the Free Software Foundation; either version 2 of the License, or (at your │
│   option) any later version.                                                 │
│                                                                              │
│   This library is distributed in the hope that it will be useful, but        │
│   WITHOUT ANY WARRANTY; without even the implied warranty of                 │
│   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library   │
│   General Public License for more details.                                   │
│                                                                              │
│   You should have received a copy of the GNU Library General Public License  │
│   along with this library; if not, write to the Free Software Foundation,    │
│   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.               │
│                                                                              │
│   Please report all bugs and problems to alexeyp@gmail.com.                  │
└──────────────────────────────────────────────────────────────────────────────┘
*/
 
#pragma once
 
#include <FL/Fl_Group.H>
 
#include <sptk5/CSmallPixmapIDs.h>
#include <sptk5/DataSource.h>
 
#include <sptk5/PackedStrings.h>
#include <sptk5/gui/CColumn.h>
#include <sptk5/gui/CControl.h>
#include <sptk5/gui/CDataControl.h>
#include <sptk5/gui/CListViewRows.h>
#include <sptk5/gui/CListViewSelection.h>
#include <sptk5/gui/CScrollBar.h>
#include <sptk5/sptk.h>
 
namespace sptk {
 
enum class CRefreshKind : uint8_t
{
    LV_REFRESH_FULL,
 
    LV_REFRESH_FAST
 
};
 
class CInternalComboBoxPanel;
 
class CDBDropDownList;
 
enum class CListViewDataMode : uint8_t
{
    LV_DATA_UNDEFINED,
 
    LV_DATA_KEY,
 
    LV_DATA_INDEX,
 
    LV_DATA_CAPTION
 
};
 
class SP_EXPORT CListView
    : public CControl
    , public SharedMutex
{
    friend class CInternalComboBoxPanel;
 
    friend class CDBDropDownList;
 
    void ctor_init();
 
    bool m_fillInProgress {false};
 
    bool m_fillTerminated {false};
 
protected:
    bool m_capitalizeColumnNames {false};
 
    bool m_multipleSelection {false};
 
    int m_horizPosition {0};
 
    int m_realHorizPosition {0};
 
    int m_maxWidth {0};
 
    int m_redraw1 {0};
 
    int m_redraw2 {0};
 
    uint32_t m_top {0};
 
    static int m_scrollbarWidth;
 
    int m_currentTextFont {0};
 
    int m_currentTextSize {0};
 
    Strings m_iconNames;
 
    CListViewDataMode m_dataMode {CListViewDataMode::LV_DATA_UNDEFINED};
 
    int m_mousePressedX {0};
 
    CSelection m_selection;
 
    std::string m_searchPhrase;
 
    uint32_t m_activeRow {0};
 
    uint32_t m_headerHeight {0};
 
    CListViewRows m_rows;
 
    CColumnList m_columnList;
 
    int m_draggingColumn {0};
 
    int m_draggingStarted {0};
 
    Fl_Font m_textFont {0};
 
    uchar m_textSize {0};
 
    Fl_Color m_textColor {0};
 
    bool m_showStripes {false};
 
    bool m_showGrid {false};
 
    bool m_showSelection {false};
 
    bool m_autoRowHeight {false};
 
    int columnAt(int x);
 
    int find_item(int y);
 
    void bbox(int& X, int& Y, int& W, int& H) const;
 
    static void scrollbar_callback(Fl_Widget* s, void*);
 
    static void hscrollbar_callback(Fl_Widget* s, void*);
 
    CScrollBar scrollbar {0, 0, 0, 0};
 
    CScrollBar hscrollbar {0, 0, 0, 0};
 
    int hposition() const
    {
        return m_horizPosition;
    }
 
    void hposition(int hpos); // pan to here
 
    static void scrollbar_width(int b);
 
    static int scrollbar_width();
 
    int find_id(int id) const;
 
    virtual int get_focus();
 
    virtual bool item_selected(uint32_t index) const;
 
    virtual void item_select(uint32_t index, bool select);
 
    virtual int item_compute_height_all();
 
    virtual int item_compute_height(CPackedStrings* rowData);
 
    virtual int item_height(uint32_t index) const;
 
    virtual int item_width(uint32_t index) const;
 
    virtual void item_draw(uint32_t index, const CPackedStrings* rowData, int x, int y, int w, int h, int focusMode,
                           int verticalAlign, bool paintBackground) const;
 
    virtual void item_clicked(int mouse_btn);
 
    virtual Fl_Color item_color(int column, const CPackedStrings& rowData) const;
 
    virtual void header_draw(int x, int y, int hh) const;
 
    virtual void header_clicked(int x);
 
    virtual bool header_drag_position(int x);
 
    virtual void header_dragged(int x);
 
    virtual void header_released(int x);
 
    void redraw_line(uint32_t index);
 
    void redraw_lines()
    {
        damage(FL_DAMAGE_SCROLL);
    }
 
    void draw() override;
 
    void key_changed(uint32_t index);
 
public:
    CListView(const char* label = nullptr, int layoutSize = 20, CLayoutAlign layoutAlign = CLayoutAlign::TOP);
 
#ifdef __COMPATIBILITY_MODE__
    CListView(int, int, int, int, const char* = 0);
#endif
 
    ~CListView() override
    {
        CListView::clear();
    }
 
    int handle(int) override;
 
    void resize(int x, int y, int w, int h) override;
 
    virtual void removeRow(uint32_t index);
 
    virtual void addRow(CPackedStrings* row);
 
    virtual void addRow(int ident, const Strings& row);
 
    virtual void insertRow(uint32_t position, const Strings& row, int ident);
 
    virtual void updateRow(uint32_t position, CPackedStrings* row);
 
    virtual void updateRow(uint32_t position, const Strings& row, int ident = 0);
 
    virtual void clear();
 
    virtual uint32_t size() const
    {
        return m_rows.size();
    }
 
    virtual int top() const
    {
        return (int) m_top;
    }
 
    virtual void top(int index);
 
    int selected(int index) const;
 
    void show(int index);
 
    void show() override
    {
        CControl::show();
    }
 
    void hide(int index);
 
    void hide() override
    {
        Fl_Widget::hide();
    }
 
    int visible(int index) const;
 
    int visible() const
    {
        return (int) Fl_Widget::visible();
    }
 
    std::string textValue() const;
 
    void textValue(const std::string& text);
 
    void dataMode(CListViewDataMode dm)
    {
        m_dataMode = dm;
    }
 
    CListViewDataMode dataMode() const
    {
        return m_dataMode;
    }
 
    Variant data() const override;
 
    void data(const Variant& v) override;
 
    CPackedStrings* row(uint32_t index) const;
 
    const CSelection& selection() const
    {
        return m_selection;
    }
 
    CPackedStrings* selectedRow() const;
 
    int selectedIndex() const;
 
    bool selectRow(uint32_t index, bool sel = true)
    {
        return select(index, sel, true);
    }
 
    bool displayed(uint32_t index) const;
 
    virtual void displayRow(uint32_t index);
 
    void redrawRow(uint32_t index)
    {
        redraw_line(index);
    }
 
protected:
    void load(Query*) override;
 
    void save(Query*) override;
 
    void load(const xdoc::SNode& node, CLayoutXMLmode xmlMode) override;
 
    void save(const xdoc::SNode& node, CLayoutXMLmode xmlMode) const override;
 
    bool valid() const override
    {
        return true;
    }
 
    virtual uint32_t cellBorderWidth() const;
 
    bool select(uint32_t index, bool sel = true, int docallbacks = false);
 
    bool select_only(uint32_t index, bool docallbacks = false);
 
    bool activate_row(uint32_t index);
 
    bool select_first();
 
    bool select_last();
 
    bool select_next();
 
    bool select_prior();
 
    bool select_next_page();
 
    bool select_prior_page();
 
public:
    void columns(const CColumnList& columns);
 
    CColumnList& columns()
    {
        return m_columnList;
    }
 
    CColumn& column(uint32_t col)
    {
        return m_columnList[col];
    }
 
    CColumn& column(const char* colname);
 
    void addColumn(const CColumn& column)
    {
        m_columnList.push_back(column);
    }
 
    void addColumn(const String& colname, VariantDataType type, uint32_t cwidth = 100, bool cvisible = true)
    {
        m_columnList.push_back(CColumn(colname, type, (short) cwidth, cvisible));
    }
 
    CControlKind kind() const override
    {
        return CControlKind::LISTBOX;
    }
 
    bool autoRowHeight() const
    {
        return m_autoRowHeight;
    }
 
    void autoRowHeight(bool arh);
 
    Fl_Font textFont() const override
    {
        return m_textFont;
    }
 
    void textFont(Fl_Font f) override
    {
        m_textFont = f;
    }
 
    uchar textSize() const override
    {
        return m_textSize;
    }
 
    void textSize(uchar s) override
    {
        m_textSize = s;
    }
 
    Fl_Color textColor() const override
    {
        return m_textColor;
    }
 
    void textColor(Fl_Color n) override
    {
        m_textColor = n;
    }
 
    bool showGrid() const
    {
        return m_showGrid;
    }
 
    void showGrid(bool flag);
 
    bool showStripes() const
    {
        return m_showStripes;
    }
 
    void showStripes(bool flag);
 
    bool showSelection() const
    {
        return m_showSelection;
    }
 
    void showSelection(bool flag)
    {
        m_showSelection = flag;
    }
 
    bool multiSelect() const
    {
        return m_multipleSelection;
    }
 
    void multiSelect(bool ms)
    {
        m_multipleSelection = ms;
    }
 
    void getSelections(std::vector<uint64_t>& selection) const;
 
    void setSelections(const std::vector<uint64_t>& selection);
 
    CPackedStrings* findCaption(const String& caption);
 
    CPackedStrings* findKey(int keyValue);
 
    [[nodiscard]] uint32_t fullWidth() const; // current width of all items
 
    [[nodiscard]] uint32_t fullHeight() const; // current height of all items
 
    virtual int findString(const std::string& str, bool select = true, uint32_t startRow = 0, uint32_t endRow = 0);
 
    String sortColumnName() const;
 
    void sortColumn(int column, bool sortNow);
 
    int sortColumn() const;
 
    bool sortAscending() const
    {
        return m_rows.sortAscending();
    }
 
    void sortAscending(bool ascending, bool sortNow);
 
 
    void sort()
    {
        m_rows.sort();
    }
 
    void fill(DataSource& ds, const String& keyFieldName = "", uint32_t recordsLimit = 0, uint32_t recordsEstimated = 0,
              CRefreshKind refreshKind = CRefreshKind::LV_REFRESH_FULL);
 
    void loadList(const xdoc::SNode& node);
 
    void saveList(const xdoc::SNode& node) const;
 
    bool preferredSize(int& w, int& h) override;
 
    uint32_t headerHeight() const
    {
        return m_headerHeight;
    }
 
    void headerHeight(uint32_t hh)
    {
        m_headerHeight = hh;
    }
 
    uint32_t activeRow() const
    {
        return m_activeRow;
    }
 
    bool capitalizeColumnNames() const
    {
        return m_capitalizeColumnNames;
    }
 
    void capitalizeColumnNames(bool ccn)
    {
        m_capitalizeColumnNames = ccn;
    }
 
    void terminateFill()
    {
        m_fillTerminated = true;
    }
 
    String className() const override
    {
        return "list_view";
    }
 
    void imageCollection(Strings& iconNames);
};
} // namespace sptk