QGIS API Documentation  3.23.0-Master (dd0cd13a00)
qgscolorbutton.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgscolorbutton.cpp - Button which displays a color
3  --------------------------------------
4  Date : 12-Dec-2006
5  Copyright : (C) 2006 by Tom Elwertowski
6  Email : telwertowski at users dot sourceforge dot net
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 
16 #include "qgscolorbutton.h"
17 #include "qgscolordialog.h"
18 #include "qgsapplication.h"
19 #include "qgslogger.h"
20 #include "qgssymbollayerutils.h"
21 #include "qgscolorswatchgrid.h"
22 #include "qgscolorschemeregistry.h"
23 #include "qgscolorwidgets.h"
24 #include "qgssettings.h"
25 #include "qgsproject.h"
26 #include "qgsguiutils.h"
27 #include "qgsgui.h"
28 
29 #include <QPainter>
30 #include <QMouseEvent>
31 #include <QMenu>
32 #include <QClipboard>
33 #include <QDrag>
34 #include <QStyle>
35 #include <QStyleOptionToolButton>
36 #include <QWidgetAction>
37 #include <QScreen>
38 #include <QLabel>
39 #include <QGridLayout>
40 #include <QPushButton>
41 #include <QBuffer>
42 
43 QgsColorButton::QgsColorButton( QWidget *parent, const QString &cdt, QgsColorSchemeRegistry *registry )
44  : QToolButton( parent )
45  , mColorDialogTitle( cdt.isEmpty() ? tr( "Select Color" ) : cdt )
46  , mNoColorString( tr( "No color" ) )
47 {
48  //if a color scheme registry was specified, use it, otherwise use the global instance
49  mColorSchemeRegistry = registry ? registry : QgsApplication::colorSchemeRegistry();
50 
51  setAcceptDrops( true );
52  setMinimumSize( QSize( 24, 16 ) );
53  connect( this, &QAbstractButton::clicked, this, &QgsColorButton::buttonClicked );
54 
55  //setup drop-down menu
56  mMenu = new QMenu( this );
57  connect( mMenu, &QMenu::aboutToShow, this, &QgsColorButton::prepareMenu );
58  setMenu( mMenu );
59  setPopupMode( QToolButton::MenuButtonPopup );
60 
61 #ifdef Q_OS_WIN
62  mMinimumSize = QSize( 120, 22 );
63 #else
64  mMinimumSize = QSize( 120, 28 );
65 #endif
66 
67  mMinimumSize.setHeight( std::max( static_cast<int>( Qgis::UI_SCALE_FACTOR * fontMetrics().height() * 1.1 ), mMinimumSize.height() ) );
68 
69  // If project colors change, we need to redraw the button, as it may be set to follow a project color
71  {
73  } );
74 }
75 
77 {
78  return mMinimumSize;
79 }
80 
82 {
83  return mMinimumSize;
84 }
85 
87 {
88  static QPixmap sTranspBkgrd;
89 
90  if ( sTranspBkgrd.isNull() )
91  sTranspBkgrd = QgsApplication::getThemePixmap( QStringLiteral( "/transp-background_8x8.png" ) );
92 
93  return sTranspBkgrd;
94 }
95 
96 void QgsColorButton::showColorDialog()
97 {
99  if ( panel && panel->dockMode() )
100  {
101  const QColor currentColor = color();
103  colorWidget->setPanelTitle( mColorDialogTitle );
104  colorWidget->setAllowOpacity( mAllowOpacity );
105 
106  if ( currentColor.isValid() )
107  {
108  colorWidget->setPreviousColor( currentColor );
109  }
110 
111  connect( colorWidget, &QgsCompoundColorWidget::currentColorChanged, this, &QgsColorButton::setValidTemporaryColor );
112  panel->openPanel( colorWidget );
113  return;
114  }
115 
116  QColor newColor;
117  const QgsSettings settings;
118 
119  // first check if we need to use the limited native dialogs
120  const bool useNative = settings.value( QStringLiteral( "qgis/native_color_dialogs" ), false ).toBool();
121  if ( useNative )
122  {
123  // why would anyone want this? who knows.... maybe the limited nature of native dialogs helps ease the transition for MapInfo users?
124  newColor = QColorDialog::getColor( color(), this, mColorDialogTitle, mAllowOpacity ? QColorDialog::ShowAlphaChannel : ( QColorDialog::ColorDialogOption )0 );
125  }
126  else
127  {
128  QgsColorDialog dialog( this, Qt::WindowFlags(), color() );
129  dialog.setTitle( mColorDialogTitle );
130  dialog.setAllowOpacity( mAllowOpacity );
131 
132  if ( dialog.exec() )
133  {
134  newColor = dialog.color();
135  }
136  }
137 
138  if ( newColor.isValid() )
139  {
140  setValidColor( newColor );
141  }
142 
143  // reactivate button's window
144  activateWindow();
145 }
146 
148 {
149  if ( !mDefaultColor.isValid() )
150  {
151  return;
152  }
153 
154  setColor( mDefaultColor );
155 }
156 
158 {
159  setColor( QColor() );
160  emit cleared();
161 }
162 
164 {
165  linkToProjectColor( QString() );
166  emit unlinked();
167 }
168 
169 bool QgsColorButton::event( QEvent *e )
170 {
171  if ( e->type() == QEvent::ToolTip )
172  {
173  QColor c = linkedProjectColor();
174  const bool isProjectColor = c.isValid();
175  if ( !isProjectColor )
176  c = mColor;
177 
178  const QString name = c.name();
179  const int hue = c.hue();
180  const int value = c.value();
181  const int saturation = c.saturation();
182 
183  // create very large preview swatch
184  const int width = static_cast< int >( Qgis::UI_SCALE_FACTOR * fontMetrics().horizontalAdvance( 'X' ) * 23 );
185  const int height = static_cast< int >( width / 1.61803398875 ); // golden ratio
186 
187  const int margin = static_cast< int >( height * 0.1 );
188  QImage icon = QImage( width + 2 * margin, height + 2 * margin, QImage::Format_ARGB32 );
189  icon.fill( Qt::transparent );
190 
191  QPainter p;
192  p.begin( &icon );
193 
194  //start with checkboard pattern
195  const QBrush checkBrush = QBrush( transparentBackground() );
196  p.setPen( Qt::NoPen );
197  p.setBrush( checkBrush );
198  p.drawRect( margin, margin, width, height );
199 
200  //draw color over pattern
201  p.setBrush( QBrush( c ) );
202 
203  //draw border
204  p.setPen( QColor( 197, 197, 197 ) );
205  p.drawRect( margin, margin, width, height );
206  p.end();
207 
208  QByteArray data;
209  QBuffer buffer( &data );
210  icon.save( &buffer, "PNG", 100 );
211 
212  const QString info = ( isProjectColor ? QStringLiteral( "<p>%1: %2</p>" ).arg( tr( "Linked color" ), mLinkedColorName ) : QString() )
213  + QStringLiteral( "<b>HEX</b> %1<br>"
214  "<b>RGB</b> %2<br>"
215  "<b>HSV</b> %3,%4,%5<p>"
216  "<img src='data:image/png;base64, %0'>" ).arg( QString( data.toBase64() ), name,
218  .arg( hue ).arg( saturation ).arg( value );
219  setToolTip( info );
220  }
221  return QToolButton::event( e );
222 }
223 
225 {
226  QColor noColor = QColor( mColor );
227  noColor.setAlpha( 0 );
228  setColor( noColor );
229 }
230 
231 void QgsColorButton::mousePressEvent( QMouseEvent *e )
232 {
233  if ( mPickingColor )
234  {
235  //don't show dialog if in color picker mode
236  e->accept();
237  return;
238  }
239 
240  if ( e->button() == Qt::RightButton )
241  {
242  QToolButton::showMenu();
243  return;
244  }
245  else if ( e->button() == Qt::LeftButton )
246  {
247  mDragStartPosition = e->pos();
248  }
249  QToolButton::mousePressEvent( e );
250 }
251 
252 bool QgsColorButton::colorFromMimeData( const QMimeData *mimeData, QColor &resultColor )
253 {
254  bool hasAlpha = false;
255  QColor mimeColor = QgsSymbolLayerUtils::colorFromMimeData( mimeData, hasAlpha );
256 
257  if ( mimeColor.isValid() )
258  {
259  if ( !mAllowOpacity )
260  {
261  //remove alpha channel
262  mimeColor.setAlpha( 255 );
263  }
264  else if ( !hasAlpha )
265  {
266  //mime color has no explicit alpha component, so keep existing alpha
267  mimeColor.setAlpha( mColor.alpha() );
268  }
269  resultColor = mimeColor;
270  return true;
271  }
272 
273  //could not get color from mime data
274  return false;
275 }
276 
277 void QgsColorButton::mouseMoveEvent( QMouseEvent *e )
278 {
279  if ( mPickingColor )
280  {
281  setButtonBackground( QgsGui::sampleColor( e->globalPos() ) );
282  e->accept();
283  return;
284  }
285 
286  //handle dragging colors from button
287  QColor c = linkedProjectColor();
288  if ( !c.isValid() )
289  c = mColor;
290 
291  if ( !( e->buttons() & Qt::LeftButton ) || !c.isValid() )
292  {
293  //left button not depressed or no color set, so not a drag
294  QToolButton::mouseMoveEvent( e );
295  return;
296  }
297 
298  if ( ( e->pos() - mDragStartPosition ).manhattanLength() < QApplication::startDragDistance() )
299  {
300  //mouse not moved, so not a drag
301  QToolButton::mouseMoveEvent( e );
302  return;
303  }
304 
305  //user is dragging color
306  QDrag *drag = new QDrag( this );
307  drag->setMimeData( QgsSymbolLayerUtils::colorToMimeData( c ) );
308  drag->setPixmap( QgsColorWidget::createDragIcon( c ) );
309  drag->exec( Qt::CopyAction );
310  setDown( false );
311 }
312 
313 void QgsColorButton::mouseReleaseEvent( QMouseEvent *e )
314 {
315  if ( mPickingColor )
316  {
317  //end color picking operation by sampling the color under cursor
318  stopPicking( e->globalPos() );
319  e->accept();
320  return;
321  }
322 
323  QToolButton::mouseReleaseEvent( e );
324 }
325 
326 void QgsColorButton::stopPicking( QPoint eventPos, bool samplingColor )
327 {
328  //release mouse and keyboard, and reset cursor
329  releaseMouse();
330  releaseKeyboard();
331  QgsApplication::restoreOverrideCursor();
332  setMouseTracking( false );
333  mPickingColor = false;
334 
335  if ( !samplingColor )
336  {
337  //not sampling color, restore old color
339  return;
340  }
341 
342  setColor( QgsGui::sampleColor( eventPos ) );
343  addRecentColor( mColor );
344 }
345 
346 QColor QgsColorButton::linkedProjectColor() const
347 {
348  QList<QgsProjectColorScheme *> projectSchemes;
349  QgsApplication::colorSchemeRegistry()->schemes( projectSchemes );
350  if ( projectSchemes.length() > 0 )
351  {
352  QgsProjectColorScheme *scheme = projectSchemes.at( 0 );
353  const QgsNamedColorList colors = scheme->fetchColors();
354  for ( const auto &color : colors )
355  {
356  if ( color.second.isEmpty() )
357  continue;
358 
359  if ( color.second == mLinkedColorName )
360  {
361  return color.first;
362  }
363  }
364  }
365  return QColor();
366 }
367 
368 void QgsColorButton::keyPressEvent( QKeyEvent *e )
369 {
370  if ( !mPickingColor )
371  {
372  //if not picking a color, use default tool button behavior
373  QToolButton::keyPressEvent( e );
374  return;
375  }
376 
377  //cancel picking, sampling the color if space was pressed
378  stopPicking( QCursor::pos(), e->key() == Qt::Key_Space );
379 }
380 
381 void QgsColorButton::dragEnterEvent( QDragEnterEvent *e )
382 {
383  const bool isProjectColor = linkedProjectColor().isValid();
384  if ( isProjectColor )
385  return;
386 
387  //is dragged data valid color data?
388  QColor mimeColor;
389  if ( colorFromMimeData( e->mimeData(), mimeColor ) )
390  {
391  //if so, we accept the drag, and temporarily change the button's color
392  //to match the dragged color. This gives immediate feedback to the user
393  //that colors can be dropped here
394  e->acceptProposedAction();
395  setButtonBackground( mimeColor );
396  }
397 }
398 
399 void QgsColorButton::dragLeaveEvent( QDragLeaveEvent *e )
400 {
401  Q_UNUSED( e )
402  //reset button color
404 }
405 
406 void QgsColorButton::dropEvent( QDropEvent *e )
407 {
408  const bool isProjectColor = linkedProjectColor().isValid();
409  if ( isProjectColor )
410  return;
411 
412  //is dropped data valid color data?
413  QColor mimeColor;
414  if ( colorFromMimeData( e->mimeData(), mimeColor ) )
415  {
416  //accept drop and set new color
417  e->acceptProposedAction();
418  setColor( mimeColor );
419  addRecentColor( mimeColor );
420  }
421 }
422 
423 void QgsColorButton::setValidColor( const QColor &newColor )
424 {
425  if ( newColor.isValid() )
426  {
427  setColor( newColor );
428  addRecentColor( newColor );
429  }
430 }
431 
432 void QgsColorButton::setValidTemporaryColor( const QColor &newColor )
433 {
434  if ( newColor.isValid() )
435  {
436  setColor( newColor );
437  }
438 }
439 
440 QPixmap QgsColorButton::createMenuIcon( const QColor &color, const bool showChecks )
441 {
442  const int iconSize = QgsGuiUtils::scaleIconSize( 16 );
443 
444  //create an icon pixmap
445  QPixmap pixmap( iconSize, iconSize );
446  pixmap.fill( Qt::transparent );
447 
448  QPainter p;
449  p.begin( &pixmap );
450 
451  //start with checkboard pattern
452  if ( showChecks )
453  {
454  const QBrush checkBrush = QBrush( transparentBackground() );
455  p.setPen( Qt::NoPen );
456  p.setBrush( checkBrush );
457  p.drawRect( 0, 0, iconSize - 1, iconSize - 1 );
458  }
459 
460  //draw color over pattern
461  p.setBrush( QBrush( color ) );
462 
463  //draw border
464  p.setPen( QColor( 197, 197, 197 ) );
465  p.drawRect( 0, 0, iconSize - 1, iconSize - 1 );
466  p.end();
467  return pixmap;
468 }
469 
470 void QgsColorButton::buttonClicked()
471 {
472  if ( linkedProjectColor().isValid() )
473  {
474  QToolButton::showMenu();
475  }
476  else
477  {
478  switch ( mBehavior )
479  {
480  case ShowDialog:
481  showColorDialog();
482  return;
483  case SignalOnly:
484  emit colorClicked( mColor );
485  return;
486  }
487  }
488 }
489 
490 void QgsColorButton::prepareMenu()
491 {
492  //we need to tear down and rebuild this menu every time it is shown. Otherwise the space allocated to any
493  //QgsColorSwatchGridAction is not recalculated by Qt and the swatch grid may not be the correct size
494  //for the number of colors shown in the grid. Note that we MUST refresh color swatch grids every time this
495  //menu is opened, otherwise color schemes like the recent color scheme grid are meaningless
496  mMenu->clear();
497 
498  const bool isProjectColor = linkedProjectColor().isValid();
499 
500  if ( !isProjectColor )
501  {
502  if ( mShowNull )
503  {
504  QAction *nullAction = new QAction( mNullColorString.isEmpty() ? tr( "Clear Color" ) : mNullColorString, this );
505  nullAction->setIcon( createMenuIcon( Qt::transparent, false ) );
506  mMenu->addAction( nullAction );
507  connect( nullAction, &QAction::triggered, this, &QgsColorButton::setToNull );
508  }
509 
510  //show default color option if set
511  if ( mDefaultColor.isValid() )
512  {
513  QAction *defaultColorAction = new QAction( tr( "Default Color" ), this );
514  defaultColorAction->setIcon( createMenuIcon( mDefaultColor ) );
515  mMenu->addAction( defaultColorAction );
516  connect( defaultColorAction, &QAction::triggered, this, &QgsColorButton::setToDefaultColor );
517  }
518 
519  if ( mShowNoColorOption )
520  {
521  QAction *noColorAction = new QAction( mNoColorString, this );
522  noColorAction->setIcon( createMenuIcon( Qt::transparent, false ) );
523  mMenu->addAction( noColorAction );
524  connect( noColorAction, &QAction::triggered, this, &QgsColorButton::setToNoColor );
525  }
526 
527  mMenu->addSeparator();
528  QgsColorWheel *colorWheel = new QgsColorWheel( mMenu );
529  colorWheel->setColor( color() );
530  QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, mMenu, mMenu );
531  colorAction->setDismissOnColorSelection( false );
532  connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsColorButton::setColor );
533  mMenu->addAction( colorAction );
534  if ( mAllowOpacity )
535  {
537  alphaRamp->setColor( color() );
538  QgsColorWidgetAction *alphaAction = new QgsColorWidgetAction( alphaRamp, mMenu, mMenu );
539  alphaAction->setDismissOnColorSelection( false );
540  connect( alphaAction, &QgsColorWidgetAction::colorChanged, this, &QgsColorButton::setColor );
541  connect( alphaAction, &QgsColorWidgetAction::colorChanged, colorWheel, [colorWheel]( const QColor & color ) { colorWheel->setColor( color, false ); }
542  );
543  connect( colorAction, &QgsColorWidgetAction::colorChanged, alphaRamp, [alphaRamp]( const QColor & color ) { alphaRamp->setColor( color, false ); }
544  );
545  mMenu->addAction( alphaAction );
546  }
547 
548  if ( mColorSchemeRegistry )
549  {
550  //get schemes with ShowInColorButtonMenu flag set
551  QList< QgsColorScheme * > schemeList = mColorSchemeRegistry->schemes( QgsColorScheme::ShowInColorButtonMenu );
552  QList< QgsColorScheme * >::iterator it = schemeList.begin();
553  for ( ; it != schemeList.end(); ++it )
554  {
555  QgsColorSwatchGridAction *colorAction = new QgsColorSwatchGridAction( *it, mMenu, mContext, this );
556  colorAction->setBaseColor( mColor );
557  mMenu->addAction( colorAction );
558  connect( colorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsColorButton::setValidColor );
559  connect( colorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsColorButton::addRecentColor );
560  }
561  }
562 
563  mMenu->addSeparator();
564  }
565 
566  if ( isProjectColor )
567  {
568  QAction *unlinkAction = new QAction( tr( "Unlink Color" ), mMenu );
569  mMenu->addAction( unlinkAction );
570  connect( unlinkAction, &QAction::triggered, this, &QgsColorButton::unlink );
571  }
572 
573  QAction *copyColorAction = new QAction( tr( "Copy Color" ), this );
574  mMenu->addAction( copyColorAction );
575  connect( copyColorAction, &QAction::triggered, this, &QgsColorButton::copyColor );
576 
577  if ( !isProjectColor )
578  {
579  QAction *pasteColorAction = new QAction( tr( "Paste Color" ), this );
580  //enable or disable paste action based on current clipboard contents. We always show the paste
581  //action, even if it's disabled, to give hint to the user that pasting colors is possible
582  QColor clipColor;
583  if ( colorFromMimeData( QApplication::clipboard()->mimeData(), clipColor ) )
584  {
585  pasteColorAction->setIcon( createMenuIcon( clipColor ) );
586  }
587  else
588  {
589  pasteColorAction->setEnabled( false );
590  }
591  mMenu->addAction( pasteColorAction );
592  connect( pasteColorAction, &QAction::triggered, this, &QgsColorButton::pasteColor );
593 
594  QAction *pickColorAction = new QAction( tr( "Pick Color" ), this );
595  mMenu->addAction( pickColorAction );
596  connect( pickColorAction, &QAction::triggered, this, &QgsColorButton::activatePicker );
597 
598  QAction *chooseColorAction = new QAction( tr( "Choose Color…" ), this );
599  mMenu->addAction( chooseColorAction );
600  connect( chooseColorAction, &QAction::triggered, this, &QgsColorButton::showColorDialog );
601  }
602 }
603 
605 {
606  if ( e->type() == QEvent::EnabledChange )
607  {
609  }
610  QToolButton::changeEvent( e );
611 }
612 
613 #if 0 // causes too many cyclical updates, but may be needed on some platforms
614 void QgsColorButton::paintEvent( QPaintEvent *e )
615 {
616  QToolButton::paintEvent( e );
617 
618  if ( !mBackgroundSet )
619  {
621  }
622 }
623 #endif
624 
625 void QgsColorButton::showEvent( QShowEvent *e )
626 {
628  QToolButton::showEvent( e );
629 }
630 
631 void QgsColorButton::resizeEvent( QResizeEvent *event )
632 {
633  QToolButton::resizeEvent( event );
634  //recalculate icon size and redraw icon
635  mIconSize = QSize();
637 }
638 
639 void QgsColorButton::setColor( const QColor &color )
640 {
641  const QColor oldColor = mColor;
642  mColor = color;
643 
644  // handle when initially set color is same as default (Qt::black); consider it a color change
645  if ( oldColor != mColor || ( mColor == QColor( Qt::black ) && !mColorSet ) )
646  {
648  if ( isEnabled() )
649  {
650  // TODO: May be beneficial to have the option to set color without emitting this signal.
651  // Now done by blockSignals( bool ) where button is used
652  emit colorChanged( mColor );
653  }
654  }
655  mColorSet = true;
656 }
657 
658 void QgsColorButton::addRecentColor( const QColor &color )
659 {
661 }
662 
663 void QgsColorButton::setButtonBackground( const QColor &color )
664 {
665  QColor backgroundColor = color;
666  bool isProjectColor = false;
667  if ( !backgroundColor.isValid() && !mLinkedColorName.isEmpty() )
668  {
669  backgroundColor = linkedProjectColor();
670  isProjectColor = backgroundColor.isValid();
671  if ( !isProjectColor )
672  {
673  mLinkedColorName.clear(); //color has been deleted, renamed, etc...
674  emit unlinked();
675  }
676  }
677  if ( !backgroundColor.isValid() )
678  {
679  backgroundColor = mColor;
680  }
681 
682  QSize currentIconSize;
683  //icon size is button size with a small margin
684  if ( menu() )
685  {
686  if ( !mIconSize.isValid() )
687  {
688  //calculate size of push button part of widget (ie, without the menu drop-down button part)
689  QStyleOptionToolButton opt;
690  initStyleOption( &opt );
691  const QRect buttonSize = QApplication::style()->subControlRect( QStyle::CC_ToolButton, &opt, QStyle::SC_ToolButton,
692  this );
693  //make sure height of icon looks good under different platforms
694 #ifdef Q_OS_WIN
695  mIconSize = QSize( buttonSize.width() - 10, height() - 6 );
696 #else
697  mIconSize = QSize( buttonSize.width() - 10, height() - 12 );
698 #endif
699  }
700  currentIconSize = mIconSize;
701  }
702  else
703  {
704  //no menu
705 #ifdef Q_OS_WIN
706  currentIconSize = QSize( width() - 10, height() - 6 );
707 #else
708  currentIconSize = QSize( width() - 10, height() - 12 );
709 #endif
710  }
711 
712  if ( !currentIconSize.isValid() || currentIconSize.width() <= 0 || currentIconSize.height() <= 0 )
713  {
714  return;
715  }
716 
717  //create an icon pixmap
718  QPixmap pixmap( currentIconSize );
719  pixmap.fill( Qt::transparent );
720 
721  if ( backgroundColor.isValid() )
722  {
723  const QRect rect( 0, 0, currentIconSize.width(), currentIconSize.height() );
724  QPainter p;
725  p.begin( &pixmap );
726  p.setRenderHint( QPainter::Antialiasing );
727  p.setPen( Qt::NoPen );
728  if ( mAllowOpacity && backgroundColor.alpha() < 255 )
729  {
730  //start with checkboard pattern
731  const QBrush checkBrush = QBrush( transparentBackground() );
732  p.setBrush( checkBrush );
733  p.drawRoundedRect( rect, 3, 3 );
734  }
735 
736  //draw semi-transparent color on top
737  p.setBrush( backgroundColor );
738  p.drawRoundedRect( rect, 3, 3 );
739  p.end();
740  }
741 
742  setIconSize( currentIconSize );
743  setIcon( pixmap );
744 }
745 
747 {
748  //copy color
749  QColor c = linkedProjectColor();
750  if ( !c.isValid() )
751  c = mColor;
752  QApplication::clipboard()->setMimeData( QgsSymbolLayerUtils::colorToMimeData( c ) );
753 }
754 
756 {
757  QColor clipColor;
758  if ( colorFromMimeData( QApplication::clipboard()->mimeData(), clipColor ) )
759  {
760  //paste color
761  setColor( clipColor );
762  addRecentColor( clipColor );
763  }
764 }
765 
767 {
768  //activate picker color
769  // Store current color
770  mCurrentColor = mColor;
771  QApplication::setOverrideCursor( QgsApplication::getThemeCursor( QgsApplication::Cursor::Sampler ) );
772  grabMouse();
773  grabKeyboard();
774  mPickingColor = true;
775  setMouseTracking( true );
776 }
777 
778 QColor QgsColorButton::color() const
779 {
780  QColor c = linkedProjectColor();
781  if ( !c.isValid() )
782  c = mColor;
783  return c;
784 }
785 
786 void QgsColorButton::setAllowOpacity( const bool allow )
787 {
788  mAllowOpacity = allow;
789 }
790 
791 void QgsColorButton::setColorDialogTitle( const QString &title )
792 {
793  mColorDialogTitle = title;
794 }
795 
797 {
798  return mColorDialogTitle;
799 }
800 
801 void QgsColorButton::setShowMenu( const bool showMenu )
802 {
803  mShowMenu = showMenu;
804  setMenu( showMenu ? mMenu : nullptr );
805  setPopupMode( showMenu ? QToolButton::MenuButtonPopup : QToolButton::DelayedPopup );
806  //force recalculation of icon size
807  mIconSize = QSize();
809 }
810 
812 {
813  mBehavior = behavior;
814 }
815 
816 void QgsColorButton::setDefaultColor( const QColor &color )
817 {
818  mDefaultColor = color;
819 }
820 
821 void QgsColorButton::setShowNull( bool showNull, const QString &nullString )
822 {
823  mShowNull = showNull;
824  mNullColorString = nullString;
825 }
826 
828 {
829  return mShowNull;
830 }
831 
833 {
834  return !mColor.isValid();
835 }
836 
837 void QgsColorButton::linkToProjectColor( const QString &name )
838 {
839  mLinkedColorName = name;
841 }
842 
static const double UI_SCALE_FACTOR
UI scaling factor.
Definition: qgis.h:1307
static QPixmap getThemePixmap(const QString &name, const QColor &foreColor=QColor(), const QColor &backColor=QColor(), int size=16)
Helper to get a theme icon as a pixmap.
static QCursor getThemeCursor(Cursor cursor)
Helper to get a theme cursor.
static QgsColorSchemeRegistry * colorSchemeRegistry()
Returns the application's color scheme registry, used for managing color schemes.
Behavior behavior
void setDefaultColor(const QColor &color)
Sets the default color for the button, which is shown in the button's drop-down menu for the "default...
void mouseReleaseEvent(QMouseEvent *e) override
Reimplemented to allow color picking.
void dragLeaveEvent(QDragLeaveEvent *e) override
Reimplemented to reset button appearance after drag leave.
void colorChanged(const QColor &color)
Emitted whenever a new color is set for the button.
void copyColor()
Copies the current color to the clipboard.
void setButtonBackground(const QColor &color=QColor())
Sets the background pixmap for the button based upon color and transparency.
void mousePressEvent(QMouseEvent *e) override
Reimplemented to detect right mouse button clicks on the color button and allow dragging colors.
bool event(QEvent *e) override
void dropEvent(QDropEvent *e) override
Reimplemented to accept dropped colors.
static const QPixmap & transparentBackground()
Returns a checkboard pattern pixmap for use as a background to transparent colors.
Behavior
Specifies the behavior when the button is clicked.
@ ShowDialog
Show a color picker dialog when clicked.
@ SignalOnly
Emit colorClicked signal only, no dialog.
void setShowMenu(bool showMenu)
Sets whether the drop-down menu should be shown for the button.
QgsColorButton(QWidget *parent=nullptr, const QString &cdt=QString(), QgsColorSchemeRegistry *registry=nullptr)
Construct a new color ramp button.
QSize sizeHint() const override
static QPixmap createMenuIcon(const QColor &color, bool showChecks=true)
Creates an icon for displaying a color in a drop-down menu.
void setBehavior(Behavior behavior)
Sets the behavior for when the button is clicked.
void setColorDialogTitle(const QString &title)
Set the title for the color chooser dialog window.
QSize minimumSizeHint() const override
void setShowNull(bool showNull, const QString &nullString=QString())
Sets whether a set to null (clear) option is shown in the button's drop-down menu.
void linkToProjectColor(const QString &name)
Sets the button to link to an existing project color, by color name.
void unlinked()
Emitted when the color is unlinked, e.g.
void setAllowOpacity(bool allowOpacity)
Sets whether opacity modification (transparency) is permitted for the color.
void setToNoColor()
Sets color to a totally transparent color.
void activatePicker()
Activates the color picker tool, which allows for sampling a color from anywhere on the screen.
void mouseMoveEvent(QMouseEvent *e) override
Reimplemented to allow dragging colors from button.
void showEvent(QShowEvent *e) override
void setToDefaultColor()
Sets color to the button's default color, if set.
void colorClicked(const QColor &color)
Emitted when the button is clicked, if the button's behavior is set to SignalOnly.
void cleared()
Emitted when the color is cleared (set to null).
QString colorDialogTitle
void dragEnterEvent(QDragEnterEvent *e) override
Reimplemented to accept dragged colors.
void unlink()
Unlinks the button from a project color.
void setToNull()
Sets color to null.
bool isNull() const
Returns true if the current color is null.
void keyPressEvent(QKeyEvent *e) override
Reimplemented to allow canceling color pick via keypress, and sample via space bar press.
void resizeEvent(QResizeEvent *event) override
bool showNull() const
Returns whether the set to null (clear) option is shown in the button's drop-down menu.
void pasteColor()
Pastes a color from the clipboard to the color button.
void setColor(const QColor &color)
Sets the current color for the button.
void changeEvent(QEvent *e) override
A custom QGIS dialog for selecting a color.
A color ramp widget.
@ Horizontal
Horizontal ramp.
Registry of color schemes.
QList< QgsColorScheme * > schemes() const
Returns all color schemes in the registry.
@ ShowInColorButtonMenu
Show scheme in color button drop-down menu.
A color swatch grid which can be embedded into a menu.
void setBaseColor(const QColor &baseColor)
Sets the base color for the color grid.
void colorChanged(const QColor &color)
Emitted when a color has been selected from the widget.
A color wheel widget.
void setColor(const QColor &color, bool emitSignals=false) override
An action containing a color widget, which can be embedded into a menu.
void setDismissOnColorSelection(bool dismiss)
Sets whether the parent menu should be dismissed and closed when a color is selected from the action'...
void colorChanged(const QColor &color)
Emitted when a color has been selected from the widget.
static QPixmap createDragIcon(const QColor &color)
Create an icon for dragging colors.
virtual void setColor(const QColor &color, bool emitSignals=false)
Sets the color for the widget.
@ Alpha
Alpha component (opacity) of color.
A custom QGIS widget for selecting a color, including options for selecting colors via hue wheel,...
@ LayoutVertical
Use a narrower, vertically stacked layout.
void currentColorChanged(const QColor &color)
Emitted when the dialog's color changes.
void setPreviousColor(const QColor &color)
Sets the color to show in an optional "previous color" section.
void setAllowOpacity(bool allowOpacity)
Sets whether opacity modification (transparency) is permitted for the color dialog.
static QColor sampleColor(QPoint point)
Samples the color on screen at the specified global point (pixel).
Definition: qgsgui.cpp:223
Base class for any widget that can be shown as a inline panel.
void openPanel(QgsPanelWidget *panel)
Open a panel or dialog depending on dock mode setting If dock mode is true this method will emit the ...
static QgsPanelWidget * findParentPanel(QWidget *widget)
Traces through the parents of a widget to find if it is contained within a QgsPanelWidget widget.
void setPanelTitle(const QString &panelTitle)
Set the title of the panel when shown in the interface.
bool dockMode()
Returns the dock mode state.
A color scheme which contains project specific colors set through project properties dialog.
QgsNamedColorList fetchColors(const QString &context=QString(), const QColor &baseColor=QColor()) override
Gets a list of colors from the scheme.
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:468
void projectColorsChanged()
Emitted whenever the project's color scheme has been changed.
static void addRecentColor(const QColor &color)
Adds a color to the list of recent colors.
static QString encodeColor(const QColor &color)
static QColor colorFromMimeData(const QMimeData *data, bool &hasAlpha)
Attempts to parse mime data as a color.
static QMimeData * colorToMimeData(const QColor &color)
Creates mime data from a color.
QList< QPair< QColor, QString > > QgsNamedColorList
List of colors paired with a friendly display name identifying the color.
QSize iconSize(bool dockableToolbar)
Returns the user-preferred size of a window's toolbar icons.
int scaleIconSize(int standardSize)
Scales an icon size to compensate for display pixel density, making the icon size hi-dpi friendly,...
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c