CustomColorDialogWidgets.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/QCustomLineEdit.h>
#include <QWidget>
#include <QColorDialog>
#include <QPointer>
#include <QWindow>
class QGridLayout;
class QTimer;
class QVBoxLayout;
namespace NDEVR
{
    class QCustomColorDialog;
    class QColorLuminancePicker;
    class QColorPicker;
    class QColorShower;
    class QWellArray;
    class Button;
    class QColorPickingEventFilter;
    class QCustomLabel;
    class QColorShowLabel;
    class QWellArray : public QWidget
    {
        Q_OBJECT
        Q_PROPERTY(int selectedColumn READ selectedColumn)
        Q_PROPERTY(int selectedRow READ selectedRow)
    public:
        QWellArray(int rows, int cols, QWidget* parent = 0);
        ~QWellArray() {}
        QString cellContent(int row, int col) const;
        int selectedColumn() const { return selCol; }
        int selectedRow() const { return selRow; }
        virtual void setCurrent(int row, int col);
        virtual void setSelected(int row, int col);
        virtual QSize minimumSizeHint() const override { return QSize(5, 5); }
        QSize sizeHint() const override;
        inline int cellWidth() const
        {
            return getMax(1, width() / numCols());
        }
        inline int cellHeight() const
        {
            return getMax(1, height() / numRows());
        }
        inline int rowAt(fltp04 y) const
        {
            return cast<int>(y / cellHeight());
        }
        inline int columnAt(fltp04 x) const
        {
            if (isRightToLeft())
                return ncols - (x / cellWidth()) - 1;
            return cast<int>(x / cellWidth());
        }
        inline int rowY(int row) const
        {
            return cellHeight() * row;
        }
        inline int columnX(int column) const
        {
            if (isRightToLeft())
                return cellWidth() * (ncols - column - 1);
            return cellWidth() * column;
        }
        inline int numRows() const
        {
            return nrows;
        }
        inline int numCols() const
        {
            return ncols;
        }
        inline QRect cellRect() const
        {
            return QRect(0, 0, cellWidth(), cellHeight());
        }
        inline QSize gridSize() const
        {
            return QSize(ncols * cellWidth(), nrows * cellHeight());
        }
        QRect cellGeometry(int row, int column)
        {
            QRect r;
            if (row >= 0 && row < nrows && column >= 0 && column < ncols)
                r.setRect(columnX(column), rowY(row), cellWidth(), cellHeight());
            return r;
        }
        inline void updateCell(int row, int column) { update(cellGeometry(row, column)); }
    signals:
        void selected(int row, int col);
        void currentChanged(int row, int col);
        void colorChanged(int index, QRgb color);
    protected:
        virtual void paintCell(QPainter*, int row, int col, const QRect&);
        virtual void paintCellContents(QPainter*, int row, int col, const QRect&);
        void mousePressEvent(QMouseEvent*) override;
        void mouseReleaseEvent(QMouseEvent*) override;
        void keyPressEvent(QKeyEvent*) override;
        void focusInEvent(QFocusEvent*) override;
        void focusOutEvent(QFocusEvent*) override;
        void paintEvent(QPaintEvent*) override;
    private:
        Q_DISABLE_COPY(QWellArray)
            int nrows;
        int ncols;
        int curRow;
        int curCol;
        int selRow;
        int selCol;
    };
    class QColorLuminancePicker : public QWidget
    {
        Q_OBJECT
    public:
        QColorLuminancePicker(QWidget* parent = 0);
        ~QColorLuminancePicker();
        virtual QSize minimumSizeHint() const override { return QSize(5, 5); }
    public slots:
        void setCol(int h, int s, int v);
        void setCol(int h, int s);
    signals:
        void newHsv(int h, int s, int v);
    protected:
        void paintEvent(QPaintEvent*) override;
        void mouseMoveEvent(QMouseEvent*) override;
        void mousePressEvent(QMouseEvent*) override;
    private:
        enum { foff = 3, coff = 4 }; //frame and contents offset
        int val;
        int hue;
        int sat;
        int y2val(int y);
        int val2y(int val);
        void setVal(int v);
        QPixmap* pix;
    };
 
    class QColorPicker : public QFrame
    {
        Q_OBJECT
    public:
        QColorPicker(QWidget* parent);
        ~QColorPicker();
        void setCrossVisible(bool visible);
        virtual QSize minimumSizeHint() const override { return QSize(5, 5); }
    public slots:
        void setCol(int h, int s);
    signals:
        void newCol(int h, int s);
    protected:
        QSize sizeHint() const override;
        void paintEvent(QPaintEvent*) override;
        void mouseMoveEvent(QMouseEvent*) override;
        void mousePressEvent(QMouseEvent*) override;
        void resizeEvent(QResizeEvent*) override;
    private:
        int hue;
        int sat;
        QPoint colPt(int width, int height);
        int huePt(const QPoint& pt, int width, int height);
        int satPt(const QPoint& pt, int width, int height);
        void setCol(const QPoint& pt, int width, int height);
        QPixmap pix;
        bool crossVisible;
    };
    class QColorValueBox : public QCustomLineEdit
    {
    public:
        QColorValueBox(QWidget* parent)
            : QCustomLineEdit(parent)
        {
            setup<uint02>(_t("Color Channel"));
            customValidator().setMin(0);
            customValidator().setMax(255);
        }
    };
    class QColorShower : public QWidget
    {
        Q_OBJECT
    public:
        QColorShower(QCustomColorDialog* parent, bool small_display);
        //things that don't emit signals
        void setHsv(int h, int s, int v);
        int currentAlpha() const;
        void setCurrentAlpha(int a);
        void showAlpha(bool b);
        bool isAlphaVisible() const;
        QRgb currentColor() const { return curCol; }
        QColor currentQColor() const { return curQColor; }
        void retranslateStrings();
        void updateQColor();
        void addWidget(QWidget* widget);
    public slots:
        void setRgb(QRgb rgb);
    signals:
        void newCol(QRgb rgb);
        void currentColorChanged(const QColor& color);
    private slots:
        void rgbEd();
        void hsvEd();
        void htmlEd();
    public:
        void showCurrentColor();
        int hue, sat, val;
        QRgb curCol;
        QColor curQColor;
        QLabel* lblHue;
        QLabel* lblSat;
        QLabel* lblVal;
        QLabel* lblRed;
        QLabel* lblGreen;
        QLabel* lblBlue;
        QLabel* lblHtml;
        QColorValueBox* hEd;
        QColorValueBox* sEd;
        QColorValueBox* vEd;
        QColorValueBox* rEd;
        QColorValueBox* gEd;
        QColorValueBox* bEd;
        QColorValueBox* alphaEd;
        QLabel* alphaLab;
        QCustomLineEdit* htEd;
        QColorShowLabel* color_show_label;
        bool rgbOriginal;
        QCustomColorDialog* colorDialog;
        QGridLayout* gl;
    };
    class QColorShowLabel : public QFrame
    {
        Q_OBJECT
    public:
        QColorShowLabel(QWidget* parent) : QFrame(parent) {
            setFrameStyle(QFrame::Panel | QFrame::Sunken);
            setAcceptDrops(true);
            mousePressed = false;
        }
        void setColor(QColor c) { col = c; }
    signals:
        void colorDropped(QRgb);
    protected:
        void paintEvent(QPaintEvent*) override;
        void mousePressEvent(QMouseEvent* e) override;
        void mouseMoveEvent(QMouseEvent* e) override;
        void mouseReleaseEvent(QMouseEvent* e) override;
#if QT_CONFIG(draganddrop)
        void dragEnterEvent(QDragEnterEvent* e) override;
        void dragLeaveEvent(QDragLeaveEvent* e) override;
        void dropEvent(QDropEvent* e) override;
#endif
    private:
        QColor col;
        bool mousePressed;
        QPoint pressPos;
    };
 
    class QCustomColorDialogPrivate : public QObject
    {
        Q_OBJECT
    public:
        enum SetColorMode {
            ShowColor = 0x1,
            SelectColor = 0x2,
            SetColorAll = ShowColor | SelectColor
        };
        QCustomColorDialogPrivate(QCustomColorDialog* dialog);
        void init(const QColor& initial);
        void initWidgets();
        QRgb currentColor() const;
        QColor currentQColor() const;
        void setCurrentColor(const QColor& color, SetColorMode setColorMode = SetColorAll);
        void setCurrentRgbColor(QRgb rgb);
        bool selectColor(const QColor& color);
        QColor grabScreenColor(const QPointF& p);
        int currentAlpha() const;
        void setCurrentAlpha(int a);
        void showAlpha(bool b);
        bool isAlphaVisible() const;
        void retranslateStrings();
    public slots:
        void _q_addCustom();
        void _q_newHsv(int h, int s, int v);
        void _q_newColorTypedIn(QRgb rgb);
        void _q_nextCustom(int, int);
        void _q_newCustom(int, int);
        void _q_newStandard(int, int);
        void _q_pickScreenColor();
        void _q_updateColorPicking();
    public:
        void updateColorPicking(const QPointF& pos);
        void releaseColorPicking();
        bool handleColorPickingMouseMove(QMouseEvent* e);
        bool handleColorPickingMouseButtonRelease(QMouseEvent* e);
        bool handleColorPickingKeyPress(QKeyEvent* e);
 
        QRgb beforeScreenColorPicking;
        QColorDialog::ColorDialogOptions options;
        QPointer<QObject> receiverToDisconnectOnClose;
        QColor selected_color;
        int next_cust;
 
        QWellArray* custom = nullptr;
        QWellArray* standard = nullptr;
        QVBoxLayout* m_right_layout = nullptr;
        QWidget* m_button_widget = nullptr;
        QColorPicker* cp = nullptr;
        QColorLuminancePicker* lp = nullptr;
        QColorShower* m_color_shower = nullptr;
        QCustomLabel* lbl_basic_colors = nullptr;
        QCustomLabel* lbl_custom_colors = nullptr;
        Button* m_ok_button = nullptr;
        Button* m_cancel_button = nullptr;
        Button* add_custom_color_button = nullptr;
        Button* screen_color_picker_button = nullptr;
        QColorPickingEventFilter* colorPickingEventFilter;
        
        QByteArray memberToDisconnectOnClose;
        QCustomColorDialog* q;
#ifdef Q_OS_WIN32
        QTimer* update_timer;
        QWindow dummyTransparentWindow;
#endif
        bool smallDisplay;
        bool screenColorPicking;
    };
}