#include <KisWaylandSurfaceColorManager.h>

Inheritance diagram for KisWaylandSurfaceColorManager:

Public Types
enum class	WaylandSurfaceState { Disconnected = 0 , Connected , WaylandWindowCreated , WaylandSurfaceCreated , APIFeedbackCreated , PreferredDescriptionReceived }

Public Member Functions
bool	isReady () const override

	KisWaylandSurfaceColorManager (QWindow window, QObject parent=nullptr)

std::optional< KisSurfaceColorimetry::SurfaceDescription >	preferredSurfaceDescription () const override

std::optional< KisSurfaceColorimetry::RenderIntent >	renderingIntent () const override

QFuture< bool >	setSurfaceDescription (const KisSurfaceColorimetry::SurfaceDescription &desc, KisSurfaceColorimetry::RenderIntent intent) override

bool	supportsRenderIntent (const KisSurfaceColorimetry::RenderIntent &intent) override

bool	supportsSurfaceDescription (const KisSurfaceColorimetry::SurfaceDescription &desc) override

std::optional< KisSurfaceColorimetry::SurfaceDescription >	surfaceDescription () const override

void	unsetSurfaceDescription () override

	~KisWaylandSurfaceColorManager () override

Public Member Functions inherited from KisSurfaceColorManagerInterface
	KisSurfaceColorManagerInterface (QWindow window, QObject parent=nullptr)

virtual	~KisSurfaceColorManagerInterface ()

Static Public Member Functions
static std::shared_ptr< KisWaylandAPIColorManager >	getOrCreateGlobalWaylandManager ()

Private Slots
void	slotPlatformWindowCreated ()

void	slotPlatformWindowDestroyed ()

void	slotPreferredChanged ()

void	slotWaylandSurfaceCreated ()

void	slotWaylandSurfaceDestroyed ()

Private Member Functions
void	reinitialize ()

void	setReadyImpl (bool value)

WaylandSurfaceState	tryDeinitialize (std::optional< KisWaylandSurfaceColorManager::WaylandSurfaceState > targetState)

WaylandSurfaceState	tryInitilize ()

Private Attributes
std::optional< KisSurfaceColorimetry::SurfaceDescription >	m_currentDescription

WaylandSurfaceState	m_currentState {WaylandSurfaceState::Disconnected}

bool	m_isReady {false}

QPointer< QObject >	m_platformWindowStateDetector

std::optional< KisSurfaceColorimetry::SurfaceDescription >	m_preferredDescription

std::optional< KisSurfaceColorimetry::RenderIntent >	m_renderingIntent

std::unique_ptr< KisWaylandAPISurface >	m_surface

QMetaObject::Connection	m_surfaceCreatedConnection

QMetaObject::Connection	m_surfaceDestroyedConnection

std::shared_ptr< KisWaylandAPIColorManager >	m_waylandManager

Additional Inherited Members
Signals inherited from KisSurfaceColorManagerInterface
void	sigPreferredSurfaceDescriptionChanged (const KisSurfaceColorimetry::SurfaceDescription &desc)

void	sigReadyChanged (bool value)

Protected Attributes inherited from KisSurfaceColorManagerInterface
QWindow *	m_window

Detailed Description

Definition at line 16 of file KisWaylandSurfaceColorManager.h.

Member Enumeration Documentation

◆ WaylandSurfaceState

enum class KisWaylandSurfaceColorManager::WaylandSurfaceState

strong

Enumerator
Disconnected
Connected
WaylandWindowCreated
WaylandSurfaceCreated
APIFeedbackCreated
PreferredDescriptionReceived

Definition at line 34 of file KisWaylandSurfaceColorManager.h.

                                   {
        Disconnected = 0, // 1) the underlying wayland manager is inactive
        Connected, // 1) the wayland manager is active; 2) m_platformWindowStateDetector is connected
        WaylandWindowCreated, // 1) QWaylandWindow is created; 2) surfaceCreated() and surfaceDestroyed() signals are connected
        WaylandSurfaceCreated, // 1) wayland surface is created inside Qt
        APIFeedbackCreated, // 1) surface feedback (m_surface) is created and connected to the wayland surface
        PreferredDescriptionReceived // 1) m_preferredDescription is initialized
    };

Constructor & Destructor Documentation

◆ KisWaylandSurfaceColorManager()

KisWaylandSurfaceColorManager::KisWaylandSurfaceColorManager	(	QWindow *	window,
		QObject *	parent = nullptr )

If we have reused an existing wayland manager, then it will be ready

Definition at line 57 of file KisWaylandSurfaceColorManager.cpp.

    : KisSurfaceColorManagerInterface(window, parent)
{
    m_waylandManager = getOrCreateGlobalWaylandManager();
    connect(m_waylandManager.get(), &KisWaylandAPIColorManager::sigReadyChanged,
            this, &KisWaylandSurfaceColorManager::reinitialize);
 
    if (m_waylandManager->isReady()) {
        reinitialize();
    }
}

References getOrCreateGlobalWaylandManager(), m_waylandManager, reinitialize(), and KisWaylandAPIColorManager::sigReadyChanged().

◆ ~KisWaylandSurfaceColorManager()

KisWaylandSurfaceColorManager::~KisWaylandSurfaceColorManager ( )

override

Definition at line 72 of file KisWaylandSurfaceColorManager.cpp.

73{

74}

Member Function Documentation

◆ getOrCreateGlobalWaylandManager()

std::shared_ptr< KisWaylandAPIColorManager > KisWaylandSurfaceColorManager::getOrCreateGlobalWaylandManager ( )

static

A weak pointer in s_waylandManager may have become released, so it may be null, even though the static itself is non-null.

Definition at line 37 of file KisWaylandSurfaceColorManager.cpp.

{
    std::shared_ptr<KisWaylandAPIColorManager> result;
 
    if (s_waylandManager.exists()) {
        result = s_waylandManager->lock();
    }
 
    if (!result) {
        result.reset(new KisWaylandAPIColorManager());
        *s_waylandManager = result;
    }
 
    return result;
}

◆ isReady()

bool KisWaylandSurfaceColorManager::isReady ( ) const

overridevirtual

Returns: true when the interface is considered as "fully initialized", i.e. all the methods of the interface are supposed to work as expected

Implements KisSurfaceColorManagerInterface.

Definition at line 138 of file KisWaylandSurfaceColorManager.cpp.

{
    return m_isReady;
}

References m_isReady.

◆ preferredSurfaceDescription()

std::optional< KisSurfaceColorimetry::SurfaceDescription > KisWaylandSurfaceColorManager::preferredSurfaceDescription ( ) const

overridevirtual

Returns: the preferred description for the underlying surface from the viewpoint of the compositor

It can return std::nullopt only when the interface is not ready

Implements KisSurfaceColorManagerInterface.

Definition at line 321 of file KisWaylandSurfaceColorManager.cpp.

{
    return m_preferredDescription;
}

References m_preferredDescription.

◆ reinitialize()

void KisWaylandSurfaceColorManager::reinitialize ( )

private

Definition at line 118 of file KisWaylandSurfaceColorManager.cpp.

{
    if (!m_waylandManager->isReady()) {
        auto newState = tryDeinitialize(std::nullopt);
        KIS_SAFE_ASSERT_RECOVER_NOOP(newState == WaylandSurfaceState::Disconnected);
        setReadyImpl(false);
        return;
    }
 
    if (m_currentState > WaylandSurfaceState::Disconnected) {
        qWarning() << "WARNING: KisWaylandSurfaceColorManager::reinitialize(): received unbalanced connectionActive(true) signal!";
        qWarning() << "    " << ppVar(m_currentState);
        m_currentState = tryDeinitialize(std::nullopt);
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_currentState == WaylandSurfaceState::Connected);
    }
 
    m_currentState = tryInitilize();
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_currentState < WaylandSurfaceState::PreferredDescriptionReceived);
}

References Connected, Disconnected, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, m_currentState, m_waylandManager, ppVar, PreferredDescriptionReceived, setReadyImpl(), tryDeinitialize(), and tryInitilize().

◆ renderingIntent()

std::optional< KisSurfaceColorimetry::RenderIntent > KisWaylandSurfaceColorManager::renderingIntent ( ) const

overridevirtual

Returns: the current rendering intent assign to the surface

It can return std::nullopt if the surface description is unset or if the connection to the compositor has been lost.

Implements KisSurfaceColorManagerInterface.

Definition at line 316 of file KisWaylandSurfaceColorManager.cpp.

{
    return m_renderingIntent;
}

References m_renderingIntent.

◆ setReadyImpl()

void KisWaylandSurfaceColorManager::setReadyImpl ( bool value )

private

Definition at line 76 of file KisWaylandSurfaceColorManager.cpp.

{
    if (value == m_isReady) return;
 
    m_isReady = value;
    Q_EMIT sigReadyChanged(m_isReady);
}

References m_isReady, KisSurfaceColorManagerInterface::sigReadyChanged(), and value().

◆ setSurfaceDescription()

QFuture< bool > KisWaylandSurfaceColorManager::setSurfaceDescription	(	const KisSurfaceColorimetry::SurfaceDescription &	desc,
		KisSurfaceColorimetry::RenderIntent	intent )

overridevirtual

Sets the surface description of the linked QWindow

The operation may be asynchronous on some platforms, so you should handle a QFuture<bool> object to get the actual result.

Returns: a future telling if the description has already been set or not.

WARNING: Please do NOT call future.waitForFinished() from the GUI thread. On some platforms (e.g. wayland) a signal from the even loop should be processed to actually set the surface description, so you'll get a deadlock if you try to wait for it in the event loop's thread.

Implements KisSurfaceColorManagerInterface.

Definition at line 233 of file KisWaylandSurfaceColorManager.cpp.

{
    if (!m_isReady) {
        qWarning() << "ERROR: KisWaylandSurfaceColorManager::setSurfaceDescription: the manager is not ready";
        return makeReadyQFuture(false);
    }
 
    using KisSurfaceColorimetry::WaylandSurfaceDescription;
 
    auto waylandDescription = WaylandSurfaceDescription::fromSurfaceDescription(desc);
    auto waylandIntent = renderIntentKritaToWayland(intent);
 
    if (!supportsSurfaceDescription(desc)) {
        qWarning() << "ERROR: KisWaylandSurfaceColorManager::setSurfaceDescription: unsupported surface description";
        return makeReadyQFuture(false);
    }
 
    if (!m_waylandManager->isIntentSupported(waylandIntent)) {
        qWarning() << "ERROR: KisWaylandSurfaceColorManager::setSurfaceDescription: unsupported rendering intent";
        return makeReadyQFuture(false);
    }
 
    KisWaylandAPIImageDescriptionCreatorParams creator(m_waylandManager.get());
    std::shared_ptr<KisWaylandAPIImageDescriptionNoInfo> descriptionObject =
        creator.createImageDescription(waylandDescription);
 
    QPromise<bool> imageDescriptionPromise;
    auto future = imageDescriptionPromise.future();
 
    connect(descriptionObject.get(), &KisWaylandAPIImageDescription::sigDescriptionConstructed,
            this,
            [promise = std::move(imageDescriptionPromise), descriptionObject] (bool success) mutable {
                promise.start();
                promise.addResult(success);
                promise.finish();
            });
 
    QFuture<bool> result =
        future.then([this, desc, descriptionObject, waylandIntent, intent] (QFuture<bool> future) {
            if (!future.result()) return false;
 
            if (!m_surface) {
                qWarning() << "WARNING: the surface has been destroyed while its format was being set!";
                return false;
            }
 
#ifdef USE_KWIN_BUG_WORKAROUND
            if (qEnvironmentVariableIsSet("KRITA_ENABLE_KWIN_INTENT_WORKAROUND")) {
                // WARNING: KWin <= 6.4.4 doesn't handle intent changes properly
                if (m_currentDescription && m_currentDescription == desc &&
                    m_renderingIntent && m_renderingIntent != intent) {
 
                    m_surface->unset_image_description();
                    auto waylandWindow = m_window->nativeInterface<QNativeInterface::Private::QWaylandWindow>();
                    ::wl_surface_commit(waylandWindow->surface());
                }
            }
#endif
 
            m_surface->set_image_description(descriptionObject->object(), waylandIntent);
            m_window->requestUpdate();
            m_currentDescription = desc;
            m_renderingIntent = intent;
            return true;
        });
 
    return result;
}

References KisWaylandAPIImageDescriptionCreatorParams::createImageDescription(), m_currentDescription, m_isReady, m_renderingIntent, m_surface, m_waylandManager, KisSurfaceColorManagerInterface::m_window, KisWaylandAPIImageDescriptionNoInfo::sigDescriptionConstructed(), and supportsSurfaceDescription().

◆ slotPlatformWindowCreated

void KisWaylandSurfaceColorManager::slotPlatformWindowCreated ( )

privateslot

Definition at line 342 of file KisWaylandSurfaceColorManager.cpp.

{
    if (m_currentState > WaylandSurfaceState::Connected) {
        qWarning() << "WARNING: KisWaylandSurfaceColorManager::slotPlatformWindowCreated(): received unbalanced window created signal!";
        qWarning() << "    " << ppVar(m_currentState);
        m_currentState = tryDeinitialize(WaylandSurfaceState::Connected);
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_currentState == WaylandSurfaceState::Connected);
        setReadyImpl(false);
    }
 
    auto newState = tryInitilize();
 
    if (newState < WaylandSurfaceState::WaylandWindowCreated) {
        qWarning() << "WARNING: KisWaylandSurfaceColorManager::slotPlatformWindowCreated(): failed to reach WaylandWindowCreated state";
    }
 
    m_currentState = newState;
}

References Connected, KIS_SAFE_ASSERT_RECOVER_RETURN, m_currentState, ppVar, setReadyImpl(), tryDeinitialize(), tryInitilize(), and WaylandWindowCreated.

◆ slotPlatformWindowDestroyed

void KisWaylandSurfaceColorManager::slotPlatformWindowDestroyed ( )

privateslot

Definition at line 361 of file KisWaylandSurfaceColorManager.cpp.

{
    auto newState = tryDeinitialize(WaylandSurfaceState::Connected);
    KIS_SAFE_ASSERT_RECOVER_NOOP(newState <= WaylandSurfaceState::Connected);
    m_currentState = newState;
    setReadyImpl(false);
}

References Connected, KIS_SAFE_ASSERT_RECOVER_NOOP, m_currentState, setReadyImpl(), and tryDeinitialize().

◆ slotPreferredChanged

void KisWaylandSurfaceColorManager::slotPreferredChanged ( )

privateslot

Definition at line 326 of file KisWaylandSurfaceColorManager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_currentState >= WaylandSurfaceState::APIFeedbackCreated);
 
    auto newState = tryInitilize();
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(newState == WaylandSurfaceState::PreferredDescriptionReceived);
 
    if (newState == m_currentState) {
        Q_EMIT sigPreferredSurfaceDescriptionChanged(*m_preferredDescription);
    } else {
        m_currentState = newState;
        setReadyImpl(true);
    }
}

References APIFeedbackCreated, KIS_SAFE_ASSERT_RECOVER_RETURN, m_currentState, m_preferredDescription, PreferredDescriptionReceived, setReadyImpl(), KisSurfaceColorManagerInterface::sigPreferredSurfaceDescriptionChanged(), and tryInitilize().

◆ slotWaylandSurfaceCreated

void KisWaylandSurfaceColorManager::slotWaylandSurfaceCreated ( )

privateslot

Definition at line 369 of file KisWaylandSurfaceColorManager.cpp.

{
    if (m_currentState > WaylandSurfaceState::WaylandWindowCreated) {
        qWarning() << "WARNING: KisWaylandSurfaceColorManager::slotWaylandSurfaceCreated(): received unbalanced surface created signal!";
        qWarning() << "    " << ppVar(m_currentState);
        m_currentState = tryDeinitialize(WaylandSurfaceState::WaylandWindowCreated);
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_currentState == WaylandSurfaceState::WaylandWindowCreated);
        setReadyImpl(false);
    }
 
    auto newState = tryInitilize();
 
    if (newState < WaylandSurfaceState::WaylandSurfaceCreated) {
        qWarning() << "WARNING: KisWaylandSurfaceColorManager::slotWaylandSurfaceCreated(): failed to reach WaylandSurfaceCreated state";
    }
    m_currentState = newState;
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, m_currentState, ppVar, setReadyImpl(), tryDeinitialize(), tryInitilize(), WaylandSurfaceCreated, and WaylandWindowCreated.

◆ slotWaylandSurfaceDestroyed

void KisWaylandSurfaceColorManager::slotWaylandSurfaceDestroyed ( )

privateslot

Definition at line 387 of file KisWaylandSurfaceColorManager.cpp.

{
    auto newState = tryDeinitialize(WaylandSurfaceState::WaylandWindowCreated);
    KIS_SAFE_ASSERT_RECOVER_NOOP(newState <= WaylandSurfaceState::WaylandWindowCreated);
    m_currentState = newState;
    setReadyImpl(false);
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_currentState, setReadyImpl(), tryDeinitialize(), and WaylandWindowCreated.

◆ supportsRenderIntent()

bool KisWaylandSurfaceColorManager::supportsRenderIntent ( const KisSurfaceColorimetry::RenderIntent & intent )

overridevirtual

Test if the rendering intent is supported by the compositor

Implements KisSurfaceColorManagerInterface.

Definition at line 221 of file KisWaylandSurfaceColorManager.cpp.

{
    auto waylandIntent = renderIntentKritaToWayland(intent);
    return m_waylandManager->isIntentSupported(waylandIntent);
}

References m_waylandManager.

◆ supportsSurfaceDescription()

bool KisWaylandSurfaceColorManager::supportsSurfaceDescription ( const KisSurfaceColorimetry::SurfaceDescription & desc )

overridevirtual

Test if the surface description is supported by the compositor

For some obscure reason Wayland compositors implemented transfer_function_srgb as gamma-2.2 transfer function, which caused a lot of confusion. Hence the enum is going to be deprecated in the upcoming version of the protocol.

https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/442

Implements KisSurfaceColorManagerInterface.

Definition at line 143 of file KisWaylandSurfaceColorManager.cpp.

{
    using feature = QtWayland::wp_color_manager_v1::feature;
    using namespace KisColorimetryUtils;
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_parametric)) {
        qWarning() << "KisWaylandSurfaceColorManager: feature_parametric is not supported";
        return false;
    }
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_set_primaries) &&
        std::holds_alternative<Colorimetry>(desc.colorSpace.primaries)) {
 
        qWarning() << "KisWaylandSurfaceColorManager: feature_set_primaries is not supported, even though requested";
        return false;
    }
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_set_tf_power) &&
        std::holds_alternative<uint32_t>(desc.colorSpace.transferFunction)) {
 
        qWarning() << "KisWaylandSurfaceColorManager: feature_set_tf_power is not supported, even though requested";
        return false;
    }
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_set_luminances) &&
        desc.colorSpace.luminance) {
 
        qWarning() << "KisWaylandSurfaceColorManager: feature_set_luminances is not supported, even though requested";
        return false;
    }
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_set_mastering_display_primaries) &&
        desc.masteringInfo) {
 
        qWarning() << "KisWaylandSurfaceColorManager: feature_set_mastering_display_primaries is not supported, even though requested";
        return false;
    }
 
    if (!m_waylandManager->isFeatureSupported(feature::feature_extended_target_volume) &&
        desc.masteringInfo && desc.colorSpace.luminance) {
        if (desc.masteringInfo->luminance.minLuminance < desc.colorSpace.luminance->minLuminance
            || desc.masteringInfo->luminance.maxLuminance > desc.colorSpace.luminance->maxLuminance) {
 
            qWarning() << "KisWaylandSurfaceColorManager: feature_set_mastering_display_primaries is not supported, even though requested";
            return false;
        }
    }
 
    if (std::holds_alternative<KisSurfaceColorimetry::NamedPrimaries>(desc.colorSpace.primaries)) {
        auto waylandPrimaries = primariesKritaToWayland(std::get<KisSurfaceColorimetry::NamedPrimaries>(desc.colorSpace.primaries));
 
        if (!m_waylandManager->isPrimariesNamedSupported(waylandPrimaries))
            return false;
    }
 
    if (std::holds_alternative<KisSurfaceColorimetry::NamedTransferFunction>(desc.colorSpace.transferFunction)) {
        auto waylandTransferFunction = transferFunctionKritaToWayland(std::get<KisSurfaceColorimetry::NamedTransferFunction>(desc.colorSpace.transferFunction));
 
        if (waylandTransferFunction == QtWayland::wp_color_manager_v1::transfer_function_srgb ||
            waylandTransferFunction == QtWayland::wp_color_manager_v1::transfer_function_ext_srgb) {
 
            return false;
        }
 
        if (!m_waylandManager->isTransferFunctionNamedSupported(waylandTransferFunction))
            return false;
    }
 
    return true;
}

References KisSurfaceColorimetry::SurfaceDescription::colorSpace, KisSurfaceColorimetry::ColorSpace::luminance, m_waylandManager, KisSurfaceColorimetry::SurfaceDescription::masteringInfo, KisSurfaceColorimetry::ColorSpace::primaries, and KisSurfaceColorimetry::ColorSpace::transferFunction.

◆ surfaceDescription()

std::optional< KisSurfaceColorimetry::SurfaceDescription > KisWaylandSurfaceColorManager::surfaceDescription ( ) const

overridevirtual

Returns: the current description of the underlying surface

It can return std::nullopt if the surface description is unset or if the connection to the compositor has been lost.

Implements KisSurfaceColorManagerInterface.

Definition at line 311 of file KisWaylandSurfaceColorManager.cpp.

{
    return m_currentDescription;
}

References m_currentDescription.

◆ tryDeinitialize()

KisWaylandSurfaceColorManager::WaylandSurfaceState KisWaylandSurfaceColorManager::tryDeinitialize ( std::optional< KisWaylandSurfaceColorManager::WaylandSurfaceState > targetState )

private

Definition at line 483 of file KisWaylandSurfaceColorManager.cpp.

{
    WaylandSurfaceState currentState = WaylandSurfaceState::PreferredDescriptionReceived;
 
    if (!targetState || *targetState < currentState) {
        m_currentDescription = std::nullopt;
        m_renderingIntent = std::nullopt;
        m_preferredDescription = std::nullopt;
 
        currentState = WaylandSurfaceState::APIFeedbackCreated;
    }
 
    auto waylandWindow = m_window->nativeInterface<QNativeInterface::Private::QWaylandWindow>();
 
    if (!waylandWindow || !waylandWindow->surface() ||
        (targetState && *targetState < currentState)) {
 
        m_surface.reset();
        currentState = WaylandSurfaceState::WaylandSurfaceCreated;
    }
 
    if (!waylandWindow || !waylandWindow->surface() ||
        (targetState && *targetState < currentState)) {
 
        currentState = WaylandSurfaceState::WaylandWindowCreated;
    }
 
    if (!waylandWindow || (targetState && *targetState < currentState)) {
        if (m_surfaceCreatedConnection) {
            disconnect(m_surfaceCreatedConnection);
        }
        if (m_surfaceDestroyedConnection) {
            disconnect(m_surfaceDestroyedConnection);
        }
        currentState = WaylandSurfaceState::Connected;
    }
 
    if (!m_waylandManager->isReady() || (targetState && *targetState < currentState)) {
        m_window->removeEventFilter(m_platformWindowStateDetector);
        m_platformWindowStateDetector->deleteLater();
        m_platformWindowStateDetector = nullptr;
 
        currentState = WaylandSurfaceState::Disconnected;
    }
 
    return currentState;
}

References APIFeedbackCreated, Connected, Disconnected, m_currentDescription, m_platformWindowStateDetector, m_preferredDescription, m_renderingIntent, m_surface, m_surfaceCreatedConnection, m_surfaceDestroyedConnection, m_waylandManager, KisSurfaceColorManagerInterface::m_window, PreferredDescriptionReceived, WaylandSurfaceCreated, and WaylandWindowCreated.

◆ tryInitilize()

KisWaylandSurfaceColorManager::WaylandSurfaceState KisWaylandSurfaceColorManager::tryInitilize ( )

private

Initialization of the managed happens sequentially by transitioning through a set of states. Some states may be transitioned asynchronously, e.g. when Qt creates a platform windows or when it creates or recreates a surface.

Definition at line 396 of file KisWaylandSurfaceColorManager.cpp.

{
    WaylandSurfaceState currentState = WaylandSurfaceState::Disconnected;
 
    if (m_waylandManager->isReady()) {
        currentState = WaylandSurfaceState::Connected;
    }
 
    if (currentState == WaylandSurfaceState::Connected) {
        if (!m_platformWindowStateDetector) {
            auto *filter = new PlatformWindowDetectionEventFilter(m_window, this);
            connect(filter,
                    &PlatformWindowDetectionEventFilter::sigPlatformWindowCreated,
                    this,
                    &KisWaylandSurfaceColorManager::slotPlatformWindowCreated);
            connect(filter,
                    &PlatformWindowDetectionEventFilter::sigPlatformWindowDestroyed,
                    this,
                    &KisWaylandSurfaceColorManager::slotPlatformWindowDestroyed);
            m_window->installEventFilter(filter);
            m_platformWindowStateDetector = filter;
        }
 
        auto waylandWindow = m_window->nativeInterface<QNativeInterface::Private::QWaylandWindow>();
        if (waylandWindow) {
            currentState = WaylandSurfaceState::WaylandWindowCreated;
        }
    }
 
    if (currentState == WaylandSurfaceState::WaylandWindowCreated) {
        auto waylandWindow = m_window->nativeInterface<QNativeInterface::Private::QWaylandWindow>();
 
        if (!m_surfaceCreatedConnection) {
            m_surfaceCreatedConnection = connect(waylandWindow,
                                                 &QNativeInterface::Private::QWaylandWindow::surfaceCreated,
                                                 this,
                                                 &KisWaylandSurfaceColorManager::slotWaylandSurfaceCreated);
        }
 
        if (!m_surfaceDestroyedConnection) {
            m_surfaceDestroyedConnection = connect(waylandWindow,
                                                   &QNativeInterface::Private::QWaylandWindow::surfaceDestroyed,
                                                   this,
                                                   &KisWaylandSurfaceColorManager::slotWaylandSurfaceDestroyed);
        }
 
        if (waylandWindow->surface()) {
            currentState = WaylandSurfaceState::WaylandSurfaceCreated;
        }
    }
 
    if (currentState == WaylandSurfaceState::WaylandSurfaceCreated) {
        auto waylandWindow = m_window->nativeInterface<QNativeInterface::Private::QWaylandWindow>();
 
        if (!m_surface) {
            auto feedback = std::make_unique<KisWaylandAPISurfaceFeedback>(
                m_waylandManager->get_surface_feedback(waylandWindow->surface()));
            connect(feedback.get(),
                    &KisWaylandAPISurfaceFeedback::preferredChanged,
                    this,
                    &KisWaylandSurfaceColorManager::slotPreferredChanged);
            m_surface = std::make_unique<KisWaylandAPISurface>(m_waylandManager->get_surface(waylandWindow->surface()),
                                                               std::move(feedback));
        }
 
        currentState = WaylandSurfaceState::APIFeedbackCreated;
    }
 
    if (currentState == WaylandSurfaceState::APIFeedbackCreated) {
        if (m_surface->m_feedback->m_preferred->info.isReady()) {
            auto waylandDesc = m_surface->m_feedback->m_preferred->info.m_data;
            m_preferredDescription = waylandDesc.toSurfaceDescription();
 
            currentState = WaylandSurfaceState::PreferredDescriptionReceived;
        }
    }
 
    return currentState;
}

References APIFeedbackCreated, Connected, Disconnected, m_platformWindowStateDetector, m_preferredDescription, m_surface, m_surfaceCreatedConnection, m_surfaceDestroyedConnection, m_waylandManager, KisSurfaceColorManagerInterface::m_window, KisWaylandAPISurfaceFeedback::preferredChanged(), PreferredDescriptionReceived, PlatformWindowDetectionEventFilter::sigPlatformWindowCreated(), PlatformWindowDetectionEventFilter::sigPlatformWindowDestroyed(), slotPlatformWindowCreated(), slotPlatformWindowDestroyed(), slotPreferredChanged(), slotWaylandSurfaceCreated(), slotWaylandSurfaceDestroyed(), WaylandSurfaceCreated, and WaylandWindowCreated.

◆ unsetSurfaceDescription()

void KisWaylandSurfaceColorManager::unsetSurfaceDescription ( )

overridevirtual

Unset the surface description of the underlying surface. In most of the compositors it means that the surface will be treated as sRGB.

Implements KisSurfaceColorManagerInterface.

Definition at line 302 of file KisWaylandSurfaceColorManager.cpp.

{
    if (!m_isReady) return;
 
    m_surface->unset_image_description();
    m_currentDescription = std::nullopt;
    m_renderingIntent = std::nullopt;
}

References m_currentDescription, m_isReady, m_renderingIntent, and m_surface.

Member Data Documentation

◆ m_currentDescription

std::optional<KisSurfaceColorimetry::SurfaceDescription> KisWaylandSurfaceColorManager::m_currentDescription

private

Definition at line 65 of file KisWaylandSurfaceColorManager.h.

◆ m_currentState

WaylandSurfaceState KisWaylandSurfaceColorManager::m_currentState {WaylandSurfaceState::Disconnected}

private

Definition at line 61 of file KisWaylandSurfaceColorManager.h.

61{WaylandSurfaceState::Disconnected};

◆ m_isReady

bool KisWaylandSurfaceColorManager::m_isReady {false}

private

Definition at line 69 of file KisWaylandSurfaceColorManager.h.

69{false};

◆ m_platformWindowStateDetector

QPointer<QObject> KisWaylandSurfaceColorManager::m_platformWindowStateDetector

private

Definition at line 73 of file KisWaylandSurfaceColorManager.h.

◆ m_preferredDescription

std::optional<KisSurfaceColorimetry::SurfaceDescription> KisWaylandSurfaceColorManager::m_preferredDescription

private

Definition at line 67 of file KisWaylandSurfaceColorManager.h.

◆ m_renderingIntent

std::optional<KisSurfaceColorimetry::RenderIntent> KisWaylandSurfaceColorManager::m_renderingIntent

private

Definition at line 66 of file KisWaylandSurfaceColorManager.h.

◆ m_surface

std::unique_ptr<KisWaylandAPISurface> KisWaylandSurfaceColorManager::m_surface

private

Definition at line 63 of file KisWaylandSurfaceColorManager.h.

◆ m_surfaceCreatedConnection

QMetaObject::Connection KisWaylandSurfaceColorManager::m_surfaceCreatedConnection

private

Definition at line 71 of file KisWaylandSurfaceColorManager.h.

◆ m_surfaceDestroyedConnection

QMetaObject::Connection KisWaylandSurfaceColorManager::m_surfaceDestroyedConnection

private

Definition at line 72 of file KisWaylandSurfaceColorManager.h.

◆ m_waylandManager

std::shared_ptr<KisWaylandAPIColorManager> KisWaylandSurfaceColorManager::m_waylandManager

private

Definition at line 62 of file KisWaylandSurfaceColorManager.h.

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

plugins/platforms/wayland/waylandcolormanagement/KisWaylandSurfaceColorManager.h
plugins/platforms/wayland/waylandcolormanagement/KisWaylandSurfaceColorManager.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ WaylandSurfaceState

Constructor & Destructor Documentation

◆ KisWaylandSurfaceColorManager()

◆ ~KisWaylandSurfaceColorManager()

Member Function Documentation

◆ getOrCreateGlobalWaylandManager()

◆ isReady()

◆ preferredSurfaceDescription()

◆ reinitialize()

◆ renderingIntent()

◆ setReadyImpl()

◆ setSurfaceDescription()

◆ slotPlatformWindowCreated

◆ slotPlatformWindowDestroyed

◆ slotPreferredChanged

◆ slotWaylandSurfaceCreated

◆ slotWaylandSurfaceDestroyed

◆ supportsRenderIntent()

◆ supportsSurfaceDescription()

◆ surfaceDescription()

◆ tryDeinitialize()

◆ tryInitilize()

◆ unsetSurfaceDescription()

Member Data Documentation

◆ m_currentDescription

◆ m_currentState

◆ m_isReady

◆ m_platformWindowStateDetector

◆ m_preferredDescription

◆ m_renderingIntent

◆ m_surface

◆ m_surfaceCreatedConnection

◆ m_surfaceDestroyedConnection

◆ m_waylandManager