KisPopupPalette Class Reference

#include <kis_popup_palette.h>

Inheritance diagram for KisPopupPalette:

Public Slots
void	slotUpdateIcons ()

Signals
void	finished () override
void	sigChangeActivePaintop (int)
void	sigChangefGColor (const KoColor &)
void	sigUpdateCanvas ()
void	sigUpdateRecentColor (int)
void	zoomLevelChanged (int)
Signals inherited from KisPopupWidgetInterface
virtual void	finished ()=0
	Emitted when a popup widget believes that its job is finished.

Public Member Functions
void	dismiss () override
	Called when you want to dismiss a popup widget.
void	ensureWithinParent (const QPoint &globalPos, bool useUpperLeft)
	KisPopupPalette (KisViewManager *, KisCoordinatesConverter *, KisFavoriteResourceManager *, const KoColorDisplayRendererInterface *displayRenderer, QWidget *parent=0)
bool	onScreen () override
	Returns whether the widget is active (on screen) or not.
void	popup (const QPoint &position) override
	Called when and where you want a widget to popup.
int	selectedColor () const
void	setParent (QWidget *parent)
void	setSelectedColor (int x)
QSize	sizeHint () const override
	~KisPopupPalette () override
Public Member Functions inherited from KisPopupWidgetInterface
virtual	~KisPopupWidgetInterface ()

Protected Member Functions
int	calculateColorIndex (QPointF position, int numColors) const
	Calculate index of recent color in array.
bool	eventFilter (QObject *, QEvent *) override
int	findPresetSlot (QPointF position) const
	/ find the index of the brush preset slot containing @position.
int	hoveredColor () const
int	hoveredPreset () const
void	mouseMoveEvent (QMouseEvent *) override
void	mousePressEvent (QMouseEvent *) override
void	mouseReleaseEvent (QMouseEvent *) override
void	paintEvent (QPaintEvent *) override
void	resizeEvent (QResizeEvent *) override
void	setHoveredColor (int x)
void	setHoveredPreset (int x)
void	showEvent (QShowEvent *event) override
void	tabletEvent (QTabletEvent *event) override

Properties
int	hoveredColor
int	hoveredPreset
int	selectedColor

Private Slots
void	showBottomBarWidget (bool visible)
void	showHudWidget (bool visible)
void	slotConfigurationChanged ()
void	slotDisplayConfigurationChanged ()
void	slotEmitColorChanged ()
void	slotExternalFgColorChanged (const KoColor &color)
void	slotFitToViewClicked ()
void	slotRemoveMirrorPos ()
void	slotSetMirrorPos ()
void	slotSetSelectedColor (int x)
void	slotShowTagsPopup ()
void	slotUpdate ()
void	slotZoomSliderChanged (int zoom)
void	slotZoomSliderPressed ()
void	slotZoomSliderReleased ()
void	slotZoomToOneHundredPercentClicked ()

Private Member Functions
void	calculatePresetLayout ()
	Determine the number of rings to distribute the presets and calculate the radius of the brush preset slots and saves the "layout" to m_cachedPresetLayout.
void	calculateRotationSnapAreas ()
QPainterPath	createPathFromPresetIndex (int index) const
QPainterPath	drawDonutPathAngle (int, int, int)
QPainterPath	drawDonutPathFull (int, int, int, int)
QPainterPath	drawFgBgColorIndicator (int type) const
QPointF	drawPointOnAngle (qreal angle, qreal radius) const
bool	isPointInPixmap (QPointF &, int pos)
void	reconfigure ()
QRectF	rotationIndicatorRect (qreal rotationAngle) const

Private Attributes
KisHighlightedToolButton *	canvasOnlyButton {0}
QPushButton *	fitToViewButton {0}
KisKActionCollection *	m_actionCollection
KisActionManager *	m_actionManager
KisAcyclicSignalConnector *	m_acyclicConnector = 0
KisRoundHudButton *	m_bottomBarButton {0}
QWidget *	m_bottomBarWidget {0}
CachedPresetLayout	m_cachedPresetLayout
QRectF	m_canvasRotationIndicatorRect
KisRoundHudButton *	m_clearColorHistoryButton {0}
KisMouseClickEater *	m_clicksEater
QScopedPointer< KisSignalCompressor >	m_colorChangeCompressor
qreal	m_colorHistoryInnerRadius {72.0}
qreal	m_colorHistoryOuterRadius {92.0}
KisColorSelectorInterface *	m_colorSelector {0}
KisCoordinatesConverter *	m_coordinatesConverter
const KoColorDisplayRendererInterface *	m_displayRenderer
KisDockerHud *	m_dockerHud {0}
KisRoundHudButton *	m_dockerHudButton {0}
int	m_hoveredColor {0}
int	m_hoveredPreset {0}
bool	m_isOverCanvasRotationIndicator {false}
bool	m_isOverFgBgColors {false}
bool	m_isOverResetCanvasRotationIndicator {false}
bool	m_isRotatingCanvasIndicator {false}
bool	m_isZoomingCanvas {false}
QSpacerItem *	m_mainArea {0}
int	m_maxPresetSlotCount {10}
QPoint	m_mirrorPos {}
qreal	m_popupPaletteSize {385.0}
qreal	m_presetRingMargin {3.0}
int	m_presetSlotCount {10}
QRectF	m_resetCanvasRotationIndicatorRect
KisFavoriteResourceManager *	m_resourceManager
qreal	m_rotationSnapAngle {0}
qreal	m_rotationTrackSize {18.0}
int	m_selectedColor {0}
bool	m_showColorHistory {true}
bool	m_showRotationTrack {true}
std::array< QLineF, 24 >	m_snapLines {}
qreal	m_snapRadius {15}
std::array< QRect, 24 >	m_snapRects {}
bool	m_snapRotation {false}
bool	m_tabletRightClickPressed {false}
KisRoundHudButton *	m_tagsButton {0}
bool	m_touchBeginReceived {false}
bool	m_useDynamicSlotCount {true}
KisViewManager *	m_viewManager
KisHighlightedToolButton *	mirrorMode {0}
QGraphicsOpacityEffect *	opacityChange {0}
QSlider *	zoomCanvasSlider {0}
int	zoomSliderMaxValue {200}
int	zoomSliderMinValue {10}
QPushButton *	zoomToOneHundredPercentButton {0}

Detailed Description

Definition at line 45 of file kis_popup_palette.h.

Constructor & Destructor Documentation

KisPopupPalette()

KisPopupPalette::KisPopupPalette	(	KisViewManager *	viewManager,
		KisCoordinatesConverter *	coordinatesConverter,
		KisFavoriteResourceManager *	manager,
		const KoColorDisplayRendererInterface *	displayRenderer,
		QWidget *	parent = 0 )

Tablet support code generates a spurious right-click right after opening the window, so we should ignore it. Next right-click will be used for closing the popup palette

Definition at line 92 of file kis_popup_palette.cpp.

    : QWidget(parent,
 
        KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS() ?
            Qt::Popup :
            Qt::FramelessWindowHint)
    , m_coordinatesConverter(coordinatesConverter)
    , m_viewManager(viewManager)
    , m_actionManager(viewManager->actionManager())
    , m_resourceManager(manager)
    , m_displayRenderer(displayRenderer)
    , m_colorChangeCompressor(new KisSignalCompressor(50, KisSignalCompressor::FIRST_ACTIVE))
    , m_actionCollection(viewManager->actionCollection())
    , m_acyclicConnector(new KisAcyclicSignalConnector(this))
    , m_clicksEater(new KisMouseClickEater(Qt::RightButton, 1, this))
{
    setAttribute(Qt::WA_TranslucentBackground);
 
    connect(m_colorChangeCompressor.data(), SIGNAL(timeout()),
            SLOT(slotEmitColorChanged()));
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(slotConfigurationChanged()));
    connect(m_displayRenderer,  SIGNAL(displayConfigurationChanged()), this, SLOT(slotDisplayConfigurationChanged()));
 
    m_acyclicConnector->connectForwardKoColor(m_resourceManager, SIGNAL(sigChangeFGColorSelector(KoColor)),
                                              this, SLOT(slotExternalFgColorChanged(KoColor)));
 
    m_acyclicConnector->connectBackwardKoColor(this, SIGNAL(sigChangefGColor(KoColor)),
                                               m_resourceManager, SIGNAL(sigSetFGColor(KoColor)));
    // just update() to repaint color labels on external background color change
    connect(viewManager->canvasResourceProvider(), SIGNAL(sigBGColorChanged(KoColor)), SLOT(update()));
 
    connect(this, SIGNAL(sigChangeActivePaintop(int)), m_resourceManager, SLOT(slotChangeActivePaintop(int)));
    connect(this, SIGNAL(sigUpdateRecentColor(int)), m_resourceManager, SLOT(slotUpdateRecentColor(int)));
 
    connect(m_resourceManager, SIGNAL(setSelectedColor(int)), this, SLOT(slotSetSelectedColor(int)));
    connect(m_resourceManager, SIGNAL(updatePalettes()), this, SLOT(slotUpdate()));
    connect(m_resourceManager, SIGNAL(hidePalettes()), this, SIGNAL(finished()));
 
    // Instances of `this` rely on finished() to be detached and its lifetime is associated with `parent`
    connect(parent, SIGNAL(destroyed(QObject *)), this, SIGNAL(finished()), Qt::DirectConnection);
 
    setCursor(Qt::ArrowCursor);
    setMouseTracking(true);
    setHoveredPreset(-1);
    setHoveredColor(-1);
    setSelectedColor(-1);
 
    m_dockerHud = new KisDockerHud(i18n("Popup Palette"), "popuppalette");
 
    m_tagsButton = new KisRoundHudButton(this);
 
    connect(m_tagsButton, SIGNAL(clicked()), SLOT(slotShowTagsPopup()));
 
    m_dockerHudButton = new KisRoundHudButton(this);
    m_dockerHudButton->setCheckable(true);
 
    connect(m_dockerHudButton, SIGNAL(toggled(bool)), SLOT(showHudWidget(bool)));
    
    m_bottomBarWidget = new QWidget(this);
    
    m_bottomBarButton = new KisRoundHudButton(this);
    m_bottomBarButton->setCheckable(true);
 
    connect( m_bottomBarButton, SIGNAL(toggled(bool)), SLOT(showBottomBarWidget(bool)));
 
    m_clearColorHistoryButton = new KisRoundHudButton(this);
    m_clearColorHistoryButton->setToolTip(i18n("Clear color history"));
 
    connect(m_clearColorHistoryButton, SIGNAL(clicked(bool)), m_resourceManager, SLOT(slotClearHistory()));
    //Otherwise the colors won't disappear until the cursor moves away from the button:
    connect(m_clearColorHistoryButton, SIGNAL(released()), this, SLOT(slotUpdate()));
 
    // add some stuff below the pop-up palette that will make it easier to use for tablet people
    QGridLayout* gLayout = new QGridLayout(this);
    gLayout->setSizeConstraint(QLayout::SetFixedSize);
    gLayout->setSpacing(0);
    gLayout->setContentsMargins(QMargins());
    m_mainArea = new QSpacerItem(m_popupPaletteSize, m_popupPaletteSize);
    gLayout->addItem(m_mainArea, 0, 0); // this should push the box to the bottom
    gLayout->setColumnMinimumWidth(1, WIDGET_MARGIN);
    gLayout->addWidget(m_dockerHud, 0, 2);
    gLayout->setRowMinimumHeight(1, WIDGET_MARGIN);
    gLayout->addWidget(m_bottomBarWidget, 2, 0);
 
    QHBoxLayout* hLayout = new QHBoxLayout(m_bottomBarWidget);
    
    mirrorMode = new KisHighlightedToolButton(this);
    mirrorMode->setFixedSize(35, 35);
 
    mirrorMode->setToolTip(i18n("Mirror Canvas"));
    mirrorMode->setDefaultAction(m_actionCollection->action("mirror_canvas_around_cursor"));
    connect(mirrorMode, SIGNAL(clicked(bool)), this, SLOT(slotUpdate()));
    connect(mirrorMode, SIGNAL(pressed()), this, SLOT(slotSetMirrorPos()));
    connect(mirrorMode, SIGNAL(clicked()), this, SLOT(slotRemoveMirrorPos()));
 
    canvasOnlyButton = new KisHighlightedToolButton(this);
    canvasOnlyButton->setFixedSize(35, 35);
 
    canvasOnlyButton->setToolTip(i18n("Canvas Only"));
    canvasOnlyButton->setDefaultAction(m_actionCollection->action("view_show_canvas_only"));
 
    zoomToOneHundredPercentButton = new QPushButton(this);
    zoomToOneHundredPercentButton->setText(i18n("100%"));
    zoomToOneHundredPercentButton->setFixedHeight(35);
 
    zoomToOneHundredPercentButton->setToolTip(i18n("Zoom to 100%"));
    connect(zoomToOneHundredPercentButton, SIGNAL(clicked(bool)), this, SLOT(slotZoomToOneHundredPercentClicked()));
 
    fitToViewButton = new QPushButton(this);
    fitToViewButton->setFixedHeight(35);
 
    fitToViewButton->setToolTip(i18n("Fit Canvas to View"));
    connect(fitToViewButton, SIGNAL(clicked(bool)), this, SLOT(slotFitToViewClicked()));
 
    zoomCanvasSlider = new QSlider(Qt::Horizontal, this);
    zoomSliderMinValue = 10; // set in %
    zoomSliderMaxValue = 200; // set in %
 
    zoomCanvasSlider->setRange(zoomSliderMinValue, zoomSliderMaxValue);
    zoomCanvasSlider->setFixedHeight(35);
    zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent());
 
    zoomCanvasSlider->setSingleStep(1);
    zoomCanvasSlider->setPageStep(1);
 
    connect(zoomCanvasSlider, SIGNAL(valueChanged(int)), this, SLOT(slotZoomSliderChanged(int)));
    connect(zoomCanvasSlider, SIGNAL(sliderPressed()), this, SLOT(slotZoomSliderPressed()));
    connect(zoomCanvasSlider, SIGNAL(sliderReleased()), this, SLOT(slotZoomSliderReleased()));
    
    slotUpdateIcons();
 
    hLayout->setSpacing(2);
    hLayout->setContentsMargins(0, 6, 0, 0);
    hLayout->addWidget(mirrorMode);
    hLayout->addWidget(canvasOnlyButton);
    hLayout->addWidget(zoomCanvasSlider);
    hLayout->addWidget(zoomToOneHundredPercentButton);
    hLayout->addWidget(fitToViewButton);
    
    setVisible(false);
    reconfigure();
 
    opacityChange = new QGraphicsOpacityEffect(this);
    opacityChange->setOpacity(1);
    setGraphicsEffect(opacityChange);
 
    installEventFilter(m_clicksEater);
 
    // Prevent tablet events from being captured by the canvas
    setAttribute(Qt::WA_NoMousePropagation, true);
 
    // Because we can create a popup in canvas widget, synthetic events sometimes arrive here (see mousePressEvent()).
    setAttribute(Qt::WA_AcceptTouchEvents, true);
    installEventFilter(this);
    const QList<QWidget *> childrenWidgets = findChildren<QWidget *>();
    for (const auto &child: childrenWidgets) {
        child->setAttribute(Qt::WA_AcceptTouchEvents, true);
        child->installEventFilter(this);
    }
 
    // No context menu here. Setting this avoids long-presses from delaying
    // inputs or dismissing the palette, see KisLongPressEventFilter.cpp.
    setContextMenuPolicy(Qt::PreventContextMenu);
 
    // Load configuration..
    KisConfig cfg(true);
    m_dockerHudButton->setChecked(cfg.showBrushHud());
    m_bottomBarButton->setChecked(cfg.showPaletteBottomBar());
 
    m_dockerHud->setVisible(m_dockerHudButton->isChecked());
    m_bottomBarWidget->setVisible(m_bottomBarButton->isChecked());
}

References KisKActionCollection::action(), canvasOnlyButton, KisViewManager::canvasResourceProvider(), KisAcyclicSignalConnector::connectBackwardKoColor(), KisAcyclicSignalConnector::connectForwardKoColor(), finished(), fitToViewButton, KisConfigNotifier::instance(), m_actionCollection, m_acyclicConnector, m_bottomBarButton, m_bottomBarWidget, m_clearColorHistoryButton, m_clicksEater, m_colorChangeCompressor, m_coordinatesConverter, m_displayRenderer, m_dockerHud, m_dockerHudButton, m_mainArea, m_popupPaletteSize, m_resourceManager, m_tagsButton, mirrorMode, opacityChange, reconfigure(), setHoveredColor(), setHoveredPreset(), setSelectedColor(), showBottomBarWidget(), KisConfig::showBrushHud(), showHudWidget(), KisConfig::showPaletteBottomBar(), sigChangeActivePaintop(), sigChangefGColor(), sigUpdateRecentColor(), slotConfigurationChanged(), slotDisplayConfigurationChanged(), slotEmitColorChanged(), slotExternalFgColorChanged(), slotFitToViewClicked(), slotRemoveMirrorPos(), slotSetMirrorPos(), slotSetSelectedColor(), slotShowTagsPopup(), slotUpdate(), slotUpdateIcons(), slotZoomSliderChanged(), slotZoomSliderPressed(), slotZoomSliderReleased(), slotZoomToOneHundredPercentClicked(), WIDGET_MARGIN, zoomCanvasSlider, KoZoomHandler::zoomInPercent(), zoomSliderMaxValue, zoomSliderMinValue, and zoomToOneHundredPercentButton.

~KisPopupPalette()

KisPopupPalette::~KisPopupPalette ( )

override

Definition at line 287 of file kis_popup_palette.cpp.

{
}

Member Function Documentation

calculateColorIndex()

int KisPopupPalette::calculateColorIndex ( QPointF position, int numColors ) const

protected

Calculate index of recent color in array.

Parameters

numColors

the total number of recent colors

Returns

-1 if numColors < 1

Definition at line 1202 of file kis_popup_palette.cpp.

{
    if (numColors < 1) {
        return -1;
    }
    // relative to palette center
    QPointF relPosition = position - QPointF(0.5 * m_popupPaletteSize, 0.5 * m_popupPaletteSize);
 
    qreal angle = M_PI - qAtan2(relPosition.x(), relPosition.y()) + M_PI / numColors;
    angle = normalizeAngle(angle);
 
    int index = floor(angle * numColors / (2 * M_PI));
    return qBound(0, index, numColors - 1);
}

References M_PI, m_popupPaletteSize, and normalizeAngle().

calculatePresetLayout()

void KisPopupPalette::calculatePresetLayout ( )

private

Determine the number of rings to distribute the presets and calculate the radius of the brush preset slots and saves the "layout" to m_cachedPresetLayout.

Definition at line 1235 of file kis_popup_palette.cpp.

{
    if (m_presetSlotCount == 0) {
        m_cachedPresetLayout = {};
        return;
    }
    // how many degrees each slice will get
    // if the slot count is 1, we must divide by 2 to get 180 for the algorithm to work
    qreal angleSlice = 360.0 / qMax(m_presetSlotCount, 2);
    qreal outerRadius = m_popupPaletteSize/2 - m_presetRingMargin - (m_showRotationTrack ? m_rotationTrackSize + 1 /* half of stroke */ : BORDER_WIDTH);
    qreal innerRadius = m_colorHistoryOuterRadius +
    (m_showColorHistory
        ? 1 /* half of stroke */ + m_presetRingMargin
        : 0 /* preset margin is already included in either color history radius when it's not showing */
    );
    
    qreal ringWidth = outerRadius - innerRadius;
    qreal halfRingWidth = 0.5 * ringWidth;
    qreal ringMidRadius = innerRadius + halfRingWidth;
 
    // reset the cached layout
    m_cachedPresetLayout = {};
    CachedPresetLayout& c = m_cachedPresetLayout;
 
    // note: adding the margin the way it's done
    // (calculating the radiuses without taking it into account then subtracting it after)
    // is not particularly accurate, but it looks fine since it's so small
    int margin = 2;
 
    // assume one row and get the max radius until the circles would touch
    qreal oneRowAngleSlice = angleSlice / 2;
    qreal oneRowMaxRadius = ringMidRadius * qSin(qDegreesToRadians(oneRowAngleSlice));
 
    // if the circles are bigger than the ring we're limited by the
    // ring's width instead and only one row would fit
    
    // oneRowMaxRadius * 0.2 is to make sure that we still do one row if
    // there isn't that much of a difference and two would just look weirder
    if (oneRowMaxRadius - margin > halfRingWidth - oneRowMaxRadius * 0.2) {
        c.ringCount = 1;
        c.firstRowRadius = qMin(halfRingWidth, oneRowMaxRadius - margin);
        c.firstRowPos = ringMidRadius;
        return;
    }
    
    // otherwise 2 or 3 rows always fit
    qreal tempRadius = halfRingWidth;
    {
        // for two rows, the first row is tangent to the inner radius
        // and the second row to the outer one
        qreal twoRowInnerCount = ceil(qMax(m_presetSlotCount, 2) / 2.0);
        qreal twoRowAngleSlice = 360.0 / twoRowInnerCount;
 
        // we can start at half the ring width and shrink the radius until nothing is overlapping
        while (tempRadius >= 0) {
            tempRadius -= 0.2;
            QPointF r1p1(drawPointOnAngle(twoRowAngleSlice / 2, innerRadius + tempRadius));
            QPointF r1p2(drawPointOnAngle(twoRowAngleSlice / 2 * 3, innerRadius + tempRadius));
            QPointF r2p(drawPointOnAngle(twoRowAngleSlice, outerRadius - tempRadius));
            qreal row1SiblingDistance = kisDistance(r1p1, r1p2);
            qreal row1To2Distance = kisDistance(r1p1, r2p);
            if (row1To2Distance >= (tempRadius + margin) * 2) {
                // the previous radius is the one that's guaranteed not to be overlapping
                if (row1SiblingDistance < (tempRadius + margin) * 2) {
                    // the inner row still overlaps, attempt 3 rows instead
                    break;
                }
                c.ringCount = 2;
                c.secondRowRadius = tempRadius;
                c.secondRowPos = outerRadius - tempRadius;
                c.firstRowRadius = tempRadius;
                c.firstRowPos = innerRadius + tempRadius;
                return;
            }
        }
    }
 
    // for three rows, we initially arrange them like so:
    // the first row tangent to the inner radius
    // the second row in the middle
    // the third row tangent to the outer radius
 
    qreal threeRowInnerCount = ceil(qMax(m_presetSlotCount, 2) / 3.0);
    qreal threeRowAngleSlice = 360.0 / threeRowInnerCount;
 
    // then we decrease the radius until no row is overlapping each other or itself
    while (tempRadius >= 0) {
        QPointF r1p1(drawPointOnAngle(threeRowAngleSlice / 2, innerRadius + tempRadius));
        QPointF r1p2(drawPointOnAngle(threeRowAngleSlice / 2 * 3, innerRadius + tempRadius));
        QPointF r2p1(drawPointOnAngle(threeRowAngleSlice, ringMidRadius));
        QPointF r2p2(drawPointOnAngle(threeRowAngleSlice * 2, ringMidRadius));
        QPointF r3p(drawPointOnAngle(threeRowAngleSlice / 2, outerRadius - tempRadius));
 
        qreal row1SiblingDistance = kisDistance(r1p1, r1p2);
        qreal row1to2Distance = kisDistance(r1p1, r2p1);
        qreal row2to3Distance = kisDistance(r2p1, r3p);
        qreal row1to3Distance = kisDistance(r1p1, r3p);
 
        if (
            row1to2Distance >= tempRadius * 2 &&
            row2to3Distance >= tempRadius * 2 &&
            row1to3Distance >= tempRadius * 2 &&
            row1SiblingDistance >= tempRadius * 2
        ) {
 
            qreal row2SiblingDistance = kisDistance(r2p1, r2p2);
 
            qreal firstRowRadius = tempRadius;
            qreal thirdRowRadius = tempRadius;
            qreal secondRowRadius = tempRadius;
 
            bool firstRowTouching = row1SiblingDistance - firstRowRadius * 2 < 1;
            if (firstRowTouching) {
                // attempt to expand the second row
                // and expand + move the third row inwards
                QPointF tempR3p = r3p;
                qreal tempSecondThirdRowRadius = secondRowRadius;
                qreal tempRow2to3Distance = row2to3Distance;
                qreal tempRow1to3Distance = row1to3Distance;
                while (
                    tempSecondThirdRowRadius * 2 < tempRow2to3Distance &&
                    tempSecondThirdRowRadius * 2 < row2SiblingDistance &&
                    tempSecondThirdRowRadius * 2 < tempRow1to3Distance &&
                    tempSecondThirdRowRadius + firstRowRadius < row1to2Distance
                ) {
                    // the previous temp variables are within limits
                    r3p = tempR3p;
                    row2to3Distance = tempRow2to3Distance;
                    row1to3Distance = tempRow1to3Distance;
                    secondRowRadius = tempSecondThirdRowRadius;
 
                    tempSecondThirdRowRadius += 1;
 
                    tempR3p = drawPointOnAngle(threeRowAngleSlice / 2, outerRadius - tempSecondThirdRowRadius);
 
                    tempRow2to3Distance = kisDistance(r2p1, tempR3p);
                    tempRow1to3Distance = kisDistance(r1p1, tempR3p);
                }
                thirdRowRadius = secondRowRadius;
            }
 
            {
                // the third row can sometimes be expanded + moved a bit more
                qreal tempThirdRowRadius = thirdRowRadius;
                QPointF tempR3p = r3p;
                qreal tempRow2to3Distance = row2to3Distance;
                qreal tempRow1to3Distance = row1to3Distance;
                while (
                    tempThirdRowRadius < halfRingWidth &&
                    secondRowRadius + tempThirdRowRadius < tempRow2to3Distance &&
                    firstRowRadius + tempThirdRowRadius < tempRow1to3Distance
                ) {
                    r3p = tempR3p;
                    row2to3Distance = tempRow2to3Distance;
                    row1to3Distance = tempRow1to3Distance;
                    thirdRowRadius = tempThirdRowRadius;
 
                    tempThirdRowRadius += 1;
 
                    tempR3p = drawPointOnAngle(threeRowAngleSlice / 2, outerRadius - tempThirdRowRadius);
                    tempRow2to3Distance = kisDistance(r2p1, tempR3p);
                    tempRow1to3Distance = kisDistance(r1p1, tempR3p);
                }
            }
            // the third row is no longer moved
            qreal thirdRowPos = outerRadius - thirdRowRadius;
 
            // many times, e.g. when the second row is touching
            // the first row can be moved outwards and expanded
            // sometimes it will even detach from the inner radius if the ringwidth is large enough
            // and there's a lot of presets
            qreal firstRowPos = innerRadius + tempRadius;
            {
                qreal tempFirstRowPos = firstRowPos;
                qreal tempFirstRowRadius = firstRowRadius;
                qreal tempRow1SiblingDistance = row1SiblingDistance;
                qreal tempRow1to3Distance = row1to3Distance;
                qreal tempRow1to2Distance = row1to2Distance;
                QPointF tempR1p1 = r1p1;
                QPointF tempR1p2 = r1p2;
 
                while (
                    tempFirstRowPos < ringMidRadius &&
                    tempFirstRowRadius + secondRowRadius < tempRow1to2Distance &&
                    tempFirstRowRadius + thirdRowRadius < tempRow1to3Distance
                ) {
                    firstRowPos = tempFirstRowPos;
                    firstRowRadius = tempFirstRowRadius;
                    row1to2Distance = tempRow1to2Distance;
                    r1p1 = tempR1p1;
                    // these are unused after so it's not necessary to update them
                    // row1to3Distance = tempRow1to3Distance;
                    // row1SiblingDistance = tempRow1SiblingDistance;
                    // r1p2 = tempR1p2;
 
                    tempFirstRowPos += 1;
 
                    tempR1p1 = drawPointOnAngle(threeRowAngleSlice / 2, tempFirstRowPos);
                    tempR1p2 = drawPointOnAngle(threeRowAngleSlice / 2 * 3, tempFirstRowPos);
                    tempRow1SiblingDistance = kisDistance(tempR1p1, tempR1p2);
                    // expand it to the max size
                    tempFirstRowRadius = tempRow1SiblingDistance / 2;
                    tempRow1to2Distance = kisDistance(tempR1p2, r2p1);
                    tempRow1to3Distance = kisDistance(tempR1p1, r3p);
                }
            }
 
            // finally it's rare, but sometimes possible to also move + expand the second row
            qreal secondRowPos = ringMidRadius;
            bool row2touching1 = row1to2Distance - (firstRowRadius + secondRowRadius) < 1;
            bool row2touching3 = row2to3Distance - (thirdRowRadius + secondRowRadius) < 1;
            if (!row2touching1 && !row2touching3) {
                // move the second row in until it's touching the first row
                qreal knownAngleRatio = qSin(qDegreesToRadians(threeRowAngleSlice / 2)) /
                                        (firstRowRadius + secondRowRadius);
                qreal angleRow1Row2Center = qAsin(knownAngleRatio * firstRowPos);
                qreal angleCenterRow2Row1 = 180 - threeRowAngleSlice / 2 - qRadiansToDegrees(angleRow1Row2Center);
                secondRowPos = qSin(qDegreesToRadians(angleCenterRow2Row1)) / knownAngleRatio;
            }
            if (!row2touching3) {
                QPointF tempR2p1 = r2p1;
                qreal tempRadius = secondRowRadius;
                qreal tempRow1to2Distance = row1to2Distance;
                qreal tempRow2to3Distance = row2to3Distance;
                qreal tempSecondRowPos = secondRowPos;
                while (
                    tempSecondRowPos < thirdRowPos &&
                    tempRadius + thirdRowRadius < tempRow2to3Distance &&
                    // this is an artificial limit, it could get bigger but looks weird
                    tempRadius < thirdRowRadius
                ) {
                    secondRowRadius = tempRadius;
                    secondRowPos = tempSecondRowPos;
                    // these are unused after so it's not necessary to update them
                    // r2p1 = tempR2p1;
                    // row1to2Distance = tempRow1to2Distance;
                    // row2to3Distance = tempRow2to3Distance;
 
                    tempSecondRowPos += 1;
 
                    tempR2p1 = drawPointOnAngle(threeRowAngleSlice, secondRowPos + 1);
                    tempRow1to2Distance = kisDistance(tempR2p1, r1p1);
                    tempRow2to3Distance = kisDistance(tempR2p1, r3p);
                    tempRadius = tempRow1to2Distance - firstRowRadius;
                }
            }
            c = {
                3, //ringCount
                firstRowRadius - margin,
                secondRowRadius - margin,
                thirdRowRadius - margin,
                firstRowPos,
                secondRowPos,
                thirdRowPos
            };
            return;
        }
        tempRadius -= 0.2;
    }
}

References BORDER_WIDTH, drawPointOnAngle(), CachedPresetLayout::firstRowPos, CachedPresetLayout::firstRowRadius, kisDistance(), m_cachedPresetLayout, m_colorHistoryOuterRadius, m_popupPaletteSize, m_presetRingMargin, m_presetSlotCount, m_rotationTrackSize, m_showColorHistory, m_showRotationTrack, CachedPresetLayout::ringCount, CachedPresetLayout::secondRowPos, and CachedPresetLayout::secondRowRadius.

calculateRotationSnapAreas()

void KisPopupPalette::calculateRotationSnapAreas ( )

private

Definition at line 1553 of file kis_popup_palette.cpp.

                                                 {
    int i = 0;
    for (QRect &rect: m_snapRects) {
        QPointF point(drawPointOnAngle(i * 15, m_popupPaletteSize / 2 - BORDER_WIDTH - m_snapRadius/2));
        point += QPointF(m_popupPaletteSize / 2 - m_snapRadius, m_popupPaletteSize / 2 - m_snapRadius);
        rect = QRect(point.x(), point.y(), m_snapRadius*2, m_snapRadius*2);
        i++;
    }
    i = 0;
    for (QLineF &line: m_snapLines) {
        qreal penWidth = BORDER_WIDTH / 2;
        QPointF point1 = drawPointOnAngle(i * 15, m_popupPaletteSize / 2 - m_rotationTrackSize + penWidth);
        point1 += QPointF(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
        QPointF point2 = drawPointOnAngle(i * 15, m_popupPaletteSize / 2 - BORDER_WIDTH - penWidth);
        point2 += QPointF(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
        line = QLineF(point1, point2);
        i++;
    }
}

References BORDER_WIDTH, drawPointOnAngle(), m_popupPaletteSize, m_rotationTrackSize, m_snapLines, m_snapRadius, and m_snapRects.

createPathFromPresetIndex()

QPainterPath KisPopupPalette::createPathFromPresetIndex ( int index ) const

private

Definition at line 1496 of file kis_popup_palette.cpp.

{
    // how many degrees each slice will get
    // if the slot count is 1, we must divide by 2 to get 180 for the algorithm to work
    qreal angleSlice = 360.0 / qMax(m_presetSlotCount, 2);
    // the starting angle of the slice we need to draw. the negative sign makes us go clockwise.
    // adding 90 degrees makes us start at the top. otherwise we would start at the right
    qreal startingAngle = -(index * angleSlice) + 90;
    qreal length = m_cachedPresetLayout.firstRowPos;
    qreal radius = m_cachedPresetLayout.firstRowRadius;
    switch (m_cachedPresetLayout.ringCount) {
    case 1: break;
    case 2: {
        angleSlice = 180.0/((m_presetSlotCount+1) / 2);
        startingAngle = -(index * angleSlice) + 90;
 
        if (index % 2) {
            length = m_cachedPresetLayout.secondRowPos;
            radius = m_cachedPresetLayout.secondRowRadius;
        }
        break;
    }
    case 3: {
        int triplet = index / 3;
        angleSlice = 180.0 / ((m_presetSlotCount + 2) / 3);
        switch (index % 3) {
        case 0:
            startingAngle = -(triplet * 2 * angleSlice) + 90;
            length = m_cachedPresetLayout.firstRowPos;
            radius = m_cachedPresetLayout.firstRowRadius;
            break;
        case 1:
            startingAngle = -(triplet * 2 * angleSlice) + 90;
            length = m_cachedPresetLayout.thirdRowPos;
            radius = m_cachedPresetLayout.thirdRowRadius;
            break;
        case 2:
            startingAngle = -((triplet * 2 + 1) * angleSlice) + 90;
            length = m_cachedPresetLayout.secondRowPos;
            radius = m_cachedPresetLayout.secondRowRadius;
            break;
        default:
            KIS_ASSERT(false);
        }
        break;
    }
    default:
        KIS_ASSERT_RECOVER_NOOP(false);
    }
    QPainterPath path;
    qreal pathX = length * qCos(qDegreesToRadians(startingAngle)) - radius;
    qreal pathY = -(length) * qSin(qDegreesToRadians(startingAngle)) - radius;
    qreal pathDiameter = 2 * radius; // distance is used to calculate the X/Y in addition to the preset circle size
    path.addEllipse(pathX, pathY, pathDiameter, pathDiameter);
    return path;
}

References CachedPresetLayout::firstRowPos, CachedPresetLayout::firstRowRadius, KIS_ASSERT, KIS_ASSERT_RECOVER_NOOP, length(), m_cachedPresetLayout, m_presetSlotCount, CachedPresetLayout::ringCount, CachedPresetLayout::secondRowPos, CachedPresetLayout::secondRowRadius, CachedPresetLayout::thirdRowPos, and CachedPresetLayout::thirdRowRadius.

dismiss()

void KisPopupPalette::dismiss ( )

overridevirtual

Called when you want to dismiss a popup widget.

Implements KisPopupWidgetInterface.

Definition at line 1089 of file kis_popup_palette.cpp.

{
    setVisible(false);
}

drawDonutPathAngle()

QPainterPath KisPopupPalette::drawDonutPathAngle ( int inner_radius, int outer_radius, int limit )

private

Definition at line 790 of file kis_popup_palette.cpp.

{
    QPainterPath path;
    path.moveTo(-0.999 * outer_radius * sin(M_PI / limit), 0.999 * outer_radius * cos(M_PI / limit));
    path.arcTo(-1 * outer_radius, -1 * outer_radius, 2 * outer_radius, 2 * outer_radius, -90.0 - 180.0 / limit,
               360.0 / limit);
    path.arcTo(-1 * inner_radius, -1 * inner_radius, 2 * inner_radius, 2 * inner_radius, -90.0 + 180.0 / limit,
               - 360.0 / limit);
    path.closeSubpath();
 
    return path;
}

References M_PI.

drawDonutPathFull()

QPainterPath KisPopupPalette::drawDonutPathFull ( int x, int y, int inner_radius, int outer_radius )

private

Definition at line 780 of file kis_popup_palette.cpp.

{
    QPainterPath path;
    path.addEllipse(QPointF(x, y), outer_radius, outer_radius);
    path.addEllipse(QPointF(x, y), inner_radius, inner_radius);
    path.setFillRule(Qt::OddEvenFill);
 
    return path;
}

drawFgBgColorIndicator()

QPainterPath KisPopupPalette::drawFgBgColorIndicator ( int type ) const

private

Definition at line 803 of file kis_popup_palette.cpp.

{
    QPointF edgePoint = QPointF(0.14645, 0.14645) * (m_popupPaletteSize);
    
    // the points are really (-5, 15) and (5, 15) shifted right 1px
    // this is so that where the circles meet the circle of the palette, the space occupied is exactly half to either side of the -45deg line
    QPainterPath indicator;
    switch (type) {
        case 0: { // background
            indicator.addEllipse(edgePoint + QPointF(-4, 15), 30, 30);
            break;
        }
        case 1: { //foreground
            indicator.addEllipse(edgePoint + QPointF(6, -15), 30, 30);
            break;
        }
    }
    return indicator;
}

References m_popupPaletteSize.

drawPointOnAngle()

QPointF KisPopupPalette::drawPointOnAngle ( qreal angle, qreal radius ) const

private

Definition at line 1225 of file kis_popup_palette.cpp.

{
    QPointF p(
        // -90 so it starts at the top since this is mainly used by calculatePresetLayout
        radius * qCos(qDegreesToRadians(angle - 90)),
        radius * qSin(qDegreesToRadians(angle - 90))
    );
    return p;
}

References p.

ensureWithinParent()

void KisPopupPalette::ensureWithinParent	(	const QPoint &	globalPos,
		bool	useUpperLeft )

Definition at line 1099 of file kis_popup_palette.cpp.

                                                                                   {
    if (isVisible())  {
        const QSize paletteSize = geometry().size();
        const QPoint paletteCenterOffset(paletteSize.width() / 2, paletteSize.height() / 2);
 
        QPoint paletteGlobalPos = globalPos;
        if (!useUpperLeft) {
            paletteGlobalPos -= paletteCenterOffset;
        }
 
        if (parentWidget()) {
            const qreal widgetMargin = -20.0;
 
            const QPoint paletteParentPos = parentWidget()->mapFromGlobal(paletteGlobalPos);
            QRect paletteParentRect(paletteParentPos, paletteSize);
 
            const QRect fitRect = kisGrowRect(parentWidget()->rect(), widgetMargin);
            paletteParentRect = kisEnsureInRect(paletteParentRect, fitRect);
            paletteGlobalPos = parentWidget()->mapToGlobal(paletteParentRect.topLeft());
        }
 
 
        const QPoint moveToPoint = this->windowHandle() ? paletteGlobalPos : parentWidget()->mapFromGlobal(paletteGlobalPos);
 
        move(moveToPoint);
    }
}

References kisEnsureInRect(), kisGrowRect(), and paletteSize.

eventFilter()

bool KisPopupPalette::eventFilter ( QObject * , QEvent * event )

overrideprotected

Definition at line 984 of file kis_popup_palette.cpp.

{
    switch (event->type()) {
    case QEvent::TouchBegin:
        m_touchBeginReceived = true;
        break;
    case QEvent::MouseButtonPress:
    case QEvent::MouseMove:
        // HACK(sh_zam): Let's say the tap gesture is used by the canvas to launch the popup. Following that, a
        // synthesized mousePress is sent and this arrives in our event filter here. But, this event was meant for the
        // canvas (even though it blocks it), so we only act on the event if we got a TouchBegin on it first.
        if (static_cast<QMouseEvent *>(event)->source() == Qt::MouseEventSynthesizedBySystem && !m_touchBeginReceived) {
            event->accept();
            return true;
        }
        break;
    case QEvent::MouseButtonRelease:
        if (static_cast<QMouseEvent *>(event)->source() == Qt::MouseEventSynthesizedBySystem && !m_touchBeginReceived) {
            event->accept();
            return true;
        }
        // fallthrough
    case QEvent::Show:
    case QEvent::FocusOut:
        m_touchBeginReceived = false;
        break;
    default:
        break;
    }
    return false;
}

References m_touchBeginReceived, and source().

findPresetSlot()

int KisPopupPalette::findPresetSlot ( QPointF position ) const

protected

/ find the index of the brush preset slot containing @position.

Returns

-1 if none is found

Definition at line 1573 of file kis_popup_palette.cpp.

{
    QPointF adjustedPoint = position - QPointF(m_popupPaletteSize/2, m_popupPaletteSize/2);
    for (int i = 0; i < m_presetSlotCount; i++) {
        if (createPathFromPresetIndex(i).contains(adjustedPoint)) {
            return i;
        }
    }
    return -1;
}

References createPathFromPresetIndex(), m_popupPaletteSize, and m_presetSlotCount.

finished

void KisPopupPalette::finished ( )

overridesignal

hoveredColor()

int KisPopupPalette::hoveredColor ( ) const

protected

Definition at line 479 of file kis_popup_palette.cpp.

{
    return m_hoveredColor;
}

References m_hoveredColor.

hoveredPreset()

int KisPopupPalette::hoveredPreset ( ) const

protected

Definition at line 469 of file kis_popup_palette.cpp.

{
    return m_hoveredPreset;
}

References m_hoveredPreset.

isPointInPixmap()

bool KisPopupPalette::isPointInPixmap ( QPointF & point, int pos )

private

Definition at line 1217 of file kis_popup_palette.cpp.

{
    if (createPathFromPresetIndex(pos).contains(point + QPointF(-m_popupPaletteSize / 2, -m_popupPaletteSize / 2))) {
        return true;
    }
    return false;
}

References createPathFromPresetIndex(), and m_popupPaletteSize.

mouseMoveEvent()

void KisPopupPalette::mouseMoveEvent ( QMouseEvent * event )

overrideprotected

Definition at line 833 of file kis_popup_palette.cpp.

{
    QPointF point = event->localPos();
    event->accept();
 
    if (m_showRotationTrack) {
        // check if mouse is over the canvas rotation knob
        bool wasOverRotationIndicator = m_isOverCanvasRotationIndicator;
        m_isOverCanvasRotationIndicator = m_canvasRotationIndicatorRect.contains(point);
        bool wasOverResetRotationIndicator = m_isOverResetCanvasRotationIndicator;
        m_isOverResetCanvasRotationIndicator = m_resetCanvasRotationIndicatorRect.contains(point);
 
        if (
            wasOverRotationIndicator != m_isOverCanvasRotationIndicator ||
            wasOverResetRotationIndicator != m_isOverResetCanvasRotationIndicator
        ) {
            update();
        }
 
        if (m_isRotatingCanvasIndicator) {
            m_snapRotation = false;
            int i = 0;
            for (QRect &rect: m_snapRects) {
                QPainterPath circle;
                circle.addEllipse(rect);
                if (circle.contains(point)) {
                    m_snapRotation = true;
                    m_rotationSnapAngle = i * 15;
                    break;
                }
                i++;
            }
            qreal finalAngle = 0.0;
            if (m_snapRotation) {
                finalAngle = m_rotationSnapAngle;
                // to match the numbers displayed when rotating without snapping
                if (finalAngle >= 270) {
                    finalAngle = finalAngle - 360;
                }
            } else {
                // we are rotating the canvas, so calculate the rotation angle based off the center
                // calculate the angle we are at first
                QPoint widgetCenterPoint = QPoint(m_popupPaletteSize/2, m_popupPaletteSize/2);
 
                qreal dX = point.x() - widgetCenterPoint.x();
                qreal dY = point.y() - widgetCenterPoint.y();
 
 
                finalAngle = qAtan2(dY,dX) * 180 / M_PI; // what we need if we have two points, but don't know the angle
                finalAngle = finalAngle + 90; // add 90 degrees so 0 degree position points up
            }
            qreal angleDifference = finalAngle - m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs, so find it out
 
            KisCanvasController *canvasController =
                dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
            KIS_ASSERT_RECOVER_RETURN(canvasController);
            canvasController->rotateCanvas(angleDifference);
            m_canvasRotationIndicatorRect = rotationIndicatorRect(finalAngle);
 
            update();
            Q_EMIT sigUpdateCanvas();
        }
    }
 
    if (m_isRotatingCanvasIndicator == false) {
        QPainterPath bgColor(drawFgBgColorIndicator(0));
        QPainterPath fgColor(drawFgBgColorIndicator(1));
        QPainterPath backgroundContainer;
        QRectF circleRect(BORDER_WIDTH / 2, BORDER_WIDTH / 2, m_popupPaletteSize - BORDER_WIDTH, m_popupPaletteSize - BORDER_WIDTH);
        backgroundContainer.addEllipse(circleRect);
        
        QPainterPath fgBgColors = (fgColor + bgColor) - backgroundContainer;
        
        if (fgBgColors.contains(point)) {
            if (!m_isOverFgBgColors) {
                m_isOverFgBgColors = true;
                setToolTip(i18n("Click to swap foreground and background colors.\nRight click to set to black and white."));
                update();
            }
        } else {
            if (m_isOverFgBgColors) {
                m_isOverFgBgColors = false;
                setToolTip(QString());
                update();
            }
        }
 
        QPainterPath colorHistoryPath(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
        if (colorHistoryPath.contains(point)) {
            if (hoveredPreset() >= 0) {
                setToolTip(QString());
                setHoveredPreset(-1);
            }
 
            int pos = calculateColorIndex(point, m_resourceManager->recentColorsTotal());
 
            if (pos != hoveredColor()) {
                setHoveredColor(pos);
                update();
            }
        }
        else {
            if (hoveredColor() >= 0) {
                setHoveredColor(-1);
                update();
            }
 
            int pos = findPresetSlot(point);
 
            if (pos != hoveredPreset()) {
 
                if (pos >= 0 && pos < m_resourceManager->numFavoritePresets()) {
                    setToolTip(m_resourceManager->favoritePresetNamesList().at(pos));
                    setHoveredPreset(pos);
                }
                else {
                    setToolTip(QString());
                    setHoveredPreset(-1);
                }
 
                update();
            }
        }
    }
}

References BORDER_WIDTH, calculateColorIndex(), KisViewManager::canvasBase(), KoCanvasBase::canvasController(), drawDonutPathFull(), drawFgBgColorIndicator(), KisFavoriteResourceManager::favoritePresetNamesList(), findPresetSlot(), hoveredColor, hoveredPreset, KIS_ASSERT_RECOVER_RETURN, m_canvasRotationIndicatorRect, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_coordinatesConverter, m_isOverCanvasRotationIndicator, m_isOverFgBgColors, m_isOverResetCanvasRotationIndicator, m_isRotatingCanvasIndicator, M_PI, m_popupPaletteSize, m_resetCanvasRotationIndicatorRect, m_resourceManager, m_rotationSnapAngle, m_showRotationTrack, m_snapRects, m_snapRotation, m_viewManager, KisFavoriteResourceManager::recentColorsTotal(), KisCanvasController::rotateCanvas(), KisCoordinatesConverter::rotationAngle(), rotationIndicatorRect(), setHoveredColor(), setHoveredPreset(), and sigUpdateCanvas().

mousePressEvent()

void KisPopupPalette::mousePressEvent ( QMouseEvent * event )

overrideprotected

Definition at line 959 of file kis_popup_palette.cpp.

{
    event->accept();
 
    if (event->button() == Qt::LeftButton) {
        if (m_showRotationTrack) {
            if (m_isOverCanvasRotationIndicator) {
                m_isRotatingCanvasIndicator = true;
                update();
            }
 
            if (m_isOverResetCanvasRotationIndicator) {
                qreal angleDifference = -m_coordinatesConverter->rotationAngle(); // the rotation function accepts diffs
                KisCanvasController *canvasController =
                        dynamic_cast<KisCanvasController*>(m_viewManager->canvasBase()->canvasController());
                KIS_ASSERT_RECOVER_RETURN(canvasController);
                canvasController->rotateCanvas(angleDifference);
                m_canvasRotationIndicatorRect = rotationIndicatorRect(0);
 
                Q_EMIT sigUpdateCanvas();
            }
        }
    }
}

References KisViewManager::canvasBase(), KoCanvasBase::canvasController(), KIS_ASSERT_RECOVER_RETURN, m_canvasRotationIndicatorRect, m_coordinatesConverter, m_isOverCanvasRotationIndicator, m_isOverResetCanvasRotationIndicator, m_isRotatingCanvasIndicator, m_showRotationTrack, m_viewManager, KisCanvasController::rotateCanvas(), KisCoordinatesConverter::rotationAngle(), rotationIndicatorRect(), and sigUpdateCanvas().

mouseReleaseEvent()

void KisPopupPalette::mouseReleaseEvent ( QMouseEvent * event )

overrideprotected

We are in native and modal mode, so handle our closure ourselves

Definition at line 1151 of file kis_popup_palette.cpp.

{
    QPointF point = event->localPos();
    event->accept();
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    const QPointF localPos = event->localPos();
#else
    const QPointF localPos = event->position();
#endif
 
     if (this->windowHandle() && !QRectF(rect()).contains(localPos)) {
        Q_EMIT finished();
        return;
    }
 
    if (m_isRotatingCanvasIndicator) {
        update();
    }
 
    m_isRotatingCanvasIndicator = false;
 
    if (event->button() == Qt::LeftButton) {
        if (m_isOverFgBgColors) {
            m_viewManager->slotToggleFgBg();
        }
        
        //in favorite brushes area
        if (hoveredPreset() > -1) {
            //setSelectedBrush(hoveredBrush());
            Q_EMIT sigChangeActivePaintop(hoveredPreset());
        }
 
        if (m_showColorHistory) {
            QPainterPath pathColor(drawDonutPathFull(m_popupPaletteSize / 2, m_popupPaletteSize / 2, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
            if (pathColor.contains(point)) {
                int pos = calculateColorIndex(point, m_resourceManager->recentColorsTotal());
 
                if (pos >= 0 && pos < m_resourceManager->recentColorsTotal()) {
                    Q_EMIT sigUpdateRecentColor(pos);
                }
            }
        }
    } else if (event->button() == Qt::RightButton) {
        Q_EMIT finished();
    }
}

References calculateColorIndex(), drawDonutPathFull(), finished(), hoveredPreset, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_isOverFgBgColors, m_isRotatingCanvasIndicator, m_popupPaletteSize, m_resourceManager, m_showColorHistory, m_viewManager, KisFavoriteResourceManager::recentColorsTotal(), sigChangeActivePaintop(), sigUpdateRecentColor(), and KisViewManager::slotToggleFgBg().

onScreen()

bool KisPopupPalette::onScreen ( )

overridevirtual

Returns whether the widget is active (on screen) or not.

Implements KisPopupWidgetInterface.

Definition at line 1094 of file kis_popup_palette.cpp.

{
    return isVisible();
}

paintEvent()

void KisPopupPalette::paintEvent ( QPaintEvent * e )

overrideprotected

Definition at line 564 of file kis_popup_palette.cpp.

{
    Q_UNUSED(e);
 
    QPainter painter(this);
 
    QPen pen(palette().color(QPalette::Text), BORDER_WIDTH);
    painter.setPen(pen);
 
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setRenderHint(QPainter::SmoothPixmapTransform);
 
    if (m_isOverFgBgColors) {
        painter.save();
        painter.setPen(QPen(palette().color(QPalette::Highlight), BORDER_WIDTH));
    }
    
    // painting background color indicator
    QPainterPath bgColor(drawFgBgColorIndicator(0));
    painter.fillPath(bgColor, m_displayRenderer->toQColor(m_resourceManager->bgColor()));
    painter.drawPath(bgColor);
 
    // painting foreground color indicator
    QPainterPath fgColor(drawFgBgColorIndicator(1));
    painter.fillPath(fgColor, m_displayRenderer->toQColor(m_colorSelector->getCurrentColor()));
    painter.drawPath(fgColor);
    
    if (m_isOverFgBgColors) painter.restore();
    
 
    // create a circle background that everything else will go into
    QPainterPath backgroundContainer;
 
    // draws the circle halfway into the border so that the border never goes past the bounds of the popup
    QRectF circleRect(BORDER_WIDTH/2, BORDER_WIDTH/2, m_popupPaletteSize - BORDER_WIDTH, m_popupPaletteSize - BORDER_WIDTH);
    backgroundContainer.addEllipse(circleRect);
    painter.fillPath(backgroundContainer, palette().brush(QPalette::Window));
    painter.drawPath(backgroundContainer);
 
    if (m_showRotationTrack) {
        painter.save();
        QPen pen(palette().color(QPalette::Window).lighter(150), 2);
        painter.setPen(pen);
 
        // draw rotation snap lines
        if (m_isRotatingCanvasIndicator) {
            for (QLineF &line: m_snapLines) {
                painter.drawLine(line);
            }
        }
        // create a path slightly inside the container circle. this will create a 'track' to indicate that we can rotate the canvas
        // with the indicator
        QPainterPath rotationTrackPath;
        QRectF circleRect2(m_rotationTrackSize, m_rotationTrackSize,
                        m_popupPaletteSize - m_rotationTrackSize * 2, m_popupPaletteSize - m_rotationTrackSize * 2);
 
        rotationTrackPath.addEllipse(circleRect2);
        painter.drawPath(rotationTrackPath);
        
        // create a reset canvas rotation indicator to bring the canvas back to 0 degrees
        QRectF resetRotationIndicator = m_resetCanvasRotationIndicatorRect;
 
        pen.setColor(m_isOverResetCanvasRotationIndicator
            ? palette().color(QPalette::Highlight)
            : palette().color(QPalette::Text));
        // cover the first snap line
        painter.setBrush(palette().brush(QPalette::Window));
        painter.setPen(pen);
        painter.drawEllipse(resetRotationIndicator);
 
        // create the canvas rotation handle
        // highlight if either just hovering or currently rotating
        pen.setColor(m_isOverCanvasRotationIndicator || m_isRotatingCanvasIndicator
            ? palette().color(QPalette::Highlight)
            : palette().color(QPalette::Text));
        painter.setPen(pen);
        
        // fill with highlight if snapping
        painter.setBrush(m_isRotatingCanvasIndicator && m_snapRotation
            ? palette().brush(QPalette::Highlight)
            : palette().brush(QPalette::Text));
        
        // gotta update the rect, see bug 459801
        // (note: it can't just update when it shows up because then rotating when popup palette is on the screen wouldn't make an effect)
        m_canvasRotationIndicatorRect = rotationIndicatorRect(m_coordinatesConverter->rotationAngle());
        painter.drawEllipse(m_canvasRotationIndicatorRect);
 
        painter.restore();
    }
    
    // the following things needs to be based off the center, so let's translate the painter
    painter.translate(m_popupPaletteSize / 2, m_popupPaletteSize / 2);
 
    // painting favorite brushes
    QList<QImage> images(m_resourceManager->favoritePresetImages());
    
    // painting favorite brushes pixmap/icon
    QPainterPath presetPath;
    int presetCount = images.size();
    bool isTagEmpty = presetCount == 0;
    for (int pos = 0; pos < m_presetSlotCount; pos++) {
        painter.save();
        presetPath = createPathFromPresetIndex(pos);
 
        if (pos < presetCount) {
            painter.setClipPath(presetPath);
 
            QRect bounds = presetPath.boundingRect().toAlignedRect();
            if (!images.at(pos).isNull()) {
                QImage previewHighDPI = images.at(pos).scaled(bounds.size()*devicePixelRatioF() , Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
                previewHighDPI.setDevicePixelRatio(devicePixelRatioF());
                painter.drawImage(bounds.topLeft(), previewHighDPI);
            }
        } else {
            painter.fillPath(presetPath, palette().brush(QPalette::Window));  // brush slot that has no brush in it
        }
        // needs to be called here so that the clipping is removed
        painter.restore();
        // if the slot is empty, stroke it slightly darker
        QColor color = isTagEmpty || pos >= presetCount
            ? palette().color(QPalette::Window).lighter(150)
            : palette().color(QPalette::Text);
        painter.setPen(QPen(color, 1));
        painter.drawPath(presetPath);
    }
    if (hoveredPreset() > -1) {
        presetPath = createPathFromPresetIndex(hoveredPreset());
        painter.setPen(QPen(palette().color(QPalette::Highlight), BORDER_WIDTH));
        painter.drawPath(presetPath);
    }
 
    if (m_showColorHistory) {
        // paint recent colors area.
        painter.setPen(Qt::NoPen);
        const qreal rotationAngle = 360.0 / m_resourceManager->recentColorsTotal();
        const qreal rotationOffset = 180.0;
 
        painter.rotate(rotationOffset);
 
        // there might be no recent colors at the start, so paint a placeholder
        if (m_resourceManager->recentColorsTotal() == 0) {
            painter.setBrush(Qt::transparent);
 
            QPainterPath emptyRecentColorsPath(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
            painter.setPen(QPen(palette().color(QPalette::Window).lighter(150), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
            painter.drawPath(emptyRecentColorsPath);
        } else {
            for (int pos = 0; pos < m_resourceManager->recentColorsTotal(); pos++) {
                QPainterPath recentColorsPath(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
 
                //accessing recent color of index pos
                painter.fillPath(recentColorsPath, m_displayRenderer->toQColor( m_resourceManager->recentColorAt(pos) ));
                painter.drawPath(recentColorsPath);
                painter.rotate(rotationAngle);
            }
        }
 
        // painting hovered color
        if (hoveredColor() > -1) {
            painter.setPen(QPen(palette().color(QPalette::Highlight), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
            if (m_resourceManager->recentColorsTotal() == 1) {
                QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
                painter.drawPath(path_ColorDonut);
            } else {
                painter.rotate((m_resourceManager->recentColorsTotal() + hoveredColor()) * rotationAngle);
                QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
                painter.drawPath(path);
                painter.rotate(hoveredColor() * -1 * rotationAngle);
            }
        }
 
        // painting selected color
        if (selectedColor() > -1) {
            painter.setPen(QPen(palette().color(QPalette::Highlight).darker(130), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
 
            if (m_resourceManager->recentColorsTotal() == 1) {
                QPainterPath path_ColorDonut(drawDonutPathFull(0, 0, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius));
                painter.drawPath(path_ColorDonut);
            } else {
                painter.rotate((m_resourceManager->recentColorsTotal() + selectedColor()) * rotationAngle);
                QPainterPath path(drawDonutPathAngle(m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_resourceManager->recentColorsTotal()));
                painter.drawPath(path);
                painter.rotate(selectedColor() * -1 * rotationAngle);
            }
        }
    }
 
 
    // if we are actively rotating the canvas or zooming, make the panel slightly transparent to see the canvas better
    if(m_isRotatingCanvasIndicator || m_isZoomingCanvas) {
        opacityChange->setOpacity(0.4);
    } else {
        opacityChange->setOpacity(1.0);
    }
 
}

References KisFavoriteResourceManager::bgColor(), BORDER_WIDTH, bounds, createPathFromPresetIndex(), drawDonutPathAngle(), drawDonutPathFull(), drawFgBgColorIndicator(), KisFavoriteResourceManager::favoritePresetImages(), KisColorSelectorInterface::getCurrentColor(), hoveredColor, hoveredPreset, m_canvasRotationIndicatorRect, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_colorSelector, m_coordinatesConverter, m_displayRenderer, m_isOverCanvasRotationIndicator, m_isOverFgBgColors, m_isOverResetCanvasRotationIndicator, m_isRotatingCanvasIndicator, m_isZoomingCanvas, m_popupPaletteSize, m_presetSlotCount, m_resetCanvasRotationIndicatorRect, m_resourceManager, m_rotationTrackSize, m_showColorHistory, m_showRotationTrack, m_snapLines, m_snapRotation, opacityChange, palette, KisFavoriteResourceManager::recentColorAt(), KisFavoriteResourceManager::recentColorsTotal(), KisCoordinatesConverter::rotationAngle(), rotationIndicatorRect(), selectedColor, and KoColorDisplayRendererInterface::toQColor().

popup()

void KisPopupPalette::popup ( const QPoint & position )

overridevirtual

Called when and where you want a widget to popup.

Implements KisPopupWidgetInterface.

Definition at line 1081 of file kis_popup_palette.cpp.

                                                  {
    setVisible(true);
    KIS_SAFE_ASSERT_RECOVER_RETURN(parentWidget());
    const QPoint globalPos = parentWidget()->mapToGlobal(position);
    ensureWithinParent(globalPos, false);
    m_mirrorPos = QCursor::pos();
}

References ensureWithinParent(), KIS_SAFE_ASSERT_RECOVER_RETURN, and m_mirrorPos.

reconfigure()

void KisPopupPalette::reconfigure ( )

private

Definition at line 297 of file kis_popup_palette.cpp.

{
    KisConfig config(true);
    m_useDynamicSlotCount = config.readEntry("popuppalette/useDynamicSlotCount", true);
    m_maxPresetSlotCount = config.favoritePresets();
    if (m_useDynamicSlotCount) {
        int presetCount = m_resourceManager->numFavoritePresets();
        // if there are no presets because the tag is empty
        // show the maximum number allowed (they will be painted as empty slots)
        m_presetSlotCount = presetCount == 0
            ? m_maxPresetSlotCount
            : qMin(m_maxPresetSlotCount, m_resourceManager->numFavoritePresets());
    } else {
        m_presetSlotCount = m_maxPresetSlotCount;
    }
    m_popupPaletteSize = config.readEntry("popuppalette/size", 385);
    qreal selectorRadius = config.readEntry("popuppalette/selectorSize", 140) / 2.0;
    
    m_showColorHistory = config.readEntry("popuppalette/showColorHistory", true);
    m_showRotationTrack = config.readEntry("popuppalette/showRotationTrack", true);
    
    m_colorHistoryInnerRadius = selectorRadius + m_presetRingMargin;
    m_colorHistoryOuterRadius = m_colorHistoryInnerRadius;
    if (m_showColorHistory) {
         m_colorHistoryOuterRadius += 20;
         m_clearColorHistoryButton->setVisible(true);
    } else {
         m_clearColorHistoryButton->setVisible(false);
    }
 
    m_mainArea->changeSize(m_popupPaletteSize, m_popupPaletteSize);
 
    bool useVisualSelector = config.readEntry<bool>("popuppalette/usevisualcolorselector", false);
    if (m_colorSelector) {
        // if the selector type changed, delete it
        bool haveVisualSelector = qobject_cast<KisVisualColorSelector*>(m_colorSelector) != 0;
        if (useVisualSelector != haveVisualSelector) {
            delete m_colorSelector;
            m_colorSelector = 0;
        }
    }
    if (!m_colorSelector) {
        if (useVisualSelector) {
            KisVisualColorSelector *selector = new KisVisualColorSelector(this);
            selector->setAcceptTabletEvents(true);
            connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
                    selector, SLOT(slotConfigurationChanged()));
            m_colorSelector = selector;
        }
        else {
            m_colorSelector  = new PopupColorTriangle(m_displayRenderer, this);
            connect(m_colorSelector, SIGNAL(requestCloseContainer()), this, SIGNAL(finished()));
            connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
                    m_colorSelector, SLOT(configurationChanged()));
        }
        m_colorSelector->setDisplayRenderer(m_displayRenderer);
        m_colorSelector->setConfig(true,false);
        m_colorSelector->setVisible(true);
        slotDisplayConfigurationChanged();
        connect(m_colorSelector, SIGNAL(sigNewColor(KoColor)),
                m_colorChangeCompressor.data(), SLOT(start()));
 
    }
 
 
    const int auxButtonSize = 35;
    m_colorSelector->move(m_popupPaletteSize/2 - selectorRadius, m_popupPaletteSize/2 - selectorRadius);
    m_colorSelector->resize(m_popupPaletteSize - 2*m_colorSelector->x(), m_popupPaletteSize - 2*m_colorSelector->y());
 
    // ellipse - to make sure the widget doesn't eat events meant for recent colors or brushes
    //         - needs to be +2 pixels on every side for anti-aliasing to look nice on high dpi displays
    // rectangle - to make sure the area doesn't extend outside of the widget
    QRegion maskedEllipse(-2, -2, m_colorSelector->width() + 4, m_colorSelector->height() + 4, QRegion::Ellipse );
    QRegion maskedRectangle(0, 0, m_colorSelector->width(), m_colorSelector->height(), QRegion::Rectangle);
    QRegion maskedRegion = maskedEllipse.intersected(maskedRectangle);
 
    m_colorSelector->setMask(maskedRegion);
 
    m_dockerHud->setFixedHeight(int(m_popupPaletteSize));
    
    // arranges the buttons around the popup palette
    // buttons are spread out from the center of the set arc length
    
    // the margin in degrees between buttons
    qreal margin = 10.0; 
    // visual center
    qreal center = m_popupPaletteSize/2 - auxButtonSize/2.0;
    qreal length = m_popupPaletteSize/2 + auxButtonSize/2.0 + 5;
    {
        int buttonCount = 2;
        int arcLength = 90;
        // note the int buttonCount/2 is on purpose
        qreal start = arcLength/2 - (buttonCount/2) * margin;
        if (buttonCount % 2 == 0) start += margin / 2;
        int place = 0;
        m_dockerHudButton->setGeometry(
            center + qCos(qDegreesToRadians(start + place*margin))*length,
            center + qSin(qDegreesToRadians(start + place*margin))*length,
            auxButtonSize, auxButtonSize
        );
        place++;
        m_bottomBarButton->setGeometry (
            center + qCos(qDegreesToRadians(start + place*margin))*length,
            center + qSin(qDegreesToRadians(start + place*margin))*length,
            auxButtonSize, auxButtonSize
        );
    }
    {
        int buttonCount = m_showColorHistory ? 2 : 1 ;
        int arcLength = 90;
        int shiftArc = 90;
        // note the int buttonCount/2 is on purpose
        qreal start = shiftArc + arcLength / 2 - (buttonCount/2) * margin;
        if (buttonCount % 2 == 0) start += margin / 2;
        int place = 0;
        if (m_showColorHistory) {
            m_clearColorHistoryButton->setGeometry(
                center + qCos(qDegreesToRadians(start + place * margin)) * length,
                center + qSin(qDegreesToRadians(start + place * margin)) * length,
                auxButtonSize, auxButtonSize);
            place++;
        }
        m_tagsButton->setGeometry(
            center + qCos(qDegreesToRadians(start + place*margin))*length,
            center + qSin(qDegreesToRadians(start + place*margin))*length,
            auxButtonSize, auxButtonSize
        );
    }
    calculatePresetLayout();
}

References calculatePresetLayout(), KisConfig::favoritePresets(), finished(), KisConfigNotifier::instance(), length(), m_bottomBarButton, m_clearColorHistoryButton, m_colorChangeCompressor, m_colorHistoryInnerRadius, m_colorHistoryOuterRadius, m_colorSelector, m_displayRenderer, m_dockerHud, m_dockerHudButton, m_mainArea, m_maxPresetSlotCount, m_popupPaletteSize, m_presetRingMargin, m_presetSlotCount, m_resourceManager, m_showColorHistory, m_showRotationTrack, m_tagsButton, m_useDynamicSlotCount, KisFavoriteResourceManager::numFavoritePresets(), KisConfig::readEntry(), KisVisualColorSelector::setAcceptTabletEvents(), KisColorSelectorInterface::setConfig(), KisColorSelectorInterface::setDisplayRenderer(), slotConfigurationChanged(), and slotDisplayConfigurationChanged().

resizeEvent()

void KisPopupPalette::resizeEvent ( QResizeEvent * resizeEvent )

overrideprotected

When popup is native, its geometry report the global position; then the popup is non-native, its geometry is in its parent's coordinate system.

Definition at line 762 of file kis_popup_palette.cpp.

                                                           {
    Q_UNUSED(resizeEvent);
    calculateRotationSnapAreas();
    m_resetCanvasRotationIndicatorRect = rotationIndicatorRect(0);
    m_canvasRotationIndicatorRect = rotationIndicatorRect(m_coordinatesConverter->rotationAngle());
    // Ensure that the resized geometry fits within the desired rect...
 
    const QPoint globalTopLeft = windowHandle() ?
        geometry().topLeft() :
        parentWidget()->mapToGlobal(geometry().topLeft());
    ensureWithinParent(globalTopLeft, true);
}

References calculateRotationSnapAreas(), ensureWithinParent(), m_canvasRotationIndicatorRect, m_coordinatesConverter, m_resetCanvasRotationIndicatorRect, resizeEvent(), KisCoordinatesConverter::rotationAngle(), and rotationIndicatorRect().

rotationIndicatorRect()

QRectF KisPopupPalette::rotationIndicatorRect ( qreal rotationAngle ) const

private

Definition at line 823 of file kis_popup_palette.cpp.

{
    qreal paletteRadius = 0.5 * m_popupPaletteSize;
    QPointF rotationDialPosition(drawPointOnAngle(rotationAngle, paletteRadius - 10));
    rotationDialPosition += QPointF(paletteRadius, paletteRadius);
    
    QPointF indicatorDiagonal(7.5, 7.5);
    return QRectF(rotationDialPosition - indicatorDiagonal, rotationDialPosition + indicatorDiagonal);
}

References drawPointOnAngle(), and m_popupPaletteSize.

selectedColor()

int KisPopupPalette::selectedColor

(

)

const

Definition at line 489 of file kis_popup_palette.cpp.

{
    return m_selectedColor;
}

References m_selectedColor.

setHoveredColor()

void KisPopupPalette::setHoveredColor ( int x )

protected

Definition at line 484 of file kis_popup_palette.cpp.

{
    m_hoveredColor = x;
}

References m_hoveredColor.

setHoveredPreset()

void KisPopupPalette::setHoveredPreset ( int x )

protected

Definition at line 474 of file kis_popup_palette.cpp.

{
    m_hoveredPreset = x;
}

References m_hoveredPreset.

setParent()

void KisPopupPalette::setParent

(

QWidget *

parent

)

Definition at line 552 of file kis_popup_palette.cpp.

                                               {
    QWidget::setParent(parent);
}

setSelectedColor()

void KisPopupPalette::setSelectedColor

(

int

x

)

Definition at line 494 of file kis_popup_palette.cpp.

{
    m_selectedColor = x;
}

References m_selectedColor.

showBottomBarWidget

void KisPopupPalette::showBottomBarWidget ( bool visible )

privateslot

Definition at line 542 of file kis_popup_palette.cpp.

{
    const bool reallyVisible = visible && m_bottomBarButton->isChecked();
 
    m_bottomBarWidget->setVisible(reallyVisible);
 
    KisConfig cfg(false);
    cfg.setShowPaletteBottomBar(visible);
}

References m_bottomBarButton, m_bottomBarWidget, and KisConfig::setShowPaletteBottomBar().

showEvent()

void KisPopupPalette::showEvent ( QShowEvent * event )

overrideprotected

Definition at line 1127 of file kis_popup_palette.cpp.

{
    m_clicksEater->reset();
 
    // don't set the zoom slider if we are outside of the zoom slider bounds. It will change the zoom level to within
    // the bounds and cause the canvas to jump between the slider's min and max
    if (m_coordinatesConverter->zoomInPercent() > zoomSliderMinValue &&
            m_coordinatesConverter->zoomInPercent() < zoomSliderMaxValue){
        KisSignalsBlocker b(zoomCanvasSlider);
        zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent()); // sync the zoom slider
    }
 
    QWidget::showEvent(event);
}

References m_clicksEater, m_coordinatesConverter, KisMouseClickEater::reset(), zoomCanvasSlider, KoZoomHandler::zoomInPercent(), zoomSliderMaxValue, and zoomSliderMinValue.

showHudWidget

void KisPopupPalette::showHudWidget ( bool visible )

privateslot

Definition at line 532 of file kis_popup_palette.cpp.

{
    m_dockerHud->setIsShown(m_dockerHudButton->isChecked());
    const bool reallyVisible = visible && m_dockerHudButton->isChecked();
    m_dockerHud->setVisible(reallyVisible);
 
    KisConfig cfg(false);
    cfg.setShowBrushHud(visible);
}

References m_dockerHud, m_dockerHudButton, KisDockerHud::setIsShown(), and KisConfig::setShowBrushHud().

sigChangeActivePaintop

void KisPopupPalette::sigChangeActivePaintop ( int )

signal

sigChangefGColor

void KisPopupPalette::sigChangefGColor ( const KoColor & )

signal

sigUpdateCanvas

void KisPopupPalette::sigUpdateCanvas ( )

signal

sigUpdateRecentColor

void KisPopupPalette::sigUpdateRecentColor ( int )

signal

sizeHint()

QSize KisPopupPalette::sizeHint ( ) const

override

Definition at line 557 of file kis_popup_palette.cpp.

{
    // Note: the canvas popup widget system "abuses" the sizeHint to determine
    // the position to show the widget; this does not reflect the true size.
    return QSize(m_popupPaletteSize, m_popupPaletteSize);
}

References m_popupPaletteSize.

slotConfigurationChanged

void KisPopupPalette::slotConfigurationChanged ( )

privateslot

Definition at line 291 of file kis_popup_palette.cpp.

{
    reconfigure();
    layout()->invalidate();
}

References reconfigure().

slotDisplayConfigurationChanged

void KisPopupPalette::slotDisplayConfigurationChanged ( )

privateslot

Definition at line 428 of file kis_popup_palette.cpp.

{
    // Visual Color Selector picks up color space from input
    KoColor col = m_viewManager->canvasResourceProvider()->fgColor();
    const KoColorSpace *paintingCS = m_displayRenderer->getPaintingColorSpace();
    //hack to get around cmyk for now.
    if (paintingCS->colorChannelCount()>3) {
        paintingCS = KoColorSpaceRegistry::instance()->rgb8();
    }
    m_colorSelector->slotSetColorSpace(paintingCS);
    m_colorSelector->slotSetColor(col);
}

References KisViewManager::canvasResourceProvider(), KoColorSpace::colorChannelCount(), KisCanvasResourceProvider::fgColor(), KoColorDisplayRendererInterface::getPaintingColorSpace(), KoColorSpaceRegistry::instance(), m_colorSelector, m_displayRenderer, m_viewManager, KoColorSpaceRegistry::rgb8(), KisColorSelectorInterface::slotSetColor(), and KisColorSelectorInterface::slotSetColorSpace().

slotEmitColorChanged

void KisPopupPalette::slotEmitColorChanged ( )

privateslot

Definition at line 448 of file kis_popup_palette.cpp.

{
    if (isVisible()) {
        update();
        Q_EMIT sigChangefGColor(m_colorSelector->getCurrentColor());
    }
}

References KisColorSelectorInterface::getCurrentColor(), m_colorSelector, and sigChangefGColor().

slotExternalFgColorChanged

void KisPopupPalette::slotExternalFgColorChanged ( const KoColor & color )

privateslot

Definition at line 441 of file kis_popup_palette.cpp.

{
    KisSignalsBlocker b(m_colorSelector);
    m_colorSelector->slotSetColor(color);
    update();
}

References m_colorSelector, and KisColorSelectorInterface::slotSetColor().

slotFitToViewClicked

void KisPopupPalette::slotFitToViewClicked ( )

privateslot

Definition at line 1063 of file kis_popup_palette.cpp.

                                           {
    QAction *action = m_actionCollection->action("zoom_to_fit");
 
    if (action) {
        action->trigger();
    }
 
    // sync zoom slider
    zoomCanvasSlider->setValue(m_coordinatesConverter->zoomInPercent());
}

References KisKActionCollection::action(), m_actionCollection, m_coordinatesConverter, zoomCanvasSlider, and KoZoomHandler::zoomInPercent().

slotRemoveMirrorPos

void KisPopupPalette::slotRemoveMirrorPos ( )

privateslot

Definition at line 1077 of file kis_popup_palette.cpp.

                                          {
    m_actionCollection->action("mirror_canvas_around_cursor")->setProperty("customPosition", QVariant());
}

References KisKActionCollection::action(), and m_actionCollection.

slotSetMirrorPos

void KisPopupPalette::slotSetMirrorPos ( )

privateslot

Definition at line 1074 of file kis_popup_palette.cpp.

                                       {
    m_actionCollection->action("mirror_canvas_around_cursor")->setProperty("customPosition", QVariant(m_mirrorPos));
}

References KisKActionCollection::action(), m_actionCollection, and m_mirrorPos.

slotSetSelectedColor

void KisPopupPalette::slotSetSelectedColor ( int x )

inlineprivateslot

Definition at line 202 of file kis_popup_palette.h.

{ setSelectedColor(x); update(); }

References setSelectedColor().

slotShowTagsPopup

void KisPopupPalette::slotShowTagsPopup ( )

privateslot

Definition at line 1016 of file kis_popup_palette.cpp.

{
    KisTagModel model (ResourceType::PaintOpPresets);
    QVector<QString> tags;
    for (int i = 0; i < model.rowCount(); ++i) {
        QModelIndex idx = model.index(i, 0);
        tags << model.data(idx, Qt::DisplayRole).toString();
    }
 
    //std::sort(tags.begin(), tags.end());
 
    if (!tags.isEmpty()) {
        QMenu menu;
        Q_FOREACH (const QString& tag, tags) {
            menu.addAction(tag)->setData(tag);
        }
 
        QAction *action = menu.exec(QCursor::pos());
        if (action) {
 
            for (int i = 0; i < model.rowCount(); ++i) {
                QModelIndex idx = model.index(i, 0);
                if (model.data(idx, Qt::DisplayRole).toString() == action->data()) {
                    m_resourceManager->setCurrentTag(model.tagForIndex(idx));
                    reconfigure();
                    break;
                }
            }
        }
    } else {
        QWhatsThis::showText(QCursor::pos(),
                             i18n("There are no tags available to show in this popup. To add presets, you need to tag them and then select the tag here."));
    }
 
}

References m_resourceManager, ResourceType::PaintOpPresets, reconfigure(), KisFavoriteResourceManager::setCurrentTag(), and KisTagModel::tagForIndex().

slotUpdate

void KisPopupPalette::slotUpdate ( )

privateslot

Definition at line 456 of file kis_popup_palette.cpp.

                                 {
    int presetCount = m_resourceManager->numFavoritePresets();
    if (m_useDynamicSlotCount && presetCount != m_presetSlotCount) {
         m_presetSlotCount = presetCount == 0
            ? m_maxPresetSlotCount
            : qMin(m_maxPresetSlotCount, presetCount);
        calculatePresetLayout();
    }
    m_canvasRotationIndicatorRect = rotationIndicatorRect(m_coordinatesConverter->rotationAngle());
    update();
}

References calculatePresetLayout(), m_canvasRotationIndicatorRect, m_coordinatesConverter, m_maxPresetSlotCount, m_presetSlotCount, m_resourceManager, m_useDynamicSlotCount, KisFavoriteResourceManager::numFavoritePresets(), KisCoordinatesConverter::rotationAngle(), and rotationIndicatorRect().

slotUpdateIcons

void KisPopupPalette::slotUpdateIcons ( )

slot

Definition at line 513 of file kis_popup_palette.cpp.

{
    this->setPalette(qApp->palette());
 
    for(int i=0; i<this->children().size(); i++) {
        QWidget *w = qobject_cast<QWidget*>(this->children().at(i));
        if (w) {
            w->setPalette(qApp->palette());
        }
    }
    zoomToOneHundredPercentButton->setIcon(m_actionCollection->action("zoom_to_100pct")->icon());
    fitToViewButton->setIcon(m_actionCollection->action("zoom_to_fit")->icon());
    m_dockerHud->slotUpdateIcons();
    m_tagsButton->setIcon(KisIconUtils::loadIcon("tag"));
    m_clearColorHistoryButton->setIcon(KisIconUtils::loadIcon("reload-preset-16"));
    m_bottomBarButton->setOnOffIcons(KisIconUtils::loadIcon("arrow-up"), KisIconUtils::loadIcon("arrow-down"));
    m_dockerHudButton->setOnOffIcons(KisIconUtils::loadIcon("arrow-left"), KisIconUtils::loadIcon("arrow-right"));
}

References KisKActionCollection::action(), fitToViewButton, KisIconUtils::loadIcon(), m_actionCollection, m_bottomBarButton, m_clearColorHistoryButton, m_dockerHud, m_dockerHudButton, m_tagsButton, KisRoundHudButton::setOnOffIcons(), KisDockerHud::slotUpdateIcons(), and zoomToOneHundredPercentButton.

slotZoomSliderChanged

void KisPopupPalette::slotZoomSliderChanged ( int zoom )

privateslot

Definition at line 499 of file kis_popup_palette.cpp.

                                                    {
    Q_EMIT zoomLevelChanged(zoom);
}

References zoomLevelChanged().

slotZoomSliderPressed

void KisPopupPalette::slotZoomSliderPressed ( )

privateslot

Definition at line 503 of file kis_popup_palette.cpp.

{
   m_isZoomingCanvas = true;
}

References m_isZoomingCanvas.

slotZoomSliderReleased

void KisPopupPalette::slotZoomSliderReleased ( )

privateslot

Definition at line 508 of file kis_popup_palette.cpp.

{
    m_isZoomingCanvas = false;
}

References m_isZoomingCanvas.

slotZoomToOneHundredPercentClicked

void KisPopupPalette::slotZoomToOneHundredPercentClicked ( )

privateslot

Definition at line 1052 of file kis_popup_palette.cpp.

                                                         {
    QAction *action = m_actionCollection->action("zoom_to_100pct");
 
    if (action) {
        action->trigger();
    }
 
    // also move the zoom slider to 100% position so they are in sync
    zoomCanvasSlider->setValue(100);
}

References KisKActionCollection::action(), m_actionCollection, and zoomCanvasSlider.

tabletEvent()

void KisPopupPalette::tabletEvent ( QTabletEvent * event )

overrideprotected

Definition at line 1142 of file kis_popup_palette.cpp.

{
    if (event->button() == Qt::RightButton && event->type() == QEvent::TabletPress) {
        m_tabletRightClickPressed = true;
    }
 
    event->ignore();
}

References m_tabletRightClickPressed.

zoomLevelChanged

void KisPopupPalette::zoomLevelChanged ( int )

signal

Member Data Documentation

canvasOnlyButton

KisHighlightedToolButton* KisPopupPalette::canvasOnlyButton {0}

private

Definition at line 170 of file kis_popup_palette.h.

{0};

fitToViewButton

QPushButton* KisPopupPalette::fitToViewButton {0}

private

Definition at line 172 of file kis_popup_palette.h.

{0};

m_actionCollection

KisKActionCollection* KisPopupPalette::m_actionCollection

private

Definition at line 145 of file kis_popup_palette.h.

m_actionManager

KisActionManager* KisPopupPalette::m_actionManager

private

Definition at line 140 of file kis_popup_palette.h.

m_acyclicConnector

KisAcyclicSignalConnector* KisPopupPalette::m_acyclicConnector = 0

private

Definition at line 176 of file kis_popup_palette.h.

m_bottomBarButton

KisRoundHudButton* KisPopupPalette::m_bottomBarButton {0}

private

Definition at line 160 of file kis_popup_palette.h.

{0};

m_bottomBarWidget

QWidget* KisPopupPalette::m_bottomBarWidget {0}

private

Definition at line 149 of file kis_popup_palette.h.

{0};

m_cachedPresetLayout

CachedPresetLayout KisPopupPalette::m_cachedPresetLayout

private

Definition at line 178 of file kis_popup_palette.h.

m_canvasRotationIndicatorRect

QRectF KisPopupPalette::m_canvasRotationIndicatorRect

private

Definition at line 162 of file kis_popup_palette.h.

m_clearColorHistoryButton

KisRoundHudButton* KisPopupPalette::m_clearColorHistoryButton {0}

private

Definition at line 158 of file kis_popup_palette.h.

{0};

m_clicksEater

KisMouseClickEater* KisPopupPalette::m_clicksEater

private

Definition at line 182 of file kis_popup_palette.h.

m_colorChangeCompressor

QScopedPointer<KisSignalCompressor> KisPopupPalette::m_colorChangeCompressor

private

Definition at line 144 of file kis_popup_palette.h.

m_colorHistoryInnerRadius

qreal KisPopupPalette::m_colorHistoryInnerRadius {72.0}

private

Definition at line 151 of file kis_popup_palette.h.

{72.0};

m_colorHistoryOuterRadius

qreal KisPopupPalette::m_colorHistoryOuterRadius {92.0}

private

Definition at line 152 of file kis_popup_palette.h.

{92.0};

m_colorSelector

KisColorSelectorInterface* KisPopupPalette::m_colorSelector {0}

private

Definition at line 142 of file kis_popup_palette.h.

{0};

m_coordinatesConverter

KisCoordinatesConverter* KisPopupPalette::m_coordinatesConverter

private

Definition at line 137 of file kis_popup_palette.h.

m_displayRenderer

const KoColorDisplayRendererInterface* KisPopupPalette::m_displayRenderer

private

Definition at line 143 of file kis_popup_palette.h.

m_dockerHud

KisDockerHud* KisPopupPalette::m_dockerHud {0}

private

Definition at line 148 of file kis_popup_palette.h.

{0};

m_dockerHudButton

KisRoundHudButton* KisPopupPalette::m_dockerHudButton {0}

private

Definition at line 161 of file kis_popup_palette.h.

{0};

m_hoveredColor

int KisPopupPalette::m_hoveredColor {0}

private

Definition at line 126 of file kis_popup_palette.h.

{0};

m_hoveredPreset

int KisPopupPalette::m_hoveredPreset {0}

private

Definition at line 124 of file kis_popup_palette.h.

{0};

m_isOverCanvasRotationIndicator

bool KisPopupPalette::m_isOverCanvasRotationIndicator {false}

private

Definition at line 164 of file kis_popup_palette.h.

{false};

m_isOverFgBgColors

bool KisPopupPalette::m_isOverFgBgColors {false}

private

Definition at line 130 of file kis_popup_palette.h.

{false};

m_isOverResetCanvasRotationIndicator

bool KisPopupPalette::m_isOverResetCanvasRotationIndicator {false}

private

Definition at line 165 of file kis_popup_palette.h.

{false};

m_isRotatingCanvasIndicator

bool KisPopupPalette::m_isRotatingCanvasIndicator {false}

private

Definition at line 166 of file kis_popup_palette.h.

{false};

m_isZoomingCanvas

bool KisPopupPalette::m_isZoomingCanvas {false}

private

Definition at line 167 of file kis_popup_palette.h.

{false};

m_mainArea

QSpacerItem* KisPopupPalette::m_mainArea {0}

private

Definition at line 147 of file kis_popup_palette.h.

{0};

m_maxPresetSlotCount

int KisPopupPalette::m_maxPresetSlotCount {10}

private

Definition at line 122 of file kis_popup_palette.h.

{10};

m_mirrorPos

QPoint KisPopupPalette::m_mirrorPos {}

private

Definition at line 121 of file kis_popup_palette.h.

{};

m_popupPaletteSize

qreal KisPopupPalette::m_popupPaletteSize {385.0}

private

Definition at line 150 of file kis_popup_palette.h.

{385.0};

m_presetRingMargin

qreal KisPopupPalette::m_presetRingMargin {3.0}

private

Definition at line 156 of file kis_popup_palette.h.

{3.0};

m_presetSlotCount

int KisPopupPalette::m_presetSlotCount {10}

private

Definition at line 123 of file kis_popup_palette.h.

{10};

m_resetCanvasRotationIndicatorRect

QRectF KisPopupPalette::m_resetCanvasRotationIndicatorRect

private

Definition at line 163 of file kis_popup_palette.h.

m_resourceManager

KisFavoriteResourceManager* KisPopupPalette::m_resourceManager

private

Definition at line 141 of file kis_popup_palette.h.

m_rotationSnapAngle

qreal KisPopupPalette::m_rotationSnapAngle {0}

private

Definition at line 132 of file kis_popup_palette.h.

{0};

m_rotationTrackSize

qreal KisPopupPalette::m_rotationTrackSize {18.0}

private

Definition at line 154 of file kis_popup_palette.h.

{18.0};

m_selectedColor

int KisPopupPalette::m_selectedColor {0}

private

Definition at line 127 of file kis_popup_palette.h.

{0};

m_showColorHistory

bool KisPopupPalette::m_showColorHistory {true}

private

Definition at line 153 of file kis_popup_palette.h.

{true};

m_showRotationTrack

bool KisPopupPalette::m_showRotationTrack {true}

private

Definition at line 155 of file kis_popup_palette.h.

{true};

m_snapLines

std::array<QLineF, 24> KisPopupPalette::m_snapLines {}

private

Definition at line 135 of file kis_popup_palette.h.

{};

m_snapRadius

qreal KisPopupPalette::m_snapRadius {15}

private

Definition at line 133 of file kis_popup_palette.h.

{15};

m_snapRects

std::array<QRect, 24> KisPopupPalette::m_snapRects {}

private

Definition at line 134 of file kis_popup_palette.h.

{};

m_snapRotation

bool KisPopupPalette::m_snapRotation {false}

private

Definition at line 131 of file kis_popup_palette.h.

{false};

m_tabletRightClickPressed

bool KisPopupPalette::m_tabletRightClickPressed {false}

private

Definition at line 128 of file kis_popup_palette.h.

{false};

m_tagsButton

KisRoundHudButton* KisPopupPalette::m_tagsButton {0}

private

Definition at line 159 of file kis_popup_palette.h.

{0};

m_touchBeginReceived

bool KisPopupPalette::m_touchBeginReceived {false}

private

Definition at line 129 of file kis_popup_palette.h.

{false};

m_useDynamicSlotCount

bool KisPopupPalette::m_useDynamicSlotCount {true}

private

Definition at line 125 of file kis_popup_palette.h.

{true};

m_viewManager

KisViewManager* KisPopupPalette::m_viewManager

private

Definition at line 139 of file kis_popup_palette.h.

mirrorMode

KisHighlightedToolButton* KisPopupPalette::mirrorMode {0}

private

Definition at line 169 of file kis_popup_palette.h.

{0};

opacityChange

QGraphicsOpacityEffect* KisPopupPalette::opacityChange {0}

private

Definition at line 181 of file kis_popup_palette.h.

{0};

zoomCanvasSlider

QSlider* KisPopupPalette::zoomCanvasSlider {0}

private

Definition at line 173 of file kis_popup_palette.h.

{0};

zoomSliderMaxValue

int KisPopupPalette::zoomSliderMaxValue {200}

private

Definition at line 175 of file kis_popup_palette.h.

{200};

zoomSliderMinValue

int KisPopupPalette::zoomSliderMinValue {10}

private

Definition at line 174 of file kis_popup_palette.h.

{10};

zoomToOneHundredPercentButton

QPushButton* KisPopupPalette::zoomToOneHundredPercentButton {0}

private

Definition at line 171 of file kis_popup_palette.h.

{0};

Property Documentation

hoveredColor

int KisPopupPalette::hoveredColor

readwrite

Definition at line 51 of file kis_popup_palette.h.

hoveredPreset

int KisPopupPalette::hoveredPreset

readwrite

Definition at line 50 of file kis_popup_palette.h.

selectedColor

int KisPopupPalette::selectedColor

readwrite

Definition at line 52 of file kis_popup_palette.h.

---

The documentation for this class was generated from the following files:

• libs/ui/kis_popup_palette.h
• libs/ui/kis_popup_palette.cpp