KisScratchPad Class Reference

#include <kis_scratch_pad.h>

Inheritance diagram for KisScratchPad:

Public Slots
QImage	copyScratchpadImageData ()
void	fillBackground ()
void	fillDefault ()
void	fillDocument ()
void	fillDocument (bool fullContent)
void	fillForeground ()
void	fillGradient ()
void	fillGradient (const QPoint &gradientVectorStart, const QPoint &gradientVectorEnd, KisGradientPainter::enumGradientShape gradientShape, KisGradientPainter::enumGradientRepeat gradientRepeat, bool reverseGradient, bool dither)
void	fillLayer (bool fullContent)
	Fill the area with what is on your current canvas.
void	fillPattern (QTransform transform)
void	fillTransparent ()
void	loadScratchpadImage (QImage image)
void	paintCustomImage (const QImage &loadedImage)
void	paintPresetImage ()
void	setFillColor (QColor newColor)
void	setPresetImage (const QImage &image)

Signals
void	colorSelected (const KoColor &color)
void	contentChanged ()
	signal is emitted when scratchpad content is changed (stroke or fill)
void	scaleChanged (qreal scale)
	signal is emitted when scratchpad scale is changed (from zoom canvas or manually)
void	sigUpdateCanvas (const QRect &rect)
void	viewportChanged (const QRect rect)
	signal is emitted when scratchpad viewport has been modified (pan, zoom)

Public Member Functions
bool	canvasZoomLink ()
	return True if the scratchpad zoom level stay in sync with canvas
QRect	contentBounds () const
QImage	cutoutOverlay () const
	return the contents of the area under the cutoutOverlay rect
QRect	imageBounds () const
void	imageUpdated (const QRect &rect)
	KisScratchPad (QWidget *parent=0)
void	panCenter ()
	pan scratchpad content to center content in viewport
void	panTo (qint32 x, qint32 y)
	pan scratchpad content to given position
void	pointerMove (KoPointerEvent *event)
void	pointerPress (KoPointerEvent *event)
void	pointerRelease (KoPointerEvent *event)
void	resetState ()
void	scaleReset ()
	reset scale value (to 1.0) and reinit position
void	scaleToFit ()
	calculate and apply scale to fit content in viewport
qreal	scaleX ()
	return current scale X applied on scratchpad (whatever the zoom source is - canvas zoom or set manually)
qreal	scaleY ()
	return current scale Y applied on scratchpad (whatever the zoom source is - canvas zoom or set manually)
void	setCanvasZoomLink (bool value)
	should the scratchpad zoom level stay in sync with canvas
void	setCutoutOverlayRect (const QRect &rc)
	set the specified rect as the area taken for
void	setModeManually (bool value)
void	setModeType (QString modeName)
	change the mode explicitly to paint, mix, or pan
bool	setScale (qreal scaleX, qreal scaleY)
	allow to manually set scratchpad scale when NOT linked to canvas zoom
void	setupScratchPad (KisCanvasResourceProvider *resourceProvider, const QColor &defaultColor)
QRect	viewportBounds () const
void	wheelDelta (QWheelEvent *event)
	~KisScratchPad () override

Protected Member Functions
void	paintEvent (QPaintEvent *event) override
void	resizeEvent (QResizeEvent *event) override

Private Types
enum	Mode { PAINTING , HOVERING , PANNING , SAMPLING }

Private Slots
void	setOnScreenResolution (qreal scaleX, qreal scaleY)
void	slotConfigChanged ()
void	slotScreenChanged (QScreen *screen)
void	slotUpdateCanvas (const QRect &rect)

Private Member Functions
void	assignNewSurfaceState (const KisMultiSurfaceStateManager::State &newState)
void	beginPan (KoPointerEvent *event)
void	beginStroke (KoPointerEvent *event)
QTransform	documentToWidget () const
void	doPan (KoPointerEvent *event)
void	doStroke (KoPointerEvent *event)
void	endPan (KoPointerEvent *event)
void	endStroke (KoPointerEvent *event)
Mode	modeFromButton (Qt::MouseButton button) const
void	resetWheelDelta ()
void	sample (KoPointerEvent *event)
bool	setScaleImpl (qreal scaleX, qreal scaleY)
void	updateTransformations ()
void	updateViewport ()
bool	updateViewportImpl ()
QTransform	widgetToDocument () const

Private Attributes
bool	isModeManuallySet
bool	isMouseDown
friend	KisScratchPadEventFilter
int	m_accumulatedMouseDelta
qreal	m_canvasScaleX
qreal	m_canvasScaleY
QBrush	m_checkBrush
QCursor	m_colorSamplerCursor
QCursor	m_cursor
QRect	m_cutoutOverlay
KoColor	m_defaultColor
KisDisplayConfig	m_displayConfig
const KoColorProfile *	m_displayProfile
KisScratchPadEventFilter *	m_eventFilter
QScopedPointer< KisToolFreehandHelper >	m_helper
KisPaintingInformationBuilder *	m_infoBuilder
bool	m_linkCanvasZoomLevel
KisMultiSurfaceStateManager::State	m_multiSurfaceState
KisMultiSurfaceStateManager	m_multiSurfaceStateManager
KisNodeGraphListener *	m_nodeListener
KisPaintLayerSP	m_paintLayer
QPointF	m_panDocPoint
QImage	m_presetImage
KisCanvasResourceProvider *	m_resourceProvider
int	m_scaleBorderWidth
QTransform	m_scaleTransform
qreal	m_scratchpadScaleX
qreal	m_scratchpadScaleY
QScopedPointer< KisScreenMigrationTracker >	m_screenMigrationTracker
Mode	m_toolMode
QTransform	m_translateTransform
KisPostExecutionUndoAdapter *	m_undoAdapter
KisUndoStore *	m_undoStore
KisUpdateScheduler *	m_updateScheduler
QRect	m_viewport

Friends
class	KisScratchPadPaintingInformationBuilder

Detailed Description

A scratchpad is a painting canvas with only one zoomlevel and based on a paint layer, not on a KisImage. It can have a blank, tiled background or a gradient background.

Definition at line 44 of file kis_scratch_pad.h.

Member Enumeration Documentation

Mode

enum KisScratchPad::Mode

private

Enumerator
PAINTING
HOVERING
PANNING
SAMPLING

Definition at line 250 of file kis_scratch_pad.h.

              {
        PAINTING,
        HOVERING,
        PANNING,
        SAMPLING
    };

Constructor & Destructor Documentation

KisScratchPad()

KisScratchPad::KisScratchPad

(

QWidget *

parent = 0

)

Definition at line 160 of file kis_scratch_pad.cpp.

    : QWidget(parent)
    , m_toolMode(HOVERING)
    , isModeManuallySet(false)
    , isMouseDown(false)
    , m_linkCanvasZoomLevel(true)
    , m_canvasScaleX(1.0)
    , m_canvasScaleY(1.0)
    , m_scratchpadScaleX(1.0)
    , m_scratchpadScaleY(1.0)
    , m_accumulatedMouseDelta(0)
    , m_paintLayer(0)
    , m_resourceProvider(0)
{
 
    setAutoFillBackground(false);
    setMouseTracking(true);
 
    m_cursor = KisCursor::load("tool_freehand_cursor.xpm", 2, 2);
    m_colorSamplerCursor = KisCursor::load("tool_color_sampler_cursor.xpm", 2, 2);
    setCursor(m_cursor);
 
 
    KisConfig cfg(true);
    QImage checkImage = KisCanvasWidgetBase::createCheckersImage(cfg.checkSize());
    m_checkBrush = QBrush(checkImage);
 
 
    // We are not supposed to use updates here,
    // so just set the listener to null
    m_updateScheduler = new KisUpdateScheduler(0);
    m_undoStore = new KisSurrogateUndoStore();
    m_undoAdapter = new KisPostExecutionUndoAdapter(m_undoStore, m_updateScheduler);
    m_nodeListener = new KisScratchPadNodeListener(this);
 
    connect(this, SIGNAL(sigUpdateCanvas(QRect)), SLOT(slotUpdateCanvas(QRect)), Qt::QueuedConnection);
 
    // filter will be deleted by the QObject hierarchy
    m_eventFilter = new KisScratchPadEventFilter(this);
 
    m_infoBuilder = new KisScratchPadPaintingInformationBuilder(this);
 
    m_scaleBorderWidth = 1;
 
    m_screenMigrationTracker.reset(new KisScreenMigrationTracker(this));
 
    connect(m_screenMigrationTracker.data(), &KisScreenMigrationTracker::sigScreenChanged,
            this, &KisScratchPad::slotScreenChanged);
 
    connect(KisConfigNotifier::instance(), &KisConfigNotifier::configChanged,
            this, &KisScratchPad::slotConfigChanged);
 
    QScreen *screen = m_screenMigrationTracker->currentScreenSafe();
    const int canvasScreenNumber = qApp->screens().indexOf(screen);
 
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
        // proxy's lifetime is managed by QObject hierarchy
        KisRootSurfaceInfoProxy *rootSurfaceInfoProxy = new KisRootSurfaceInfoProxy(this, this);
        m_multiSurfaceStateManager.setRootSurfaceInfoProxy(rootSurfaceInfoProxy);
        connect(rootSurfaceInfoProxy,
                &KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged,
                parent,
                [this] (const KoColorProfile *profile) {
                    auto newState = m_multiSurfaceStateManager.onGuiSurfaceFormatChanged(m_multiSurfaceState, profile);
                    assignNewSurfaceState(newState);
                });
    }
#endif
 
    m_multiSurfaceState = m_multiSurfaceStateManager.createInitializingConfig(false, canvasScreenNumber, nullptr);
}

References assignNewSurfaceState(), KisConfig::checkSize(), KisConfigNotifier::configChanged(), connect(), KisCanvasWidgetBase::createCheckersImage(), KisMultiSurfaceStateManager::createInitializingConfig(), KisConfigNotifier::instance(), KisPlatformPluginInterfaceFactory::instance(), KisScratchPadEventFilter, KisScratchPadPaintingInformationBuilder, KisCursor::load(), m_checkBrush, m_colorSamplerCursor, m_cursor, m_eventFilter, m_infoBuilder, m_multiSurfaceState, m_multiSurfaceStateManager, m_nodeListener, m_scaleBorderWidth, m_screenMigrationTracker, m_undoAdapter, m_undoStore, m_updateScheduler, KisMultiSurfaceStateManager::onGuiSurfaceFormatChanged(), KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged(), KisScreenMigrationTracker::sigScreenChanged(), sigUpdateCanvas(), slotConfigChanged(), slotScreenChanged(), and slotUpdateCanvas().

~KisScratchPad()

KisScratchPad::~KisScratchPad ( )

override

Definition at line 233 of file kis_scratch_pad.cpp.

{
    delete m_infoBuilder;
 
    delete m_undoAdapter;
    delete m_undoStore;
    delete m_updateScheduler;
    delete m_nodeListener;
}

References m_infoBuilder, m_nodeListener, m_undoAdapter, m_undoStore, and m_updateScheduler.

Member Function Documentation

assignNewSurfaceState()

void KisScratchPad::assignNewSurfaceState ( const KisMultiSurfaceStateManager::State & newState )

private

Definition at line 707 of file kis_scratch_pad.cpp.

{
    m_multiSurfaceState = newState;
 
    if (newState.multiConfig.uiDisplayConfig() != m_displayConfig) {
        m_displayConfig = newState.multiConfig.uiDisplayConfig();
        update();
    }
}

References m_displayConfig, m_multiSurfaceState, KisMultiSurfaceStateManager::State::multiConfig, and KisMultiSurfaceDisplayConfig::uiDisplayConfig().

beginPan()

void KisScratchPad::beginPan ( KoPointerEvent * event )

private

Definition at line 445 of file kis_scratch_pad.cpp.

{
    setCursor(QCursor(Qt::ClosedHandCursor));
    m_panDocPoint = event->point;
}

References m_panDocPoint.

beginStroke()

void KisScratchPad::beginStroke ( KoPointerEvent * event )

private

Definition at line 419 of file kis_scratch_pad.cpp.

{
 
    m_helper->initPaint(event,
                        documentToWidget().map(event->point),
                        0,
                        0,
                        m_updateScheduler,
                        m_paintLayer,
                        m_paintLayer->paintDevice()->defaultBounds());
 
 
}

References KisPaintDevice::defaultBounds(), documentToWidget(), m_helper, m_paintLayer, m_updateScheduler, KisPaintLayer::paintDevice, and KoPointerEvent::point.

canvasZoomLink()

bool KisScratchPad::canvasZoomLink

(

)

return True if the scratchpad zoom level stay in sync with canvas

Definition at line 862 of file kis_scratch_pad.cpp.

{
    return m_linkCanvasZoomLevel;
}

References m_linkCanvasZoomLevel.

colorSelected

void KisScratchPad::colorSelected ( const KoColor & color )

signal

contentBounds()

QRect KisScratchPad::contentBounds

(

)

const

Definition at line 665 of file kis_scratch_pad.cpp.

{
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    // -- DIRTY CODE HERE --
    // Call of nonDefaultPixelArea() should return expected result but no, not in all case
    //
    // Doing
    // - fillLayer()
    // - contentBounds() --> return expected QRect() bounds
    //
    // Doing
    // - fillDefault()
    // - do a stroke
    // - contentBounds() --> return empty QRect()
    // - do another stroke
    // - call contentBounds() --> return expected QRect() bounds of 1st stroke, ignoring 2nd stroke
    // - do another stroke
    // - call contentBounds() --> return expected QRect() bounds of 2nd stroke, ignoring 3rd stroke...
    //
    // Not sure what happen here and what's the best and cleanest solution to apply
    // Calling calculateExactBounds/nonDefaultPixelArea multiple times fix the problem, except for 1st stroke
    // for which an empty QRect() is still returned :-/
    paintDevice->calculateExactBounds(true);
    paintDevice->nonDefaultPixelArea();
    paintDevice->calculateExactBounds(true);
    paintDevice->nonDefaultPixelArea();
    paintDevice->calculateExactBounds(true);
 
    return paintDevice->nonDefaultPixelArea();
}

References KisPaintDevice::calculateExactBounds(), m_paintLayer, KisPaintDevice::nonDefaultPixelArea(), and KisPaintLayer::paintDevice.

contentChanged

void KisScratchPad::contentChanged ( )

signal

signal is emitted when scratchpad content is changed (stroke or fill)

copyScratchpadImageData

QImage KisScratchPad::copyScratchpadImageData ( )

slot

Definition at line 945 of file kis_scratch_pad.cpp.

{
    const QRect paintingBounds = m_paintLayer.data()->exactBounds();
    QImage imageData = m_paintLayer->paintDevice()->convertToQImage(0, paintingBounds.x(), paintingBounds.y(), paintingBounds.width(), paintingBounds.height(),
                            KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::internalConversionFlags());
    return imageData;
}

References KisPaintDevice::convertToQImage(), KisSharedPtr< T >::data(), KisPaintLayer::exactBounds(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), m_paintLayer, and KisPaintLayer::paintDevice.

cutoutOverlay()

QImage KisScratchPad::cutoutOverlay

(

)

const

return the contents of the area under the cutoutOverlay rect

Definition at line 867 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return QImage();
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
    QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
    QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
    QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
                                         Qt::IgnoreAspectRatio,
                                         Qt::SmoothTransformation);
 
    return scaledImage;
}

References KisPaintDevice::convertToQImage(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), m_cutoutOverlay, m_paintLayer, KisPaintLayer::paintDevice, and widgetToDocument().

documentToWidget()

QTransform KisScratchPad::documentToWidget ( ) const

private

Definition at line 621 of file kis_scratch_pad.cpp.

{
    return m_translateTransform.inverted() * m_scaleTransform;
}

References m_scaleTransform, and m_translateTransform.

doPan()

void KisScratchPad::doPan ( KoPointerEvent * event )

private

Definition at line 451 of file kis_scratch_pad.cpp.

{
    QPointF docOffset = event->point - m_panDocPoint;
 
    m_translateTransform.translate(-docOffset.x(), -docOffset.y());
    updateTransformations();
    update();
}

References m_panDocPoint, m_translateTransform, and updateTransformations().

doStroke()

void KisScratchPad::doStroke ( KoPointerEvent * event )

private

Definition at line 433 of file kis_scratch_pad.cpp.

{
    m_helper->paintEvent(event);
}

References m_helper.

endPan()

void KisScratchPad::endPan ( KoPointerEvent * event )

private

Definition at line 460 of file kis_scratch_pad.cpp.

{
    Q_UNUSED(event);
 
    // the normal brush editor scratchpad reverts back to paint mode when done
    if (isModeManuallySet) {
        setCursor(QCursor(Qt::OpenHandCursor));
    } else {
        setCursor(m_cursor);
    }
    updateViewport();
}

References isModeManuallySet, m_cursor, and updateViewport().

endStroke()

void KisScratchPad::endStroke ( KoPointerEvent * event )

private

Definition at line 438 of file kis_scratch_pad.cpp.

{
    Q_UNUSED(event);
    m_helper->endPaint();
    Q_EMIT contentChanged();
}

References contentChanged(), and m_helper.

fillBackground

void KisScratchPad::fillBackground ( )

slot

Definition at line 1126 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisTransaction t(paintDevice);
        paintDevice->setDefaultPixel(m_resourceProvider->bgColor());
        paintDevice->clear();
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisCanvasResourceProvider::bgColor(), KisPaintDevice::clear(), contentChanged(), KisTransaction::end(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, and KisPaintDevice::setDefaultPixel().

fillDefault

void KisScratchPad::fillDefault ( )

slot

Definition at line 989 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
 
        KisTransaction t(paintDevice);
        paintDevice->setDefaultPixel(m_defaultColor);
        paintDevice->clear();
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPaintDevice::clear(), contentChanged(), KisTransaction::end(), m_defaultColor, m_paintLayer, m_updateScheduler, KisPaintLayer::paintDevice, and KisPaintDevice::setDefaultPixel().

fillDocument [1/2]

void KisScratchPad::fillDocument ( )

slot

Definition at line 1186 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    fillDocument(false);
}

References fillDocument(), and m_paintLayer.

fillDocument [2/2]

void KisScratchPad::fillDocument ( bool fullContent )

slot

Definition at line 1160 of file kis_scratch_pad.cpp.

{
    QRect sourceRect;
 
    if (!m_paintLayer) return;
 
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    if (fullContent) {
        sourceRect = QRect(0, 0, m_resourceProvider->currentImage()->width(), m_resourceProvider->currentImage()->height());
    } else {
        sourceRect = QRect(0, 0, paintDevice->exactBounds().width(), paintDevice->exactBounds().height());
    }
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisPainter painter(paintDevice);
        painter.beginTransaction();
        painter.bitBlt(QPoint(0, 0), m_resourceProvider->currentImage()->projection(), sourceRect);
        painter.deleteTransaction();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPainter::beginTransaction(), KisPainter::bitBlt(), contentChanged(), KisCanvasResourceProvider::currentImage(), KisPainter::deleteTransaction(), KisPaintDevice::exactBounds(), KisImage::height(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, KisImage::projection(), and KisImage::width().

fillForeground

void KisScratchPad::fillForeground ( )

slot

Definition at line 1143 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisTransaction t(paintDevice);
        paintDevice->setDefaultPixel(m_resourceProvider->fgColor());
        paintDevice->clear();
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPaintDevice::clear(), contentChanged(), KisTransaction::end(), KisCanvasResourceProvider::fgColor(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, and KisPaintDevice::setDefaultPixel().

fillGradient [1/2]

void KisScratchPad::fillGradient ( )

slot

Definition at line 1084 of file kis_scratch_pad.cpp.

{
    // default legacy method
    if (!m_paintLayer) return;
    QRect gradientRect = widgetToDocument().mapRect(rect());
    fillGradient(gradientRect.topLeft(),
                 gradientRect.bottomRight(),
                 KisGradientPainter::GradientShapeLinear,
                 KisGradientPainter::GradientRepeatNone,
                 false,
                 false
                 );
}

References fillGradient(), KisGradientPainter::GradientRepeatNone, KisGradientPainter::GradientShapeLinear, m_paintLayer, and widgetToDocument().

fillGradient [2/2]

void KisScratchPad::fillGradient ( const QPoint & gradientVectorStart, const QPoint & gradientVectorEnd, KisGradientPainter::enumGradientShape gradientShape, KisGradientPainter::enumGradientRepeat gradientRepeat, bool reverseGradient, bool dither )

slot

Definition at line 1034 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    KoAbstractGradientSP gradient = m_resourceProvider->currentGradient();
    QRect gradientRect = widgetToDocument().mapRect(rect());
 
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisTransaction t(paintDevice);
 
        paintDevice->clear();
 
        KisGradientPainter painter(paintDevice);
        painter.setGradient(gradient);
        painter.setGradientShape(gradientShape);
        if (gradientVectorStart == gradientVectorEnd && gradientVectorStart == QPoint()) {
            // start & end are the same and are at origin: use default rect
            painter.paintGradient(gradientRect.topLeft(),
                                  gradientRect.bottomRight(),
                                  gradientRepeat,
                                  0.2,
                                  reverseGradient,
                                  gradientRect.left(), gradientRect.top(),
                                  gradientRect.width(), gradientRect.height(),
                                  dither);
        } else {
            painter.paintGradient(gradientVectorStart,
                                  gradientVectorEnd,
                                  gradientRepeat,
                                  0.2,
                                  reverseGradient,
                                  gradientRect.left(), gradientRect.top(),
                                  gradientRect.width(), gradientRect.height(),
                                  dither);
        }
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPaintDevice::clear(), contentChanged(), KisCanvasResourceProvider::currentGradient(), KisTransaction::end(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, KisGradientPainter::paintGradient(), KisPainter::setGradient(), KisGradientPainter::setGradientShape(), and widgetToDocument().

fillLayer

void KisScratchPad::fillLayer ( bool fullContent )

slot

Fill the area with what is on your current canvas.

Definition at line 1192 of file kis_scratch_pad.cpp.

{
    QRect sourceRect;
 
    if (!m_paintLayer) return;
 
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    if (fullContent) {
        sourceRect = m_resourceProvider->currentNode()->exactBounds();
    } else {
        sourceRect = QRect(0, 0, paintDevice->exactBounds().width(), paintDevice->exactBounds().height());
    }
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisPainter painter(paintDevice);
        painter.beginTransaction();
        painter.bitBlt(QPoint(0, 0), m_resourceProvider->currentNode()->projection(), sourceRect);
        painter.deleteTransaction();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPainter::beginTransaction(), KisPainter::bitBlt(), contentChanged(), KisCanvasResourceProvider::currentNode(), KisPainter::deleteTransaction(), KisBaseNode::exactBounds(), KisPaintDevice::exactBounds(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, and KisBaseNode::projection().

fillPattern

void KisScratchPad::fillPattern ( QTransform transform )

slot

Definition at line 1098 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    KoPatternSP pattern = m_resourceProvider->currentPattern();
 
    QRect patternRect = widgetToDocument().mapRect(rect());
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
 
        KisTransaction t(paintDevice);
 
        paintDevice->clear();
 
        KisFillPainter painter(paintDevice);
        painter.setPattern(pattern);
        painter.setWidth(patternRect.width());
        painter.setHeight(patternRect.height());
        painter.fillPattern(0, 0, paintDevice, transform);
 
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPaintDevice::clear(), contentChanged(), KisCanvasResourceProvider::currentPattern(), KisTransaction::end(), KisFillPainter::fillPattern(), m_paintLayer, m_resourceProvider, m_updateScheduler, KisPaintLayer::paintDevice, KisFillPainter::setHeight(), KisPainter::setPattern(), KisFillPainter::setWidth(), and widgetToDocument().

fillTransparent

void KisScratchPad::fillTransparent ( )

slot

Definition at line 1007 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    QColor transQColor(0,0,0,0);
    KoColor transparentColor(transQColor, KoColorSpaceRegistry::instance()->rgb8());
    transparentColor.setOpacity(0.0);
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
 
        KisTransaction t(paintDevice);
        paintDevice->setDefaultPixel(transparentColor);
        paintDevice->clear();
        t.end();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPaintDevice::clear(), contentChanged(), KisTransaction::end(), KoColorSpaceRegistry::instance(), m_paintLayer, m_updateScheduler, KisPaintLayer::paintDevice, KisPaintDevice::setDefaultPixel(), and KoColor::setOpacity().

imageBounds()

QRect KisScratchPad::imageBounds

(

)

const

Definition at line 636 of file kis_scratch_pad.cpp.

{
    return rect();
}

imageUpdated()

void KisScratchPad::imageUpdated

(

const QRect &

rect

)

Definition at line 697 of file kis_scratch_pad.cpp.

{
    Q_EMIT sigUpdateCanvas(documentToWidget().mapRect(QRectF(rect)).toAlignedRect());
}

References documentToWidget(), and sigUpdateCanvas().

loadScratchpadImage

void KisScratchPad::loadScratchpadImage ( QImage image )

slot

Definition at line 919 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
 
    m_translateTransform.reset(); // image will be loaded at 0,0, so reset panning location
    updateTransformations();
 
    fillDefault(); // wipes out whatever was there before
 
    QRect imageSize = image.rect();
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
    KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
    device->convertFromQImage(image, 0);
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisPainter painter(paintDevice);
        painter.beginTransaction();
        painter.bitBlt(imageSize.topLeft(), device, imageSize);
        painter.deleteTransaction();
    }
 
    update();
}

References KisPainter::beginTransaction(), KisPainter::bitBlt(), KisPaintDevice::colorSpace(), KisPaintDevice::convertFromQImage(), KisPainter::deleteTransaction(), fillDefault(), m_paintLayer, m_translateTransform, m_updateScheduler, KisPaintLayer::paintDevice, and updateTransformations().

modeFromButton()

KisScratchPad::Mode KisScratchPad::modeFromButton ( Qt::MouseButton button ) const

private

Definition at line 243 of file kis_scratch_pad.cpp.

{
    return
        button == Qt::NoButton ? HOVERING :
        button == Qt::MiddleButton ? PANNING :
        button == Qt::RightButton ? SAMPLING :
        PAINTING;
}

References button(), HOVERING, PAINTING, PANNING, and SAMPLING.

paintCustomImage

void KisScratchPad::paintCustomImage ( const QImage & loadedImage )

slot

Paint the icon of a custom image that is being loaded

Definition at line 888 of file kis_scratch_pad.cpp.

{
    // this is 99% copied from the normal paintPresetImage()
    // we don't want to save over the preset image, so we don't
    // want to store it in the m_presetImage
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
    QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
    QRect imageRect(QPoint(), overlayRect.size());
 
    QImage scaledImage = loadedImage.scaled(overlayRect.size(),
                                              Qt::IgnoreAspectRatio,
                                              Qt::SmoothTransformation);
    KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
    device->convertFromQImage(scaledImage, 0);
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisPainter painter(paintDevice);
        painter.beginTransaction();
        painter.bitBlt(overlayRect.topLeft(), device, imageRect);
        painter.deleteTransaction();
    }
 
 
    update();
    Q_EMIT contentChanged();
}

References KisPainter::beginTransaction(), KisPainter::bitBlt(), KisPaintDevice::colorSpace(), contentChanged(), KisPaintDevice::convertFromQImage(), KisPainter::deleteTransaction(), m_cutoutOverlay, m_paintLayer, m_updateScheduler, KisPaintLayer::paintDevice, and widgetToDocument().

paintEvent()

void KisScratchPad::paintEvent ( QPaintEvent * event )

overrideprotected

Definition at line 733 of file kis_scratch_pad.cpp.

                                                     {
    if (!m_paintLayer) return;
 
    QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
 
    QRect alignedImageRect =
        imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
                           m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
 
    QPointF offset = alignedImageRect.topLeft();
 
    m_paintLayer->projectionPlane()->recalculate(alignedImageRect, m_paintLayer, KisRenderPassFlag::None);
    KisPaintDeviceSP projection = m_paintLayer->projection();
 
    QImage image = projection->convertToQImage(m_displayConfig.profile,
                                               alignedImageRect.x(),
                                               alignedImageRect.y(),
                                               alignedImageRect.width(),
                                               alignedImageRect.height(),
                                               m_displayConfig.intent,
                                               m_displayConfig.conversionFlags);
 
 
    QPainter gc(this);
    gc.fillRect(event->rect(), m_checkBrush);
 
    // if we scale down, it should use Smooth
    // if we scale up, it should use Fast (nearest Neighbour) to show pixels
    if (event->rect().width() < image.rect().width()) {
        gc.setRenderHints(QPainter::SmoothPixmapTransform, true);
    } else {
        gc.setRenderHints(QPainter::SmoothPixmapTransform, false); // that will use NN
    }
 
    gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
 
    QBrush brush(Qt::lightGray);
    QPen pen(brush, 1, Qt::DotLine);
    gc.setPen(pen);
    if (m_cutoutOverlay.isValid()) {
        gc.drawRect(m_cutoutOverlay);
    }
 
    if (!isEnabled()) {
        QColor color(Qt::lightGray);
        color.setAlphaF(0.5);
        QBrush disabledBrush(color);
        gc.fillRect(event->rect(), disabledBrush);
    }
    gc.end();
}

References KisDisplayConfig::conversionFlags, KisPaintDevice::convertToQImage(), KisDisplayConfig::intent, m_checkBrush, m_cutoutOverlay, m_displayConfig, m_paintLayer, m_scaleBorderWidth, None, KisDisplayConfig::profile, KisLayer::projection(), KisLayer::projectionPlane, and widgetToDocument().

paintPresetImage

void KisScratchPad::paintPresetImage ( )

slot

Paint the icon of the current preset inside the cutout overlay

See also

setPresetImage

Definition at line 954 of file kis_scratch_pad.cpp.

{
    if (!m_paintLayer) return;
    KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
    QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
    QRect imageRect(QPoint(), overlayRect.size());
 
    QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
                                              Qt::IgnoreAspectRatio,
                                              Qt::SmoothTransformation);
    KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
    device->convertFromQImage(scaledImage, 0);
 
    {
        KisUpdateSchedulerLockWithFeedback l(m_updateScheduler);
        KisPainter painter(paintDevice);
        painter.beginTransaction();
        painter.bitBlt(overlayRect.topLeft(), device, imageRect);
        painter.deleteTransaction();
    }
 
    update();
    Q_EMIT contentChanged();
}

References KisPainter::beginTransaction(), KisPainter::bitBlt(), KisPaintDevice::colorSpace(), contentChanged(), KisPaintDevice::convertFromQImage(), KisPainter::deleteTransaction(), m_cutoutOverlay, m_paintLayer, m_presetImage, m_updateScheduler, KisPaintLayer::paintDevice, and widgetToDocument().

panCenter()

void KisScratchPad::panCenter

(

)

pan scratchpad content to center content in viewport

Definition at line 610 of file kis_scratch_pad.cpp.

                              {
    updateViewportImpl();
 
    QPointF viewportF = QPointF(viewportBounds().width(), viewportBounds().height());
    QRectF contentsF = QRectF(contentBounds());
 
    QPoint panPosition = QPointF( contentsF.center() - viewportF/2 ).toPoint() ;
 
    panTo(panPosition.x(), panPosition.y());
}

References contentBounds(), panTo(), updateViewportImpl(), and viewportBounds().

panTo()

void KisScratchPad::panTo	(	qint32	x,
		qint32	y )

pan scratchpad content to given position

Parameters

x	absissa position to pan to
y	ordinate position to pan to

Definition at line 602 of file kis_scratch_pad.cpp.

                                            {
    m_translateTransform.reset();
    m_translateTransform.translate(x, y);
    updateTransformations();
    update();
    updateViewport();
}

References m_translateTransform, updateTransformations(), and updateViewport().

pointerMove()

void KisScratchPad::pointerMove

(

KoPointerEvent *

event

)

Definition at line 396 of file kis_scratch_pad.cpp.

{
    if (!isEnabled()) return;
    KIS_SAFE_ASSERT_RECOVER_RETURN(event);
 
    if (event->point.isNull() == false) {
        m_helper->cursorMoved(documentToWidget().map(event->point));
    }
 
    if (isMouseDown) {
        if (m_toolMode == PAINTING) {
            doStroke(event);
            event->accept();
        } else if (m_toolMode == PANNING) {
            doPan(event);
            event->accept();
        } else if (m_toolMode == SAMPLING) {
            sample(event);
            event->accept();
        }
    }
}

References documentToWidget(), doPan(), doStroke(), isMouseDown, KIS_SAFE_ASSERT_RECOVER_RETURN, m_helper, m_toolMode, PAINTING, PANNING, KoPointerEvent::point, sample(), and SAMPLING.

pointerPress()

void KisScratchPad::pointerPress

(

KoPointerEvent *

event

)

Definition at line 332 of file kis_scratch_pad.cpp.

{
    if (!isEnabled()) return;
 
    if (isModeManuallySet == false) {
        m_toolMode = modeFromButton(event->button());
    }
 
    // see if we are pressing down with a button
    if (event->button() == Qt::LeftButton ||
        event->button() == Qt::MiddleButton ||
        event->button() == Qt::RightButton) {
        isMouseDown = true;
    } else {
        isMouseDown = false;
    }
 
    // if mouse is down, we are doing one of three things
    if (isMouseDown) {
        if (m_toolMode == PAINTING) {
            beginStroke(event);
            event->accept();
        } else if (m_toolMode == PANNING) {
            beginPan(event);
            event->accept();
        } else if (m_toolMode == SAMPLING) {
            sample(event);
            event->accept();
        }
    }
}

References beginPan(), beginStroke(), KoPointerEvent::button(), isModeManuallySet, isMouseDown, m_toolMode, modeFromButton(), PAINTING, PANNING, sample(), and SAMPLING.

pointerRelease()

void KisScratchPad::pointerRelease

(

KoPointerEvent *

event

)

Definition at line 364 of file kis_scratch_pad.cpp.

{
    if (!isEnabled()) return;
    isMouseDown = false;
 
    if (isModeManuallySet == false) {
        if (modeFromButton(event->button()) != m_toolMode) return;
 
        if (m_toolMode == PAINTING) {
            endStroke(event);
            m_toolMode = HOVERING;
            event->accept();
        } else if (m_toolMode == PANNING) {
            endPan(event);
            m_toolMode = HOVERING;
            event->accept();
        } else if (m_toolMode == SAMPLING) {
            event->accept();
            m_toolMode = HOVERING;
        }
 
    } else {
        if (m_toolMode == PAINTING) {
            endStroke(event);
        } else if (m_toolMode == PANNING) {
            endPan(event);
        }
 
        event->accept();
    }
}

References KoPointerEvent::button(), endPan(), endStroke(), HOVERING, isModeManuallySet, isMouseDown, m_toolMode, modeFromButton(), PAINTING, PANNING, and SAMPLING.

resetState()

void KisScratchPad::resetState

(

)

Definition at line 790 of file kis_scratch_pad.cpp.

{
    if (m_helper->isRunning()) {
        m_helper->endPaint();
    }
 
    m_toolMode = HOVERING;
    setCursor(m_cursor);
}

References HOVERING, m_cursor, m_helper, and m_toolMode.

resetWheelDelta()

void KisScratchPad::resetWheelDelta ( )

private

Definition at line 550 of file kis_scratch_pad.cpp.

{
    m_accumulatedMouseDelta = 0;
}

References m_accumulatedMouseDelta.

resizeEvent()

void KisScratchPad::resizeEvent ( QResizeEvent * event )

overrideprotected

Definition at line 785 of file kis_scratch_pad.cpp.

                                                    {
    updateViewport();
    QWidget::resizeEvent(event);
}

References updateViewport().

sample()

void KisScratchPad::sample ( KoPointerEvent * event )

private

Definition at line 473 of file kis_scratch_pad.cpp.

{
    KoColor color;
    if (KisToolUtils::sampleColor(color, m_paintLayer->projection(), event->point.toPoint())) {
        Q_EMIT colorSelected(color);
    }
}

References colorSelected(), m_paintLayer, KoPointerEvent::point, KisLayer::projection(), and KisToolUtils::sampleColor().

scaleChanged

void KisScratchPad::scaleChanged ( qreal scale )

signal

signal is emitted when scratchpad scale is changed (from zoom canvas or manually)

Parameters

scale

updated scale value

scaleReset()

void KisScratchPad::scaleReset

(

)

reset scale value (to 1.0) and reinit position

Definition at line 591 of file kis_scratch_pad.cpp.

                               {
    // developer must ensure zoom level is not linked with canvas zoom level before
    // calling this method
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_linkCanvasZoomLevel);
 
    if (setScaleImpl(1.0, 1.0)) {
        Q_EMIT scaleChanged(m_scratchpadScaleX);
    }
    panTo(0, 0);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_linkCanvasZoomLevel, m_scratchpadScaleX, panTo(), scaleChanged(), and setScaleImpl().

scaleToFit()

void KisScratchPad::scaleToFit

(

)

calculate and apply scale to fit content in viewport

Definition at line 565 of file kis_scratch_pad.cpp.

                               {
    // developer must ensure zoom level is not linked with canvas zoom level before
    // calling this method
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_linkCanvasZoomLevel);
 
    QRectF viewportF = QRectF(imageBounds());
    QRectF contentsF = QRectF(contentBounds());
    qreal scale;
 
    if (contentsF.isEmpty() || viewportF.isEmpty()) return;
 
    qreal contentRatio = contentsF.width() / contentsF.height();
    qreal viewportRatio = viewportF.width() / viewportF.height();
 
    if (viewportRatio > contentRatio) {
        scale = viewportF.height() / contentsF.height();
    } else {
        scale = viewportF.width() / contentsF.width();
    }
 
    if (setScaleImpl(scale, scale)) {
        Q_EMIT scaleChanged(m_scratchpadScaleX);
    }
    panCenter();
}

References contentBounds(), imageBounds(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_linkCanvasZoomLevel, m_scratchpadScaleX, panCenter(), scaleChanged(), and setScaleImpl().

scaleX()

qreal KisScratchPad::scaleX

(

)

return current scale X applied on scratchpad (whatever the zoom source is - canvas zoom or set manually)

Definition at line 555 of file kis_scratch_pad.cpp.

{
    return m_scratchpadScaleX;
}

References m_scratchpadScaleX.

scaleY()

qreal KisScratchPad::scaleY

(

)

return current scale Y applied on scratchpad (whatever the zoom source is - canvas zoom or set manually)

Definition at line 560 of file kis_scratch_pad.cpp.

{
    return m_scratchpadScaleY;
}

References m_scratchpadScaleY.

setCanvasZoomLink()

void KisScratchPad::setCanvasZoomLink

(

bool

value

)

should the scratchpad zoom level stay in sync with canvas

Parameters

should

we link zoom level

Definition at line 848 of file kis_scratch_pad.cpp.

{
    if (m_linkCanvasZoomLevel != value) {
        m_accumulatedMouseDelta = 0;
        m_linkCanvasZoomLevel = value;
 
        if (m_linkCanvasZoomLevel) {
            // link status updated AND set to True
            // Then need to update scratchPad zoom to canvas zoom immediately
            setOnScreenResolution(m_canvasScaleX, m_canvasScaleY);
        }
    }
}

References m_accumulatedMouseDelta, m_canvasScaleX, m_canvasScaleY, m_linkCanvasZoomLevel, setOnScreenResolution(), and value().

setCutoutOverlayRect()

void KisScratchPad::setCutoutOverlayRect

(

const QRect &

rc

)

set the specified rect as the area taken for

See also

cutoutOverlay

Definition at line 824 of file kis_scratch_pad.cpp.

{
    m_cutoutOverlay = rc;
}

References m_cutoutOverlay.

setFillColor

void KisScratchPad::setFillColor ( QColor newColor )

slot

Definition at line 1029 of file kis_scratch_pad.cpp.

{
    m_defaultColor = KoColor(newColor, KoColorSpaceRegistry::instance()->rgb8());
}

References KoColorSpaceRegistry::instance(), and m_defaultColor.

setModeManually()

void KisScratchPad::setModeManually

(

bool

value

)

keep track of if our scratchpad is in paint, pan, or color sample mode Set to true if there is a GUI controlling current mode If this is false, the modes are only changed with various mouse click shortcuts

Definition at line 829 of file kis_scratch_pad.cpp.

{
    isModeManuallySet = value;
}

References isModeManuallySet, and value().

setModeType()

void KisScratchPad::setModeType

(

QString

modeName

)

change the mode explicitly to paint, mix, or pan

Parameters

what	mode to change it to

Definition at line 834 of file kis_scratch_pad.cpp.

{
    if (mode.toLower() == "painting") {
        m_toolMode = PAINTING;
        setCursor(m_cursor);
    } else if (mode.toLower() == "panning") {
        m_toolMode = PANNING;
        setCursor(Qt::OpenHandCursor);
    } else if (mode.toLower() == "colorsampling") {
        m_toolMode = SAMPLING;
        setCursor(m_colorSamplerCursor);
    }
}

References m_colorSamplerCursor, m_cursor, m_toolMode, PAINTING, PANNING, and SAMPLING.

setOnScreenResolution

void KisScratchPad::setOnScreenResolution ( qreal scaleX, qreal scaleY )

privateslot

Definition at line 481 of file kis_scratch_pad.cpp.

{
    // This method is called only when canvas zoom is changed (sigOnScreenResolutionChanged) AND scratchPad is
    // linked to it
    //
    // Otherwise do nothing
    // If zoom on scratchPad has to be updated, then it has to be updated manually through setScale() method
 
    // value not changed? do nothing
    if (qFuzzyCompare(scaleX, m_canvasScaleX) && qFuzzyCompare(scaleY, m_canvasScaleY)) return;
 
    // always keep in memory canvas zoom, even if link is not active
    m_canvasScaleX = scaleX;
    m_canvasScaleY = scaleY;
 
    // the scratchpad will use the canvas zoom level...or not
    if (m_linkCanvasZoomLevel) {
        m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
        // memorize current scratchPad scale
        m_scratchpadScaleX = scaleX;
        m_scratchpadScaleY = scaleY;
 
        m_scaleTransform = QTransform::fromScale(scaleX, scaleY);
        updateTransformations();
        update();
 
        Q_EMIT scaleChanged(m_scratchpadScaleX);
        updateViewport();
    }
}

References BORDER_SIZE, m_canvasScaleX, m_canvasScaleY, m_linkCanvasZoomLevel, m_scaleBorderWidth, m_scaleTransform, m_scratchpadScaleX, m_scratchpadScaleY, qFuzzyCompare(), scaleChanged(), scaleX(), scaleY(), updateTransformations(), and updateViewport().

setPresetImage

void KisScratchPad::setPresetImage ( const QImage & image )

slot

Set the icon of the current preset

Definition at line 883 of file kis_scratch_pad.cpp.

{
    m_presetImage = image;
}

References m_presetImage.

setScale()

bool KisScratchPad::setScale	(	qreal	scaleX,
		qreal	scaleY )

allow to manually set scratchpad scale when NOT linked to canvas zoom

Parameters

scaleX	zoom level for X
scaleY	zoom level for Y

Returns

if scale is applied, return true otherwise false

Definition at line 513 of file kis_scratch_pad.cpp.

{
    const bool retval = setScaleImpl(scaleX, scaleY);
 
    if (retval) {
        Q_EMIT scaleChanged(m_scratchpadScaleX);
        updateViewport();
    }
 
    return retval;
}

References m_scratchpadScaleX, scaleChanged(), scaleX(), scaleY(), setScaleImpl(), and updateViewport().

setScaleImpl()

bool KisScratchPad::setScaleImpl ( qreal scaleX, qreal scaleY )

private

Definition at line 525 of file kis_scratch_pad.cpp.

{
    // developer must ensure zoom level is not linked with canvas zoom level before
    // calling this method
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_linkCanvasZoomLevel, false);
 
    scaleX = qBound(0.05, scaleX, 16.0);
    scaleY = qBound(0.05, scaleY, 16.0);
 
    // value not changed? do nothing and return false
    if (scaleX == m_scratchpadScaleX && scaleY == m_scratchpadScaleY) return false;
 
    m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
    // memorize current scratchPad scale
    m_scratchpadScaleX = scaleX;
    m_scratchpadScaleY = scaleY;
 
    m_scaleTransform = QTransform::fromScale(m_scratchpadScaleX, m_scratchpadScaleY);
    updateTransformations();
    update();
 
    return true;
}

References BORDER_SIZE, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_linkCanvasZoomLevel, m_scaleBorderWidth, m_scaleTransform, m_scratchpadScaleX, m_scratchpadScaleY, scaleX(), scaleY(), and updateTransformations().

setupScratchPad()

void KisScratchPad::setupScratchPad	(	KisCanvasResourceProvider *	resourceProvider,
		const QColor &	defaultColor )

Definition at line 800 of file kis_scratch_pad.cpp.

{
    m_resourceProvider = resourceProvider;
 
    connect(m_resourceProvider, SIGNAL(sigOnScreenResolutionChanged(qreal,qreal)),
            SLOT(setOnScreenResolution(qreal,qreal)));
    connect(this, SIGNAL(colorSelected(KoColor)),
            m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
 
    m_helper.reset(new KisToolFreehandHelper(m_infoBuilder, m_resourceProvider->resourceManager()));
 
    setFillColor(defaultColor);
 
    KisPaintDeviceSP paintDevice =
        new KisPaintDevice(m_defaultColor.colorSpace(), "scratchpad");
 
    m_paintLayer = new KisPaintLayer(0, "ScratchPad", OPACITY_OPAQUE_U8, paintDevice);
    m_paintLayer->setGraphListener(m_nodeListener);
    m_paintLayer->paintDevice()->setDefaultBounds(new KisScratchPadDefaultBounds(this));
 
    fillDefault();
}

References colorSelected(), KoColor::colorSpace(), connect(), fillDefault(), m_defaultColor, m_helper, m_infoBuilder, m_nodeListener, m_paintLayer, m_resourceProvider, OPACITY_OPAQUE_U8, KisPaintLayer::paintDevice, KisCanvasResourceProvider::resourceManager(), KisPaintDevice::setDefaultBounds(), setFillColor(), KisNode::setGraphListener(), and setOnScreenResolution().

sigUpdateCanvas

void KisScratchPad::sigUpdateCanvas ( const QRect & rect )

signal

slotConfigChanged

void KisScratchPad::slotConfigChanged ( )

privateslot

Definition at line 717 of file kis_scratch_pad.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_screenMigrationTracker);
 
    KisConfig cfg(true);
 
    QScreen *screen = m_screenMigrationTracker->currentScreenSafe();
    const int screenId = qApp->screens().indexOf(screen);
 
    auto newState = m_multiSurfaceStateManager.onConfigChanged(m_multiSurfaceState,
                                                               screenId,
                                                               cfg.canvasSurfaceColorSpaceManagementMode(),
                                                               KisDisplayConfig::optionsFromKisConfig(cfg));
    assignNewSurfaceState(newState);
}

References assignNewSurfaceState(), KisConfig::canvasSurfaceColorSpaceManagementMode(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_multiSurfaceState, m_multiSurfaceStateManager, m_screenMigrationTracker, KisMultiSurfaceStateManager::onConfigChanged(), and KisDisplayConfig::optionsFromKisConfig().

slotScreenChanged

void KisScratchPad::slotScreenChanged ( QScreen * screen )

privateslot

Definition at line 981 of file kis_scratch_pad.cpp.

{
    const int screenId = qApp->screens().indexOf(screen);
 
    auto newState = m_multiSurfaceStateManager.onScreenChanged(m_multiSurfaceState, screenId);
    assignNewSurfaceState(newState);
}

References assignNewSurfaceState(), m_multiSurfaceState, m_multiSurfaceStateManager, and KisMultiSurfaceStateManager::onScreenChanged().

slotUpdateCanvas

void KisScratchPad::slotUpdateCanvas ( const QRect & rect )

privateslot

Definition at line 702 of file kis_scratch_pad.cpp.

{
    update(rect);
}

updateTransformations()

void KisScratchPad::updateTransformations ( )

private

Definition at line 631 of file kis_scratch_pad.cpp.

{
    m_eventFilter->setWidgetToDocumentTransform(widgetToDocument());
}

References m_eventFilter, KisScratchPadEventFilter::setWidgetToDocumentTransform(), and widgetToDocument().

updateViewport()

void KisScratchPad::updateViewport ( )

private

Definition at line 646 of file kis_scratch_pad.cpp.

{
    if (updateViewportImpl()) {
        Q_EMIT viewportChanged(m_viewport);
    }
}

References m_viewport, updateViewportImpl(), and viewportChanged().

updateViewportImpl()

bool KisScratchPad::updateViewportImpl ( )

private

Definition at line 653 of file kis_scratch_pad.cpp.

{
    const QRect viewport = widgetToDocument().mapRect(rect());
 
    if (viewport != m_viewport) {
        m_viewport = viewport;
        return true;
    }
    return false;
}

References m_viewport, and widgetToDocument().

viewportBounds()

QRect KisScratchPad::viewportBounds

(

)

const

Definition at line 641 of file kis_scratch_pad.cpp.

{
    return m_viewport;
}

References m_viewport.

viewportChanged

void KisScratchPad::viewportChanged ( const QRect rect )

signal

signal is emitted when scratchpad viewport has been modified (pan, zoom)

Parameters

rect	new viewport bounds

wheelDelta()

void KisScratchPad::wheelDelta

(

QWheelEvent *

event

)

Definition at line 252 of file kis_scratch_pad.cpp.

{
    // if linked to canvas zoom level, ignore wheel event scale
    if (!isEnabled() || m_linkCanvasZoomLevel) return;
 
    const int angleDelta = event->angleDelta().y();
 
#ifdef Q_OS_MACOS
    // --> from KisInputManager::eventFilterImpl()
 
    // Some QT wheel events are actually touch pad pan events. From the QT docs:
    // "Wheel events are generated for both mouse wheels and trackpad scroll gestures."
    // We differentiate between touchpad events and real mouse wheels by inspecting the
    // event source.
    if (event->source() == Qt::MouseEventSource::MouseEventSynthesizedBySystem) {
        return;
    }
 
    if (angleDelta == 0) {
        return;
    }
#endif
 
    m_accumulatedMouseDelta += angleDelta;
 
    qreal scaleX = m_scratchpadScaleX;
    qreal scaleY = m_scratchpadScaleY;
 
    // cursor position on widget
    QPointF position = event->position();
    // matching cursor position in document (taking in account scale + translate)
    QPointF docPosition = widgetToDocument().map(position);
 
    // loop manage case where angleDelta is greater than one mouse wheel tick
    // and allows to refresh zoom smoothly in this case
    //      if angleDelta = 360, 360/120 = 3, then scale will be refreshed 3 times
    // m_accumulatedMouseDelta allow to manage the case where angleDelta in not equal QWheelEvent::DefaultDeltasPerStep
    while (qAbs(m_accumulatedMouseDelta) >= QWheelEvent::DefaultDeltasPerStep) {
        if (m_accumulatedMouseDelta > 0) {
            qreal scaleFactor = 0.5;
            if (scaleX < 1) scaleFactor = 0.05;
            // zoom In
            scaleX += scaleFactor;
            scaleY += scaleFactor;
        } else {
            qreal scaleFactor = 0.5;
            if (scaleX <= 1) scaleFactor = 0.05;
            // zoom out
            scaleX -= scaleFactor;
            scaleY -= scaleFactor;
        }
 
        // update zoom level
        if (!setScaleImpl(scaleX, scaleY)) {
            // if can't apply zoom level, reset accumulated delta and exit, no need to try
            // to continue
            m_accumulatedMouseDelta = 0;
            break;
        }
 
        Q_EMIT scaleChanged(m_scratchpadScaleX);
 
        // cursor position after scale
        QPointF offsetPosition = QPointF(position.x() / m_scratchpadScaleX, position.y() / m_scratchpadScaleY);
 
        // new position after scale is applied
        //
        QPoint panPosition = QPointF( docPosition - offsetPosition).toPoint();
 
        // pan to ensure zoomed point is always under cursor
        panTo(panPosition.x(), panPosition.y());
 
        m_accumulatedMouseDelta -= KisAlgebra2D::signPZ(m_accumulatedMouseDelta) * QWheelEvent::DefaultDeltasPerStep;
    }
}

References m_accumulatedMouseDelta, m_linkCanvasZoomLevel, m_scratchpadScaleX, m_scratchpadScaleY, panTo(), scaleChanged(), scaleX(), scaleY(), setScaleImpl(), KisAlgebra2D::signPZ(), and widgetToDocument().

widgetToDocument()

QTransform KisScratchPad::widgetToDocument ( ) const

private

Definition at line 626 of file kis_scratch_pad.cpp.

{
    return m_scaleTransform.inverted() * m_translateTransform;
}

References m_scaleTransform, and m_translateTransform.

Friends And Related Symbol Documentation

KisScratchPadPaintingInformationBuilder

friend class KisScratchPadPaintingInformationBuilder

friend

Definition at line 242 of file kis_scratch_pad.h.

Member Data Documentation

isModeManuallySet

bool KisScratchPad::isModeManuallySet

private

Definition at line 263 of file kis_scratch_pad.h.

isMouseDown

bool KisScratchPad::isMouseDown

private

Definition at line 264 of file kis_scratch_pad.h.

KisScratchPadEventFilter

friend KisScratchPad::KisScratchPadEventFilter

private

Definition at line 245 of file kis_scratch_pad.h.

m_accumulatedMouseDelta

int KisScratchPad::m_accumulatedMouseDelta

private

Definition at line 276 of file kis_scratch_pad.h.

m_canvasScaleX

qreal KisScratchPad::m_canvasScaleX

private

Definition at line 268 of file kis_scratch_pad.h.

m_canvasScaleY

qreal KisScratchPad::m_canvasScaleY

private

Definition at line 269 of file kis_scratch_pad.h.

m_checkBrush

QBrush KisScratchPad::m_checkBrush

private

Definition at line 287 of file kis_scratch_pad.h.

m_colorSamplerCursor

QCursor KisScratchPad::m_colorSamplerCursor

private

Definition at line 285 of file kis_scratch_pad.h.

m_cursor

QCursor KisScratchPad::m_cursor

private

Definition at line 284 of file kis_scratch_pad.h.

m_cutoutOverlay

QRect KisScratchPad::m_cutoutOverlay

private

Definition at line 286 of file kis_scratch_pad.h.

m_defaultColor

KoColor KisScratchPad::m_defaultColor

private

Definition at line 261 of file kis_scratch_pad.h.

m_displayConfig

KisDisplayConfig KisScratchPad::m_displayConfig

private

Definition at line 283 of file kis_scratch_pad.h.

m_displayProfile

const KoColorProfile* KisScratchPad::m_displayProfile

private

Definition at line 282 of file kis_scratch_pad.h.

m_eventFilter

KisScratchPadEventFilter* KisScratchPad::m_eventFilter

private

Definition at line 294 of file kis_scratch_pad.h.

m_helper

QScopedPointer<KisToolFreehandHelper> KisScratchPad::m_helper

private

Definition at line 296 of file kis_scratch_pad.h.

m_infoBuilder

KisPaintingInformationBuilder* KisScratchPad::m_infoBuilder

private

Definition at line 297 of file kis_scratch_pad.h.

m_linkCanvasZoomLevel

bool KisScratchPad::m_linkCanvasZoomLevel

private

Definition at line 265 of file kis_scratch_pad.h.

m_multiSurfaceState

KisMultiSurfaceStateManager::State KisScratchPad::m_multiSurfaceState

private

Definition at line 308 of file kis_scratch_pad.h.

m_multiSurfaceStateManager

KisMultiSurfaceStateManager KisScratchPad::m_multiSurfaceStateManager

private

Definition at line 307 of file kis_scratch_pad.h.

m_nodeListener

KisNodeGraphListener* KisScratchPad::m_nodeListener

private

Definition at line 293 of file kis_scratch_pad.h.

m_paintLayer

KisPaintLayerSP KisScratchPad::m_paintLayer

private

Definition at line 281 of file kis_scratch_pad.h.

m_panDocPoint

QPointF KisScratchPad::m_panDocPoint

private

Definition at line 302 of file kis_scratch_pad.h.

m_presetImage

QImage KisScratchPad::m_presetImage

private

Definition at line 305 of file kis_scratch_pad.h.

m_resourceProvider

KisCanvasResourceProvider* KisScratchPad::m_resourceProvider

private

Definition at line 288 of file kis_scratch_pad.h.

m_scaleBorderWidth

int KisScratchPad::m_scaleBorderWidth

private

Definition at line 303 of file kis_scratch_pad.h.

m_scaleTransform

QTransform KisScratchPad::m_scaleTransform

private

Definition at line 299 of file kis_scratch_pad.h.

m_scratchpadScaleX

qreal KisScratchPad::m_scratchpadScaleX

private

Definition at line 272 of file kis_scratch_pad.h.

m_scratchpadScaleY

qreal KisScratchPad::m_scratchpadScaleY

private

Definition at line 273 of file kis_scratch_pad.h.

m_screenMigrationTracker

QScopedPointer<KisScreenMigrationTracker> KisScratchPad::m_screenMigrationTracker

private

Definition at line 306 of file kis_scratch_pad.h.

m_toolMode

Mode KisScratchPad::m_toolMode

private

Definition at line 262 of file kis_scratch_pad.h.

m_translateTransform

QTransform KisScratchPad::m_translateTransform

private

Definition at line 300 of file kis_scratch_pad.h.

m_undoAdapter

KisPostExecutionUndoAdapter* KisScratchPad::m_undoAdapter

private

Definition at line 292 of file kis_scratch_pad.h.

m_undoStore

KisUndoStore* KisScratchPad::m_undoStore

private

Definition at line 291 of file kis_scratch_pad.h.

m_updateScheduler

KisUpdateScheduler* KisScratchPad::m_updateScheduler

private

Definition at line 290 of file kis_scratch_pad.h.

m_viewport

QRect KisScratchPad::m_viewport

private

Definition at line 279 of file kis_scratch_pad.h.

---

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

• libs/ui/widgets/kis_scratch_pad.h
• libs/ui/widgets/kis_scratch_pad.cpp