#include <KisMultiSurfaceStateManager.h>

Classes
struct	State

Public Member Functions
State	createInitializingConfig (bool isCanvasOpenGL, int screenId, KisProofingConfigurationSP proofingConfig) const

	KisMultiSurfaceStateManager ()

State	onCanvasSurfaceFormatChanged (const State &oldState, const KisDisplayConfig &canvasConfig) const

State	onConfigChanged (const State &oldState, int screenId, KisConfig::CanvasSurfaceMode surfaceMode, const KisDisplayConfig::Options &options) const

State	onGuiSurfaceFormatChanged (const State &oldState, const KoColorProfile *uiProfile) const

State	onProofingChanged (const State &oldState, KisProofingConfigurationSP proofingConfig) const

State	onScreenChanged (const State &oldState, int screenId) const

	~KisMultiSurfaceStateManager ()

Private Member Functions
KisDisplayConfig::Options	overriddenWithProofingConfig (const KisDisplayConfig::Options &options, KisProofingConfigurationSP proofingConfig) const

Detailed Description

On some systems the canvas may have a surface format different from the rest of the GUI. This class help to manage the state of both the surfaces, GUI and canvas ones in an atomic way using value-based semantics.

Every incoming event accept the current state and transitions it forward into a new state that is returned from the function. The calling code should only check for the changes and apply the said changes to the actual consumers: KisDisplayColorConverter, KisOpenGLCanvas2 and KisCanvasSurfaceColorSpaceManager.

Handling the state in a value-based atomic way allows us to avoid weird flow of updates between different consumers. Such flows are almost impossible to manage externally because we have three different canvas managemend modes:

1) Legacy HDR mode (the one used on Windows), where the whole main window's surface is switched into the HDR space and compositing happens indide Qt

2) Wayland-style HDR mode, where the canvas has its own surface, which color space is managed by OS

3) Unmanaged mode, where we assume OS just passes color data directly to the GPU, so we perform all the color management ourselves.

Definition at line 51 of file KisMultiSurfaceStateManager.h.

Constructor & Destructor Documentation

◆ KisMultiSurfaceStateManager()

KisMultiSurfaceStateManager::KisMultiSurfaceStateManager ( )

Definition at line 17 of file KisMultiSurfaceStateManager.cpp.

18{

19}

◆ ~KisMultiSurfaceStateManager()

KisMultiSurfaceStateManager::~KisMultiSurfaceStateManager ( )

Definition at line 21 of file KisMultiSurfaceStateManager.cpp.

22{

23}

Member Function Documentation

◆ createInitializingConfig()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::createInitializingConfig	(	bool	isCanvasOpenGL,
		int	screenId,
		KisProofingConfigurationSP	proofingConfig ) const

Definition at line 32 of file KisMultiSurfaceStateManager.cpp.

{
    State state;
    KisMultiSurfaceDisplayConfig &multiConfig = state.multiConfig;
 
    state.isCanvasOpenGL = isCanvasOpenGL;
 
    KisConfig cfg(true);
 
    state.optionsFromConfig = KisDisplayConfig::optionsFromKisConfig(cfg);
    state.surfaceMode = cfg.canvasSurfaceColorSpaceManagementMode();
    state.proofingConfig = proofingConfig;
 
    if (KisOpenGLModeProber::instance()->useHDRMode()) {
        multiConfig.canvasProfile = state.isCanvasOpenGL
            ? KisOpenGLModeProber::instance()->rootSurfaceColorProfile()
            : KoColorSpaceRegistry::instance()->p709SRGBProfile();
        multiConfig.uiProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
 
    } else if (KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
#if KRITA_USE_SURFACE_COLOR_MANAGEMENT_API
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_rootSurfaceInfoProxy);
        if (m_rootSurfaceInfoProxy) {
            multiConfig.canvasProfile = m_rootSurfaceInfoProxy->rootSurfaceProfile();
            multiConfig.uiProfile = m_rootSurfaceInfoProxy->rootSurfaceProfile();
        }
#else
        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "managed surface mode is active, but Krita is compiled without it!");
        multiConfig.canvasProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
        multiConfig.uiProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
#endif /* KRITA_USE_SURFACE_COLOR_MANAGEMENT_API */
    } else {
        const KoColorProfile *profile = cfg.displayProfile(screenId);
        KIS_SAFE_ASSERT_RECOVER(profile) {
            profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
        }
 
        multiConfig.canvasProfile = profile;
        multiConfig.uiProfile = profile;
    }
 
    multiConfig.setOptions(overriddenWithProofingConfig(state.optionsFromConfig, state.proofingConfig));
    multiConfig.isCanvasHDR = false;
 
    return state;
}

References KisMultiSurfaceDisplayConfig::canvasProfile, KisConfig::canvasSurfaceColorSpaceManagementMode(), KisConfig::displayProfile(), KoColorSpaceRegistry::instance(), KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KisMultiSurfaceDisplayConfig::isCanvasHDR, KisMultiSurfaceStateManager::State::isCanvasOpenGL, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, KisMultiSurfaceStateManager::State::multiConfig, KisMultiSurfaceStateManager::State::optionsFromConfig, KisDisplayConfig::optionsFromKisConfig(), overriddenWithProofingConfig(), KoColorSpaceRegistry::p709SRGBProfile(), KisMultiSurfaceStateManager::State::proofingConfig, KisOpenGLModeProber::rootSurfaceColorProfile(), KisMultiSurfaceDisplayConfig::setOptions(), KisMultiSurfaceStateManager::State::surfaceMode, and KisMultiSurfaceDisplayConfig::uiProfile.

◆ onCanvasSurfaceFormatChanged()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::onCanvasSurfaceFormatChanged	(	const State &	oldState,
		const KisDisplayConfig &	canvasConfig ) const

Surface changed signal is possible only for the managed surface under an openGL canvas. In legacy HDR mode it is not possible to get that.

Definition at line 79 of file KisMultiSurfaceStateManager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS(), oldState);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!KisOpenGLModeProber::instance()->useHDRMode(), oldState);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(oldState.isCanvasOpenGL, oldState);
 
    // the surface format change should not change the conversion
    // options of the surface
    // TODO: downgrade to a warning!
    KIS_SAFE_ASSERT_RECOVER_NOOP(oldState.multiConfig.options() == canvasConfig.options());
 
    State newState = oldState;
    KisMultiSurfaceDisplayConfig &newMultiConfig = newState.multiConfig;
 
    newMultiConfig.canvasProfile = canvasConfig.profile;
    newMultiConfig.setOptions(canvasConfig.options());
    newMultiConfig.isCanvasHDR = canvasConfig.isHDR;
 
    return newState;
}

References KisMultiSurfaceDisplayConfig::canvasProfile, KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KisMultiSurfaceDisplayConfig::isCanvasHDR, KisMultiSurfaceStateManager::State::isCanvasOpenGL, KisDisplayConfig::isHDR, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisMultiSurfaceStateManager::State::multiConfig, KisDisplayConfig::options(), KisMultiSurfaceDisplayConfig::options(), KisDisplayConfig::profile, and KisMultiSurfaceDisplayConfig::setOptions().

◆ onConfigChanged()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::onConfigChanged	(	const State &	oldState,
		int	screenId,
		KisConfig::CanvasSurfaceMode	surfaceMode,
		const KisDisplayConfig::Options &	options ) const

Definition at line 126 of file KisMultiSurfaceStateManager.cpp.

{
    State newState = oldState;
    newState.surfaceMode = surfaceMode;
    newState.optionsFromConfig = options;
    newState.multiConfig.setOptions(
        overriddenWithProofingConfig(newState.optionsFromConfig, newState.proofingConfig));
 
    if (!KisOpenGLModeProber::instance()->useHDRMode() &&
        !KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
 
        KisConfig cfg(true);
        const KoColorProfile *profile = cfg.displayProfile(screenId);
        KIS_SAFE_ASSERT_RECOVER(profile) {
            profile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
        }
        newState.multiConfig.canvasProfile = profile;
        newState.multiConfig.uiProfile = profile;
    }
 
    return newState;
}

References KisMultiSurfaceDisplayConfig::canvasProfile, KisConfig::displayProfile(), KoColorSpaceRegistry::instance(), KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KIS_SAFE_ASSERT_RECOVER, KisMultiSurfaceStateManager::State::multiConfig, KisMultiSurfaceStateManager::State::optionsFromConfig, overriddenWithProofingConfig(), KoColorSpaceRegistry::p709SRGBProfile(), KisMultiSurfaceStateManager::State::proofingConfig, KisMultiSurfaceDisplayConfig::setOptions(), KisMultiSurfaceStateManager::State::surfaceMode, and KisMultiSurfaceDisplayConfig::uiProfile.

◆ onGuiSurfaceFormatChanged()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::onGuiSurfaceFormatChanged	(	const State &	oldState,
		const KoColorProfile *	uiProfile ) const

Surface changed signal is possible only on OS with managed surface color space

Definition at line 103 of file KisMultiSurfaceStateManager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS(), oldState);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!KisOpenGLModeProber::instance()->useHDRMode(), oldState);
 
    State newState = oldState;
    newState.multiConfig.uiProfile = uiProfile;
 
    return newState;
}

References KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisMultiSurfaceStateManager::State::multiConfig, and KisMultiSurfaceDisplayConfig::uiProfile.

◆ onProofingChanged()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::onProofingChanged	(	const State &	oldState,
		KisProofingConfigurationSP	proofingConfig ) const

Definition at line 117 of file KisMultiSurfaceStateManager.cpp.

{
    State newState = oldState;
    newState.proofingConfig = proofingConfig;
    newState.multiConfig.setOptions(
        overriddenWithProofingConfig(newState.optionsFromConfig, newState.proofingConfig));
    return newState;
}

References KisMultiSurfaceStateManager::State::multiConfig, KisMultiSurfaceStateManager::State::optionsFromConfig, overriddenWithProofingConfig(), KisMultiSurfaceStateManager::State::proofingConfig, and KisMultiSurfaceDisplayConfig::setOptions().

◆ onScreenChanged()

KisMultiSurfaceStateManager::State KisMultiSurfaceStateManager::onScreenChanged	(	const State &	oldState,
		int	screenId ) const

Definition at line 152 of file KisMultiSurfaceStateManager.cpp.

{
    if (KisOpenGLModeProber::instance()->useHDRMode() ||
        KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS()) {
        return oldState;
    }
 
    return onConfigChanged(oldState, screenId, oldState.surfaceMode, oldState.optionsFromConfig);
}

References KisPlatformPluginInterfaceFactory::instance(), KisOpenGLModeProber::instance(), onConfigChanged(), KisMultiSurfaceStateManager::State::optionsFromConfig, and KisMultiSurfaceStateManager::State::surfaceMode.

◆ overriddenWithProofingConfig()

KisDisplayConfig::Options KisMultiSurfaceStateManager::overriddenWithProofingConfig	(	const KisDisplayConfig::Options &	options,
		KisProofingConfigurationSP	proofingConfig ) const

private

Definition at line 162 of file KisMultiSurfaceStateManager.cpp.

{
    if (proofingConfig && proofingConfig->displayFlags.testFlag(KoColorConversionTransformation::SoftProofing)) {
        return { proofingConfig->determineDisplayIntent(options.first),
                 proofingConfig->determineDisplayFlags(options.second) };
    }
 
    return options;
}

References KoColorConversionTransformation::SoftProofing.

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

libs/ui/KisMultiSurfaceStateManager.h
libs/ui/KisMultiSurfaceStateManager.cpp

Classes

Public Member Functions

Private Member Functions