gwindow.h

/*
 * File: gwindow.h
 * ---------------
 *
 * @author Marty Stepp
 * @version 2021/04/09
 * - added sgl namespace
 * @version 2021/04/03
 * - removed dependency on custom collections
 * @version 2019/05/05
 * - added static method for isDarkMode checking support
 * - added static methods to ask for system default widget bg/fg color
 * @version 2019/04/09
 * - added toolbar support
 * @version 2018/10/20
 * - added high-density screen features
 * @version 2018/09/09
 * - added doc comments for new documentation generation
 * @version 2018/09/05
 * - refactored to use a border layout GContainer "content pane" for storing all interactors
 * @version 2018/08/23
 * - renamed to gwindow.h to replace Java version
 * @version 2018/07/29
 * - menu bars
 * @version 2018/06/25
 * - initial version
 */


#ifndef _gwindow_h
#define _gwindow_h

#include <map>
#include <set>
#include <string>
#include <QCloseEvent>
#include <QEvent>
#include <QLayout>
#include <QMainWindow>
#include <QRect>

#include "gcanvas.h"
#include "gcontainer.h"
#include "gdrawingsurface.h"
#include "geventqueue.h"
#include "ginteractor.h"
#include "gtypes.h"

namespace sgl {

class _Internal_QMainWindow;

class GWindow : public GObservable, public virtual GForwardDrawingSurface {
public:
    enum Region {
        REGION_CENTER = GContainer::REGION_CENTER,
        REGION_EAST = GContainer::REGION_EAST,
        REGION_NORTH = GContainer::REGION_NORTH,
        REGION_SOUTH = GContainer::REGION_SOUTH,
        REGION_WEST = GContainer::REGION_WEST
    };

    enum CloseOperation {
        CLOSE_DO_NOTHING,
        CLOSE_HIDE,
        CLOSE_DISPOSE,
        CLOSE_EXIT
    };

    static const int DEFAULT_WIDTH;

    static const int DEFAULT_HEIGHT;

    static const int HIGH_DPI_SCREEN_THRESHOLD;

    static const int STANDARD_SCREEN_DPI;

    static const string DEFAULT_ICON_FILENAME;

    GWindow(bool visible = true);

    GWindow(double width, double height, bool visible = true);

    GWindow(double x, double y, double width, double height, bool visible = true);

    ~GWindow() override;

    virtual void add(GInteractor* interactor);

    virtual void add(GInteractor* interactor, double x, double y);

    virtual void add(GInteractor& interactor);

    virtual void add(GInteractor& interactor, double x, double y);

    virtual void add(GObject* obj);

    virtual void add(GObject* obj, double x, double y);

    virtual void add(GObject& obj);

    virtual void add(GObject& obj, double x, double y);

    virtual QMenu* addMenu(const string& text);

    virtual QAction* addMenuItem(const string& menu, const string& item,
                                 const string& icon = "");

    virtual QAction* addMenuItem(const string& menu, const string& item,
                                 const string& icon, GEventListenerVoid func);

    virtual QAction* addMenuItem(const string& menu, const string& item,
                                 const QIcon& icon, GEventListenerVoid func);

    virtual QAction* addMenuItem(const string& menu, const string& item,
                                 const QPixmap& icon, GEventListenerVoid func);

    virtual QAction* addMenuItemCheckBox(const string& menu, const string& item,
                                         bool checked = false,
                                         const string& icon = "");

    virtual QAction* addMenuItemCheckBox(const string& menu, const string& item,
                                         bool checked,
                                         const string& icon, GEventListenerVoid func);

    virtual QAction* addMenuSeparator(const string& menu);

    virtual QMenu* addSubMenu(const string& menu, const string& submenu);

    virtual void addToRegion(GInteractor* interactor, Region region);

    virtual void addToRegion(GInteractor* interactor, const string& region = "Center");

    virtual void addToRegion(GInteractor& interactor, Region region);

    virtual void addToRegion(GInteractor& interactor, const string& region = "Center");

    virtual void addToolbar(const string& title = "");

    virtual QAction* addToolbarItem(const string& item,
                                    const string& icon = "");

    virtual QAction* addToolbarItem(const string& item,
                                    const string& icon,
                                    GEventListenerVoid func);

    virtual QAction* addToolbarItem(const string& item,
                                    const QIcon& icon,
                                    GEventListenerVoid func);

    virtual QAction* addToolbarItem(const string& item,
                                    const QPixmap& icon,
                                    GEventListenerVoid func);

    virtual QAction* addToolbarSeparator();

    void clear() override;

    virtual void clearCanvas();

    virtual void clearCanvasObjects();

    virtual void clearCanvasPixels();

    virtual void clearRegion(Region region);

    virtual void clearRegion(const string& region);

    virtual void clearToolbarItems();

    virtual void center();

    static string chooseLightDarkModeColor(const string& lightColor,
                                                const string& darkColor);

    static int chooseLightDarkModeColorInt(int lightColor, int darkColor);

    virtual void close();

    virtual void compareToImage(const string& filename, bool ignoreWindowSize = true) const;

    bool eventsEnabled() const override;

    virtual GCanvas* getCanvas() const;

    virtual double getCanvasHeight() const;

    virtual GDimension getCanvasSize() const;

    virtual double getCanvasWidth() const;

    virtual CloseOperation getCloseOperation() const;

    static string getDefaultInteractorBackgroundColor();

    static int getDefaultInteractorBackgroundColorInt();

    static string getDefaultInteractorTextColor();

    static int getDefaultInteractorTextColorInt();

    virtual GObject* getGObject(int index) const;

    virtual GObject* getGObjectAt(double x, double y) const;

    virtual int getGObjectCount() const;

    static QMainWindow* getLastWindow();

    virtual GPoint getLocation() const;

    virtual double getHeight() const;

    virtual GDimension getPreferredSize() const;

    virtual double getRegionHeight(Region region) const;

    virtual double getRegionHeight(const string& region) const;

    virtual GDimension getRegionSize(Region region) const;

    virtual GDimension getRegionSize(const string& region) const;

    virtual double getRegionWidth(Region region) const;

    virtual double getRegionWidth(const string& region) const;

    static int getScreenDpi();

    static double getScreenDpiScaleRatio();

    static double getScreenHeight();

    static GDimension getScreenSize();

    static double getScreenWidth();

    virtual GDimension getSize() const;

    virtual string getTitle() const;

    /* @inherit */
    string getType() const override;

    virtual QWidget* getWidget() const;

    virtual double getWidth() const;

    virtual double getX() const;

    virtual double getY() const;

    virtual bool hasToolbar() const;

    virtual void hide();

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

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

    static bool isDarkMode();

    static bool isHighDensityScreen();

    static bool isHighDpiScalingEnabled();

    virtual bool isMaximized() const;

    virtual bool isMinimized() const;

    virtual bool isOpen() const;

    /* @inherit */
    bool isRepaintImmediately() const override;

    virtual bool isResizable() const;

    virtual bool isVisible() const;

    virtual void loadCanvasPixels(const string& filename);

    virtual void maximize();

    virtual void minimize();

    virtual void pack();

    virtual void pause(double ms);

    virtual void rememberPosition();

    virtual void remove(GInteractor* interactor);

    virtual void remove(GInteractor& interactor);

    virtual void remove(GObject* obj);

    virtual void remove(GObject& obj);

    virtual void removeClickListener();

    virtual void removeFromRegion(GInteractor* interactor, Region region);

    virtual void removeFromRegion(GInteractor* interactor, const string& region);

    virtual void removeFromRegion(GInteractor& interactor, Region region);

    virtual void removeFromRegion(GInteractor& interactor, const string& region);

    virtual void removeKeyListener();

    virtual void removeMenuListener();

    virtual void removeMouseListener();

    virtual void removeTimerListener();

    virtual void removeToolbar();

    virtual void removeWindowListener();

    virtual void requestFocus();

    virtual void restore();

    virtual void saveCanvasPixels(const string& filename);

    /* @inherit */
    void setBackground(int color) override;

    /* @inherit */
    void setBackground(const string& color) override;

    virtual void setCanvasHeight(double height);

    virtual void setCanvasSize(double width, double height);

    virtual void setCanvasSize(const GDimension& size);

    virtual void setCanvasWidth(double width);

    virtual void setClickListener(GEventListener func);

    virtual void setClickListener(GEventListenerVoid func);

    virtual void setCloseOperation(CloseOperation op);

    virtual void setExitOnClose(bool exitOnClose);

    virtual void setHeight(double width);

    virtual void setKeyListener(GEventListener func);

    virtual void setKeyListener(GEventListenerVoid func);

    virtual void setLocation(double x, double y);

    virtual void setLocation(const GPoint& p);

    virtual void setMenuItemEnabled(const string& menu, const string& item, bool enabled);

    virtual void setMenuListener(GEventListener func);

    virtual void setMenuListener(GEventListenerVoid func);

    virtual void setMouseListener(GEventListener func);

    virtual void setMouseListener(GEventListenerVoid func);

    virtual void setRegionAlignment(Region region, HorizontalAlignment halign);

    virtual void setRegionAlignment(Region region, VerticalAlignment valign);

    virtual void setRegionAlignment(Region region, HorizontalAlignment halign, VerticalAlignment valign);

    virtual void setRegionAlignment(const string& region, const string& align);

    virtual void setRegionAlignment(const string& region, const string& halign, const string& valign);

    virtual void setRegionHorizontalAlignment(Region region, HorizontalAlignment halign);

    virtual void setRegionHorizontalAlignment(const string& region, const string& halign);

    virtual void setRegionVerticalAlignment(const string& region, const string& valign);

    virtual void setRegionVerticalAlignment(Region region, VerticalAlignment valign);

    virtual void setResizable(bool resizable);

    virtual void setSize(double width, double height);

    virtual void setSize(const GDimension& size);

    virtual void setTimerListener(double ms, GEventListener func);

    virtual void setTimerListener(double ms, GEventListenerVoid func);

    // TODO: setTimerListenerOnce?

    virtual void setTitle(const string& title);

    virtual void setVisible(bool visible);

    virtual void setWidth(double width);

    virtual void setWindowIcon(const string& iconFile);

    virtual void setWindowListener(GEventListener func);

    virtual void setWindowListener(GEventListenerVoid func);

    virtual void setWindowTitle(const string& title);

    virtual void setX(double x);

    virtual void setY(double y);

    virtual void show();

    virtual void sleep(double ms);

    virtual void toBack();

    virtual void toFront();

protected:
    virtual void processKeyPressEventInternal(QKeyEvent* event);

private:
    Q_DISABLE_COPY(GWindow)

    static _Internal_QMainWindow* _lastWindow;

    void ensureForwardTarget() override;
    void _init(double width, double height, bool visible);
    static Region stringToRegion(const string& regionStr);

    _Internal_QMainWindow* _iqmainwindow;
    GContainer* _contentPane;
    GCanvas* _canvas;
    bool _resizable;
    CloseOperation _closeOperation;
    std::map<string, QMenu*> _menuMap;
    std::map<string, QAction*> _menuActionMap;
    QToolBar* _toolbar;

    friend class GInteractor;
    friend class _Internal_QMainWindow;
};


// global functions for compatibility

int convertColorToRGB(const string& colorName);

string convertRGBToColor(int rgb);

void exitGraphics();

double getScreenHeight();

GDimension getScreenSize();

double getScreenWidth();

void pause(double milliseconds);

void repaint();


class _Internal_QMainWindow : public QMainWindow {
    Q_OBJECT

public:
    _Internal_QMainWindow(GWindow* gwindow, QWidget* parent = nullptr);

    void changeEvent(QEvent* event) override;
    void closeEvent(QCloseEvent* event) override;
    void keyPressEvent(QKeyEvent* event) override;
    void resizeEvent(QResizeEvent* event) override;
    void timerEvent(QTimerEvent* event) override;
    virtual bool timerExists(int id = -1);
    virtual int timerStart(double ms);
    virtual void timerStop(int id = -1);

public slots:
    void handleMenuAction(const string& menu, const string& item);

private:
    GWindow* _gwindow;
    std::set<int> _timerIDs;

    void processTimerEvent();

    friend class GWindow;
};

} // namespace sgl

#endif // _gwindow_h