Main window for Krita. More...

#include <KisMainWindow.h>

Inheritance diagram for KisMainWindow:

Classes
struct	CustomDocumentWidgetItem

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	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 180 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 218 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 345 of file KisMainWindow.cpp.

    : KXmlGuiWindow()
    , d(new Private(this, uuid))
{
    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()));
#ifdef Q_OS_ANDROID
    connect(this, &KisMainWindow::sigFullscreenOnShow, this, &KisMainWindow::viewFullscreen, Qt::QueuedConnection);
#endif
 
    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();
    }
    Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
        KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
        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;
 
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QStringList allowableStyles = QStringList() << "macintosh" << "breeze" << "fusion";
#else
    QStringList allowableStyles = QStringList() << "macos" << "breeze" << "fusion";
#endif
 
    Q_FOREACH (QString styleName, QStyleFactory::keys()) {
#ifdef Q_OS_ANDROID
        // disable the style for android platform
        if (styleName.toLower().contains("android")) {
            continue;
        }
#endif
        if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
            if (!allowableStyles.contains(styleName.toLower())) {
                continue;
            }
        }
        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 == "" ? 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()));
 
 
    // 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()));
    }
 
    // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
    QAction *helpAction = actionCollection()->action("help_contents");
    helpAction->disconnect();
    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()));
 
    // 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(), 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(), slotToolbarToggled(), slotUpdateWidgetStyle(), slotXmlGuiMakingChanges(), subWindowActivated(), switchTab(), themeChanged(), KisKMainWindow::toolBar(), toolbarList, KisConfig::toolOptionsInDocker(), updateWindowMenu(), KoGenericRegistry< T >::value(), viewFullscreen(), void(), warnUI, KisConfig::widgetStyle(), ResourceType::Workspaces, KisResourceServerProvider::workspaceServer(), and KisConfig::writeEntry().

◆ ~KisMainWindow()

KisMainWindow::~KisMainWindow ( )

override

Destructor.

Definition at line 666 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();
    //        }
    //    }
 
    // 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(), and KisPart::removeMainWindow().

Member Function Documentation

◆ actionManager()

KisActionManager * KisMainWindow::actionManager ( )

inline

Definition at line 313 of file KisMainWindow.cpp.

                                       {
        return viewManager->actionManager();
    }

◆ activeKisView()

QPointer< KisView > KisMainWindow::activeKisView ( )

private

Definition at line 2929 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 705 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 1124 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()) {
        QTimer::singleShot(0, this, [this] {
            hide();
            QTimer::singleShot(0, this, [this] {
                show();
            });
        });
    }
#endif
 
    return view;
}

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

◆ adjustLayoutForWelcomePage()

void KisMainWindow::adjustLayoutForWelcomePage ( )

private

Definition at line 1656 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 3239 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 3100 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 2056 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 969 of file KisMainWindow.cpp.

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

References d.

◆ canvasObservers()

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

overridevirtual

Implements KoCanvasSupervisor.

Definition at line 2510 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 3216 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 3227 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 2896 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 1005 of file KisMainWindow.cpp.

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

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

◆ closeCurrentWindow

void KisMainWindow::closeCurrentWindow ( )

privateslot

Definition at line 2888 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 1504 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 2798 of file KisMainWindow.cpp.

{
    KisConfig cfg(true);
    QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
    d->mdiArea->setViewMode(viewMode);
    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 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 2966 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()));
 
    d->importVideoAnimation = actionManager->createAction("file_import_video_animation");
    connect(d->importVideoAnimation, SIGNAL(triggered()), this, SLOT(importVideoAnimation()));
    
    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()));
 
#ifndef Q_OS_ANDROID
    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, 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(), slotConfigureToolbars(), slotDocumentInfo(), slotExportAdvance(), slotExportFile(), slotFileCloseAll(), slotFileNew(), slotFileOpen(), slotFileOpenRecent(), slotFileQuit(), slotFileSave(), slotFileSaveAs(), slotImportFile(), 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 2366 of file KisMainWindow.cpp.

{
    QDockWidget* dockWidget = 0;
    const bool showTitlebars = KisConfig(false).showDockerTitleBars();
 
    if (!d->dockWidgetsMap.contains(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 696 of file KisMainWindow.cpp.

{
    return 0;
}

◆ customizeTabBar()

void KisMainWindow::customizeTabBar ( )

private

Definition at line 928 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-top: 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 2504 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 2499 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 1728 of file KisMainWindow.cpp.

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

References d.

◆ dragLeaveEvent()

void KisMainWindow::dragLeaveEvent ( QDragLeaveEvent * event )

overrideprotected

Definition at line 1595 of file KisMainWindow.cpp.

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

References dragLeave().

◆ dragMove()

void KisMainWindow::dragMove ( QDragMoveEvent * event )

private

Definition at line 1706 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 1589 of file KisMainWindow.cpp.

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

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

◆ findTabBarHACK()

QTabBar * KisMainWindow::findTabBarHACK ( )

inline

Definition at line 317 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 2463 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 1219 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 3117 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);
    }
    d->fullScreenMode->setChecked(isFullScreen());
}

References d.

◆ installBundle()

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

Copy the given file into the bundle directory.

Definition at line 1225 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 1235 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, layoutThumbnail(), and palette.

◆ 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 2938 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 2864 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 727 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 1971 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 1041 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 1056 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 3177 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 183 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 1010 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 1582 of file KisMainWindow.cpp.

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

References d.

◆ resourceManager()

KoCanvasResourceProvider * KisMainWindow::resourceManager ( ) const

Definition at line 1878 of file KisMainWindow.cpp.

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

References d.

◆ restoreWorkspace [1/2]

void KisMainWindow::restoreWorkspace ( )

privateslot

Definition at line 1958 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 2034 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 1927 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 1269 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;
    }
 
    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, true);
                    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(), and KisImportExportManager::supportedMimeTypes().

◆ saveWindowSettings()

void KisMainWindow::saveWindowSettings ( )

private

Definition at line 1542 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 1893 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 2777 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 1674 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 974 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 1620 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 2923 of file KisMainWindow.cpp.

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

◆ showDockerTitleBars

void KisMainWindow::showDockerTitleBars ( bool show )

privateslot

Toggle docker titlebars on/off.

Definition at line 3158 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 1108 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 2915 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 1607 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
    Q_EMIT sigFullscreenOnShow(true); // Android defaults to fullscreen.
#endif
    return KXmlGuiWindow::showEvent(event);
}

References d, KXmlGuiWindow::event(), and setMainWindowLayoutForCurrentMainWidget().

◆ showManual

void KisMainWindow::showManual ( )

privateslot

Definition at line 3153 of file KisMainWindow.cpp.

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

◆ showOpenFileDialog()

QStringList KisMainWindow::showOpenFileDialog ( bool isImporting )

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

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 741 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);
            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, KoToolManager::initializeCurrentToolForCanvas(), KoToolManager::instance(), KisConfig::readEntry(), setActiveView(), KisCanvas2::setFavoriteResourceManager(), KisView::setSubWindow(), KisView::setViewManager(), KisView::slotLoadingFinished(), 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 1744 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().

◆ slotConfigureToolbars

void KisMainWindow::slotConfigureToolbars ( )

privateslot

Configure toolbars.

Definition at line 2296 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 2096 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 1867 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 1861 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 2119 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 1762 of file KisMainWindow.cpp.

{
    const QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
    KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
    startupWidget->setWindowModality(Qt::WindowModal);
    startupWidget->setWindowTitle(i18n("Create new document"));
 
 
    KisConfig cfg(true);
 
    int w = cfg.defImageWidth();
    int h = cfg.defImageHeight();
    const double resolution = cfg.defImageResolution();
    const QString colorModel = cfg.defColorModel();
    const QString colorDepth = cfg.defaultColorDepth();
    const QString colorProfile = cfg.defColorProfile();
 
 
    CustomDocumentWidgetItem item;
    item.widget = new KisCustomImageWidget(startupWidget,
                                           w,
                                           h,
                                           resolution,
                                           colorModel,
                                           colorDepth,
                                           colorProfile,
                                           i18n("Unnamed"));
 
    item.icon = "document-new";
    item.title = i18n("Custom Document");
    startupWidget->addCustomDocumentWidget(item.widget, item.title, "Custom Document", item.icon);
 
    item.widget = new KisImageFromClipboardWidget(startupWidget,
                                            0,
                                            0,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
    item.title = i18n("Create from Clipboard");
    item.icon = "tab-new";
 
    startupWidget->addCustomDocumentWidget(item.widget, item.title, "Create from ClipBoard", item.icon);
 
    connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
    connect(startupWidget, SIGNAL(openTemplate(QUrl)), KisPart::instance(), SLOT(openTemplate(QUrl)));
 
    startupWidget->exec();
    startupWidget->deleteLater();
}

References KisOpenPane::addCustomDocumentWidget(), KisConfig::defaultColorDepth(), KisConfig::defColorModel(), KisConfig::defColorProfile(), KisConfig::defImageHeight(), KisConfig::defImageResolution(), KisConfig::defImageWidth(), KisMainWindow::CustomDocumentWidgetItem::icon, KisImportExportManager::Import, KisPart::instance(), KisImportExportManager::supportedMimeTypes(), KisMainWindow::CustomDocumentWidgetItem::title, and KisMainWindow::CustomDocumentWidgetItem::widget.

◆ 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 1823 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 1842 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 2131 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 1847 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 1854 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 1816 of file KisMainWindow.cpp.

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

References dbgUI, and slotFileOpen().

◆ slotLoadCanceled

void KisMainWindow::slotLoadCanceled ( const QString & errMsg )

privateslot

Definition at line 1184 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 1171 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 2311 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 816 of file KisMainWindow.cpp.

{
    QScopedPointer<KisDlgPreferences> dlgPreferences(new KisDlgPreferences(this));
 
    if (dlgPreferences->editPreferences()) {
        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 d, KisSharedPtr< T >::data(), KisViewManager::image(), KisConfigNotifier::instance(), KisImageConfigNotifier::instance(), KisPart::instance(), KisConfigNotifier::notifyConfigChanged(), KisImageConfigNotifier::notifyConfigChanged(), KisConfigNotifier::notifyPixelGridModeChanged(), KisImage::rootLayer(), KisBaseNode::updateSettings(), and updateWindowMenu().

◆ slotResetConfigurations

void KisMainWindow::slotResetConfigurations ( )

privateslot

Reset User Configurations.

Definition at line 2305 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 1193 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 1205 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 1874 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 2011 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 885 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 2333 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 1027 of file KisMainWindow.cpp.

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

References d.

◆ slotUpdateSaveActionTitle

void KisMainWindow::slotUpdateSaveActionTitle ( const QString & documentPath )

privateslot

Definition at line 1015 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 2472 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
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
            if (qApp->style()->objectName() == "macintosh") {
                d->themeManager->setCurrentTheme("System");
            }
#else
            if (qApp->style()->name() == "macos") {
                d->themeManager->setCurrentTheme("System");
            }
#endif
#endif
         }
     }
}

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

◆ slotXmlGuiMakingChanges

void KisMainWindow::slotXmlGuiMakingChanges ( bool finished )

privateslot

Definition at line 3170 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 2549 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 2082 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 1736 of file KisMainWindow.cpp.

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

References d.

◆ synchronizeDynamicActions

void KisMainWindow::synchronizeDynamicActions ( )

slot

Definition at line 3270 of file KisMainWindow.cpp.

{
    // Add all actions with a menu property to the main window
    Q_FOREACH(QAction *action, this->actionCollection()->actions()) {
        QString menuLocation = action->property("menulocation").toString();
        if (!menuLocation.isEmpty()) {
            QAction *found = 0;
            QList<QAction *> candidates = this->menuBar()->actions();
            Q_FOREACH(const QString &name, menuLocation.split("/")) {
                Q_FOREACH(QAction *candidate, candidates) {
                    if (candidate->objectName().toLower() == name.toLower()) {
                        found = candidate;
                        candidates = candidate->menu()->actions();
                        break;
                    }
                }
                if (candidates.isEmpty()) {
                    break;
                }
            }
 
            if (found && found->menu()) {
                QList<QAction *> existingActions = found->menu()->actions();
 
                if (std::find_if(existingActions.begin(),
                                 existingActions.end(),
                                 kismpl::mem_equal_to(&QAction::objectName, action->objectName()))
                    == existingActions.end()) {
 
                    if (std::is_sorted(existingActions.begin(),
                                       existingActions.end(),
                                       kismpl::mem_less(&QAction::objectName))) {
 
                        auto it = std::upper_bound(existingActions.begin(),
                                                   existingActions.end(),
                                                   action->objectName(),
                                                   kismpl::mem_less(&QAction::objectName));
                        found->menu()->insertAction(it != existingActions.end() ? *it : nullptr, action);
 
                    } else {
                        found->menu()->addAction(action);
                    }
                }
            }
        }
    }
}

References KisKXMLGUIClient::action(), KisKXMLGUIClient::actionCollection(), kismpl::mem_equal_to(), and kismpl::mem_less().

◆ 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 2530 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 1699 of file KisMainWindow.cpp.

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

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

◆ updateSubwindowFlags

void KisMainWindow::updateSubwindowFlags ( )

privateslot

Definition at line 2761 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 847 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 2618 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 1883 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 2353 of file KisMainWindow.cpp.

{
    KisConfig cfg(false);
    cfg.setFullscreenMode(fullScreen);
 
    if (fullScreen) {
        setWindowState(windowState() | Qt::WindowFullScreen);   // set
    } else {
        setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
    }
    d->fullScreenMode->setChecked(isFullScreen());
}

References d, 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 2586 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 1601 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 452 of file KisMainWindow.h.

◆ KisWelcomePageWidget

friend class KisWelcomePageWidget

friend

Definition at line 439 of file KisMainWindow.h.

Member Data Documentation

◆ actionMap

QMap<QString, QAction*> KisMainWindow::actionMap

Definition at line 267 of file KisMainWindow.cpp.

◆ activeSubWindow

QMdiSubWindow* KisMainWindow::activeSubWindow {nullptr}

Definition at line 298 of file KisMainWindow.cpp.

298{nullptr};

◆ activeView

KisView * KisMainWindow::activeView

Definition at line 227 of file KisMainWindow.cpp.

◆ activeViewConnections

KisSignalAutoConnectionsStore KisMainWindow::activeViewConnections

Definition at line 228 of file KisMainWindow.cpp.

◆ canvasWindow

QWidget * KisMainWindow::canvasWindow {nullptr}

Definition at line 301 of file KisMainWindow.cpp.

301{nullptr};

◆ close

KisAction* KisMainWindow::close {nullptr}

Definition at line 248 of file KisMainWindow.cpp.

248{nullptr};

◆ closeAll

KisAction* KisMainWindow::closeAll {nullptr}

Definition at line 242 of file KisMainWindow.cpp.

242{nullptr};

◆ commandBar

KateCommandBar* KisMainWindow::commandBar {nullptr}

Definition at line 311 of file KisMainWindow.cpp.

311{nullptr};

◆ commandBarAction

KisAction* KisMainWindow::commandBarAction {nullptr}

Definition at line 262 of file KisMainWindow.cpp.

262{nullptr};

◆ d

Private* const KisMainWindow::d

private

Definition at line 496 of file KisMainWindow.h.

◆ deferredClosingEvent

QCloseEvent* KisMainWindow::deferredClosingEvent {nullptr}

Definition at line 287 of file KisMainWindow.cpp.

287{nullptr};

◆ dockerStateBeforeHiding

QByteArray KisMainWindow::dockerStateBeforeHiding

Definition at line 284 of file KisMainWindow.cpp.

◆ dockWidgetMenu

KActionMenu* KisMainWindow::dockWidgetMenu {nullptr}

Definition at line 269 of file KisMainWindow.cpp.

269{nullptr};

◆ dockWidgetsMap

QMap<QString, QDockWidget *> KisMainWindow::dockWidgetsMap

Definition at line 283 of file KisMainWindow.cpp.

◆ documentMapper

KisSignalMapper* KisMainWindow::documentMapper {nullptr}

Definition at line 300 of file KisMainWindow.cpp.

300{nullptr};

◆ documentMenu

KActionMenu* KisMainWindow::documentMenu {nullptr}

Definition at line 271 of file KisMainWindow.cpp.

271{nullptr};

◆ expandingSpacers

KisAction* KisMainWindow::expandingSpacers[2]

Definition at line 263 of file KisMainWindow.cpp.

◆ exportFile

KisAction* KisMainWindow::exportFile {nullptr}

Definition at line 244 of file KisMainWindow.cpp.

244{nullptr};

◆ exportFileAdvance

KisAction* KisMainWindow::exportFileAdvance {nullptr}

Definition at line 245 of file KisMainWindow.cpp.

245{nullptr};

◆ firstTime

bool KisMainWindow::firstTime {true}

Definition at line 232 of file KisMainWindow.cpp.

232{true};

◆ fullScreenMode

KisAction* KisMainWindow::fullScreenMode {nullptr}

Definition at line 260 of file KisMainWindow.cpp.

260{nullptr};

◆ helpMenu

KisKHelpMenu* KisMainWindow::helpMenu {nullptr}

Definition at line 274 of file KisMainWindow.cpp.

274{nullptr};

◆ id

QUuid KisMainWindow::id

Definition at line 223 of file KisMainWindow.cpp.

◆ importAnimation

void KisMainWindow::importAnimation {nullptr}

Definition at line 238 of file KisMainWindow.cpp.

238{nullptr};

◆ importFile

KisAction* KisMainWindow::importFile {nullptr}

Definition at line 243 of file KisMainWindow.cpp.

243{nullptr};

◆ importVideoAnimation

void KisMainWindow::importVideoAnimation {nullptr}

Definition at line 239 of file KisMainWindow.cpp.

239{nullptr};

◆ lastExportedFormat

QByteArray KisMainWindow::lastExportedFormat

Definition at line 303 of file KisMainWindow.cpp.

◆ lastExportLocation

QString KisMainWindow::lastExportLocation

Definition at line 281 of file KisMainWindow.cpp.

◆ m_dieOnError

bool KisMainWindow::m_dieOnError

private

Definition at line 499 of file KisMainWindow.h.

◆ m_errorMessage

QString KisMainWindow::m_errorMessage

private

Definition at line 498 of file KisMainWindow.h.

◆ mdiArea

QMdiArea* KisMainWindow::mdiArea {nullptr}

Definition at line 297 of file KisMainWindow.cpp.

297{nullptr};

◆ mdiCascade

KisAction* KisMainWindow::mdiCascade {nullptr}

Definition at line 249 of file KisMainWindow.cpp.

249{nullptr};

◆ mdiNextWindow

KisAction* KisMainWindow::mdiNextWindow {nullptr}

Definition at line 251 of file KisMainWindow.cpp.

251{nullptr};

◆ mdiPreviousWindow

KisAction* KisMainWindow::mdiPreviousWindow {nullptr}

Definition at line 252 of file KisMainWindow.cpp.

252{nullptr};

◆ mdiTile

KisAction* KisMainWindow::mdiTile {nullptr}

Definition at line 250 of file KisMainWindow.cpp.

250{nullptr};

◆ newWindow

void KisMainWindow::newWindow {nullptr}

Definition at line 258 of file KisMainWindow.cpp.

258{nullptr};

◆ q

KisMainWindow* KisMainWindow::q {nullptr}

Definition at line 222 of file KisMainWindow.cpp.

222{nullptr};

◆ recentFiles

KRecentFilesAction* KisMainWindow::recentFiles {nullptr}

Definition at line 276 of file KisMainWindow.cpp.

276{nullptr};

◆ redo

void KisMainWindow::redo {nullptr}

Definition at line 247 of file KisMainWindow.cpp.

247{nullptr};

◆ renderAnimation

void KisMainWindow::renderAnimation {nullptr}

Definition at line 240 of file KisMainWindow.cpp.

240{nullptr};

◆ renderAnimationAgain

void KisMainWindow::renderAnimationAgain {nullptr}

Definition at line 241 of file KisMainWindow.cpp.

241{nullptr};

◆ resetConfigurations

KisAction* KisMainWindow::resetConfigurations {nullptr}

Definition at line 254 of file KisMainWindow.cpp.

254{nullptr};

◆ saveAction

KisAction* KisMainWindow::saveAction {nullptr}

Definition at line 236 of file KisMainWindow.cpp.

236{nullptr};

◆ saveActionAs

KisAction* KisMainWindow::saveActionAs {nullptr}

Definition at line 237 of file KisMainWindow.cpp.

237{nullptr};

◆ savingEntryMutex

QMutex KisMainWindow::savingEntryMutex

Definition at line 305 of file KisMainWindow.cpp.

◆ showDocumentInfo

KisAction* KisMainWindow::showDocumentInfo {nullptr}

Definition at line 235 of file KisMainWindow.cpp.

235{nullptr};

◆ showSessionManager

KisAction* KisMainWindow::showSessionManager {nullptr}

Definition at line 261 of file KisMainWindow.cpp.

261{nullptr};

◆ styleActions

QActionGroup* KisMainWindow::styleActions {nullptr}

Definition at line 266 of file KisMainWindow.cpp.

266{nullptr};

◆ styleMenu

KActionMenu* KisMainWindow::styleMenu {nullptr}

Definition at line 265 of file KisMainWindow.cpp.

265{nullptr};

◆ tabSwitchCompressor

QScopedPointer<KisSignalCompressorWithParam<int> > KisMainWindow::tabSwitchCompressor

Definition at line 304 of file KisMainWindow.cpp.

◆ themeManager

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

Definition at line 289 of file KisMainWindow.cpp.

289{nullptr};

◆ toggleDetachCanvas

KisAction* KisMainWindow::toggleDetachCanvas {nullptr}

Definition at line 257 of file KisMainWindow.cpp.

257{nullptr};

◆ toggleDockers

KisAction* KisMainWindow::toggleDockers {nullptr}

Definition at line 253 of file KisMainWindow.cpp.

253{nullptr};

◆ toggleDockerTitleBars

KisAction* KisMainWindow::toggleDockerTitleBars {nullptr}

Definition at line 255 of file KisMainWindow.cpp.

255{nullptr};

◆ toolbarList

QList<QAction *> KisMainWindow::toolbarList

Definition at line 230 of file KisMainWindow.cpp.

◆ toolOptionsDocker

KoToolDocker* KisMainWindow::toolOptionsDocker {nullptr}

Definition at line 285 of file KisMainWindow.cpp.

285{nullptr};

◆ undo

void KisMainWindow::undo {nullptr}

Definition at line 246 of file KisMainWindow.cpp.

246{nullptr};

◆ undoActionsUpdateManager

QScopedPointer<KisUndoActionsUpdateManager> KisMainWindow::undoActionsUpdateManager

Definition at line 279 of file KisMainWindow.cpp.

◆ viewManager

KisViewManager * KisMainWindow::viewManager {nullptr}

Definition at line 225 of file KisMainWindow.cpp.

225{nullptr};

◆ welcomePage

KisWelcomePageWidget* KisMainWindow::welcomePage {nullptr}

Definition at line 292 of file KisMainWindow.cpp.

292{nullptr};

◆ welcomeScroller

QScrollArea* KisMainWindow::welcomeScroller {nullptr}

Definition at line 291 of file KisMainWindow.cpp.

291{nullptr};

◆ widgetStack

QStackedWidget* KisMainWindow::widgetStack {nullptr}

Definition at line 295 of file KisMainWindow.cpp.

295{nullptr};

◆ windowMapper

KisSignalMapper* KisMainWindow::windowMapper {nullptr}

Definition at line 299 of file KisMainWindow.cpp.

299{nullptr};

◆ windowMenu

KActionMenu* KisMainWindow::windowMenu {nullptr}

Definition at line 270 of file KisMainWindow.cpp.

270{nullptr};

◆ windowSizeDirty

bool KisMainWindow::windowSizeDirty {false}

Definition at line 233 of file KisMainWindow.cpp.

233{false};

◆ windowStateConfig

const KConfigGroup & KisMainWindow::windowStateConfig

Definition at line 307 of file KisMainWindow.cpp.

◆ workspaceBorrowedBy

QUuid KisMainWindow::workspaceBorrowedBy

Definition at line 309 of file KisMainWindow.cpp.

◆ workspaceMenu

KActionMenu* KisMainWindow::workspaceMenu {nullptr}

Definition at line 272 of file KisMainWindow.cpp.

272{nullptr};

◆ workspacemodel

KisResourceModel* KisMainWindow::workspacemodel {nullptr}

Definition at line 277 of file KisMainWindow.cpp.

277{nullptr};

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

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

Classes

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]