QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
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 "qgssymbollayerutils.h"
20#include "qgscolorswatchgrid.h"
22#include "qgscolorwidgets.h"
23#include "qgssettings.h"
24#include "qgsproject.h"
25#include "qgsguiutils.h"
26#include "qgsgui.h"
27#include "qgscolortooltip_p.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
43QgsColorButton::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
96void 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
169bool QgsColorButton::event( QEvent *e )
170{
171 if ( e->type() == QEvent::ToolTip && isEnabled() )
172 {
173 QColor c = linkedProjectColor();
174 const bool isProjectColor = c.isValid();
175 if ( !isProjectColor )
176 c = mColor;
177
178 QString info = ( isProjectColor ? QStringLiteral( "<p>%1: %2</p>" ).arg( tr( "Linked color" ), mLinkedColorName ) : QString() );
179
180 info += QgsColorTooltip::htmlDescription( c, this );
181
182 setToolTip( info );
183 }
184 return QToolButton::event( e );
185}
186
188{
189 QColor noColor = QColor( mColor );
190 noColor.setAlpha( 0 );
191 setColor( noColor );
192}
193
195{
196 if ( mPickingColor )
197 {
198 //don't show dialog if in color picker mode
199 e->accept();
200 return;
201 }
202
203 if ( e->button() == Qt::RightButton )
204 {
205 QToolButton::showMenu();
206 return;
207 }
208 else if ( e->button() == Qt::LeftButton )
209 {
210 mDragStartPosition = e->pos();
211 }
212 QToolButton::mousePressEvent( e );
213}
214
215bool QgsColorButton::colorFromMimeData( const QMimeData *mimeData, QColor &resultColor )
216{
217 bool hasAlpha = false;
218 QColor mimeColor = QgsSymbolLayerUtils::colorFromMimeData( mimeData, hasAlpha );
219
220 if ( mimeColor.isValid() )
221 {
222 if ( !mAllowOpacity )
223 {
224 //remove alpha channel
225 mimeColor.setAlpha( 255 );
226 }
227 else if ( !hasAlpha )
228 {
229 //mime color has no explicit alpha component, so keep existing alpha
230 mimeColor.setAlpha( mColor.alpha() );
231 }
232 resultColor = mimeColor;
233 return true;
234 }
235
236 //could not get color from mime data
237 return false;
238}
239
240void QgsColorButton::mouseMoveEvent( QMouseEvent *e )
241{
242 if ( mPickingColor )
243 {
244 setButtonBackground( QgsGui::sampleColor( e->globalPos() ) );
245 e->accept();
246 return;
247 }
248
249 //handle dragging colors from button
250 QColor c = linkedProjectColor();
251 if ( !c.isValid() )
252 c = mColor;
253
254 if ( !( e->buttons() & Qt::LeftButton ) || !c.isValid() )
255 {
256 //left button not depressed or no color set, so not a drag
257 QToolButton::mouseMoveEvent( e );
258 return;
259 }
260
261 if ( ( e->pos() - mDragStartPosition ).manhattanLength() < QApplication::startDragDistance() )
262 {
263 //mouse not moved, so not a drag
264 QToolButton::mouseMoveEvent( e );
265 return;
266 }
267
268 //user is dragging color
269 QDrag *drag = new QDrag( this );
270 drag->setMimeData( QgsSymbolLayerUtils::colorToMimeData( c ) );
271 drag->setPixmap( QgsColorWidget::createDragIcon( c ) );
272 drag->exec( Qt::CopyAction );
273 setDown( false );
274}
275
277{
278 if ( mPickingColor )
279 {
280 //end color picking operation by sampling the color under cursor
281 stopPicking( e->globalPos() );
282 e->accept();
283 return;
284 }
285
286 QToolButton::mouseReleaseEvent( e );
287}
288
289void QgsColorButton::stopPicking( QPoint eventPos, bool samplingColor )
290{
291 //release mouse and keyboard, and reset cursor
292 releaseMouse();
293 releaseKeyboard();
294 QgsApplication::restoreOverrideCursor();
295 setMouseTracking( false );
296 mPickingColor = false;
297
298 if ( !samplingColor )
299 {
300 //not sampling color, restore old color
302 return;
303 }
304
305 setColor( QgsGui::sampleColor( eventPos ) );
306 addRecentColor( mColor );
307}
308
309QColor QgsColorButton::linkedProjectColor() const
310{
311 QList<QgsProjectColorScheme *> projectSchemes;
312 QgsApplication::colorSchemeRegistry()->schemes( projectSchemes );
313 if ( projectSchemes.length() > 0 )
314 {
315 QgsProjectColorScheme *scheme = projectSchemes.at( 0 );
316 const QgsNamedColorList colors = scheme->fetchColors();
317 for ( const auto &color : colors )
318 {
319 if ( color.second.isEmpty() )
320 continue;
321
322 if ( color.second == mLinkedColorName )
323 {
324 return color.first;
325 }
326 }
327 }
328 return QColor();
329}
330
332{
333 if ( !mPickingColor )
334 {
335 //if not picking a color, use default tool button behavior
336 QToolButton::keyPressEvent( e );
337 return;
338 }
339
340 //cancel picking, sampling the color if space was pressed
341 stopPicking( QCursor::pos(), e->key() == Qt::Key_Space );
342}
343
344void QgsColorButton::dragEnterEvent( QDragEnterEvent *e )
345{
346 const bool isProjectColor = linkedProjectColor().isValid();
347 if ( isProjectColor )
348 return;
349
350 //is dragged data valid color data?
351 QColor mimeColor;
352 if ( colorFromMimeData( e->mimeData(), mimeColor ) )
353 {
354 //if so, we accept the drag, and temporarily change the button's color
355 //to match the dragged color. This gives immediate feedback to the user
356 //that colors can be dropped here
357 e->acceptProposedAction();
358 setButtonBackground( mimeColor );
359 }
360}
361
362void QgsColorButton::dragLeaveEvent( QDragLeaveEvent *e )
363{
364 Q_UNUSED( e )
365 //reset button color
367}
368
369void QgsColorButton::dropEvent( QDropEvent *e )
370{
371 const bool isProjectColor = linkedProjectColor().isValid();
372 if ( isProjectColor )
373 return;
374
375 //is dropped data valid color data?
376 QColor mimeColor;
377 if ( colorFromMimeData( e->mimeData(), mimeColor ) )
378 {
379 //accept drop and set new color
380 e->acceptProposedAction();
381 setColor( mimeColor );
382 addRecentColor( mimeColor );
383 }
384}
385
386void QgsColorButton::wheelEvent( QWheelEvent *event )
387{
388 if ( mAllowOpacity && isEnabled() && !isNull() )
389 {
390 const double increment = ( ( event->modifiers() & Qt::ControlModifier ) ? 0.01 : 0.1 ) *
391 ( event->angleDelta().y() > 0 ? 1 : -1 );
392 const double alpha = std::min( std::max( 0.0, mColor.alphaF() + increment ), 1.0 );
393 mColor.setAlphaF( alpha );
394
396 emit colorChanged( mColor );
397 event->accept();
398 }
399 else
400 {
401 QToolButton::wheelEvent( event );
402 }
403}
404
405void QgsColorButton::setValidColor( const QColor &newColor )
406{
407 if ( newColor.isValid() )
408 {
409 setColor( newColor );
410 addRecentColor( newColor );
411 }
412}
413
414void QgsColorButton::setValidTemporaryColor( const QColor &newColor )
415{
416 if ( newColor.isValid() )
417 {
418 setColor( newColor );
419 }
420}
421
422QPixmap QgsColorButton::createMenuIcon( const QColor &color, const bool showChecks )
423{
424 const int iconSize = QgsGuiUtils::scaleIconSize( 16 );
425
426 //create an icon pixmap
427 QPixmap pixmap( iconSize, iconSize );
428 pixmap.fill( Qt::transparent );
429
430 QPainter p;
431 p.begin( &pixmap );
432
433 //start with checkboard pattern
434 if ( showChecks )
435 {
436 const QBrush checkBrush = QBrush( transparentBackground() );
437 p.setPen( Qt::NoPen );
438 p.setBrush( checkBrush );
439 p.drawRect( 0, 0, iconSize - 1, iconSize - 1 );
440 }
441
442 //draw color over pattern
443 p.setBrush( QBrush( color ) );
444
445 //draw border
446 p.setPen( QColor( 197, 197, 197 ) );
447 p.drawRect( 0, 0, iconSize - 1, iconSize - 1 );
448 p.end();
449 return pixmap;
450}
451
452void QgsColorButton::buttonClicked()
453{
454 if ( linkedProjectColor().isValid() )
455 {
456 QToolButton::showMenu();
457 }
458 else
459 {
460 switch ( mBehavior )
461 {
462 case ShowDialog:
463 showColorDialog();
464 return;
465 case SignalOnly:
466 emit colorClicked( mColor );
467 return;
468 }
469 }
470}
471
472void QgsColorButton::prepareMenu()
473{
474 //we need to tear down and rebuild this menu every time it is shown. Otherwise the space allocated to any
475 //QgsColorSwatchGridAction is not recalculated by Qt and the swatch grid may not be the correct size
476 //for the number of colors shown in the grid. Note that we MUST refresh color swatch grids every time this
477 //menu is opened, otherwise color schemes like the recent color scheme grid are meaningless
478 mMenu->clear();
479
480 const bool isProjectColor = linkedProjectColor().isValid();
481
482 if ( !isProjectColor )
483 {
484 if ( mShowNull )
485 {
486 QAction *nullAction = new QAction( mNullColorString.isEmpty() ? tr( "Clear Color" ) : mNullColorString, this );
487 nullAction->setIcon( createMenuIcon( Qt::transparent, false ) );
488 mMenu->addAction( nullAction );
489 connect( nullAction, &QAction::triggered, this, &QgsColorButton::setToNull );
490 }
491
492 //show default color option if set
493 if ( mDefaultColor.isValid() )
494 {
495 QAction *defaultColorAction = new QAction( tr( "Default Color" ), this );
496 defaultColorAction->setIcon( createMenuIcon( mDefaultColor ) );
497 mMenu->addAction( defaultColorAction );
498 connect( defaultColorAction, &QAction::triggered, this, &QgsColorButton::setToDefaultColor );
499 }
500
501 if ( mShowNoColorOption )
502 {
503 QAction *noColorAction = new QAction( mNoColorString, this );
504 noColorAction->setIcon( createMenuIcon( Qt::transparent, false ) );
505 mMenu->addAction( noColorAction );
506 connect( noColorAction, &QAction::triggered, this, &QgsColorButton::setToNoColor );
507 }
508
509 mMenu->addSeparator();
510 QgsColorWheel *colorWheel = new QgsColorWheel( mMenu );
511 colorWheel->setColor( color() );
512 QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, mMenu, mMenu );
513 colorAction->setDismissOnColorSelection( false );
514 connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsColorButton::setColor );
515 mMenu->addAction( colorAction );
516 if ( mAllowOpacity )
517 {
519 alphaRamp->setColor( color() );
520 QgsColorWidgetAction *alphaAction = new QgsColorWidgetAction( alphaRamp, mMenu, mMenu );
521 alphaAction->setDismissOnColorSelection( false );
522 connect( alphaAction, &QgsColorWidgetAction::colorChanged, this, &QgsColorButton::setColor );
523 connect( alphaAction, &QgsColorWidgetAction::colorChanged, colorWheel, [colorWheel]( const QColor & color ) { colorWheel->setColor( color, false ); }
524 );
525 connect( colorAction, &QgsColorWidgetAction::colorChanged, alphaRamp, [alphaRamp]( const QColor & color ) { alphaRamp->setColor( color, false ); }
526 );
527 mMenu->addAction( alphaAction );
528 }
529
530 if ( mColorSchemeRegistry )
531 {
532 //get schemes with ShowInColorButtonMenu flag set
533 QList< QgsColorScheme * > schemeList = mColorSchemeRegistry->schemes( QgsColorScheme::ShowInColorButtonMenu );
534 QList< QgsColorScheme * >::iterator it = schemeList.begin();
535 for ( ; it != schemeList.end(); ++it )
536 {
537 QgsColorSwatchGridAction *colorAction = new QgsColorSwatchGridAction( *it, mMenu, mContext, this );
538 colorAction->setBaseColor( mColor );
539 mMenu->addAction( colorAction );
540 connect( colorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsColorButton::setValidColor );
541 connect( colorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsColorButton::addRecentColor );
542 }
543 }
544
545 mMenu->addSeparator();
546 }
547
548 if ( isProjectColor )
549 {
550 QAction *unlinkAction = new QAction( tr( "Unlink Color" ), mMenu );
551 mMenu->addAction( unlinkAction );
552 connect( unlinkAction, &QAction::triggered, this, &QgsColorButton::unlink );
553 }
554
555 QAction *copyColorAction = new QAction( tr( "Copy Color" ), this );
556 mMenu->addAction( copyColorAction );
557 connect( copyColorAction, &QAction::triggered, this, &QgsColorButton::copyColor );
558
559 if ( !isProjectColor )
560 {
561 QAction *pasteColorAction = new QAction( tr( "Paste Color" ), this );
562 //enable or disable paste action based on current clipboard contents. We always show the paste
563 //action, even if it's disabled, to give hint to the user that pasting colors is possible
564 QColor clipColor;
565 if ( colorFromMimeData( QApplication::clipboard()->mimeData(), clipColor ) )
566 {
567 pasteColorAction->setIcon( createMenuIcon( clipColor ) );
568 }
569 else
570 {
571 pasteColorAction->setEnabled( false );
572 }
573 mMenu->addAction( pasteColorAction );
574 connect( pasteColorAction, &QAction::triggered, this, &QgsColorButton::pasteColor );
575
576 QAction *pickColorAction = new QAction( tr( "Pick Color" ), this );
577 mMenu->addAction( pickColorAction );
578 connect( pickColorAction, &QAction::triggered, this, &QgsColorButton::activatePicker );
579
580 QAction *chooseColorAction = new QAction( tr( "Choose Color…" ), this );
581 mMenu->addAction( chooseColorAction );
582 connect( chooseColorAction, &QAction::triggered, this, &QgsColorButton::showColorDialog );
583 }
584}
585
587{
588 if ( e->type() == QEvent::EnabledChange )
589 {
591 }
592 QToolButton::changeEvent( e );
593}
594
595#if 0 // causes too many cyclical updates, but may be needed on some platforms
596void QgsColorButton::paintEvent( QPaintEvent *e )
597{
598 QToolButton::paintEvent( e );
599
600 if ( !mBackgroundSet )
601 {
603 }
604}
605#endif
606
607void QgsColorButton::showEvent( QShowEvent *e )
608{
610 QToolButton::showEvent( e );
611}
612
613void QgsColorButton::resizeEvent( QResizeEvent *event )
614{
615 QToolButton::resizeEvent( event );
616 //recalculate icon size and redraw icon
617 mIconSize = QSize();
619}
620
621void QgsColorButton::setColor( const QColor &color )
622{
623 const QColor oldColor = mColor;
624 mColor = color;
625
626 // handle when initially set color is same as default (Qt::black); consider it a color change
627 if ( oldColor != mColor || ( mColor == QColor( Qt::black ) && !mColorSet ) )
628 {
630 if ( isEnabled() )
631 {
632 // TODO: May be beneficial to have the option to set color without emitting this signal.
633 // Now done by blockSignals( bool ) where button is used
634 emit colorChanged( mColor );
635 }
636 }
637 mColorSet = true;
638}
639
640void QgsColorButton::addRecentColor( const QColor &color )
641{
643}
644
645void QgsColorButton::setButtonBackground( const QColor &color )
646{
647 QColor backgroundColor = color;
648 bool isProjectColor = false;
649 if ( !backgroundColor.isValid() && !mLinkedColorName.isEmpty() )
650 {
651 backgroundColor = linkedProjectColor();
652 isProjectColor = backgroundColor.isValid();
653 if ( !isProjectColor )
654 {
655 mLinkedColorName.clear(); //color has been deleted, renamed, etc...
656 emit unlinked();
657 }
658 }
659 if ( !backgroundColor.isValid() )
660 {
661 backgroundColor = mColor;
662 }
663
664 QSize currentIconSize;
665 //icon size is button size with a small margin
666 if ( menu() )
667 {
668 if ( !mIconSize.isValid() )
669 {
670 //calculate size of push button part of widget (ie, without the menu drop-down button part)
671 QStyleOptionToolButton opt;
672 initStyleOption( &opt );
673 const QRect buttonSize = QApplication::style()->subControlRect( QStyle::CC_ToolButton, &opt, QStyle::SC_ToolButton,
674 this );
675 //make sure height of icon looks good under different platforms
676#ifdef Q_OS_WIN
677 mIconSize = QSize( buttonSize.width() - 10, height() - 6 );
678#else
679 mIconSize = QSize( buttonSize.width() - 10, height() - 12 );
680#endif
681 }
682 currentIconSize = mIconSize;
683 }
684 else
685 {
686 //no menu
687#ifdef Q_OS_WIN
688 currentIconSize = QSize( width() - 10, height() - 6 );
689#else
690 currentIconSize = QSize( width() - 10, height() - 12 );
691#endif
692 }
693
694 if ( !currentIconSize.isValid() || currentIconSize.width() <= 0 || currentIconSize.height() <= 0 )
695 {
696 return;
697 }
698
699 //create an icon pixmap
700 const double pixelRatio = devicePixelRatioF();
701 QPixmap pixmap( currentIconSize * pixelRatio );
702 pixmap.setDevicePixelRatio( pixelRatio );
703 pixmap.fill( Qt::transparent );
704
705 if ( backgroundColor.isValid() )
706 {
707 const QRectF rect( 0, 0,
708 currentIconSize.width(),
709 currentIconSize.height() );
710 QPainter p;
711 p.begin( &pixmap );
712 p.setRenderHint( QPainter::Antialiasing );
713 p.setPen( Qt::NoPen );
714 if ( mAllowOpacity && backgroundColor.alpha() < 255 )
715 {
716 //start with checkboard pattern
717 const QBrush checkBrush = QBrush( transparentBackground() );
718 p.setBrush( checkBrush );
719 p.drawRoundedRect( rect, 3, 3 );
720 }
721
722 //draw semi-transparent color on top
723 p.setBrush( backgroundColor );
724 p.drawRoundedRect( rect, 3, 3 );
725 p.end();
726 }
727
728 setIconSize( currentIconSize );
729 setIcon( pixmap );
730}
731
733{
734 //copy color
735 QColor c = linkedProjectColor();
736 if ( !c.isValid() )
737 c = mColor;
738 QApplication::clipboard()->setMimeData( QgsSymbolLayerUtils::colorToMimeData( c ) );
739}
740
742{
743 QColor clipColor;
744 if ( colorFromMimeData( QApplication::clipboard()->mimeData(), clipColor ) )
745 {
746 //paste color
747 setColor( clipColor );
748 addRecentColor( clipColor );
749 }
750}
751
753{
754 //activate picker color
755 // Store current color
756 mCurrentColor = mColor;
757 QApplication::setOverrideCursor( QgsApplication::getThemeCursor( QgsApplication::Cursor::Sampler ) );
758 grabMouse();
759 grabKeyboard();
760 mPickingColor = true;
761 setMouseTracking( true );
762}
763
765{
766 QColor c = linkedProjectColor();
767 if ( !c.isValid() )
768 c = mColor;
769 return c;
770}
771
772void QgsColorButton::setAllowOpacity( const bool allow )
773{
774 mAllowOpacity = allow;
775}
776
777void QgsColorButton::setColorDialogTitle( const QString &title )
778{
779 mColorDialogTitle = title;
780}
781
783{
784 return mColorDialogTitle;
785}
786
787void QgsColorButton::setShowMenu( const bool showMenu )
788{
789 mShowMenu = showMenu;
790 setMenu( showMenu ? mMenu : nullptr );
791 setPopupMode( showMenu ? QToolButton::MenuButtonPopup : QToolButton::DelayedPopup );
792 //force recalculation of icon size
793 mIconSize = QSize();
795}
796
798{
799 mBehavior = behavior;
800}
801
802void QgsColorButton::setDefaultColor( const QColor &color )
803{
804 mDefaultColor = color;
805}
806
807void QgsColorButton::setShowNull( bool showNull, const QString &nullString )
808{
809 mShowNull = showNull;
810 mNullColorString = nullString;
811}
812
814{
815 return mShowNull;
816}
817
819{
820 return !mColor.isValid();
821}
822
823void QgsColorButton::linkToProjectColor( const QString &name )
824{
825 mLinkedColorName = name;
827}
static const double UI_SCALE_FACTOR
UI scaling factor.
Definition qgis.h:5627
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.
@ Sampler
Color/Value picker.
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.
void wheelEvent(QWheelEvent *event) override
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.
static QString htmlDescription(QColor color, T *widget)
Returns an HTML desciption given a color with a preview image of the color.
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:275
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.
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.
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
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.
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