KisWindowLayoutResource Class Reference

#include <KisWindowLayoutResource.h>

Inheritance diagram for KisWindowLayoutResource:

Classes
struct	Private

Public Member Functions
void	applyLayout ()
KoResourceSP	clone () const override
QString	defaultFileExtension () const override
	KisWindowLayoutResource (const KisWindowLayoutResource &rhs)
	KisWindowLayoutResource (const QString &filename)
bool	loadFromDevice (QIODevice *dev, KisResourcesInterfaceSP resourcesInterface) override
KisWindowLayoutResource &	operator= (const KisWindowLayoutResource &rhs)=delete
QPair< QString, QString >	resourceType () const override
bool	saveToDevice (QIODevice *dev) const override
	~KisWindowLayoutResource () override
Public Member Functions inherited from KoResource
bool	active () const
void	addMetaData (QString key, QVariant value)
	store the given key, value pair in the resource
virtual void	clearSideLoadedResources ()
virtual QList< KoResourceLoadResult >	embeddedResources (KisResourcesInterfaceSP globalResourcesInterface) const
QString	filename () const
QImage	image () const
bool	isDirty () const
virtual bool	isEphemeral () const
virtual bool	isSerializable () const
	KoResource ()
	KoResource (const KoResource &rhs)
	KoResource (const QString &filename)
virtual QList< KoResourceLoadResult >	linkedResources (KisResourcesInterfaceSP globalResourcesInterface) const
bool	load (KisResourcesInterfaceSP resourcesInterface)
QString	md5Sum (bool generateIfEmpty=true) const
QMap< QString, QVariant >	metadata () const
	get a map with all the metadata
virtual QString	name () const
KoResource &	operator= (const KoResource &rhs)=delete
bool	permanent () const
virtual QList< int >	requiredCanvasResources () const
QList< KoResourceLoadResult >	requiredResources (KisResourcesInterfaceSP globalResourcesInterface) const
int	resourceId () const
bool	save ()
void	setActive (bool active)
void	setDirty (bool value)
	Mark the preset as modified but not saved.
void	setFilename (const QString &filename)
void	setImage (const QImage &image)
void	setMD5Sum (const QString &md5sum)
	Set the md5sum of this resource. It must be in hex-encoded string format.
void	setName (const QString &name)
void	setPermanent (bool permanent)
void	setResourceId (int id)
void	setStorageLocation (const QString &location)
void	setValid (bool valid)
void	setVersion (int version)
virtual QList< KoResourceLoadResult >	sideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface) const
KoResourceSignature	signature () const
QString	storageLocation () const
QList< KoResourceLoadResult >	takeSideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface)
virtual QImage	thumbnail () const
	thumbnail the thumbnail image to use in resource selectors
virtual QString	thumbnailPath () const
	thumbnailPath returns the path to a separate thumbnail image, outside the actual resource file itself. If the path is relative, it is supposed start in the same location as the resource itself. If it's absolute, that is, it starts with "/", it is from the root of the storage.
virtual void	updateThumbnail ()
	updateThumbnail updates the thumbnail for this resource. Reimplement if your thumbnail is something else than the image set with setImage.
bool	valid () const
int	version () const
	Get the version of the resource.
virtual	~KoResource ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static KisWindowLayoutResourceSP	fromCurrentWindows (const QString &filename, const QList< QPointer< KisMainWindow > > &mainWindows, bool showImageInAllWindows, bool primaryWorkspaceFollowsFocus, KisMainWindow *primaryWindow)

Protected Member Functions
virtual void	loadXml (const QDomElement &root) const
virtual void	saveXml (QDomDocument &doc, QDomElement &root) const
void	setWindows (const QList< QPointer< KisMainWindow > > &mainWindows)

Private Attributes
QScopedPointer< Private >	d

Additional Inherited Members
Public Attributes inherited from KoResource
bool	active {true}
QString	filename
QImage	image
QString	md5sum
QMap< QString, QVariant >	metadata
bool	modified {false}
QString	name
bool	permanent {false}
int	resourceId {-1}
QString	storageLocation
bool	valid {false}
int	version {-1}
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

Definition at line 18 of file KisWindowLayoutResource.h.

Constructor & Destructor Documentation

KisWindowLayoutResource() [1/2]

KisWindowLayoutResource::KisWindowLayoutResource ( const QString & filename )

explicit

Definition at line 223 of file KisWindowLayoutResource.cpp.

    : KoResource(filename)
    , d(new Private)
{}

~KisWindowLayoutResource()

KisWindowLayoutResource::~KisWindowLayoutResource ( )

override

Definition at line 228 of file KisWindowLayoutResource.cpp.

{}

KisWindowLayoutResource() [2/2]

KisWindowLayoutResource::KisWindowLayoutResource

(

const KisWindowLayoutResource &

rhs

)

Definition at line 231 of file KisWindowLayoutResource.cpp.

    : KoResource(rhs)
    , d(new Private(*rhs.d))
{
}

Member Function Documentation

applyLayout()

void KisWindowLayoutResource::applyLayout

(

)

Definition at line 255 of file KisWindowLayoutResource.cpp.

{
    auto *kisPart = KisPart::instance();
    auto *layoutManager= KisWindowLayoutManager::instance();
 
    layoutManager->setLastUsedLayout(this);
 
    QList<QPointer<KisMainWindow>> currentWindows = kisPart->mainWindows();
    bool createWindows = d->windows.isEmpty();
 
    if (createWindows) {
        // No windows defined (e.g. fresh new session). Leave things as they are, but make sure there's at least one visible main window
        if (kisPart->mainwindowCount() == 0) {
            kisPart->createMainWindow();
        } else {
            kisPart->mainWindows().first()->show();
        }
    } else {
        d->openNecessaryWindows(currentWindows);
    }
 
    // Wait for the windows to finish opening / closing before applying saved geometry.
    // If we don't, the geometry may get reset after we apply it.
    QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
    Q_FOREACH(const auto &window, d->windows) {
        QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
        KIS_SAFE_ASSERT_RECOVER_BREAK(mainWindow);
 
        mainWindow->restoreGeometry(window.geometry.data);
        mainWindow->restoreWorkspaceState(window.windowState);
 
        mainWindow->setCanvasDetached(window.canvasDetached);
        if (window.canvasDetached) {
            QWidget *canvasWindow = mainWindow->canvasWindow();
            canvasWindow->restoreGeometry(window.canvasWindowGeometry.data);
        }
    }
 
    QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
    QList<QScreen*> screens = d->getScreensInConsistentOrder();
    Q_FOREACH(const auto &window, d->windows) {
        Private::WindowGeometry geometry = window.geometry;
        QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
        KIS_SAFE_ASSERT_RECOVER_BREAK(mainWindow);
 
        if (geometry.screen >= 0 && geometry.screen < screens.size()) {
            geometry.forceOntoCorrectScreen(mainWindow, screens);
        }
        if (window.canvasDetached) {
            Private::WindowGeometry canvasWindowGeometry = window.canvasWindowGeometry;
            if (canvasWindowGeometry.screen >= 0 && canvasWindowGeometry.screen < screens.size()) {
                canvasWindowGeometry.forceOntoCorrectScreen(mainWindow->canvasWindow(), screens);
            }
        }
    }
 
    layoutManager->setShowImageInAllWindowsEnabled(d->showImageInAllWindows);
    layoutManager->setPrimaryWorkspaceFollowsFocus(d->primaryWorkspaceFollowsFocus, d->primaryWindow);
    if (!createWindows) {
        d->closeUnneededWindows(currentWindows);
    }
}

References d, KisWindowLayoutResource::Private::WindowGeometry::forceOntoCorrectScreen(), KisPart::instance(), KisWindowLayoutManager::instance(), KIS_SAFE_ASSERT_RECOVER_BREAK, and KisWindowLayoutResource::Private::WindowGeometry::screen.

clone()

KoResourceSP KisWindowLayoutResource::clone ( ) const

overridevirtual

Implements KoResource.

Definition at line 237 of file KisWindowLayoutResource.cpp.

{
    return KoResourceSP(new KisWindowLayoutResource(*this));
}

References KisWindowLayoutResource().

defaultFileExtension()

QString KisWindowLayoutResource::defaultFileExtension ( ) const

overridevirtual

Returns

the default file extension which should be used when saving the resource

Reimplemented from KoResource.

Definition at line 422 of file KisWindowLayoutResource.cpp.

{
    return QString(".kwl");
}

fromCurrentWindows()

KisWindowLayoutResourceSP KisWindowLayoutResource::fromCurrentWindows ( const QString & filename, const QList< QPointer< KisMainWindow > > & mainWindows, bool showImageInAllWindows, bool primaryWorkspaceFollowsFocus, KisMainWindow * primaryWindow )

static

Definition at line 242 of file KisWindowLayoutResource.cpp.

{
    KisWindowLayoutResourceSP resource(new KisWindowLayoutResource(filename));
    resource->setWindows(mainWindows);
    resource->d->showImageInAllWindows = showImageInAllWindows;
    resource->d->primaryWorkspaceFollowsFocus = primaryWorkspaceFollowsFocus;
    resource->d->primaryWindow = primaryWindow->id();
    return resource;
}

References KoResource::filename, KisMainWindow::id, and KisWindowLayoutResource().

loadFromDevice()

bool KisWindowLayoutResource::loadFromDevice ( QIODevice * dev, KisResourcesInterfaceSP resourcesInterface )

overridevirtual

Implements KoResource.

Definition at line 337 of file KisWindowLayoutResource.cpp.

{
    Q_UNUSED(resourcesInterface);
 
    QDomDocument doc;
    if (!doc.setContent(dev)) {
        return false;
    }
 
    QDomElement element = doc.documentElement();
    setName(element.attribute("name"));
 
    d->windows.clear();
 
    loadXml(element);
 
    setValid(true);
    return true;
}

References d, loadXml(), KoResource::setName(), and KoResource::setValid().

loadXml()

void KisWindowLayoutResource::loadXml ( const QDomElement & root ) const

protectedvirtual

Reimplemented in KisSessionResource.

Definition at line 382 of file KisWindowLayoutResource.cpp.

{
    d->showImageInAllWindows = KisDomUtils::toInt(element.attribute("showImageInAllWindows", "0"));
    d->primaryWorkspaceFollowsFocus = KisDomUtils::toInt(element.attribute("primaryWorkspaceFollowsFocus", "0"));
    d->primaryWindow = QUuid::fromString(element.attribute("primaryWindow"));
 
#ifdef Q_OS_ANDROID
    if (element.firstChildElement("window") != element.lastChildElement("window")) {
        QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"),
                             "Workspaces with multiple windows isn't supported on Android");
        return;
    }
#endif
 
    for (auto windowElement = element.firstChildElement("window");
         !windowElement.isNull();
         windowElement = windowElement.nextSiblingElement("window")) {
 
        Private::Window window;
 
        window.windowId = QUuid(windowElement.attribute("id", QUuid().toString()));
        if (window.windowId.isNull()) {
            window.windowId = QUuid::createUuid();
        }
 
        window.geometry = Private::WindowGeometry::load(windowElement);
 
        QDomElement canvasWindowElement = windowElement.firstChildElement("canvasWindow");
        if (!canvasWindowElement.isNull()) {
            window.canvasDetached = true;
            window.canvasWindowGeometry = Private::WindowGeometry::load(canvasWindowElement);
        }
 
        QDomElement state = windowElement.firstChildElement("windowState");
        window.windowState = QByteArray::fromBase64(state.text().toLatin1());
 
        d->windows.append(window);
    }
}

References KisWindowLayoutResource::Private::Window::canvasDetached, KisWindowLayoutResource::Private::Window::canvasWindowGeometry, d, KisWindowLayoutResource::Private::Window::geometry, KisWindowLayoutResource::Private::WindowGeometry::load(), KisDomUtils::toInt(), KisWindowLayoutResource::Private::Window::windowId, and KisWindowLayoutResource::Private::Window::windowState.

operator=()

KisWindowLayoutResource & KisWindowLayoutResource::operator= ( const KisWindowLayoutResource & rhs )

delete

resourceType()

QPair< QString, QString > KisWindowLayoutResource::resourceType ( ) const

inlineoverridevirtual

Returns

the resource type

Implements KoResource.

Definition at line 40 of file KisWindowLayoutResource.h.

    {
        return QPair<QString, QString>(ResourceType::WindowLayouts, "");
    }

References ResourceType::WindowLayouts.

saveToDevice()

bool KisWindowLayoutResource::saveToDevice ( QIODevice * dev ) const

overridevirtual

Reimplemented from KoResource.

Definition at line 320 of file KisWindowLayoutResource.cpp.

{
    QDomDocument doc;
    QDomElement root = doc.createElement("WindowLayout");
    root.setAttribute("name", name());
    root.setAttribute("version", WINDOW_LAYOUT_VERSION);
 
    saveXml(doc, root);
 
    doc.appendChild(root);
 
    QTextStream textStream(dev);
    KisPortingUtils::setUtf8OnStream(textStream);
    doc.save(textStream, 4);
    return true;
}

References KoResource::name, saveXml(), KisPortingUtils::setUtf8OnStream(), and WINDOW_LAYOUT_VERSION.

saveXml()

void KisWindowLayoutResource::saveXml ( QDomDocument & doc, QDomElement & root ) const

protectedvirtual

Reimplemented in KisSessionResource.

Definition at line 357 of file KisWindowLayoutResource.cpp.

{
    root.setAttribute("showImageInAllWindows", (int)d->showImageInAllWindows);
    root.setAttribute("primaryWorkspaceFollowsFocus", (int)d->primaryWorkspaceFollowsFocus);
    root.setAttribute("primaryWindow", d->primaryWindow.toString());
 
    Q_FOREACH(const auto &window, d->windows) {
        QDomElement elem = doc.createElement("window");
        elem.setAttribute("id", window.windowId.toString());
 
        window.geometry.save(doc, elem);
 
        if (window.canvasDetached) {
            QDomElement canvasWindowElement = doc.createElement("canvasWindow");
            window.canvasWindowGeometry.save(doc, canvasWindowElement);
            elem.appendChild(canvasWindowElement);
        }
 
        QDomElement state = doc.createElement("windowState");
        state.appendChild(doc.createCDATASection(window.windowState.toBase64()));
        elem.appendChild(state);
        root.appendChild(elem);
    }
}

References d.

setWindows()

void KisWindowLayoutResource::setWindows ( const QList< QPointer< KisMainWindow > > & mainWindows )

protected

Definition at line 427 of file KisWindowLayoutResource.cpp.

{
    d->windows.clear();
 
    QList<QScreen*> screens = d->getScreensInConsistentOrder();
 
    Q_FOREACH(auto window, mainWindows) {
        if (!window->isVisible()) continue;
 
        Private::Window state;
        state.windowId = window->id();
        state.windowState = window->saveState();
        state.geometry = Private::WindowGeometry::fromWindow(window, screens);
 
        state.canvasDetached = window->canvasDetached();
        if (state.canvasDetached) {
            state.canvasWindowGeometry = Private::WindowGeometry::fromWindow(window->canvasWindow(), screens);
        }
 
        d->windows.append(state);
    }
}

References KisWindowLayoutResource::Private::Window::canvasDetached, KisWindowLayoutResource::Private::Window::canvasWindowGeometry, d, KisWindowLayoutResource::Private::WindowGeometry::fromWindow(), KisWindowLayoutResource::Private::Window::geometry, KisWindowLayoutResource::Private::Window::windowId, and KisWindowLayoutResource::Private::Window::windowState.

Member Data Documentation

d

QScopedPointer<Private> KisWindowLayoutResource::d

private

Definition at line 57 of file KisWindowLayoutResource.h.

---

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

• libs/ui/KisWindowLayoutResource.h
• libs/ui/KisWindowLayoutResource.cpp