#include <kis_canvas2.h>

Inheritance diagram for KisCanvas2:

Classes
struct	CanvasInputActionGroupsMaskInterface

Public Slots
void	channelSelectionChanged ()

void	finishResizingImage (qint32 w, qint32 h)

qreal	rotationAngle () const
	canvas rotation in degrees

void	slotChangeGlobalProofingConfig ()

void	slotChangeProofingConfig ()

void	slotConfigChanged ()

void	slotGamutCheck ()

void	slotPopupPaletteRequestedZoomChange (int zoom)

void	slotScreenChanged (QScreen *screen)

void	slotSoftProofing ()

void	slotTrySwitchShapeManager ()

void	startResizingImage ()

void	startUpdateInPatches (const QRect &imageRect)

void	updateCanvas ()
	Update the entire canvas area.

void	updateCanvasDecorations ()

void	updateCanvasDecorations (const QRectF &docRect)

void	updateCanvasProjection (const QRectF &docRect)

void	updateCanvasScene ()

void	updateCanvasToolOutlineDoc (const QRectF &docRect)

void	updateCanvasToolOutlineWdg (const QRect &widgetRect)

bool	xAxisMirrored () const
	Bools indicating canvasmirroring.

bool	yAxisMirrored () const

Signals
void	sigCanvasCacheUpdated ()

void	sigCanvasEngineChanged ()

void	sigCanvasStateChanged ()

void	sigContinueResizeImage (qint32 w, qint32 h)

void	sigRegionOfInterestChanged (const QRect &roi)

void	updateCanvasRequested (const QRect &rc)

Public Member Functions
void	addCommand (KUndo2Command *command) override

void	addDecoration (KisCanvasDecorationSP deco)

KisCanvasAnimationState *	animationState () const

void	assignChangedMultiSurfaceState (const KisMultiSurfaceStateManager::State &newState)

void	assignChangedMultiSurfaceStateSkipCanvasSurface (const KisMultiSurfaceStateManager::State &newState)

bool	canvasIsOpenGL () const override

const QWidget *	canvasWidget () const override

QWidget *	canvasWidget () override

QString	colorManagementReport () const

const KisCoordinatesConverter *	coordinatesConverter () const

KisImageWSP	currentImage () const

int	currentScreenId () const

KisCanvasDecorationSP	decoration (const QString &id) const

void	disconnectCanvasObserver (QObject *object) override

void	disconnectImage ()

KisDisplayColorConverter *	displayColorConverter () const

QSharedPointer< KisDisplayFilter >	displayFilter () const

QPoint	documentOffset () const

QPoint	documentOrigin () const override

QRect	docUpdateRectToWidget (const QRectF &docRect)

bool	effectiveLodAllowedInImage () const

KisExposureGammaCorrectionInterface *	exposureGammaCorrectionInterface () const

void	fetchProofingOptions ()
	fetchProofingOptions Get the options for softproofing, and apply the view-specific state without affecting the proofing options as stored inside the image.

KisAnimationFrameCacheSP	frameCache () const

KisInputManager *	globalInputManager () const

KoShapeManager *	globalShapeManager () const

void	gridSize (QPointF offset, QSizeF spacing) const override

KisImageWSP	image () const

QPointer< KisView >	imageView () const

void	initializeImage ()

KisInputActionGroupsMaskInterface::SharedInterface	inputActionGroupsMaskInterface ()

	KisCanvas2 (KisCoordinatesConverter coordConverter, KoCanvasResourceProvider resourceManager, KisMainWindow mainWindow, KisView view, KoShapeControllerBase *sc)

	KisCanvas2Private (KisCanvas2 parent, KisCoordinatesConverter coordConverter, QPointer< KisView > view, KoCanvasResourceProvider *resourceManager)

KoShapeManager *	localShapeManager () const

bool	lodIsSupported () const

bool	lodPreferredInCanvas () const

KisOpenGL::FilterMode	openGLFilterMode () const

KisPaintingAssistantsDecorationSP	paintingAssistantsDecoration () const

KisPopupPalette *	popupPalette ()

bool	proofingConfigUpdated ()
	proofingConfigUpdated ask the canvas whether or not it updated the proofing config.

KisProofingConfigurationSP	proofingConfiguration () const

KisReferenceImagesDecorationSP	referenceImagesDecoration () const

void	refetchDataFromImage ()

QRect	regionOfInterest () const

QRect	renderingLimit () const

KoSelectedShapesProxy *	selectedShapesProxy () const override

void	setActiveShapeManager (KoShapeManager *shapeManager)

void	setCursor (const QCursor &cursor) override

void	setDisplayFilter (QSharedPointer< KisDisplayFilter > displayFilter)

void	setFavoriteResourceManager (KisFavoriteResourceManager *favoriteResourceManager)

void	setLodPreferredInCanvas (bool value)

void	setProofingConfigUpdated (bool updated)
	setProofingConfigUpdated This function is to set whether the proofing config is updated, this is needed for determining whether or not to generate a new proofing transform.

void	setRenderingLimit (const QRect &rc)

void	setWrapAroundViewingMode (bool value)

void	setWrapAroundViewingModeAxis (WrapAroundAxis value)

KoShapeManager *	shapeManager () const override

bool	snapToGrid () const override

KoToolProxy *	toolProxy () const override

KoUnit	unit () const override

void	updateCanvas (const QRectF &rc) override

void	updateProofingState ()

const KoViewConverter *	viewConverter () const override

KoViewConverter *	viewConverter () override

KisViewManager *	viewManager () const

bool	wrapAroundViewingMode () const

WrapAroundAxis	wrapAroundViewingModeAxis () const

	~KisCanvas2 () override

	~KisCanvas2Private ()

Public Member Functions inherited from KoCanvasBase
KoCanvasController *	canvasController () const

virtual void	clipToDocument (const KoShape *shape, QPointF &move) const

	KoCanvasBase (KoShapeControllerBase shapeController, KoCanvasResourceProvider sharedResourceManager=0)

	Private ()

KoCanvasResourceProvider *	resourceManager () const

void	setCanvasController (KoCanvasController *controller)
	called by KoCanvasController to set the controller that handles this canvas.

KoShapeController *	shapeController () const

KoSnapGuide *	snapGuide () const

virtual QPointF	viewToDocument (const QPointF &viewPoint) const

	~KoCanvasBase () override

	~Private ()

Public Attributes
QScopedPointer< KisCanvasAnimationState >	animationPlayer

bool	bootstrapLodBlocked = false

KisSignalCompressor	canvasUpdateCompressor

KisAbstractCanvasWidget *	canvasWidget = 0

QBitArray	channelFlags

KisCoordinatesConverter *	coordinatesConverter = 0

bool	currentCanvasIsOpenGL = true

QPointer< KoShapeManager >	currentlyActiveShapeManager

KisDisplayColorConverter	displayColorConverter

KisAnimationFrameCacheSP	frameCache

KisSignalCompressor	frameRenderStartCompressor

KisInputActionGroupsMask	inputActionGroupsMask = AllActionGroup

QSharedPointer< CanvasInputActionGroupsMaskInterface >	inputActionGroupsMaskInterface

int	isBatchUpdateActive = 0

bool	lodPreferredInImage = false

KisMultiSurfaceStateManager	multiSurfaceSetupManager

std::optional< KisMultiSurfaceStateManager::State >	multiSurfaceState

int	openGLFilterMode = 0

KisPopupPalette *	popupPalette = 0

KisPrescaledProjectionSP	prescaledProjection

KisCanvasUpdatesCompressor	projectionUpdatesCompressor

KisProofingConfigurationSP	proofingConfig

bool	proofingConfigUpdated = false

KisCanvas2 *	q = 0

KisSignalCompressor	referencesBoundsUpdateCompressor

QRect	regionOfInterest

qreal	regionOfInterestMargin = 0.25

KisSignalCompressor	regionOfInterestUpdateCompressor

QRect	renderingLimit

QRect	savedCanvasProjectionUpdateRect

QRect	savedOverlayUpdateRect

KisSelectedShapesProxy	selectedShapesProxy

KoShapeManager	shapeManager

KisToolProxy	toolProxy

bool	updateSceneRequested = false

QPointer< KisView >	view

Public Attributes inherited from KoCanvasBase
KoCanvasController *	controller

bool	isResourceManagerShared

QPointer< KoCanvasResourceProvider >	resourceManager

QPointer< KoShapeController >	shapeController

KoSnapGuide *	snapGuide

Private Slots
void	bootstrapFinished ()

void	slotBeginUpdatesBatch ()

void	slotCanvasStateChanged ()

void	slotDoCanvasUpdate ()

void	slotEffectiveZoomChanged (qreal newZoom)

void	slotEndUpdatesBatch ()

void	slotImageColorSpaceChanged ()

void	slotSelectionChanged ()

void	slotSetLodUpdatesBlocked (bool value)

void	slotUpdateReferencesBounds ()

void	slotUpdateRegionOfInterest ()

void	startUpdateCanvasProjection (const QRect &rc)

void	updateCanvasProjection ()

Private Member Functions
void	connectCurrentCanvas ()

void	createCanvas (bool useOpenGL)

void	createOpenGLCanvas ()

void	createQPainterCanvas ()

void	initializeFpsDecoration ()

void	notifyLevelOfDetailChange ()

void	requestCanvasUpdateMaybeCompressed ()

void	resetCanvas (bool useOpenGL)

void	setCanvasWidget (KisAbstractCanvasWidget *widget)

void	setup ()

void	slotSurfaceFormatChanged (const KisDisplayConfig &config)

void	updateCanvasWidgetImpl (const QRect &rc=QRect())

Private Attributes
KisCanvas2Private *const	m_d

Friends
class	KisView

Detailed Description

KisCanvas2 is not an actual widget class, but rather an adapter for the widget it contains, which may be either a QPainter based canvas, or an OpenGL based canvas: that are the real widgets.

Definition at line 113 of file kis_canvas2.cpp.

Constructor & Destructor Documentation

◆ ~KisCanvas2Private()

KisCanvas2::~KisCanvas2Private ( )

inline

Definition at line 173 of file kis_canvas2.cpp.

    {
        inputActionGroupsMaskInterface->m_canvasPrivateRef = nullptr;
 
        // We need to make sure that the QScopedPointer gets freed within the scope
        // of KisCanvas2Private's lifespan. For some reason, this isn't guaranteed
        // and was causing a crash when closing a file when playback is happening
        // and there are multiple images. See Bug: 499658
        animationPlayer.reset();
    }

◆ KisCanvas2()

KisCanvas2::KisCanvas2	(	KisCoordinatesConverter *	coordConverter,
		KoCanvasResourceProvider *	resourceManager,
		KisMainWindow *	mainWindow,
		KisView *	view,
		KoShapeControllerBase *	sc )

Create a new canvas. The canvas manages a widget that will do the actual painting: the canvas itself is not a widget.

Parameters

viewConverter the viewconverter for converting between window and document coordinates.

While loading LoD should be blocked. Only when GUI has finished loading and zoom level settled down, LoD is given a green light.

Definition at line 294 of file kis_canvas2.cpp.

    : KoCanvasBase(sc, resourceManager)
    , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
{
    m_d->bootstrapLodBlocked = true;
    connect(mainWindow, SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
    KisImageConfig config(false);
 
#if !KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
    m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
#endif
 
    m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
    m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
    snapGuide()->overrideSnapStrategy(KoSnapGuide::PixelSnapping, new KisSnapPixelStrategy());
}

References bootstrapFinished(), connect(), KisSignalCompressor::FIRST_ACTIVE, KisImageConfig::fpsLimit(), m_d, KoSnapGuide::overrideSnapStrategy(), KoSnapGuide::PixelSnapping, and KoCanvasBase::snapGuide.

◆ ~KisCanvas2()

KisCanvas2::~KisCanvas2 ( )

override

Definition at line 398 of file kis_canvas2.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

◆ addCommand()

void KisCanvas2::addCommand ( KUndo2Command * command )

overridevirtual

Adds a command to the history. Call this for each command you create. This will also execute the command. This means, most of the application's code will look like MyCommand * cmd = new MyCommand( parameters ); canvas.addCommand( cmd );

Note that the command history takes ownership of the command, it will delete it when the undo limit is reached, or when deleting the command history itself.

Parameters

command the command to add

Implements KoCanvasBase.

Definition at line 541 of file kis_canvas2.cpp.

{
    // This method exists to support flake-related operations
    m_d->view->image()->undoAdapter()->addCommand(command);
}

References m_d.

◆ addDecoration()

void KisCanvas2::addDecoration ( KisCanvasDecorationSP deco )

Returns: true if the canvas image should be displayed in vertically mirrored mode

Definition at line 1472 of file kis_canvas2.cpp.

{
    m_d->canvasWidget->addDecoration(deco);
}

References m_d.

◆ animationState()

KisCanvasAnimationState * KisCanvas2::animationState ( ) const

Definition at line 1522 of file kis_canvas2.cpp.

{
    return m_d->animationPlayer.data();
}

References m_d.

◆ assignChangedMultiSurfaceState()

void KisCanvas2::assignChangedMultiSurfaceState ( const KisMultiSurfaceStateManager::State & newState )

◆ assignChangedMultiSurfaceStateSkipCanvasSurface()

void KisCanvas2::assignChangedMultiSurfaceStateSkipCanvasSurface ( const KisMultiSurfaceStateManager::State & newState )

◆ bootstrapFinished

void KisCanvas2::bootstrapFinished ( )

privateslot

Definition at line 1567 of file kis_canvas2.cpp.

{
    if (!m_d->bootstrapLodBlocked) return;
 
    m_d->bootstrapLodBlocked = false;
    setLodPreferredInCanvas(m_d->lodPreferredInImage);
 
    // Initialization of audio tracks is deferred until after canvas has been completely constructed.
    m_d->animationPlayer->setupAudioTracks();
}

References m_d, and setLodPreferredInCanvas().

◆ canvasIsOpenGL()

bool KisCanvas2::canvasIsOpenGL ( ) const

overridevirtual

Returns: true if opengl can be used directly on the canvas

Reimplemented from KoCanvasBase.

Definition at line 484 of file kis_canvas2.cpp.

{
    return m_d->currentCanvasIsOpenGL;
}

References m_d.

◆ canvasWidget() [1/2]

const QWidget * KisCanvas2::canvasWidget ( ) const

overridevirtual

Return the widget that will be added to the scrollArea.

Implements KoCanvasBase.

◆ canvasWidget() [2/2]

QWidget * KisCanvas2::canvasWidget ( )

overridevirtual

Return the widget that will be added to the scrollArea.

Implements KoCanvasBase.

◆ channelSelectionChanged

void KisCanvas2::channelSelectionChanged ( )

slot

Definition at line 528 of file kis_canvas2.cpp.

{
    KisImageSP image = this->image();
    m_d->channelFlags = image->rootLayer()->channelFlags();
 
    m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
    image->barrierLock();
    m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
    startUpdateInPatches(image->bounds());
    image->unlock();
}

References KisImage::barrierLock(), KisImage::bounds(), KisLayer::channelFlags, image(), m_d, KisImage::rootLayer(), startUpdateInPatches(), and KisImage::unlock().

◆ colorManagementReport()

QString KisCanvas2::colorManagementReport ( ) const

Return user-facing information about color management status of the main window surface. The information is intentionally left untranslated, since it is supposed to be used for bugreports.

Definition at line 1615 of file kis_canvas2.cpp.

{
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    QString report;
    QDebug str(&report);
 
    if (m_d->canvasWidget) {
        str << "(canvas bit depth report)" << Qt::endl;
        str << Qt::endl;
        str.noquote().nospace() << m_d->canvasWidget->currentBitDepthUserReport();
    }
 
    str << Qt::endl;
 
    if (m_d->surfaceColorManager) {
        str.noquote().nospace() << QString("(canvas surface color manager)\n");
        str.noquote().nospace() << QString("\n");
        str.noquote().nospace() << m_d->surfaceColorManager->colorManagementReport();
    } else {
        str.noquote().nospace() << QString("Surface color management is not supported on this platform\n");
    }
 
    return report;
#else
    return "Surface color management is disabled\n";
#endif
}

References m_d.

◆ connectCurrentCanvas()

void KisCanvas2::connectCurrentCanvas ( )

private

Definition at line 760 of file kis_canvas2.cpp.

{
    KisImageWSP image = m_d->view->image();
 
    if (!m_d->currentCanvasIsOpenGL) {
        Q_ASSERT(m_d->prescaledProjection);
        m_d->prescaledProjection->setImage(image);
    }
 
    startResizingImage();
    setLodPreferredInCanvas(m_d->lodPreferredInImage);
 
    Q_EMIT sigCanvasEngineChanged();
}

References image(), m_d, setLodPreferredInCanvas(), sigCanvasEngineChanged(), and startResizingImage().

◆ coordinatesConverter()

const KisCoordinatesConverter * KisCanvas2::coordinatesConverter ( ) const

◆ createCanvas()

void KisCanvas2::createCanvas ( bool useOpenGL )

private

Definition at line 687 of file kis_canvas2.cpp.

{
    // deinitialize previous canvas structures
    m_d->prescaledProjection = 0;
    m_d->frameCache = 0;
 
    KisConfig cfg(true);
 
    if (useOpenGL && !KisOpenGL::hasOpenGL()) {
        warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
        useOpenGL = false;
    }
 
    if (useOpenGL) {
        createOpenGLCanvas();
        if (cfg.canvasState() == "OPENGL_FAILED") {
            // Creating the opengl canvas failed, fall back
            warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
            createQPainterCanvas();
        }
    } else {
        createQPainterCanvas();
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->multiSurfaceState);
    m_d->displayColorConverter.setMultiSurfaceDisplayConfig(m_d->multiSurfaceState->multiConfig);
 
    if (m_d->popupPalette) {
        m_d->popupPalette->setParent(m_d->canvasWidget->widget());
    }
 
}

References KisConfig::canvasState(), createOpenGLCanvas(), createQPainterCanvas(), KisOpenGL::hasOpenGL(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and warnKrita.

◆ createOpenGLCanvas()

void KisCanvas2::createOpenGLCanvas ( )

private

Definition at line 660 of file kis_canvas2.cpp.

{
    KisConfig cfg(true);
    m_d->openGLFilterMode = cfg.openGLFilteringMode();
    m_d->currentCanvasIsOpenGL = true;
 
    m_d->multiSurfaceState =
        m_d->multiSurfaceSetupManager.createInitializingConfig(true, m_d->currentScreenId(), m_d->proofingConfig);
 
    auto bitDepthMode =
        cfg.effectiveCanvasSurfaceBitDepthMode(QSurfaceFormat::defaultFormat())
            == KisConfig::CanvasSurfaceBitDepthMode::Depth10Bit ?
        KisOpenGLCanvas2::BitDepthMode::Depth10Bit :
        KisOpenGLCanvas2::BitDepthMode::Depth8Bit;
 
    KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this,
                                                          m_d->coordinatesConverter,
                                                          0,
                                                          m_d->view->image(),
                                                          m_d->multiSurfaceState->multiConfig.canvasDisplayConfig(),
                                                          m_d->displayColorConverter.displayFilter(),
                                                          bitDepthMode);
    m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
    setCanvasWidget(canvasWidget);
}

References canvasWidget, KisAbstractCanvasWidget::Depth10Bit, KisConfig::Depth10Bit, KisAbstractCanvasWidget::Depth8Bit, KisConfig::effectiveCanvasSurfaceBitDepthMode(), KisAnimationFrameCache::getFrameCache(), m_d, KisConfig::openGLFilteringMode(), and setCanvasWidget().

◆ createQPainterCanvas()

void KisCanvas2::createQPainterCanvas ( )

private

Definition at line 644 of file kis_canvas2.cpp.

{
    m_d->currentCanvasIsOpenGL = false;
 
    m_d->multiSurfaceState =
        m_d->multiSurfaceSetupManager.createInitializingConfig(false, m_d->currentScreenId(), m_d->proofingConfig);
 
    KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
    m_d->prescaledProjection = new KisPrescaledProjection();
    m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
    m_d->prescaledProjection->setDisplayConfig(m_d->displayColorConverter.displayConfig());
    m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
    canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
    setCanvasWidget(canvasWidget);
}

References canvasWidget, m_d, and setCanvasWidget().

◆ currentImage()

KisImageWSP KisCanvas2::currentImage ( ) const

Definition at line 1343 of file kis_canvas2.cpp.

{
    return m_d->view->image();
}

References m_d.

◆ currentScreenId()

int KisCanvas2::currentScreenId ( ) const

inline

Definition at line 253 of file kis_canvas2.cpp.

                                {
        int canvasScreenNumber = qApp->screens().indexOf(view->currentScreen());
 
        if (canvasScreenNumber < 0) {
            warnKrita << "Couldn't detect screen that Krita belongs to..." << ppVar(view->currentScreen());
            canvasScreenNumber = 0;
        }
        return canvasScreenNumber;
    }

References ppVar, and warnKrita.

◆ decoration()

KisCanvasDecorationSP KisCanvas2::decoration ( const QString & id ) const

Definition at line 1477 of file kis_canvas2.cpp.

{
    return m_d->canvasWidget->decoration(id);
}

References m_d.

◆ disconnectCanvasObserver()

void KisCanvas2::disconnectCanvasObserver ( QObject * object )

overridevirtual

disconnect the given QObject completely and utterly from any and all connections it has to any QObject owned by the canvas. Do this in the setCanvas of every KoCanvasObserver.

Reimplemented from KoCanvasBase.

Definition at line 1231 of file kis_canvas2.cpp.

{
    KoCanvasBase::disconnectCanvasObserver(object);
    m_d->view->disconnect(object);
}

References KoCanvasBase::disconnectCanvasObserver(), and m_d.

◆ disconnectImage()

void KisCanvas2::disconnectImage ( )

We explicitly don't use barrierLock() here, because we don't care about all the updates completed (we don't use image's content). We only need to guarantee that the image will not try to access us in a multithreaded way, while we are being destroyed.

Definition at line 744 of file kis_canvas2.cpp.

{
    KisImageSP image = m_d->view->image();
 
    image->immediateLockForReadOnly();
    disconnect(image.data(), 0, this, 0);
    image->unlock();
}

References KisWeakSharedPtr< T >::data(), image(), KisImage::immediateLockForReadOnly(), m_d, and KisImage::unlock().

◆ displayColorConverter()

KisDisplayColorConverter * KisCanvas2::displayColorConverter ( ) const

◆ displayFilter()

QSharedPointer< KisDisplayFilter > KisCanvas2::displayFilter ( ) const

Definition at line 838 of file kis_canvas2.cpp.

{
    return m_d->displayColorConverter.displayFilter();
}

References m_d.

◆ documentOffset()

QPoint KisCanvas2::documentOffset ( ) const

Definition at line 1494 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter->documentOffset();
}

References m_d.

◆ documentOrigin()

QPoint KisCanvas2::documentOrigin ( ) const

overridevirtual

Return the position of the document origin inside the canvas widget, in pixels. By default the origin of the canvas widget and the position of the document origin are coincident, thus an empty point is returned.

In Krita we don't use document origin anymore. All the centering when needed (vastScrolling < 0.5) is done automatically by the KisCoordinatesConverter.

Reimplemented from KoCanvasBase.

Definition at line 1483 of file kis_canvas2.cpp.

{
    return QPoint();
}

◆ docUpdateRectToWidget()

QRect KisCanvas2::docUpdateRectToWidget ( const QRectF & docRect )

◆ effectiveLodAllowedInImage()

bool KisCanvas2::effectiveLodAllowedInImage ( ) const

inline

Definition at line 238 of file kis_canvas2.cpp.

                                            {
        return lodPreferredInImage && !bootstrapLodBlocked;
    }

◆ exposureGammaCorrectionInterface()

KisExposureGammaCorrectionInterface * KisCanvas2::exposureGammaCorrectionInterface ( ) const

Definition at line 868 of file kis_canvas2.cpp.

{
    QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
    return displayFilter ?
        displayFilter->correctionInterface() :
        KisDumbExposureGammaCorrectionInterface::instance();
}

References displayFilter(), KisDumbExposureGammaCorrectionInterface::instance(), and m_d.

◆ fetchProofingOptions()

void KisCanvas2::fetchProofingOptions ( )

fetchProofingOptions Get the options for softproofing, and apply the view-specific state without affecting the proofing options as stored inside the image.

Definition at line 877 of file kis_canvas2.cpp.

{
    KisProofingConfigurationSP baseConfig = image()->proofingConfiguration();
    if (!baseConfig) {
        baseConfig = KisImageConfig(true).defaultProofingconfiguration();
    }
    *m_d->proofingConfig = *baseConfig;
 
    updateProofingState();
}

References KisImageConfig::defaultProofingconfiguration(), image(), m_d, KisImage::proofingConfiguration(), and updateProofingState().

◆ finishResizingImage

void KisCanvas2::finishResizingImage	(	qint32	w,
		qint32	h )

slot

Definition at line 963 of file kis_canvas2.cpp.

{
    m_d->canvasWidget->finishResizingImage(w, h);
}

References m_d.

◆ frameCache()

KisAnimationFrameCacheSP KisCanvas2::frameCache ( ) const

◆ globalInputManager()

KisInputManager * KisCanvas2::globalInputManager ( ) const

Filters events and sends them to canvas actions. Shared among all the views/canvases

NOTE: May be null while initialization!

Definition at line 604 of file kis_canvas2.cpp.

{
    return m_d->view->globalInputManager();
}

References m_d.

◆ globalShapeManager()

KoShapeManager * KisCanvas2::globalShapeManager ( ) const

Return the shape manager associated with this canvas

Definition at line 572 of file kis_canvas2.cpp.

{
    return &m_d->shapeManager;
}

References m_d.

◆ gridSize()

void KisCanvas2::gridSize	(	QPointF *	offset,
		QSizeF *	spacing ) const

overridevirtual

retrieve the grid size setting. The grid spacing will be provided in pt.

Parameters

horizontal	a pointer to a qreal that will be filled with the horizontal grid-spacing
vertical	a pointer to a qreal that will be filled with the vertical grid-spacing

Implements KoCanvasBase.

Definition at line 494 of file kis_canvas2.cpp.

{
    QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
    const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
    const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
    QPointF size = transform.map(QPointF(intSpacing));
    spacing->rwidth() = size.x();
    spacing->rheight() = size.y();
 
    *offset = transform.map(QPointF(intOffset));
}

References coordinatesConverter, KisCoordinatesConverter::imageToDocumentTransform(), and m_d.

◆ image()

KisImageWSP KisCanvas2::image ( ) const

Definition at line 1337 of file kis_canvas2.cpp.

{
    return m_d->view->image();
 
}

References m_d.

◆ imageView()

QPointer< KisView > KisCanvas2::imageView ( ) const

Definition at line 1332 of file kis_canvas2.cpp.

{
    return m_d->view;
}

References m_d.

◆ initializeFpsDecoration()

void KisCanvas2::initializeFpsDecoration ( )

private

Definition at line 378 of file kis_canvas2.cpp.

{
    KisConfig cfg(true);
 
    const bool shouldShowDebugOverlay =
        (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
        cfg.enableBrushSpeedLogging();
 
    if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
        addDecoration(new KisFpsDecoration(imageView()));
 
        if (cfg.enableBrushSpeedLogging()) {
            connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
        }
    } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
        m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
        disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
    }
}

References addDecoration(), canvasIsOpenGL(), connect(), decoration(), KisConfig::enableBrushSpeedLogging(), KisConfig::enableOpenGLFramerateLogging(), KisFpsDecoration::idTag, imageView(), KisStrokeSpeedMonitor::instance(), m_d, and updateCanvas().

◆ initializeImage()

void KisCanvas2::initializeImage ( )

Definition at line 720 of file kis_canvas2.cpp.

{
    KisImageSP image = m_d->view->image();
 
    m_d->displayColorConverter.setImageColorSpace(image->colorSpace());
    m_d->coordinatesConverter->setImage(image);
    m_d->toolProxy.initializeImage(image);
 
    connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
    connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateStarted()), SLOT(slotBeginUpdatesBatch()), Qt::DirectConnection);
    connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateEnded()), SLOT(slotEndUpdatesBatch()), Qt::DirectConnection);
    connect(image->signalRouter(), SIGNAL(sigRequestLodPlanesSyncBlocked(bool)), SLOT(slotSetLodUpdatesBlocked(bool)), Qt::DirectConnection);
 
    connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
    connect(image, SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(startResizingImage()), Qt::DirectConnection);
    connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
    connect(image, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), SLOT(slotImageColorSpaceChanged()));
    connect(image, SIGNAL(sigProfileChanged(const KoColorProfile*)), SLOT(slotImageColorSpaceChanged()));
 
    connectCurrentCanvas();
    fetchProofingOptions();
}

References KisImage::colorSpace(), connect(), connectCurrentCanvas(), fetchProofingOptions(), image(), m_d, KisImage::signalRouter(), slotBeginUpdatesBatch(), slotChangeProofingConfig(), slotEndUpdatesBatch(), slotImageColorSpaceChanged(), slotSetLodUpdatesBlocked(), slotTrySwitchShapeManager(), startResizingImage(), startUpdateCanvasProjection(), and KisImage::undoAdapter().

◆ inputActionGroupsMaskInterface()

KisInputActionGroupsMaskInterface::SharedInterface KisCanvas2::inputActionGroupsMaskInterface ( )

Returns: a reference to alter this canvas' input action groups mask

◆ KisCanvas2Private()

KisCanvas2::KisCanvas2Private	(	KisCanvas2 *	parent,
		KisCoordinatesConverter *	coordConverter,
		QPointer< KisView >	view,
		KoCanvasResourceProvider *	resourceManager )

inline

Definition at line 140 of file kis_canvas2.cpp.

        : q(parent)
        , coordinatesConverter(coordConverter)
        , view(view)
        , shapeManager(parent)
        , selectedShapesProxy(&shapeManager)
        , toolProxy(parent)
        , proofingConfig(new KisProofingConfiguration)
        , displayColorConverter(resourceManager, view)
        , inputActionGroupsMaskInterface(new CanvasInputActionGroupsMaskInterface(this))
        , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
        , referencesBoundsUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
    {
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
        if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
            rootSurfaceInfoProxy = new KisRootSurfaceInfoProxy(view, q);
            multiSurfaceSetupManager.setRootSurfaceInfoProxy(rootSurfaceInfoProxy);
            connect(rootSurfaceInfoProxy,
                    &KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged,
                    parent,
                    [this](const KoColorProfile *profile) {
                        if (!multiSurfaceState)
                            return;
                        auto newState = multiSurfaceSetupManager.onGuiSurfaceFormatChanged(*multiSurfaceState, profile);
                        assignChangedMultiSurfaceState(newState);
                    });
        }
#endif
    }

References connect(), KisPlatformPluginInterfaceFactory::instance(), and KisRootSurfaceInfoProxy::sigRootSurfaceProfileChanged().

◆ localShapeManager()

KoShapeManager * KisCanvas2::localShapeManager ( ) const

Return shape manager associated with the currently active node. If current node has no internal shape manager, return null.

Definition at line 577 of file kis_canvas2.cpp.

{
    KisNodeSP node = m_d->view->currentNode();
    KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
    if (localShapeManager != m_d->currentlyActiveShapeManager) {
        m_d->setActiveShapeManager(localShapeManager);
    }
 
    return localShapeManager;
}

References localShapeManager(), and m_d.

◆ lodIsSupported()

bool KisCanvas2::lodIsSupported ( ) const

inline

Definition at line 242 of file kis_canvas2.cpp.

                                {
        return currentCanvasIsOpenGL &&
                KisOpenGL::supportsLoD() &&
                (openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
                 openGLFilterMode == KisOpenGL::HighQualityFiltering);
    }

References KisOpenGL::HighQualityFiltering, KisOpenGL::supportsLoD(), and KisOpenGL::TrilinearFilterMode.

◆ lodPreferredInCanvas()

bool KisCanvas2::lodPreferredInCanvas ( ) const

Definition at line 1593 of file kis_canvas2.cpp.

{
    return m_d->lodPreferredInImage;
}

References m_d.

◆ notifyLevelOfDetailChange()

void KisCanvas2::notifyLevelOfDetailChange ( )

private

Definition at line 1303 of file kis_canvas2.cpp.

{
    KisImageSP image = this->image();
 
    if (m_d->bootstrapLodBlocked || !m_d->lodIsSupported()) {
        image->setLodPreferences(KisLodPreferences(KisLodPreferences::None, 0));
    } else {
        const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
        KisConfig cfg(true);
        const int maxLod = cfg.numMipmapLevels();
        const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
        KisLodPreferences::PreferenceFlags flags = KisLodPreferences::LodSupported;
 
        if (m_d->lodPreferredInImage) {
            flags |= KisLodPreferences::LodPreferred;
        }
        image->setLodPreferences(KisLodPreferences(flags, lod));
    }
}

References image(), KisLodPreferences::LodPreferred, KisLodPreferences::LodSupported, m_d, KisLodPreferences::None, KisConfig::numMipmapLevels(), KisLodTransformBase::scaleToLod(), and KisImage::setLodPreferences().

◆ openGLFilterMode()

KisOpenGL::FilterMode KisCanvas2::openGLFilterMode ( ) const

◆ paintingAssistantsDecoration()

KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration ( ) const

Definition at line 1598 of file kis_canvas2.cpp.

{
    KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
    return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
}

References KisSharedPtr< T >::data(), and decoration().

◆ popupPalette()

KisPopupPalette * KisCanvas2::popupPalette ( )

◆ proofingConfigUpdated()

bool KisCanvas2::proofingConfigUpdated ( )

proofingConfigUpdated ask the canvas whether or not it updated the proofing config.

Returns: whether or not the proofing config is updated, if so, a new proofing transform needs to be made in KisOpenGL canvas.

◆ proofingConfiguration()

KisProofingConfigurationSP KisCanvas2::proofingConfiguration ( ) const

Definition at line 946 of file kis_canvas2.cpp.

{
    return m_d->proofingConfig;
}

References m_d.

◆ referenceImagesDecoration()

KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration ( ) const

Definition at line 1604 of file kis_canvas2.cpp.

{
    KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
    return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
}

References KisSharedPtr< T >::data(), and decoration().

◆ refetchDataFromImage()

void KisCanvas2::refetchDataFromImage ( )

Definition at line 1400 of file kis_canvas2.cpp.

{
    KisImageSP image = this->image();
    KisImageReadOnlyBarrierLock l(image);
    startUpdateInPatches(image->bounds());
}

References KisImage::bounds(), image(), and startUpdateInPatches().

◆ regionOfInterest()

QRect KisCanvas2::regionOfInterest ( ) const

Returns: area of the image (in image coordinates) that is visible on the canvas with a small margin selected by the user

◆ renderingLimit()

QRect KisCanvas2::renderingLimit ( ) const

Returns: artificial limit outside which the image will not be rendered

◆ requestCanvasUpdateMaybeCompressed()

void KisCanvas2::requestCanvasUpdateMaybeCompressed ( )

private

If Qt has our custom patch for global updates compression, then we shouldn't do our own compression here in the canvas. Everything will be done in Qt.

Definition at line 1077 of file kis_canvas2.cpp.

{
#if !KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    m_d->canvasUpdateCompressor.start();
#else
    slotDoCanvasUpdate();
#endif
}

References m_d, and slotDoCanvasUpdate().

◆ resetCanvas()

void KisCanvas2::resetCanvas ( bool useOpenGL )

private

Definition at line 775 of file kis_canvas2.cpp.

{
    // we cannot reset the canvas before it's created, but this method might be called,
    // for instance when setting the monitor profile.
    if (!m_d->canvasWidget) {
        return;
    }
 
    KisConfig cfg(true);
 
    const bool canvasHasNativeSurface = bool(m_d->canvasWidget->widget()->windowHandle());
    const bool canvasNeedsNativeSurface =
        cfg.enableCanvasSurfaceColorSpaceManagement() &&
        KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS();
 
    bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
        (m_d->currentCanvasIsOpenGL &&
         m_d->openGLFilterMode != cfg.openGLFilteringMode()) ||
         canvasHasNativeSurface != canvasNeedsNativeSurface;
 
    if (needReset) {
        createCanvas(useOpenGL);
        connectCurrentCanvas();
        slotEffectiveZoomChanged(m_d->coordinatesConverter->effectiveZoom());
    }
    updateCanvasWidgetImpl();
}

References connectCurrentCanvas(), createCanvas(), KisConfig::enableCanvasSurfaceColorSpaceManagement(), KisPlatformPluginInterfaceFactory::instance(), m_d, KisConfig::openGLFilteringMode(), slotEffectiveZoomChanged(), KisPlatformPluginInterfaceFactory::surfaceColorManagedByOS(), and updateCanvasWidgetImpl().

◆ rotationAngle

qreal KisCanvas2::rotationAngle ( ) const

slot

canvas rotation in degrees

Definition at line 513 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter->rotationAngle();
}

References m_d.

◆ selectedShapesProxy()

KoSelectedShapesProxy * KisCanvas2::selectedShapesProxy ( ) const

overridevirtual

Since shapeManager() may change, we need a persistent object where we can connect to and thack the selection. See more comments in KoCanvasBase.

Implements KoCanvasBase.

◆ setActiveShapeManager()

void KisCanvas2::setActiveShapeManager ( KoShapeManager * shapeManager )

◆ setCanvasWidget()

void KisCanvas2::setCanvasWidget ( KisAbstractCanvasWidget * widget )

private

We are switching the canvas type. We should reinitialize our connections to decorations and input manager

Definition at line 403 of file kis_canvas2.cpp.

{
    if (m_d->popupPalette) {
        m_d->popupPalette->setParent(widget->widget());
    }
 
    if (m_d->canvasWidget) {
        widget->setDecorations(m_d->canvasWidget->decorations());
 
        if(viewManager()) {
            viewManager()->inputManager()->removeTrackedCanvas(this);
            m_d->canvasWidget = widget;
            viewManager()->inputManager()->addTrackedCanvas(this);
        } else {
            m_d->canvasWidget = widget;
        }
    } else {
        m_d->canvasWidget = widget;
    }
 
    if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
        KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
        manager->setVisible(true);
        m_d->canvasWidget->addDecoration(manager);
    }
 
    widget->widget()->setAutoFillBackground(false);
    widget->widget()->setAttribute(Qt::WA_OpaquePaintEvent);
    widget->widget()->setMouseTracking(true);
    widget->widget()->setAcceptDrops(true);
 
    KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
    if (controller && controller->canvas() == this) {
        controller->changeCanvasWidget(widget->widget());
    }
 
 
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
    if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
        m_d->surfaceColorManager.reset();
 
        QWindow *mainWindowNativeWindow = m_d->view->mainWindow()->windowHandle();
        QWindow *nativeWindow = widget->widget()->windowHandle();
 
        if (nativeWindow && nativeWindow != mainWindowNativeWindow) {
            std::unique_ptr<KisSurfaceColorManagerInterface> iface(
                KisPlatformPluginInterfaceFactory::instance()->createSurfaceColorManager(nativeWindow));
 
            // if surfaceColorManagedByOS() is true, then interface is guaranteed to
            // be present
            KIS_SAFE_ASSERT_RECOVER_NOOP(iface);
 
            if (iface) {
                m_d->surfaceColorManager.reset(
                    new KisCanvasSurfaceColorSpaceManager(iface.release(),
                                                          m_d->multiSurfaceState->surfaceMode,
                                                          m_d->multiSurfaceState->multiConfig.options(),
                                                          this));
 
                connect(m_d->surfaceColorManager.data(),
                        &KisCanvasSurfaceColorSpaceManager::sigDisplayConfigChanged,
                        this,
                        &KisCanvas2::slotSurfaceFormatChanged);
            }
        } else {
            qWarning() << "WARNING: created non-native Krita canvas on managed platform,"
                       << "its color space will be limited to sRGB";
        }
    }
#endif
}

References KisInputManager::addTrackedCanvas(), KoCanvasController::canvas(), KoCanvasBase::canvasController(), connect(), KoCanvasBase::controller, INFINITY_DECORATION_ID, KisViewManager::inputManager(), KisPlatformPluginInterfaceFactory::instance(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisInputManager::removeTrackedCanvas(), KisAbstractCanvasWidget::setDecorations(), KisCanvasDecoration::setVisible(), KisCanvasSurfaceColorSpaceManager::sigDisplayConfigChanged(), slotSurfaceFormatChanged(), KisPlatformPluginInterfaceFactory::surfaceColorManagedByOS(), viewManager(), and KisAbstractCanvasWidget::widget().

◆ setCursor()

void KisCanvas2::setCursor ( const QCursor & cursor )

overridevirtual

set the specified cursor on this canvas

Parameters

cursor the new cursor

Returns: the old cursor

Implements KoCanvasBase.

Definition at line 1512 of file kis_canvas2.cpp.

{
    canvasWidget()->setCursor(cursor);
}

References canvasWidget.

◆ setDisplayFilter()

void KisCanvas2::setDisplayFilter ( QSharedPointer< KisDisplayFilter > displayFilter )

Definition at line 826 of file kis_canvas2.cpp.

{
    m_d->displayColorConverter.setDisplayFilter(displayFilter);
    KisImageSP image = this->image();
 
    m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
    image->barrierLock();
    m_d->canvasWidget->setDisplayFilter(displayFilter);
    image->unlock();
}

References KisImage::barrierLock(), displayFilter(), image(), m_d, and KisImage::unlock().

◆ setFavoriteResourceManager()

void KisCanvas2::setFavoriteResourceManager ( KisFavoriteResourceManager * favoriteResourceManager )

Definition at line 1499 of file kis_canvas2.cpp.

{
    m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                            m_d->canvasWidget->widget());
    connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
    connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
    connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
}

References connect(), displayColorConverter, m_d, slotPopupPaletteRequestedZoomChange(), updateCanvas(), and viewManager().

◆ setLodPreferredInCanvas()

void KisCanvas2::setLodPreferredInCanvas ( bool value )

Definition at line 1578 of file kis_canvas2.cpp.

{
    if (!KisOpenGL::supportsLoD()) {
        qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
    }
 
    m_d->lodPreferredInImage =
        value && m_d->lodIsSupported();
 
    notifyLevelOfDetailChange();
 
    KisConfig cfg(false);
    cfg.setLevelOfDetailEnabled(m_d->lodPreferredInImage);
}

References m_d, notifyLevelOfDetailChange(), KisConfig::setLevelOfDetailEnabled(), KisOpenGL::supportsLoD(), and value().

◆ setProofingConfigUpdated()

void KisCanvas2::setProofingConfigUpdated ( bool updated )

setProofingConfigUpdated This function is to set whether the proofing config is updated, this is needed for determining whether or not to generate a new proofing transform.

Parameters

updated whether it's updated. Just set it to false in normal usage.

Definition at line 936 of file kis_canvas2.cpp.

{
    m_d->proofingConfigUpdated = updated;
}

References m_d.

◆ setRenderingLimit()

void KisCanvas2::setRenderingLimit ( const QRect & rc )

Set artificial limit outside which the image will not be rendered rc is measured in image pixels

Definition at line 1278 of file kis_canvas2.cpp.

{
    m_d->renderingLimit = rc;
}

References m_d.

◆ setup()

void KisCanvas2::setup ( )

private

We switch the shape manager every time vector layer or shape selection is activated. Flake does not expect this and connects all the signals of the global shape manager to the clients in the constructor. To workaround this we forward the signals of local shape managers stored in the vector layers to the signals of global shape manager. So the sequence of signal deliveries is the following:

shapeLayer.m_d.canvas.m_shapeManager.selection() -> shapeLayer -> shapeController -> globalShapeManager.selection()

Definition at line 318 of file kis_canvas2.cpp.

{
    // a bit of duplication from slotConfigChanged()
    KisConfig cfg(true);
    m_d->lodPreferredInImage = cfg.levelOfDetailEnabled();
    m_d->regionOfInterestMargin = KisImageConfig(true).animationCacheRegionOfInterestMargin();
 
    createCanvas(cfg.useOpenGL());
 
    setLodPreferredInCanvas(m_d->lodPreferredInImage);
 
    connect(m_d->view->canvasController()->proxyObject, SIGNAL(effectiveZoomChanged(qreal)), SLOT(slotEffectiveZoomChanged(qreal)));
    connect(m_d->view->canvasController()->proxyObject, &KoCanvasControllerProxyObject::canvasStateChanged, this, &KisCanvas2::slotCanvasStateChanged);
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
    connect(KisImageConfigNotifier::instance(), &KisImageConfigNotifier::globalProofingConfigChanged,
            this, &KisCanvas2::slotChangeGlobalProofingConfig);
 
    KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
    connect(kritaShapeController, SIGNAL(selectionChanged()),
            this, SLOT(slotSelectionChanged()));
    connect(kritaShapeController, SIGNAL(selectionContentChanged()),
            selectedShapesProxy(), SIGNAL(selectionContentChanged()));
    connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
            selectedShapesProxy(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
#if !KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
#endif
 
    connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
    connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
    connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
    connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
    connect(&m_d->referencesBoundsUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateReferencesBounds()));
 
    connect(m_d->view->document(), SIGNAL(sigReferenceImagesChanged()), &m_d->referencesBoundsUpdateCompressor, SLOT(start()));
 
    initializeFpsDecoration();
 
    m_d->animationPlayer.reset(new KisCanvasAnimationState(this));
}

References KisImageConfig::animationCacheRegionOfInterestMargin(), KoCanvasControllerProxyObject::canvasStateChanged(), connect(), createCanvas(), finishResizingImage(), KisImageConfigNotifier::globalProofingConfigChanged(), initializeFpsDecoration(), KisConfigNotifier::instance(), KisImageConfigNotifier::instance(), KisConfig::levelOfDetailEnabled(), m_d, selectedShapesProxy, setLodPreferredInCanvas(), KoCanvasBase::shapeController, sigCanvasCacheUpdated(), sigContinueResizeImage(), slotCanvasStateChanged(), slotChangeGlobalProofingConfig(), slotConfigChanged(), slotDoCanvasUpdate(), slotEffectiveZoomChanged(), slotSelectionChanged(), slotUpdateReferencesBounds(), slotUpdateRegionOfInterest(), updateCanvasProjection(), and KisConfig::useOpenGL().

◆ setWrapAroundViewingMode()

void KisCanvas2::setWrapAroundViewingMode ( bool value )

Definition at line 1539 of file kis_canvas2.cpp.

{
    KisCanvasDecorationSP infinityDecoration =
        m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
    if (infinityDecoration) {
        infinityDecoration->setVisible(!value);
    }
 
    m_d->canvasWidget->setWrapAroundViewingMode(value);
}

References INFINITY_DECORATION_ID, m_d, and value().

◆ setWrapAroundViewingModeAxis()

void KisCanvas2::setWrapAroundViewingModeAxis ( WrapAroundAxis value )

Definition at line 1556 of file kis_canvas2.cpp.

{
    m_d->canvasWidget->setWrapAroundViewingModeAxis(value);
    updateCanvas();
}

References m_d, updateCanvas(), and value().

◆ shapeManager()

KoShapeManager * KisCanvas2::shapeManager ( ) const

overridevirtual

Return the right shape manager for the current layer. That is to say, if the current layer is a vector layer, return the shape layer's canvas' shapemanager, else the shapemanager associated with the global krita canvas.

Implements KoCanvasBase.

◆ sigCanvasCacheUpdated

void KisCanvas2::sigCanvasCacheUpdated ( )

signal

◆ sigCanvasEngineChanged

void KisCanvas2::sigCanvasEngineChanged ( )

signal

◆ sigCanvasStateChanged

void KisCanvas2::sigCanvasStateChanged ( )

signal

◆ sigContinueResizeImage

void KisCanvas2::sigContinueResizeImage	(	qint32	w,
		qint32	h )

signal

◆ sigRegionOfInterestChanged

void KisCanvas2::sigRegionOfInterestChanged ( const QRect & roi )

signal

◆ slotBeginUpdatesBatch

void KisCanvas2::slotBeginUpdatesBatch ( )

privateslot

Definition at line 1048 of file kis_canvas2.cpp.

{
    KisUpdateInfoSP info =
        new KisMarkerUpdateInfo(KisMarkerUpdateInfo::StartBatch,
                                      m_d->coordinatesConverter->imageRectInImagePixels());
    m_d->projectionUpdatesCompressor.putUpdateInfo(info);
    Q_EMIT sigCanvasCacheUpdated();
}

References m_d, sigCanvasCacheUpdated(), and KisMarkerUpdateInfo::StartBatch.

◆ slotCanvasStateChanged

void KisCanvas2::slotCanvasStateChanged ( )

privateslot

Definition at line 1348 of file kis_canvas2.cpp.

{
    if (!m_d->currentCanvasIsOpenGL) {
        Q_ASSERT(m_d->prescaledProjection);
        auto state = KisCanvasState::fromConverter(*m_d->coordinatesConverter);
        m_d->prescaledProjection->notifyCanvasStateChanged(state);
    }
 
    updateCanvas();
    m_d->regionOfInterestUpdateCompressor.start();
 
    Q_EMIT sigCanvasStateChanged();
}

References KisCanvasState::fromConverter(), m_d, sigCanvasStateChanged(), and updateCanvas().

◆ slotChangeGlobalProofingConfig

void KisCanvas2::slotChangeGlobalProofingConfig ( )

slot

Definition at line 919 of file kis_canvas2.cpp.

{
    if (image() && !image()->proofingConfiguration()) {
        // global config should be updated only when
        // the image doesn't have its own config
        slotChangeProofingConfig();
    }
}

References image(), proofingConfiguration(), and slotChangeProofingConfig().

◆ slotChangeProofingConfig

void KisCanvas2::slotChangeProofingConfig ( )

slot

Definition at line 928 of file kis_canvas2.cpp.

{
    fetchProofingOptions();
    if (imageView()->softProofing()) {
        refetchDataFromImage();
    }
}

References fetchProofingOptions(), imageView(), and refetchDataFromImage().

◆ slotConfigChanged

void KisCanvas2::slotConfigChanged ( )

slot

Called whenever the configuration settings change.

Definition at line 1362 of file kis_canvas2.cpp.

{
    KisConfig cfg(true);
    m_d->regionOfInterestMargin = KisImageConfig(true).animationCacheRegionOfInterestMargin();
 
    resetCanvas(cfg.useOpenGL());
 
    QWidget *mainWindow = m_d->view->mainWindow();
    KIS_SAFE_ASSERT_RECOVER_RETURN(mainWindow);
 
    QWidget *topLevelWidget = mainWindow->topLevelWidget();
    KIS_SAFE_ASSERT_RECOVER_RETURN(topLevelWidget);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->multiSurfaceState);
    auto newState = m_d->multiSurfaceSetupManager.onConfigChanged(*m_d->multiSurfaceState,
                                                                  m_d->currentScreenId(),
                                                                  cfg.canvasSurfaceColorSpaceManagementMode(),
                                                                  KisDisplayConfig::optionsFromKisConfig(cfg));
    m_d->assignChangedMultiSurfaceState(newState);
 
    initializeFpsDecoration();
}

References KisImageConfig::animationCacheRegionOfInterestMargin(), KisConfig::canvasSurfaceColorSpaceManagementMode(), initializeFpsDecoration(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisDisplayConfig::optionsFromKisConfig(), resetCanvas(), and KisConfig::useOpenGL().

◆ slotDoCanvasUpdate

void KisCanvas2::slotDoCanvasUpdate ( )

privateslot

WARNING: in isBusy() we access openGL functions without making the painting context current. We hope that currently active context will be Qt's one, which is shared with our own.

Definition at line 1090 of file kis_canvas2.cpp.

{
 
#if !KRITA_QT_HAS_UPDATE_COMPRESSION_PATCH
    if (m_d->canvasWidget->isBusy()) {
        // just restarting the timer
        m_d->canvasUpdateCompressor.start();
        return;
    }
#endif
 
    QRect combinedUpdateRect = m_d->savedCanvasProjectionUpdateRect | m_d->savedOverlayUpdateRect;
    if (!combinedUpdateRect.isEmpty()) {
        // TODO: Remove this signal (only used by the old KisSketchView)
        Q_EMIT updateCanvasRequested(combinedUpdateRect);
 
        if (wrapAroundViewingMode() && !m_d->savedCanvasProjectionUpdateRect.isEmpty()) {
            const QRect widgetRect = m_d->canvasWidget->widget()->rect();
            const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
            const QRect widgetRectInImagePixels =
                m_d->coordinatesConverter->widgetToImage(widgetRect).toAlignedRect();
 
            const QRect rc = m_d->coordinatesConverter->widgetToImage(m_d->savedCanvasProjectionUpdateRect).toAlignedRect();
 
            const QVector<QRect> updateRects =
                KisWrappedRect::multiplyWrappedRect(rc, imageRect, widgetRectInImagePixels, wrapAroundViewingModeAxis());
 
            Q_FOREACH(const QRect &rc, updateRects) {
                const QRect widgetUpdateRect =
                    m_d->coordinatesConverter->imageToWidget(rc).toAlignedRect() & widgetRect;
                m_d->canvasWidget->updateCanvasImage(widgetUpdateRect);
            }
            m_d->canvasWidget->updateCanvasDecorations(m_d->savedOverlayUpdateRect);
        } else {
            m_d->canvasWidget->updateCanvasImage(m_d->savedCanvasProjectionUpdateRect);
            m_d->canvasWidget->updateCanvasDecorations(m_d->savedOverlayUpdateRect);
        }
    } else if (m_d->updateSceneRequested) {
        m_d->canvasWidget->widget()->update();
    }
 
    m_d->savedCanvasProjectionUpdateRect = QRect();
    m_d->savedOverlayUpdateRect = QRect();
    m_d->updateSceneRequested = false;
}

References m_d, KisWrappedRect::multiplyWrappedRect(), updateCanvasRequested(), wrapAroundViewingMode(), and wrapAroundViewingModeAxis().

◆ slotEffectiveZoomChanged

void KisCanvas2::slotEffectiveZoomChanged ( qreal newZoom )

privateslot

Definition at line 1237 of file kis_canvas2.cpp.

{
    Q_UNUSED(newZoom)
 
    notifyLevelOfDetailChange();
}

References notifyLevelOfDetailChange().

◆ slotEndUpdatesBatch

void KisCanvas2::slotEndUpdatesBatch ( )

privateslot

Definition at line 1057 of file kis_canvas2.cpp.

{
    KisUpdateInfoSP info =
        new KisMarkerUpdateInfo(KisMarkerUpdateInfo::EndBatch,
                                      m_d->coordinatesConverter->imageRectInImagePixels());
    m_d->projectionUpdatesCompressor.putUpdateInfo(info);
    Q_EMIT sigCanvasCacheUpdated();
}

References KisMarkerUpdateInfo::EndBatch, m_d, and sigCanvasCacheUpdated().

◆ slotGamutCheck

void KisCanvas2::slotGamutCheck ( )

slot

Definition at line 911 of file kis_canvas2.cpp.

{
    updateProofingState();
    if (imageView()->softProofing()) {
        refetchDataFromImage();
    }
}

References imageView(), refetchDataFromImage(), and updateProofingState().

◆ slotImageColorSpaceChanged

void KisCanvas2::slotImageColorSpaceChanged ( )

privateslot

Definition at line 843 of file kis_canvas2.cpp.

{
    KisImageSP image = this->image();
 
    m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
    m_d->displayColorConverter.setImageColorSpace(image->colorSpace());
    m_d->channelFlags = image->rootLayer()->channelFlags();
    m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
 
    // Not all color spaces are supported by soft-proofing, so update state
    if (imageView()->softProofing()) {
        updateProofingState();
    }
 
    image->barrierLock();
    m_d->canvasWidget->notifyImageColorSpaceChanged(image->colorSpace());
    image->unlock();
}

References KisImage::barrierLock(), KisLayer::channelFlags, KisImage::colorSpace(), image(), imageView(), m_d, KisImage::rootLayer(), KisImage::unlock(), and updateProofingState().

◆ slotPopupPaletteRequestedZoomChange

void KisCanvas2::slotPopupPaletteRequestedZoomChange ( int zoom )

slot

Definition at line 1508 of file kis_canvas2.cpp.

                                                              {
    m_d->view->canvasController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
}

References m_d, and KoZoomMode::ZOOM_CONSTANT.

◆ slotScreenChanged

void KisCanvas2::slotScreenChanged ( QScreen * screen )

slot

Definition at line 1385 of file kis_canvas2.cpp.

{
    const int screenId = qApp->screens().indexOf(screen);
 
    if (screenId < 0) {
        warnUI << "Failed to get screenNumber for updating display profile.";
        return;
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->multiSurfaceState);
    auto newState = m_d->multiSurfaceSetupManager.onScreenChanged(*m_d->multiSurfaceState,
                                                                  screenId);
    m_d->assignChangedMultiSurfaceState(newState);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and warnUI.

◆ slotSelectionChanged

void KisCanvas2::slotSelectionChanged ( )

privateslot

Definition at line 1527 of file kis_canvas2.cpp.

{
    KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
    if (!shapeLayer) {
        return;
    }
    m_d->shapeManager.selection()->deselectAll();
    Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
        m_d->shapeManager.selection()->select(shape);
    }
}

References KisViewManager::activeLayer(), KisSharedPtr< T >::data(), m_d, KoSelection::selectedShapes(), KoShapeManager::selection, KisShapeLayer::shapeManager(), and viewManager().

◆ slotSetLodUpdatesBlocked

void KisCanvas2::slotSetLodUpdatesBlocked ( bool value )

privateslot

Definition at line 1066 of file kis_canvas2.cpp.

{
    KisUpdateInfoSP info =
        new KisMarkerUpdateInfo(value ?
                                KisMarkerUpdateInfo::BlockLodUpdates :
                                KisMarkerUpdateInfo::UnblockLodUpdates,
                                m_d->coordinatesConverter->imageRectInImagePixels());
    m_d->projectionUpdatesCompressor.putUpdateInfo(info);
    Q_EMIT sigCanvasCacheUpdated();
}

References KisMarkerUpdateInfo::BlockLodUpdates, m_d, sigCanvasCacheUpdated(), KisMarkerUpdateInfo::UnblockLodUpdates, and value().

◆ slotSoftProofing

void KisCanvas2::slotSoftProofing ( )

slot

Definition at line 905 of file kis_canvas2.cpp.

{
    updateProofingState();
    refetchDataFromImage();
}

References refetchDataFromImage(), and updateProofingState().

◆ slotSurfaceFormatChanged()

void KisCanvas2::slotSurfaceFormatChanged ( const KisDisplayConfig & config )

private

Definition at line 1445 of file kis_canvas2.cpp.

{
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->multiSurfaceState);
    if (m_d->multiSurfaceState->multiConfig.canvasDisplayConfig() == config) return;
 
    if (m_d->multiSurfaceState->isCanvasOpenGL) {
        if (config.isHDR &&
            m_d->canvasWidget->currentBitDepthMode() < KisOpenGLCanvas2::BitDepthMode::Depth10Bit) {
 
            const QString warningMessage = i18n(
                "WARNING: HDR mode was activated on surface working in 8-bit mode!\n"
                "Please activate 10-bit mode in Krita's Preferences dialog and restart "
                "Krita to avoid color banding!");
 
            m_d->view->showFloatingMessage(warningMessage, koIcon("warning"), 7000, KisFloatingMessage::High);
            warnOpenGL.noquote() << QString(warningMessage).replace('\n', ' ');
            warnOpenGL << ppVar(QSurfaceFormat::defaultFormat());
        }
    }
 
    auto newState = m_d->multiSurfaceSetupManager.onCanvasSurfaceFormatChanged(*m_d->multiSurfaceState, config);
    m_d->assignChangedMultiSurfaceStateSkipCanvasSurface(newState);
#endif
}

References KisAbstractCanvasWidget::Depth10Bit, KisFloatingMessage::High, KisDisplayConfig::isHDR, KIS_SAFE_ASSERT_RECOVER_RETURN, koIcon, m_d, ppVar, and warnOpenGL.

◆ slotTrySwitchShapeManager

void KisCanvas2::slotTrySwitchShapeManager ( )

slot

Definition at line 1293 of file kis_canvas2.cpp.

{
    KisNodeSP node = m_d->view->currentNode();
 
    QPointer<KoShapeManager> newManager;
    newManager = fetchShapeManagerFromNode(node);
 
    m_d->setActiveShapeManager(newManager);
}

References m_d.

◆ slotUpdateReferencesBounds

void KisCanvas2::slotUpdateReferencesBounds ( )

privateslot

Definition at line 1267 of file kis_canvas2.cpp.

{
    QRectF referencesRect;
    KisReferenceImagesLayerSP layer = m_d->view->document()->referenceImagesLayer();
    if (layer) {
        referencesRect = layer->boundingImageRect();
    }
 
    m_d->view->canvasController()->syncOnReferencesChange(referencesRect);
}

References KisReferenceImagesLayer::boundingImageRect(), and m_d.

◆ slotUpdateRegionOfInterest

void KisCanvas2::slotUpdateRegionOfInterest ( )

privateslot

Definition at line 1251 of file kis_canvas2.cpp.

{
    const QRect oldRegionOfInterest = m_d->regionOfInterest;
 
    const qreal ratio = m_d->regionOfInterestMargin;
    const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
 
    const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
    m_d->regionOfInterest = proposedRoi & imageRect;
 
    if (m_d->regionOfInterest != oldRegionOfInterest) {
        Q_EMIT sigRegionOfInterestChanged(m_d->regionOfInterest);
    }
}

References KisAlgebra2D::blowRect(), m_d, and sigRegionOfInterestChanged().

◆ snapToGrid()

bool KisCanvas2::snapToGrid ( ) const

overridevirtual

return if snap to grid is enabled.

Returns: if snap to grid is enabled.

Implements KoCanvasBase.

Definition at line 508 of file kis_canvas2.cpp.

{
    return m_d->view->document()->gridConfig().snapToGrid();
}

References m_d.

◆ startResizingImage

void KisCanvas2::startResizingImage ( )

slot

Definition at line 951 of file kis_canvas2.cpp.

{
    KisImageWSP image = this->image();
    qint32 w = image->width();
    qint32 h = image->height();
 
    Q_EMIT sigContinueResizeImage(w, h);
 
    QRect imageBounds(0, 0, w, h);
    startUpdateInPatches(imageBounds);
}

References KisImage::height(), image(), sigContinueResizeImage(), startUpdateInPatches(), and KisImage::width().

◆ startUpdateCanvasProjection

void KisCanvas2::startUpdateCanvasProjection ( const QRect & rc )

privateslot

The image projection has changed, now start an update of the canvas representation.

Definition at line 968 of file kis_canvas2.cpp.

{
    KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc);
    if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
        Q_EMIT sigCanvasCacheUpdated();
    }
}

References m_d, and sigCanvasCacheUpdated().

◆ startUpdateInPatches

void KisCanvas2::startUpdateInPatches ( const QRect & imageRect )

slot

We don't do patched loading for openGL canvas, because it loads the tiles, which are basically "patches". Therefore, big chunks of memory are never allocated.

Definition at line 803 of file kis_canvas2.cpp.

{
    if (m_d->currentCanvasIsOpenGL) {
        startUpdateCanvasProjection(imageRect);
    } else {
        KisImageConfig imageConfig(true);
        int patchWidth = imageConfig.updatePatchWidth();
        int patchHeight = imageConfig.updatePatchHeight();
 
        for (int y = 0; y < imageRect.height(); y += patchHeight) {
            for (int x = 0; x < imageRect.width(); x += patchWidth) {
                QRect patchRect(x, y, patchWidth, patchHeight);
                startUpdateCanvasProjection(patchRect);
            }
        }
    }
}

References m_d, startUpdateCanvasProjection(), KisImageConfig::updatePatchHeight(), and KisImageConfig::updatePatchWidth().

◆ toolProxy()

KoToolProxy * KisCanvas2::toolProxy ( ) const

overridevirtual

Return the proxy to the active tool (determining which tool is really, really active is hard when tablets are involved, so leave that to others.

Implements KoCanvasBase.

◆ unit()

KoUnit KisCanvas2::unit ( ) const

overridevirtual

Return the unit of the current document for initialization of the widgets created by the flake framework.

See also: KoDocument::unit()

Implements KoCanvasBase.

Definition at line 620 of file kis_canvas2.cpp.

{
    KoUnit unit(KoUnit::Pixel);
 
    KisImageWSP image = m_d->view->image();
    if (image) {
        if (!qFuzzyCompare(image->xRes(), image->yRes())) {
            warnKrita << "WARNING: resolution of the image is anisotropic"
                       << ppVar(image->xRes())
                       << ppVar(image->yRes());
        }
 
        const qreal resolution = image->xRes();
        unit.setFactor(resolution);
    }
 
    return unit;
}

References image(), m_d, KoUnit::Pixel, ppVar, qFuzzyCompare(), KoUnit::setFactor(), unit(), warnKrita, KisImage::xRes(), and KisImage::yRes().

◆ updateCanvas [1/2]

void KisCanvas2::updateCanvas ( )

slot

Update the entire canvas area.

Definition at line 1158 of file kis_canvas2.cpp.

{
    updateCanvasWidgetImpl();
}

References updateCanvasWidgetImpl().

◆ updateCanvas() [2/2]

void KisCanvas2::updateCanvas ( const QRectF & rc )

overridevirtual

Tell the canvas to repaint the specified rectangle. The coordinates are document coordinates, not view coordinates.

Implements KoCanvasBase.

Definition at line 1170 of file kis_canvas2.cpp.

{
    // updateCanvas is called from tools, never from the projection
    // updates, so no need to prescale!
    QRect widgetRect = m_d->docUpdateRectToWidget(documentRect);
    if (!widgetRect.isEmpty()) {
        updateCanvasWidgetImpl(widgetRect);
    }
}

References m_d, and updateCanvasWidgetImpl().

◆ updateCanvasDecorations [1/2]

void KisCanvas2::updateCanvasDecorations ( )

slot

Definition at line 1189 of file kis_canvas2.cpp.

{
    m_d->savedOverlayUpdateRect = m_d->canvasWidget->widget()->rect();
    requestCanvasUpdateMaybeCompressed();
}

References m_d, and requestCanvasUpdateMaybeCompressed().

◆ updateCanvasDecorations [2/2]

void KisCanvas2::updateCanvasDecorations ( const QRectF & docRect )

slot

Definition at line 1195 of file kis_canvas2.cpp.

{
    QRect widgetRect = m_d->docUpdateRectToWidget(docRect);
    if (!widgetRect.isEmpty()) {
        m_d->savedOverlayUpdateRect |= widgetRect;
        requestCanvasUpdateMaybeCompressed();
    }
}

References m_d, and requestCanvasUpdateMaybeCompressed().

◆ updateCanvasProjection [1/2]

void KisCanvas2::updateCanvasProjection ( )

privateslot

Definition at line 976 of file kis_canvas2.cpp.

{
    auto tryIssueCanvasUpdates = [this](const QRect &vRect) {
        if (!m_d->isBatchUpdateActive) {
            // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
            if (m_d->currentCanvasIsOpenGL) {
                m_d->savedCanvasProjectionUpdateRect |= vRect;
 
                // we already had a compression in frameRenderStartCompressor, so force the update directly
                slotDoCanvasUpdate();
            } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
                m_d->savedCanvasProjectionUpdateRect |= m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
                // we already had a compression in frameRenderStartCompressor, so force the update directly
                slotDoCanvasUpdate();
            }
        }
    };
 
    auto uploadData = [this, tryIssueCanvasUpdates](const QVector<KisUpdateInfoSP> &infoObjects) {
        QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
        const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                            QRect(), std::bit_or<QRect>());
 
        tryIssueCanvasUpdates(vRect);
    };
 
    bool shouldExplicitlyIssueUpdates = false;
 
    QVector<KisUpdateInfoSP> infoObjects;
    KisUpdateInfoList originalInfoObjects;
    m_d->projectionUpdatesCompressor.takeUpdateInfo(originalInfoObjects);
 
    for (auto it = originalInfoObjects.constBegin();
         it != originalInfoObjects.constEnd();
         ++it) {
 
        KisUpdateInfoSP info = *it;
 
        const KisMarkerUpdateInfo *batchInfo = dynamic_cast<const KisMarkerUpdateInfo*>(info.data());
        if (batchInfo) {
            if (!infoObjects.isEmpty()) {
                uploadData(infoObjects);
                infoObjects.clear();
            }
 
            if (batchInfo->type() == KisMarkerUpdateInfo::StartBatch) {
                m_d->isBatchUpdateActive++;
            } else if (batchInfo->type() == KisMarkerUpdateInfo::EndBatch) {
                m_d->isBatchUpdateActive--;
                KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->isBatchUpdateActive >= 0);
                if (m_d->isBatchUpdateActive == 0) {
                    shouldExplicitlyIssueUpdates = true;
                }
            } else if (batchInfo->type() == KisMarkerUpdateInfo::BlockLodUpdates) {
                m_d->canvasWidget->setLodResetInProgress(true);
            } else if (batchInfo->type() == KisMarkerUpdateInfo::UnblockLodUpdates) {
                m_d->canvasWidget->setLodResetInProgress(false);
                shouldExplicitlyIssueUpdates = true;
            }
        } else {
            infoObjects << info;
        }
    }
 
    if (!infoObjects.isEmpty()) {
        uploadData(infoObjects);
    } else if (shouldExplicitlyIssueUpdates) {
        tryIssueCanvasUpdates(m_d->coordinatesConverter->imageRectInImagePixels());
    }
}

References KisMarkerUpdateInfo::BlockLodUpdates, KisSharedPtr< T >::data(), KisMarkerUpdateInfo::EndBatch, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, slotDoCanvasUpdate(), KisMarkerUpdateInfo::StartBatch, KisMarkerUpdateInfo::type(), and KisMarkerUpdateInfo::UnblockLodUpdates.

◆ updateCanvasProjection [2/2]

void KisCanvas2::updateCanvasProjection ( const QRectF & docRect )

slot

Definition at line 1180 of file kis_canvas2.cpp.

{   
    QRect widgetRect = m_d->docUpdateRectToWidget(docRect);
    if (!widgetRect.isEmpty()) {
        m_d->savedCanvasProjectionUpdateRect |= widgetRect;
        requestCanvasUpdateMaybeCompressed();
    }
}

References m_d, and requestCanvasUpdateMaybeCompressed().

◆ updateCanvasRequested

void KisCanvas2::updateCanvasRequested ( const QRect & rc )

signal

◆ updateCanvasScene

void KisCanvas2::updateCanvasScene ( )

slot

Definition at line 1225 of file kis_canvas2.cpp.

{
    m_d->updateSceneRequested = true;
    requestCanvasUpdateMaybeCompressed();
}

References m_d, and requestCanvasUpdateMaybeCompressed().

◆ updateCanvasToolOutlineDoc

void KisCanvas2::updateCanvasToolOutlineDoc ( const QRectF & docRect )

slot

Definition at line 1204 of file kis_canvas2.cpp.

{
    QRect widgetRect = m_d->docUpdateRectToWidget(docRect);
    if (!widgetRect.isEmpty()) {
        updateCanvasToolOutlineWdg(widgetRect);
    }
}

References m_d, and updateCanvasToolOutlineWdg().

◆ updateCanvasToolOutlineWdg

void KisCanvas2::updateCanvasToolOutlineWdg ( const QRect & widgetRect )

slot

Definition at line 1212 of file kis_canvas2.cpp.

{
    QRect rect = widgetRect & m_d->canvasWidget->widget()->rect();
    if (!rect.isEmpty()) {
        m_d->savedOverlayUpdateRect |= rect;
#ifdef HAVE_NO_QT_UPDATE_COMPRESSIO
        m_d->canvasUpdateCompressor.start();
#else
        slotDoCanvasUpdate();
#endif
    }
}

References m_d, and slotDoCanvasUpdate().

◆ updateCanvasWidgetImpl()

void KisCanvas2::updateCanvasWidgetImpl ( const QRect & rc = QRect() )

private

Definition at line 1142 of file kis_canvas2.cpp.

{
    QRect rect = m_d->canvasWidget->widget()->rect();
    if (!rc.isEmpty()) {
        rect &= rc;
        if (rect.isEmpty()) {
            return;
        }
    }
    // We don't know if it's the canvas projection or the overlay that's
    // changed, so we update both.
    m_d->savedCanvasProjectionUpdateRect |= rect;
    m_d->savedOverlayUpdateRect |= rect;
    requestCanvasUpdateMaybeCompressed();
}

References m_d, and requestCanvasUpdateMaybeCompressed().

◆ updateProofingState()

void KisCanvas2::updateProofingState ( )

Definition at line 888 of file kis_canvas2.cpp.

{
    KoColorConversionTransformation::ConversionFlags displayFlags = m_d->proofingConfig->displayFlags;
    displayFlags.setFlag(KoColorConversionTransformation::SoftProofing, false);
 
    if (image()->colorSpace()->colorDepthId().id().contains("U")) {
        displayFlags.setFlag(KoColorConversionTransformation::SoftProofing, imageView()->softProofing());
        displayFlags.setFlag(KoColorConversionTransformation::GamutCheck, imageView()->gamutCheck());
    }
    m_d->proofingConfig->displayFlags = displayFlags;
    m_d->proofingConfigUpdated = true;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->multiSurfaceState);
    auto newState = m_d->multiSurfaceSetupManager.onProofingChanged(*m_d->multiSurfaceState, m_d->proofingConfig);
    m_d->assignChangedMultiSurfaceState(newState);
}

References KoColorConversionTransformation::GamutCheck, image(), imageView(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and KoColorConversionTransformation::SoftProofing.

◆ viewConverter() [1/2]

const KoViewConverter * KisCanvas2::viewConverter ( ) const

overridevirtual

Return the viewConverter for this view.

Returns: the viewConverter for this view.

Implements KoCanvasBase.

Definition at line 594 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter;
}

References m_d.

◆ viewConverter() [2/2]

KoViewConverter * KisCanvas2::viewConverter ( )

overridevirtual

Implements KoCanvasBase.

Definition at line 599 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter;
}

References m_d.

◆ viewManager()

KisViewManager * KisCanvas2::viewManager ( ) const

Definition at line 1324 of file kis_canvas2.cpp.

{
    if (m_d->view) {
        return m_d->view->viewManager();
    }
    return 0;
}

References m_d.

◆ wrapAroundViewingMode()

bool KisCanvas2::wrapAroundViewingMode ( ) const

Definition at line 1551 of file kis_canvas2.cpp.

{
    return m_d->canvasWidget->wrapAroundViewingMode();
}

References m_d.

◆ wrapAroundViewingModeAxis()

WrapAroundAxis KisCanvas2::wrapAroundViewingModeAxis ( ) const

Definition at line 1562 of file kis_canvas2.cpp.

{
    return m_d->canvasWidget->wrapAroundViewingModeAxis();
}

References m_d.

◆ xAxisMirrored

bool KisCanvas2::xAxisMirrored ( ) const

slot

Bools indicating canvasmirroring.

Definition at line 518 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter->xAxisMirrored();
}

References m_d.

◆ yAxisMirrored

bool KisCanvas2::yAxisMirrored ( ) const

slot

Definition at line 523 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter->yAxisMirrored();
}

References m_d.

Friends And Related Symbol Documentation

◆ KisView

friend class KisView

friend

Definition at line 343 of file kis_canvas2.h.

Member Data Documentation

◆ animationPlayer

QScopedPointer<KisCanvasAnimationState> KisCanvas2::animationPlayer

Definition at line 211 of file kis_canvas2.cpp.

◆ bootstrapLodBlocked

bool KisCanvas2::bootstrapLodBlocked = false

Definition at line 214 of file kis_canvas2.cpp.

◆ canvasUpdateCompressor

KisSignalCompressor KisCanvas2::canvasUpdateCompressor

Definition at line 197 of file kis_canvas2.cpp.

◆ canvasWidget

const QWidget * KisCanvas2::canvasWidget = 0

Definition at line 188 of file kis_canvas2.cpp.

◆ channelFlags

QBitArray KisCanvas2::channelFlags

Definition at line 203 of file kis_canvas2.cpp.

◆ coordinatesConverter

const KisCoordinatesConverter * KisCanvas2::coordinatesConverter = 0

Definition at line 186 of file kis_canvas2.cpp.

◆ currentCanvasIsOpenGL

bool KisCanvas2::currentCanvasIsOpenGL = true

Definition at line 191 of file kis_canvas2.cpp.

◆ currentlyActiveShapeManager

QPointer<KoShapeManager> KisCanvas2::currentlyActiveShapeManager

Definition at line 215 of file kis_canvas2.cpp.

◆ displayColorConverter

KisDisplayColorConverter * KisCanvas2::displayColorConverter

Definition at line 208 of file kis_canvas2.cpp.

◆ frameCache

KisAnimationFrameCacheSP KisCanvas2::frameCache

Definition at line 212 of file kis_canvas2.cpp.

◆ frameRenderStartCompressor

KisSignalCompressor KisCanvas2::frameRenderStartCompressor

Definition at line 220 of file kis_canvas2.cpp.

◆ inputActionGroupsMask

KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask = AllActionGroup

Definition at line 216 of file kis_canvas2.cpp.

◆ inputActionGroupsMaskInterface

KisInputActionGroupsMaskInterface::SharedInterface KisCanvas2::inputActionGroupsMaskInterface

Definition at line 218 of file kis_canvas2.cpp.

◆ isBatchUpdateActive

int KisCanvas2::isBatchUpdateActive = 0

Definition at line 228 of file kis_canvas2.cpp.

◆ lodPreferredInImage

bool KisCanvas2::lodPreferredInImage = false

Definition at line 213 of file kis_canvas2.cpp.

◆ m_d

KisCanvas2Private* const KisCanvas2::m_d

private

Definition at line 345 of file kis_canvas2.h.

◆ multiSurfaceSetupManager

KisMultiSurfaceStateManager KisCanvas2::multiSurfaceSetupManager

Definition at line 235 of file kis_canvas2.cpp.

◆ multiSurfaceState

std::optional<KisMultiSurfaceStateManager::State> KisCanvas2::multiSurfaceState

Definition at line 236 of file kis_canvas2.cpp.

◆ openGLFilterMode

KisOpenGL::FilterMode KisCanvas2::openGLFilterMode = 0

Definition at line 192 of file kis_canvas2.cpp.

◆ popupPalette

KisPopupPalette * KisCanvas2::popupPalette = 0

Definition at line 207 of file kis_canvas2.cpp.

◆ prescaledProjection

KisPrescaledProjectionSP KisCanvas2::prescaledProjection

Definition at line 194 of file kis_canvas2.cpp.

◆ projectionUpdatesCompressor

KisCanvasUpdatesCompressor KisCanvas2::projectionUpdatesCompressor

Definition at line 210 of file kis_canvas2.cpp.

◆ proofingConfig

KisProofingConfigurationSP KisCanvas2::proofingConfig

Definition at line 204 of file kis_canvas2.cpp.

◆ proofingConfigUpdated

bool KisCanvas2::proofingConfigUpdated = false

Definition at line 205 of file kis_canvas2.cpp.

◆ q

KisCanvas2* KisCanvas2::q = 0

Definition at line 185 of file kis_canvas2.cpp.

◆ referencesBoundsUpdateCompressor

KisSignalCompressor KisCanvas2::referencesBoundsUpdateCompressor

Definition at line 223 of file kis_canvas2.cpp.

◆ regionOfInterest

QRect KisCanvas2::regionOfInterest

Definition at line 224 of file kis_canvas2.cpp.

◆ regionOfInterestMargin

qreal KisCanvas2::regionOfInterestMargin = 0.25

Definition at line 225 of file kis_canvas2.cpp.

◆ regionOfInterestUpdateCompressor

KisSignalCompressor KisCanvas2::regionOfInterestUpdateCompressor

Definition at line 222 of file kis_canvas2.cpp.

◆ renderingLimit

QRect KisCanvas2::renderingLimit

Definition at line 227 of file kis_canvas2.cpp.

◆ savedCanvasProjectionUpdateRect

QRect KisCanvas2::savedCanvasProjectionUpdateRect

Definition at line 199 of file kis_canvas2.cpp.

◆ savedOverlayUpdateRect

QRect KisCanvas2::savedOverlayUpdateRect

Definition at line 200 of file kis_canvas2.cpp.

◆ selectedShapesProxy

KoSelectedShapesProxy * KisCanvas2::selectedShapesProxy

Definition at line 190 of file kis_canvas2.cpp.

◆ shapeManager

KoShapeManager * KisCanvas2::shapeManager

Definition at line 189 of file kis_canvas2.cpp.

◆ toolProxy

KoToolProxy * KisCanvas2::toolProxy

Definition at line 193 of file kis_canvas2.cpp.

◆ updateSceneRequested

bool KisCanvas2::updateSceneRequested = false

Definition at line 201 of file kis_canvas2.cpp.

◆ view

QPointer<KisView> KisCanvas2::view

Definition at line 187 of file kis_canvas2.cpp.

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

libs/ui/canvas/kis_canvas2.cpp
libs/ui/canvas/kis_canvas2.h

Classes

Public Slots

Signals

Public Member Functions

Public Attributes

Private Slots

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ~KisCanvas2Private()

◆ KisCanvas2()

◆ ~KisCanvas2()

Member Function Documentation

◆ addCommand()

◆ addDecoration()

◆ animationState()

◆ assignChangedMultiSurfaceState()

◆ assignChangedMultiSurfaceStateSkipCanvasSurface()

◆ bootstrapFinished

◆ canvasIsOpenGL()

◆ canvasWidget() [1/2]

◆ canvasWidget() [2/2]

◆ channelSelectionChanged

◆ colorManagementReport()

◆ connectCurrentCanvas()

◆ coordinatesConverter()

◆ createCanvas()

◆ createOpenGLCanvas()

◆ createQPainterCanvas()

◆ currentImage()

◆ currentScreenId()

◆ decoration()

◆ disconnectCanvasObserver()

◆ disconnectImage()

◆ displayColorConverter()

◆ displayFilter()

◆ documentOffset()

◆ documentOrigin()

◆ docUpdateRectToWidget()

◆ effectiveLodAllowedInImage()

◆ exposureGammaCorrectionInterface()

◆ fetchProofingOptions()

◆ finishResizingImage

◆ frameCache()

◆ globalInputManager()

◆ globalShapeManager()

◆ gridSize()

◆ image()

◆ imageView()

◆ initializeFpsDecoration()

◆ initializeImage()

◆ inputActionGroupsMaskInterface()

◆ KisCanvas2Private()

◆ localShapeManager()

◆ lodIsSupported()

◆ lodPreferredInCanvas()

◆ notifyLevelOfDetailChange()

◆ openGLFilterMode()

◆ paintingAssistantsDecoration()

◆ popupPalette()

◆ proofingConfigUpdated()

◆ proofingConfiguration()

◆ referenceImagesDecoration()

◆ refetchDataFromImage()

◆ regionOfInterest()

◆ renderingLimit()

◆ requestCanvasUpdateMaybeCompressed()

◆ resetCanvas()

◆ rotationAngle

◆ selectedShapesProxy()

◆ setActiveShapeManager()

◆ setCanvasWidget()

◆ setCursor()

◆ setDisplayFilter()

◆ setFavoriteResourceManager()

◆ setLodPreferredInCanvas()

◆ setProofingConfigUpdated()

◆ setRenderingLimit()