Rev 25046 |
Rev 25197 |
Go to most recent revision |
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 "textnote.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(scrapbookFileO);
if (scrapbookFileInfoO.exists())
{
scrapbookPalette->readOldContents(scrapbookFileO, ScPaths::scrapbookDir(true) + "main");
QDir d;
d.rename(scrapbookFileO, QDir::toNativeSeparators(m_prefsManager.preferencesLocation()+"/scrap13.backup"));
}
QString scrapbookTemp = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "tmp");
QFileInfo scrapbookTempInfo(scrapbookTemp);
if (scrapbookTempInfo.exists())
scrapbookPalette->readTempContents(scrapbookTemp);
QString scrapbookFile = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "main");
QFileInfo scrapbookFileInfo(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->createMenu("Marks", tr("Marks"), "Item");
scrMenuMgr->addMenuItemString("Marks", "Item");
scrMenuMgr->addMenuItemString("editMark", "Marks");
scrMenuMgr->createMenu("TextFeatures", tr("Text Features", "Item"));
scrMenuMgr->addMenuItemString("TextFeatures", "Item");
scrMenuMgr->addMenuItemString("alignLeft", "TextFeatures");
scrMenuMgr->addMenuItemString("alignCenter", "TextFeatures");
scrMenuMgr->addMenuItemString("alignRight", "TextFeatures");
scrMenuMgr->addMenuItemString("alignBlock", "TextFeatures");
scrMenuMgr->addMenuItemString("alignForced", "TextFeatures");
scrMenuMgr->addMenuItemString("SEPARATOR", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectNormal", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectUnderline", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectUnderlineWords", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectStrikeThrough", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectAllCaps", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectSmallCaps", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectSuperscript", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectSubscript", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectOutline", "TextFeatures");
scrMenuMgr->addMenuItemString("typeEffectShadow", "TextFeatures");
//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(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)
return;
auto it = scrapbookPalette->tempBView->objectMap.end();
QString strippedName;
for (int i = 0; i < max; ++i)
{
it--;
strippedName = it.key();
QPixmap pm = it.value().Preview;
scrRecentPasteActions.insert(strippedName, new ScrAction(ScrAction::RecentPaste, pm, QString(), QString("&%1 %2").arg(i + 1).arg(strippedName), QKeySequence(), this, it.key()));
connect( scrRecentPasteActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(pasteRecent(QString)) );
scrMenuMgr->addMenuItemString(strippedName, "EditPasteRecent");
}
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));