qgscolorwidgets.h

Go to the documentation of this file.

/***************************************************************************
    qgscolorwidgets.h - color selection widgets
    ---------------------
    begin                : September 2014
    copyright            : (C) 2014 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSCOLORWIDGETS_H
#define QGSCOLORWIDGETS_H
 
#include "qgis_gui.h"
#include "qgis_sip.h"
 
#include <QWidget>
#include <QWidgetAction>
 
class QColor;
class QLineEdit;
class QToolButton;
class QgsDoubleSpinBox;
template<class T> class QgsSettingsEntryEnumFlag;

 
class GUI_EXPORT QgsColorWidget : public QWidget
{
    Q_OBJECT
 
  public:
    enum ColorComponent
    {
      Multiple = 0, 
      Red,          
      Green,        
      Blue,         
      Hue,          
      Saturation,   
      Value,        
      Alpha,        
      Cyan,         
      Magenta,      
      Yellow,       
      Black         
    };

    enum class ComponentUnit
    {
      Scaled0to255, 
      Percent,      
      Degree        
    };
    Q_ENUM( ComponentUnit )
 
    
    QgsColorWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr, ColorComponent component = Multiple );

    QColor color() const;

    ColorComponent component() const { return mComponent; }

    Q_DECL_DEPRECATED int componentValue() const SIP_DEPRECATED;

    float componentValueF() const;

    static QPixmap createDragIcon( const QColor &color );

    static ComponentUnit componentUnit( ColorComponent component );
 
 
  public slots:

    virtual void setColor( const QColor &color, bool emitSignals = false );

    virtual void setComponent( QgsColorWidget::ColorComponent component );

    Q_DECL_DEPRECATED virtual void setComponentValue( int value ) SIP_DEPRECATED;

    virtual void setComponentValueF( float value );
 
  signals:

    void colorChanged( const QColor &color );

    void hovered();
 
  protected:
    QColor mCurrentColor;
 
    ColorComponent mComponent;

    float mExplicitHue = 0;

    int componentRange() const;

    static int componentRange( ColorComponent component );

    Q_DECL_DEPRECATED int componentValue( ColorComponent component ) const SIP_DEPRECATED;

    float componentValueF( ColorComponent component ) const;

    Q_DECL_DEPRECATED int hue() const SIP_DEPRECATED;

    float hueF() const;

    Q_DECL_DEPRECATED static void alterColor( QColor &color, QgsColorWidget::ColorComponent component, int newValue ) SIP_DEPRECATED;

    static void alterColorF( QColor &color, QgsColorWidget::ColorComponent component, float newValue );

    QColor::Spec colorSpec() const;

    static QColor::Spec colorSpec( QgsColorWidget::ColorComponent component );

    static const QPixmap &transparentBackground();
 
    //Reimplemented to accept dragged colors
    void dragEnterEvent( QDragEnterEvent *e ) override;
 
    //Reimplemented to accept dropped colors
    void dropEvent( QDropEvent *e ) override;
 
    void mouseMoveEvent( QMouseEvent *e ) override;
    void mousePressEvent( QMouseEvent *e ) override;
    void mouseReleaseEvent( QMouseEvent *e ) override;
 
    friend class TestQgsCompoundColorWidget;
};
 

 
class GUI_EXPORT QgsColorWidgetAction : public QWidgetAction
{
    Q_OBJECT
 
  public:
    QgsColorWidgetAction( QgsColorWidget *colorWidget, QMenu *menu = nullptr, QWidget *parent SIP_TRANSFERTHIS = nullptr );

    QgsColorWidget *colorWidget() { return mColorWidget; }

    void setDismissOnColorSelection( bool dismiss ) { mDismissOnColorSelection = dismiss; }

    bool dismissOnColorSelection() const { return mDismissOnColorSelection; }
 
  signals:

    void colorChanged( const QColor &color );
 
  private:
    QMenu *mMenu = nullptr;
    QgsColorWidget *mColorWidget = nullptr;
 
    //used to suppress recursion with hover events
    bool mSuppressRecurse = false;
 
    bool mDismissOnColorSelection = true;
 
  private slots:

    void onHover();

    void setColor( const QColor &color );
};
 

 
class GUI_EXPORT QgsColorWheel : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    QgsColorWheel( QWidget *parent SIP_TRANSFERTHIS = nullptr );
 
    ~QgsColorWheel() override;
 
    QSize sizeHint() const override;
    void paintEvent( QPaintEvent *event ) override;
 
  public slots:
 
    void setColor( const QColor &color, bool emitSignals = false ) override;
 
  protected:
    void resizeEvent( QResizeEvent *event ) override;
    void mouseMoveEvent( QMouseEvent *event ) override;
    void mousePressEvent( QMouseEvent *event ) override;
    void mouseReleaseEvent( QMouseEvent *event ) override;
 
  private:
    enum ControlPart
    {
      None,
      Wheel,
      Triangle
    };
 
    bool mIsDragging = false;
 
    /*Margin between outer ring and edge of widget*/
    int mMargin = 4;
 
    /*Thickness of hue ring in pixels*/
    int mWheelThickness = 18;
 
    /*Part of the wheel where the mouse was originally depressed*/
    ControlPart mClickedPart = QgsColorWheel::None;
 
    /*Cached image of hue wheel*/
    QImage mWheelImage;
 
    /*Cached image of inner triangle*/
    QImage mTriangleImage;
 
    /*Resuable, temporary image for drawing widget*/
    QImage mWidgetImage;
 
    /*Whether the color wheel image requires redrawing*/
    bool mWheelDirty = true;
 
    /*Whether the inner triangle image requires redrawing*/
    bool mTriangleDirty = true;
 
    /*Conical gradient brush used for drawing hue wheel*/
    QBrush mWheelBrush;

    void createImages( QSizeF size );

    void createWheel();

    void createTriangle();

    void setColorFromPos( QPointF pos );
};
 

 
class GUI_EXPORT QgsColorBox : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    QgsColorBox( QWidget *parent SIP_TRANSFERTHIS = nullptr, ColorComponent component = Value );
 
    ~QgsColorBox() override;
 
    QSize sizeHint() const override;
    void paintEvent( QPaintEvent *event ) override;
 
    void setComponent( ColorComponent component ) override;
 
  public slots:
    void setColor( const QColor &color, bool emitSignals = false ) override;
 
  protected:
    void resizeEvent( QResizeEvent *event ) override;
    void mouseMoveEvent( QMouseEvent *event ) override;
    void mousePressEvent( QMouseEvent *event ) override;
    void mouseReleaseEvent( QMouseEvent *event ) override;
 
  private:
    bool mIsDragging = false;
 
    /*Margin between outer ring and edge of widget*/
    static constexpr float mMargin = 2.;
 
    /*Cached image for color box*/
    std::unique_ptr<QImage> mBoxImage;
 
    /*Whether the cached image requires redrawing*/
    bool mDirty = true;

    void createBox();

    float valueRangeX() const;

    float valueRangeY() const;

    QgsColorWidget::ColorComponent yComponent() const;

    float yComponentValue() const;

    QgsColorWidget::ColorComponent xComponent() const;

    float xComponentValue() const;

    void setColorFromPoint( QPoint point );
};
 

 
class GUI_EXPORT QgsColorRampWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    enum Orientation
    {
      Horizontal = 0, 
      Vertical        
    };

    QgsColorRampWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr, ColorComponent component = QgsColorWidget::Red, Orientation orientation = QgsColorRampWidget::Horizontal );
 
    QSize sizeHint() const override;
    void paintEvent( QPaintEvent *event ) override;

    void setOrientation( Orientation orientation );

    Orientation orientation() const { return mOrientation; }

    void setInteriorMargin( int margin );

    int interiorMargin() const { return mMargin; }

    void setShowFrame( bool showFrame );

    bool showFrame() const { return mShowFrame; }

    void setMarkerSize( int markerSize );
 
  signals:

    Q_DECL_DEPRECATED void valueChanged( int value ) SIP_DEPRECATED;

    void valueChangedF( float value );
 
  protected:
    void mouseMoveEvent( QMouseEvent *event ) override;
    void wheelEvent( QWheelEvent *event ) override;
    void mousePressEvent( QMouseEvent *event ) override;
    void mouseReleaseEvent( QMouseEvent *event ) override;
    void keyPressEvent( QKeyEvent *event ) override;
 
  private:
    bool mIsDragging = false;
 
    /*Orientation for ramp*/
    Orientation mOrientation;
 
    /*Margin around ramp*/
    int mMargin = 4;
 
    /*Whether to draw a frame around the ramp*/
    bool mShowFrame = false;
 
    /*Polygon for upper triangle marker*/
    QPolygonF mTopTriangle;
 
    /*Polygon for lower triangle marker*/
    QPolygonF mBottomTriangle;

    void setColorFromPoint( QPointF point );
 
    friend class TestQgsCompoundColorWidget;
};
 

 
class GUI_EXPORT QgsColorSliderWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    QgsColorSliderWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr, ColorComponent component = QgsColorWidget::Red );
 
    void setComponent( ColorComponent component ) override;
    void setComponentValueF( float value ) override;
    void setColor( const QColor &color, bool emitSignals = false ) override;
 
  private:
    /*Color ramp widget*/
    QgsColorRampWidget *mRampWidget = nullptr;
 
    /*Spin box widget*/
    QgsDoubleSpinBox *mSpinBox = nullptr;

    float convertRealToDisplay( float realValue ) const;

    float convertDisplayToReal( float displayValue ) const;
 
  private slots:

    void rampColorChanged( const QColor &color );

    void spinChanged( double value );

    void rampChanged( float value );
 
    friend class TestQgsCompoundColorWidget;
};
 

 
class GUI_EXPORT QgsColorTextWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    enum ColorTextFormat
    {
      HexRgb = 0, 
      HexRgbA,    
      Rgb,        
      Rgba        
    };
    Q_ENUM( ColorTextFormat )
 
    static const QgsSettingsEntryEnumFlag<ColorTextFormat> *settingsTextFormat SIP_SKIP;

    QgsColorTextWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr );
 
    void setColor( const QColor &color, bool emitSignals = false ) override;

    void setAllowOpacity( bool allowOpacity );
 
  protected:
    void resizeEvent( QResizeEvent *event ) override;
 
  private:
    QLineEdit *mLineEdit = nullptr;
 
    /*Drop-down menu button*/
    QToolButton *mMenuButton = nullptr;
 
    /*Display format for colors*/
    ColorTextFormat mFormat = QgsColorTextWidget::HexRgb;
 
    bool mAllowAlpha = true;

    void updateText();
 
  private slots:

    void textChanged();

    void showMenu();
};
 

 
class GUI_EXPORT QgsColorPreviewWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    QgsColorPreviewWidget( QWidget *parent SIP_TRANSFERTHIS = nullptr );
 
    void paintEvent( QPaintEvent *event ) override;
    QSize sizeHint() const override;

    QColor color2() const { return mColor2; }
 
  public slots:

    virtual void setColor2( const QColor &color );
 
  protected:
    //reimplemented to allow dragging colors
    void mousePressEvent( QMouseEvent *e ) override;
 
    //reimplemented to click colors
    void mouseReleaseEvent( QMouseEvent *e ) override;
 
    //reimplemented to allow dragging colors
    void mouseMoveEvent( QMouseEvent *e ) override;
 
  private:
    /*Secondary color for widget*/
    QColor mColor2;
 
    QPoint mDragStartPosition;
 
    /*Draws a color preview within the specified rect.
     * \param color color to draw
     * \param rect rect to draw color in
     * \param painter destination painter
     */
    void drawColor( const QColor &color, QRect rect, QPainter &painter );
};
 
#endif // #ifndef QGSCOLORWIDGETS_H