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 <QWidgetAction>
#include <QWidget>
#include "qgis_gui.h"
#include "qgis_sip.h"
 
class QColor;
class QLineEdit;
class QToolButton;
class QgsDoubleSpinBox;
 
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 ColorComponent {…};
 
    enum class ComponentUnit
    {
      Scaled0to255, 
      Percent,      
      Degree        
    };
    enum class ComponentUnit {…};
    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 QgsColorWidget : public QWidget {…};
 
 
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;
 
    bool mDismissOnColorSelection;
 
  private slots:
 
    void onHover();
 
    void setColor( const QColor &color );
};
class GUI_EXPORT QgsColorWidgetAction : public QWidgetAction {…};
 
 
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 QgsColorWheel : public QgsColorWidget {…};
 
 
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*/
    QImage *mBoxImage = nullptr;
 
    /*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 QgsColorBox : public QgsColorWidget {…};
 
 
class GUI_EXPORT QgsColorRampWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    enum Orientation
    {
      Horizontal = 0, 
      Vertical        
    };
    enum Orientation {…};
 
    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 QgsColorRampWidget : public QgsColorWidget {…};
 
 
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 QgsColorSliderWidget : public QgsColorWidget {…};
 
 
class GUI_EXPORT QgsColorTextWidget : public QgsColorWidget
{
    Q_OBJECT
 
  public:
    enum ColorTextFormat
    {
      HexRgb = 0, 
      HexRgbA,    
      Rgb,        
      Rgba        
    };
    enum ColorTextFormat {…};
    Q_ENUM( ColorTextFormat )
 
    
    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 QgsColorTextWidget : public QgsColorWidget {…};
 
 
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 );
};
class GUI_EXPORT QgsColorPreviewWidget : public QgsColorWidget {…};
 
#endif // #ifndef QGSCOLORWIDGETS_H