CControl.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 <FL/Fl_Menu_Button.H>
 
#include <sptk5/db/Query.h>
#include <sptk5/gui/CEvent.h>
#include <sptk5/gui/CLayoutClient.h>
#include <sptk5/xdoc/Node.h>
 
#include <string>
 
namespace sptk {
 
enum class CControlKind : uint32_t
{
    UNKNOWN = 0,
 
    BOX = 1,
 
    HTMLBOX = 2,
 
    STRING = 4,
 
    MEMO = 8,
 
    INTEGER = 0x10,
 
    FLOAT = 0x20,
 
    DATE = 0x40,
 
    TIME = 0x80,
 
    DATETIME = 0x100,
 
    DATEINTERVAL = 0x200,
 
    COMBO = 0x400,
 
    INTVALUECOMBO = 0x800,
 
    LISTBOX = 0x1000,
 
    CHECKBUTTONS = 0x2000,
 
    RADIOBUTTONS = 0x4000,
 
    PHONE = 0x8000,
 
    TREEVIEW = 0x10000,
 
    GROUP = 0x20000,
 
    SLIDER = 0x40000,
 
    PROGRESS = 0x80000
 
};
 
enum class InputEntryFlags : uint32_t
{
    NONE = 0,
 
    SPELLCHECK = 1,
 
    MANDATORY = 2,
 
    CFIELD = 4,
 
    SINGLELINEENTRY = 256,
 
    MULTILINEENTRY = 512
 
};
 
constexpr int SINGLE_EDIT_ENTRY_HEIGHT = 23;
 
class CDBDropDownList;
 
class CPackedStrings;
 
class CColumnList;
 
class Strings;
 
SP_EXPORT bool checkFieldName(const String& fldName);
 
class SP_EXPORT CControl
    : public ::Fl_Group
    , public CLayoutClient
{
    friend class CInternalComboBoxPanel;
 
    friend class CEditor;
 
    friend class CBaseButton;
 
    friend class CRadioButton;
 
    friend class CCheckButton;
 
    friend class CInput_;
 
    void ctor_init(const char*);
 
protected:
    bool m_limited {false};
 
    uint32_t m_labelWidth {0};
 
    Fl_Color m_labelColor;
 
    Fl_Color m_textColor;
 
    Fl_Font m_textFont;
 
    uchar m_textSize {0};
 
    String m_fieldName;
 
    String m_hint;
 
    Fl_Widget* m_control {nullptr};
 
    int m_tag {0};
 
    uint32_t m_controlFlags {0};
    Fl_Menu_Button* m_menuButton {nullptr};
 
    CEventInfo m_event;
 
    bool m_hasFocus {false};
 
    bool containsFocus() const;
 
    void notifyFocus(bool gotFocus = true);
 
    virtual void onEnter();
 
    virtual void onExit();
 
    uint32_t labelHeight() const;
 
    int handle(int) override;
 
    static void internalCallback(Fl_Widget* internalWidget, void* data);
 
public:
    explicit CControl(const char* label, int layoutSize = 20, CLayoutAlign layoutAlign = CLayoutAlign::TOP);
 
#ifdef __COMPATIBILITY_MODE__
    CControl(int, int, int, int, const char* = 0);
#endif
 
    void resize(int x, int y, int w, int h) override;
 
    void draw() override;
 
    virtual int tag() const
    {
        return m_tag;
    }
 
    virtual void tag(int t)
    {
        m_tag = t;
    }
 
#if FL_MAJOR_VERSION < 2
 
    virtual Fl_Font textFont() const;
 
    virtual void textFont(Fl_Font);
 
#else
 
    virtual Font* textFont() const;
 
    virtual void textFont(Font*);
#endif
 
    virtual uchar textSize() const;
 
    virtual void textSize(uchar);
 
    virtual Fl_Color textColor() const;
 
    virtual void textColor(Fl_Color);
 
    virtual Fl_Color labelColor() const;
 
    virtual void labelColor(Fl_Color);
 
    virtual Fl_Color color() const;
 
    virtual void color(Fl_Color);
 
    uint32_t flags() const
    {
        return m_controlFlags;
    }
 
    void flags(uint32_t flags);
 
    Fl_Widget* control() const
    {
        return m_control;
    }
 
    const String& label() const override
    {
        return m_label;
    }
 
    void label(const String&) override;
 
    Fl_Menu_* menu() const;
 
    void menu(const Fl_Menu_Item*);
 
    Fl_Font labelFont() const
    {
        return labelfont();
    }
 
    void labelSize(Fl_Font f)
    {
        labelfont(f);
    }
 
    uchar labelSize() const;
 
    void labelSize(uchar);
 
    uint32_t labelWidth() const
    {
        return m_labelWidth;
    }
 
    void labelWidth(uint32_t);
 
    void hint(const String& str)
    {
        if (m_control)
        {
            m_hint = str;
            m_control->tooltip(m_hint.c_str());
        }
    }
 
    String hint() const
    {
        return m_hint;
    }
 
    virtual int maxLength() const
    {
        return 0;
    }
 
    virtual void maxLength(int)
    {
        // Implemented in derived classes
    }
 
    virtual const String& fieldName() const
    {
        return m_fieldName;
    }
 
    virtual void fieldName(const String&);
 
    virtual CControlKind kind() const = 0;
 
    String className() const override
    {
        return "control";
    }
 
    virtual void reset()
    {
        data(Variant(""));
    }
 
    virtual void load(Query*)
    {
        // Implemented in derived classes
    }
 
    virtual void save(Query*)
    {
        // Implemented in derived classes
    }
 
    void load(const xdoc::SNode& node, CLayoutXMLmode xmlMode) override;
 
    void load(const xdoc::SNode& node) override
    {
        load(node, CLayoutXMLmode::DATA);
    }
 
    void save(const xdoc::SNode& node, CLayoutXMLmode xmlMode) const override;
 
    virtual void save(const xdoc::SNode& node) const
    {
        save(node, CLayoutXMLmode::DATA);
    }
 
    virtual bool valid() const = 0;
 
    virtual Variant data() const
    {
        return Variant("");
    }
 
    virtual void data(const Variant& v)
    {
        // Implemented in derived classes
    }
 
    void fireEvent(CEvent ev, int32_t arg);
 
    const CEventInfo& event() const
    {
        return m_event;
    }
 
    CEvent eventType() const
    {
        return m_event.type();
    }
 
    int eventArgument() const
    {
        return m_event.argument();
    }
 
    static CControlKind controlNameToType(const String& typeName, int& maxLength, const String& values = "");
 
    CControl& operator=(const String& str)
    {
        data(str);
        return *this;
    }
 
    CControl& operator=(const char* str)
    {
        data(str);
        return *this;
    }
 
    CControl& operator=(int32_t v)
    {
        data(v);
        return *this;
    }
 
    CControl& operator=(uint32_t v)
    {
        data((int) v);
        return *this;
    }
 
    CControl& operator=(int64_t v)
    {
        data(v);
        return *this;
    }
 
    CControl& operator=(float v)
    {
        data(v);
        return *this;
    }
 
    CControl& operator=(double v)
    {
        data(v);
        return *this;
    }
 
    CControl& operator=(const DateTime& dt)
    {
        data(Variant(dt));
        return *this;
    }
 
    CControl& operator=(const Field& fld)
    {
        data(fld);
        return *this;
    }
 
    explicit operator String() const
    {
        return data().asString();
    }
 
    explicit operator int32_t() const
    {
        return data().asInteger();
    }
 
    explicit operator uint32_t() const
    {
        return data().asInteger();
    }
 
    explicit operator int64_t() const
    {
        return data().asInt64();
    }
 
    explicit operator uint64_t() const
    {
        return data().asInt64();
    }
 
    explicit operator float() const
    {
        return (float) data().asFloat();
    }
 
    explicit operator double() const
    {
        return data().asFloat();
    }
 
    explicit operator DateTime() const
    {
        return data().asDateTime();
    }
 
    static void defaultControlMenuCopy(Fl_Widget*, void*);
 
    static void defaultControlMenuCut(Fl_Widget*, void*);
 
    static void defaultControlMenuPaste(Fl_Widget*, void*);
 
    static void defaultControlMenuClear(Fl_Widget*, void*);
 
    static const Fl_Menu_Item defaultControlMenu[];
};
 
CControl* createControl(CControlKind controlKind, const String& label, const String& fieldName, int layoutSize);
 
void createControls(const xdoc::SNode& xmlControls);
 
} // namespace sptk