Subversion Repositories Scribus

Rev

Rev 24644 | Blame | Compare with Previous | Last modification | View Log | RSS feed

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/

/***************************************************************************
                          scribus.cpp  -  description
                             -------------------
    begin                : Fre Apr  6 21:09:31 CEST 2001
    copyright            : (C) 2001 by Franz Schmid
    email                : Franz.Schmid@altmuehlnet.de
 ***************************************************************************/


/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


#include <QAction>
#include <QApplication>
#include <QByteArray>
#include <QCloseEvent>
#include <QColor>
#include <QColorDialog>
#include <QCursor>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QEvent>
#include <QEventLoop>
#include <QFileDialog>
#include <QFrame>
#include <QFont>
#include <QHBoxLayout>
#include <QIcon>
#include <QInputDialog>
#include <QKeyEvent>
#include <QKeySequence>
#include <QLabel>
#include <QList>
#include <QLocale>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QMessageBox>
#include <QMouseEvent>
#include <QMultiMap>
#include <QPixmap>
#include <QProgressBar>
#include <QPushButton>
//<<QML testing
//#include <QQuickView>
//#include <QQmlEngine>
//#include <QQmlComponent>
//#include <QQuickItem>
//#include <QQmlProperty>
//>>
#include <QRegExp>
#include <QScopedPointer>
#include <QScreen>
#include <QStyleFactory>
#include <QTableWidget>
#include <QTextCodec>
#include <QTranslator>
#include <QWindow>
#include <QWheelEvent>

#ifdef DEBUG_LOAD_TIMES
#include <QDebug>
#include <QTime>
#include <sys/times.h>
#endif

#include <cstdio>
#include <cstdlib>
#include <cassert>

#include "scconfig.h"

#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <iostream>
#include <sstream>
#include <csignal>
#include <string>

#include "actionmanager.h"
#include "actionsearch.h"
#include "api/api_application.h"
#include "appmodehelper.h"
#include "appmodes.h"
#include "canvasmode.h"
#include "canvasmode_imageimport.h"
#include "commonstrings.h"
#include "desaxe/digester.h"
#include "desaxe/saxXML.h"
#include "desaxe/simple_actions.h"
#include "documentchecker.h"
#include "documentinformation.h"
#include "fileloader.h"
#include "filewatcher.h"
#include "fpoint.h"
#include "fpointarray.h"
#include "gtgettext.h"
#include "hyphenator.h"
#include "iconmanager.h"
#include "langmgr.h"
#include "localemgr.h"
#include "loadsaveplugin.h"
#include "marks.h"
#include "nfttemplate.h"
#include "notesstyles.h"
#include "pageitem_group.h"
#include "pageitem_imageframe.h"
#include "pageitem_latexframe.h"
#include "pageitem_noteframe.h"
#include "pageitem_table.h"
#include "pageitem_textframe.h"
#include "pagesize.h"
#include "pdflib.h"
#include "pdfoptions.h"
#include "pluginmanager.h"
#include "plugins/formatidlist.h"
#include "plugins/formatidlist.h"
#include "prefscontext.h"
#include "prefsfile.h"
#include "prefsmanager.h"
#include "prefstable.h"
#include "pslib.h"
#include "resourcecollection.h"
#include "sccolorengine.h"
#include "scgtplugin.h"
#include "scimagecachemanager.h"
#include "scmimedata.h"
#include "scpage.h"
#include "scpaths.h"
#include "scprintengine_pdf.h"
#include "scprintengine_ps.h"
#include "scraction.h"
#include "scribusXml.h"
#include "scribusapp.h"
#include "scribuscore.h"
#include "scribusdoc.h"
#include "scribusview.h"
#include "scribuswin.h"
#include "selection.h"
#include "serializer.h"
#include "storyloader.h"
#include "styleoptions.h"
#include "tocgenerator.h"
#include "ui/about.h"
#include "ui/aboutplugins.h"
#include "ui/actionsearchdialog.h"
#include "ui/aligndistribute.h"
#include "ui/annot.h"
#include "ui/annota.h"
#include "ui/applytemplatedialog.h"
#include "ui/arrowchooser.h"
#include "ui/autoform.h"
#include "ui/basepointwidget.h"
#include "ui/bookmarkpalette.h"
#include "ui/charselect.h"
#include "ui/checkDocument.h"
#include "ui/collectforoutput_ui.h"
#include "ui/colorcombo.h"
#include "ui/contentpalette.h"
#include "ui/contextmenu.h"
#include "ui/copypagetomasterpagedialog.h"
#include "ui/cpalette.h"
#include "ui/customfdialog.h"
#include "ui/delpages.h"
#include "ui/downloadspalette.h"
#include "ui/edittoolbar.h"
#include "ui/effectsdialog.h"
#include "ui/filetoolbar.h"
#include "ui/fontcombo.h"
#include "ui/guidemanager.h"
#include "ui/helpbrowser.h"
#include "ui/hruler.h"
#include "ui/imageinfodialog.h"
#include "ui/inlinepalette.h"
#include "ui/insertaframe.h"
#include "ui/inspage.h"
#include "ui/javadocs.h"
#include "ui/layers.h"
#include "ui/loremipsum.h"
#include "ui/marginwidget.h"
#include "ui/mark2item.h"
#include "ui/mark2mark.h"
#include "ui/markanchor.h"
#include "ui/markinsert.h"
#include "ui/marknote.h"
#include "ui/marksmanager.h"
#include "ui/markvariabletext.h"
#include "ui/mergedoc.h"
#include "ui/modetoolbar.h"
#include "ui/movepage.h"
#include "ui/multipleduplicate.h"
#include "ui/newdocdialog.h"
#include "ui/newtemp.h"
#include "ui/nftdialog.h"
#include "ui/nftwidget.h"
#include "ui/nodeeditpalette.h"
#include "ui/notesstyleseditor.h"
#include "ui/outlinepalette.h"
#include "ui/outputpreview_pdf.h"
#include "ui/outputpreview_ps.h"
#include "ui/pageitemattributes.h"
#include "ui/pagelayout.h"
#include "ui/pagepalette.h"
#include "ui/pagepropertiesdialog.h"
#include "ui/pageselector.h"
#include "ui/colorsandfills.h"
#include "ui/pdfexportdialog.h"
#include "ui/pdftoolbar.h"
#include "ui/picstatus.h"
#include "ui/polygonwidget.h"
#include "ui/preferencesdialog.h"
#include "ui/printdialog.h"
#include "ui/printpreview.h"
#include "ui/propertiespalette.h"
#include "ui/propertiespalette_line.h"
#include "ui/propertiespalette_shape.h"
#include "ui/propertiespalette_xyz.h"
#include "ui/query.h"
#include "ui/recoverdialog.h"
#include "ui/replacecolors.h"
#include "ui/resourcemanager.h"
#include "ui/scfilewidget.h"
#include "ui/scmessagebox.h"
#include "ui/scmwmenumanager.h"
#include "ui/scrapbookpalette.h"
#include "ui/scrspinbox.h"
#include "ui/search.h"
#include "ui/selectobjects.h"
#include "ui/smcellstyle.h"
#include "ui/smlinestyle.h"
#include "ui/smtablestyle.h"
#include "ui/smtextstyles.h"
#include "ui/splash.h"
#include "ui/storyeditor.h"
#include "ui/stylemanager.h"
#include "ui/symbolpalette.h"
#include "ui/tabmanager.h"
#include "ui/transformdialog.h"
#include "ui/transparencypalette.h"
#include "ui/viewtoolbar.h"
#include "ui/vruler.h"
#include "ui_nftdialog.h"
#include "undogui.h"
#include "undomanager.h"
#include "undostate.h"
#include "units.h"
#include "urllauncher.h"
#include "usertaskstructs.h"
#include "util.h"
#include "util_file.h"
#include "util_formats.h"
#include "util_ghostscript.h"
#include "util_math.h"

#ifdef HAVE_SVNVERSION
        #include "svnversion.h"
#endif

#ifdef HAVE_OSG
        #include "ui/osgeditor.h"
        #include <osgDB/ReaderWriter>
        #include <osgDB/PluginQuery>
#endif

#if defined(_WIN32)
#include "scdocoutput_ps2.h"
#include "scprintengine_gdi.h"
#endif

#include "sclimits.h"

using namespace std;

bool previewDinUse;
bool printDinUse;

QString DocDir;


//extern ScribusQApp* ScQApp;
extern bool emergencyActivated;


ScribusMainWindow::ScribusMainWindow() :
        m_prefsManager(PrefsManager::instance())
{
#ifdef Q_OS_MAC
        //commenting this out until this is resolved :https://bugreports.qt.io/browse/QTBUG-44565
        //ScQApp->setAttribute(Qt::AA_DontShowIconsInMenus);
        //noIcon = IconManager::instance().loadPixmap("noicon.png");
#endif
}

/*
 * retval 0 - ok, 1 - no fonts, ...
 */

int ScribusMainWindow::initScMW(bool primaryMainWindow)
{
        int retVal=0;
        qsrand(1234);
        QByteArray stylesheet;
        if (loadRawText(ScPaths::preferencesDir() + "/stylesheet.css", stylesheet))
        {
                qApp->setStyleSheet(QString(stylesheet));
        }

        qApp->setLayoutDirection(QLocale(ScCore->getGuiLanguage()).textDirection());
        previewDinUse = false;
        printDinUse = false;
        internalCopy = false;
        internalCopyBuffer.clear();
        m_doc = new ScribusDoc();
        m_doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
        m_doc->setPage(100, 100, 0, 0, 0, 0, 0, 0, false, false);
        m_doc->addPage(0);
        m_doc->setGUI(false, this, nullptr);
        CurrStED = nullptr;
        QString scribusTitle(ScribusAPI::getVersionScribusTranslated());
        if (ScribusAPI::isSVN() && ScribusAPI::haveSVNRevision())
                scribusTitle.append(QString(" (r%1)").arg(ScribusAPI::getSVNRevision()));
        setWindowTitle(scribusTitle);
        setAttribute(Qt::WA_KeyCompression, false);
        setAttribute(Qt::WA_InputMethodEnabled, true);
        setWindowIcon(IconManager::instance().loadIcon("AppIcon.png"));
        setObjectName("MainWindow");
        scrActionGroups.clear();
        scrActions.clear();
        scrRecentFileActions.clear();
        scrRecentPasteActions.clear();
        scrWindowsActions.clear();
        scrLayersActions.clear();
        scrScrapActions.clear();
        actionManager = new ActionManager(this);
        appModeHelper = new AppModeHelper();
        appModeHelper->setup(actionManager, &scrActions, &scrRecentFileActions, &scrWindowsActions, &scrScrapActions, &scrLayersActions, &scrRecentPasteActions);
        scrMenuMgr = new ScMWMenuManager(menuBar(), actionManager);
        m_formatsManager = FormatsManager::instance();
        m_objectSpecificUndo = false;

        m_undoManager = UndoManager::instance();
        PrefsContext *undoPrefs = m_prefsManager.prefsFile->getContext("undo");
        m_undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
        m_tocGenerator = new TOCGenerator();
        m_marksCount = 0;

        initDefaultValues();
        initStatusBar();

        qApp->processEvents();

        actionManager->init(this);

        initMdiArea();
        initMenuBar();
        createMenuBar();
        initToolBars();
        ScCore->pluginManager->setupPluginActions(this);
        ScCore->pluginManager->enableOnlyStartupPluginActions(this);
        ScCore->pluginManager->languageChange();

        if (primaryMainWindow)
                ScCore->setSplashStatus( tr("Applying User Shortcuts") );
        m_prefsManager.applyLoadedShortCuts();
        initKeyboardShortcuts();

        resize(610, 600);
        connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(newActWin(QMdiSubWindow*)));
        //Connect windows cascade and tile actions to the workspace after its created. Only depends on mdiArea created.
        connect( scrActions["windowsCascade"], SIGNAL(triggered()) , mdiArea, SLOT(cascadeSubWindows()) );
        connect( scrActions["windowsTile"], SIGNAL(triggered()) , mdiArea, SLOT(tileSubWindows()) );
        initPalettes();


        viewToolBar->previewQualitySwitcher->setCurrentIndex(m_prefsManager.appPrefs.itemToolPrefs.imageLowResType);
        if (primaryMainWindow)
                ScCore->setSplashStatus( tr("Initializing Story Editor") );
        storyEditor = new StoryEditor(this);

        DocDir = m_prefsManager.documentDir();

        if (primaryMainWindow)
                ScCore->setSplashStatus( tr("Initializing Languages") );
        LanguageManager::instance();

        initHyphenator();
//      QString preLang(m_prefsManager.appPrefs.hyphPrefs.Language);
//      if (!LanguageManager::instance()->getHyphFilename( preLang ).isEmpty() )
//              m_prefsManager.appPrefs.hyphPrefs.Language = preLang;
        if (primaryMainWindow)
                ScCore->setSplashStatus( tr("Reading Scrapbook") );
        initScrapbook();

        scrActions["helpTooltips"]->setChecked(m_prefsManager.appPrefs.displayPrefs.showToolTips);
        scrActions["showMouseCoordinates"]->setChecked(m_prefsManager.appPrefs.displayPrefs.showMouseCoordinates);
        scrActions["stickyTools"]->setChecked(m_prefsManager.appPrefs.uiPrefs.stickyTools);
        ToggleTips();
        ToggleMouseTips();
        propertiesPalette->setFontSize();
        contentPalette->setFontSize();
        if (scrActions["SaveAsDocumentTemplate"])
                scrActions["SaveAsDocumentTemplate"]->setEnabled(false);

        connect(ScQApp, SIGNAL(iconSetChanged()), this, SLOT(iconSetChange()));
        connect(ScQApp, SIGNAL(localeChanged()), this, SLOT(localeChange()));
        connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), this, SLOT(removeRecentFromWatcher(QString)));
        connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
        setAcceptDrops(true);
        QCoreApplication::instance()->installEventFilter(this);
        scrActions["toolsSelect"]->setChecked(true);

        ColorSetManager csm;
        csm.findPaletteLocations();
        csm.findPalettes();
        csm.findUserPalettes();
        QString Cpfad = QDir::toNativeSeparators(ScPaths::applicationDataDir())+"DefaultColors.xml";
        QFile fc(Cpfad);
        if (fc.exists())
                csm.loadPalette(Cpfad, m_doc, m_prefsManager.appPrefs.colorPrefs.DColors, m_prefsManager.appPrefs.defaultGradients, m_prefsManager.appPrefs.defaultPatterns, false);
        else
        {
                if (m_prefsManager.appPrefs.colorPrefs.DColorSet != "Scribus Small")
                {
                        QStringList CustomColorSets = csm.userPaletteNames();
                        if (CustomColorSets.contains(m_prefsManager.appPrefs.colorPrefs.DColorSet))
                                Cpfad = csm.userPaletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
                        else
                                Cpfad = csm.paletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
                        if (!Cpfad.isEmpty())
                                csm.loadPalette(Cpfad, m_doc, m_prefsManager.appPrefs.colorPrefs.DColors, m_prefsManager.appPrefs.defaultGradients, m_prefsManager.appPrefs.defaultPatterns, false);
                }
        }
        appModeHelper->setStartupActionsEnabled(false);

        setStyleSheet();

        return retVal;
}

void ScribusMainWindow::setupMainWindow()
{
        setDefaultPrinter(m_prefsManager.appPrefs.printerPrefs.PrinterName, m_prefsManager.appPrefs.printerPrefs.PrinterFile, m_prefsManager.appPrefs.printerPrefs.PrinterCommand);

        uint max = qMin(m_prefsManager.appPrefs.uiPrefs.recentDocCount, m_prefsManager.appPrefs.uiPrefs.RecentDocs.count());
        for (uint m = 0; m < max; ++m)
        {
                QFileInfo fd(m_prefsManager.appPrefs.uiPrefs.RecentDocs[m]);
                if (fd.exists())
                {
                        m_recentDocsList.append(m_prefsManager.appPrefs.uiPrefs.RecentDocs[m]);
                        //#9845: ScCore->fileWatcher->addFile(appPrefs.uiPrefs.RecentDocs[m]);
                }
        }
        rebuildRecentFileMenu();
        //For 1.3.5, we dump prefs first time around.
        if (!m_prefsManager.firstTimeIgnoreOldPrefs())
                m_prefsManager.readPrefsXML();
        if (m_prefsManager.appPrefs.verifierPrefs.checkerPrefsList.count() == 0)
        {
                m_prefsManager.initDefaultCheckerPrefs(m_prefsManager.appPrefs.verifierPrefs.checkerPrefsList);
                m_prefsManager.appPrefs.verifierPrefs.curCheckProfile = CommonStrings::PDF_1_4;
        }

        const WindowPrefs& mainWinSettings = m_prefsManager.appPrefs.uiPrefs.mainWinSettings;
        QWindow* w = windowHandle();
        QList<QScreen*> screens = QGuiApplication::screens();
        QScreen* s = nullptr;
        if (w != nullptr)
        {
                s = screens.at(qMin(mainWinSettings.screenNumber, QGuiApplication::screens().count() - 1));
                windowHandle()->setScreen(s);
        }
        else
                s = QGuiApplication::primaryScreen();
        QRect r(0, 0, 0, 0);
        if (s != nullptr)
                r = s->geometry();
        move(r.left() + abs(mainWinSettings.xPosition), r.top() + abs(mainWinSettings.yPosition));
        resize(mainWinSettings.width, mainWinSettings.height);

        if (mainWinSettings.maximized)
                this->setWindowState((this->windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen)) | Qt::WindowMaximized);

        if (!m_prefsManager.appPrefs.uiPrefs.mainWinState.isEmpty())
                restoreState(m_prefsManager.appPrefs.uiPrefs.mainWinState);
}

int ScribusMainWindow::getScreenNumber() const
{
        QList<QScreen*> screens = QGuiApplication::screens();
        int screenNumber = -1;

#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
        QWindow* w = ScCore->primaryMainWindow()->windowHandle();
        if (w != nullptr)
                screenNumber = screens.indexOf(w->screen());
#else
        QScreen* s = ScCore->primaryMainWindow()->screen();
        screenNumber = screens.indexOf(s);
#endif
        if (screenNumber < 0)
                screenNumber = screens.indexOf(QGuiApplication::primaryScreen());
        if (screenNumber < 0)
                screenNumber = 0;
        return screenNumber;
}

QScreen* ScribusMainWindow::getScreen() const
{
        QList<QScreen*> screens = QGuiApplication::screens();
        return screens.at(getScreenNumber());
}

void ScribusMainWindow::getScreenPosition(int& xPos, int& yPos) const
{
        QScreen* screen(getScreen());
        QRect screenGeom = screen->geometry();
        xPos = screenGeom.left();
        yPos = screenGeom.top();
}

void ScribusMainWindow::getScreenDPI(int& dpiX, int& dpiY) const
{
        QScreen* screen(getScreen());
        dpiX = screen->physicalDotsPerInchX();
        dpiY = screen->physicalDotsPerInchY();
}

ScribusMainWindow::~ScribusMainWindow()
{
        delete actionManager;
        delete appModeHelper;
        delete m_doc;
        delete m_tocGenerator;
}

void ScribusMainWindow::addScToolBar(ScToolBar *tb, const QString & name)
{
        if (!scrToolBars.contains(name))
                scrToolBars.insert(name, tb);
        addToolBar(tb);
}

void ScribusMainWindow::initToolBars()
{
        fileToolBar = new FileToolBar(this);
        editToolBar = new EditToolBar(this);
        UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
        m_undoManager->registerGui(uWidget);
        modeToolBar = new ModeToolBar(this);
        pdfToolBar = new PDFToolBar(this);
        viewToolBar = new ViewToolBar(this);

        addScToolBar(fileToolBar, fileToolBar->objectName());
        addScToolBar(editToolBar, editToolBar->objectName());
        addScToolBar(modeToolBar, modeToolBar->objectName());
        addScToolBar(pdfToolBar, pdfToolBar->objectName());
        addScToolBar(viewToolBar, viewToolBar->objectName());
        connect(modeToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setChecked(bool)));
        connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setVisible(bool)));
        connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setChecked(bool)));
        connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), modeToolBar, SLOT(setVisible(bool)) );
        connect(viewToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarView"], SLOT(setChecked(bool)));
        connect(scrActions["toolsToolbarView"], SIGNAL(toggled(bool)), viewToolBar, SLOT(setVisible(bool)) );
}

void ScribusMainWindow::setStyleSheet()
{
        QByteArray stylesheet;
        if (loadRawText(ScPaths::instance().libDir() + "scribus.css", stylesheet))
        {
                QString downArrow(IconManager::instance().pathForIcon("16/go-down.png"));
                QByteArray da;
                da.append(downArrow.toUtf8());
                stylesheet.replace("___downArrow___", da);
                QString toolbararrow(IconManager::instance().pathForIcon("stylesheet/down_arrow.png"));
                QByteArray tba;
                tba.append(toolbararrow.toUtf8());
                stylesheet.replace("___tb_menu_arrow___", tba);
        }

        layerMenu->setStyleSheet(stylesheet);
        unitSwitcher->setStyleSheet(stylesheet);
        zoomDefaultToolbarButton->setStyleSheet(stylesheet);
        zoomInToolbarButton->setStyleSheet(stylesheet);
        zoomOutToolbarButton->setStyleSheet(stylesheet);
        zoomSpinBox->setStyleSheet(stylesheet);

        fileToolBar->setStyleSheet(stylesheet);
        editToolBar->setStyleSheet(stylesheet);
        modeToolBar->setStyleSheet(stylesheet);
        pdfToolBar->setStyleSheet(stylesheet);
        viewToolBar->setStyleSheet(stylesheet);
}


void ScribusMainWindow::initDefaultValues()
{
        HaveDoc = false;
        view = nullptr;
        doc = nullptr;
        m_DocNr = 1;
        m_PrinterUsed = false;
        PDef.Pname.clear();
        PDef.Dname.clear();
        PDef.Command.clear();
        //m_keyrep = false;
        //m_arrowKeyDown = false;
        ClipB = QApplication::clipboard();
        for (int i=0; i<PAL_MAX ; ++i)
                m_palettesStatus[i] = false;
        for (int i=0; i<GS_MAX ; ++i)
                m_guidesStatus[i] = false;
#ifdef HAVE_OSG
        QStringList supportedExts;
        supportedExts << "osg" << "dxf" << "flt" << "ive" << "geo" << "sta" << "stl" << "logo" << "3ds" << "ac" << "obj";
        QStringList realSupportedExts;
        QMap<QString, QString> formats;
        osgDB::FileNameList plugins = osgDB::listAllAvailablePlugins();
        for (osgDB::FileNameList::iterator itr = plugins.begin(); itr != plugins.end(); ++itr)
        {
                osgDB::ReaderWriterInfoList infoList;
                if (QString::fromStdString(*itr).contains("qfont"))
                        continue;
                if (osgDB::queryPlugin(*itr, infoList))
                {
                        for (auto rwi_itr = infoList.begin(); rwi_itr != infoList.end(); ++rwi_itr)
                        {
                                osgDB::ReaderWriterInfo& info = *(*rwi_itr);
                                osgDB::ReaderWriter::FormatDescriptionMap::iterator fdm_itr;
                                for (fdm_itr = info.extensions.begin(); fdm_itr != info.extensions.end(); ++fdm_itr)
                                {
                                        if (supportedExts.contains(QString::fromStdString(fdm_itr->first)))
                                                formats.insert("*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper(), QString::fromStdString(fdm_itr->second) + " (*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper() + ")");
                                }
                        }
                }
        }
        realSupportedExts = formats.keys();
        QString docexts = realSupportedExts.join(" ");
        QStringList longList = formats.values();
        QString longDesc = longList.join(";;") + ";;";
        m_osgFilterString = tr("All Supported Formats (%1);;%2All Files (*)").arg(docexts).arg(longDesc);
#endif
}


void ScribusMainWindow::initKeyboardShortcuts()
{
        for (auto it = scrActions.begin(); it!=scrActions.end(); ++it )
        {
                if ((ScrAction*)(it.value()) != nullptr)
                {
                        QString accelerator = it.value()->shortcut().toString();
                        m_prefsManager.setKeyEntry(it.key(), it.value()->cleanMenuText(), accelerator,0);
                }
                //else
                //      qDebug() << it.key();
                //qDebug() << QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.value()->cleanMenuText()).arg(QString(it.data()->accel()));
        }
}


void ScribusMainWindow::initPalettes()
{
        //CB TODO hide the publicly available members of some palettes
        // these must be filtered too as they take control of the palettes events
        outlinePalette = new OutlinePalette(this);
        outlinePalette->setMainWindow(this);
        connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)));
        connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setChecked(bool)));

        propertiesPalette = new PropertiesPalette(this);
        propertiesPalette->setMainWindow(this);
        connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)));
        connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setChecked(bool)));
        emit UpdateRequest(reqDefFontListUpdate);
        propertiesPalette->installEventFilter(this);

        contentPalette = new ContentPalette(this);
        contentPalette->setMainWindow(this);
        connect( scrActions["toolsContent"], &QAction::toggled, contentPalette, &ContentPalette::setPaletteShown);
        connect( contentPalette, &ContentPalette::paletteShown, scrActions["toolsContent"], &QAction::setChecked);
        contentPalette->installEventFilter(this);

        nodePalette = new NodePalette(this);
        nodePalette->installEventFilter(this);
        layerPalette = new LayerPalette(this);
        guidePalette = new GuideManager(this);
        charPalette = new CharSelect(this);
        connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)));
        connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setChecked(bool)));
        layerPalette->installEventFilter(this);
        scrapbookPalette = new Biblio(this);
        connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)));
        connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setChecked(bool)));
        connect( scrapbookPalette, SIGNAL(pasteToActualPage(QString)), this, SLOT(pasteFromScrapbook(QString)));
        connect( scrapbookPalette, SIGNAL(scrapbookListChanged()), this, SLOT(rebuildScrapbookMenu()));
        scrapbookPalette->installEventFilter(this);
        pagePalette = new PagePalette(this);
        connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
        connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setChecked(bool)));
        pagePalette->installEventFilter(this);
        bookmarkPalette = new BookPalette(this);
        connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
        connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setChecked(bool)));
        bookmarkPalette->installEventFilter(this);
        downloadsPalette = new DownloadsPalette(this);
        connect( scrActions["toolsDownloads"], SIGNAL(toggled(bool)) , downloadsPalette, SLOT(setPaletteShown(bool)) );
        connect( downloadsPalette, SIGNAL(paletteShown(bool)), scrActions["toolsDownloads"], SLOT(setChecked(bool)));
        downloadsPalette->installEventFilter(this);
        connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool,int)) , this, SLOT(setAppModeByToggle(bool,int)) );
        docCheckerPalette = new CheckDocument(this, false);
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
        connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setChecked(bool)));
        connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
        docCheckerPalette->installEventFilter(this);
        docCheckerPalette->hide();

        alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette");
        connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
        connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setChecked(bool)));
        connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
        alignDistributePalette->installEventFilter(this);

        symbolPalette = new SymbolPalette(this);
        symbolPalette->setMainWindow(this);
        connect(scrActions["toolsSymbols"], SIGNAL(toggled(bool)), symbolPalette, SLOT(setPaletteShown(bool)));
        connect(symbolPalette, SIGNAL(paletteShown(bool)), scrActions["toolsSymbols"], SLOT(setChecked(bool)));
        connect(symbolPalette, SIGNAL(startEdit(QString)), this, SLOT(editSymbolStart(QString)));
        connect(symbolPalette, SIGNAL(endEdit()), this, SLOT(editSymbolEnd()));
        connect(symbolPalette, SIGNAL(objectDropped()), this, SLOT(PutToPatterns()));
        symbolPalette->installEventFilter(this);
        symbolPalette->hide();

        inlinePalette = new InlinePalette(this);
        inlinePalette->setMainWindow(this);
        connect(scrActions["toolsInline"], SIGNAL(toggled(bool)), inlinePalette, SLOT(setPaletteShown(bool)));
        connect(inlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsInline"], SLOT(setChecked(bool)));
        connect(inlinePalette, SIGNAL(startEdit(int)), this, SLOT(editInlineStart(int)));
        connect(inlinePalette, SIGNAL(endEdit()), this, SLOT(editInlineEnd()));
        connect(inlinePalette, SIGNAL(objectDropped(QString)), this, SLOT(PutToInline(QString)));
        inlinePalette->installEventFilter(this);
        inlinePalette->hide();

        undoPalette = new UndoPalette(this, "undoPalette");
        undoPalette->installEventFilter(this);
        m_undoManager->registerGui(undoPalette);
        connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
        connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));

        // initializing style manager here too even it's not strictly a palette
        m_styleManager = new StyleManager(this, "styleManager");
        SMCharacterStyle *tmpCS = new SMCharacterStyle();
        m_styleManager->addStyle(new SMParagraphStyle(tmpCS));
        m_styleManager->addStyle(tmpCS);
        m_styleManager->addStyle(new SMTableStyle());
        m_styleManager->addStyle(new SMCellStyle());
        m_styleManager->addStyle(new SMLineStyle());
        connect( scrActions["editStyles"], SIGNAL(toggled(bool)), m_styleManager, SLOT(setPaletteShown(bool)) );
        connect( m_styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
        m_styleManager->installEventFilter(this);

        // initializing mark`s manager
        marksManager = new MarksManager(this, "marksManager");
        connect( scrActions["editMarks"], SIGNAL(toggled(bool)), marksManager, SLOT(setPaletteShown(bool)) );
        connect( marksManager, SIGNAL(paletteShown(bool)), scrActions["editMarks"], SLOT(setChecked(bool)));
        marksManager->installEventFilter(this);
        // initializing notes styles manager
        nsEditor = new NotesStylesEditor(this, "notesStylesEditor");
        connect( scrActions["editNotesStyles"], SIGNAL(toggled(bool)), nsEditor, SLOT(setPaletteShown(bool)) );
        connect( nsEditor, SIGNAL(paletteShown(bool)), scrActions["editNotesStyles"], SLOT(setChecked(bool)));
        nsEditor->installEventFilter(this);

        connect(docCheckerPalette, SIGNAL(selectElementByItem(PageItem*,bool)), this, SLOT(selectItemsFromOutlines(PageItem*,bool)));
        connect(docCheckerPalette, SIGNAL(selectElement(PageItem*,bool,int)), this, SLOT(selectItemFromOutlines(PageItem*,bool,int)));
        connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
        connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
        connect(outlinePalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem*,bool)));
        connect(outlinePalette, SIGNAL(editElementByItem(PageItem *)), this, SLOT(editItemsFromOutlines(PageItem *)));
        connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
        connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
        connect(nodePalette, SIGNAL(paletteClosed()), this, SLOT(slotSelect()));
        connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
        connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));

        connect(bookmarkPalette->BView, SIGNAL(markMoved()), this, SLOT(StoreBookmarks()));
        connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
        connect(bookmarkPalette->BView, SIGNAL(selectElement(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
        // guides
        connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
        connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setChecked(bool)));
        // char palette
        connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
        connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setChecked(bool)));
}


void ScribusMainWindow::initScrapbook()
{
        QString scrapbookFileO = QDir::toNativeSeparators(m_prefsManager.preferencesLocation()+"/scrap13.scs");
        QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
        if (scrapbookFileInfoO.exists())
        {
                scrapbookPalette->readOldContents(scrapbookFileO, ScPaths::scrapbookDir(true) + "main");
                QDir d = QDir();
                d.rename(scrapbookFileO, QDir::toNativeSeparators(m_prefsManager.preferencesLocation()+"/scrap13.backup"));
        }
        QString scrapbookTemp = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "tmp");
        QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
        if (scrapbookTempInfo.exists())
                scrapbookPalette->readTempContents(scrapbookTemp);
        QString scrapbookFile = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "main");
        QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
        if (scrapbookFileInfo.exists())
                scrapbookPalette->readContents(scrapbookFile);
        scrapbookPalette->setScrapbookFileName(scrapbookFile);
        ScCore->fileWatcher->addDir(scrapbookFile, true);
        scrapbookPalette->setOpenScrapbooks(m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks);
        rebuildRecentPasteMenu();
        connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
        connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString )), scrapbookPalette, SLOT(reloadLib(QString )));
        connect(ScCore->fileWatcher, SIGNAL(dirDeleted(QString )), scrapbookPalette, SLOT(closeOnDel(QString )));
}

bool ScribusMainWindow::warningVersion(QWidget *parent)
{
        bool retval = false;
        int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
                                                                 QObject::tr("You are running a development version of Scribus 1.5.x. The document you are working with was created in Scribus 1.2.x.  Saving the current file under 1.5.x renders it unable to be edited in Scribus 1.2.x versions. To preserve the ability to edit in 1.2.x, save this file under a different name and further edit the newly named file and the original will be untouched. Are you sure you wish to proceed with this operation?") + "</qt>",
                                                                 QMessageBox::Ok | QMessageBox::Cancel,
                                                                 QMessageBox::Cancel,   // GUI default
                                                                 QMessageBox::Ok);      // batch default
        if (t == QMessageBox::Ok)
                retval = true;
        return retval;
}

void ScribusMainWindow::initMdiArea()
{
        mdiArea = new QMdiArea(this);
        mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
        mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
        if (m_prefsManager.appPrefs.uiPrefs.useTabs)
        {
                mdiArea->setViewMode(QMdiArea::TabbedView);
                mdiArea->setTabsClosable(true);
                mdiArea->setDocumentMode(true);
        }
        else
                mdiArea->setViewMode(QMdiArea::SubWindowView);
        setCentralWidget(mdiArea);
}

void ScribusMainWindow::initMenuBar()
{
        m_recentDocsList.clear();
        scrMenuMgr->createMenu("File", ActionManager::defaultMenuNameEntryTranslated("File"));
        scrMenuMgr->addMenuItemString("fileNew", "File");
        scrMenuMgr->addMenuItemString("fileNewFromTemplate", "File");
        scrMenuMgr->addMenuItemString("fileOpen", "File");
        scrMenuMgr->addMenuItemString("FileOpenRecent", "File");
        scrMenuMgr->createMenu("FileOpenRecent", tr("Open &Recent"), "File", false, true);
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        scrMenuMgr->addMenuItemString("fileClose", "File");
        scrMenuMgr->addMenuItemString("fileSave", "File");
        scrMenuMgr->addMenuItemString("fileSaveAs", "File");
        scrMenuMgr->addMenuItemString("fileRevert", "File");
        scrMenuMgr->addMenuItemString("fileCollect", "File");
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
        scrMenuMgr->addMenuItemString("FileImport", "File");
        scrMenuMgr->addMenuItemString("fileImportText", "FileImport");
        scrMenuMgr->addMenuItemString("fileImportAppendText", "FileImport");
        scrMenuMgr->addMenuItemString("fileImportImage", "FileImport");
        scrMenuMgr->addMenuItemString("fileImportVector", "FileImport");
        scrMenuMgr->addMenuItemString("FileExport", "File");
        scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
        scrMenuMgr->addMenuItemString("fileExportText", "FileExport");
        scrMenuMgr->addMenuItemString("fileExportAsEPS", "FileExport");
        scrMenuMgr->addMenuItemString("fileExportAsPDF", "FileExport");
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        scrMenuMgr->addMenuItemString("fileDocSetup150", "File");
        scrMenuMgr->addMenuItemString("filePreferences150", "File");
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        scrMenuMgr->addMenuItemString("filePrint", "File");
        if (ScCore->haveGS() || ScCore->isWinGUI())
                scrMenuMgr->addMenuItemString("PrintPreview", "File");
        scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        if (ScCore->haveGS())
        {
                scrMenuMgr->addMenuItemString("FileOutputPreview", "File");
                scrMenuMgr->createMenu("FileOutputPreview", tr("&Output Preview"), "File");
                scrMenuMgr->addMenuItemString("OutputPreviewPDF", "FileOutputPreview");
                scrMenuMgr->addMenuItemString("OutputPreviewPS", "FileOutputPreview");
                scrMenuMgr->addMenuItemString("SEPARATOR", "File");
        }
        scrMenuMgr->addMenuItemString("fileQuit", "File");

        scrMenuMgr->setMenuEnabled("FileImport", false);
        scrMenuMgr->setMenuEnabled("FileExport", false);
        scrMenuMgr->setMenuEnabled("FileOutputPreview", false);

        scrMenuMgr->createMenu("Edit", ActionManager::defaultMenuNameEntryTranslated("Edit"));
        scrMenuMgr->addMenuItemString("editUndoAction", "Edit");
        scrMenuMgr->addMenuItemString("editRedoAction", "Edit");
        scrMenuMgr->addMenuItemString("editActionMode", "Edit");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
        scrMenuMgr->addMenuItemString("editCut", "Edit");
        scrMenuMgr->addMenuItemString("editCopy", "Edit");
        scrMenuMgr->addMenuItemString("editPaste", "Edit");
        scrMenuMgr->createMenu("EditPasteRecent", tr("Paste Recent"), "Edit", false, true);
        scrMenuMgr->addMenuItemString("itemDelete", "Edit");
        scrMenuMgr->createMenu("EditContents", tr("Contents"), "Edit", false, true);
        scrMenuMgr->addMenuItemString("EditContents", "Edit");
        scrMenuMgr->addMenuItemString("editCopyContents", "EditContents");
        scrMenuMgr->addMenuItemString("editPasteContents", "EditContents");
        scrMenuMgr->addMenuItemString("editPasteContentsAbs", "EditContents");
        scrMenuMgr->addMenuItemString("editClearContents", "EditContents");
        scrMenuMgr->addMenuItemString("editTruncateContents", "EditContents");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
        scrMenuMgr->addMenuItemString("editSelectAll", "Edit");
        scrMenuMgr->addMenuItemString("editSelectAllOnLayer", "Edit");
        scrMenuMgr->addMenuItemString("editDeselectAll", "Edit");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
        scrMenuMgr->addMenuItemString("editSearchReplace", "Edit");
        scrMenuMgr->addMenuItemString("toolsEditWithStoryEditor", "Edit");
        scrMenuMgr->addMenuItemString("editEditWithImageEditor", "Edit");
        scrMenuMgr->addMenuItemString("editEditRenderSource", "Edit");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
        scrMenuMgr->addMenuItemString("editColorsAndFills", "Edit");
        scrMenuMgr->addMenuItemString("editReplaceColors", "Edit");
        scrMenuMgr->addMenuItemString("editStyles", "Edit");
        scrMenuMgr->addMenuItemString("editMarks", "Edit");
        scrMenuMgr->addMenuItemString("editNotesStyles", "Edit");
        scrMenuMgr->addMenuItemString("editMasterPages", "Edit");
        scrMenuMgr->addMenuItemString("editJavascripts", "Edit");
        scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
        scrMenuMgr->setMenuEnabled("EditContents", false);


        //Item Menu
        scrMenuMgr->createMenu("Item", ActionManager::defaultMenuNameEntryTranslated("Item"));
        scrMenuMgr->createMenu("DuplicateTransform", tr("Duplicate/Transform"), "Item");
        scrMenuMgr->addMenuItemString("DuplicateTransform", "Item");
        scrMenuMgr->addMenuItemString("itemDuplicate", "DuplicateTransform");
        scrMenuMgr->addMenuItemString("itemMulDuplicate", "DuplicateTransform");
        scrMenuMgr->addMenuItemString("itemTransform", "DuplicateTransform");
        scrMenuMgr->createMenu("Grouping", tr("Grouping"), "Item");
        scrMenuMgr->addMenuItemString("Grouping", "Item");
        scrMenuMgr->addMenuItemString("itemGroup", "Grouping");
        scrMenuMgr->addMenuItemString("itemUngroup", "Grouping");
        scrMenuMgr->addMenuItemString("itemGroupAdjust", "Grouping");
        scrMenuMgr->createMenu("Locking", tr("Locking"), "Item");
        scrMenuMgr->addMenuItemString("Locking", "Item");
        scrMenuMgr->addMenuItemString("itemLock", "Locking");
        scrMenuMgr->addMenuItemString("itemLockSize", "Locking");
        scrMenuMgr->createMenu("ItemLevel", tr("Level"), "Item");
        scrMenuMgr->addMenuItemString("ItemLevel", "Item");
        scrMenuMgr->addMenuItemString("itemRaise", "ItemLevel");
        scrMenuMgr->addMenuItemString("itemLower", "ItemLevel");
        scrMenuMgr->addMenuItemString("itemRaiseToTop", "ItemLevel");
        scrMenuMgr->addMenuItemString("itemLowerToBottom", "ItemLevel");
        scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"), QString(), false, true);
        scrMenuMgr->addMenuItemString("ItemLayer", "Item");
        scrMenuMgr->createMenu("SendTo", tr("Send to"), "Item");
        scrMenuMgr->addMenuItemString("SendTo", "Item");
        scrMenuMgr->createMenu("ItemSendToScrapbook", tr("Scrapbook"), QString(), false, true);
        scrMenuMgr->addMenuItemString("ItemSendToScrapbook", "SendTo");
        scrMenuMgr->addMenuItemString("itemSendToPattern", "SendTo");
        scrMenuMgr->addMenuItemString("itemSendToInline", "SendTo");
        scrMenuMgr->createMenu("Adjust", tr("Adjust"), "Item");
        scrMenuMgr->addMenuItemString("Adjust", "Item");
        scrMenuMgr->addMenuItemString("itemAdjustFrameHeightToText", "Adjust");
        scrMenuMgr->addMenuItemString("itemAdjustFrameToImage", "Adjust");
        scrMenuMgr->addMenuItemString("itemAdjustImageToFrame", "Adjust");
        scrMenuMgr->createMenu("Image", tr("Image"), "Item");
        scrMenuMgr->addMenuItemString("Image", "Item");
        scrMenuMgr->addMenuItemString("itemUpdateImage", "Image");
        scrMenuMgr->addMenuItemString("styleImageEffects", "Image");
        scrMenuMgr->addMenuItemString("itemExtendedImageProperties", "Image");
        scrMenuMgr->addMenuItemString("itemToggleInlineImage", "Image");
        scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"));
        scrMenuMgr->addMenuItemString("ItemPreviewSettings", "Image");
        scrMenuMgr->addMenuItemString("itemImageIsVisible", "ItemPreviewSettings");
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemPreviewSettings");
        scrMenuMgr->addMenuItemString("itemPreviewFull", "ItemPreviewSettings");
        scrMenuMgr->addMenuItemString("itemPreviewNormal", "ItemPreviewSettings");
        scrMenuMgr->addMenuItemString("itemPreviewLow", "ItemPreviewSettings");
        scrMenuMgr->createMenu("ItemPDFOptions", tr("P&DF Options"));
        scrMenuMgr->addMenuItemString("ItemPDFOptions", "Item");
        scrMenuMgr->addMenuItemString("itemPDFIsAnnotation", "ItemPDFOptions");
        scrMenuMgr->addMenuItemString("itemPDFIsBookmark", "ItemPDFOptions");
        scrMenuMgr->addMenuItemString("itemPDFAnnotationProps", "ItemPDFOptions");
        scrMenuMgr->addMenuItemString("itemPDFFieldProps", "ItemPDFOptions");
        scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert to"), "Item");
        scrMenuMgr->addMenuItemString("ItemConvertTo", "Item");
        scrMenuMgr->addMenuItemString("itemConvertToTextFrame", "ItemConvertTo");
        scrMenuMgr->addMenuItemString("itemConvertToImageFrame", "ItemConvertTo");
        scrMenuMgr->addMenuItemString("itemConvertToPolygon", "ItemConvertTo");
        scrMenuMgr->addMenuItemString("itemConvertToBezierCurve", "ItemConvertTo");
        scrMenuMgr->addMenuItemString("itemConvertToOutlines", "ItemConvertTo");
        scrMenuMgr->addMenuItemString("itemConvertToSymbolFrame", "ItemConvertTo");
        scrMenuMgr->createMenu("TextLinking", tr("Text Frame Links"), "Item");
        scrMenuMgr->addMenuItemString("TextLinking", "Item");
        scrMenuMgr->addMenuItemString("toolsLinkTextFrame", "TextLinking");
        scrMenuMgr->addMenuItemString("toolsUnlinkTextFrame", "TextLinking");
        scrMenuMgr->addMenuItemString("toolsUnlinkTextFrameAndCutText", "TextLinking");
        scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
        scrMenuMgr->addMenuItemString("ItemPathOps", "Item");
        scrMenuMgr->addMenuItemString("itemCombinePolygons", "ItemPathOps");
        scrMenuMgr->addMenuItemString("itemSplitPolygons", "ItemPathOps");
        scrMenuMgr->addMenuItemString("itemAttachTextToPath", "ItemPathOps");
        scrMenuMgr->addMenuItemString("itemDetachTextFromPath", "ItemPathOps");

        scrActions["itemPrintingEnabled"]->setEnabled(false);
        scrMenuMgr->setMenuEnabled("ItemConvertTo", false);

        scrMenuMgr->createMenu("Weld", tr("Welding"), "Item");
        scrMenuMgr->addMenuItemString("Weld", "Item");
        scrMenuMgr->addMenuItemString("itemWeld", "Weld");
        scrMenuMgr->addMenuItemString("itemsUnWeld", "Weld");
        scrMenuMgr->addMenuItemString("itemEditWeld", "Weld");
        scrMenuMgr->addMenuItemString("editMark", "Item");

        //Insert menu
        scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
        scrMenuMgr->addMenuItemString("insertFrame", "Insert");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertTextFrame", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertImageFrame", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertRenderFrame", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertTable", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertShape", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertPolygon", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertArc", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertSpiral", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertLine", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertBezier", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertFreehandLine", "Insert");
        scrMenuMgr->addMenuItemString("toolsInsertCalligraphicLine", "Insert");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
        scrMenuMgr->addMenuItemString("stickyTools", "Insert");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
        scrMenuMgr->addMenuItemString("insertGlyph", "Insert");

        scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
        scrMenuMgr->addMenuItemString("InsertChar", "Insert");
        scrMenuMgr->addMenuItemString("unicodePageNumber", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodePageCount", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeSoftHyphen", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeNonBreakingHyphen", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeZWJ", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeZWNJ", "InsertChar");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeCopyRight", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeRegdTM", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeTM", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeSolidus", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeBullet", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeMidpoint", "InsertChar");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeDashEm", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeDashEn", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeDashFigure", "InsertChar");
        scrMenuMgr->addMenuItemString("unicodeDashQuotation", "InsertChar");

        scrMenuMgr->createMenu("InsertQuote", tr("&Quote"), "Insert");
        scrMenuMgr->addMenuItemString("InsertQuote", "Insert");
        scrMenuMgr->addMenuItemString("unicodeQuoteApostrophe", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteStraight", "InsertQuote");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeft", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleRight", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeft", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRight", "InsertQuote");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleReversed", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleReversed", "InsertQuote");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteLowSingleComma", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteLowDoubleComma", "InsertQuote");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeftGuillemet", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteSingleRightGuillemet", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeftGuillemet", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRightGuillemet", "InsertQuote");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleLeft", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleRight", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleLeft", "InsertQuote");
        scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleRight", "InsertQuote");

        scrMenuMgr->createMenu("InsertSpace", tr("S&paces && Breaks"), "Insert");
        scrMenuMgr->addMenuItemString("InsertSpace", "Insert");
        scrMenuMgr->addMenuItemString("unicodeNonBreakingSpace", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeNarrowNoBreakSpace", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceEN", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceEM", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceThin", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceThick", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceMid", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeSpaceHair", "InsertSpace");
        scrMenuMgr->addMenuItemString("SEPARATOR", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeZerowidthSpace", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeNewLine", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeColumnBreak", "InsertSpace");
        scrMenuMgr->addMenuItemString("unicodeFrameBreak", "InsertSpace");

        scrMenuMgr->createMenu("InsertLigature", tr("Liga&ture"), "Insert");
        scrMenuMgr->addMenuItemString("InsertLigature", "Insert");
        scrMenuMgr->addMenuItemString("unicodeLigature_ff", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_fi", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_fl", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_ffi", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_ffl", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_ft", "InsertLigature");
        scrMenuMgr->addMenuItemString("unicodeLigature_st", "InsertLigature");

        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
        scrMenuMgr->addMenuItemString("insertSampleText", "Insert");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
        scrMenuMgr->createMenu("InsertMark", tr("Marks"), "Insert");
        scrMenuMgr->addMenuItemString("InsertMark", "Insert");
        scrMenuMgr->addMenuItemString("insertMarkAnchor", "InsertMark");
        scrMenuMgr->addMenuItemString("insertMarkNote", "InsertMark");
        scrMenuMgr->addMenuItemString("insertMarkItem", "InsertMark");
        scrMenuMgr->addMenuItemString("insertMark2Mark", "InsertMark");
        scrMenuMgr->addMenuItemString("insertMarkVariableText", "InsertMark");

        //Page menu
        scrMenuMgr->createMenu("Page", ActionManager::defaultMenuNameEntryTranslated("Page"));
        scrMenuMgr->addMenuItemString("pageInsert", "Page");
        scrMenuMgr->addMenuItemString("pageImport", "Page");
        scrMenuMgr->addMenuItemString("pageDelete", "Page");
        scrMenuMgr->addMenuItemString("pageCopy", "Page");
        scrMenuMgr->addMenuItemString("pageMove", "Page");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
        scrMenuMgr->addMenuItemString("pageApplyMasterPage", "Page");
        scrMenuMgr->addMenuItemString("pageCopyToMasterPage", "Page");
        scrMenuMgr->addMenuItemString("pageManageGuides", "Page");
        scrMenuMgr->addMenuItemString("pageManageProperties", "Page");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
        scrMenuMgr->addMenuItemString("viewSnapToGrid", "Page");
        scrMenuMgr->addMenuItemString("viewSnapToGuides", "Page");
        scrMenuMgr->addMenuItemString("viewSnapToElements", "Page");

        //View menu
        scrMenuMgr->createMenu("View", ActionManager::defaultMenuNameEntryTranslated("View"));
        scrMenuMgr->createMenu("ViewZoom", tr("Zoom"), "View");
        scrMenuMgr->addMenuItemString("ViewZoom", "View");
        scrMenuMgr->addMenuItemString("viewFitInWindow", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFitWidth", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFit50", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFit75", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFit100", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFit200", "ViewZoom");
        scrMenuMgr->addMenuItemString("viewFit400", "ViewZoom");
        scrMenuMgr->createMenu("ViewPreview", tr("Preview"), "View");
        scrMenuMgr->addMenuItemString("ViewPreview", "View");
        scrMenuMgr->addMenuItemString("viewPreviewMode", "ViewPreview");
        scrMenuMgr->createMenu("ViewMeasuring", tr("Measurement"), "View");
        scrMenuMgr->addMenuItemString("ViewMeasuring", "View");
        scrMenuMgr->addMenuItemString("viewShowRulers", "ViewMeasuring");
        scrMenuMgr->addMenuItemString("viewRulerMode", "ViewMeasuring");
        scrMenuMgr->addMenuItemString("showMouseCoordinates", "ViewMeasuring");
        scrMenuMgr->createMenu("ViewTextFrames", tr("Text Frames"), "View");
        scrMenuMgr->addMenuItemString("ViewTextFrames", "View");
        scrMenuMgr->addMenuItemString("viewShowBaseline", "ViewTextFrames");
        scrMenuMgr->addMenuItemString("viewShowColumnBorders", "ViewTextFrames");
        scrMenuMgr->addMenuItemString("viewShowTextChain", "ViewTextFrames");
        scrMenuMgr->addMenuItemString("viewShowTextControls", "ViewTextFrames");
        scrMenuMgr->createMenu("ViewImageFrames", tr("Image Frames"), "View");
        scrMenuMgr->addMenuItemString("ViewImageFrames", "View");
        scrMenuMgr->addMenuItemString("viewShowImages", "ViewImageFrames");
        scrMenuMgr->createMenu("ViewDocument", tr("Document"), "View");
        scrMenuMgr->addMenuItemString("ViewDocument", "View");
        scrMenuMgr->addMenuItemString("viewShowMargins", "ViewDocument");
        scrMenuMgr->addMenuItemString("viewShowBleeds", "ViewDocument");
        scrMenuMgr->addMenuItemString("viewShowFrames", "ViewDocument");
        scrMenuMgr->addMenuItemString("viewShowLayerMarkers", "ViewDocument");
        scrMenuMgr->createMenu("ViewGrids", tr("Grids and Guides"), "View");
        scrMenuMgr->addMenuItemString("ViewGrids", "View");
        scrMenuMgr->addMenuItemString("viewShowGrid", "ViewGrids");
        scrMenuMgr->addMenuItemString("viewShowGuides", "ViewGrids");

        //CB If this is viewNewView imeplemented, it should be on the windows menu
//      scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");

        // Table menu.
        scrMenuMgr->createMenu("ItemTable", ActionManager::defaultMenuNameEntryTranslated("Table"));
        scrMenuMgr->addMenuItemString("tableInsertRows", "ItemTable");
        scrMenuMgr->addMenuItemString("tableInsertColumns", "ItemTable");
        scrMenuMgr->addMenuItemString("tableDeleteRows", "ItemTable");
        scrMenuMgr->addMenuItemString("tableDeleteColumns", "ItemTable");
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
        scrMenuMgr->addMenuItemString("tableMergeCells", "ItemTable");
        scrMenuMgr->addMenuItemString("tableSplitCells", "ItemTable");
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
        scrMenuMgr->addMenuItemString("tableSetRowHeights", "ItemTable");
        scrMenuMgr->addMenuItemString("tableSetColumnWidths", "ItemTable");
        scrMenuMgr->addMenuItemString("tableDistributeRowsEvenly", "ItemTable");
        scrMenuMgr->addMenuItemString("tableDistributeColumnsEvenly", "ItemTable");
        scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
        scrMenuMgr->addMenuItemString("tableAdjustFrameToTable", "ItemTable");
        scrMenuMgr->addMenuItemString("tableAdjustTableToFrame", "ItemTable");

        //Extra menu
        scrMenuMgr->createMenu("Extras", ActionManager::defaultMenuNameEntryTranslated("Extras"));
        scrMenuMgr->addMenuItemString("extrasHyphenateText", "Extras");
        scrMenuMgr->addMenuItemString("extrasDeHyphenateText", "Extras");
        scrMenuMgr->addMenuItemString("extrasGenerateTableOfContents", "Extras");
        scrMenuMgr->addMenuItemString("itemUpdateMarks", "Extras");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
        scrMenuMgr->addMenuItemString("extrasManageImages", "Extras");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
        scrMenuMgr->addMenuItemString("extrasUpdateDocument", "Extras");
//      Disabled for release as it does nothing useful
//      scrMenuMgr->addMenuItemString("extrasTestQTQuick2_1", "Extras");

        //Window menu
        scrMenuMgr->createMenu("Windows", ActionManager::defaultMenuNameEntryTranslated("Windows"), QString(), true);

        //Help menu
        scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
        scrMenuMgr->addMenuItemString("helpManual", "Help");
        scrMenuMgr->addMenuItemString("helpChat", "Help");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
        scrMenuMgr->addMenuItemString("helpActionSearch", "Help");
        scrMenuMgr->addMenuItemString("helpTooltips", "Help");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
        scrMenuMgr->addMenuItemString("helpOnlineWWW", "Help");
        scrMenuMgr->addMenuItemString("helpOnlineDocs", "Help");
        scrMenuMgr->addMenuItemString("helpOnlineWiki", "Help");
        scrMenuMgr->addMenuItemString("HelpOnlineTutorials", "Help");
        scrMenuMgr->addMenuItemString("helpOnlineTutorial1", "Help");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
        scrMenuMgr->addMenuItemString("helpCheckUpdates", "Help");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
        scrMenuMgr->addMenuItemString("helpAboutScribus", "Help");
        scrMenuMgr->addMenuItemString("helpAboutPlugins", "Help");
        scrMenuMgr->addMenuItemString("helpAboutQt", "Help");
}

void ScribusMainWindow::createMenuBar()
{
        scrMenuMgr->addMenuStringToMenuBar("File");
        scrMenuMgr->addMenuItemStringsToMenuBar("File", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Edit");
        scrMenuMgr->addMenuItemStringsToMenuBar("Edit", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Item");
        scrMenuMgr->addMenuItemStringsToMenuBar("Item", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Insert");
        scrMenuMgr->addMenuItemStringsToMenuBar("Insert", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Page");
        scrMenuMgr->addMenuItemStringsToMenuBar("Page", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("ItemTable");
        scrMenuMgr->addMenuItemStringsToMenuBar("ItemTable", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Extras");
        scrMenuMgr->addMenuItemStringsToMenuBar("Extras", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("View");
        scrMenuMgr->addMenuItemStringsToMenuBar("View", scrActions);
        scrMenuMgr->addMenuStringToMenuBar("Windows", true);
        addDefaultWindowMenuItems();
        menuBar()->addSeparator();
        scrMenuMgr->addMenuStringToMenuBar("Help");
        scrMenuMgr->addMenuItemStringsToMenuBar("Help", scrActions);
        connect(scrMenuMgr->getLocalPopupMenu("Extras"), SIGNAL(aboutToShow()), this, SLOT(extrasMenuAboutToShow()));
        connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));

}


void ScribusMainWindow::addDefaultWindowMenuItems()
{
        scrMenuMgr->clearMenu("Windows");
        scrMenuMgr->addMenuItemString("windowsCascade", "Windows");
        scrMenuMgr->addMenuItemString("windowsTile", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemString("toolsProperties", "Windows");
        scrMenuMgr->addMenuItemString("toolsContent", "Windows");
        scrMenuMgr->addMenuItemString("toolsActionHistory", "Windows");
        scrMenuMgr->addMenuItemString("toolsAlignDistribute", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemString("toolsOutline", "Windows");
        scrMenuMgr->addMenuItemString("toolsPages", "Windows");
        scrMenuMgr->addMenuItemString("toolsLayers", "Windows");
        scrMenuMgr->addMenuItemString("toolsBookmarks", "Windows");
//      scrMenuMgr->addMenuItemString("toolsDownloads", "Windows");
        scrMenuMgr->addMenuItemString("toolsResources", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemString("toolsScrapbook", "Windows");
        scrMenuMgr->addMenuItemString("toolsSymbols", "Windows");
        scrMenuMgr->addMenuItemString("toolsInline", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemString("toolsMeasurements", "Windows");
        scrMenuMgr->addMenuItemString("toolsPreflightVerifier", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemString("toolsToolbarTools", "Windows");
        scrMenuMgr->addMenuItemString("toolsToolbarPDF", "Windows");
        scrMenuMgr->addMenuItemString("toolsToolbarView", "Windows");
        scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
        scrMenuMgr->addMenuItemStringsToMenuBar("Windows", scrActions);
}


void ScribusMainWindow::initStatusBar()
{
        QFont fo = QFont(font());
        int posi = fo.pointSize() - (ScCore->isWinGUI() ? 1 : 2);
        fo.setPointSize(posi);
        unitSwitcher = new QComboBox( this );
        unitSwitcher->setObjectName("unitSwitcher");
        unitSwitcher->setFocusPolicy(Qt::NoFocus);
        unitSwitcher->setFont(fo);
        int maxUindex = unitGetMaxIndex() - 2;
        for (int i = 0; i <= maxUindex; ++i)
                unitSwitcher->addItem(unitGetStrFromIndex(i));


        QWidget* zoomWidget = new QWidget( statusBar() );
        QHBoxLayout* zoomLayout = new QHBoxLayout( zoomWidget );
        zoomLayout->setContentsMargins(0, 0, 0, 0);
        zoomLayout->setSpacing(3);

        zoomSpinBox = new ScrSpinBox( 1, 32000, zoomWidget, 6 );
        zoomSpinBox->setFont(fo);
        zoomSpinBox->setValue( 100 );
        zoomSpinBox->setSingleStep(10);
        zoomSpinBox->setFocusPolicy(Qt::ClickFocus);
        zoomSpinBox->setSuffix( tr( " %" ) );
        layerMenu = new QComboBox( this );
        layerMenu->setObjectName("layerMenu");
        layerMenu->setEditable(false);
        layerMenu->setFont(fo);
        layerMenu->setFocusPolicy(Qt::NoFocus);
        layerMenu->setSizeAdjustPolicy(QComboBox::AdjustToContents);

        pageSelector = new PageSelector(this, 1);
        pageSelector->setObjectName("pageSelector");
        pageSelector->setFont(fo);
        pageSelector->setFocusPolicy(Qt::ClickFocus);

        zoomDefaultToolbarButton = new QPushButton(zoomWidget);
        zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomDefaultToolbarButton->setDefault( false );
        zoomDefaultToolbarButton->setAutoDefault( false );
        zoomOutToolbarButton = new QPushButton(zoomWidget);
        zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomOutToolbarButton->setDefault( false );
        zoomOutToolbarButton->setAutoDefault( false );
        zoomInToolbarButton = new QPushButton(zoomWidget);
        zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomInToolbarButton->setDefault( false );
        zoomInToolbarButton->setAutoDefault( false );

        zoomDefaultToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-original.png"));
        zoomOutToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-out.png"));
        zoomInToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-in.png"));

        zoomLayout->addWidget( zoomSpinBox );
        zoomLayout->addWidget( zoomOutToolbarButton );
        zoomLayout->addWidget( zoomDefaultToolbarButton );
        zoomLayout->addWidget( zoomInToolbarButton );

        m_mainWindowStatusLabel = new QLabel( "           ", statusBar());
        m_mainWindowStatusLabel->setFont(fo);
        mainWindowProgressBar = new QProgressBar(statusBar());
        mainWindowProgressBar->setAlignment(Qt::AlignHCenter);
        mainWindowProgressBar->setFixedWidth( 100 );
        mainWindowProgressBar->reset();
        mainWindowXPosLabel = new QLabel( tr("X:"), statusBar());
        mainWindowXPosLabel->setFont(fo);
        mainWindowYPosLabel = new QLabel( tr("Y:"), statusBar());
        mainWindowYPosLabel->setFont(fo);
        mainWindowXPosDataLabel = new QLabel(QString(), statusBar());
        mainWindowXPosDataLabel->setFont(fo);
        mainWindowYPosDataLabel = new QLabel(QString(), statusBar());
        mainWindowYPosDataLabel->setFont(fo);
        mainWindowXPosDataLabel->setMinimumWidth(mainWindowXPosDataLabel->fontMetrics().horizontalAdvance("99999.999"));
        mainWindowYPosDataLabel->setMinimumWidth(mainWindowYPosDataLabel->fontMetrics().horizontalAdvance("99999.999"));
        statusBarLanguageChange();

        layerMenu->setObjectName("layerMenu");
        unitSwitcher->setObjectName("unitSwitcher");
        zoomDefaultToolbarButton->setObjectName("zoomDefaultToolbarButton");
        zoomInToolbarButton->setObjectName("zoomInToolbarButton");
        zoomOutToolbarButton->setObjectName("zoomOutToolbarButton");
        zoomSpinBox->setObjectName("zoomSpinBox");

        statusBar()->setFont(fo);
        statusBar()->addPermanentWidget(m_mainWindowStatusLabel, 5);
        QLabel *s = new QLabel(QString());
        QLabel *s2 = new QLabel(QString());
        QLabel *s3 = new QLabel(QString());
        statusBar()->addPermanentWidget(s,1);
        statusBar()->addPermanentWidget(s2,1);
        statusBar()->addPermanentWidget(zoomWidget,0);
        statusBar()->addPermanentWidget(pageSelector,0);
        statusBar()->addPermanentWidget(layerMenu,1);
        statusBar()->addPermanentWidget(s3,3);
        statusBar()->addPermanentWidget(mainWindowXPosLabel, 0);
        statusBar()->addPermanentWidget(mainWindowXPosDataLabel, 0);
        statusBar()->addPermanentWidget(mainWindowYPosLabel, 0);
        statusBar()->addPermanentWidget(mainWindowYPosDataLabel, 0);

        statusBar()->addPermanentWidget(unitSwitcher,0);
        statusBar()->addPermanentWidget(mainWindowProgressBar, 0);
        connect(statusBar(), SIGNAL(messageChanged(const QString &)), this, SLOT(setTempStatusBarText(const QString &)));

}


void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
{
        if (!HaveDoc)
        {
                mainWindowXPosDataLabel->clear();
                mainWindowYPosDataLabel->clear();
                return;
        }
        if (doc->Pages->count() == 0)
                return;
        double xn = xp;
        double yn = yp;
        if (doc->guidesPrefs().rulerMode)
        {
                xn -= doc->currentPage()->xOffset();
                yn -= doc->currentPage()->yOffset();
        }
        xn -= doc->rulerXoffset;
        yn -= doc->rulerYoffset;
        mainWindowXPosDataLabel->setText(value2String(xn, doc->unitIndex(), true, false));
        mainWindowYPosDataLabel->setText(value2String(yn, doc->unitIndex(), true, false));
}

void ScribusMainWindow::setStatusBarTextPosition(double base, double xp)
{
        if (doc->Pages->count() == 0)
                return;
        mainWindowXPosDataLabel->setText(base + xp >= 0? value2String(xp, doc->unitIndex(), true, true): QString("-"));
        mainWindowYPosDataLabel->setText("-");
}

void ScribusMainWindow::setStatusBarTextSelectedItemInfo()
{
        const int docSelectionCount = doc->m_Selection->count();
        if (docSelectionCount == 0)
        {
                setStatusBarInfoText("");
                return;
        }
        QString widthTxt = value2String(doc->m_Selection->width(), doc->unitIndex(), true, true);
        QString heightTxt = value2String(doc->m_Selection->height(), doc->unitIndex(), true, true);
        if (docSelectionCount == 1)
        {
                QString whatSel = tr("Unknown");
                switch (doc->m_Selection->itemAt(0)->itemType())
                {
                        case 2:
                                whatSel = CommonStrings::itemType_ImageFrame;
                                break;
                        case 4:
                                whatSel = CommonStrings::itemType_TextFrame;
                                break;
                        case 5:
                                whatSel = CommonStrings::itemType_Line;
                                break;
                        case 6:
                                whatSel = CommonStrings::itemType_Polygon;
                                break;
                        case 7:
                                whatSel = CommonStrings::itemType_Polyline;
                                break;
                        case 8:
                                whatSel = CommonStrings::itemType_PathText;
                                break;
                        case 9:
                                whatSel = CommonStrings::itemType_LatexFrame;
                                break;
                        case 11:
                                whatSel = CommonStrings::itemType_Symbol;
                                break;
                        case 12:
                                whatSel = CommonStrings::itemType_Group;
                                break;
                        case 13:
                                whatSel = CommonStrings::itemType_RegularPolygon;
                                break;
                        case 14:
                                whatSel = CommonStrings::itemType_Arc;
                                break;
                        case 15:
                                whatSel = CommonStrings::itemType_Spiral;
                                break;
                        case 16:
                                whatSel = CommonStrings::itemType_Table;
                                break;
                        default:
                                whatSel = "Unknown";
                                break;
                }
                QString txtBody = tr("%1 selected").arg(whatSel) + " : " + tr("Size");
                setStatusBarInfoText( QString("%1 = %3 x %4").arg(txtBody, widthTxt, heightTxt));
        }
        else
        {
                setStatusBarInfoText( tr("%1 Objects selected, Selection Size = %2 x %3").arg(docSelectionCount).arg(widthTxt, heightTxt));
        }
}

void ScribusMainWindow::setTempStatusBarText(const QString &text)
{
        if (m_mainWindowStatusLabel)
        {
                if (text.isEmpty())
                        m_mainWindowStatusLabel->setText(m_statusLabelText);
                else
                        m_mainWindowStatusLabel->setText(text);
        }
}

void ScribusMainWindow::setStatusBarInfoText(const QString & newText)
{
        if (m_mainWindowStatusLabel)
                m_mainWindowStatusLabel->setText(newText);
        m_statusLabelText = newText;
}


//AV to be replaced with Selection::update and listener in contentPalette
void ScribusMainWindow::setTBvals(PageItem *currItem)
{
        scrActions["editMark"]->setEnabled(false);
       
        PageItem* item  = currItem;
        bool inEditMode = (doc->appMode == modeEdit);
        if (doc->appMode == modeEditTable)
        {
                if (currItem->isTable())
                        item = currItem->asTable()->activeCell().textFrame();
                inEditMode = item->isTextFrame();
        }
        if (!item || item->itemText.length() <= 0)
                return;

        const ParagraphStyle& currPStyle(inEditMode ? item->currentStyle() : item->itemText.defaultStyle());
        setAlignmentValue(currPStyle.alignment());

        // Assignment operator does not perform style context assignment
        // Do it in this case, otherwise we might get some crashes if previous
        // text object was deleted or things like that
        const ParagraphStyle& curStyle = item->currentStyle();
        doc->currentStyle.setContext(curStyle.context());
        doc->currentStyle = curStyle;
        if (doc->appMode == modeEdit || doc->appMode == modeEditTable)
                item->currentTextProps(doc->currentStyle);
        else
                doc->currentStyle.charStyle().setStyle(item->currentCharStyle());
        emit TextStyle(doc->currentStyle);
        // to go: (av)
        contentPalette->update(doc->currentStyle);
        //check if mark in cursor place and enable editMark action
        if (doc->appMode == modeEdit && item->itemText.cursorPosition() < item->itemText.length())
        {
                if (item->itemText.hasMark(item->itemText.cursorPosition()))
                {
                        Mark* mark = item->itemText.mark(item->itemText.cursorPosition());
                        scrActions["editMark"]->setEnabled(true);
                        if ((mark->isType(MARKNoteMasterType) || mark->isType(MARKNoteFrameType)) && (mark->getNotePtr() != nullptr))
                                nsEditor->setNotesStyle(mark->getNotePtr()->notesStyle());
                }
                else
                        scrActions["editMark"]->setEnabled(false);
        }
}

//Special keys assigned to actions are stolen by the action and not passed to
//keyPressEvent so process them here.
void ScribusMainWindow::specialActionKeyEvent(int unicodevalue)
{
        if (!HaveDoc)
                return;
        if (doc->m_Selection->count() != 1)
                return;
        if ((doc->appMode != modeEdit) && (doc->appMode != modeEditTable))
                return;

        PageItem* selItem = doc->m_Selection->itemAt(0);
        if (!selItem->isTextFrame() && !selItem->isTable())
                return;

        PageItem_TextFrame *currItem;
        if (doc->appMode == modeEditTable)
                currItem = selItem->asTable()->activeCell().textFrame();
        else
                currItem = selItem->asTextFrame();
        if (currItem == nullptr)
                return;

        if (unicodevalue!=-1)
        {
                UndoTransaction activeTransaction;
                if (currItem->HasSel)
                {
                        if (UndoManager::undoEnabled())
                                activeTransaction = m_undoManager->beginTransaction(Um::Selection, Um::IGroup, Um::ReplaceText, QString(), Um::IDelete);
                        currItem->deleteSelectedTextFromFrame();
                }
                if (UndoManager::undoEnabled())
                {
                        SimpleState *ss = dynamic_cast<SimpleState*>(m_undoManager->getLastUndo());
                        UndoObject *undoTarget = currItem;
                        if (ss && (ss->get("ETEA") == "insert_frametext") && (ss->undoObject() == undoTarget))
                                ss->set("TEXT_STR", ss->get("TEXT_STR") + QString(QChar(unicodevalue)));
                        else
                        {
                                ss = new SimpleState(Um::InsertText, QString(), Um::ICreate);
                                ss->set("INSERT_FRAMETEXT");
                                ss->set("ETEA", QString("insert_frametext"));
                                ss->set("TEXT_STR", QString(QChar(unicodevalue)));
                                ss->set("START", currItem->itemText.cursorPosition());
                                if (currItem->isNoteFrame())
                                {
                                        undoTarget = doc;
                                        ss->set("noteframeName", currItem->getUName());
                                }
                                m_undoManager->action(undoTarget, ss);
                        }
                }
                currItem->itemText.insertChars(QString(QChar(unicodevalue)), true);
                if (activeTransaction)
                        activeTransaction.commit();
        }
        else if (unicodevalue == SpecialChars::SHYPHEN.unicode()) //ignore the char as we use an attribute if the text item, for now.
        {
                // this code is currently dead since unicodeSoftHyphen
                // doesn't have unicodevalue == -1 any more
                if (currItem->itemText.cursorPosition() <= 1)
                        return;
#if 0
                StyleFlag fl = currItem->itemText.item(qMax(currItem->CPos-1,0))->effects();
                fl |= ScStyle_HyphenationPossible;
                currItem->itemText.item(qMax(currItem->CPos-1,0))->setEffects(fl);
#else
                if (UndoManager::undoEnabled())
                {
                        SimpleState *ss = dynamic_cast<SimpleState*>(m_undoManager->getLastUndo());
                        UndoObject *undoTarget = currItem;
                        if (ss && (ss->get("ETEA") == "insert_frametext") && (ss->undoObject() == undoTarget))
                                ss->set("TEXT_STR", ss->get("TEXT_STR") + QString(SpecialChars::SHYPHEN));
                        else
                        {
                                ss = new SimpleState(Um::InsertText, QString(), Um::ICreate);
                                ss->set("INSERT_FRAMETEXT");
                                ss->set("ETEA", QString("insert_frametext"));
                                ss->set("TEXT_STR", QString(SpecialChars::SHYPHEN));
                                ss->set("START", currItem->itemText.cursorPosition());
                                if (currItem->isNoteFrame())
                                {
                                        undoTarget = doc;
                                        ss->set("noteframeName", currItem->getUName());
                                }
                                m_undoManager->action(undoTarget, ss);
                        }
                }
                currItem->itemText.insertChars(QString(SpecialChars::SHYPHEN), true);
#endif
        }
        if (doc->appMode == modeEditTable)
                selItem->asTable()->update();
        else
                currItem->update();
}

bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
{
        if (e->type() == QEvent::ToolTip)
                return (!m_prefsManager.appPrefs.displayPrefs.showToolTips);

        bool retVal = false;
        if (e->type() == QEvent::KeyPress)
        {
                QKeyEvent *k = dynamic_cast<QKeyEvent *>(e);
                if (!k)
                        return false;
                int keyMod=0;
                if (k->modifiers() & Qt::ShiftModifier)
                        keyMod |= Qt::SHIFT;
                if (k->modifiers() & Qt::ControlModifier)
                        keyMod |= Qt::CTRL;
                if (k->modifiers() & Qt::AltModifier)
                        keyMod |= Qt::ALT;

                QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
                if (QString(currKeySeq.toString()).isNull())
                        return false;
                retVal = true;
                //Palette actions
                if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllPalettes"))
                        scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
                else if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllGuides"))
                        scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
                else
                        retVal = false;
        }
        else if (e->type() == QEvent::KeyRelease)
        {
                QKeyEvent *k = dynamic_cast<QKeyEvent *>(e);
                if (!k)
                        return false;
#if defined(Q_OS_MAC)
                if ((k->key() == Qt::Key_QuoteLeft) && (k->modifiers() & Qt::ControlModifier))
                {
                        if (k->modifiers() & Qt::ShiftModifier)
                                mdiArea->activatePreviousSubWindow();
                        else
                                mdiArea->activateNextSubWindow();
                        retVal = true;
                }
#endif
        }
        //Return false to pass event to object
        return retVal;
}


void ScribusMainWindow::inputMethodEvent ( QInputMethodEvent * event )
{
        //qDebug() << "IMEmw" << event->commitString() << event->preeditString() << "attributes:" << event->attributes().count();
}

QVariant ScribusMainWindow::inputMethodQuery ( Qt::InputMethodQuery query ) const
{
        //qDebug() << "IMQmw" << query;
        return QVariant();
}

//AV -> CanvasMode
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
{
        if (HaveDoc && view && (view->hasFocus() || view->widget()->hasFocus()))
        {
                view->canvasMode()->keyPressEvent(k);
                return;
        }

        QMainWindow::keyPressEvent(k);
}

void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
{
        if (HaveDoc && view && (view->hasFocus() || view->widget()->hasFocus()))
        {
                view->canvasMode()->keyReleaseEvent(k);
                return;
        }

        QMainWindow::keyReleaseEvent(k);
}

void ScribusMainWindow::changeEvent(QEvent *e)
{
        if (e->type() == QEvent::LanguageChange)
                languageChange();
        else
                QMainWindow::changeEvent(e);
}

void ScribusMainWindow::closeEvent(QCloseEvent *ce)
{
        //Do not quit if Preferences or new doc window is open
        PreferencesDialog *prefsDialog = findChild<PreferencesDialog *>(QString::fromLocal8Bit("PreferencesDialog"));
        NewDocDialog *newDocWin = findChild<NewDocDialog *>(QString::fromLocal8Bit("NewDocumentWindow"));
        if (prefsDialog != nullptr || newDocWin != nullptr)
        {
                ce->ignore();
                return;
        }
        QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
        ScribusWin* tw;
        disconnect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(newActWin(QMdiSubWindow *)));
        if (!windows.isEmpty())
        {
                int windowCount = windows.count();
                for ( int i = 0; i < windowCount; ++i )
                {
                        tw = qobject_cast<ScribusWin *>(windows.at(i));
                        QMdiSubWindow *tws = windows.at(i);
                        ScribusWin* scw = dynamic_cast<ScribusWin *>(tws->widget());
                        if (scw)
                        {
                                newActWin(windows.at(i));
                                tw = ActWin;
                                slotSelect();
                                tws->close();
                                if (tw == ActWin)
                                {
                                        ce->ignore();
                                        connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(newActWin(QMdiSubWindow*)));
                                        return;
                                }
                        }
                }
        }
        fileToolBar->connectPrefsSlot(false);
        editToolBar->connectPrefsSlot(false);
        modeToolBar->connectPrefsSlot(false);
        pdfToolBar->connectPrefsSlot(false);

        m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.clear();
        QList<QTabBar *> bars = findChildren<QTabBar *>(QString());
        for (int i = 0; i < bars.count(); ++i)
        {
                QTabBar *bar = bars[i];
                tabPrefs currentTab;
                for (int ii = 0; ii < bar->count(); ii++)
                {
                        currentTab.activeTab = bar->currentIndex();
                        QObject *obj = (QObject*)bar->tabData(ii).toULongLong();
                        if (obj != nullptr)
                                currentTab.palettes.append(obj->objectName());
                }
                if (!currentTab.palettes.isEmpty())
                        m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.append(currentTab);
        }

        propertiesPalette->hide();
        contentPalette->hide();
        outlinePalette->hide();
        scrapbookPalette->hide();
        bookmarkPalette->hide();
        downloadsPalette->hide();
        layerPalette->hide();
        pagePalette->hide();
        docCheckerPalette->hide();
        undoPalette->hide();
        alignDistributePalette->hide();
        guidePalette->hide();
        charPalette->hide();
        symbolPalette->hide();
        inlinePalette->hide();

        // Clean up plugins, THEN save prefs to disk
        ScCore->pluginManager->cleanupPlugins();
        if (!m_prefsManager.appPrefs.scrapbookPrefs.persistentScrapbook)
                scrapbookPalette->cleanUpTemp();
        m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks.clear();
        m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
        if (!emergencyActivated)
                m_prefsManager.savePrefs();
        UndoManager::deleteInstance();
        FormatsManager::deleteInstance();
//      qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
        ce->accept();
}

void ScribusMainWindow::requestUpdate(int val)
{
        emit UpdateRequest(val);
}

/////////////////////////////////////////////////////////////////////
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////

/*
bool ScribusMainWindow::arrowKeyDown()
{
        return m_arrowKeyDown;
}
*/


QStringList ScribusMainWindow::findRecoverableFile()
{
        QSet<QString> foundFiles;
        QDir::SortFlags sortflags = QDir::Name | QDir::Time;
        QDir::Filters filterflags = QDir::Files | QDir::NoSymLinks | QDir::NoDot | QDir::NoDotDot;
        if (!m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir.isEmpty())
        {
                QDir dirAuto(m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir, "*_emergency_*.sla", sortflags, filterflags);
                QFileInfoList aList = dirAuto.entryInfoList();
                if (aList.count() > 0)
                {
                        for (int i = 0; i < aList.count(); i++)
                                foundFiles.insert(aList[i].absoluteFilePath());
                }
                QDir dirAuto2(m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir, "*_autosave_*.sla", sortflags, filterflags);
                QFileInfoList aList2 = dirAuto2.entryInfoList();
                if (aList2.count() > 0)
                {
                        for (int i = 0; i < aList2.count(); i++)
                                foundFiles.insert(aList2[i].absoluteFilePath());
                }
        }
        QDir dirDoc(m_prefsManager.documentDir(), "*_emergency_*.sla", sortflags, filterflags);
        QFileInfoList dList = dirDoc.entryInfoList();
        for (int i = 0; i < dList.count(); i++)
                foundFiles.insert(dList[i].absoluteFilePath());

        QDir dirDoc2(m_prefsManager.documentDir(), "*_autosave_*.sla", sortflags, filterflags);
        QFileInfoList dList2 = dirDoc2.entryInfoList();
        for (int i = 0; i < dList2.count(); i++)
                foundFiles.insert(dList2[i].absoluteFilePath());

        QDir dirHome(QDir::toNativeSeparators(QDir::homePath()), "*_emergency_*.sla", sortflags, filterflags);
        QFileInfoList hList = dirHome.entryInfoList();
        for (int i = 0; i < hList.count(); i++)
                foundFiles.insert(hList[i].absoluteFilePath());

        QDir dirHome2(QDir::toNativeSeparators(QDir::homePath()), "*_autosave_*.sla", sortflags, filterflags);
        QFileInfoList hList2 = dirHome2.entryInfoList();
        for (int i = 0; i < hList2.count(); i++)
                foundFiles.insert(hList2[i].absoluteFilePath());

        return foundFiles.values();
}

bool ScribusMainWindow::recoverFile(const QStringList& foundFiles)
{
        appModeHelper->setStartupActionsEnabled(false);
        bool ret = false;
        RecoverDialog* dia = new RecoverDialog(this, foundFiles);
        if (dia->exec())
        {
                if (!dia->recoverFiles.isEmpty())
                {
                        for (int i = 0; i < dia->recoverFiles.count(); ++i)
                        {
                                loadDoc(dia->recoverFiles[i]);
                                doc->setDocumentFileName(dia->recoverNames[i]);
                                doc->hasName = true;
                                updateActiveWindowCaption(doc->documentFileName());
                                outlinePalette->setDoc(doc);
                                if (outlinePalette->isVisible())
                                        outlinePalette->BuildTree();
                        }
                        ret = true;
                }
        }
        delete dia;
        return ret;
}

void ScribusMainWindow::startUpDialog()
{
        bool docSet = false;
        PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
        NewDocDialog* dia = new NewDocDialog(this, m_recentDocsList, true, ScCore->getGuiLanguage());
        if (dia->exec())
        {
                if (dia->tabSelected() == NewDocDialog::NewDocumentTab)
                {
                        int facingPages = dia->choosenLayout();
                        int firstPage = dia->firstPage->currentIndex();
                        docSet = dia->startDocSetup->isChecked();
                        double topMargin = dia->marginGroup->top();
                        double bottomMargin = dia->marginGroup->bottom();
                        double leftMargin = dia->marginGroup->left();
                        double rightMargin = dia->marginGroup->right();
                        double columnDistance = dia->distance();
                        double pageWidth = dia->pageWidth();
                        double pageHeight = dia->pageHeight();
                        double numberCols = dia->numberOfCols->value();
                        bool autoframes = dia->autoTextFrame->isChecked();
                        int orientation = dia->orientation();
                        int pageCount=dia->pageCountSpinBox->value();
                        QString pagesize;
                        if (dia->pageSizeComboBox->currentText() == CommonStrings::trCustomPageSize)
                                pagesize = CommonStrings::customPageSize;
                        else
                        {
                                PageSize ps2(dia->pageSizeComboBox->currentText());
                                pagesize = ps2.name();
                        }
                        doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentIndex(), firstPage, orientation, 1, pagesize, true, pageCount, true, dia->marginGroup->getMarginPreset());
                        doc->setPageSetFirstPage(facingPages, firstPage);
                        doc->bleeds()->set(dia->bleedTop(), dia->bleedLeft(), dia->bleedBottom(), dia->bleedRight());
                        HaveNewDoc();
                        doc->reformPages(true);
                        // Don's disturb user with "save?" dialog just after new doc
                        // doc changing should be rewritten maybe... maybe later...
                        doc->setModified(false);
                        updateActiveWindowCaption(doc->documentFileName());
                }
                else if (dia->tabSelected() == NewDocDialog::NewFromTemplateTab)
                {
                        QString fileName = QDir::cleanPath(dia->selectedFile());
                        if (!fileName.isEmpty() && loadDoc(fileName))
                        {
                                doc->hasName = false;
                                UndoManager::instance()->renameStack(dia->nftGui->currentDocumentTemplate->name);
                                doc->setDocumentFileName(dia->nftGui->currentDocumentTemplate->name);
                                updateActiveWindowCaption(QObject::tr("Document Template: ") + dia->nftGui->currentDocumentTemplate->name);
                                QDir::setCurrent(PrefsManager::instance().documentDir());
                                removeRecent(fileName);
                        }
                }
                else if (dia->tabSelected() == NewDocDialog::OpenExistingTab)
                {
                        QString fileName = dia->selectedFile();
                        if (!fileName.isEmpty())
                        {
                                QFileInfo fi(fileName);
                                docContext->set("docsopen", fi.absolutePath());
                                loadDoc(fileName);
                        }
                }
                else // NewDocDialog::OpenRecentTab
                {
                        QString fileName = dia->selectedFile();
                        if (!fileName.isEmpty())
                                loadRecent(fileName);
                }
        }
        else
        {
                appModeHelper->setStartupActionsEnabled(false);
        }
        m_prefsManager.setShowStartupDialog(!dia->startUpDialog->isChecked());
        delete dia;
        m_mainWindowStatusLabel->setText( tr("Ready"));
        if (docSet)
                slotDocSetup();
}

bool ScribusMainWindow::slotFileNew()
{
        if (HaveDoc && doc->appMode == modeEditClip)
                view->requestMode(submodeEndNodeEdit);
        bool retVal = false;
        bool docSet = false;
        NewDocDialog* dia = new NewDocDialog(this, m_recentDocsList);
        if (dia->exec())
        {
                int facingPages = dia->choosenLayout();
                int firstPage = dia->firstPage->currentIndex();
                docSet = dia->startDocSetup->isChecked();
                double topMargin = dia->marginGroup->top();
                double bottomMargin = dia->marginGroup->bottom();
                double leftMargin = dia->marginGroup->left();
                double rightMargin = dia->marginGroup->right();
                double columnDistance = dia->distance();
                double pageWidth = dia->pageWidth();
                double pageHeight = dia->pageHeight();
                double numberCols = dia->numberOfCols->value();
                bool autoframes = dia->autoTextFrame->isChecked();
                int orientation = dia->orientation();
                int pageCount=dia->pageCountSpinBox->value();
                QString pagesize;
                if (dia->pageSizeComboBox->currentText() == CommonStrings::trCustomPageSize)
                        pagesize = CommonStrings::customPageSize;
                else
                {
                        PageSize ps2(dia->pageSizeComboBox->currentText());
                        pagesize = ps2.name();
                }
                if (doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentIndex(), firstPage, orientation, 1, pagesize, true, pageCount, true, dia->marginGroup->getMarginPreset()))
                {
                        doc->setPageSetFirstPage(facingPages, firstPage);
                        doc->bleeds()->set(dia->bleedTop(), dia->bleedLeft(), dia->bleedBottom(), dia->bleedRight());
                        m_mainWindowStatusLabel->setText( tr("Ready"));
                        HaveNewDoc();
                        doc->reformPages(true);
                        retVal = true;
                        // Don's disturb user with "save?" dialog just after new doc
                        // doc changing should be rewritten maybe... maybe later...
                        doc->setModified(false);
                        updateActiveWindowCaption(doc->documentFileName());
                }
        }
        delete dia;
        if (docSet)
                slotDocSetup();
        return retVal;
}

//TODO move to core, assign doc to doc list, optionally create gui for it
ScribusDoc *ScribusMainWindow::newDoc(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView, int marginPreset)
{
        return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView, marginPreset);
}

ScribusDoc *ScribusMainWindow::doFileNew(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView, int marginPreset)
{
        if (HaveDoc)
                outlinePalette->buildReopenVals();
        m_undoManager->setUndoEnabled(false);
        MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
        DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
        QString newDocName( tr("Document")+"-"+QString::number(m_DocNr));
        ScribusDoc *tempDoc = new ScribusDoc();
        if (requiresGUI)
                doc=tempDoc;
        tempDoc->setLoading(true);
        outlinePalette->setDoc(tempDoc);
        ColorSetManager csm;
        csm.findPaletteLocations();
        csm.findPalettes();
        csm.findUserPalettes();
        ColorList colorList;
        QHash<QString, VGradient> gradientsList;
        QHash<QString, ScPattern> patternsList;
        QString Cpfad = QDir::toNativeSeparators(ScPaths::applicationDataDir())+"DefaultColors.xml";
        QFile fc(Cpfad);
        if (fc.exists())
        {
                csm.loadPalette(Cpfad, doc, colorList, gradientsList, patternsList, false);
                doc->PageColors = colorList;
                doc->docGradients = gradientsList;
                doc->docPatterns = patternsList;
        }
        else
        {
                if (m_prefsManager.appPrefs.colorPrefs.DColorSet != "Scribus Small")
                {
                        QStringList CustomColorSets = csm.userPaletteNames();
                        if (CustomColorSets.contains(m_prefsManager.appPrefs.colorPrefs.DColorSet))
                                Cpfad = csm.userPaletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
                        else
                                Cpfad = csm.paletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
                        if (!Cpfad.isEmpty())
                                csm.loadPalette(Cpfad, doc, colorList, gradientsList, patternsList, false);
                        doc->PageColors = colorList;
                        doc->docGradients = gradientsList;
                        doc->docPatterns = patternsList;
                }
                else
                        doc->PageColors = m_prefsManager.appPrefs.colorPrefs.DColors;
        }
        tempDoc->PageColors.ensureDefaultColors();
        tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
        if (requiresGUI)
        {
                HaveDoc++;
                m_DocNr++;
        }
        if (ScCore->haveCMS() && tempDoc->cmsSettings().CMSinUse)
                recalcColors();
        //CB NOTE should be all done now
        tempDoc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnCount, columnDistance, autoTextFrames, pageArrangement);
        tempDoc->setMarginPreset(marginPreset);
        tempDoc->setMasterPageMode(false);
        tempDoc->createDefaultMasterPages();
        tempDoc->createNewDocPages(pageCount);
        tempDoc->addSection();
        tempDoc->setFirstSectionFromFirstPageNumber();
        tempDoc->setModified(false);
        tempDoc->OpenNodes.clear();
        if (requiresGUI)
        {
                actionManager->disconnectNewDocActions();
                actionManager->connectNewDocActions(tempDoc);
        }
        //<<View and window code
        QMdiArea* qwsp = nullptr;
        if (requiresGUI)
                qwsp = mdiArea;

        ScribusWin* w = new ScribusWin(qwsp, tempDoc);
        w->setMainWindow(this);
        if (requiresGUI && view != nullptr)
                actionManager->disconnectNewViewActions();

        ScribusView* tempView = new ScribusView(w, this, tempDoc);
        if (requiresGUI)
                view = tempView;
        tempDoc->setCurrentPage(tempDoc->Pages->at(0));
        tempDoc->setGUI(requiresGUI, this, tempView);
        if (requiresGUI)
        {
                tempDoc->createHyphenator();
                tempDoc->docHyphenator->ignoredWords = m_prefsManager.appPrefs.hyphPrefs.ignoredWords;
                tempDoc->docHyphenator->specialWords = m_prefsManager.appPrefs.hyphPrefs.specialWords;
        }
        tempDoc->setLoading(false);
        //run after setGUI to set up guidepalette ok

        tempView->setScale(m_prefsManager.displayScale());
        if (requiresGUI)
        {
                //done in newactinw actionManager->connectNewViewActions(tempView);
                alignDistributePalette->setDoc(tempDoc);
                docCheckerPalette->clearErrorList();
                symbolPalette->setDoc(tempDoc);
                inlinePalette->setDoc(tempDoc);
        }
        w->setView(tempView);
        ActWin = w;
        tempDoc->WinHan = w;
        if (requiresGUI)
                tempDoc->connectDocSignals(); //Must be before the first reformpages
        tempView->reformPages(true);
        //>>
        if (requiresGUI)
                w->setSubWin(mdiArea->addSubWindow(w));
        //Independent finishing tasks after tempDoc setup
        if (showView)
        {
                if (mdiArea->subWindowList().count() == 1)
                        w->showMaximized();
                else
                        w->show();
                tempView->show();
                // Seems to fix crash on loading
                ActWin = nullptr;
                newActWin(w->getSubWin());
        }
        if (requiresGUI)
        {
                connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), tempDoc, SLOT(updatePict(QString)));
                connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), tempDoc, SLOT(removePict(QString)));
                connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString)), tempDoc, SLOT(updatePictDir(QString)));
                connect(doc, SIGNAL(updateAutoSaveClock()), view->clockLabel, SLOT(resetTime()));
                view->clockLabel->resetTime();
                scrActions["viewToggleCMS"]->setChecked(tempDoc->HasCMS);
                m_undoManager->switchStack(tempDoc->documentFileName());
                m_styleManager->setDoc(tempDoc);
                marksManager->setDoc(tempDoc);
                nsEditor->setDoc(tempDoc);
                m_tocGenerator->setDoc(tempDoc);
        }
        m_undoManager->setUndoEnabled(true);
        return tempDoc;
}

void ScribusMainWindow::newFileFromTemplate()
{
        nftdialog* nftdia = new nftdialog(this, ScCore->getGuiLanguage());
        if (nftdia->exec() && nftdia->isTemplateSelected())
        {
                qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
                nfttemplate* currentTemplate = nftdia->currentTemplate();
                if (loadDoc(QDir::cleanPath(currentTemplate->file)))
                {
                        doc->hasName = false;
                        UndoManager::instance()->renameStack(currentTemplate->name);
                        doc->setDocumentFileName(currentTemplate->name);
                        updateActiveWindowCaption(QObject::tr("Document Template: ") + currentTemplate->name);
                        QDir::setCurrent(PrefsManager::instance().documentDir());
                        removeRecent(QDir::cleanPath(currentTemplate->file));
                }
                qApp->restoreOverrideCursor();
        }
        delete nftdia;
}

void ScribusMainWindow::newView()
{
        ScribusWin* w = new ScribusWin(mdiArea, doc);
        w->setMainWindow(this);
        view = new ScribusView(w, this, doc);
        view->setScale(m_prefsManager.displayScale());
        w->setView(view);
        ActWin = w;
        w->setCentralWidget(view);
        actionManager->connectNewViewActions(view);
        alignDistributePalette->setDoc(doc);
        connect(m_undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
        view->show();
}

void ScribusMainWindow::windowsMenuAboutToShow()
{
        if (!scrWindowsActions.isEmpty())
        {
                for (auto it = scrWindowsActions.begin(); it != scrWindowsActions.end(); ++it)
                {
                        scrMenuMgr->removeMenuItem(it.key(), it.value(), "Windows");
                }
                scrWindowsActions.clear();
        }
        QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
        bool windowsListNotEmpty=!windows.isEmpty();
        scrActions["windowsCascade"]->setEnabled(windowsListNotEmpty);
        scrActions["windowsTile"]->setEnabled(windowsListNotEmpty);
        if (windowsListNotEmpty)
        {
                int windowCount=static_cast<int>(windows.count());
                for ( int i = 0; i < windowCount; ++i )
                {
                        QString docInWindow(windows.at(i)->windowTitle());
                        scrWindowsActions.insert(docInWindow, new ScrAction( ScrAction::Window, QString(), QString(), docInWindow, QKeySequence(), this, i));
                        scrWindowsActions[docInWindow]->setToggleAction(true);
                        connect( scrWindowsActions[docInWindow], SIGNAL(triggeredData(int)), this, SLOT(windowsMenuActivated(int)) );
                        scrWindowsActions[docInWindow]->setChecked(mdiArea->activeSubWindow() == windows.at(i));
                        scrMenuMgr->addMenuItemString(docInWindow, "Windows");
                }
                if (windowCount>1)
                        scrMenuMgr->addMenuItemStringsToRememberedMenu("Windows", scrWindowsActions);
        }
}

void ScribusMainWindow::extrasMenuAboutToShow()
{
        // There is only Picture Manager handled now.
        // As it can be opened all the time of the document life.
        // This is only check for availability of any ImageFrame
        // in the doc.
        bool enablePicManager = false;
        if (HaveDoc)
        {
                QList<PageItem*> allItems;
                for (int i = 0; i < doc->Items->count(); ++i)
                {
                        PageItem *currItem = doc->Items->at(i);
                        if (currItem->isGroup())
                                allItems = currItem->getAllChildren();
                        else
                                allItems.append(currItem);
                        for (int j = 0; j < allItems.count(); j++)
                        {
                                PageItem* item = allItems.at(j);
                                if ((item->itemType() == PageItem::ImageFrame) && (!item->isLatexFrame()) && (!item->isOSGFrame()))
                                {
                                        enablePicManager = true;
                                        break;
                                }
                        }
                        allItems.clear();
                }
        }
        scrActions["extrasManageImages"]->setEnabled(enablePicManager);
}

void ScribusMainWindow::newActWin(QMdiSubWindow *w)
{
        if (w == nullptr)
        {
                if (mdiArea->subWindowList().count() == 0)
                        ActWin = nullptr;
                return;
        }
        if (w->widget() == nullptr)
                return;
        ScribusWin* scw = dynamic_cast<ScribusWin *>(w->widget());
        if (!scw)
                return;
        if (scw && scw->doc())
        {
                if (!scw->doc()->hasGUI())
                        return;
        }
        if (scw == ActWin)
                return;
        ActWin = scw;
        if (ActWin->doc() == nullptr)
                return;
        if (doc != nullptr)
        {
                if (doc->appMode == modeEditClip)
                        view->requestMode(submodeEndNodeEdit);
                if ((HaveDoc) && (doc != ActWin->doc()))
                        outlinePalette->buildReopenVals();
        }
        docCheckerPalette->clearErrorList();
        if (HaveDoc && (doc != nullptr) && doc->hasGUI())
        {
                disconnect(m_undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
                disconnect(m_undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
                disconnect(m_undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
                disconnect(doc, SIGNAL(addBookmark(PageItem *)), this, SLOT(AddBookMark(PageItem *)));
                disconnect(doc, SIGNAL(deleteBookmark(PageItem *)), this, SLOT(DelBookMark(PageItem *)));
                unitSwitcher->disconnect();
                unitSwitcher->setEnabled(false);
                zoomSpinBox->disconnect();
                zoomSpinBox->setEnabled(false);
                zoomDefaultToolbarButton->disconnect();
                zoomDefaultToolbarButton->setEnabled(false);
                zoomOutToolbarButton->disconnect();
                zoomDefaultToolbarButton->setEnabled(false);
                zoomInToolbarButton->disconnect();
                zoomInToolbarButton->setEnabled(false);
                layerMenu->disconnect();
                layerMenu->setEnabled(false);
                disconnect(viewToolBar->previewQualitySwitcher, SIGNAL(activated(int)), this, SLOT(changePreviewQuality(int)));
                disconnect(viewToolBar->visualMenu, SIGNAL(activated(int)), doc->view(), SLOT(switchPreviewVisual(int)));
                pageSelector->disconnect();
                pageSelector->setEnabled(false);
        }
        doc = ActWin->doc();
        m_undoManager->switchStack(doc->documentFileName());
        if ((doc != nullptr) && doc->hasGUI())
        {
                connect(m_undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
                connect(m_undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
                connect(m_undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
                connect(doc, SIGNAL(addBookmark(PageItem*)), this, SLOT(AddBookMark(PageItem*)));
                connect(doc, SIGNAL(deleteBookmark(PageItem*)), this, SLOT(DelBookMark(PageItem*)));
                connect(unitSwitcher, SIGNAL(activated(int)), doc->view(), SLOT(ChgUnit(int)));
                unitSwitcher->setEnabled(true);
                connect(zoomSpinBox, SIGNAL(valueChanged(double)), doc->view(), SLOT(setZoom()));
                zoomSpinBox->setEnabled(true);
                connect(zoomDefaultToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoom100()));
                zoomDefaultToolbarButton->setEnabled(true);
                connect(zoomOutToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomOut()));
                zoomOutToolbarButton->setEnabled(true);
                connect(zoomInToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomIn()));
                zoomInToolbarButton->setEnabled(true);
                connect(layerMenu, SIGNAL(activated(int)), doc->view(), SLOT(GotoLayer(int)));
                layerMenu->setEnabled(true);
                scrActions["viewPreviewMode"]->blockSignals(true);
                scrActions["viewPreviewMode"]->setChecked(doc->drawAsPreview);
                scrActions["viewPreviewMode"]->blockSignals(false);
                appModeHelper->setPreviewMode(doc->drawAsPreview);
                scrActions["viewEditInPreview"]->setEnabled(doc->drawAsPreview);
                scrActions["viewToggleCMS"]->blockSignals(true);
                scrActions["viewToggleCMS"]->setChecked(doc->HasCMS);
                scrActions["viewToggleCMS"]->blockSignals(false);
                viewToolBar->previewQualitySwitcher->setCurrentIndex(doc->previewQuality());
                connect(viewToolBar->previewQualitySwitcher, SIGNAL(activated(int)), this, SLOT(changePreviewQuality(int)));
                viewToolBar->visualMenu->setCurrentIndex(doc->previewVisual);
                connect(viewToolBar->visualMenu, SIGNAL(activated(int)), doc->view(), SLOT(switchPreviewVisual(int)));
                viewToolBar->setDoc(doc);
                pageSelector->setMaximum(doc->masterPageMode() ? 1 : doc->Pages->count());
                slotSetCurrentPage(doc->currentPageNumber());
                connect(pageSelector, SIGNAL(pageChanged(int)), this, SLOT(setCurrentPage(int)));
                pageSelector->setEnabled(true);
        }
        if (view != nullptr)
        {
                actionManager->disconnectNewViewActions();
                if (ScCore->usingGUI())
                        doc->m_Selection->disconnect(SIGNAL(selectionChanged()), actionManager, SLOT(handleMultipleSelections()));
        }
        view = ActWin->view();
        bool b = zoomSpinBox->blockSignals(true);
        zoomSpinBox->setValue(view->scale() * 100.0 / PrefsManager::instance().appPrefs.displayPrefs.displayScale);
        zoomSpinBox->blockSignals(b);
        actionManager->connectNewViewActions(view);
        actionManager->disconnectNewDocActions();
        actionManager->connectNewDocActions(doc);
        if (ScCore->usingGUI())
                connect(doc->m_Selection, SIGNAL(selectionChanged()), actionManager, SLOT(handleMultipleSelections()));
        pagePalette->setView(view);
        alignDistributePalette->setDoc(doc);
        if (!doc->isLoading())
        {
                SwitchWin();
                view->requestMode(doc->appMode);
        }
        view->setFocus();
        view->setRulersShown(doc->guidesPrefs().rulersShown);
        scrActions["viewShowMargins"]->setChecked(doc->guidesPrefs().marginsShown);
        scrActions["viewShowBleeds"]->setChecked(doc->guidesPrefs().showBleed);
        scrActions["viewShowFrames"]->setChecked(doc->guidesPrefs().framesShown);
        scrActions["viewShowLayerMarkers"]->setChecked(doc->guidesPrefs().layerMarkersShown);
        scrActions["viewShowGrid"]->setChecked(doc->guidesPrefs().gridShown);
        scrActions["viewShowGuides"]->setChecked(doc->guidesPrefs().guidesShown);
        scrActions["viewShowColumnBorders"]->setChecked(doc->guidesPrefs().colBordersShown);
        scrActions["viewShowBaseline"]->setChecked(doc->guidesPrefs().baselineGridShown);
        scrActions["viewShowImages"]->setChecked(doc->guidesPrefs().showPic);
        scrActions["viewShowTextChain"]->setChecked(doc->guidesPrefs().linkShown);
        scrActions["viewShowTextControls"]->setChecked(doc->guidesPrefs().showControls);
        scrActions["viewShowRulers"]->setChecked(doc->guidesPrefs().rulersShown);
        scrActions["viewRulerMode"]->setChecked(doc->guidesPrefs().rulerMode);
        scrActions["extrasGenerateTableOfContents"]->setEnabled(doc->hasTOCSetup());
        scrActions["extrasUpdateDocument"]->setEnabled(true);
        if (!doc->masterPageMode())
                pagePalette->rebuild();
        outlinePalette->setDoc(doc);
        if (outlinePalette->isVisible())
        {
                outlinePalette->BuildTree(false);
                outlinePalette->reopenTree();
        }
        RestoreBookMarks();
        if (!doc->isLoading())
        {
                HaveNewSel();
                if (!doc->m_Selection->isEmpty())
                        doc->m_Selection->itemAt(0)->emitAllToGUI();
        }
        docCheckerPalette->setDoc(doc);
        m_tocGenerator->setDoc(doc);
        m_styleManager->setDoc(doc);
        marksManager->setDoc(doc);
        nsEditor->setDoc(doc);
        symbolPalette->setDoc(doc);
        inlinePalette->setDoc(doc);
        modeToolBar->setDoc(doc);
        // Give plugins a chance to react on changing the current document
        PluginManager& pluginManager(PluginManager::instance());
        QStringList pluginNames(pluginManager.pluginNames(false));
        ScPlugin* plugin;
        QString pName;
        for (int i = 0; i < pluginNames.count(); ++i)
        {
                pName = pluginNames.at(i);
                plugin = pluginManager.getPlugin(pName, true);
                Q_ASSERT(plugin); // all the returned names should represent loaded plugins
                plugin->setDoc(doc);
        }
}

void ScribusMainWindow::windowsMenuActivated(int id)
{
        QMdiSubWindow* windowWidget = mdiArea->subWindowList().at( id );
        if (windowWidget)
        {
                if (windowWidget->isShaded() || windowWidget->isMinimized())
                        windowWidget->showNormal();
                windowWidget->raise();
        }
        newActWin(windowWidget);
}


void ScribusMainWindow::SwitchWin()
{
        updateActiveWindowCaption(doc->documentFileName());
        propertiesPalette->setDoc(doc);
        contentPalette->setDoc(doc);
        marksManager->setDoc(doc);
        nsEditor->setDoc(doc);
        pagePalette->setView(view);
        layerPalette->setDoc(doc);
        guidePalette->setDoc(doc);
        charPalette->setDoc(doc);
        outlinePalette->setDoc(doc);
        symbolPalette->setDoc(doc);
        inlinePalette->setDoc(doc);
        rebuildLayersList();
        updateLayerMenu();
        //Do not set this!, it doesn't get valid pointers unless its in EditClip mode and its not
        //if we are switching windows #4357
        //nodePalette->setDoc(doc, view);
        slotChangeUnit(doc->unitIndex(), false);
/*      FIXME: check if this is really superfluous now
        if (doc->appMode == modeEditClip)
        {
                doc->appMode = modeNormal;
                view->requestMode(submodeEndNodeEdit);
        } */

        appModeHelper->mainWindowSwitchWin(doc);

        if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
                pagePalette->enablePalette(false);
        else
        {
                if (doc->isModified())
                        slotDocCh(false);
                pagePalette->enablePalette(true);
                setPreviewToolbar();
        }

        bool setter = !doc->layerLocked( doc->activeLayer() );
        scrMenuMgr->setMenuEnabled("EditPasteRecent", ((scrapbookPalette->tempBView->objectMap.count() > 0) && (setter)));
        scrMenuMgr->setMenuEnabled("Insert", setter);
        scrMenuMgr->setMenuEnabled("ItemLayer", doc->layerCount() > 1);
        appModeHelper->changeLayer(doc, (ScMimeData::clipboardHasScribusData() || (scrapbookPalette->tempHasContents())));
}

void ScribusMainWindow::HaveNewDoc()
{
        appModeHelper->mainWindowHasNewDoc(doc, (ScMimeData::clipboardHasScribusData()) || (scrapbookPalette->tempHasContents()));

        //Update palettes
        updateActiveWindowCaption(doc->documentFileName());
        propertiesPalette->setDoc(doc);
        contentPalette->setDoc(doc);
        nsEditor->setDoc(doc);

        marksManager->setDoc(doc);
        symbolPalette->setDoc(doc);
        inlinePalette->setDoc(doc);
        pagePalette->setView(view);
        layerPalette->setDoc(doc);
        guidePalette->setDoc(doc);
        charPalette->setDoc(doc);
        outlinePalette->setDoc(doc);
        if (outlinePalette->isVisible())
                outlinePalette->BuildTree();
        rebuildLayersList();
        updateLayerMenu();
        slotChangeUnit(doc->unitIndex());
        windowsMenuAboutToShow();

        // #9275 : scripter must call HaveNewDoc() in case new doc has been created in a script
        // We may consequently have to call HaveNewDoc several times for the same doc.
        // Use Qt::UniqueConnection here to avoid multiple identical signal connections
        connect(view, SIGNAL(unitChanged(int)), this, SLOT(slotChangeUnit(int)), Qt::UniqueConnection);
        connect(view, SIGNAL(layerChanged(int)), layerPalette, SLOT(markActiveLayer(int)), Qt::UniqueConnection);
        connect(this, SIGNAL(changeLayers(int)), layerPalette, SLOT(markActiveLayer(int)), Qt::UniqueConnection);
        connect(view->horizRuler, SIGNAL(MarkerMoved(double,double)), this, SLOT(setStatusBarTextPosition(double,double)), Qt::UniqueConnection);
        connect(view->horizRuler, SIGNAL(DocChanged(bool)), this, SLOT(slotDocCh(bool)), Qt::UniqueConnection);
        connect(view, SIGNAL(ClipPo(double,double)), nodePalette, SLOT(SetXY(double,double)), Qt::UniqueConnection);
        connect(view, SIGNAL(PolyOpen()), nodePalette, SLOT(IsOpen()), Qt::UniqueConnection);
        connect(view, SIGNAL(ItemGeom()), propertiesPalette->xyzPal, SLOT(handleSelectionChanged()), Qt::UniqueConnection);
        connect(view, SIGNAL(ChBMText(PageItem*)), this, SLOT(BookMarkTxT(PageItem*)), Qt::UniqueConnection);
        connect(view, SIGNAL(HaveSel()), this, SLOT(HaveNewSel()), Qt::UniqueConnection);
        connect(view, SIGNAL(DocChanged()), this, SLOT(slotDocCh()), Qt::UniqueConnection);
        connect(view, SIGNAL(MousePos(double,double)), this, SLOT(setStatusBarMousePosition(double,double)), Qt::UniqueConnection);
        connect(view, SIGNAL(ItemCharStyle(const CharStyle&)), contentPalette, SLOT(update(const CharStyle&)), Qt::UniqueConnection);
        connect(view, SIGNAL(ItemTextEffects(int)), this, SLOT(setStyleEffects(int)), Qt::UniqueConnection);
        connect(view, SIGNAL(ItemTextAlign(int)), this, SLOT(setAlignmentValue(int)), Qt::UniqueConnection);
        connect(view, SIGNAL(LoadElem(QString,double,double,bool,bool,ScribusDoc*,ScribusView*)), this, SLOT(slotElemRead(QString,double,double,bool,bool,ScribusDoc*,ScribusView*)), Qt::UniqueConnection);
        connect(view, SIGNAL(AddBM(PageItem*)), this, SLOT(AddBookMark(PageItem*)), Qt::UniqueConnection);
        connect(view, SIGNAL(DelBM(PageItem*)), this, SLOT(DelBookMark(PageItem*)), Qt::UniqueConnection);
}

void ScribusMainWindow::HaveNewSel()
{
        if (doc == nullptr)
                return;
        int selectedType = -1;
        PageItem *currItem = nullptr;
        const int docSelectionCount = doc->m_Selection->count();
        if (docSelectionCount > 0)
        {
                currItem = doc->m_Selection->itemAt(0);
                selectedType = currItem->itemType();
        }
        assert (docSelectionCount == 0 || currItem != nullptr); // help coverity analysis

        setStatusBarTextSelectedItemInfo();

        actionManager->disconnectNewSelectionActions();

        charPalette->setEnabled(false, nullptr);
        view->horizRuler->textMode(false);
        view->horizRuler->update();
        if (!doc->inAnEditMode())
                appModeHelper->enableActionsForSelection(this, doc);

        switch (selectedType)
        {
        case -1: // None
                outlinePalette->slotShowSelect(doc->currentPageNumber(), nullptr);
                propertiesPalette->setGradientEditMode(false);
                break;
        case PageItem::TextFrame: //Text Frame
                if (doc->appMode == modeEdit)
                {
                        setTBvals(currItem);
                        charPalette->setEnabled(true, currItem);
                        if (currItem->isTextFrame())
                        {
                                appModeHelper->enableTextActions(true, currItem->currentStyle().charStyle().font().scName());
                                currItem->asTextFrame()->toggleEditModeActions();
                        }
                        view->horizRuler->setItem(currItem);
                        view->horizRuler->update();
                }
                else
                {
                        const ParagraphStyle& curStyle = currItem->itemText.defaultStyle();
                        doc->currentStyle.setContext(curStyle.context());
                        doc->currentStyle = curStyle;
                        emit TextStyle(doc->currentStyle);
                        // to go: (av)
                        contentPalette->update(doc->currentStyle);
                        setStyleEffects(doc->currentStyle.charStyle().effects());
                }
                break;
        case PageItem::Table:
                if (doc->appMode == modeEditTable)
                {
                        charPalette->setEnabled(true, currItem);
                        PageItem *cellItem = currItem->asTable()->activeCell().textFrame();
                        setTBvals(cellItem);
                        appModeHelper->enableTextActions(true, cellItem->currentCharStyle().font().scName());
                }
                break;
        case PageItem::PathText: //Path Text
                if (doc->appMode == modeEdit)
                        setTBvals(currItem);
                else
                {
                        const ParagraphStyle& curStyle = currItem->itemText.defaultStyle();
                        doc->currentStyle.setContext(curStyle.context());
                        doc->currentStyle = curStyle;
                        emit TextStyle(doc->currentStyle);
                        // to go: (av)
                        contentPalette->update(doc->currentStyle);
                        setStyleEffects(doc->currentStyle.charStyle().effects());
                }
                break;
        }
        propertiesPalette->xyzPal->basePointWidget->setCheckedId(doc->rotationMode());

        if (docSelectionCount != 0)
        {
                actionManager->setPDFActions(view);
                updateItemLayerList();
                rebuildScrapbookMenu();
                propertiesPalette->setTextFlowMode(currItem->textFlowMode());
        }

        if (selectedType != -1)
        {
                outlinePalette->slotShowSelect(currItem->OwnPage, currItem);
                actionManager->connectNewSelectionActions(view, doc);
        }

        appModeHelper->updateActionPluginsActions(doc);
}

void ScribusMainWindow::slotDocCh(bool /*reb*/)
{
        if (!doc->isModified())
                doc->setModified(true);
        updateActiveWindowCaption(doc->documentFileName() + "*");
        if (!doc->masterPageMode())
        {
                if (!doc->symbolEditMode() && !doc->inlineEditMode())
                {
                        if (doc->hasName)
                                scrActions["fileRevert"]->setEnabled(true);
                        bool multiPages = doc->DocPages.count() > 1;
                        scrActions["pageDelete"]->setEnabled(multiPages);
                        scrActions["pageMove"]->setEnabled(multiPages);
                        scrActions["fileCollect"]->setEnabled(true);
                }
                scrActions["fileClose"]->setEnabled(true);
        }

        if (outlinePalette->isVisible())
                outlinePalette->BuildTree();
        // Give plugins a chance to react on changes in the current document
        PluginManager& pluginManager(PluginManager::instance());
        QStringList pluginNames(pluginManager.pluginNames(false));
        ScPlugin* plugin;
        QString pName;
        for (int i = 0; i < pluginNames.count(); ++i)
        {
                pName = pluginNames.at(i);
                plugin = pluginManager.getPlugin(pName, true);
                Q_ASSERT(plugin); // all the returned names should represent loaded plugins
                plugin->changedDoc(doc);
        }
        if (doc->flag_NumUpdateRequest)
        {
                doc->setupNumerations();
                emit UpdateRequest(reqNumUpdate);
        }
        while (doc->flag_Renumber)
        {
                doc->updateNumbers();
                if (!doc->flag_Renumber)
                        doc->regionsChanged()->update(QRect());
        }
        if (m_marksCount != doc->marksList().count() || doc->notesChanged() || doc->flag_updateEndNotes || doc->flag_updateMarksLabels)
        {
                bool sendUpdateReqest = false;
                if (m_marksCount != doc->marksList().count() || doc->flag_updateMarksLabels)
                        sendUpdateReqest = true;
                m_marksCount = doc->marksList().count();
                doc->updateMarks(doc->notesChanged());
                doc->updateChangedEndNotesFrames();
                if (sendUpdateReqest)
                        emit UpdateRequest(reqMarksUpdate);
                doc->setNotesChanged(false);
                doc->flag_updateEndNotes = false;
                doc->flag_updateMarksLabels = false;
        }
}

void ScribusMainWindow::updateRecent(const QString& fn)
{
        if (m_recentDocsList.indexOf(fn) != -1)
                m_recentDocsList.removeAll(fn);
        m_recentDocsList.prepend(fn);
        rebuildRecentFileMenu();
}

void ScribusMainWindow::removeRecent(const QString& fn, bool fromFileWatcher)
{
        if (m_recentDocsList.indexOf(fn) != -1)
        {
                m_recentDocsList.removeAll(fn);
                //#9845: if (!fromFileWatcher)
                //#9845:        ScCore->fileWatcher->removeFile(fn);
        }
        rebuildRecentFileMenu();
}

void ScribusMainWindow::removeRecentFromWatcher(const QString& filename)
{
        removeRecent(filename, true);
}

void ScribusMainWindow::loadRecent(const QString& filename)
{
        QFileInfo fd(filename);
        if (!fd.exists())
                removeRecent(filename);
        else
                loadDoc(filename);
}

void ScribusMainWindow::rebuildRecentFileMenu()
{
        QString strippedName, localName;
        scrMenuMgr->clearMenuStrings("FileOpenRecent");
        scrRecentFileActions.clear();
        int max = qMin(m_prefsManager.appPrefs.uiPrefs.recentDocCount, m_recentDocsList.count());
        for (int i = 0; i < max; ++i)
        {
                strippedName = localName = QDir::toNativeSeparators(m_recentDocsList[i]);
                strippedName.remove(QDir::separator());
                strippedName.prepend(QString("%1").arg(i+1, 2, 10, QChar('0')));
                scrRecentFileActions.insert(strippedName, new ScrAction(ScrAction::RecentFile, QString(), QString(), QString("&%1 %2").arg(i + 1).arg(localName.replace("&","&&")), QKeySequence(), this, m_recentDocsList[i]));
                connect( scrRecentFileActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(loadRecent(QString)) );
                scrMenuMgr->addMenuItemString(strippedName, "FileOpenRecent");
        }
        scrMenuMgr->addMenuItemStringsToRememberedMenu("FileOpenRecent", scrRecentFileActions);
        fileToolBar->rebuildRecentFileMenu();
}

void ScribusMainWindow::rebuildRecentPasteMenu()
{
        scrMenuMgr->clearMenuStrings("EditPasteRecent");

        scrRecentPasteActions.clear();
        int max = qMin(m_prefsManager.appPrefs.scrapbookPrefs.numScrapbookCopies, scrapbookPalette->tempBView->objectMap.count());
        if (max > 0)
        {
                QMap<QString,BibView::Elem>::Iterator it;
                it = scrapbookPalette->tempBView->objectMap.end();
                it--;
                QString strippedName;
                for (int m = 0; m < max; ++m)
                {
                        strippedName = it.key();
                        QPixmap pm = it.value().Preview;
                        scrRecentPasteActions.insert(strippedName, new ScrAction(ScrAction::RecentPaste, pm, QString(), QString("&%1 %2").arg(m+1).arg(strippedName), QKeySequence(), this, it.key()));
                        connect( scrRecentPasteActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(pasteRecent(QString)) );
                        scrMenuMgr->addMenuItemString(strippedName, "EditPasteRecent");
                        it--;
                }
                scrMenuMgr->addMenuItemStringsToRememberedMenu("EditPasteRecent", scrRecentPasteActions);
        }
}

void ScribusMainWindow::rebuildScrapbookMenu()
{
        scrMenuMgr->clearMenuStrings("ItemSendToScrapbook");
        scrScrapActions.clear();
        if (!HaveDoc)
                return;
        QStringList scrapNames = scrapbookPalette->getOpenScrapbooksNames();
        scrapNames.removeAt(1);
        for (int i = 0; i < scrapNames.count(); ++i)
        {
                ScrAction *act = new ScrAction( ScrAction::DataInt, QString(), QString(), scrapNames[i], QKeySequence(), this, i);
                scrScrapActions.insert(scrapNames[i], act);
                connect(act, SIGNAL(triggeredData(int)), this, SLOT(PutScrap(int)));
                scrMenuMgr->addMenuItemString(scrapNames[i], "ItemSendToScrapbook");
        }
        scrMenuMgr->addMenuItemStringsToRememberedMenu("ItemSendToScrapbook", scrScrapActions);
}

void ScribusMainWindow::pasteFromScrapbook(const QString& fn)
{
        if (!HaveDoc)
                return;
        view->dragX = 0;
        view->dragY = 0;
        doPasteRecent(scrapbookPalette->activeBView->objectMap[fn].Data);
}

void ScribusMainWindow::pasteRecent(const QString& fn)
{
        doPasteRecent(scrapbookPalette->tempBView->objectMap[fn].Data);
}

void ScribusMainWindow::doPasteRecent(const QString& data)
{
        if (!HaveDoc)
                return;
        QFileInfo fi(data);
        QString formatD(FormatsManager::instance()->extensionListForFormat(FormatsManager::RASTORIMAGES, 1));
        QStringList rasterFiles = formatD.split("|");
        QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_FIRSTUSER);
        if (vectorFiles.contains(fi.suffix().toLower()))
        {
                FileLoader *fileLoader = new FileLoader(data);
                int testResult = fileLoader->testFile();
                delete fileLoader;
                if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
                {
                        const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
                        if (fmt)
                        {
                                fmt->loadFile(data, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
                        }
                }
                if (!doc->m_Selection->isEmpty())
                {
                        double x2, y2, w, h;
                        doc->m_Selection->getGroupRect(&x2, &y2, &w, &h);
                        doc->moveGroup(doc->currentPage()->xOffset() - x2, doc->currentPage()->yOffset() - y2);
                        emit UpdateRequest(reqColorsUpdate|reqTextStylesUpdate|reqLineStylesUpdate);
                }
        }
        else if (rasterFiles.contains(fi.suffix().toLower()))
        {
                int z = doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), 1, 1, doc->itemToolPrefs().shapeLineWidth, doc->itemToolPrefs().imageFillColor, doc->itemToolPrefs().imageStrokeColor);
                PageItem *b = doc->Items->at(z);
                b->m_layerID = doc->activeLayer();
                doc->loadPict(data, b);
                b->setWidth(static_cast<double>(b->OrigW * 72.0 / b->pixm.imgInfo.xres));
                b->setHeight(static_cast<double>(b->OrigH * 72.0 / b->pixm.imgInfo.yres));
                b->OldB2 = b->width();
                b->OldH2 = b->height();
                b->updateClip();
                b->adjustPictScale();
        }
        else
        {
                UndoTransaction pasteAction;
                if (UndoManager::undoEnabled())
                        pasteAction = m_undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Create, QString(), Um::ICreate);
                view->deselectItems(true);
                int docItemCount = doc->Items->count();
                bool savedAlignGrid = doc->SnapGrid;
                bool savedAlignGuides = doc->SnapGuides;
                bool savedAlignElement = doc->SnapElement;
                doc->SnapGrid = false;
                doc->SnapGuides = false;
                doc->SnapElement = false;
                if ((view->dragX == 0.0) && (view->dragY == 0.0))
                        slotElemRead(data, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), true, true, doc, view);
                else
                        slotElemRead(data, view->dragX, view->dragY, true, false, doc, view);
                doc->SnapGrid = savedAlignGrid;
                doc->SnapGuides = savedAlignGuides;
                doc->SnapElement = savedAlignElement;
                Selection tmpSelection(this, false);
                tmpSelection.copy(*doc->m_Selection, true);
                for (int i = docItemCount; i < doc->Items->count(); ++i)
                {
                        PageItem* currItem = doc->Items->at(i);
                        doc->setRedrawBounding(currItem);
                        tmpSelection.addItem(currItem, true);
                        if (currItem->isBookmark)
                                AddBookMark(currItem);
                }
                doc->m_Selection->copy(tmpSelection, false);
                if (pasteAction)
                        pasteAction.commit();
        }
        slotDocCh(false);
        doc->regionsChanged()->update(QRectF());
        view->dragX = 0;
        view->dragY = 0;
}

void ScribusMainWindow::importVectorFile()
{
        QStringList formats;
        QString allFormats = tr("All Supported Formats")+" (";
        int fmtCode = FORMATID_FIRSTUSER;
        const FileFormat *fmt = LoadSavePlugin::getFormatById(fmtCode);
        while (fmt != nullptr)
        {
                if (fmt->load)
                {
                        formats.append(fmt->filter);
                        int an = fmt->filter.indexOf("(");
                        int en = fmt->filter.indexOf(")");
                        while (an != -1)
                        {
                                allFormats += fmt->filter.mid(an+1, en-an-1)+" ";
                                an = fmt->filter.indexOf("(", en);
                                en = fmt->filter.indexOf(")", an);
                        }
                }
                fmtCode++;
                fmt = LoadSavePlugin::getFormatById(fmtCode);
        }
        allFormats += "*.sce *.SCE);;";
        formats.append("Scribus Objects (*.sce *.SCE)");
        formats.sort(Qt::CaseInsensitive);
        allFormats += formats.join(";;");

        PrefsContext* dirs = PrefsManager::instance().prefsFile->getContext("dirs");
        QString wdir = dirs->get("pastefile", ".");
        CustomFDialog dia(this, wdir, tr("Open"), allFormats, fdExistingFiles | fdDisableOk);
        if (dia.exec() != QDialog::Accepted)
                return;

        QString fileName = dia.selectedFile();
        if (fileName.isEmpty())
                return;

        PrefsManager::instance().prefsFile->getContext("dirs")->set("pastefile", fileName.left(fileName.lastIndexOf("/")));
        QFileInfo fi(fileName);
        QString suffix = fi.suffix().toLower();
        if ((suffix == "sce") || (suffix == "shape"))
        {
                QList<QUrl> urls;
                QMimeData* md = new QMimeData();
                urls.append( QUrl::fromLocalFile(fileName) );
                md->setUrls(urls);
                QDrag* dr = new QDrag(this);
                dr->setMimeData(md);
                const QPixmap& dragCursor = IconManager::instance().loadPixmap("dragpix.png");
                dr->setPixmap(dragCursor);
                dr->exec();
        }
        else
        {
                FileLoader *fileLoader = new FileLoader(fileName);
                int testResult = fileLoader->testFile();
                delete fileLoader;
                if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
                {
                        const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
                        if (fmt)
                        {
                                doc->dontResize = true;
                                fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive);
                                doc->dontResize = false;
                        }
                }
        }
        requestUpdate(reqColorsUpdate | reqSymbolsUpdate | reqLineStylesUpdate | reqTextStylesUpdate);
}

void ScribusMainWindow::rebuildLayersList()
{
        if (!HaveDoc)
                return;
        scrMenuMgr->clearMenuStrings("ItemLayer");
        scrLayersActions.clear();
        ScLayers::iterator it;
        if (doc->Layers.count()!= 0)
        {
                for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
                {
                        scrLayersActions.insert(QString("%1").arg((*it).ID), new ScrAction(ScrAction::Layer, QString(), QString(), (*it).Name, QKeySequence(), this, (*it).ID));
                        scrLayersActions[QString("%1").arg((*it).ID)]->setToggleAction(true);
                        QPixmap pm(20,15);
                        pm.fill((*it).markerColor);
                        scrLayersActions[QString("%1").arg((*it).ID)]->setIcon(pm);
                }
        }
        int currActiveLayer = doc->activeLayer();
        bool found = false;
        for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
        {
                if ((*it).ID == currActiveLayer)
                {
                        found=true;
                        break;
                }
        }
        Q_ASSERT(found);
        scrLayersActions[QString("%1").arg((*it).ID)]->setChecked(true);

        for (auto it = scrLayersActions.begin(); it != scrLayersActions.end(); ++it )
        {
                scrMenuMgr->addMenuItemString(it.key(), "ItemLayer");
                connect( (*it), SIGNAL(triggeredData(int)), doc, SLOT(itemSelection_SendToLayer(int)) );
        }
        scrMenuMgr->addMenuItemStringsToRememberedMenu("ItemLayer", scrLayersActions);
}

void ScribusMainWindow::updateItemLayerList()
{
        if (!HaveDoc)
                return;
        QMap<QString, QPointer<ScrAction> >::Iterator itend=scrLayersActions.end();
        for (auto it = scrLayersActions.begin(); it!=itend; ++it)
        {
                (*it)->disconnect(SIGNAL(triggeredData(int)));
                (*it)->setChecked(false);
        }
        if (!doc->m_Selection->isEmpty() && doc->m_Selection->itemAt(0))
                scrLayersActions[QString("%1").arg(doc->m_Selection->itemAt(0)->m_layerID)]->setChecked(true);
        for (auto it = scrLayersActions.begin(); it != itend; ++it)
                connect( (*it), SIGNAL(triggeredData(int)), doc, SLOT(itemSelection_SendToLayer(int)) );
}

void ScribusMainWindow::updateColorLists()
{
        if (!HaveDoc)
                return;
        requestUpdate(reqColorsUpdate | reqLineStylesUpdate);
        m_styleManager->updateColorList();
}

bool ScribusMainWindow::slotFileOpen()
{
        PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
        QString docDir(".");
        QString prefsDocDir(m_prefsManager.documentDir());
        if (!prefsDocDir.isEmpty())
                docDir = docContext->get("docsopen", prefsDocDir);
        else
                docDir = docContext->get("docsopen", ".");
        QString formats(FileLoader::getLoadFilterString());
        QString fileName(CFileDialog( docDir, tr("Open"), formats, "", fdDisableOk));
        if (fileName.isEmpty()) // User cancelled
                return false;
        QFileInfo fi(fileName);
        docContext->set("docsopen", fi.absolutePath());
        return loadDoc(fileName);
}

bool ScribusMainWindow::slotPageImport()
{
        Q_ASSERT(!doc->masterPageMode());
       
        QScopedPointer<MergeDoc> dia(new MergeDoc(this, false, doc->DocPages.count(), doc->currentPage()->pageNr() + 1));
        if (!dia->exec())
                return false;

        bool ret = false;
        UndoTransaction activeTransaction;
        if (UndoManager::undoEnabled())
                activeTransaction = m_undoManager->beginTransaction(Um::ImportPage, Um::IGroup, Um::ImportPage, nullptr, Um::ILock);

        m_mainWindowStatusLabel->setText( tr("Importing Pages..."));
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
        std::vector<int> pageNs;
        parsePagesString(dia->getPageNumbers(), &pageNs, dia->getPageCounter());
        int startPage=0, nrToImport=pageNs.size();
        bool doIt = true;
        if (doc->masterPageMode())
        {
                if (nrToImport > 1)
                        loadPage(dia->getFromDoc(), pageNs[0] - 1, false);
                doIt = false;
        }
        else if (dia->getCreatePageChecked())
        {
                int importWhere = dia->getImportWhere();
                if (importWhere == 0)
                        startPage = dia->getImportWherePage();
                else if (importWhere == 1)
                        startPage = dia->getImportWherePage() + 1;
                else
                        startPage = doc->DocPages.count() + 1;
                addNewPages(dia->getImportWherePage(), importWhere, nrToImport, doc->pageHeight(), doc->pageWidth(), doc->pageOrientation(), doc->pageSize(), true);
        }
        else
        {
                startPage = doc->currentPage()->pageNr() + 1;
                if (nrToImport > (doc->DocPages.count() - doc->currentPage()->pageNr()))
                {
                        qApp->setOverrideCursor(QCursor(Qt::ArrowCursor));
                        ScMessageBox msgBox;
                        msgBox.setIcon(QMessageBox::Information);
                        msgBox.setText(tr("Import Page(s)"));
                        msgBox.setInformativeText("<qt>" +
                        QObject::tr("<p>You are trying to import more pages than there are available in the current document counting from the active page.</p>Choose one of the following:"
                        "<ul><li><b>Create</b> missing pages</li>"
                        "<li><b>Import</b> pages until the last page</li>"
                        "<li><b>Cancel</b></li></ul>") + "</qt>");
                        QPushButton *createButton = msgBox.addButton(tr("C&reate"), QMessageBox::AcceptRole);
                        QPushButton *importButton = msgBox.addButton(tr("&Import"), QMessageBox::AcceptRole);
                        QPushButton *cancelButton = msgBox.addButton(CommonStrings::tr_Cancel, QMessageBox::RejectRole);
                        msgBox.setDefaultButton(cancelButton);
                        msgBox.setDefaultBatchButton(createButton);
                        msgBox.exec();
                        if (msgBox.clickedButton() == createButton)
                        {
                                addNewPages(doc->DocPages.count(), 2,
                                                        nrToImport - (doc->DocPages.count() - doc->currentPage()->pageNr()),
                                                        doc->pageHeight(), doc->pageWidth(), doc->pageOrientation(), doc->pageSize(), true);
                        }
                        else if (msgBox.clickedButton() == importButton)
                        {
                                nrToImport = doc->DocPages.count() - doc->currentPage()->pageNr();
                        }
                        else
                        {
                                doIt = false;
                                m_mainWindowStatusLabel->setText("");
                        }
                        qApp->restoreOverrideCursor();
                }
        }
        if (doIt)
        {
                if (nrToImport > 0)
                {
                        mainWindowProgressBar->reset();
                        mainWindowProgressBar->setMaximum(nrToImport);
                        int counter = startPage;
                        for (int i = 0; i < nrToImport; ++i)
                        {
                                view->GotoPa(counter);
                                loadPage(dia->getFromDoc(), pageNs[i] - 1, false);
                                counter++;
                                mainWindowProgressBar->setValue(i + 1);
                        }
                        view->GotoPa(startPage);
                        mainWindowProgressBar->reset();
                        m_mainWindowStatusLabel->setText( tr("Import done"));
                }
                else
                {
                        m_mainWindowStatusLabel->setText( tr("Found nothing to import"));
                        doIt = false;
                }
        }
        qApp->restoreOverrideCursor();
        ret = doIt;

        if (activeTransaction)
                activeTransaction.commit();
        return ret;
}

bool ScribusMainWindow::loadPage(const QString& fileName, int Nr, bool Mpa, const QString& renamedPageName)
{
        if (fileName.isEmpty())
                return false;

        FileLoader *fl = new FileLoader(fileName);
        if (fl->testFile() == -1)
        {
                delete fl;
                return false;
        }
        doc->setLoading(true);
        int oldItemsCount = doc->Items->count();
        if (!fl->loadPage(doc, Nr, Mpa, renamedPageName))
        {
                delete fl;
                doc->setLoading(false);
                return false;
        }
        delete fl;
        if (ScCore->haveCMS() && doc->cmsSettings().CMSinUse)
        {
                recalcColors();
                doc->RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK);
        }
        int docItemsCount = doc->Items->count();
        for (int i = oldItemsCount; i < docItemsCount; ++i)
        {
                PageItem *ite = doc->Items->at(i);
                if ((ite->isTextFrame()) && (ite->isBookmark))
                        AddBookMark(ite);
        }
        propertiesPalette->updateColorList();
        contentPalette->updateColorList();
        emit UpdateRequest(reqArrowStylesUpdate | reqLineStylesUpdate | reqStyleComboDocUpdate | reqInlinePalUpdate);
        symbolPalette->updateSymbolList();
        slotDocCh();
        rebuildLayersList();
        updateLayerMenu();
        layerPalette->rebuildList();
        doc->setLoading(false);

        if (!Mpa)
                pagePalette->rebuild();
        view->reformPages();
        view->DrawNew();
        return true;
}

bool ScribusMainWindow::loadDoc(const QString& fileName)
{
#ifdef DEBUG_LOAD_TIMES
        QTime t;
        struct tms tms1, tms2;
        t.start();
        times(&tms1);
#endif
       
        QFileInfo fi(fileName);
        if (!fi.exists())
        {
                ScMessageBox::warning(this, CommonStrings::trWarning, tr("File does not exist on the specified path :\n%1").arg(QDir::toNativeSeparators(fileName)), QMessageBox::Ok);
                return false;
        }
       
        qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
        if (HaveDoc)
                outlinePalette->buildReopenVals();
        bool ret = false;
        QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
        ScribusWin* ActWinOld = nullptr;
        if (windows.count() != 0)
        {
                ActWinOld = ActWin;
        }

        // PV - 5780: Scribus doesn't track what documents are already opened
        // The goal of this part of code is to disallow user to open one
        // doc multiple times.
        QString filename = fi.absoluteFilePath();
        QString platfName(QDir::toNativeSeparators(filename));
        int windowCount = windows.count();
        for (int i = 0; i < windowCount; ++i)
        {
                QString docNameUnmodified(windows.at(i)->windowTitle());
                ScribusWin * mx = qobject_cast<ScribusWin*>(windows.at(i)->widget());
                if (mx && mx->doc()->isModified() && docNameUnmodified.endsWith("*"))
                        docNameUnmodified.resize(docNameUnmodified.length() - 1);

                if (docNameUnmodified == platfName)
                {
                        qApp->restoreOverrideCursor();
                        ScMessageBox::information(this, tr("Document is already opened"), tr("This document is already open. It will be set as the active document."));
                        windowsMenuActivated(i);
                        return true;
                }
        }
        UndoBlocker undoBlocker;
        if (!fileName.isEmpty())
        {
                FileLoader *fileLoader = new FileLoader(filename);
                int testResult = fileLoader->testFile();
                if (testResult == -1)
                {
                        delete fileLoader;
                        qApp->restoreOverrideCursor();
                        QString title = tr("Fatal Error") ;
                        QString msg = "<qt>"+ tr("File %1 is not in an acceptable format").arg(filename)+"</qt>";
                        QString infoMsg = "<qt>" + tr("The file may be damaged or may have been produced in a later version of Scribus.") + "</qt>";
                        ScMessageBox msgBox(QMessageBox::Critical, title, msg, QMessageBox::Ok | QMessageBox::Help, this);
                        msgBox.setInformativeText(infoMsg);
                        int i = msgBox.exec();
                        if (i == QMessageBox::Help)
                                slotOnlineHelp("", "fileproblems.html");
                        return false;
                }
                bool is12doc=false;
                if (testResult == 0)
                {
                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
                        //Scribus 1.3.x warning, remove at a later stage
                        is12doc=true;
                }
                QDir docProfileDir(fi.absolutePath() + "/profiles");
                ScCore->getCMSProfilesDir(fi.absolutePath() + "/", false, false);
                if (docProfileDir.exists())
                        ScCore->getCMSProfilesDir(fi.absolutePath() + "/profiles", false, false);

                m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/", filename);
                QDir docFontDir(fi.absolutePath() + "/fonts");
                if (docFontDir.exists())
                        m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/fonts", filename);
                QDir docFontDir2(fi.absolutePath() + "/Fonts");
                if (docFontDir2.exists())
                        m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/Fonts", filename);
                QDir docFontDir3(fi.absolutePath() + "/Document fonts");
                if (docFontDir3.exists())
                        m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/Document fonts", filename);
                m_prefsManager.appPrefs.fontPrefs.AvailFonts.updateFontMap();
                if (view != nullptr)
                        actionManager->disconnectNewViewActions();
                doc = new ScribusDoc();
                doc->saveFilePermissions(QFile::permissions(fileName));
                doc->is12doc=is12doc;
                doc->appMode = modeNormal;
                doc->HasCMS = false;
                doc->OpenNodes.clear();
                doc->setLoading(true);
                m_mainWindowStatusLabel->setText( tr("Loading..."));
                mainWindowProgressBar->reset();
                ScribusWin* w = new ScribusWin(mdiArea, doc);
                w->setMainWindow(this);
                view = new ScribusView(w, this, doc);
                doc->setGUI(true, this, view);
                view->setScale(m_prefsManager.displayScale());
                w->setView(view);
                alignDistributePalette->setDoc(doc);
                ActWin = w;
                doc->WinHan = w;
                w->setSubWin(mdiArea->addSubWindow(w));
                w->setUpdatesEnabled(false);
                view->updatesOn(false);
                doc->SoftProofing = false;
                doc->Gamut = false;
                setScriptRunning(true);
                bool loadSuccess = fileLoader->loadFile(doc);
                //Do the font replacement check from here, when we have a GUI. TODO do this also somehow without the GUI
                //This also gives the user the opportunity to cancel the load when finding there's a replacement required.
                if (loadSuccess && ScCore->usingGUI())
                        loadSuccess = fileLoader->postLoad(doc);
                if (!loadSuccess)
                {
                        view->close();
                        delete fileLoader;
                        delete doc;
                        doc = nullptr;
                        mdiArea->removeSubWindow(w->getSubWin());
                        delete w;
                        view = nullptr;
                        doc = nullptr;
                        setScriptRunning(false);
                        qApp->restoreOverrideCursor();
                        m_mainWindowStatusLabel->setText("");
                        mainWindowProgressBar->reset();
                        ActWin = nullptr;
                        if (windows.count() != 0)
                        {
                                newActWin(ActWinOld->getSubWin());
                                if (ActWin)
                                {
                                        if ((mdiArea->subWindowList().isEmpty()) || (mdiArea->subWindowList().count() == 1))
                                                ActWin->showMaximized();
                                }
                        }
                        return false;
                }
                symbolPalette->setDoc(doc);
                outlinePalette->setDoc(doc);
                fileLoader->informReplacementFonts();
                setCurrentComboItem(unitSwitcher, unitGetStrFromIndex(doc->unitIndex()));
                bool b = zoomSpinBox->blockSignals(true);
                zoomSpinBox->setValue(view->scale());
                zoomSpinBox->blockSignals(b);
                view->unitChange();
                setScriptRunning(false);
                view->deselectItems(true);
                m_mainWindowStatusLabel->setText("");
                mainWindowProgressBar->reset();
                HaveDoc++;
                if (doc->checkerProfiles().count() == 0)
                {
                        m_prefsManager.initDefaultCheckerPrefs(doc->checkerProfiles());
                        doc->setCurCheckProfile(CommonStrings::PDF_1_4);
                }
                m_prefsManager.insertMissingCheckerProfiles(doc->checkerProfiles());
                if (doc->pdfOptions().LPISettings.count() == 0)
                {
                        struct LPIData lpo;
                        lpo.Frequency = 133;
                        lpo.SpotFunc = 3;
                        lpo.Angle = 105;
                        doc->pdfOptions().LPISettings.insert("Cyan", lpo);
                        lpo.Angle = 75;
                        doc->pdfOptions().LPISettings.insert("Magenta", lpo);
                        lpo.Angle = 90;
                        doc->pdfOptions().LPISettings.insert("Yellow", lpo);
                        lpo.Angle = 45;
                        doc->pdfOptions().LPISettings.insert("Black", lpo);
                }
                if (!doc->cmsSettings().CMSinUse)
                        doc->HasCMS = false;
                if ((ScCore->haveCMS()) && (doc->cmsSettings().CMSinUse))
                {
                        QString missing, replacement;
                        QMultiMap<QString, QString> missingMap;
                        if (!ScCore->InputProfiles.contains(doc->cmsSettings().DefaultImageRGBProfile))
                        {
                                missing = doc->cmsSettings().DefaultImageRGBProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultImageRGBProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
                        }
                        if (!ScCore->InputProfilesCMYK.contains(doc->cmsSettings().DefaultImageCMYKProfile))
                        {
                                missing = doc->cmsSettings().DefaultImageCMYKProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageCMYKProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultImageCMYKProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageCMYKProfile;
                        }
                        if (!ScCore->InputProfiles.contains(doc->cmsSettings().DefaultSolidColorRGBProfile))
                        {
                                missing = doc->cmsSettings().DefaultSolidColorRGBProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultSolidColorRGBProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
                        }
                        if (!ScCore->InputProfilesCMYK.contains(doc->cmsSettings().DefaultSolidColorCMYKProfile))
                        {
                                missing = doc->cmsSettings().DefaultSolidColorCMYKProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultSolidColorCMYKProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile;
                        }
                        if (!ScCore->MonitorProfiles.contains(doc->cmsSettings().DefaultMonitorProfile))
                        {
                                missing = doc->cmsSettings().DefaultMonitorProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultMonitorProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultMonitorProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultMonitorProfile;
                        }
                        if (!ScCore->PrinterProfiles.contains(doc->cmsSettings().DefaultPrinterProfile))
                        {
                                missing = doc->cmsSettings().DefaultPrinterProfile;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->cmsSettings().DefaultPrinterProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
                        }
                        if (!ScCore->PrinterProfiles.contains(doc->pdfOptions().PrintProf))
                        {
                                missing = doc->pdfOptions().PrintProf;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->pdfOptions().PrintProf = doc->cmsSettings().DefaultPrinterProfile;
                        }
                        if (!ScCore->InputProfiles.contains(doc->pdfOptions().ImageProf))
                        {
                                missing = doc->pdfOptions().ImageProf;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->pdfOptions().ImageProf = doc->cmsSettings().DefaultImageRGBProfile;
                        }
                        if (!ScCore->InputProfiles.contains(doc->pdfOptions().SolidProf))
                        {
                                missing = doc->pdfOptions().SolidProf;
                                replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
                                if (!missingMap.contains(missing, replacement))
                                        missingMap.insert(missing, replacement);
                                doc->pdfOptions().SolidProf = doc->cmsSettings().DefaultSolidColorRGBProfile;
                        }
                        if (missingMap.count() > 0)
                        {
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
                                QString mess = tr("Some color profiles used by this document are not installed:")+"\n\n";
                                for (auto it = missingMap.constBegin(); it != missingMap.constEnd(); ++it)
                                {
                                        mess += it.key() + tr(" was replaced by: ") + it.value() +"\n";
                                }
                                ScMessageBox::warning(this, CommonStrings::trWarning, mess);
                        }
                        doc->SoftProofing = doc->cmsSettings().SoftProofOn;
                        doc->Gamut        = doc->cmsSettings().GamutCheck;
                        doc->IntentColors = doc->cmsSettings().DefaultIntentColors;
                        doc->IntentImages = doc->cmsSettings().DefaultIntentImages;
                        if (doc->OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles))
                        {
                                doc->HasCMS = true;
                                doc->pdfOptions().SComp = doc->cmsSettings().ComponentsInput2;
                        }
                        else
                        {
                                doc->SetDefaultCMSParams();
                                doc