ginteractor.h

/*
 * File: ginteractor.h
 * -------------------
 *
 * @author Marty Stepp
 * @version 2021/04/09
 * - added sgl namespace
 * @version 2019/04/23
 * - added set/removeActionListener
 * - added set/removeClickListener
 * - added set/removeDoubleClickListener
 * - added set/removeKeyListener
 * - added set/removeMouseListener
 * @version 2019/04/22
 * - added setIcon with QIcon and QPixmap
 * @version 2018/09/20
 * - added read/write lock to avoid race conditions
 * @version 2018/09/05
 * - added getContainer and is/setVisible logic
 * @version 2018/08/23
 * - renamed to ginteractor.h to replace Java version
 * @version 2018/06/25
 * - initial version
 */


#ifndef _ginteractor_h
#define _ginteractor_h

#include <string>
#include <QReadWriteLock>
#include <QWidget>

#include "gevent.h"
#include "gobservable.h"

class QPixmap;
class QIcon;

namespace sgl {

class GContainer;
class GDiffGui;
class GWindow;
class _Internal_QWidget;

class GInteractor : public GObservable {
public:
    enum TextPosition {
        TEXT_BESIDE_ICON,
        TEXT_UNDER_ICON,
        TEXT_ONLY
    };

    GInteractor();

    virtual ~GInteractor();

    virtual void addActionListener() (deprecated);   // does nothing

    bool eventsEnabled() const override;

    virtual std::string getAccelerator() const;

    virtual std::string getActionCommand() const;

    virtual std::string getBackground() const;

    virtual int getBackgroundInt() const;

    virtual GRectangle getBounds() const;

    virtual std::string getColor() const;

    virtual int getColorInt() const;

    virtual GContainer* getContainer() const;

    virtual std::string getFont() const;

    virtual std::string getForeground() const;

    virtual int getForegroundInt() const;

    virtual double getHeight() const;

    virtual int getID() const;

    virtual std::string getIcon() const;

    virtual _Internal_QWidget* getInternalWidget() const = 0;

    virtual GPoint getLocation() const;

    virtual double getMinimumHeight() const;

    virtual GDimension getMinimumSize() const;

    virtual double getMinimumWidth() const;

    virtual char getMnemonic() const (deprecated);

    virtual std::string getName() const;

    virtual double getPreferredHeight() const;

    virtual GDimension getPreferredSize() const;

    virtual double getPreferredWidth() const;

    virtual GDimension getSize() const;

    std::string getType() const override = 0;

    virtual QWidget* getWidget() const = 0;

    virtual double getWidth() const;

    virtual double getX() const;

    virtual double getY() const;

    virtual bool inBounds(double x, double y) const;

    virtual bool inBounds(int x, int y) const;

    virtual bool isEnabled() const;

    virtual bool isVisible() const;

    virtual void removeActionListener();

    virtual void removeClickListener();

    virtual void removeDoubleClickListener();

    virtual void removeKeyListener();

    virtual void removeMouseListener();

    virtual void requestFocus();

    virtual void setAccelerator(const std::string& accelerator);

    virtual void setActionCommand(const std::string& actionCommand);

    virtual void setActionListener(GEventListener func);

    virtual void setActionListener(GEventListenerVoid func);

    virtual void setBackground(int rgb);

    virtual void setBackground(const std::string& color);

    virtual void setBounds(double x, double y, double width, double height);

    virtual void setBounds(const GRectangle& size);

    virtual void setClickListener(GEventListener func);

    virtual void setClickListener(GEventListenerVoid func);

    virtual void setColor(int rgb);

    virtual void setColor(const std::string& color);

    virtual void setDoubleClickListener(GEventListener func);

    virtual void setDoubleClickListener(GEventListenerVoid func);

    virtual void setEnabled(bool value);

    virtual void setFont(const QFont& font);

    virtual void setFont(const std::string& font);

    virtual void setForeground(int rgb);

    virtual void setForeground(const std::string& color);

    virtual void setHeight(double height);

    virtual void setIcon(const QIcon& icon);

    virtual void setIcon(const QPixmap& icon);

    virtual void setIcon(const std::string& filename, bool retainIconSize = true);

    virtual void setKeyListener(GEventListener func);

    virtual void setKeyListener(GEventListenerVoid func);

    virtual void setLocation(double x, double y);

    virtual void setMinimumSize(double width, double height);

    virtual void setMinimumSize(const GDimension& size);

    virtual void setMnemonic(char mnemonic) (deprecated);

    virtual void setMouseListener(GEventListener func);

    virtual void setMouseListener(GEventListenerVoid func);

    virtual void setName(const std::string& name);

    virtual void setPreferredHeight(double height);

    virtual void setPreferredSize(double width, double height);


    virtual void setPreferredSize(const GDimension& size);


    virtual void setPreferredWidth(double width);

    virtual void setSize(double width, double height);

    virtual void setSize(const GDimension& size);

    virtual void setTooltip(const std::string& tooltipText);

    virtual void setVisible(bool visible);

    virtual void setWidth(double width);

    virtual void setX(double x);

    virtual void setY(double y);

protected:
    std::string _actionCommand;

    std::string _actionEventType;

    std::string _icon;

    std::string _name;

    int _id;

    GContainer* _container;

    QReadWriteLock _lock;    // avoid thread race conditions

    static QWidget* getInternalParent(QWidget* parent);

    virtual std::string getActionEventType() const;

    virtual std::string getDefaultInteractorName() const;

    virtual void lockForRead();

    virtual void lockForReadConst() const;

    virtual void lockForWrite();

    virtual void lockForWriteConst() const;

    static std::string normalizeAccelerator(const std::string& accelerator);

    virtual void setContainer(GContainer* container);

    virtual void unlock();

    virtual void unlockConst() const;

    friend class GContainer;
    friend class GDiffGui;
    friend class GWindow;
    friend class _Internal_QWidget;

private:
    static int _interactorCount;
};


class _Internal_QWidget {
public:
    _Internal_QWidget();
    virtual ~_Internal_QWidget();
    virtual void detach();
    virtual QSize getMinimumSize() const;
    virtual bool hasMinimumSize() const;
    virtual QSize getPreferredSize() const;
    virtual bool hasPreferredSize() const;
    virtual void setMinimumSize(double width, double height);
    virtual void setMinimumSize(const QSize& size);
    virtual void setPreferredSize(double width, double height);
    virtual void setPreferredSize(const QSize& size);

private:
    GDimension _minimumSize;
    GDimension _preferredSize;

    friend class GInteractor;
};

template <typename T>
class GGenericInteractor : public GInteractor {
public:
    GGenericInteractor(T* widget)
            : _widget(widget) {
        _iqwidget = new _Internal_QWidget();   // dummy
    }

    _Internal_QWidget* getInternalWidget() const override {
        return _iqwidget;
    }

    string getType() const override {
        string typeName = typeid(T).name();
        return string("GGenericInteractor<") + typeName + ">";
    }

    QWidget* getWidget() const override {
        return _widget;
    }

private:
    _Internal_QWidget* _iqwidget;
    T* _widget;
};

} // namespace sgl

#endif // _ginteractor_h