Main window for Krita. More...

#include <KisMainWindow.h>

Inheritance diagram for KisMainWindow:

Public Types
enum	OpenFlag { None = 0 , Import = 0x1 , BatchMode = 0x2 , RecoveryFile = 0x4 }

Public Types inherited from KXmlGuiWindow
enum	StandardWindowOption { ToolBar = 1 , Keys = 2 , StatusBar = 4 , Save = 8 , Create = 16 , Default = ToolBar \| Keys \| StatusBar \| Save \| Create }

Public Types inherited from KisKXMLGUIClient
enum	ReverseStateChange { StateNoReverse , StateReverse }

Public Slots
bool	checkActiveBundlesAvailable ()
	checkActiveStorages checks whether there is at least one bundle available and at least one paintop preset.

bool	checkPaintOpAvailable ()

void	clearRecentFiles ()

void	newOptionWidgets (KoCanvasController *controller, const QList< QPointer< QWidget > > &optionWidgetList)

KisView *	newView (QObject document, QMdiSubWindow subWindow=0)

void	notifyChildViewDestroyed (KisView *view)

void	removeRecentFile (QString url)

void	setActiveView (KisView *view)
	Set the active view, this will update the undo/redo actions.

void	setCanvasDetached (bool detached)

void	slotChangeInterfaceScale ()

void	slotFileNew ()

void	slotFileOpen (bool isImporting=false)

void	slotFileOpenRecent (const QUrl &)

void	slotFileSave ()

void	slotPreferences ()
	slotPreferences open the preferences dialog

void	slotShowSessionManager ()

void	subWindowActivated ()

void	synchronizeDynamicActions ()

void	unsetActiveView ()

void	viewFullscreen (bool fullScreen)

void	windowFocused ()

Public Slots inherited from KXmlGuiWindow
virtual void	configureToolbars ()

virtual void	slotStateChanged (const QString &newstate)

void	slotStateChanged (const QString &newstate, bool reverse)

Public Slots inherited from KisKMainWindow
void	appHelpActivated (void)

void	setSettingsDirty ()

Signals
void	activeViewChanged ()
	emitted when the current view has changed

void	documentSaved ()

void	guiLoadingFinished ()

void	keyBindingsChanged ()
	This signal is emitted when the shortcut key configuration has changed.

void	loadCompleted ()

void	restoringDone ()
	This signal is emitted right after the docker states have been successfully restored from config.

void	themeChanged ()
	This signal is emitted when the color theme changes.

Public Member Functions
KisActionManager *	actionManager ()

KisView *	activeView () const

KisView *	addViewAndNotifyLoadingCompleted (KisDocument document, QMdiSubWindow subWindow=0)

bool	canvasDetached () const

QList< KoCanvasObserverBase * >	canvasObservers () const override

QWidget *	canvasWindow () const

QMenu *	createPopupMenu () override

QDockWidget *	dockWidget (const QString &id)

QList< QDockWidget * >	dockWidgets () const
	Return the list of dock widgets belonging to this main window.

QTabBar *	findTabBarHACK ()

bool	hackIsSaving () const

QUuid	id () const

bool	installBundle (const QString &fileName) const
	Copy the given file into the bundle directory.

	KisMainWindow (QUuid id=QUuid())

QImage	layoutThumbnail ()
	layoutThumbnail

bool	openDocument (const QString &path, OpenFlags flags)

	Private (KisMainWindow *parent, QUuid id)

KoCanvasResourceProvider *	resourceManager () const

bool	restoreWorkspace (KoResourceSP res)

bool	restoreWorkspaceState (const QByteArray &state)

bool	saveDocument (KisDocument *document, bool saveas, bool isExporting, bool isAdvancedExporting=false)

void	saveWindowState (bool restoreNormalState=false)

void	showDocument (KisDocument *document)

QStringList	showOpenFileDialog (bool isImporting)

virtual void	showView (KisView view, QMdiSubWindow subWindow=0)
	showView shows the given view, in `subWindow` if not null, in a new tab otherwise.

void	showWelcomeScreen (bool show)

int	viewCount () const

KisViewManager *	viewManager () const

const KConfigGroup &	windowStateConfig () const

	~KisMainWindow () override

	~Private ()

Public Member Functions inherited from KXmlGuiWindow
void	applyMainWindowSettings (const KConfigGroup &config) override

void	createGUI (const QString &xmlfile=QString())

void	createStandardStatusBarAction ()

void	finalizeGUI (bool force)

void	finalizeGUI (KisKXMLGUIClient *client) override

virtual KisKXMLGUIFactory *	guiFactory ()

bool	isHelpMenuEnabled () const

bool	isStandardToolBarMenuEnabled () const

	KXmlGuiWindow (QWidget *parent=0, Qt::WindowFlags f=Qt::WindowFlags())

void	setHelpMenuEnabled (bool showHelpMenu=true)

void	setStandardToolBarMenuEnabled (bool enable)

void	setupGUI (const QSize &defaultSize, StandardWindowOptions options=Default, const QString &xmlfile=QString())

void	setupGUI (StandardWindowOptions options=Default, const QString &xmlfile=QString())

void	setupToolbarMenuActions ()

QAction *	toolBarMenuAction ()

	~KXmlGuiWindow () override
	Destructor.

Public Member Functions inherited from KisKMainWindow
KConfigGroup	autoSaveConfigGroup () const

QString	autoSaveGroup () const

bool	autoSaveSettings () const

QString	dbusName () const

bool	hasMenuBar ()

	KisKMainWindow (QWidget *parent=0, Qt::WindowFlags f=Qt::WindowFlags())

void	resetAutoSaveSettings ()

bool	restore (int number, bool show=true)

void	saveMainWindowSettings (KConfigGroup &config)

void	setAutoSaveSettings (const KConfigGroup &group, bool saveWindowSize=true)

void	setAutoSaveSettings (const QString &groupName=QLatin1String("MainWindow"), bool saveWindowSize=true)

KisToolBar *	toolBar (const QString &name=QString())

QList< KisToolBar * >	toolBars () const

	~KisKMainWindow () override
	Destructor.

Public Member Functions inherited from KisKXMLGUIBuilder
KisKXMLGUIClient *	builderClient () const

virtual QStringList	containerTags () const

virtual QWidget *	createContainer (QWidget parent, int index, const QDomElement &element, QAction &containerAction)

virtual QAction *	createCustomElement (QWidget *parent, int index, const QDomElement &element)

virtual QStringList	customTags () const

	KisKXMLGUIBuilder (QWidget *widget)

virtual void	removeContainer (QWidget container, QWidget parent, QDomElement &element, QAction *containerAction)

virtual void	removeCustomElement (QWidget parent, QAction action)

void	setBuilderClient (KisKXMLGUIClient *client)

QWidget *	widget ()

virtual	~KisKXMLGUIBuilder ()

Public Member Functions inherited from KisKXMLGUIClient
QAction *	action (const char *name) const

virtual QAction *	action (const QDomElement &element) const

virtual KisKActionCollection *	actionCollection () const

void	addStateActionDisabled (const QString &state, const QString &action)

void	addStateActionEnabled (const QString &state, const QString &action)

void	beginXMLPlug (QWidget *)

QList< KisKXMLGUIClient * >	childClients ()

KisKXMLGUIBuilder *	clientBuilder () const

virtual QString	componentName () const

virtual QDomDocument	domDocument () const

void	endXMLPlug ()

KisKXMLGUIFactory *	factory () const

StateChange	getActionsToChangeForState (const QString &state)

void	insertChildClient (KisKXMLGUIClient *child)

	KisKXMLGUIClient ()

	KisKXMLGUIClient (KisKXMLGUIClient *parent)

virtual QString	localXMLFile () const

KisKXMLGUIClient *	parentClient () const

void	plugActionList (const QString &name, const QList< QAction * > &actionList)

void	prepareXMLUnplug (QWidget *)

void	reloadXML ()

void	removeChildClient (KisKXMLGUIClient *child)

void	replaceXMLFile (const QString &xmlfile, const QString &localxmlfile, bool merge=false)

void	setClientBuilder (KisKXMLGUIBuilder *builder)

void	setFactory (KisKXMLGUIFactory *factory)

void	setXMLGUIBuildDocument (const QDomDocument &doc)

void	unplugActionList (const QString &name)

virtual QString	xmlFile () const

QDomDocument	xmlguiBuildDocument () const

virtual	~KisKXMLGUIClient ()

Public Member Functions inherited from KoCanvasSupervisor
	KoCanvasSupervisor ()

virtual	~KoCanvasSupervisor ()

Static Public Member Functions
static void	swapWorkspaces (KisMainWindow a, KisMainWindow b)

Static Public Member Functions inherited from KisKMainWindow
static bool	canBeRestored (int number)

static const QString	classNameOfToplevel (int number)

static QList< KisKMainWindow * >	memberList ()

Static Public Member Functions inherited from KisKXMLGUIClient
static QString	findMostRecentXMLFile (const QStringList &files, QString &doc)

Public Attributes
QMap< QString, QAction * >	actionMap

QMdiSubWindow *	activeSubWindow {nullptr}

QPointer< KisView >	activeView

KisSignalAutoConnectionsStore	activeViewConnections

KisCanvasWindow *	canvasWindow {nullptr}

KisAction *	close {nullptr}

KisAction *	closeAll {nullptr}

KateCommandBar *	commandBar {nullptr}

KisAction *	commandBarAction {nullptr}

QCloseEvent *	deferredClosingEvent {nullptr}

QByteArray	dockerStateBeforeHiding

KActionMenu *	dockWidgetMenu {nullptr}

QMap< QString, QDockWidget * >	dockWidgetsMap

KisSignalMapper *	documentMapper {nullptr}

KActionMenu *	documentMenu {nullptr}

KisAction *	expandingSpacers [2]

KisAction *	exportFile {nullptr}

KisAction *	exportFileAdvance {nullptr}

bool	firstTime {true}

KisAction *	fullScreenMode {nullptr}

KisKHelpMenu *	helpMenu {nullptr}

QUuid	id

KisAction *	importAnimation {nullptr}

KisAction *	importFile {nullptr}

KisAction *	importVideoAnimation {nullptr}

QByteArray	lastExportedFormat

QString	lastExportLocation

QMdiArea *	mdiArea {nullptr}

KisAction *	mdiCascade {nullptr}

KisAction *	mdiNextWindow {nullptr}

KisAction *	mdiPreviousWindow {nullptr}

KisAction *	mdiTile {nullptr}

KisAction *	newWindow {nullptr}

KisMainWindow *	q {nullptr}

KRecentFilesAction *	recentFiles {nullptr}

KisAction *	redo {nullptr}

KisAction *	renderAnimation {nullptr}

KisAction *	renderAnimationAgain {nullptr}

KisAction *	resetConfigurations {nullptr}

KisAction *	saveAction {nullptr}

KisAction *	saveActionAs {nullptr}

QMutex	savingEntryMutex

KisAction *	showDocumentInfo {nullptr}

KisAction *	showSessionManager {nullptr}

QActionGroup *	styleActions {nullptr}

KActionMenu *	styleMenu {nullptr}

QScopedPointer< KisSignalCompressorWithParam< int > >	tabSwitchCompressor

Digikam::ThemeManager *	themeManager {nullptr}

KisAction *	toggleDetachCanvas {nullptr}

KisAction *	toggleDockers {nullptr}

KisAction *	toggleDockerTitleBars {nullptr}

QList< QAction * >	toolbarList

KoToolDocker *	toolOptionsDocker {nullptr}

KisAction *	undo {nullptr}

QScopedPointer< KisUndoActionsUpdateManager >	undoActionsUpdateManager

KisViewManager *	viewManager {nullptr}

KisWelcomePageWidget *	welcomePage {nullptr}

QScrollArea *	welcomeScroller {nullptr}

QStackedWidget *	widgetStack {nullptr}

KisSignalMapper *	windowMapper {nullptr}

KActionMenu *	windowMenu {nullptr}

bool	windowSizeDirty {false}

KConfigGroup	windowStateConfig

QUuid	workspaceBorrowedBy

KActionMenu *	workspaceMenu {nullptr}

KisResourceModel *	workspacemodel {nullptr}

Protected Member Functions
void	closeEvent (QCloseEvent *e) override

void	dragLeaveEvent (QDragLeaveEvent *event) override

void	dragMoveEvent (QDragMoveEvent *event) override

void	resizeEvent (QResizeEvent *e) override

void	showEvent (QShowEvent *event) override

bool	windowsLayoutSavingAllowed () const override

Protected Member Functions inherited from KXmlGuiWindow
bool	event (QEvent *event) override

Protected Member Functions inherited from KisKMainWindow
void	closeEvent (QCloseEvent *) override

bool	event (QEvent *event) override

	KisKMainWindow (KisKMainWindowPrivate &dd, QWidget *parent, Qt::WindowFlags f)

virtual bool	queryClose ()

virtual void	readGlobalProperties (KConfig *sessionConfig)

virtual void	readProperties (const KConfigGroup &)

bool	readPropertiesInternal (KConfig *, int)

virtual void	saveGlobalProperties (KConfig *sessionConfig)

virtual void	saveProperties (KConfigGroup &)

void	savePropertiesInternal (KConfig *, int)

bool	settingsDirty () const

Protected Member Functions inherited from KisKXMLGUIBuilder
virtual void	virtual_hook (int id, void *data)

Protected Member Functions inherited from KisKXMLGUIClient
void	loadStandardsXmlFile ()

virtual void	setComponentName (const QString &componentName, const QString &componentDisplayName)

void	setDOMDocument (const QDomDocument &document, bool merge=false)

void	setLocalXMLFile (const QString &file)

void	setXML (const QString &document, bool merge=false)

void	setXMLFile (const QString &file, bool merge=false, bool setXMLDoc=true)

virtual void	stateChanged (const QString &newstate, ReverseStateChange reverse=StateNoReverse)

virtual void	virtual_hook (int id, void *data)

Private Slots
void	checkSanity ()

void	closeCurrentWindow ()

void	configChanged ()

void	forceDockTabFonts ()

void	importAnimation ()

void	importVideoAnimation ()

void	initializeGeometry ()

void	newWindow ()

void	openCommandBar ()

void	orientationChanged ()

void	redo ()

void	renderAnimation ()

void	renderAnimationAgain ()

void	restoreWorkspace ()

void	setActiveSubWindow (QWidget *window)

virtual void	showAboutApplication ()
	showAboutApplication show the about box

void	showDockerTitleBars (bool show)

void	showErrorAndDie ()
	Quits Krita with error message from m_errorMessage.

void	showManual ()

void	slotConfigureToolbars ()

void	slotDocumentInfo ()

void	slotExportAdvance ()

void	slotExportFile ()

bool	slotFileCloseAll ()

void	slotFileQuit ()

void	slotFileSaveAs ()

void	slotImportFile ()

void	slotLoadCanceled (const QString &)

void	slotLoadCompleted ()

void	slotNewToolbarConfig ()

void	slotResetConfigurations ()

void	slotSaveCanceled (const QString &)

void	slotSaveCompleted ()

void	slotStoragesWarning (const QString &location=QString())

void	slotThemeChanged ()

void	slotToolbarToggled (bool toggle)

void	slotUpdateReadWriteMode (bool readWrite)

void	slotUpdateSaveActionTitle (const QString &documentPath)

void	slotUpdateWidgetStyle ()

void	slotXmlGuiMakingChanges (bool finished)

void	switchTab (int index)

void	toggleDockersVisibility (bool visible, bool onWelcomePage=false)

void	undo ()

void	updateSubwindowFlags ()

void	updateTheme ()

void	updateWindowMenu ()

Private Member Functions
QPointer< KisView >	activeKisView ()

void	addView (KisView view, QMdiSubWindow subWindow=0)

void	adjustLayoutForWelcomePage ()

void	applyActionIconOverridesFromLocalXML ()

void	applyToolBarLayout ()

QByteArray	borrowWorkspace (KisMainWindow *borrower)

void	createActions ()

QDockWidget *	createDockWidget (KoDockFactoryBase *factory)

void	customizeTabBar ()

void	dragLeave ()

void	dragMove (QDragMoveEvent *event)

bool	openDocumentInternal (const QString &path, KisMainWindow::OpenFlags f=KisMainWindow::OpenFlags())

void	saveWindowSettings ()

void	setMainWindowLayoutForCurrentMainWidget (int widgetIndex, bool widgetIndexChanged)

Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d

bool	m_dieOnError

QString	m_errorMessage

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Friends
class	KisPart

class	KisWelcomePageWidget

Additional Inherited Members
Protected Slots inherited from KXmlGuiWindow
virtual void	saveNewToolbarConfig ()

Protected Slots inherited from KisKMainWindow
void	saveAutoSaveSettings ()

Static Protected Member Functions inherited from KisKXMLGUIClient
static QString	standardsXmlFileLocation ()

Protected Attributes inherited from KisKMainWindow
KisKMainWindowPrivate *const	k_ptr

Properties inherited from KXmlGuiWindow
QString	autoSaveGroup

bool	autoSaveSettings

bool	hasMenuBar

bool	standardToolBarMenuEnabled

Properties inherited from KisKMainWindow
QString	autoSaveGroup

bool	autoSaveSettings

bool	hasMenuBar

Detailed Description

Main window for Krita.

This class is used to represent a main window within a Krita session. Each main window contains a menubar and some toolbars, and potentially several views of several canvases.

Definition at line 190 of file KisMainWindow.cpp.

Member Enumeration Documentation

◆ OpenFlag

enum KisMainWindow::OpenFlag

Enumerator
None
Import
BatchMode
RecoveryFile

Definition at line 51 of file KisMainWindow.h.

                  {
        None = 0,
        Import = 0x1,
        BatchMode = 0x2,
        RecoveryFile = 0x4
    };

Constructor & Destructor Documentation

◆ ~Private()

KisMainWindow::~Private ( )

inline

Definition at line 228 of file KisMainWindow.cpp.

               {
        qDeleteAll(toolbarList);
    }

◆ KisMainWindow()

KisMainWindow::KisMainWindow ( QUuid id = QUuid() )

explicit

Initializes a Krita main window (with its basic GUI etc.).

Definition at line 364 of file KisMainWindow.cpp.

    : KXmlGuiWindow()
    , d(new Private(this, uuid))
{
    KisScopedPerformanceLogger perfLog(QStringLiteral("KisMainWindow::KisMainWindow"));
 
    KAcceleratorManager::setNoAccel(this);
 
    d->workspacemodel = new KisResourceModel(ResourceType::Workspaces, this);
    connect(d->workspacemodel, SIGNAL(modelReset()), this, SLOT(updateWindowMenu()));
    connect(d->workspacemodel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(updateWindowMenu()));
    connect(d->workspacemodel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(updateWindowMenu()));
 
    d->viewManager = new KisViewManager(this, actionCollection());
    KConfigGroup group( KSharedConfig::openConfig(), "theme");
#ifndef Q_OS_HAIKU
    d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
#endif
    d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
    setStandardToolBarMenuEnabled(true);
    setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
    setDockNestingEnabled(true);
#ifdef Q_OS_ANDROID
    // On Android, the animations for docks and menus are not only slow, but
    // also can cause crashes in some circumstances. Turning them off feels
    // better and avoids those.
    setAnimated(false);
#endif
 
    qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
    connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
    connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
    connect(this, SIGNAL(themeChanged()), KoToolManager::instance(), SLOT(themeChanged()));
    connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
    connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
    actionCollection()->addAssociatedWidget(this);
    KoPluginLoader::instance()->load("Krita/ViewPlugin", KoPluginLoader::PluginsConfig(), d->viewManager, false);
 
    // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
    KoPluginLoader::instance()->load("Krita/ApplicationPlugin", KoPluginLoader::PluginsConfig(), qApp, true);
 
    KoToolBoxFactory toolBoxFactory;
    QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
 
    KisConfig cfg(true);
    if (cfg.toolOptionsInDocker()) {
        ToolDockerFactory toolDockerFactory;
        d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
        if (d->toolOptionsDocker) {
            d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
        }
    }
 
    QMap<QString, QAction*> dockwidgetActions;
 
    if (toolbox) {
        dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
    }
 
    for (KoDockFactoryBase *factory : KoDockRegistry::instance()->sortedDockWidgetFactories()) {
        QDockWidget *dw = createDockWidget(factory);
        if (dw) {
            dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
        }
    }
 
    if (d->toolOptionsDocker) {
        dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
    }
    connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*,QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*,QList<QPointer<QWidget> >)));
 
    Q_FOREACH (QString title, dockwidgetActions.keys()) {
        d->dockWidgetMenu->addAction(dockwidgetActions[title]);
    }
 
 
    // Style menu actions
    d->styleActions = new QActionGroup(this);
    QAction * action;
 
#ifndef Q_OS_ANDROID
 
    Q_FOREACH (QString styleName, QStyleFactory::keys()) {
 
        action = new QAction(styleName, d->styleActions);
        action->setCheckable(true);
        d->actionMap.insert(styleName, action);
        d->styleMenu->addAction(d->actionMap.value(styleName));
    }
 
    // select the config value, or the current style if that does not exist
    QString styleFromConfig = cfg.widgetStyle().toLower();
    QString styleToSelect = styleFromConfig.isEmpty() ? style()->objectName().toLower() : styleFromConfig;
 
    Q_FOREACH (auto key, d->actionMap.keys()) {
        if(key.toLower() == styleToSelect) { // does the key match selection
            d->actionMap.value(key)->setChecked(true);
        }
    }
 
    connect(d->styleActions, SIGNAL(triggered(QAction*)),
            this, SLOT(slotUpdateWidgetStyle()));
#endif
 
    // Load all the actions from the tool plugins
    // ToolBoxDocker needs them when at setViewManager()
    Q_FOREACH(KoToolFactoryBase *toolFactory, KoToolRegistry::instance()->values()) {
        toolFactory->createActions(actionCollection());
    }
 
 
    Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
        if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
            wdg->setVisible(true);
        }
    }
 
    Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
        observer->setObservedCanvas(0);
        KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
        if (mainwindowObserver) {
            mainwindowObserver->setViewManager(d->viewManager);
        }
    }
 
    d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    d->mdiArea->setTabPosition(QTabWidget::North);
    d->mdiArea->setTabsClosable(true);
    d->mdiArea->setAcceptDrops(true);
 
    themeChanged(); // updates icon styles
 
    setCentralWidget(d->widgetStack);
    d->widgetStack->setCurrentIndex(0);
 
    connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
    connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
    connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
    d->canvasWindow = new KisCanvasWindow(this);
    actionCollection()->addAssociatedWidget(d->canvasWindow);
 
    createActions();
 
    // the welcome screen needs to grab actions...so make sure this line goes after the createAction() so they exist
    d->welcomePage->setMainWindow(this);
 
    d->recentFiles->setRecentFilesModel(&KisRecentDocumentsModelWrapper::instance()->model());
 
    subWindowActivated();
    updateWindowMenu();
 
    if (isHelpMenuEnabled() && !d->helpMenu) {
        d->helpMenu = new KisKHelpMenu(this, KAboutData::applicationData(), false);
 
        // workaround-less version:
        // d->helpMenu = new KisKHelpMenu(this, QString()/*unused*/, false);
 
        // The difference between using KisKActionCollection->addAction() is that
        // these actions do not get tied to the MainWindow.  What does this all do?
        KisKActionCollection *actions = d->viewManager->actionCollection();
        QAction *helpContentsAction = d->helpMenu->action(KisKHelpMenu::menuHelpContents);
        QAction *whatsThisAction = d->helpMenu->action(KisKHelpMenu::menuWhatsThis);
        QAction *reportBugAction = d->helpMenu->action(KisKHelpMenu::menuReportBug);
        QAction *switchLanguageAction = d->helpMenu->action(KisKHelpMenu::menuSwitchLanguage);
        QAction *aboutAppAction = d->helpMenu->action(KisKHelpMenu::menuAboutApp);
        QAction *aboutKdeAction = d->helpMenu->action(KisKHelpMenu::menuAboutKDE);
 
        if (helpContentsAction) {
            actions->addAction(helpContentsAction->objectName(), helpContentsAction);
        }
        if (whatsThisAction) {
            actions->addAction(whatsThisAction->objectName(), whatsThisAction);
        }
        if (reportBugAction) {
            actions->addAction(reportBugAction->objectName(), reportBugAction);
        }
        if (switchLanguageAction) {
            actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
        }
        if (aboutAppAction) {
            actions->addAction(aboutAppAction->objectName(), aboutAppAction);
        }
        if (aboutKdeAction) {
            actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
        }
 
        connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
    }
 
    // Custom handling of help action for manual URL outside docs.kde.org.
    QAction *helpAction = actionCollection()->action("help_contents");
    helpAction->disconnect(SIGNAL(triggered()));
    connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
#if 0
    //check for colliding shortcuts
    QSet<QKeySequence> existingShortcuts;
    Q_FOREACH (QAction* action, actionCollection()->actions()) {
        if(action->shortcut() == QKeySequence(0)) {
            continue;
        }
        dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
        Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
        existingShortcuts.insert(action->shortcut());
    }
#endif
 
    configChanged();
 
    // Make sure the python plugins create their actions in time
    KisPart::instance()->notifyMainWindowIsBeingCreated(this);
 
    // If we have customized the toolbars, load that first
    setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita5.xmlgui"));
    setXMLFile(":/kxmlgui5/krita5.xmlgui");
 
    guiFactory()->addClient(this);
    applyActionIconOverridesFromLocalXML();
    connect(guiFactory(), SIGNAL(makingChanges(bool)), SLOT(slotXmlGuiMakingChanges(bool)));
 
    // Create and plug toolbar list for Settings menu
    QList<QAction *> toolbarList;
    Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
        KisToolBar * toolBar = ::qobject_cast<KisToolBar *>(it);
        if (toolBar) {
            KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
            actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
            act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
            connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
            act->setChecked(!toolBar->isHidden());
            toolbarList.append(act);
        } else {
            warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
        }
    }
 
    plugActionList("toolbarlist", toolbarList);
    d->toolbarList = toolbarList;
 
    applyToolBarLayout();
 
    d->viewManager->updateGUI();
    d->viewManager->updateIcons();
 
    QTimer::singleShot(1000, Qt::CoarseTimer, this, SLOT(checkSanity()));
 
    {
        using namespace std::placeholders; // For _1 placeholder
        std::function<void (int)> callback(
                    std::bind(&KisMainWindow::switchTab, this, _1));
 
        d->tabSwitchCompressor.reset(
                    new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
    }
 
 
    if (cfg.readEntry("CanvasOnlyActive", false)) {
        QString currentWorkspace = cfg.readEntry<QString>("CurrentWorkspace", "Default");
        KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
        KisWorkspaceResourceSP workspace = rserver->resource("", "", currentWorkspace);
        if (workspace) {
            restoreWorkspace(workspace);
        }
        cfg.writeEntry("CanvasOnlyActive", false);
        menuBar()->setVisible(true);
    }
 
    this->winId(); // Ensures the native window has been created.
 
#ifdef Q_OS_ANDROID
    // HACK: This prevents the mainWindow from going beyond the screen with no
    // way to bring it back. Apparently the size doesn't matter here as long as
    // it remains fixed?
    setFixedSize(KisApplication::primaryScreen()->availableGeometry().size());
 
    QScreen *s = QGuiApplication::primaryScreen();
    s->setOrientationUpdateMask(Qt::LandscapeOrientation|Qt::InvertedLandscapeOrientation|Qt::PortraitOrientation|Qt::InvertedPortraitOrientation);
    connect(s, SIGNAL(orientationChanged(Qt::ScreenOrientation)), this, SLOT(orientationChanged()));
 
#if KRITA_QT_HAS_ANDROID_QPLATFORMSCREEN_DENSITY_ADJUSTMENT
    // When the screen's UI scale changes, we have to hide and show it to get
    // its contents to update, otherwise it fails to re-render altogether.
    KisAndroidScaling *androidScaling = KisAndroidScaling::instance();
    if (androidScaling) {
        connect(androidScaling,
                &KisAndroidScaling::sigInterfaceScaleChanged,
                this,
                &KisMainWindow::slotFlashWindowHack,
                Qt::QueuedConnection);
    }
#endif
 
    // When Krita starts, Java side sends an event to set applicationState() to active. But, before
    // the event could reach KisApplication's platform integration, it is cleared by KisOpenGLModeProber::probeFormat.
    // So, we send it manually when MainWindow shows up.
    QAndroidJniObject::callStaticMethod<void>("org/qtproject/qt5/android/QtNative", "setApplicationState", "(I)V", Qt::ApplicationActive);
#endif
 
    setAcceptDrops(true);
    QTabBar *tabBar = d->findTabBarHACK();
    if (tabBar) {
        tabBar->setElideMode(Qt::ElideRight);
        // load customized tab style
        customizeTabBar();
        tabBar->setExpanding(true);
        tabBar->setAcceptDrops(true);
        tabBar->setChangeCurrentOnDrag(true);
    }
 
    applyMainWindowSettings(d->windowStateConfig);
}

References KisKXMLGUIClient::action(), KisKActionCollection::action(), KisKXMLGUIClient::actionCollection(), KisKActionCollection::addAction(), KisKActionCollection::addAssociatedWidget(), KisKXMLGUIFactory::addClient(), applyActionIconOverridesFromLocalXML(), KXmlGuiWindow::applyMainWindowSettings(), applyToolBarLayout(), canvasObservers(), checkSanity(), configChanged(), createActions(), KoToolFactoryBase::createActions(), createDockWidget(), customizeTabBar(), d, dbgKrita, dockWidgets(), KisKXMLGUIClient::factory(), KisSignalCompressor::FIRST_INACTIVE, forceDockTabFonts(), KXmlGuiWindow::guiFactory(), KoDockRegistry::instance(), KoToolManager::instance(), KoToolRegistry::instance(), KisConfigNotifier::instance(), KoPluginLoader::instance(), KisAndroidScaling::instance(), KisPart::instance(), KisResourceServerProvider::instance(), KisRecentDocumentsModelWrapper::instance(), KXmlGuiWindow::isHelpMenuEnabled(), KoPluginLoader::load(), KoResourcePaths::locateLocal(), KisKHelpMenu::menuAboutApp, KisKHelpMenu::menuAboutKDE, KisKHelpMenu::menuHelpContents, KisKHelpMenu::menuReportBug, KisKHelpMenu::menuSwitchLanguage, KisKHelpMenu::menuWhatsThis, newOptionWidgets(), newView(), KisPart::notifyMainWindowIsBeingCreated(), orientationChanged(), KisKXMLGUIClient::plugActionList(), KisConfig::readEntry(), restoreWorkspace(), restoringDone(), setActiveSubWindow(), KisKXMLGUIClient::setLocalXMLFile(), KoCanvasObserverBase::setObservedCanvas(), KXmlGuiWindow::setStandardToolBarMenuEnabled(), KisMainwindowObserver::setViewManager(), KisKXMLGUIClient::setXMLFile(), showAboutApplication(), showManual(), KisAndroidScaling::sigInterfaceScaleChanged(), slotToolbarToggled(), slotUpdateWidgetStyle(), slotXmlGuiMakingChanges(), KoDockRegistry::sortedDockWidgetFactories(), subWindowActivated(), switchTab(), themeChanged(), KisKMainWindow::toolBar(), toolbarList, KisConfig::toolOptionsInDocker(), updateWindowMenu(), void(), warnUI, KisConfig::widgetStyle(), ResourceType::Workspaces, KisResourceServerProvider::workspaceServer(), and KisConfig::writeEntry().

◆ ~KisMainWindow()

KisMainWindow::~KisMainWindow ( )

override

Destructor.

Destructor of KisView accesses KisViewManager is multiple ways, directly and via KoToolManager. Hence we should destroy all the subwindows before we actually destroy the view manager.

Please note that we cannot just close() the subwindows, becasue they are deleted with deleteLater(), which may postpone their destruction till after KisViewManager's death.

Definition at line 682 of file KisMainWindow.cpp.

{
    //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
    //        QAction *action = qobject_cast<QAction*>(ac);
    //        if (action) {
    //        qDebug() << "<Action"
    //                 << "\n\tname=" << action->objectName()
    //                 << "\n\ticon=" << action->icon().name()
    //                 << "\n\ttext="  << action->text().replace("&", "&amp;")
    //                 << "\n\twhatsThis="  << action->whatsThis()
    //                 << "\n\ttoolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
    //                 << "\n\ticonText="  << action->iconText().replace("&", "&amp;")
    //                 << "\n\tshortcut="  << action->shortcut().toString()
    //                 << "\n\tisCheckable="  << QString((action->isChecked() ? "true" : "false"))
    //                 << "\n\tstatusTip=" << action->statusTip()
    //                 << "\n/>\n"   ;
    //        }
    //        else {
    //            dbgKrita << "Got a non-qaction:" << ac->objectName();
    //        }
    //    }
 
    Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
        if (subwin) {
            (void) subwin->close();
            delete subwin;
        }
    }
 
    // The doc and view might still exist (this is the case when closing the window)
    KisPart::instance()->removeMainWindow(this);
 
    delete d->viewManager;
    delete d;
 
}

References d, KisPart::instance(), KisPart::removeMainWindow(), and void().

Member Function Documentation

◆ actionManager()

KisActionManager * KisMainWindow::actionManager ( )

inline

Definition at line 332 of file KisMainWindow.cpp.

                                       {
        return viewManager->actionManager();
    }

◆ activeKisView()

QPointer< KisView > KisMainWindow::activeKisView ( )

private

Definition at line 3033 of file KisMainWindow.cpp.

{
    if (!d->mdiArea) return 0;
    QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
    //dbgKrita << "activeKisView" << activeSubWindow;
    if (!activeSubWindow) return 0;
    return qobject_cast<KisView*>(activeSubWindow->widget());
}

References activeSubWindow, and d.

◆ activeView()

KisView * KisMainWindow::activeView ( ) const

Returns: the currently active view

◆ activeViewChanged

void KisMainWindow::activeViewChanged ( )

signal

emitted when the current view has changed

◆ addView()

void KisMainWindow::addView	(	KisView *	view,
		QMdiSubWindow *	subWindow = 0 )

private

Add a the given view to the list of views of this mainwindow. This is a private implementation. For public usage please use newView() and addViewAndNotifyLoadingCompleted().

Definition at line 737 of file KisMainWindow.cpp.

{
    if (d->activeView == view && !subWindow) return;
 
    if (d->activeView) {
        d->activeView->disconnect(this);
    }
 
    // register the newly created view in the input manager
    viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
    showView(view, subWindow);
    Q_EMIT restoringDone();
 
//    QTabBar *tabBar = d->findTabBarHACK();
//    Q_FOREACH(QObject *c, tabBar->children()) {
//        if (QWidget *w = qobject_cast<QWidget*>(c)) {
//            w->setAcceptDrops(true);
//        }
//    }
}

References KisInputManager::addTrackedCanvas(), KisView::canvasBase(), d, KisViewManager::inputManager(), restoringDone(), showView(), and viewManager.

◆ addViewAndNotifyLoadingCompleted()

KisView * KisMainWindow::addViewAndNotifyLoadingCompleted	(	KisDocument *	document,
		QMdiSubWindow *	subWindow = 0 )

Definition at line 1195 of file KisMainWindow.cpp.

{
    showWelcomeScreen(false); // see workaround in function header
 
    KisView *view = KisPart::instance()->createView(document, d->viewManager, this);
    addView(view, subWindow);
 
    Q_EMIT guiLoadingFinished();
 
#ifdef Q_OS_ANDROID
    // HACK: When opening documents on Android, the main window sometimes fails
    // to update until the application is shunted to the background and brought
    // back or the menu bar is fiddled with. Flickering the window fixes this.
    // Having a docker that uses QML somehow also fixes this, so this hack is
    // gone again in 5.3 with the introduction of the text properties docker.
    // UNHACK: But not on Xiaomi devices! There flickering the window makes it
    // sorta exit fullscreen, adding black bars at the top and bottom. Just
    // opening a document seems to work fine on these devices though, it delays
    // for a moment then displays fine, so just skip this there I guess.
    if (!KisAndroidUtils::looksLikeXiaomiDevice()) {
        slotFlashWindowHack();
    }
#endif
 
    return view;
}

References addView(), KisPart::createView(), d, guiLoadingFinished(), KisPart::instance(), KisAndroidUtils::looksLikeXiaomiDevice(), and showWelcomeScreen().

◆ adjustLayoutForWelcomePage()

void KisMainWindow::adjustLayoutForWelcomePage ( )

private

Definition at line 1733 of file KisMainWindow.cpp.

{
    // This makes sure we don't save window state when we're in welcome page mode, because all the dockers
    // etc are hidden while the user is here.
    resetAutoSaveSettings();
 
    toggleDockersVisibility(false, true);
    if (statusBar()) {
        statusBar()->hide();
    }
    QList<QToolBar *> toolbars = findChildren<QToolBar *>();
    for (QToolBar *toolbar : toolbars) {
        if (toolbar->objectName() != "mainToolBar") {
            toolbar->hide();
        }
    }
}

References KisKMainWindow::resetAutoSaveSettings(), and toggleDockersVisibility().

◆ applyActionIconOverridesFromLocalXML()

void KisMainWindow::applyActionIconOverridesFromLocalXML ( )

private

Definition at line 3379 of file KisMainWindow.cpp.

{
    QString xmlPath = KoResourcePaths::locateLocal("data", "krita5.xmlgui");
    QFile file(xmlPath);
    if (!file.exists()) {
        return;
    }
 
    QDomDocument doc;
    if (!file.open(QIODevice::ReadOnly) || !doc.setContent(&file)) {
        return;
    }
 
    QDomNodeList overridesList = doc.elementsByTagName(QStringLiteral("ActionIconOverrides"));
    if (!overridesList.isEmpty()) {
        QDomElement overridesElement = overridesList.at(0).toElement();
        QDomNodeList actions = overridesElement.elementsByTagName(QStringLiteral("Action"));
        for (int i = 0; i < actions.count(); ++i) {
            QDomElement actionElement = actions.at(i).toElement();
            QString name = actionElement.attribute(QStringLiteral("name"));
            QString icon = actionElement.attribute(QStringLiteral("icon"));
            if (!name.isEmpty() && !icon.isEmpty()) {
                QAction *qa = actionCollection()->action(name);
                if (qa) {
                    qa->setIcon(KisIconUtils::loadIcon(icon));
                }
            }
        }
    }
}

References KisKActionCollection::action(), KisKXMLGUIClient::actionCollection(), KisIconUtils::loadIcon(), and KoResourcePaths::locateLocal().

◆ applyToolBarLayout()

void KisMainWindow::applyToolBarLayout ( )

private

Definition at line 3234 of file KisMainWindow.cpp.

{
    Q_FOREACH (KisToolBar *toolBar, toolBars()) {
        toolBar->layout()->setSpacing(4);
        toolBar->setStyleSheet("QToolBar { border: none }"); // has a border in "Fusion" style that people don't like
 
        // Hide text for buttons with an icon in the toolbar
        Q_FOREACH (QAction *ac, toolBar->actions()){
            if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                ac->setPriority(QAction::LowPriority);
            } else {
                ac->setIcon(QIcon());
            }
        }
    }
}

References KisKMainWindow::toolBar(), and KisKMainWindow::toolBars().

◆ borrowWorkspace()

QByteArray KisMainWindow::borrowWorkspace ( KisMainWindow * borrower )

private

Definition at line 2143 of file KisMainWindow.cpp.

{
    QByteArray currentWorkspace = saveState();
 
    if (!d->workspaceBorrowedBy.isNull()) {
        if (other->id() == d->workspaceBorrowedBy) {
            // We're swapping our original workspace back
            d->workspaceBorrowedBy = QUuid();
            return currentWorkspace;
        } else {
            // Get our original workspace back before swapping with a third window
            KisMainWindow *borrower = KisPart::instance()->windowById(d->workspaceBorrowedBy);
            if (borrower) {
                QByteArray originalLayout = borrower->borrowWorkspace(this);
                borrower->restoreWorkspaceState(currentWorkspace);
 
                d->workspaceBorrowedBy = other->id();
                return originalLayout;
            }
        }
    }
 
    d->workspaceBorrowedBy = other->id();
    return currentWorkspace;
}

References borrowWorkspace(), d, id, KisPart::instance(), restoreWorkspaceState(), and KisPart::windowById().

◆ canvasDetached()

bool KisMainWindow::canvasDetached ( ) const

Definition at line 1040 of file KisMainWindow.cpp.

{
    return centralWidget() != d->widgetStack;
}

References d.

◆ canvasObservers()

QList< KoCanvasObserverBase * > KisMainWindow::canvasObservers ( ) const

overridevirtual

Implements KoCanvasSupervisor.

Definition at line 2611 of file KisMainWindow.cpp.

{
    QList<KoCanvasObserverBase*> observers;
 
    observers.append(static_cast<KoCanvasObserverBase*>(KisPart::instance()->playbackEngine()));
 
    Q_FOREACH (QDockWidget *docker, dockWidgets()) {
        KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
        if (observer) {
            observers << observer;
        }
        else {
            warnKrita << docker << "is not a canvas observer";
        }
    }
 
    return observers;
}

References dockWidgets(), KisPart::instance(), and warnKrita.

◆ canvasWindow()

QWidget * KisMainWindow::canvasWindow ( ) const

The top-level window used for a detached canvas.

◆ checkActiveBundlesAvailable

bool KisMainWindow::checkActiveBundlesAvailable ( )

slot

checkActiveStorages checks whether there is at least one bundle available and at least one paintop preset.

Definition at line 3356 of file KisMainWindow.cpp.

{
    KisStorageFilterProxyModel proxy;
    proxy.setSourceModel(KisStorageModel::instance());
    proxy.setFilter(KisStorageFilterProxyModel::ByStorageType,
                    QStringList()
                    << KisResourceStorage::storageTypeToUntranslatedString(KisResourceStorage::StorageType::Bundle));
 
    return (proxy.rowCount() > 0);
}

References KisResourceStorage::Bundle, KisStorageFilterProxyModel::ByStorageType, KisStorageModel::instance(), KisStorageFilterProxyModel::setFilter(), and KisResourceStorage::storageTypeToUntranslatedString().

◆ checkPaintOpAvailable

bool KisMainWindow::checkPaintOpAvailable ( )

slot

Definition at line 3367 of file KisMainWindow.cpp.

{
    KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
    return (rserver->resourceCount() > 0);
}

References KisResourceServerProvider::instance(), KisResourceServerProvider::paintOpPresetServer(), and KoResourceServer< T >::resourceCount().

◆ checkSanity

void KisMainWindow::checkSanity ( )

privateslot

Definition at line 3000 of file KisMainWindow.cpp.

{
    // print error if the lcms engine is not available
    if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
        // need to wait 1 event since exiting here would not work.
        m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
        m_dieOnError = true;
        QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
        return;
    }
 
    slotStoragesWarning();
 
    // window is created signal (used in Python)
    // there must be some asynchronous things happening in the constructor, because the window cannot
    // be referenced until after this timeout is done
    Q_EMIT KisPart::instance()->sigMainWindowCreated();
}

References KoColorSpaceEngineRegistry::instance(), KisPart::instance(), m_dieOnError, m_errorMessage, showErrorAndDie(), KisPart::sigMainWindowCreated(), and slotStoragesWarning().

◆ clearRecentFiles

void KisMainWindow::clearRecentFiles ( )

slot

clears the list of the recent files

Definition at line 1076 of file KisMainWindow.cpp.

{
    KisRecentFilesManager::instance()->clear();
}

References KisRecentFilesManager::clear(), and KisRecentFilesManager::instance().

◆ closeCurrentWindow

void KisMainWindow::closeCurrentWindow ( )

privateslot

Definition at line 2992 of file KisMainWindow.cpp.

{
    if (d->mdiArea->currentSubWindow()) {
        d->mdiArea->currentSubWindow()->close();
        d->actionManager()->updateGUI();
    }
}

References d.

◆ closeEvent()

void KisMainWindow::closeEvent ( QCloseEvent * e )

overrideprotected

Definition at line 1575 of file KisMainWindow.cpp.

{
    if (hackIsSaving()) {
        e->setAccepted(false);
        return;
    }
 
    if (!KisPart::instance()->closingSession()) {
        QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
        if ((action) && (action->isChecked())) {
            action->setChecked(false);
        }
 
        // Save session when last window is closed
        if (KisPart::instance()->mainwindowCount() == 1) {
            bool closeAllowed = KisPart::instance()->closeSession();
 
            if (!closeAllowed) {
                e->setAccepted(false);
                return;
            }
        }
    }
 
    d->mdiArea->closeAllSubWindows();
 
    QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
    if (childrenList.isEmpty()) {
        // TODO: that assignment looks really suspicious, because `e`
        // is destroyed right after the exit of this function
        d->deferredClosingEvent = e;
        d->canvasWindow->close();
    } else {
        e->setAccepted(false);
    }
}

References KisKXMLGUIClient::action(), KisPart::closeSession(), d, hackIsSaving(), and KisPart::instance().

◆ configChanged

void KisMainWindow::configChanged ( )

privateslot

Dirty workaround for a bug in Qt (checked on Qt 5.6.1):

If you make a window "Show on top" and then switch to the tabbed mode the window will continue to be painted in its initial "mid-screen" position. It will persist here until you explicitly switch to its tab.

Definition at line 2899 of file KisMainWindow.cpp.

{
    KisConfig cfg(true);
    QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
    d->mdiArea->setViewMode(viewMode);
    //Do it here to avoid the wrong icon briefly flashing
    customizeTabBar();
 
    Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
        subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
        subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
        if (viewMode == QMdiArea::TabbedView) {
            subwin->setWindowState(Qt::WindowMaximized);
        }
 
        if (viewMode == QMdiArea::TabbedView) {
            Qt::WindowFlags oldFlags = subwin->windowFlags();
            Qt::WindowFlags flags = oldFlags;
 
            flags &= ~Qt::WindowStaysOnTopHint;
            flags &= ~Qt::WindowStaysOnBottomHint;
 
            if (flags != oldFlags) {
                subwin->setWindowFlags(flags);
                subwin->showMaximized();
            }
        }
    }
#ifdef Q_OS_MACOS
    updateSubwindowFlags();
#endif
 
    KConfigGroup group( KSharedConfig::openConfig(), "theme");
#ifndef Q_OS_HAIKU
    d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
#endif
    d->actionManager()->updateGUI();
 
    QString s = cfg.getMDIBackgroundColor();
    KoColor c = KoColor::fromXML(s);
    QBrush brush(c.toQColor());
    d->mdiArea->setBackground(brush);
 
    QString backgroundImage = cfg.getMDIBackgroundImage();
    if (backgroundImage != "") {
        QImage image(backgroundImage);
        QBrush brush(image);
        d->mdiArea->setBackground(brush);
    }
 
    d->mdiArea->update();
 
    qApp->setFont(KisUiFont::normalFont());
 
    Q_FOREACH (QObject* widget, children()) {
        if (widget->inherits("QDockWidget")) {
            QDockWidget* dw = static_cast<QDockWidget*>(widget);
            dw->setFont(KisUiFont::dockFont());
        }
    }
}

References customizeTabBar(), d, KisUiFont::dockFont(), KoColor::fromXML(), KisConfig::getMDIBackgroundColor(), KisConfig::getMDIBackgroundImage(), KisUiFont::normalFont(), KisConfig::readEntry(), KoColor::toQColor(), updateSubwindowFlags(), KisConfig::useOpenGL(), and KisKXMLGUIBuilder::widget().

◆ createActions()

void KisMainWindow::createActions ( )

private

Definition at line 3070 of file KisMainWindow.cpp.

{
    KisActionManager *actionManager = d->actionManager();
 
 
 
    actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
    actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
    actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
    actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
    d->fullScreenMode = actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
    d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
 
    d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
    d->saveAction->setActivationFlags(KisAction::IMAGE_IS_WRITABLE);
 
    d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
    d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
    d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
    d->undo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
    d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
    d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
    d->undoActionsUpdateManager.reset(new KisUndoActionsUpdateManager(d->undo, d->redo));
    d->undoActionsUpdateManager->setCurrentDocument(d->activeView ? d->activeView->document() : 0);
 
    d->importAnimation  = actionManager->createAction("file_import_animation");
    connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
    // Importing video requires ffmpeg, which is not available on Android.
#ifndef Q_OS_ANDROID
    d->importVideoAnimation = actionManager->createAction("file_import_video_animation");
    connect(d->importVideoAnimation, SIGNAL(triggered()), this, SLOT(importVideoAnimation()));
#endif
 
    d->renderAnimation = actionManager->createAction("render_animation");
    d->renderAnimation->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
    connect( d->renderAnimation, SIGNAL(triggered()), this, SLOT(renderAnimation()));
 
    d->renderAnimationAgain = actionManager->createAction("render_animation_again");
    d->renderAnimationAgain->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
    connect( d->renderAnimationAgain, SIGNAL(triggered()), this, SLOT(renderAnimationAgain()));
 
    d->closeAll = actionManager->createAction("file_close_all");
    connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
    d->importFile  = actionManager->createAction("file_import_file");
    d->importFile->setActivationFlags(KisAction::IMAGE_IS_WRITABLE);
    connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
    d->exportFile  = actionManager->createAction("file_export_file");
    connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
    d->exportFileAdvance  = actionManager->createAction("file_export_advanced");
    connect(d->exportFileAdvance, SIGNAL(triggered(bool)), this, SLOT(slotExportAdvance()));
 
    /* The following entry opens the document information dialog.  Since the action is named so it
        intends to show data this entry should not have a trailing ellipses (...).  */
    d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
    connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
#ifndef Q_OS_HAIKU
    d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
    d->themeManager->registerThemeActions(actionCollection());
    connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()), Qt::QueuedConnection);
    connect(this, SIGNAL(themeChanged()), d->welcomePage, SLOT(slotUpdateThemeColors()), Qt::UniqueConnection);
#endif
    d->toggleDockers = actionManager->createAction("view_toggledockers");
 
 
    KisConfig(true).showDockers(true);
    d->toggleDockers->setChecked(true);
    connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
    d->resetConfigurations  = actionManager->createAction("reset_configurations");
    connect(d->resetConfigurations, SIGNAL(triggered()), this, SLOT(slotResetConfigurations()));
 
#ifndef Q_OS_ANDROID
    d->toggleDetachCanvas = actionManager->createAction("view_detached_canvas");
    d->toggleDetachCanvas->setChecked(false);
    connect(d->toggleDetachCanvas, SIGNAL(toggled(bool)), SLOT(setCanvasDetached(bool)));
#endif
    setCanvasDetached(false);
 
    d->toggleDockerTitleBars = actionManager->createAction("view_toggledockertitlebars");
    d->toggleDockerTitleBars->setChecked(KisConfig(false).showDockerTitleBars());
    connect(d->toggleDockerTitleBars, SIGNAL(toggled(bool)), SLOT(showDockerTitleBars(bool)));
 
    actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
    actionCollection()->addAction("window", d->windowMenu);
 
    actionCollection()->addAction("style_menu", d->styleMenu); // for widget styles: breeze, fusion, etc
 
    d->mdiCascade = actionManager->createAction("windows_cascade");
    connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
    d->mdiTile = actionManager->createAction("windows_tile");
    connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
    d->mdiNextWindow = actionManager->createAction("windows_next");
    connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
    d->mdiPreviousWindow = actionManager->createAction("windows_previous");
    connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
#ifdef Q_OS_ANDROID
    d->showDonationManagementDialog = actionManager->createAction("manage_donations");
    connect(d->showDonationManagementDialog,
            &QAction::triggered,
            this,
            &KisMainWindow::slotShowDonationManagementDialog);
 
    KisAndroidDonations *androidDonations = KisAndroidDonations::instance();
    if (androidDonations) {
        d->manageSubscriptions = actionManager->createAction("manage_subscriptions");
        connect(d->manageSubscriptions,
                &QAction::triggered,
                androidDonations,
                &KisAndroidDonations::slotManageSubscriptions);
        connect(androidDonations,
                &KisAndroidDonations::sigShowDonationManagementDialogRequested,
                this,
                &KisMainWindow::slotShowDonationManagementDialog,
                Qt::QueuedConnection);
    }
#if KRITA_QT_HAS_ANDROID_QPLATFORMSCREEN_DENSITY_ADJUSTMENT
    KisAndroidScaling *androidScaling = KisAndroidScaling::instance();
    if (androidScaling && androidScaling->isSupported()) {
        d->changeInterfaceScale = actionManager->createAction("change_interface_scale");
        connect(d->changeInterfaceScale, &QAction::triggered, this, &KisMainWindow::slotChangeInterfaceScale);
    }
#endif
#else
    d->newWindow = actionManager->createAction("view_newwindow");
    connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
#endif
 
    d->close = actionManager->createStandardAction(KStandardAction::Close, this, SLOT(closeCurrentWindow()));
 
    d->showSessionManager = actionManager->createAction("file_sessions");
    connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
    d->commandBarAction = actionManager->createAction("command_bar_open");
    connect(d->commandBarAction, SIGNAL(triggered(bool)), this, SLOT(openCommandBar()));
 
    actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
    for (int i = 0; i < 2; i++) {
        d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
        d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
        d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
        actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
    }
 
    {
        using namespace KisWidgetConnectionUtils;
 
        QAction *action = actionManager->createAction("lock_toolbars");
        connectControl(action, KisToolBar::toolBarStateModel(), "toolBarsLocked");
    }
}

References KisKXMLGUIClient::action(), KisKXMLGUIClient::actionCollection(), actionManager(), KisAction::ACTIVE_IMAGE, KisActionManager::addAction(), KisKActionCollection::addAction(), KStandardAction::Close, closeCurrentWindow(), KStandardAction::ConfigureToolbars, KisActionManager::createAction(), KisActionManager::createStandardAction(), d, KStandardAction::FullScreen, KisAction::IMAGE_HAS_ANIMATION, KisAction::IMAGE_IS_WRITABLE, importAnimation, importVideoAnimation, KisAndroidDonations::instance(), KisAndroidScaling::instance(), KisAndroidScaling::isSupported(), KStandardAction::New, newWindow, KStandardAction::Open, openCommandBar(), KStandardAction::openRecent(), KStandardAction::Preferences, KStandardAction::Quit, redo, KStandardAction::Redo, renderAnimation, renderAnimationAgain, KStandardAction::Save, KStandardAction::SaveAs, setCanvasDetached(), KisConfig::showDockers(), showDockerTitleBars(), KisAndroidDonations::sigShowDonationManagementDialogRequested(), slotChangeInterfaceScale(), slotConfigureToolbars(), slotDocumentInfo(), slotExportAdvance(), slotExportFile(), slotFileCloseAll(), slotFileNew(), slotFileOpen(), slotFileOpenRecent(), slotFileQuit(), slotFileSave(), slotFileSaveAs(), slotImportFile(), KisAndroidDonations::slotManageSubscriptions(), slotPreferences(), slotResetConfigurations(), slotShowSessionManager(), slotThemeChanged(), themeChanged(), toggleDockersVisibility(), KisToolBar::toolBarStateModel(), undo, KStandardAction::Undo, and viewFullscreen().

◆ createDockWidget()

QDockWidget * KisMainWindow::createDockWidget ( KoDockFactoryBase * factory )

private

Returns the dockwidget specified by the factory. If the dock widget doesn't exist yet it's created. Add a "view_palette_action_menu" action to your view menu if you want to use closable dock widgets.

Parameters

factory the factory used to create the dock widget if needed

Returns: the dock widget specified by factory (may be 0)

Definition at line 2465 of file KisMainWindow.cpp.

{
    QDockWidget* dockWidget = 0;
    const bool showTitlebars = KisConfig(false).showDockerTitleBars();
 
    if (!d->dockWidgetsMap.contains(factory->id())) {
        KisScopedPerformanceLogger perfLog(QStringLiteral("KisMainWindow::createDockWidget(%1)").arg(factory->id()));
        dockWidget = factory->createDockWidget();
        KAcceleratorManager::setNoAccel(dockWidget);
 
        // It is quite possible that a dock factory cannot create the dock; don't
        // do anything in that case.
        if (!dockWidget) {
            warnKrita << "Could not create docker for" << factory->id();
            return 0;
        }
 
        KoDockWidgetTitleBar *titleBar = dynamic_cast<KoDockWidgetTitleBar*>(dockWidget->titleBarWidget());
 
        // Check if the dock widget is supposed to be collapsible
        if (!dockWidget->titleBarWidget()) {
            titleBar = new KoDockWidgetTitleBar(dockWidget);
            dockWidget->setTitleBarWidget(titleBar);
        }
        if (titleBar) {
            titleBar->setFont(KisUiFont::dockFont());
        }
 
        if (dockWidget->titleBarWidget() && !dockWidget->titleBarWidget()->inherits("KisUtilityTitleBar")) {
            dockWidget->titleBarWidget()->setVisible(KisConfig(true).showDockerTitleBars());
        }
 
        dockWidget->setObjectName(factory->id());
        dockWidget->setParent(this);
        if (!showTitlebars) {
            if (dockWidget->titleBarWidget() && !dockWidget->titleBarWidget()->inherits("KisUtilityTitleBar")) {
                dockWidget->titleBarWidget()->setVisible(false);
            }
            dockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures);
        }
        if (dockWidget->widget() && dockWidget->widget()->layout())
            dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
        Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
        bool visible = true;
 
        switch (factory->defaultDockPosition()) {
        case KoDockFactoryBase::DockTornOff:
            dockWidget->setFloating(true); // position nicely?
            break;
        case KoDockFactoryBase::DockTop:
            side = Qt::TopDockWidgetArea; break;
        case KoDockFactoryBase::DockLeft:
            side = Qt::LeftDockWidgetArea; break;
        case KoDockFactoryBase::DockBottom:
            side = Qt::BottomDockWidgetArea; break;
        case KoDockFactoryBase::DockRight:
            side = Qt::RightDockWidgetArea; break;
        case KoDockFactoryBase::DockMinimized:
        default:
            side = Qt::RightDockWidgetArea;
            visible = false;
        }
 
        KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
        side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
        if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
        addDockWidget(side, dockWidget);
        if (!visible) {
            dockWidget->hide();
        }
 
        bool locked = group.readEntry("Locked", false);
        if (titleBar && locked) {
            titleBar->setLocked(true);
        }
        else if ( dockWidget->titleBarWidget()->inherits("KisUtilityTitleBar") && locked){
            KisUtilityTitleBar *utilityTitleBar = dynamic_cast<KisUtilityTitleBar*>(dockWidget->titleBarWidget());
            utilityTitleBar->setLocked(true);
        }
 
        d->dockWidgetsMap.insert(factory->id(), dockWidget);
    }
    else {
        dockWidget = d->dockWidgetsMap[factory->id()];
    }
 
#ifdef Q_OS_MACOS
    dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
#endif
    dockWidget->setFont(KisUiFont::dockFont());
 
    connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
    return dockWidget;
}

References d, KoDockFactoryBase::DockBottom, KisUiFont::dockFont(), KoDockFactoryBase::DockLeft, KoDockFactoryBase::DockMinimized, KoDockFactoryBase::DockRight, KoDockFactoryBase::DockTop, KoDockFactoryBase::DockTornOff, dockWidget(), KisKXMLGUIClient::factory(), forceDockTabFonts(), KisUtilityTitleBar::setLocked(), KoDockWidgetTitleBar::setLocked(), KisConfig::showDockerTitleBars(), showDockerTitleBars(), and warnKrita.

◆ createPopupMenu()

QMenu * KisMainWindow::createPopupMenu ( )

override

Definition at line 728 of file KisMainWindow.cpp.

{
    return 0;
}

◆ customizeTabBar()

void KisMainWindow::customizeTabBar ( )

private

Definition at line 998 of file KisMainWindow.cpp.

{
    // update MDI area theme
    // Tab close button override
    // just switch this icon out for all OSs so it is easier to see
    QString closeButtonImageUrl;
    QString closeButtonHoverColor;
    if (KisIconUtils::useDarkIcons()) {
        closeButtonImageUrl = QStringLiteral(":/dark_close-tab.svg");
        closeButtonHoverColor = QStringLiteral("lightcoral");
    } else {
        closeButtonImageUrl = QStringLiteral(":/light_close-tab.svg");
        closeButtonHoverColor = QStringLiteral("darkred");
    }
    QString tabStyleSheet = QStringLiteral(R"(
            QTabBar::close-button {
                image: url(%1);
                padding: 1.5px;
                border-radius: 3px;
            }
            QTabBar::close-button:hover {
                background-color: %2;
            }
            QTabBar::close-button:pressed {
                background-color: red;
            }
 
            QHeaderView::section {
                padding: 7px;
            }
 
           )")
           .arg(closeButtonImageUrl, closeButtonHoverColor);
 
 
    QTabBar* tabBar = d->findTabBarHACK();
    if (tabBar) {
        tabBar->setStyleSheet(tabStyleSheet);
    }
 
}

References d, and KisIconUtils::useDarkIcons().

◆ dockWidget()

QDockWidget * KisMainWindow::dockWidget ( const QString & id )

Definition at line 2605 of file KisMainWindow.cpp.

{
    if (!d->dockWidgetsMap.contains(id)) return 0;
    return d->dockWidgetsMap[id];
}

References d, and id.

◆ dockWidgets()

QList< QDockWidget * > KisMainWindow::dockWidgets ( ) const

Return the list of dock widgets belonging to this main window.

Definition at line 2600 of file KisMainWindow.cpp.

{
    return d->dockWidgetsMap.values();
}

References d.

◆ documentSaved

void KisMainWindow::documentSaved ( )

signal

This signal is emitted if the document has been saved successfully.

◆ dragLeave()

void KisMainWindow::dragLeave ( )

private

Definition at line 1805 of file KisMainWindow.cpp.

{
    if (d->tabSwitchCompressor->isActive()) {
        d->tabSwitchCompressor->stop();
    }
}

References d.

◆ dragLeaveEvent()

void KisMainWindow::dragLeaveEvent ( QDragLeaveEvent * event )

overrideprotected

Definition at line 1666 of file KisMainWindow.cpp.

{
    dragLeave();
    event->accept();
}

References dragLeave().

◆ dragMove()

void KisMainWindow::dragMove ( QDragMoveEvent * event )

private

Definition at line 1783 of file KisMainWindow.cpp.

{
    QTabBar *tabBar = d->findTabBarHACK();
 
    if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
        qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
    }
 
    if (tabBar && tabBar->isVisible()) {
        QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
        if (tabBar->rect().contains(pos)) {
            const int tabIndex = tabBar->tabAt(pos);
 
            if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                d->tabSwitchCompressor->start(tabIndex);
            }
        } else if (d->tabSwitchCompressor->isActive()) {
            d->tabSwitchCompressor->stop();
        }
    }
}

References d, and KXmlGuiWindow::event().

◆ dragMoveEvent()

void KisMainWindow::dragMoveEvent ( QDragMoveEvent * event )

overrideprotected

Definition at line 1660 of file KisMainWindow.cpp.

{
    dragMove(event);
    event->accept();
}

References dragMove(), and KXmlGuiWindow::event().

◆ findTabBarHACK()

QTabBar * KisMainWindow::findTabBarHACK ( )

inline

Definition at line 336 of file KisMainWindow.cpp.

                              {
        QObjectList objects = mdiArea->children();
        Q_FOREACH (QObject *object, objects) {
            QTabBar *bar = qobject_cast<QTabBar*>(object);
            if (bar) {
                return bar;
            }
        }
        return 0;
    }

◆ forceDockTabFonts

void KisMainWindow::forceDockTabFonts ( )

privateslot

Definition at line 2563 of file KisMainWindow.cpp.

{
    Q_FOREACH (QObject *child, children()) {
        if (child->inherits("QTabBar")) {
            ((QTabBar *)child)->setFont(KisUiFont::dockFont());
        }
    }
}

References KisUiFont::dockFont().

◆ guiLoadingFinished

void KisMainWindow::guiLoadingFinished ( )

signal

◆ hackIsSaving()

bool KisMainWindow::hackIsSaving ( ) const

Shows if the main window is saving anything right now. If the user presses Ctrl+W too fast, then the document can be close before the saving is completed. I'm not sure if it is fixable in any way without avoiding using processEvents() everywhere (DK)

Don't use it unless you have no option.

Definition at line 1285 of file KisMainWindow.cpp.

{
    std::unique_lock<QMutex> l(d->savingEntryMutex, std::try_to_lock);
    return !l.owns_lock();
}

References d.

◆ id()

QUuid KisMainWindow::id ( ) const

◆ importAnimation

void KisMainWindow::importAnimation ( )

privateslot

◆ importVideoAnimation

void KisMainWindow::importVideoAnimation ( )

privateslot

◆ initializeGeometry

void KisMainWindow::initializeGeometry ( )

privateslot

Definition at line 3251 of file KisMainWindow.cpp.

{
    // if the user didn's specify the geometry on the command line (does anyone do that still?),
    // we first figure out some good default size and restore the x,y position. See bug 285804Z.
    KConfigGroup cfg = d->windowStateConfig;
    QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
    if (!restoreGeometry(geom)) {
        QRect desk = this->screen()->availableGeometry();
 
        quint32 x = desk.x();
        quint32 y = desk.y();
        quint32 w = 0;
        quint32 h = 0;
 
        // Default size -- maximize on small screens, something useful on big screens
        const int deskWidth = desk.width();
        if (deskWidth > 1024) {
            // a nice width, and slightly less than total available
            // height to compensate for the window decs
            w = (deskWidth / 3) * 2;
            h = (desk.height() / 3) * 2;
        }
        else {
            w = desk.width();
            h = desk.height();
        }
 
        x += (desk.width() - w) / 2;
        y += (desk.height() - h) / 2;
 
        move(x,y);
        setGeometry(geometry().x(), geometry().y(), w, h);
    }
#ifdef Q_OS_ANDROID
    // We handle full-screening differently on Android, see viewFullScreen.
    bool fullScreen = KisAndroidUtils::isInFullScreen();
#else
    bool fullScreen = isFullScreen();
#endif
    d->fullScreenMode->setChecked(fullScreen);
}

References d, and KisAndroidUtils::isInFullScreen().

◆ installBundle()

bool KisMainWindow::installBundle ( const QString & fileName ) const

Copy the given file into the bundle directory.

Definition at line 1291 of file KisMainWindow.cpp.

{
    QFileInfo from(fileName);
    QFileInfo to(QStringLiteral("%1/%2").arg(KoResourcePaths::getAppDataLocation(), from.fileName()));
    if (to.exists()) {
        QFile::remove(to.canonicalFilePath());
    }
    return QFile::copy(fileName, to.absoluteFilePath());
}

References KoResourcePaths::getAppDataLocation().

◆ keyBindingsChanged

void KisMainWindow::keyBindingsChanged ( )

signal

This signal is emitted when the shortcut key configuration has changed.

◆ layoutThumbnail()

QImage KisMainWindow::layoutThumbnail ( )

layoutThumbnail

Returns: image for the workspaces.

Definition at line 1301 of file KisMainWindow.cpp.

{
    int size = 256;
    qreal scale = qreal(size)/qreal(qMax(geometry().width(), geometry().height()));
    QImage layoutThumbnail = QImage(qRound(geometry().width()*scale), qRound(geometry().height()*scale), QImage::Format_ARGB32);
    QPainter gc(&layoutThumbnail);
    gc.fillRect(0, 0, layoutThumbnail.width(), layoutThumbnail.height(), this->palette().dark());
 
    Q_FOREACH(const QObject *child, children()) {
        if (child->isWidgetType()) {
            const QWidget *w = static_cast<const QWidget *>(child);
 
            if (w->isVisible() && !w->property("_kis_excludeFromLayoutThumbnail").toBool()) {
                QRect wRect = QRectF(w->geometry().x()*scale
                                     , w->geometry().y()*scale
                                     , w->geometry().width()*scale
                                     , w->geometry().height()*scale
                                     ).toRect();
 
                wRect = wRect.intersected(layoutThumbnail.rect().adjusted(-1, -1, -1, -1));
 
                gc.setBrush(this->palette().window());
                if (w == d->widgetStack) {
                    gc.setBrush(d->mdiArea->background());
                }
                gc.setPen(this->palette().windowText().color());
                gc.drawRect(wRect);
            }
        }
    }
    gc.end();
    return layoutThumbnail;
}

References d, and layoutThumbnail().

◆ loadCompleted

void KisMainWindow::loadCompleted ( )

signal

This signal is emitted when this windows has finished loading of a document. The document may be opened in another window in the end. In this case, the signal means there is no link between the window and the document anymore.

◆ newOptionWidgets

void KisMainWindow::newOptionWidgets	(	KoCanvasController *	controller,
		const QList< QPointer< QWidget > > &	optionWidgetList )

slot

Update the option widgets to the argument ones, removing the currently set widgets.

Definition at line 3042 of file KisMainWindow.cpp.

{
    KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
    bool isOurOwnView = false;
 
    Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
        if (view && view->canvasController() == controller) {
            isOurOwnView = view->mainWindow() == this;
        }
    }
 
    if (!isOurOwnView) return;
 
    Q_FOREACH (QWidget *w, optionWidgetList) {
#ifdef Q_OS_MACOS
        w->setAttribute(Qt::WA_MacSmallSize, true);
#endif
        w->setFont(KisUiFont::dockFont());
    }
 
    if (d->toolOptionsDocker) {
        d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
    }
    else {
        d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
    }
}

References d, KisUiFont::dockFont(), KoToolManager::instance(), KisPart::instance(), and KIS_ASSERT_RECOVER_NOOP.

◆ newView

KisView * KisMainWindow::newView	(	QObject *	document,
		QMdiSubWindow *	subWindow = 0 )

slot

Definition at line 2968 of file KisMainWindow.cpp.

{
    KisDocument *doc = qobject_cast<KisDocument*>(document);
    KisView *view = addViewAndNotifyLoadingCompleted(doc, subWindow);
    d->actionManager()->updateGUI();
 
    return view;
}

References addViewAndNotifyLoadingCompleted(), and d.

◆ newWindow

void KisMainWindow::newWindow ( )

privateslot

◆ notifyChildViewDestroyed

void KisMainWindow::notifyChildViewDestroyed ( KisView * view )

slot

If we are the last view of the window, Qt will not activate another tab before destroying tab/window. In this case we should clear all the dangling pointers manually by setting the current view to null

Definition at line 759 of file KisMainWindow.cpp.

{
    viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
    if (view->canvasBase() == viewManager()->canvasBase()) {
        viewManager()->setCurrentView(0);
    }
}

References KisView::canvasBase(), KisViewManager::inputManager(), KisInputManager::removeTrackedCanvas(), KisViewManager::setCurrentView(), and viewManager.

◆ openCommandBar

void KisMainWindow::openCommandBar ( )

privateslot

Definition at line 2058 of file KisMainWindow.cpp.

{
    QList<KisKActionCollection *> actionCollections;
 
    auto clients = guiFactory()->clients();
    int actionsCount = 0;
    for (const KisKXMLGUIClient *c : clients) {
        if (!c) {
            continue;
        }
        if (auto collection = c->actionCollection()) {
            actionCollections.append(collection);
            actionsCount += collection->count();
        }
    }
 
    if (activeKisView()) {
        KisKActionCollection *layerActionCollection = new KisKActionCollection(0, "layeractions (disposable)");
        layerActionCollection->setComponentDisplayName(i18n("Layers/Masks"));
        KisNodeActivationActionCreatorVisitor v(layerActionCollection, viewManager()->nodeManager());
        activeKisView()->image()->rootLayer()->accept(v);
        actionCollections.append(layerActionCollection);
        actionsCount += layerActionCollection->count();
    }
 
    d->commandBar->updateBar(actionCollections, actionsCount);
 
    // The following line is needed to work around input method not working
    // on Windows.
    // See https://bugs.kde.org/show_bug.cgi?id=395598
    // and https://bugs.kde.org/show_bug.cgi?id=438122
    d->commandBar->activateWindow();
 
    // The following line is present in Kate's version and was ported over
    // but I am sceptical of its use. I worry that it may subtly cause other
    // issues, and since the command bar appears to work fine without it, I
    // believe it may be better to leave it out.  -- Alvin
    // centralWidget()->setFocusProxy(d->commandBar);
}

References activeKisView(), KisKXMLGUIFactory::clients(), KisKActionCollection::count(), d, KXmlGuiWindow::guiFactory(), KisKActionCollection::setComponentDisplayName(), v, and viewManager.

◆ openDocument()

bool KisMainWindow::openDocument	(	const QString &	path,
		OpenFlags	flags )

Load the desired document and show it.

Parameters

url	the URL to open

Returns: TRUE on success.

Definition at line 1112 of file KisMainWindow.cpp.

{
    ScopedWidgetDisabler disabler(d->welcomePage->dropFrameBorder);
    QApplication::processEvents(); // make UI more responsive
 
    if (!QFile(path).exists()) {
        if (!(flags & BatchMode)) {
            QMessageBox::critical(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", path));
        }
        KisRecentFilesManager::instance()->remove(QUrl::fromLocalFile(path)); //remove the file from the recent-opened-file-list
        return false;
    }
    return openDocumentInternal(path, flags);
}

References BatchMode, d, KisRecentFilesManager::instance(), openDocumentInternal(), and KisRecentFilesManager::remove().

◆ openDocumentInternal()

bool KisMainWindow::openDocumentInternal	(	const QString &	path,
		KisMainWindow::OpenFlags	f = KisMainWindow::OpenFlags() )

private

Definition at line 1127 of file KisMainWindow.cpp.

{
    if (!QFile(path).exists()) {
        qWarning() << "KisMainWindow::openDocumentInternal. Could not open:" << path;
        return false;
    }
 
    KisDocument *newdoc = KisPart::instance()->createDocument();
 
    if (flags & BatchMode) {
        newdoc->setFileBatchMode(true);
    }
 
    d->firstTime = true;
    connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
    connect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
    KisDocument::OpenFlags openFlags = KisDocument::None;
    // XXX: Why this duplication of OpenFlags...
    if (flags & RecoveryFile) {
        openFlags |= KisDocument::RecoveryFile;
    }
 
    bool openRet = !(flags & Import) ? newdoc->openPath(path, openFlags) : newdoc->importDocument(path);
 
    if (!openRet) {
        delete newdoc;
        return false;
    }
 
    KisPart::instance()->addDocument(newdoc);
 
    // Try to determine whether this was an unnamed autosave
    if (flags & RecoveryFile &&
            (   path.startsWith(QDir::tempPath())
                || path.startsWith(QDir::homePath())
                ) &&
            (      QFileInfo(path).fileName().startsWith(".krita")
                   || QFileInfo(path).fileName().startsWith("krita")
                   )
            )
    {
        QString path = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
        if (!QFileInfo(path).exists()) {
            path = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
        }
        newdoc->setPath(path + "/" + newdoc->objectName() + ".kra");
    }
 
    return true;
}

References KisPart::addDocument(), BatchMode, KisPart::createDocument(), d, Import, KisDocument::importDocument(), KisPart::instance(), KisDocument::None, KisDocument::openPath(), KisDocument::RecoveryFile, RecoveryFile, KisDocument::setFileBatchMode(), KisDocument::setPath(), slotLoadCanceled(), and slotLoadCompleted().

◆ orientationChanged

void KisMainWindow::orientationChanged ( )

privateslot

Definition at line 3317 of file KisMainWindow.cpp.

{
    QScreen *screen = QGuiApplication::primaryScreen();
 
    for (QWindow* window: QGuiApplication::topLevelWindows()) {
        // Android: we shouldn't transform Window managers independent of its child
        if ((window->type() == Qt::Popup)
            && (window->flags() & Qt::FramelessWindowHint) == 0
            && (window->geometry().topLeft() != QPoint(0, 0))) {
            // We are using reversed values. Because geometry returned is not the updated
            // one, but the previous one.
            int screenHeight = screen->geometry().width();
            int screenWidth = screen->geometry().height();
 
            // scaling
            int new_x = (window->position().x() * screenWidth) / screenHeight;
            int new_y = (window->position().y() * screenHeight) / screenWidth;
 
            // window width or height shouldn't change
            int winWidth = window->geometry().width();
            int winHeight = window->geometry().height();
 
            // Try best to not let the window go beyond screen.
            if (new_x > screenWidth - winWidth) {
                new_x = screenWidth - winWidth;
                if (new_x < 0)
                    new_x = 0;
            }
            if (new_y > screenHeight - winHeight) {
                new_y = screenHeight - winHeight;
                if (new_y < 0)
                    new_y = 0;
            }
 
            window->setPosition(QPoint(new_x, new_y));
        }
    }
}

◆ Private()

KisMainWindow::Private	(	KisMainWindow *	parent,
		QUuid	id )

inline

Definition at line 193 of file KisMainWindow.cpp.

        : q(parent)
        , id(id)
        , styleMenu(new KActionMenu(i18nc("@action:inmenu", "Styles"), parent))
        , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
        , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
        , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
        , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
        , welcomePage(new KisWelcomePageWidget(parent))
        , widgetStack(new QStackedWidget(parent))
        , mdiArea(new QMdiArea(parent))
        , windowMapper(new KisSignalMapper(parent))
        , documentMapper(new KisSignalMapper(parent))
    {
        if (id.isNull()) this->id = QUuid::createUuid();
 
        welcomeScroller = new QScrollArea();
        welcomeScroller->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
        welcomeScroller->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
        welcomeScroller->setWidget(welcomePage);
        welcomeScroller->setWidgetResizable(true);
 
        widgetStack->addWidget(welcomeScroller);
        widgetStack->addWidget(mdiArea);
        mdiArea->setTabsMovable(true);
        mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
        mdiArea->setDocumentMode(true);
        mdiArea->setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
#ifdef HAVE_QMDIAREA_ALWAYS_SHOW_SUBWINDOW_TITLE
        mdiArea->setOption(QMdiArea::AlwaysShowSubwindowNameInTitleBar);
#endif /* HAVE_QMDIAREA_ALWAYS_SHOW_SUBWINDOW_TITLE */
 
        commandBar = new KateCommandBar(parent);
    }

◆ redo

void KisMainWindow::redo ( )

privateslot

◆ removeRecentFile

void KisMainWindow::removeRecentFile ( QString url )

slot

remove one file from the list of the recent files

Definition at line 1081 of file KisMainWindow.cpp.

{
    KisRecentFilesManager::instance()->remove(QUrl::fromLocalFile(url));
}

References KisRecentFilesManager::instance(), and KisRecentFilesManager::remove().

◆ renderAnimation

void KisMainWindow::renderAnimation ( )

privateslot

◆ renderAnimationAgain

void KisMainWindow::renderAnimationAgain ( )

privateslot

◆ resizeEvent()

void KisMainWindow::resizeEvent ( QResizeEvent * e )

overrideprotected

Definition at line 1653 of file KisMainWindow.cpp.

{
    d->windowSizeDirty = true;
    KXmlGuiWindow::resizeEvent(e);
}

References d.

◆ resourceManager()

KoCanvasResourceProvider * KisMainWindow::resourceManager ( ) const

Definition at line 1965 of file KisMainWindow.cpp.

{
    return d->viewManager->canvasResourceProvider()->resourceManager();
}

References d.

◆ restoreWorkspace [1/2]

void KisMainWindow::restoreWorkspace ( )

privateslot

Definition at line 2045 of file KisMainWindow.cpp.

{
    QString md5 = sender()->property("md5").toString();
    KoResourceServer<KisWorkspaceResource> *rserver = KisResourceServerProvider::instance()->workspaceServer();
    KoResourceSP resource = rserver->resource(md5, "", "");
    if (resource) {
        restoreWorkspace(resource);
    }
    else {
        qWarning() << "Could not retrieve resource for" << md5;
    }
}

References KisResourceServerProvider::instance(), KoResourceServer< T >::resource(), restoreWorkspace(), and KisResourceServerProvider::workspaceServer().

◆ restoreWorkspace() [2/2]

bool KisMainWindow::restoreWorkspace ( KoResourceSP res )

A wrapper around restoreState

Parameters

state the saved state

Returns: TRUE on success

Definition at line 2121 of file KisMainWindow.cpp.

{
    KisWorkspaceResourceSP workspace = res.dynamicCast<KisWorkspaceResource>();
 
    bool success = restoreWorkspaceState(workspace->dockerState());
 
    const bool showTitlebars = KisConfig(false).showDockerTitleBars();
    Q_FOREACH (QDockWidget *dock, dockWidgets()) {
        if (dock->titleBarWidget() && !dock->titleBarWidget()->inherits("KisUtilityTitleBar")) {
            dock->titleBarWidget()->setVisible(showTitlebars || dock->isFloating());
        }
    }
 
    if (activeKisView()) {
        activeKisView()->resourceProvider()->notifyLoadingWorkspace(workspace);
    }
 
    d->viewManager->notifyWorkspaceLoaded();
 
    return success;
}

References activeKisView(), d, dockWidgets(), restoreWorkspaceState(), and KisConfig::showDockerTitleBars().

◆ restoreWorkspaceState()

bool KisMainWindow::restoreWorkspaceState ( const QByteArray & state )

Definition at line 2014 of file KisMainWindow.cpp.

{
    QByteArray oldState = saveState();
    const bool showTitlebars = KisConfig(false).showDockerTitleBars();
 
    // needed because otherwise the layout isn't correctly restored in some situations
    Q_FOREACH (QDockWidget *dock, dockWidgets()) {
        if (dock) {
            dock->setProperty("Locked", false); // Unlock invisible dockers
            dock->toggleViewAction()->setEnabled(true);
            dock->hide();
            if (dock->titleBarWidget() && !dock->titleBarWidget()->inherits("KisUtilityTitleBar")) {
                dock->titleBarWidget()->setVisible(showTitlebars);
            }
        }
    }
 
    bool success = KXmlGuiWindow::restoreState(state);
 
    if (!success) {
        KXmlGuiWindow::restoreState(oldState);
        Q_FOREACH (QDockWidget *dock, dockWidgets()) {
            if (dock->titleBarWidget() && !dock->titleBarWidget()->inherits("KisUtilityTitleBar")) {
                dock->titleBarWidget()->setVisible(showTitlebars || dock->isFloating());
            }
        }
        return false;
    }
    return success;
}

References dockWidgets(), and KisConfig::showDockerTitleBars().

◆ restoringDone

void KisMainWindow::restoringDone ( )

signal

This signal is emitted right after the docker states have been successfully restored from config.

◆ saveDocument()

bool KisMainWindow::saveDocument	(	KisDocument *	document,
		bool	saveas,
		bool	isExporting,
		bool	isAdvancedExporting = false )

Saves the document, asking for a filename if necessary.

Parameters

saveas	if set to TRUE the user is always prompted for a filename
silent	if set to TRUE rootDocument()->setTitleModified will not be called.

Returns: TRUE on success, false on error or cancel (don't display anything in this case, the error dialog box is also implemented here but restore the original URL in slotFileSaveAs)

Make sure that we cannot enter this method twice!

The lower level functions may call processEvents() so double-entry is quite possible to achieve. Here we try to lock the mutex, and if it is failed, just cancel saving.

Definition at line 1335 of file KisMainWindow.cpp.

{
    if (!document) {
        return true;
    }
 
    std::unique_lock<QMutex> l(d->savingEntryMutex, std::try_to_lock);
    if (!l.owns_lock()) return false;
 
    // no busy wait for saving because it is dangerous!
    KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
    dlg.blockIfImageIsBusy();
 
    if (dlg.result() == KisDelayedSaveDialog::Rejected) {
        return false;
    }
    else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
        QMessageBox::critical(qApp->activeWindow(),
                              i18nc("@title:window", "Krita"),
                              i18n("You are saving a file while the image is "
                                   "still rendering. The saved file may be "
                                   "incomplete or corrupted.\n\n"
                                   "Please select a location where the original "
                                   "file will not be overridden!"));
 
 
        saveas = true;
    }
 
    if (document->isRecovered()) {
        saveas = true;
    }
 
    if (document->path().isEmpty()) {
        saveas = true;
    }
 
    QFile target(document->path());
    if (!target.exists()) { // Possible when file is moved/unmounted during Krita session.
        saveas = true;
    }
 
    connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
    connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
    QByteArray nativeFormat = document->nativeFormatMimeType();
    QByteArray oldMimeFormat = document->mimeType();
 
    QUrl suggestedURL = QUrl::fromLocalFile(document->path());
 
    QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
    mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
    if (!mimeFilter.contains(oldMimeFormat)) {
        dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
        // --- don't setOutputMimeType in case the user cancels the Save As
        // dialog and then tries to just plain Save ---
 
        // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
        QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
 
        if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
            suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
            suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
            suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
        }
 
        // force the user to choose outputMimeType
        saveas = true;
    }
 
    bool ret = false;
 
    if (document->path().isEmpty() || isExporting || saveas) {
        // if you're just File/Save As'ing to change filter options you
        // don't want to be reminded about overwriting files etc.
        bool justChangingFilterOptions = false;
 
        KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
        dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
        //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
        if (isExporting && !d->lastExportLocation.isEmpty() && !d->lastExportLocation.contains(QDir::tempPath())) {
 
            // Use the location where we last exported to, if it's set, as the opening location for the file dialog
            QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
            // If the document doesn't have a filename yet, use the title
            QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
            // Use the last mimetype we exported to by default
            QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
            QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
            // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
            dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
            dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
        }
        else { 
            //This section only runs when the user haven't exported yet during the session, behavior set in the File Handling, Default MimeType setting.
            KisConfig cfg(true);
            QByteArray default_mime_type = cfg.exportMimeType(false).toUtf8();
            QString proposedMimeType = QString::fromLatin1(default_mime_type);
 
            // Get the last used location for saving
            KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
            QString proposedPath = group.readEntry("SaveAs", "");
            // if that is empty, get the last used location for loading
            if (proposedPath.isEmpty()) {
                proposedPath = group.readEntry("OpenDocument", "");
            }
            // If that is empty, too, use the Pictures location.
            if (proposedPath.isEmpty()) {
                proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
            }
            // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
            // open the location where the document currently is.
 
            //For if the user picked All Files Supported as the default, where there would not be an extension
            if(default_mime_type == "all/mime"){
                dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : proposedPath + "/" + QFileInfo(suggestedURL.toLocalFile()).completeBaseName(), true);
            }
 
            if (default_mime_type != "all/mime" && !default_mime_type.isEmpty()) {
                QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
                //This line is responsible for setting filename, which also manipulates filters.
                dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath :  proposedPath + "/" + QFileInfo(suggestedURL.toLocalFile()).completeBaseName() + "." + proposedExtension, true);
            }
 
            if (!isExporting) {
                // If Saving, use the document's mimetype, or if that is empty, kra, which is the safest.
                dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
                default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
            }
            dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
        }
 
        QString newFilePath = dialog.filename();
 
        bool bOk = true;
        if (newFilePath.isEmpty()) {
            bOk = false;
        }
 
        if (bOk) {
            if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
                QString fn = newFilePath;
                QFileInfo info(fn);
                document->documentInfo()->setAboutInfo("title", info.completeBaseName());
            }
 
            QByteArray outputFormat = nativeFormat;
 
            QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newFilePath, false);
            outputFormat = outputFormatString.toLatin1();
 
 
            if (!isExporting) {
                justChangingFilterOptions = (newFilePath == document->path()) && (outputFormat == document->mimeType());
            }
            else {
                QString path = QFileInfo(d->lastExportLocation).absolutePath();
                QString filename = QFileInfo(document->path()).completeBaseName();
                justChangingFilterOptions = (QFileInfo(newFilePath).absolutePath() == path)
                        && (QFileInfo(newFilePath).completeBaseName() == filename)
                        && (outputFormat == d->lastExportedFormat);
            }
 
            bool wantToSave = true;
 
            // don't change this line unless you know what you're doing :)
            if (!justChangingFilterOptions) {
                if (!document->isNativeFormat(outputFormat))
                    wantToSave = true;
            }
 
            if (wantToSave) {
                if (!isExporting) {  // Save As
                    ret = document->saveAs(newFilePath, outputFormat, true);
                    if (ret) {
                        dbgUI << "Successful Save As!";
                        KisPart::instance()->queueAddRecentURLToAllMainWindowsOnFileSaved(QUrl::fromLocalFile(newFilePath));
                    } else {
                        dbgUI << "Failed Save As!";
 
                    }
                }
                else { // Export
                    ret = document->exportDocument(newFilePath, outputFormat, isAdvancedExporting, false);
                    if (ret) {
                        d->lastExportLocation = newFilePath;
                        d->lastExportedFormat = outputFormat;
                    }
                }
 
            }   // if (wantToSave)  {
            else
                ret = false;
        }   // if (bOk) {
        else
            ret = false;
    } else { // saving
        // We cannot "export" into the currently
        // opened document. We are not Gimp.
        KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
        // be sure document has the correct outputMimeType!
        if (document->isModified()) {
            ret = document->save(true, 0);
        }
 
        if (!ret) {
            dbgUI << "Failed Save!";
        }
    }
 
    return ret;
}

References KisDelayedSaveDialog::blockIfImageIsBusy(), d, dbgUI, KisImportExportManager::Export, KisConfig::exportMimeType(), KisDelayedSaveDialog::Ignored, KisPart::instance(), KIS_ASSERT_RECOVER_NOOP, KIS_MIME_TYPE, KisMimeDatabase::mimeTypeForFile(), KisPart::queueAddRecentURLToAllMainWindowsOnFileSaved(), KisDelayedSaveDialog::Rejected, KisDelayedSaveDialog::SaveDialog, KoFileDialog::SaveFile, slotSaveCanceled(), slotSaveCompleted(), KisMimeDatabase::suffixesForMimeType(), KisImportExportManager::supportedMimeTypes(), and target().

◆ saveWindowSettings()

void KisMainWindow::saveWindowSettings ( )

private

Definition at line 1613 of file KisMainWindow.cpp.

{
    KSharedConfigPtr config =  KSharedConfig::openConfig();
 
    if (d->windowSizeDirty ) {
        dbgUI << "KisMainWindow::saveWindowSettings";
        KConfigGroup group = d->windowStateConfig;
        KWindowConfig::saveWindowSize(windowHandle(), group);
        config->sync();
        d->windowSizeDirty = false;
    }
 
    if (!d->activeView || d->activeView->document()) {
 
        // Save toolbar position into the config file of the app, under the doc's component name
        KConfigGroup group = d->windowStateConfig;
        saveMainWindowSettings(group);
 
        // Save state of dock widgets
        for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
             i != d->dockWidgetsMap.constEnd(); ++i) {
            if (i.value()->widget()) {
                KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                dockGroup.writeEntry("height", (int) i.value()->widget()->height());
            }
        }
 
    }
 
    KSharedConfig::openConfig()->sync();
    resetAutoSaveSettings(); // Don't let KisKMainWindow override the good stuff we wrote down
 
}

References d, dbgUI, KisKMainWindow::resetAutoSaveSettings(), and KisKMainWindow::saveMainWindowSettings().

◆ saveWindowState()

void KisMainWindow::saveWindowState ( bool restoreNormalState = false )

Definition at line 1980 of file KisMainWindow.cpp.

{
    // We don't need to save welcome page's layout
    if (d->widgetStack->currentIndex() == 0) {
        // TODO(sh_zam): We should still save position/geometry, right?
        return;
    }
 
    if (restoreNormalState) {
        QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
        if (showCanvasOnly && showCanvasOnly->isChecked()) {
            showCanvasOnly->setChecked(false);
        }
 
        d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
        d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
        // if the dockers are hidden at this time, save their state.
        if (!d->toggleDockers->isChecked()) {
            restoreState(d->dockerStateBeforeHiding);
        }
 
        statusBar()->setVisible(true);
        menuBar()->setVisible(true);
 
        saveWindowSettings();
 
    } else {
        saveMainWindowSettings(d->windowStateConfig);
    }
 
}

References d, KisKMainWindow::saveMainWindowSettings(), and saveWindowSettings().

◆ setActiveSubWindow

void KisMainWindow::setActiveSubWindow ( QWidget * window )

privateslot

Definition at line 2878 of file KisMainWindow.cpp.

{
    if (!window) {
        unsetActiveView();
        return;
    }
    QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
    //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
    if (subwin && subwin != d->activeSubWindow) {
        KisView *view = qobject_cast<KisView *>(subwin->widget());
        //dbgKrita << "\t" << view << activeView();
        if (view && view != activeView()) {
            setActiveView(view);
        }
        d->activeSubWindow = subwin;
    }
    updateWindowMenu();
    d->actionManager()->updateGUI();
}

References activeView, d, setActiveView(), unsetActiveView(), and updateWindowMenu().

◆ setActiveView

void KisMainWindow::setActiveView ( KisView * view )

slot

Set the active view, this will update the undo/redo actions.

Definition at line 1751 of file KisMainWindow.cpp.

{
    d->activeView = view;
 
    if (d->undoActionsUpdateManager) {
        d->undoActionsUpdateManager->setCurrentDocument(view ? view->document() : 0);
    }
 
    d->viewManager->setCurrentView(view);
 
    d->activeViewConnections.clear();
    d->activeViewConnections.addConnection(view->document(),
                                           SIGNAL(sigPathChanged(QString)),
                                           this, SLOT(slotUpdateSaveActionTitle(QString)));
    slotUpdateSaveActionTitle(view->document()->path());
    d->activeViewConnections.addConnection(view->document(),
                                           SIGNAL(sigReadWriteChanged(bool)),
                                           this, SLOT(slotUpdateReadWriteMode(bool)));
    slotUpdateReadWriteMode(view->document()->isReadWrite());
 
    KisWindowLayoutManager::instance()->activeDocumentChanged(view->document());
 
    Q_EMIT activeViewChanged();
}

References KisWindowLayoutManager::activeDocumentChanged(), activeViewChanged(), d, KisView::document, KisWindowLayoutManager::instance(), slotUpdateReadWriteMode(), and slotUpdateSaveActionTitle().

◆ setCanvasDetached

void KisMainWindow::setCanvasDetached ( bool detached )

slot

Detach canvas onto a separate window, or restore it back to to main window.

Definition at line 1045 of file KisMainWindow.cpp.

{
#ifdef Q_OS_ANDROID
    if (detach) {
        QMessageBox::warning(this, i18nc("@title:window", "Krita"),
                             "Detach Canvas is unsupported on Android");
    }
#else
    if (detach == canvasDetached()) return;
 
    QWidget *outgoingWidget = centralWidget() ? takeCentralWidget() : nullptr;
    QWidget *incomingWidget = d->canvasWindow->swapMainWidget(outgoingWidget);
 
    if (incomingWidget) {
        setCentralWidget(incomingWidget);
    }
 
    if (detach) {
        d->canvasWindow->show();
    } else {
        d->canvasWindow->hide();
    }
    d->toggleDetachCanvas->setChecked(detach);
#endif
}

References canvasDetached(), and d.

◆ setMainWindowLayoutForCurrentMainWidget()

void KisMainWindow::setMainWindowLayoutForCurrentMainWidget	(	int	widgetIndex,
		bool	widgetIndexChanged )

private

save the state of the window which existed up-to now (this is before we stop auto-saving).

saving should happen if the call s has come from a real state change, but not from on-startup initialization

When closing the latest subwindow we should restore the canvas-only mode to save stuff properly

Definition at line 1697 of file KisMainWindow.cpp.

{
 
    if (widgetIndex == 0) {
        if (widgetIndexChanged) {
 
            if (d->mdiArea->subWindowList().isEmpty()) {
                saveWindowState(true);
            } else {
                saveMainWindowSettings(d->windowStateConfig);
            }
        }
        adjustLayoutForWelcomePage();
    }
    else {
        setAutoSaveSettings(d->windowStateConfig, false);
        statusBar()->setVisible(KisConfig(true).showStatusBar());
    }
 
    QList<QAction *> actions = d->dockWidgetMenu->menu()->actions();
    actions.append(toolBarMenuAction()->menu()->actions());
    for (QAction *action : actions) {
        if (action) {
            action->setEnabled(widgetIndex);
        }
    }
}

References KisKXMLGUIClient::action(), adjustLayoutForWelcomePage(), d, KisKMainWindow::saveMainWindowSettings(), saveWindowState(), KisKMainWindow::setAutoSaveSettings(), and KXmlGuiWindow::toolBarMenuAction().

◆ showAboutApplication

void KisMainWindow::showAboutApplication ( )

privatevirtualslot

showAboutApplication show the about box

Definition at line 3027 of file KisMainWindow.cpp.

{
    KisAboutApplication dlg(this);
    dlg.exec();
}

◆ showDockerTitleBars

void KisMainWindow::showDockerTitleBars ( bool show )

privateslot

Toggle docker titlebars on/off.

Definition at line 3298 of file KisMainWindow.cpp.

{
    Q_FOREACH (QDockWidget *dock, dockWidgets()) {
        if (dock->titleBarWidget() && !dock->titleBarWidget()->inherits("KisUtilityTitleBar")) {
            dock->titleBarWidget()->setVisible(show || dock->isFloating());
        }
    }
 
    KisConfig cfg(true);
    cfg.setShowDockerTitleBars(show);
}

References dockWidgets(), and KisConfig::setShowDockerTitleBars().

◆ showDocument()

void KisMainWindow::showDocument ( KisDocument * document )

Activate a view containing the document in this window, creating one if needed.

Definition at line 1179 of file KisMainWindow.cpp.

                                                      {
    Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
        KisView *view = qobject_cast<KisView*>(subwindow->widget());
        KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
        if (view) {
            if (view->document() == document) {
                setActiveSubWindow(subwindow);
                return;
            }
        }
    }
 
    addViewAndNotifyLoadingCompleted(document);
}

References addViewAndNotifyLoadingCompleted(), d, KisView::document, KIS_SAFE_ASSERT_RECOVER_NOOP, and setActiveSubWindow().

◆ showErrorAndDie

void KisMainWindow::showErrorAndDie ( )

privateslot

Quits Krita with error message from m_errorMessage.

Definition at line 3019 of file KisMainWindow.cpp.

{
    QMessageBox::critical(qApp->activeWindow(), i18nc("@title:window", "Installation error"), m_errorMessage);
    if (m_dieOnError) {
        exit(10);
    }
}

References m_dieOnError, and m_errorMessage.

◆ showEvent()

void KisMainWindow::showEvent ( QShowEvent * event )

overrideprotected

Definition at line 1678 of file KisMainWindow.cpp.

{
    // we're here because, we need to make sure everything (dockers, toolbars etc) is loaded and ready before
    // we can hide it.
    if (!event->spontaneous()) {
        setMainWindowLayoutForCurrentMainWidget(d->widgetStack->currentIndex(), false);
    }
#ifdef Q_OS_ANDROID
    // The user can conceivably purchase a product from the splash screen while
    // Krita is still loading. In that case, the "pending" flag will be set. The
    // dialog in question will clear the flag.
    KisAndroidDonations *androidDonations = KisAndroidDonations::instance();
    if (androidDonations && androidDonations->isShowDonationManagementDialogPending()) {
        QTimer::singleShot(0, this, &KisMainWindow::slotShowDonationManagementDialog);
    }
#endif
    return KXmlGuiWindow::showEvent(event);
}

References d, KXmlGuiWindow::event(), KisAndroidDonations::instance(), KisAndroidDonations::isShowDonationManagementDialogPending(), and setMainWindowLayoutForCurrentMainWidget().

◆ showManual

void KisMainWindow::showManual ( )

privateslot

Definition at line 3293 of file KisMainWindow.cpp.

{
    QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
}

◆ showOpenFileDialog()

QStringList KisMainWindow::showOpenFileDialog ( bool isImporting )

Definition at line 1223 of file KisMainWindow.cpp.

{
    KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
    dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
    dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
    QStringList filenames = dialog.filenames();
    filenames.sort();
 
    return filenames;
}

References KisImportExportManager::Import, KoFileDialog::ImportFiles, and KisImportExportManager::supportedMimeTypes().

◆ showView()

void KisMainWindow::showView	(	KisView *	view,
		QMdiSubWindow *	subWindow = 0 )

virtual

showView shows the given view, in subWindow if not null, in a new tab otherwise.

We set Qt::WA_DontCreateNativeAncestors in KisOpenGLCanvas2, so the parents will not receive native surfaces automatically. That is a problem for MDI-subwindows, since they may overlap. This overlapping cannot be resolved when the MDI-subwindow is an alien widget, but the wrapped widget is a native widget. The docorations of any subwindow will always be lower than the content of any of the subwindows.

Therefore we explicitly create a native surface for every MDI-subwindow.

Hack alert!

Here we explicitly request KoToolManager to Q_EMIT all the tool activation signals, to reinitialize the tool options docker.

That is needed due to a design flaw we have in the initialization procedure. The tool in the KoToolManager is initialized in KisView::setViewManager() calls, which happens early enough. During this call the tool manager requests KoCanvasControllerWidget to Q_EMIT the signal to update the widgets in the tool docker. But at that moment of time the view is not yet connected to the main window, because it happens in KisViewManager::setCurrentView a bit later. This fact makes the widgets updating signals be lost and never reach the tool docker.

So here we just explicitly call the tool activation stub.

Definition at line 773 of file KisMainWindow.cpp.

{
    if (imageView && activeView() != imageView) {
        // XXX: find a better way to initialize this!
        imageView->setViewManager(d->viewManager);
 
        imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
        imageView->slotLoadingFinished();
 
        if (!subwin) {
            QMdiSubWindow *currentSubWin = d->mdiArea->currentSubWindow();
            bool shouldMaximize = currentSubWin ? currentSubWin->isMaximized() : true;
            subwin = d->mdiArea->addSubWindow(imageView);
 
            const bool osManagedSurfacePresent = KisPlatformPluginInterfaceFactory::instance()->surfaceColorManagedByOS();
            const bool useNativeSurfaceForCanvas = KisConfig(true).effectiveShouldUseNativeSurfaceForCanvas(osManagedSurfacePresent);
            if (useNativeSurfaceForCanvas) {
                subwin->setAttribute(Qt::WA_DontCreateNativeAncestors);
                subwin->setAttribute(Qt::WA_NativeWindow);
            }
 
            if (shouldMaximize) {
                subwin->setWindowState(Qt::WindowMaximized);
            }
        } else {
            subwin->setWidget(imageView);
        }
        imageView->setSubWindow(subwin);
        subwin->setAttribute(Qt::WA_DeleteOnClose, true);
        connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
        KisConfig cfg(true);
        subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
        subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
        subwin->setWindowIcon(qApp->windowIcon());
 
#ifdef Q_OS_MACOS
        connect(subwin, SIGNAL(destroyed()), SLOT(updateSubwindowFlags()));
        updateSubwindowFlags();
#endif
 
        if (d->mdiArea->subWindowList().size() == 1) {
            imageView->showMaximized();
        }
        else {
            imageView->show();
        }
 
        KoToolManager::instance()->initializeCurrentToolForCanvas();
 
        // No, no, no: do not try to call this _before_ the show() has
        // been called on the view; only when that has happened is the
        // opengl context active, and very bad things happen if we tell
        // the dockers to update themselves with a view if the opengl
        // context is not active.
        setActiveView(imageView);
 
        updateWindowMenu();
    } else {
        unsetActiveView();
    }
}

References activeView, KisView::canvasBase(), d, KisConfig::effectiveShouldUseNativeSurfaceForCanvas(), KoToolManager::initializeCurrentToolForCanvas(), KoToolManager::instance(), KisPlatformPluginInterfaceFactory::instance(), KisConfig::readEntry(), setActiveView(), KisCanvas2::setFavoriteResourceManager(), KisView::setSubWindow(), KisView::setViewManager(), KisView::slotLoadingFinished(), KisPlatformPluginInterfaceFactory::surfaceColorManagedByOS(), unsetActiveView(), updateSubwindowFlags(), updateWindowMenu(), and KisConfig::useOpenGL().

◆ showWelcomeScreen()

void KisMainWindow::showWelcomeScreen ( bool show )

Toggles between showing the welcome screen and the MDI area

hack: There seems to be a bug that prevents events happening to the MDI area if it isn't actively displayed (set in the widgetStack). This can cause things like the title bar not to update correctly Before doing any actions related to opening or creating documents, make sure to switch this first to make sure everything can communicate to the MDI area correctly

Definition at line 1821 of file KisMainWindow.cpp.

{
    const int currentIndex = show ? 0 : 1;
    if (d->widgetStack->currentIndex() != currentIndex) {
        setUpdatesEnabled(false);
        // These have to be done in different sequence to avoid graphical
        // layout glitch during the switch.
        if (show) {
            setMainWindowLayoutForCurrentMainWidget(currentIndex, true);
            d->widgetStack->setCurrentIndex(currentIndex);
        } else {
            d->widgetStack->setCurrentIndex(currentIndex);
            setMainWindowLayoutForCurrentMainWidget(currentIndex, true);
        }
        setUpdatesEnabled(true);
    }
}

References d, and setMainWindowLayoutForCurrentMainWidget().

◆ slotChangeInterfaceScale

void KisMainWindow::slotChangeInterfaceScale ( )

slot

Definition at line 1884 of file KisMainWindow.cpp.

{
#if defined(Q_OS_ANDROID) && KRITA_QT_HAS_ANDROID_QPLATFORMSCREEN_DENSITY_ADJUSTMENT
    KisAndroidScaling *androidScaling = KisAndroidScaling::instance();
    if (androidScaling) {
        androidScaling->showDialog();
    }
#endif
}

References KisAndroidScaling::instance(), and KisAndroidScaling::showDialog().

◆ slotConfigureToolbars

void KisMainWindow::slotConfigureToolbars ( )

privateslot

Configure toolbars.

Definition at line 2386 of file KisMainWindow.cpp.

{
    saveWindowState();
    KisKEditToolBar edit(factory(), this);
    connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
    (void) edit.exec();
    applyToolBarLayout();
}

References applyToolBarLayout(), KisKXMLGUIClient::factory(), saveWindowState(), slotNewToolbarConfig(), and void().

◆ slotDocumentInfo

void KisMainWindow::slotDocumentInfo ( )

privateslot

Show a dialog with author and document information.

Definition at line 2183 of file KisMainWindow.cpp.

{
    if (!d->activeView->document())
        return;
 
    KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
    if (!docInfo)
        return;
 
    KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
    if (dlg->exec()) {
        if (dlg->isDocumentSaved()) {
            d->activeView->document()->setModified(false);
        } else {
            d->activeView->document()->setModified(true);
        }
    }
 
    delete dlg;
}

References d, and KoDocumentInfoDlg::isDocumentSaved().

◆ slotExportAdvance

void KisMainWindow::slotExportAdvance ( )

privateslot

Definition at line 1907 of file KisMainWindow.cpp.

{
    if (saveDocument(d->activeView->document(), true, true,true)) {
        Q_EMIT documentSaved();
    }
}

References d, documentSaved(), and saveDocument().

◆ slotExportFile

void KisMainWindow::slotExportFile ( )

privateslot

File --> Export

This will call slotFileSaveAs().

Definition at line 1901 of file KisMainWindow.cpp.

{
    if (saveDocument(d->activeView->document(), true, true,false)) {
        Q_EMIT documentSaved();
    }
}

References d, documentSaved(), and saveDocument().

◆ slotFileCloseAll

bool KisMainWindow::slotFileCloseAll ( )

privateslot

Closes all open documents.

Definition at line 2206 of file KisMainWindow.cpp.

{
    Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
        if (subwin) {
            if(!subwin->close())
                return false;
        }
    }
 
    return true;
}

References d.

◆ slotFileNew

void KisMainWindow::slotFileNew ( )

slot

Slot for opening a new document.

If the current document is empty, the new document replaces it. If not, a new mainwindow will be opened for showing the document.

Definition at line 1839 of file KisMainWindow.cpp.

{
    KisDlgCreateNewDocument* dlg = new KisDlgCreateNewDocument(this);
    dlg->exec();
    dlg->deleteLater();
}

◆ slotFileOpen

void KisMainWindow::slotFileOpen ( bool isImporting = false )

slot

Slot for opening a saved file.

If the current document is empty, the opened document replaces it. If not a new mainwindow will be opened for showing the opened file.

Definition at line 1853 of file KisMainWindow.cpp.

{
    QStringList urls = showOpenFileDialog(isImporting);
 
    if (urls.isEmpty())
        return;
 
    Q_FOREACH (const QString& url, urls) {
 
        if (!url.isEmpty()) {
            OpenFlags flags = isImporting ? Import : None;
            bool res = openDocument(url, flags);
            if (!res) {
                warnKrita << "Loading" << url << "failed";
            }
        }
    }
}

References Import, None, openDocument(), showOpenFileDialog(), and warnKrita.

◆ slotFileOpenRecent

void KisMainWindow::slotFileOpenRecent ( const QUrl & url )

slot

Slot for opening a file among the recently opened files.

If the current document is empty, the opened document replaces it. If not a new mainwindow will be opened for showing the opened file.

Definition at line 1872 of file KisMainWindow.cpp.

{
    (void) openDocument(url.toLocalFile(), None);
}

References None, openDocument(), and void().

◆ slotFileQuit

void KisMainWindow::slotFileQuit ( )

privateslot

Closes the mainwindow.

Definition at line 2218 of file KisMainWindow.cpp.

{
    // Do not close while KisMainWindow has the savingEntryMutex locked, bug409395.
    // After the background saving job is initiated, KisDocument blocks closing
    // while it saves itself.
    if (hackIsSaving()) {
        return;
    }
    KisPart::instance()->closeSession();
}

References KisPart::closeSession(), hackIsSaving(), and KisPart::instance().

◆ slotFileSave

void KisMainWindow::slotFileSave ( )

slot

Saves the current document with the current name.

Definition at line 1877 of file KisMainWindow.cpp.

{
    if (saveDocument(d->activeView->document(), false, false,false)) {
        Q_EMIT documentSaved();
    }
}

References d, documentSaved(), and saveDocument().

◆ slotFileSaveAs

void KisMainWindow::slotFileSaveAs ( )

privateslot

Saves the current document with a new name.

Definition at line 1894 of file KisMainWindow.cpp.

{
    if (saveDocument(d->activeView->document(), true, false,false)) {
        Q_EMIT documentSaved();
    }
}

References d, documentSaved(), and saveDocument().

◆ slotImportFile

void KisMainWindow::slotImportFile ( )

privateslot

File --> Import

This will call slotFileOpen().

Definition at line 1846 of file KisMainWindow.cpp.

{
    dbgUI << "slotImportFile()";
    slotFileOpen(true);
}

References dbgUI, and slotFileOpen().

◆ slotLoadCanceled

void KisMainWindow::slotLoadCanceled ( const QString & errMsg )

privateslot

Definition at line 1250 of file KisMainWindow.cpp.

{
    KisUsageLogger::log(QString("Loading canceled: %1.").arg(errMsg));
    KisDocument* doc = qobject_cast<KisDocument*>(sender());
    Q_ASSERT(doc);
    disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
    disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
}

References KisUsageLogger::log(), slotLoadCanceled(), and slotLoadCompleted().

◆ slotLoadCompleted

void KisMainWindow::slotLoadCompleted ( )

privateslot

Definition at line 1237 of file KisMainWindow.cpp.

{
    KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
    if (newdoc && newdoc->image()) {
        addViewAndNotifyLoadingCompleted(newdoc);
 
        disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
        disconnect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
        Q_EMIT loadCompleted();
    }
}

References addViewAndNotifyLoadingCompleted(), KisDocument::image, loadCompleted(), slotLoadCanceled(), and slotLoadCompleted().

◆ slotNewToolbarConfig

void KisMainWindow::slotNewToolbarConfig ( )

privateslot

Post toolbar config. (Plug action lists back in, etc.)

First we should apply icon overrides, and only after that we should update the layout, since the function checks for the presence of the icons in the action.

Definition at line 2401 of file KisMainWindow.cpp.

{
    applyMainWindowSettings(d->windowStateConfig);
 
    KisKXMLGUIFactory *factory = guiFactory();
    Q_UNUSED(factory);
 
    // Check if there's an active view
    if (!d->activeView)
        return;
 
    plugActionList("toolbarlist", d->toolbarList);
 
    applyActionIconOverridesFromLocalXML();
    applyToolBarLayout();
}

References applyActionIconOverridesFromLocalXML(), KXmlGuiWindow::applyMainWindowSettings(), applyToolBarLayout(), d, KisKXMLGUIClient::factory(), KXmlGuiWindow::guiFactory(), and KisKXMLGUIClient::plugActionList().

◆ slotPreferences

void KisMainWindow::slotPreferences ( )

slot

slotPreferences open the preferences dialog

Definition at line 868 of file KisMainWindow.cpp.

{
    std::optional<KisDlgPreferences::PageDesc>page = std::nullopt;
 
    KisAction* action = d->actionManager()->actionByName("options_configure");
    QVariant data  = action->data();
    if (data.userType() == QMetaType::QVariantList) {
        // Reset the data first
        action->setData(QVariant());
        QList<QVariant> list = data.toList();
 
        Q_ASSERT(list.length() == 2);
        Q_ASSERT(list[0].userType() == QMetaType::Int);
        Q_ASSERT(list[1].userType() == QMetaType::Int);
 
        KisDlgPreferences::Page p = (KisDlgPreferences::Page)list[0].toInt();
        int t = list[1].toInt();
        page = KisDlgPreferences::PageDesc{p, t};
    }
 
    QScopedPointer<KisDlgPreferences> dlgPreferences(new KisDlgPreferences(this));
 
    if (dlgPreferences->editPreferences(page)) {
        KisConfigNotifier::instance()->notifyConfigChanged();
        KisConfigNotifier::instance()->notifyPixelGridModeChanged();
        KisImageConfigNotifier::instance()->notifyConfigChanged();
 
        // XXX: should this be changed for the views in other windows as well?
        Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
            KisViewManager *view = qobject_cast<KisViewManager*>(koview);
            if (view) {
                // Update the settings for all nodes -- they don't query
                // KisConfig directly because they need the settings during
                // compositing, and they don't connect to the config notifier
                // because nodes are not QObjects (because only one base class
                // can be a QObject).
                KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                if (node) {
                    node->updateSettings();
                }
            }
 
        }
        updateWindowMenu();
 
        d->viewManager->showHideScrollbars();
    }
}

References KisKXMLGUIClient::action(), d, KisSharedPtr< T >::data(), KisViewManager::image(), KisConfigNotifier::instance(), KisImageConfigNotifier::instance(), KisPart::instance(), KisConfigNotifier::notifyConfigChanged(), KisImageConfigNotifier::notifyConfigChanged(), KisConfigNotifier::notifyPixelGridModeChanged(), p, KisImage::rootLayer(), KisBaseNode::updateSettings(), and updateWindowMenu().

◆ slotResetConfigurations

void KisMainWindow::slotResetConfigurations ( )

privateslot

Reset User Configurations.

Definition at line 2395 of file KisMainWindow.cpp.

{
    KisApplication *kisApp = static_cast<KisApplication*>(qApp);
    kisApp->askResetConfig();
}

References KisApplication::askResetConfig().

◆ slotSaveCanceled

void KisMainWindow::slotSaveCanceled ( const QString & errMsg )

privateslot

Definition at line 1259 of file KisMainWindow.cpp.

{
    if (!errMsg.isEmpty()) {   // empty when cancelled by user
        KisUsageLogger::log(QString("Saving cancelled. Error:").arg(errMsg));
        QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
    }
    else {
        KisUsageLogger::log(QString("Saving cancelled by the user."));
    }
    slotSaveCompleted();
}

References KisUsageLogger::log(), and slotSaveCompleted().

◆ slotSaveCompleted

void KisMainWindow::slotSaveCompleted ( )

privateslot

Definition at line 1271 of file KisMainWindow.cpp.

{
    KisUsageLogger::log(QString("Saving Completed"));
    KisDocument* doc = qobject_cast<KisDocument*>(sender());
    if (doc) {
        disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
        disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
    }
 
    if (d->deferredClosingEvent) {
        KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
    }
}

References KisKMainWindow::closeEvent(), d, KisUsageLogger::log(), slotSaveCanceled(), and slotSaveCompleted().

◆ slotShowSessionManager

void KisMainWindow::slotShowSessionManager ( )

slot

Definition at line 1914 of file KisMainWindow.cpp.

                                           {
    KisPart::instance()->showSessionManager();
}

References KisPart::instance(), and KisPart::showSessionManager().

◆ slotStoragesWarning

void KisMainWindow::slotStoragesWarning ( const QString & location = QString() )

privateslot

Definition at line 2098 of file KisMainWindow.cpp.

{
    QString warning;
    if (!checkActiveBundlesAvailable()) {
        warning = i18n("You don't have any resource bundles enabled.");
    }
 
    if (!checkPaintOpAvailable()) {
        warning += i18n("\nThere are no brush presets available. Please enable a bundle that has presets before continuing.\n");
        QMessageBox::critical(this, i18nc("@title:window", "Krita"), warning);
 
        QAction *action = actionCollection()->action("manage_bundles");
        if (action) {
            action->trigger();
        }
    }
 
    if (!checkActiveBundlesAvailable()) {
        QMessageBox::warning(this, i18nc("@title:window", "Krita"), warning + i18n("\nOnly your local resources are available."));
    }
 
}

References KisKXMLGUIClient::action(), KisKActionCollection::action(), KisKXMLGUIClient::actionCollection(), checkActiveBundlesAvailable(), and checkPaintOpAvailable().

◆ slotThemeChanged

void KisMainWindow::slotThemeChanged ( )

privateslot

Definition at line 955 of file KisMainWindow.cpp.

{
    KConfigGroup group(KSharedConfig::openConfig(), "theme");
#ifndef Q_OS_HAIKU
    if (group.readEntry("Theme", "") == d->themeManager->currentThemeName()) return;
 
    // save theme changes instantly
    group.writeEntry("Theme", d->themeManager->currentThemeName());
#endif
    updateTheme();
 
    // Make the other top level windows update as well
    Q_FOREACH (QWidget* topLevelWidget, qApp->topLevelWidgets()) {
        if (topLevelWidget == this) {
            // Skip if the current top level widget is this window
            continue;
        }
        if (topLevelWidget->isHidden()) {
            // Skip unwanted top level widgets like menus, dropdowns, tooltips, etc.
            continue;
        }
        KisMainWindow *topLevelMainWindow = qobject_cast<KisMainWindow*>(topLevelWidget);
        if (topLevelMainWindow) {
            topLevelMainWindow->updateTheme();
            Q_EMIT topLevelMainWindow->themeChanged();
        } else {
            QObjectList objects;
            objects.append(topLevelWidget);
            while (!objects.isEmpty()) {
                QWidget* widget = qobject_cast<QWidget*>(objects.takeFirst());
                if (widget) {
                    objects.append(widget->children());
                    KisIconUtils::updateIconCommon(widget);
                }
            }
        }
    }
 
    applyActionIconOverridesFromLocalXML();
 
    Q_EMIT themeChanged();
}

References applyActionIconOverridesFromLocalXML(), d, themeChanged(), KisIconUtils::updateIconCommon(), updateTheme(), and KisKXMLGUIBuilder::widget().

◆ slotToolbarToggled

void KisMainWindow::slotToolbarToggled ( bool toggle )

privateslot

Shows or hides a toolbar

Definition at line 2423 of file KisMainWindow.cpp.

{
    //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
    // The action (sender) and the toolbar have the same name
    KisToolBar * bar = toolBar(sender()->objectName());
    if (bar) {
        if (toggle) {
            bar->show();
        }
        else {
            bar->hide();
        }
 
        if (d->activeView && d->activeView->document()) {
            saveWindowState();
        }
    } else
        warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
}

References d, saveWindowState(), KisKMainWindow::toolBar(), and warnUI.

◆ slotUpdateReadWriteMode

void KisMainWindow::slotUpdateReadWriteMode ( bool readWrite )

privateslot

Definition at line 1098 of file KisMainWindow.cpp.

{
    Q_UNUSED(readWrite);
    d->actionManager()->updateGUI();
}

References d.

◆ slotUpdateSaveActionTitle

void KisMainWindow::slotUpdateSaveActionTitle ( const QString & documentPath )

privateslot

Definition at line 1086 of file KisMainWindow.cpp.

{
    const QString fileName = QFileInfo(documentPath).fileName();
 
    if (!fileName.isEmpty()) {
        d->saveAction->setToolTip(i18n("Save as %1", fileName));
    }
    else {
        d->saveAction->setToolTip(i18n("Save"));
    }
}

References d.

◆ slotUpdateWidgetStyle

void KisMainWindow::slotUpdateWidgetStyle ( )

privateslot

Definition at line 2572 of file KisMainWindow.cpp.

{
     KisConfig cfg(true);
     QString themeFromConfig = cfg.widgetStyle();
 
     Q_FOREACH (auto key, d->actionMap.keys()) { // find checked style to save to config
         if(d->actionMap.value(key)->isChecked()) {
            cfg.setWidgetStyle(key);
            qApp->setProperty(currentUnderlyingStyleNameProperty, key);
            qApp->setStyle(key);
 
            // When switching to a style that uses system colors, reset the theme
#ifndef Q_OS_HAIKU
            QString currentStyle = qApp->style()->objectName();
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
            if (currentStyle == "macintosh" || currentStyle == "windowsvista") {
                d->themeManager->setCurrentTheme("System");
            }
#else
            if (currentStyle == "macos" || currentStyle == "windowsvista" || currentStyle == "windows11") {
                d->themeManager->setCurrentTheme("System");
            }
#endif
#endif
         }
     }
}

References currentUnderlyingStyleNameProperty, d, KisConfig::setWidgetStyle(), and KisConfig::widgetStyle().

◆ slotXmlGuiMakingChanges

void KisMainWindow::slotXmlGuiMakingChanges ( bool finished )

privateslot

Definition at line 3310 of file KisMainWindow.cpp.

{
    if (finished) {
        subWindowActivated();
    }
}

References subWindowActivated().

◆ subWindowActivated

void KisMainWindow::subWindowActivated ( )

slot

Qt has a weirdness, it has hardcoded shortcuts added to an action in the window menu. We need to reset the shortcuts for that menu to nothing, otherwise the shortcuts cannot be made configurable.

See: https://bugs.kde.org/show_bug.cgi?id=352205 https://bugs.kde.org/show_bug.cgi?id=375524 https://bugs.kde.org/show_bug.cgi?id=398729

Definition at line 2650 of file KisMainWindow.cpp.

{
    bool enabled = (activeKisView() != 0);
 
    d->mdiCascade->setEnabled(enabled);
    d->mdiNextWindow->setEnabled(enabled);
    d->mdiPreviousWindow->setEnabled(enabled);
    d->mdiTile->setEnabled(enabled);
    d->close->setEnabled(enabled);
    d->closeAll->setEnabled(enabled);
 
    setActiveSubWindow(d->mdiArea->activeSubWindow());
 
    QMdiSubWindow *subWindow = d->mdiArea->currentSubWindow();
    if (subWindow) {
        QMenu *menu = subWindow->systemMenu();
        if (menu && menu->actions().size() == 8) {
            Q_FOREACH (QAction *action, menu->actions()) {
                action->setShortcut(QKeySequence());
 
            }
            menu->actions().last()->deleteLater();
        }
    }
 
    d->actionManager()->updateGUI();
}

References KisKXMLGUIClient::action(), activeKisView(), d, and setActiveSubWindow().

◆ swapWorkspaces()

void KisMainWindow::swapWorkspaces	(	KisMainWindow *	a,
		KisMainWindow *	b )

static

Definition at line 2169 of file KisMainWindow.cpp.

{
    QByteArray workspaceA = a->borrowWorkspace(b);
    QByteArray workspaceB = b->borrowWorkspace(a);
 
    a->restoreWorkspaceState(workspaceB);
    b->restoreWorkspaceState(workspaceA);
}

References borrowWorkspace(), and restoreWorkspaceState().

◆ switchTab

void KisMainWindow::switchTab ( int index )

privateslot

Definition at line 1813 of file KisMainWindow.cpp.

{
    QTabBar *tabBar = d->findTabBarHACK();
    if (!tabBar) return;
 
    tabBar->setCurrentIndex(index);
}

References d.

◆ synchronizeDynamicActions

void KisMainWindow::synchronizeDynamicActions ( )

slot

Definition at line 3410 of file KisMainWindow.cpp.

{
    // Add all actions with a menu property to the main window
    KisActionManager::synchronizeDynamicActions(this->actionCollection()->actions(), this->menuBar()->actions());
}

References KisKXMLGUIClient::actionCollection(), and KisActionManager::synchronizeDynamicActions().

◆ themeChanged

void KisMainWindow::themeChanged ( )

signal

This signal is emitted when the color theme changes.

◆ toggleDockersVisibility

void KisMainWindow::toggleDockersVisibility	(	bool	visible,
		bool	onWelcomePage = false )

privateslot

Hide the dockers

Definition at line 2631 of file KisMainWindow.cpp.

{
    if (!visible) {
        d->dockerStateBeforeHiding = saveState();
 
        Q_FOREACH (QObject* widget, children()) {
            if (widget->inherits("QDockWidget")) {
                QDockWidget* dw = static_cast<QDockWidget*>(widget);
                if (dw->isVisible() && !(onWelcomePage && dw->property("ShowOnWelcomePage").toBool())) {
                    dw->hide();
                }
            }
        }
    }
    else {
        restoreState(d->dockerStateBeforeHiding);
    }
}

References d, and KisKXMLGUIBuilder::widget().

◆ undo

void KisMainWindow::undo ( )

privateslot

◆ unsetActiveView

void KisMainWindow::unsetActiveView ( )

slot

Definition at line 1776 of file KisMainWindow.cpp.

{
    d->activeViewConnections.clear();
    slotUpdateSaveActionTitle(QString());
    slotUpdateReadWriteMode(false);
}

References d, slotUpdateReadWriteMode(), and slotUpdateSaveActionTitle().

◆ updateSubwindowFlags

void KisMainWindow::updateSubwindowFlags ( )

privateslot

Definition at line 2862 of file KisMainWindow.cpp.

{
    bool onlyOne = false;
    if (d->mdiArea->subWindowList().size() == 1 && d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
        onlyOne = true;
    }
    Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
        if (onlyOne) {
            subwin->setWindowFlags(subwin->windowFlags() | Qt::FramelessWindowHint);
            subwin->showMaximized();
        } else {
            subwin->setWindowFlags((subwin->windowFlags() | Qt::FramelessWindowHint) ^ Qt::FramelessWindowHint);
        }
    }
}

References d.

◆ updateTheme

void KisMainWindow::updateTheme ( )

privateslot

Handle theme changes from theme manager

Definition at line 917 of file KisMainWindow.cpp.

{
    // reload action icons!
    Q_FOREACH (QAction *action, actionCollection()->actions()) {
        KisIconUtils::updateIcon(action);
    }
    if (d->mdiArea) {
        d->mdiArea->setPalette(qApp->palette());
        for (int i=0; i<d->mdiArea->subWindowList().size(); i++) {
            QMdiSubWindow *window = d->mdiArea->subWindowList().at(i);
            if (window) {
                window->setPalette(qApp->palette());
                KisView *view = qobject_cast<KisView*>(window->widget());
                if (view) {
                    view->slotThemeChanged(qApp->palette());
                }
            }
        }
    }
 
    customizeTabBar();
 
    // Update toolbars
    {
        Q_FOREACH (KisToolBar* aToolBar, toolBars()) {
            QObjectList objects;
            objects.append(aToolBar);
            while (!objects.isEmpty()) {
                QWidget* widget = qobject_cast<QWidget*>(objects.takeFirst());
                if (widget) {
                    objects.append(widget->children());
                    widget->setPalette(qApp->palette());
                }
            }
        }
    }
}

References KisKXMLGUIClient::action(), KisKXMLGUIClient::actionCollection(), customizeTabBar(), d, KisView::slotThemeChanged(), KisKMainWindow::toolBars(), KisIconUtils::updateIcon(), and KisKXMLGUIBuilder::widget().

◆ updateWindowMenu

void KisMainWindow::updateWindowMenu ( )

privateslot

Definition at line 2719 of file KisMainWindow.cpp.

{
    QMenu *menu = d->windowMenu->menu();
    menu->clear();
 
#ifndef Q_OS_ANDROID
    menu->addAction(d->newWindow);
#endif
    menu->addAction(d->documentMenu);
 
    QMenu *docMenu = d->documentMenu->menu();
    docMenu->clear();
 
    QFontMetrics fontMetrics = docMenu->fontMetrics();
    QRect geom = this->geometry();
    QPoint p(geom.width() / 2 + geom.left(), geom.height() / 2 + geom.top());
    QScreen *screen = qApp->screenAt(p);
    int fileStringWidth = 300;
    if (screen) {
        fileStringWidth = int(screen->availableGeometry().width() * .40f);
    }
    Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
        if (doc) {
            QString title = fontMetrics.elidedText(doc->path(), Qt::ElideMiddle, fileStringWidth);
            if (title.isEmpty() && doc->image()) {
                title = doc->image()->objectName();
            }
            QAction *action = docMenu->addAction(title);
            action->setIcon(qApp->windowIcon());
            connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
            d->documentMapper->setMapping(action, doc);
        }
    }
 
    menu->addAction(d->workspaceMenu);
    QMenu *workspaceMenu = d->workspaceMenu->menu();
    workspaceMenu->clear();
    KisResourceModel resourceModel(ResourceType::Workspaces);
    KisResourceIterator resourceIterator(&resourceModel);
    KisMainWindow *m_this = this;
 
    while (resourceIterator.hasNext()) {
        KisResourceItemSP resource = resourceIterator.next();
        QAction *action = workspaceMenu->addAction(resource->name());
        action->setProperty("md5", QVariant::fromValue<QString>(resource->md5sum()));
        connect(action, SIGNAL(triggered()), this, SLOT(restoreWorkspace()));
    }
    workspaceMenu->addSeparator();
    connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
            &QAction::triggered,
            this,
            [&]()
    {
        QStringList mimeTypes = KisResourceLoaderRegistry::instance()->mimeTypes(ResourceType::Workspaces);
 
        KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
        dialog.setMimeTypeFilters(mimeTypes);
        dialog.setCaption(i18nc("@title:window", "Choose File to Add"));
        QString filename = dialog.filename();
 
        KisResourceUserOperations::importResourceFileWithUserInput(this, "", ResourceType::Workspaces, filename);
    });
 
    connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&New Workspace...")),
            &QAction::triggered,
            [=]() {
        QString name;
        name = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                                                i18nc("@label:textbox", "Name:"));
        if (name.isEmpty()) {
            return;
        }
 
        KisWorkspaceResourceSP workspace(new KisWorkspaceResource(""));
        workspace->setDockerState(m_this->saveState());
        workspace->setImage(layoutThumbnail());
        workspace->setValid(true);
 
        // this line must happen before we save the workspace to resource folder or other places
        // because it mostly just triggers palettes to be saved into the workspace
        d->viewManager->canvasResourceProvider()->notifySavingWorkspace(workspace);
        workspace->setValid(true);
 
        workspace->setFilename(name.replace(" ", "_") + workspace->defaultFileExtension());
        workspace->setName(name);
 
        KisResourceUserOperations::addResourceWithUserInput(this, workspace);
    });
 
    // TODO: What to do about delete?
    //    workspaceMenu->addAction(i18nc("@action:inmenu", "&Delete Workspace..."));
 
    menu->addSeparator();
    menu->addAction(d->close);
    menu->addAction(d->closeAll);
    if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
        menu->addSeparator();
        menu->addAction(d->mdiTile);
        menu->addAction(d->mdiCascade);
    }
    menu->addSeparator();
    menu->addAction(d->mdiNextWindow);
    menu->addAction(d->mdiPreviousWindow);
    menu->addSeparator();
 
    QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
    for (int i = 0; i < windows.size(); ++i) {
        QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
        if (child && child->document()) {
            QString text;
            if (i < 9) {
                text = i18n("&%1 %2", i + 1, fontMetrics.elidedText(child->document()->path(), Qt::ElideMiddle, fileStringWidth));
            }
            else {
                text = i18n("%1 %2", i + 1, fontMetrics.elidedText(child->document()->path(), Qt::ElideMiddle, fileStringWidth));
            }
 
            QAction *action  = menu->addAction(text);
            action->setIcon(qApp->windowIcon());
            action->setCheckable(true);
            action->setChecked(child == activeKisView());
            connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
            d->windowMapper->setMapping(action, windows.at(i));
        }
    }
 
    bool showMdiArea = windows.count( ) > 0;
    if (!showMdiArea) {
        showWelcomeScreen(true); // see workaround in function in header
    }
 
    // enable/disable the toolbox docker if there are no documents open
    Q_FOREACH (QObject* widget, children()) {
        if (widget->inherits("QDockWidget")) {
            QDockWidget* dw = static_cast<QDockWidget*>(widget);
 
            if ( dw->objectName() == "ToolBox") {
                dw->setEnabled(showMdiArea);
            }
        }
    }
}

References KisKXMLGUIClient::action(), activeKisView(), KisResourceUserOperations::addResourceWithUserInput(), d, KisResourceIterator::hasNext(), KisResourceUserOperations::importResourceFileWithUserInput(), KisResourceLoaderRegistry::instance(), KisPart::instance(), layoutThumbnail(), KisResourceLoaderRegistry::mimeTypes(), KisResourceIterator::next(), KoFileDialog::OpenFile, p, restoreWorkspace(), showWelcomeScreen(), KisKXMLGUIBuilder::widget(), workspaceMenu, and ResourceType::Workspaces.

◆ viewCount()

int KisMainWindow::viewCount ( ) const

Definition at line 1970 of file KisMainWindow.cpp.

{
    return d->mdiArea->subWindowList().size();
}

References d.

◆ viewFullscreen

void KisMainWindow::viewFullscreen ( bool fullScreen )

slot

Toggle full screen on/off.

Definition at line 2443 of file KisMainWindow.cpp.

{
#ifdef Q_OS_ANDROID
    // Full-screening on Android applies to the entire application, not this
    // window in particular. Qt tries to paper over that matter, but it causes
    // some pretty horrid flickering when the main window gets hidden. We just
    // talk to the Android interface directly to get around that.
    KisAndroidUtils::setFullScreen(fullScreen);
    d->fullScreenMode->setChecked(fullScreen);
#else
    KisConfig cfg(false);
    cfg.setFullscreenMode(fullScreen);
 
    if (fullScreen) {
        setWindowState(windowState() | Qt::WindowFullScreen);   // set
    } else {
        setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
    }
    d->fullScreenMode->setChecked(isFullScreen());
#endif
}

References d, KisAndroidUtils::setFullScreen(), and KisConfig::setFullscreenMode().

◆ viewManager()

KisViewManager * KisMainWindow::viewManager ( ) const

◆ windowFocused

void KisMainWindow::windowFocused ( )

slot

Notify selection manager so that it could update selection mask overlay

Definition at line 2687 of file KisMainWindow.cpp.

{
    if (viewManager() && viewManager()->selectionManager()) {
        viewManager()->selectionManager()->selectionChanged();
    }
 
    KisPart *kisPart = KisPart::instance();
    KisWindowLayoutManager *layoutManager = KisWindowLayoutManager::instance();
    if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
    QUuid primary = layoutManager->primaryWindowId();
    if (primary.isNull()) return;
 
    if (d->id == primary) {
        if (!d->workspaceBorrowedBy.isNull()) {
            KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
            if (!borrower) return;
            swapWorkspaces(this, borrower);
        }
    } else {
        if (d->workspaceBorrowedBy == primary) return;
 
        KisMainWindow *primaryWindow = kisPart->windowById(primary);
        if (!primaryWindow) return;
        swapWorkspaces(this, primaryWindow);
    }
}

References d, KisPart::instance(), KisWindowLayoutManager::instance(), KisWindowLayoutManager::primaryWindowId(), KisWindowLayoutManager::primaryWorkspaceFollowsFocus(), KisSelectionManager::selectionChanged(), KisViewManager::selectionManager(), swapWorkspaces(), viewManager, and KisPart::windowById().

◆ windowsLayoutSavingAllowed()

bool KisMainWindow::windowsLayoutSavingAllowed ( ) const

overrideprotectedvirtual

Reimplemented from KisKMainWindow.

Definition at line 1672 of file KisMainWindow.cpp.

{
    QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
    return !action || !action->isChecked();
}

References KisKXMLGUIClient::action(), and d.

◆ windowStateConfig()

const KConfigGroup & KisMainWindow::windowStateConfig ( ) const

Friends And Related Symbol Documentation

◆ KisPart

friend class KisPart

friend

Definition at line 455 of file KisMainWindow.h.

◆ KisWelcomePageWidget

friend class KisWelcomePageWidget

friend

Definition at line 442 of file KisMainWindow.h.

Member Data Documentation

◆ actionMap

QMap<QString, QAction*> KisMainWindow::actionMap

Definition at line 286 of file KisMainWindow.cpp.

◆ activeSubWindow

QMdiSubWindow* KisMainWindow::activeSubWindow {nullptr}

Definition at line 317 of file KisMainWindow.cpp.

317{nullptr};

◆ activeView

KisView * KisMainWindow::activeView

Definition at line 237 of file KisMainWindow.cpp.

◆ activeViewConnections

KisSignalAutoConnectionsStore KisMainWindow::activeViewConnections

Definition at line 238 of file KisMainWindow.cpp.

◆ canvasWindow

QWidget * KisMainWindow::canvasWindow {nullptr}

Definition at line 320 of file KisMainWindow.cpp.

320{nullptr};

◆ close

KisAction* KisMainWindow::close {nullptr}

Definition at line 261 of file KisMainWindow.cpp.

261{nullptr};

◆ closeAll

KisAction* KisMainWindow::closeAll {nullptr}

Definition at line 255 of file KisMainWindow.cpp.

255{nullptr};

◆ commandBar

KateCommandBar* KisMainWindow::commandBar {nullptr}

Definition at line 330 of file KisMainWindow.cpp.

330{nullptr};

◆ commandBarAction

KisAction* KisMainWindow::commandBarAction {nullptr}

Definition at line 281 of file KisMainWindow.cpp.

281{nullptr};

◆ d

Private* const KisMainWindow::d

private

Definition at line 486 of file KisMainWindow.h.

◆ deferredClosingEvent

QCloseEvent* KisMainWindow::deferredClosingEvent {nullptr}

Definition at line 306 of file KisMainWindow.cpp.

306{nullptr};

◆ dockerStateBeforeHiding

QByteArray KisMainWindow::dockerStateBeforeHiding

Definition at line 303 of file KisMainWindow.cpp.

◆ dockWidgetMenu

KActionMenu* KisMainWindow::dockWidgetMenu {nullptr}

Definition at line 288 of file KisMainWindow.cpp.

288{nullptr};

◆ dockWidgetsMap

QMap<QString, QDockWidget *> KisMainWindow::dockWidgetsMap

Definition at line 302 of file KisMainWindow.cpp.

◆ documentMapper

KisSignalMapper* KisMainWindow::documentMapper {nullptr}

Definition at line 319 of file KisMainWindow.cpp.

319{nullptr};

◆ documentMenu

KActionMenu* KisMainWindow::documentMenu {nullptr}

Definition at line 290 of file KisMainWindow.cpp.

290{nullptr};

◆ expandingSpacers

KisAction* KisMainWindow::expandingSpacers[2]

Definition at line 282 of file KisMainWindow.cpp.

◆ exportFile

KisAction* KisMainWindow::exportFile {nullptr}

Definition at line 257 of file KisMainWindow.cpp.

257{nullptr};

◆ exportFileAdvance

KisAction* KisMainWindow::exportFileAdvance {nullptr}

Definition at line 258 of file KisMainWindow.cpp.

258{nullptr};

◆ firstTime

bool KisMainWindow::firstTime {true}

Definition at line 242 of file KisMainWindow.cpp.

242{true};

◆ fullScreenMode

KisAction* KisMainWindow::fullScreenMode {nullptr}

Definition at line 279 of file KisMainWindow.cpp.

279{nullptr};

◆ helpMenu

KisKHelpMenu* KisMainWindow::helpMenu {nullptr}

Definition at line 293 of file KisMainWindow.cpp.

293{nullptr};

◆ id

QUuid KisMainWindow::id

Definition at line 233 of file KisMainWindow.cpp.

◆ importAnimation

void KisMainWindow::importAnimation {nullptr}

Definition at line 251 of file KisMainWindow.cpp.

251{nullptr};

◆ importFile

KisAction* KisMainWindow::importFile {nullptr}

Definition at line 256 of file KisMainWindow.cpp.

256{nullptr};

◆ importVideoAnimation

void KisMainWindow::importVideoAnimation {nullptr}

Definition at line 252 of file KisMainWindow.cpp.

252{nullptr};

◆ lastExportedFormat

QByteArray KisMainWindow::lastExportedFormat

Definition at line 322 of file KisMainWindow.cpp.

◆ lastExportLocation

QString KisMainWindow::lastExportLocation

Definition at line 300 of file KisMainWindow.cpp.

◆ m_dieOnError

bool KisMainWindow::m_dieOnError

private

Definition at line 489 of file KisMainWindow.h.

◆ m_errorMessage

QString KisMainWindow::m_errorMessage

private

Definition at line 488 of file KisMainWindow.h.

◆ mdiArea

QMdiArea* KisMainWindow::mdiArea {nullptr}

Definition at line 316 of file KisMainWindow.cpp.

316{nullptr};

◆ mdiCascade

KisAction* KisMainWindow::mdiCascade {nullptr}

Definition at line 262 of file KisMainWindow.cpp.

262{nullptr};

◆ mdiNextWindow

KisAction* KisMainWindow::mdiNextWindow {nullptr}

Definition at line 264 of file KisMainWindow.cpp.

264{nullptr};

◆ mdiPreviousWindow

KisAction* KisMainWindow::mdiPreviousWindow {nullptr}

Definition at line 265 of file KisMainWindow.cpp.

265{nullptr};

◆ mdiTile

KisAction* KisMainWindow::mdiTile {nullptr}

Definition at line 263 of file KisMainWindow.cpp.

263{nullptr};

◆ newWindow

void KisMainWindow::newWindow {nullptr}

Definition at line 277 of file KisMainWindow.cpp.

277{nullptr};

◆ q

KisMainWindow* KisMainWindow::q {nullptr}

Definition at line 232 of file KisMainWindow.cpp.

232{nullptr};

◆ recentFiles

KRecentFilesAction* KisMainWindow::recentFiles {nullptr}

Definition at line 295 of file KisMainWindow.cpp.

295{nullptr};

◆ redo

void KisMainWindow::redo {nullptr}

Definition at line 260 of file KisMainWindow.cpp.

260{nullptr};

◆ renderAnimation

void KisMainWindow::renderAnimation {nullptr}

Definition at line 253 of file KisMainWindow.cpp.

253{nullptr};

◆ renderAnimationAgain

void KisMainWindow::renderAnimationAgain {nullptr}

Definition at line 254 of file KisMainWindow.cpp.

254{nullptr};

◆ resetConfigurations

KisAction* KisMainWindow::resetConfigurations {nullptr}

Definition at line 267 of file KisMainWindow.cpp.

267{nullptr};

◆ saveAction

KisAction* KisMainWindow::saveAction {nullptr}

Definition at line 249 of file KisMainWindow.cpp.

249{nullptr};

◆ saveActionAs

KisAction* KisMainWindow::saveActionAs {nullptr}

Definition at line 250 of file KisMainWindow.cpp.

250{nullptr};

◆ savingEntryMutex

QMutex KisMainWindow::savingEntryMutex

Definition at line 324 of file KisMainWindow.cpp.

◆ showDocumentInfo

KisAction* KisMainWindow::showDocumentInfo {nullptr}

Definition at line 248 of file KisMainWindow.cpp.

248{nullptr};

◆ showSessionManager

KisAction* KisMainWindow::showSessionManager {nullptr}

Definition at line 280 of file KisMainWindow.cpp.

280{nullptr};

◆ styleActions

QActionGroup* KisMainWindow::styleActions {nullptr}

Definition at line 285 of file KisMainWindow.cpp.

285{nullptr};

◆ styleMenu

KActionMenu* KisMainWindow::styleMenu {nullptr}

Definition at line 284 of file KisMainWindow.cpp.

284{nullptr};

◆ tabSwitchCompressor

QScopedPointer<KisSignalCompressorWithParam<int> > KisMainWindow::tabSwitchCompressor

Definition at line 323 of file KisMainWindow.cpp.

◆ themeManager

Digikam::ThemeManager* KisMainWindow::themeManager {nullptr}

Definition at line 308 of file KisMainWindow.cpp.

308{nullptr};

◆ toggleDetachCanvas

KisAction* KisMainWindow::toggleDetachCanvas {nullptr}

Definition at line 276 of file KisMainWindow.cpp.

276{nullptr};

◆ toggleDockers

KisAction* KisMainWindow::toggleDockers {nullptr}

Definition at line 266 of file KisMainWindow.cpp.

266{nullptr};

◆ toggleDockerTitleBars

KisAction* KisMainWindow::toggleDockerTitleBars {nullptr}

Definition at line 268 of file KisMainWindow.cpp.

268{nullptr};

◆ toolbarList

QList<QAction *> KisMainWindow::toolbarList

Definition at line 240 of file KisMainWindow.cpp.

◆ toolOptionsDocker

KoToolDocker* KisMainWindow::toolOptionsDocker {nullptr}

Definition at line 304 of file KisMainWindow.cpp.

304{nullptr};

◆ undo

void KisMainWindow::undo {nullptr}

Definition at line 259 of file KisMainWindow.cpp.

259{nullptr};

◆ undoActionsUpdateManager

QScopedPointer<KisUndoActionsUpdateManager> KisMainWindow::undoActionsUpdateManager

Definition at line 298 of file KisMainWindow.cpp.

◆ viewManager

KisViewManager * KisMainWindow::viewManager {nullptr}

Definition at line 235 of file KisMainWindow.cpp.

235{nullptr};

◆ welcomePage

KisWelcomePageWidget* KisMainWindow::welcomePage {nullptr}

Definition at line 311 of file KisMainWindow.cpp.

311{nullptr};

◆ welcomeScroller

QScrollArea* KisMainWindow::welcomeScroller {nullptr}

Definition at line 310 of file KisMainWindow.cpp.

310{nullptr};

◆ widgetStack

QStackedWidget* KisMainWindow::widgetStack {nullptr}

Definition at line 314 of file KisMainWindow.cpp.

314{nullptr};

◆ windowMapper

KisSignalMapper* KisMainWindow::windowMapper {nullptr}

Definition at line 318 of file KisMainWindow.cpp.

318{nullptr};

◆ windowMenu

KActionMenu* KisMainWindow::windowMenu {nullptr}

Definition at line 289 of file KisMainWindow.cpp.

289{nullptr};

◆ windowSizeDirty

bool KisMainWindow::windowSizeDirty {false}

Definition at line 243 of file KisMainWindow.cpp.

243{false};

◆ windowStateConfig

const KConfigGroup & KisMainWindow::windowStateConfig

Definition at line 326 of file KisMainWindow.cpp.

◆ workspaceBorrowedBy

QUuid KisMainWindow::workspaceBorrowedBy

Definition at line 328 of file KisMainWindow.cpp.

◆ workspaceMenu

KActionMenu* KisMainWindow::workspaceMenu {nullptr}

Definition at line 291 of file KisMainWindow.cpp.

291{nullptr};

◆ workspacemodel

KisResourceModel* KisMainWindow::workspacemodel {nullptr}

Definition at line 296 of file KisMainWindow.cpp.

296{nullptr};

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

libs/ui/KisMainWindow.cpp
libs/ui/KisMainWindow.h

Public Types

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Private Slots

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ OpenFlag

Constructor & Destructor Documentation

◆ ~Private()

◆ KisMainWindow()

◆ ~KisMainWindow()

Member Function Documentation

◆ actionManager()

◆ activeKisView()

◆ activeView()

◆ activeViewChanged

◆ addView()

◆ addViewAndNotifyLoadingCompleted()

◆ adjustLayoutForWelcomePage()

◆ applyActionIconOverridesFromLocalXML()

◆ applyToolBarLayout()

◆ borrowWorkspace()

◆ canvasDetached()

◆ canvasObservers()

◆ canvasWindow()

◆ checkActiveBundlesAvailable

◆ checkPaintOpAvailable

◆ checkSanity

◆ clearRecentFiles

◆ closeCurrentWindow

◆ closeEvent()

◆ configChanged

◆ createActions()

◆ createDockWidget()

◆ createPopupMenu()

◆ customizeTabBar()

◆ dockWidget()

◆ dockWidgets()

◆ documentSaved

◆ dragLeave()

◆ dragLeaveEvent()

◆ dragMove()

◆ dragMoveEvent()

◆ findTabBarHACK()

◆ forceDockTabFonts

◆ guiLoadingFinished

◆ hackIsSaving()

◆ id()

◆ importAnimation

◆ importVideoAnimation

◆ initializeGeometry

◆ installBundle()

◆ keyBindingsChanged

◆ layoutThumbnail()

◆ loadCompleted

◆ newOptionWidgets

◆ newView

◆ newWindow

◆ notifyChildViewDestroyed

◆ openCommandBar

◆ openDocument()

◆ openDocumentInternal()

◆ orientationChanged

◆ Private()

◆ redo

◆ removeRecentFile

◆ renderAnimation

◆ renderAnimationAgain

◆ resizeEvent()

◆ resourceManager()

◆ restoreWorkspace [1/2]

◆ restoreWorkspace() [2/2]