#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

KoShape *	currentShapeManagerOwnerShape () const override
	the shape that owns the currently active shape manager

KisCanvasDecorationSP	decoration (const QString &id) const

void	disconnectCanvasObserver (QObject *object) override

void	disconnectImage ()

KisDisplayColorConverter *	displayColorConverter () const

QSharedPointer< KisDisplayFilter >	displayFilter () const

KoColorDisplayRendererInterface *	displayRendererInterface () const override
	displayRendererInterface The display renderer interface has a number of color conversion functions which are useful to convert a KoColor to a QColor.

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	setCurrentShapeManagerOwnerShape (KoShape *source) override
	sets the group shape that is supposed to be "entered"

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

std::optional< ShapeLifetimeWrapper >	groupModeShapeWrapper

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 144 of file kis_canvas2.cpp.

Constructor & Destructor Documentation

◆ ~KisCanvas2Private()

KisCanvas2::~KisCanvas2Private ( )

inline

Definition at line 204 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 327 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(), KisSignalCompressor::FIRST_ACTIVE, KisImageConfig::fpsLimit(), m_d, KoSnapGuide::overrideSnapStrategy(), KoSnapGuide::PixelSnapping, and KoCanvasBase::snapGuide.

◆ ~KisCanvas2()

KisCanvas2::~KisCanvas2 ( )

override

Definition at line 431 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 574 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 1557 of file kis_canvas2.cpp.

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

References m_d.

◆ animationState()

KisCanvasAnimationState * KisCanvas2::animationState ( ) const

Definition at line 1607 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 1652 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 517 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 561 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 1700 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 847 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 774 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 747 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 731 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->multiSurfaceState->multiConfig.canvasDisplayConfig());
    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 1426 of file kis_canvas2.cpp.

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

References m_d.

◆ currentScreenId()

int KisCanvas2::currentScreenId ( ) const

inline

Definition at line 286 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.

◆ currentShapeManagerOwnerShape()

KoShape * KisCanvas2::currentShapeManagerOwnerShape ( ) const

overridevirtual

the shape that owns the currently active shape manager

When the editor enters some kind of "group editing mode", the user see only shapes belonging to this particular group. In other words, the shapeManager() of this canvas will contain only shapes of this "entered" group.

currentShapeManagerOwnerShape() returns the shape that represents this currently entered group, so that the tools could detect it better

If no group is currently entered, then the function returns nullptr.

NOTE: the functionality is currently implemented for text shapes only, not for actual groups :)

Reimplemented from KoCanvasBase.

Definition at line 610 of file kis_canvas2.cpp.

{
    return m_d->groupModeShapeWrapper ? m_d->groupModeShapeWrapper->shape() : nullptr;
}

References m_d.

◆ decoration()

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

Definition at line 1562 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 1318 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 831 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 925 of file kis_canvas2.cpp.

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

References m_d.

◆ displayRendererInterface()

KoColorDisplayRendererInterface * KisCanvas2::displayRendererInterface ( ) const

overridevirtual

displayRendererInterface The display renderer interface has a number of color conversion functions which are useful to convert a KoColor to a QColor.

Returns: The display renderer interface for this canvas.

Reimplemented from KoCanvasBase.

Definition at line 686 of file kis_canvas2.cpp.

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

References m_d.

◆ documentOffset()

QPoint KisCanvas2::documentOffset ( ) const

Definition at line 1579 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 1568 of file kis_canvas2.cpp.

{
    return QPoint();
}

◆ docUpdateRectToWidget()

QRect KisCanvas2::docUpdateRectToWidget ( const QRectF & docRect )

◆ effectiveLodAllowedInImage()

bool KisCanvas2::effectiveLodAllowedInImage ( ) const

inline

Definition at line 271 of file kis_canvas2.cpp.

                                            {
        return lodPreferredInImage && !bootstrapLodBlocked;
    }

◆ exposureGammaCorrectionInterface()

KisExposureGammaCorrectionInterface * KisCanvas2::exposureGammaCorrectionInterface ( ) const

Definition at line 955 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 964 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 1050 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 691 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 605 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 527 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 1420 of file kis_canvas2.cpp.

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

References m_d.

◆ imageView()

QPointer< KisView > KisCanvas2::imageView ( ) const

Definition at line 1415 of file kis_canvas2.cpp.

{
    return m_d->view;
}

References m_d.

◆ initializeFpsDecoration()

void KisCanvas2::initializeFpsDecoration ( )

private

Definition at line 411 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(), decoration(), KisConfig::enableBrushSpeedLogging(), KisConfig::enableOpenGLFramerateLogging(), KisFpsDecoration::idTag, imageView(), KisStrokeSpeedMonitor::instance(), m_d, and updateCanvas().

◆ initializeImage()

void KisCanvas2::initializeImage ( )

Definition at line 807 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(), 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 171 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 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.

The group shape should be manually reset by the external code when the active layer is switched.

Definition at line 634 of file kis_canvas2.cpp.

{
    KisNodeSP node = m_d->view->currentNode();
    KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
    KIS_SAFE_ASSERT_RECOVER(
        !m_d->groupModeShapeWrapper ||
        !localShapeManager ||
        localShapeManager->shapes().contains(m_d->groupModeShapeWrapper->shape())) {
 
        m_d->groupModeShapeWrapper = std::nullopt;
    }
 
    if (m_d->groupModeShapeWrapper) {
        auto textShape = dynamic_cast<KoSvgTextShape*>(m_d->groupModeShapeWrapper->shape());
 
        // we currently support entering text shapes only
        KIS_SAFE_ASSERT_RECOVER(textShape) {
            m_d->groupModeShapeWrapper = std::nullopt;
        }
 
        if (textShape) {
            localShapeManager = textShape->internalShapeManager();
        }
    }
 
    if (localShapeManager != m_d->currentlyActiveShapeManager) {
        m_d->setActiveShapeManager(localShapeManager);
    }
 
    return localShapeManager;
}

References KIS_SAFE_ASSERT_RECOVER, localShapeManager(), m_d, and KoShapeManager::shapes.

◆ lodIsSupported()

bool KisCanvas2::lodIsSupported ( ) const

inline

Definition at line 275 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 1678 of file kis_canvas2.cpp.

{
    return m_d->lodPreferredInImage;
}

References m_d.

◆ notifyLevelOfDetailChange()

void KisCanvas2::notifyLevelOfDetailChange ( )

private

Definition at line 1386 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 1683 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 1033 of file kis_canvas2.cpp.

{
    return m_d->proofingConfig;
}

References m_d.

◆ referenceImagesDecoration()

KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration ( ) const

Definition at line 1689 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 1483 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 1164 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 862 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 546 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 436 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(), 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().

◆ setCurrentShapeManagerOwnerShape()

void KisCanvas2::setCurrentShapeManagerOwnerShape ( KoShape * source )

overridevirtual

sets the group shape that is supposed to be "entered"

The tool can instruct the canvas to enter the group represented by shape shape. The implementation of the canvas is supposed to switch its shapeManager() to the one owned by shape.

NOTE: we currently have no common interface for fetching the shape manager from a particular shape. The canvas is supposed to know how to dynamic_cast the shape itself.

recalculate the local shape manager and make sure that selected shapes proxy emits all the necessary signals

Reimplemented from KoCanvasBase.

Definition at line 615 of file kis_canvas2.cpp.

{
    if (currentShapeManagerOwnerShape() == source) return;
 
    m_d->groupModeShapeWrapper = std::nullopt;
 
    // we currently support entering text shapes only
    if (source && dynamic_cast<KoSvgTextShape*>(source)) {
        m_d->groupModeShapeWrapper.emplace(source, [this] () {
            this->setCurrentShapeManagerOwnerShape(nullptr);
        });
    }
 
    (void) localShapeManager();
}

References currentShapeManagerOwnerShape(), localShapeManager(), m_d, setCurrentShapeManagerOwnerShape(), source(), and void().

◆ 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 1597 of file kis_canvas2.cpp.

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

References canvasWidget.

◆ setDisplayFilter()

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

Definition at line 913 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 1584 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 displayColorConverter, displayRendererInterface(), m_d, slotPopupPaletteRequestedZoomChange(), updateCanvas(), and viewManager().

◆ setLodPreferredInCanvas()

void KisCanvas2::setLodPreferredInCanvas ( bool value )

Definition at line 1663 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 1023 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 1365 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 351 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(), 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 1624 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 1641 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 1135 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 1431 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 1006 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 1015 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 1445 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 1177 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 1324 of file kis_canvas2.cpp.

{
    Q_UNUSED(newZoom)
 
    notifyLevelOfDetailChange();
}

References notifyLevelOfDetailChange().

◆ slotEndUpdatesBatch

void KisCanvas2::slotEndUpdatesBatch ( )

privateslot

Definition at line 1144 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 998 of file kis_canvas2.cpp.

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

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

◆ slotImageColorSpaceChanged

void KisCanvas2::slotImageColorSpaceChanged ( )

privateslot

Definition at line 930 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 1593 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 1468 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 1612 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 1153 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 992 of file kis_canvas2.cpp.

{
    updateProofingState();
    refetchDataFromImage();
}

References refetchDataFromImage(), and updateProofingState().

◆ slotSurfaceFormatChanged()

void KisCanvas2::slotSurfaceFormatChanged ( const KisDisplayConfig & config )

private

Definition at line 1528 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);
#else
    Q_UNUSED(config);
#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 1380 of file kis_canvas2.cpp.

{
    // Still needs to be recalculated in some cases, like when deleting vector layers
    localShapeManager();
}

References localShapeManager().

◆ slotUpdateReferencesBounds

void KisCanvas2::slotUpdateReferencesBounds ( )

privateslot

Definition at line 1354 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 1338 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 541 of file kis_canvas2.cpp.

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

References m_d.

◆ startResizingImage

void KisCanvas2::startResizingImage ( )

slot

Definition at line 1038 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 1055 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 890 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 707 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 1245 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 1257 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 1276 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 1282 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 1063 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 1267 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 1312 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 1291 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 1299 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 1229 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 975 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 676 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter;
}

References m_d.

◆ viewConverter() [2/2]

KoViewConverter * KisCanvas2::viewConverter ( )

overridevirtual

Implements KoCanvasBase.

Definition at line 681 of file kis_canvas2.cpp.

{
    return m_d->coordinatesConverter;
}

References m_d.

◆ viewManager()

KisViewManager * KisCanvas2::viewManager ( ) const

Definition at line 1407 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 1636 of file kis_canvas2.cpp.

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

References m_d.

◆ wrapAroundViewingModeAxis()

WrapAroundAxis KisCanvas2::wrapAroundViewingModeAxis ( ) const

Definition at line 1647 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 551 of file kis_canvas2.cpp.

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

References m_d.

◆ yAxisMirrored

bool KisCanvas2::yAxisMirrored ( ) const

slot

Definition at line 556 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 348 of file kis_canvas2.h.

Member Data Documentation

◆ animationPlayer

QScopedPointer<KisCanvasAnimationState> KisCanvas2::animationPlayer

Definition at line 244 of file kis_canvas2.cpp.

◆ bootstrapLodBlocked

bool KisCanvas2::bootstrapLodBlocked = false

Definition at line 247 of file kis_canvas2.cpp.

◆ canvasUpdateCompressor

KisSignalCompressor KisCanvas2::canvasUpdateCompressor

Definition at line 230 of file kis_canvas2.cpp.

◆ canvasWidget

const QWidget * KisCanvas2::canvasWidget = 0

Definition at line 219 of file kis_canvas2.cpp.

◆ channelFlags

QBitArray KisCanvas2::channelFlags

Definition at line 236 of file kis_canvas2.cpp.

◆ coordinatesConverter

const KisCoordinatesConverter * KisCanvas2::coordinatesConverter = 0

Definition at line 217 of file kis_canvas2.cpp.

◆ currentCanvasIsOpenGL

bool KisCanvas2::currentCanvasIsOpenGL = true

Definition at line 222 of file kis_canvas2.cpp.

◆ currentlyActiveShapeManager

QPointer<KoShapeManager> KisCanvas2::currentlyActiveShapeManager

Definition at line 248 of file kis_canvas2.cpp.

◆ displayColorConverter

KisDisplayColorConverter * KisCanvas2::displayColorConverter

Definition at line 241 of file kis_canvas2.cpp.

◆ frameCache

KisAnimationFrameCacheSP KisCanvas2::frameCache

Definition at line 245 of file kis_canvas2.cpp.

◆ frameRenderStartCompressor

KisSignalCompressor KisCanvas2::frameRenderStartCompressor

Definition at line 253 of file kis_canvas2.cpp.

◆ groupModeShapeWrapper

std::optional<ShapeLifetimeWrapper> KisCanvas2::groupModeShapeWrapper

Definition at line 223 of file kis_canvas2.cpp.

◆ inputActionGroupsMask

KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask = AllActionGroup

Definition at line 249 of file kis_canvas2.cpp.

◆ inputActionGroupsMaskInterface

KisInputActionGroupsMaskInterface::SharedInterface KisCanvas2::inputActionGroupsMaskInterface

Definition at line 251 of file kis_canvas2.cpp.

◆ isBatchUpdateActive

int KisCanvas2::isBatchUpdateActive = 0

Definition at line 261 of file kis_canvas2.cpp.

◆ lodPreferredInImage

bool KisCanvas2::lodPreferredInImage = false

Definition at line 246 of file kis_canvas2.cpp.

◆ m_d

KisCanvas2Private* const KisCanvas2::m_d

private

Definition at line 350 of file kis_canvas2.h.

◆ multiSurfaceSetupManager

KisMultiSurfaceStateManager KisCanvas2::multiSurfaceSetupManager

Definition at line 268 of file kis_canvas2.cpp.

◆ multiSurfaceState

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

Definition at line 269 of file kis_canvas2.cpp.

◆ openGLFilterMode

KisOpenGL::FilterMode KisCanvas2::openGLFilterMode = 0

Definition at line 225 of file kis_canvas2.cpp.

◆ popupPalette

KisPopupPalette * KisCanvas2::popupPalette = 0

Definition at line 240 of file kis_canvas2.cpp.

◆ prescaledProjection

KisPrescaledProjectionSP KisCanvas2::prescaledProjection

Definition at line 227 of file kis_canvas2.cpp.

◆ projectionUpdatesCompressor

KisCanvasUpdatesCompressor KisCanvas2::projectionUpdatesCompressor

Definition at line 243 of file kis_canvas2.cpp.

◆ proofingConfig

KisProofingConfigurationSP KisCanvas2::proofingConfig

Definition at line 237 of file kis_canvas2.cpp.

◆ proofingConfigUpdated

bool KisCanvas2::proofingConfigUpdated = false

Definition at line 238 of file kis_canvas2.cpp.

◆ q

KisCanvas2* KisCanvas2::q = 0

Definition at line 216 of file kis_canvas2.cpp.

◆ referencesBoundsUpdateCompressor

KisSignalCompressor KisCanvas2::referencesBoundsUpdateCompressor

Definition at line 256 of file kis_canvas2.cpp.

◆ regionOfInterest

QRect KisCanvas2::regionOfInterest

Definition at line 257 of file kis_canvas2.cpp.

◆ regionOfInterestMargin

qreal KisCanvas2::regionOfInterestMargin = 0.25

Definition at line 258 of file kis_canvas2.cpp.

◆ regionOfInterestUpdateCompressor

KisSignalCompressor KisCanvas2::regionOfInterestUpdateCompressor

Definition at line 255 of file kis_canvas2.cpp.

◆ renderingLimit

QRect KisCanvas2::renderingLimit

Definition at line 260 of file kis_canvas2.cpp.

◆ savedCanvasProjectionUpdateRect

QRect KisCanvas2::savedCanvasProjectionUpdateRect

Definition at line 232 of file kis_canvas2.cpp.

◆ savedOverlayUpdateRect

QRect KisCanvas2::savedOverlayUpdateRect

Definition at line 233 of file kis_canvas2.cpp.

◆ selectedShapesProxy

KoSelectedShapesProxy * KisCanvas2::selectedShapesProxy

Definition at line 221 of file kis_canvas2.cpp.

◆ shapeManager

KoShapeManager * KisCanvas2::shapeManager

Definition at line 220 of file kis_canvas2.cpp.

◆ toolProxy

KoToolProxy * KisCanvas2::toolProxy

Definition at line 226 of file kis_canvas2.cpp.

◆ updateSceneRequested

bool KisCanvas2::updateSceneRequested = false

Definition at line 234 of file kis_canvas2.cpp.

◆ view

QPointer<KisView> KisCanvas2::view

Definition at line 218 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()

◆ currentShapeManagerOwnerShape()

◆ decoration()

◆ disconnectCanvasObserver()

◆ disconnectImage()

◆ displayColorConverter()

◆ displayFilter()

◆ displayRendererInterface()

◆ 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()

◆ setCurrentShapeManagerOwnerShape()

◆ setCursor()

◆ setDisplayFilter()

◆ setFavoriteResourceManager()