Rev 21025 |
Rev 21040 |
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 <QDesktopWidget>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QEvent>
#include <QEventLoop>
#include <QFileDialog>
#include <QFrame>
#include <QFont>
#include <QIcon>
#include <QInputDialog>
#include <QKeyEvent>
#include <QKeySequence>
#include <QLabel>
#include <QList>
#include <QLocale>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPixmap>
#include <QProgressBar>
#include <QPushButton>
//<<QML testing
#include <QHBoxLayout>
#include <QQuickView>
#include <QQmlEngine>
#include <QQmlComponent>
#include <QQuickItem>
#include <QQmlProperty>
//>>
#include <QRegExp>
#include <QScopedPointer>
#include <QStyleFactory>
#include <QTableWidget>
#include <QTextCodec>
#include <QTranslator>
#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 <signal.h>
#include <string>
#include "actionmanager.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 "docinfo.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 "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_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 "styleoptions.h"
#include "tocgenerator.h"
#include "ui/about.h"
#include "ui/aboutplugins.h"
#include "ui/adjustcmsdialog.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/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/margindialog.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/newfile.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/pageitemattributes.h"
#include "ui/pagelayout.h"
#include "ui/pagepalette.h"
#include "ui/pageselector.h"
#include "ui/paintmanager.h"
#include "ui/pdfexportdialog.h"
#include "ui/pdftoolbar.h"
#include "ui/picstatus.h"
#include "ui/polygonwidget.h"
#include "ui/preferencesdialog.h"
#include "ui/preview.h"
#include "ui/printdialog.h"
#include "ui/propertiespalette.h"
#include "ui/propertiespalette_image.h"
#include "ui/propertiespalette_line.h"
#include "ui/propertiespalette_shape.h"
#include "ui/propertiespalette_text.h"
#include "ui/propertiespalette_xyz.h"
#include "ui/query.h"
#include "ui/replacecolors.h"
#include "ui/resourcemanager.h"
#include "ui/sccombobox.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 "util.h"
#include "util_file.h"
#include "util_formats.h"
#include "util_ghostscript.h"
#include "util_math.h"
#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()
{
actionManager=0;
appModeHelper=0;
scrMenuMgr=0;
m_prefsManager=0;
m_formatsManager=0;
resourceManager=0;
UrlLauncher::instance();
m_mainWindowStatusLabel=0;
ExternalApp=0;
m_ScriptRunning = 0;
#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.xpm");
#endif
}
/*
* retval 0 - ok, 1 - no fonts, ...
*/
int ScribusMainWindow::initScMW(bool primaryMainWindow)
{
int retVal=0;
qsrand(1234);
QByteArray stylesheet;
if (loadRawText(ScPaths::getApplicationDataDir() + "/stylesheet.css", stylesheet))
{
qApp->setStyleSheet(QString(stylesheet));
}
previewDinUse = false;
printDinUse = false;
internalCopy = false;
internalCopyBuffer = "";
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, 0);
CurrStED = NULL;
setWindowTitle( tr("Scribus " VERSION));
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_prefsManager = PrefsManager::instance();
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);
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);
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 );
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();
m_prefsManager->setupMainWindow(this);
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();
QString preLang(m_prefsManager->appPrefs.hyphPrefs.Language);
initHyphenator();
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();
if (scrActions["SaveAsDocumentTemplate"])
scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
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::getApplicationDataDir())+"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;
}
ScribusMainWindow::~ScribusMainWindow()
{
if (actionManager)
delete actionManager;
if (appModeHelper)
delete appModeHelper;
delete m_doc;
}
void ScribusMainWindow::addScToolBar(ScToolBar *tb, 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);
stylesheet.replace("___downArrow___", da);
QString toolbararrow(IconManager::instance()->pathForIcon("stylesheet/down_arrow.png"));
QByteArray tba;
tba.append(toolbararrow);
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 = NULL;
doc = NULL;
m_DocNr = 1;
m_PrinterUsed = false;
PDef.Pname = "";
PDef.Dname = "";
PDef.Command = "";
m_keyrep = false;
m__arrowKeyDown = false;
ClipB = QApplication::clipboard();
for (int i=0; i<PS_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(osgDB::ReaderWriterInfoList::iterator 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( QMap<QString, QPointer<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
{
if ((ScrAction*)(it.value())!=NULL)
{
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);
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);
layerPalette->Table->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->tmpStyles()));
m_styleManager->addStyle(tmpCS);
m_styleManager->addStyle(new SMTableStyle());
m_styleManager->addStyle(new SMCellStyle());
m_styleManager->addStyle(new SMLineStyle());
connect( scrActions["editStyles"], SIGNAL(toggled(bool)), m_styleManager, SLOT(setPaletteShown(bool)) );
connect( m_styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
m_styleManager->installEventFilter(this);
// initializing mark`s manager
marksManager = new MarksManager(this, "marksManager");
connect( scrActions["editMarks"], SIGNAL(toggled(bool)), marksManager, SLOT(setPaletteShown(bool)) );
connect( marksManager, SIGNAL(paletteShown(bool)), scrActions["editMarks"], SLOT(setChecked(bool)));
marksManager->installEventFilter(this);
// initializing notes styles manager
nsEditor = new NotesStylesEditor(this, "notesStylesEditor");
connect( scrActions["editNotesStyles"], SIGNAL(toggled(bool)), nsEditor, SLOT(setPaletteShown(bool)) );
connect( nsEditor, SIGNAL(paletteShown(bool)), scrActions["editNotesStyles"], SLOT(setChecked(bool)));
nsEditor->installEventFilter(this);
connect(docCheckerPalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
connect(docCheckerPalette, SIGNAL(selectElement(PageItem *, bool, int)), this, SLOT(selectItemFromOutlines(PageItem *, bool, int)));
connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
connect(outlinePalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
connect(outlinePalette, SIGNAL(editElementByItem(PageItem *)), this, SLOT(editItemsFromOutlines(PageItem *)));
connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
connect(nodePalette, SIGNAL(paletteClosed()), this, SLOT(slotSelect()));
connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
connect(bookmarkPalette->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
connect(bookmarkPalette->BView, SIGNAL(SelectElement(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
// guides
connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setChecked(bool)));
// char palette
connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setChecked(bool)));
}
void ScribusMainWindow::initScrapbook()
{
QString scrapbookFileO = QDir::toNativeSeparators(m_prefsManager->preferencesLocation()+"/scrap13.scs");
QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
if (scrapbookFileInfoO.exists())
{
scrapbookPalette->readOldContents(scrapbookFileO, QDir::toNativeSeparators(m_prefsManager->preferencesLocation()+"/scrapbook/main"));
QDir d = QDir();
d.rename(scrapbookFileO, QDir::toNativeSeparators(m_prefsManager->preferencesLocation()+"/scrap13.backup"));
}
QString scrapbookTemp = QDir::toNativeSeparators(m_prefsManager->preferencesLocation()+"/scrapbook/tmp");
QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
if (scrapbookTempInfo.exists())
scrapbookPalette->readTempContents(scrapbookTemp);
QString scrapbookFile = QDir::toNativeSeparators(m_prefsManager->preferencesLocation()+"/scrapbook/main");
QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
if (scrapbookFileInfo.exists())
scrapbookPalette->readContents(scrapbookFile);
scrapbookPalette->setScrapbookFileName(scrapbookFile);
ScCore->fileWatcher->addDir(scrapbookFile, true);
scrapbookPalette->setOpenScrapbooks(m_prefsManager->appPrefs.scrapbookPrefs.RecentScrapbooks);
rebuildRecentPasteMenu();
connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString )), scrapbookPalette, SLOT(reloadLib(QString )));
connect(ScCore->fileWatcher, SIGNAL(dirDeleted(QString )), scrapbookPalette, SLOT(closeOnDel(QString )));
}
bool ScribusMainWindow::warningVersion(QWidget *parent)
{
bool retval = false;
int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
QObject::tr("You are running a development version of Scribus 1.5.x. The document you are working with was created in Scribus 1.2.x. Saving the current file under 1.5.x renders it unable to be edited in Scribus 1.2.x versions. To preserve the ability to edit in 1.2.x, save this file under a different name and further edit the newly named file and the original will be untouched. Are you sure you wish to proceed with this operation?") + "</qt>",
QMessageBox::Ok | QMessageBox::Cancel,
QMessageBox::Cancel, // GUI default
QMessageBox::Ok); // batch default
if (t == QMessageBox::Ok)
retval = true;
return retval;
}
void ScribusMainWindow::initMenuBar()
{
RecentDocs.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");
scrMenuMgr->addMenuItemString("fileQuit", "File");
scrMenuMgr->setMenuEnabled("FileImport", false);
scrMenuMgr->setMenuEnabled("FileExport", 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->createMenu("EditContents", tr("Contents"), "Edit");
scrMenuMgr->addMenuItemString("editCopyContents", "EditContents");
scrMenuMgr->addMenuItemString("editPasteContents", "EditContents");
scrMenuMgr->addMenuItemString("editPasteContentsAbs", "EditContents");
scrMenuMgr->addMenuItemString("editClearContents", "EditContents");
scrMenuMgr->addMenuItemString("editTruncateContents", "EditTruncateContents");
scrMenuMgr->addMenuItemString("itemDelete", "Edit");
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("editColors", "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"), "",false, true);
scrMenuMgr->addMenuItemString("ItemLayer", "Item");
scrMenuMgr->createMenu("SendTo", tr("Send to"), "Item");
scrMenuMgr->addMenuItemString("SendTo", "Item");
scrMenuMgr->createMenu("ItemSendToScrapbook", tr("Scrapbook"),"",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("&PDF 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("toolsUnlinkTextFrameWithTextCopy", "TextLinking");
scrMenuMgr->addMenuItemString("toolsUnlinkTextFrameWithTextCut", "TextLinking");
scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
scrMenuMgr->addMenuItemString("ItemPathOps", "Item");
scrMenuMgr->addMenuItemString("itemCombinePolygons", "ItemPathOps");
scrMenuMgr->addMenuItemString("itemSplitPolygons", "ItemPathOps");
scrMenuMgr->addMenuItemString("itemAttachTextToPath", "ItemPathOps");
scrMenuMgr->addMenuItemString("itemDetachTextFromPath", "ItemPathOps");
scrActions["itemPrintingEnabled"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrMenuMgr->createMenu("Weld", tr("Welding"), "Item");
scrMenuMgr->addMenuItemString("Weld", "Item");
scrMenuMgr->addMenuItemString("itemWeld", "Weld");
scrMenuMgr->addMenuItemString("itemsUnWeld", "Weld");
scrMenuMgr->addMenuItemString("itemEditWeld", "Weld");
scrMenuMgr->addMenuItemString("editMark", "Item");
//Insert menu
scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
scrMenuMgr->addMenuItemString("insertFrame", "Insert");
scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertTextFrame", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertImageFrame", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertRenderFrame", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertTable", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertShape", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertPolygon", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertArc", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertSpiral", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertLine", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertBezier", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertFreehandLine", "Insert");
scrMenuMgr->addMenuItemString("toolsInsertCalligraphicLine", "Insert");
scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
scrMenuMgr->addMenuItemString("stickyTools", "Insert");
scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
scrMenuMgr->addMenuItemString("insertGlyph", "Insert");
scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
scrMenuMgr->addMenuItemString("InsertChar", "Insert");
scrMenuMgr->addMenuItemString("unicodePageNumber", "InsertChar");
scrMenuMgr->addMenuItemString("unicodePageCount", "InsertChar");
scrMenuMgr->addMenuItemString("unicodeSoftHyphen", "InsertChar");
scrMenuMgr->addMenuItemString("unicodeNonBreakingHyphen", "InsertChar");
scrMenuMgr->addMenuItemString("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("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("unicodeNewLine", "InsertSpace");
scrMenuMgr->addMenuItemString("unicodeFrameBreak", "InsertSpace");
scrMenuMgr->addMenuItemString("unicodeColumnBreak", "InsertSpace");
scrMenuMgr->addMenuItemString("unicodeZerowidthSpace", "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("insertMark2Mark", "InsertMark");
scrMenuMgr->addMenuItemString("insertMarkItem", "InsertMark");
scrMenuMgr->addMenuItemString("insertMarkVariableText", "InsertMark");
scrMenuMgr->addMenuItemString("insertMarkNote", "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::null, true);
//Help menu
scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
scrMenuMgr->addMenuItemString("helpManual", "Help");
scrMenuMgr->addMenuItemString("helpChat", "Help");
scrMenuMgr->addMenuItemString("SEPARATOR", "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("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->setMargin(0);
zoomLayout->setSpacing(1);
zoomSpinBox = new ScrSpinBox( 1, 32000, zoomWidget, 6 );
zoomSpinBox->setTabAdvance(false);
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( "", statusBar());
mainWindowXPosDataLabel->setFont(fo);
mainWindowYPosDataLabel = new QLabel( "", statusBar());
mainWindowYPosDataLabel->setFont(fo);
mainWindowXPosDataLabel->setMinimumWidth(mainWindowXPosDataLabel->fontMetrics().width("99999.999"));
mainWindowYPosDataLabel->setMinimumWidth(mainWindowYPosDataLabel->fontMetrics().width("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("");
QLabel *s2=new QLabel("");
QLabel *s3=new QLabel("");
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 (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 uint 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).arg(widthTxt).arg(heightTxt));
}
else
{
setStatusBarInfoText( tr("%1 Objects selected, Selection Size = %2 x %3").arg(docSelectionCount).arg(widthTxt).arg(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(QString newText)
{
if (m_mainWindowStatusLabel)
m_mainWindowStatusLabel->setText(newText);
m_statusLabelText = newText;
}
//AV to be replaced with Selection::update and listener in PropertiesPalette
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());
propertiesPalette->textPal->showParStyle(currPStyle.parent());
propertiesPalette->textPal->showCharStyle(item->currentCharStyle().parent());
doc->currentStyle = item->currentStyle();
// #8112 : do not use operator= here as it does not update style features
doc->currentStyle.charStyle().setStyle(item->currentCharStyle());
emit TextStyle(doc->currentStyle);
// to go: (av)
propertiesPalette->textPal->updateStyle(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() != NULL))
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;
// const QString& actionName="";
if (doc->m_Selection->count() == 1)
{
PageItem* selItem = doc->m_Selection->itemAt(0);
if (((doc->appMode == modeEdit) || (doc->appMode == modeEditTable)) && (selItem->isTextFrame() || selItem->isTable()))
{
PageItem_TextFrame *currItem;
if (doc->appMode == modeEditTable)
currItem = selItem->asTable()->activeCell().textFrame();
else
currItem = selItem->asTextFrame();
if (currItem!=NULL)
{
if (unicodevalue!=-1)
{
UndoTransaction activeTransaction;
if (currItem->HasSel){
if (UndoManager::undoEnabled())
activeTransaction = m_undoManager->beginTransaction(Um::Selection, Um::IGroup, Um::ReplaceText, "", Um::IDelete);
currItem->deleteSelectedTextFromFrame();
}
if (UndoManager::undoEnabled())
{
SimpleState *ss = dynamic_cast<SimpleState*>(m_undoManager->getLastUndo());
if (ss && ss->get("ETEA") == "insert_frametext")
ss->set("TEXT_STR",ss->get("TEXT_STR") + QString(QChar(unicodevalue)));
else {
ss = new SimpleState(Um::InsertText,"",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());
UndoObject * undoTarget = currItem;
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)
{
#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());
if (ss && ss->get("ETEA") == "insert_frametext")
ss->set("TEXT_STR",ss->get("TEXT_STR") + QString(SpecialChars::SHYPHEN));
else {
ss = new SimpleState(Um::InsertText,"",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());
UndoObject * undoTarget = currItem;
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 )
{
bool retVal;
if (e->type() == QEvent::ToolTip)
return (!m_prefsManager->appPrefs.displayPrefs.showToolTips);
if ( e->type() == QEvent::KeyPress )
{
QKeyEvent *k = (QKeyEvent *)e;
int keyMod=0;
if (k->modifiers() & Qt::ShiftModifier)
keyMod |= Qt::SHIFT;
if (k->modifiers() & Qt::ControlModifier)
keyMod |= Qt::CTRL;
if (k->modifiers() & Qt::AltModifier)
keyMod |= Qt::ALT;
QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
if (QString(currKeySeq.toString()).isNull())
return false;
retVal=true;
//Palette actions
if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllPalettes"))
scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
else
if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllGuides"))
scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
else
retVal=false;
}
else
retVal=false;
//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)
{
QList<QMdiSubWindow *> windows;
QMdiSubWindow* w = NULL;
int kk = k->key();
if (HaveDoc)
{
if ((doc->appMode == modeMagnifier) && (kk == Qt::Key_Shift))
{
view->setCursor(IconManager::instance()->loadCursor("LupeZm.xpm"));
return;
}
}
if (m_keyrep)
return;
m_keyrep = true;
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;
//User presses escape and we have a doc open, and we have an item selected
if ((kk == Qt::Key_Escape) && (HaveDoc))
{
m_keyrep = false;
PageItem *currItem;
if (!doc->m_Selection->isEmpty())
{
currItem = doc->m_Selection->itemAt(0);
switch (doc->appMode)
{
case modeNormal:
case modeEditClip:
currItem->Sizing = false;
if (doc->SubMode != -1)
{
view->Deselect(false);
doc->Items->removeOne(currItem);
}
else
view->Deselect(false);
view->cancelGroupTransaction();
break;
case modeEdit:
view->cancelGroupTransaction();
break;
case modeCopyProperties:
case modeEditGradientVectors:
case modeEditMeshGradient:
case modeLinkFrames:
case modeUnlinkFrames:
case modeRotation:
view->Deselect(false);
case modeEditWeldPoint:
case modeEyeDropper:
case modeImportObject:
case modeImportImage:
case modePanning:
view->requestMode(modeNormal);
break;
case modeDrawBezierLine:
break;
default:
if (currItem->Sizing)
{
view->Deselect(false);
doc->Items->removeOne(currItem);
}
break;
}
}
doc->DragP = false;
doc->leaveDrag = false;
view->stopAllDrags();
doc->SubMode = -1;
doc->ElemToLink = NULL;
slotSelect();
if (doc->m_Selection->isEmpty())
HaveNewSel();
m_prefsManager->appPrefs.uiPrefs.stickyTools = false;
scrActions["stickyTools"]->setChecked(false);
return;
}
Qt::KeyboardModifiers buttonModifiers = k->modifiers();
/**If we have a doc and we are not changing the page or zoom level in the status bar */
if ((HaveDoc) && (!zoomSpinBox->hasFocus()) && (!pageSelector->hasFocus()))
{
//Show our context menu
if (actionManager->compareKeySeqToShortcut(kk, buttonModifiers, "viewShowContextMenu"))
{
ContextMenu* cmen=NULL;
if (doc->m_Selection->isEmpty())
{
//CB We should be able to get this calculated by the canvas.... it is already in m_canvas->globalToCanvas(m->globalPos());
QPoint p(QCursor::pos() - mapToGlobal(QPoint(0,0)));
FPoint fp(p.x() / view->scale() + doc->minCanvasCoordinate.x(),
p.y() / view->scale() + doc->minCanvasCoordinate.y());
cmen = new ContextMenu(this, doc, fp.x(), fp.y());
}
else
cmen = new ContextMenu(*(doc->m_Selection), this, doc);
if (cmen)
{
setUndoMode(true);
cmen->exec(QCursor::pos());
setUndoMode(false);
}
delete cmen;
}
/**
* With no item selected we can:
* - With space, get into panning mode (modePanning)
* - With PageUp, scroll up
* - With PageDown, scroll down
* - With Tab, change active document windowActivated
*/
if ((doc->appMode != modeEdit) && (doc->m_Selection->isEmpty()))
{
int pg;
int wheelVal = m_prefsManager->mouseWheelJump();
if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
wheelVal = qMax(qRound(wheelVal / 10.0), 1);
switch (kk)
{
case Qt::Key_Space:
m_keyrep = false;
if (doc->appMode == modePanning)
view->requestMode(modeNormal);
else
view->requestMode(modePanning);
return;
break;
case Qt::Key_PageUp:
if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
view->scrollBy(0, -m_prefsManager->mouseWheelJump());
else
{
pg = doc->currentPageNumber();
if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
pg--;
else
pg -= doc->pageSets()[doc->pagePositioning()].Columns;
if (pg > -1)
view->GotoPage(pg);
}
m_keyrep = false;
return;
break;
case Qt::Key_PageDown:
if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
view->scrollBy(0, m_prefsManager->mouseWheelJump());
else
{
pg = doc->currentPageNumber();
if ((buttonModifiers & Qt::ShiftModifier) && !(buttonModifiers & Qt::ControlModifier) && !(buttonModifiers & Qt::AltModifier))
pg++;
else
pg += doc->pageSets()[doc->pagePositioning()].Columns;
if (pg < static_cast<int>(doc->Pages->count()))
view->GotoPage(pg);
}
m_keyrep = false;
return;
break;
case Qt::Key_Left:
view->scrollBy(-wheelVal, 0);
m_keyrep = false;
return;
break;
case Qt::Key_Right:
view->scrollBy(wheelVal, 0);
m_keyrep = false;
return;
break;
case Qt::Key_Up:
view->scrollBy(0, -wheelVal);
m_keyrep = false;
return;
break;
case Qt::Key_Down:
view->scrollBy(0, wheelVal);
m_keyrep = false;
return;
break;
case Qt::Key_Tab:
if (buttonModifiers == Qt::ControlModifier)
{
m_keyrep = false;
windows = mdiArea->subWindowList();
if (windows.count() > 1)
{
for (int i = 0; i < static_cast<int>(windows.count()); ++i)
{
if (mdiArea->activeSubWindow() == windows.at(i))
{
if (i == static_cast<int>(windows.count()-1))
w = windows.at(0);
else
w = windows.at(i+1);
break;
}
}
outlinePalette->buildReopenVals();
docCheckerPalette->clearErrorList();
if ( w )
w->showNormal();
newActWin(w);
}
return;
}
break;
}
}
}
switch(kk)
{
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
m__arrowKeyDown = true;
}
m_keyrep = false;
}
void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
{
//Exit out of panning mode if Control is release while the right mouse button is pressed
if (HaveDoc)
{
if ((doc->appMode == modePanning) && (k->key() == Qt::Key_Control) && (QApplication::mouseButtons() & Qt::RightButton))
view->requestMode(modeNormal);
}
if (HaveDoc)
{
if (doc->appMode == modeMagnifier)
view->setCursor(IconManager::instance()->loadCursor("LupeZ.xpm"));
}
if (k->isAutoRepeat() || !m__arrowKeyDown)
return;
switch(k->key())
{
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
m__arrowKeyDown = false;
if ((HaveDoc) && (!zoomSpinBox->hasFocus()) && (!pageSelector->hasFocus()))
{
int docSelectionCount=doc->m_Selection->count();
if ((docSelectionCount != 0) && (doc->appMode == modeEditClip) && (doc->nodeEdit.hasNodeSelected()))
{
PageItem *currItem = doc->m_Selection->itemAt(0);
double xposOrig = currItem->xPos();
double yposOrig = currItem->yPos();
doc->adjustItemSize(currItem);
if (!doc->nodeEdit.isContourLine())
currItem->ContourLine.translate(xposOrig - currItem->xPos(),yposOrig - currItem->yPos());
currItem->update();
}
for (int i = 0; i < docSelectionCount; ++i)
doc->m_Selection->itemAt(i)->checkChanges(true);
if (docSelectionCount > 1 && view->groupTransactionStarted())
view->endGroupTransaction();
}
break;
}
}
void ScribusMainWindow::changeEvent(QEvent *e)
{
if (e->type() == QEvent::LanguageChange)
languageChange();
else
QWidget::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"));
NewDoc *newDocWin = findChild<NewDoc *>(QString::fromLocal8Bit("NewDocumentWindow"));
if (prefsDialog!=NULL || newDocWin!=NULL)
{
ce->ignore();
return;
}
QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
ScribusWin* tw;
disconnect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(newActWin(QMdiSubWindow *)));
if (!windows.isEmpty())
{
uint windowCount=windows.count();
for ( uint i = 0; i < windowCount; ++i )
{
tw = (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);
propertiesPalette->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();
UrlLauncher::deleteInstance();
// qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
ce->accept();
}
void ScribusMainWindow::requestUpdate(int val)
{
emit UpdateRequest(val);
}
/////////////////////////////////////////////////////////////////////
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
bool ScribusMainWindow::arrowKeyDown()
{
return m__arrowKeyDown;
}
void ScribusMainWindow::startUpDialog()
{
bool docSet = false;
PrefsContext* docContext = m_prefsManager->prefsFile->getContext("docdirs", false);
NewDoc* dia = new NewDoc(this, RecentDocs, true, ScCore->getGuiLanguage());
if (dia->exec())
{
if (dia->tabSelected() == NewDoc::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->DocName);
}
else if (dia->tabSelected() == NewDoc::NewFromTemplateTab)
{
QString fileName = QDir::cleanPath(dia->selectedFile());
if (!fileName.isEmpty() && loadDoc(fileName))
{
doc->hasName = false;
UndoManager::instance()->renameStack(dia->nftGui->currentDocumentTemplate->name);
doc->DocName = dia->nftGui->currentDocumentTemplate->name;
updateActiveWindowCaption(QObject::tr("Document Template: ") + dia->nftGui->currentDocumentTemplate->name);
QDir::setCurrent(PrefsManager::instance()->documentDir());
removeRecent(fileName);
}
}
else if (dia->tabSelected() == NewDoc::OpenExistingTab)
{
QString fileName = dia->selectedFile();
if (!fileName.isEmpty())
{
QFileInfo fi(fileName);
docContext->set("docsopen", fi.absolutePath());
loadDoc(fileName);
}
}
else // NewDoc::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;
NewDoc* dia = new NewDoc(this, RecentDocs);
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->DocName);
}
}
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::getApplicationDataDir())+"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 = 0;
if (requiresGUI)
qwsp = mdiArea;
ScribusWin* w = new ScribusWin(qwsp, tempDoc);
w->setMainWindow(this);
if (requiresGUI && view!=NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, qreal)), alignDistributePalette, SLOT(setGuide(int, qreal)));
}
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));
connect(tempView, SIGNAL(signalGuideInformation(int, qreal)), alignDistributePalette, SLOT(setGuide(int, qreal)));
}
//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 = NULL;
newActWin(w->getSubWin());
}
if (requiresGUI)
{
connect(w, SIGNAL(autoSaved()), this, SLOT(slotAutoSaved()));
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->DocName);
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->DocName = 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 (QMap<QString, QPointer<ScrAction> >::iterator 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, QPixmap(), QPixmap(), 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->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
PageItem* item = allItems.at(ii);
#ifdef HAVE_OSG
if ((item->itemType() == PageItem::ImageFrame) && (!((item->asLatexFrame()) || (item->asOSGFrame()))))
#else
if ((item->itemType() == PageItem::ImageFrame) && (!(item->asLatexFrame())))
#endif
{
enablePicManager = true;
break;
}
}
allItems.clear();
}
}
scrActions["extrasManageImages"]->setEnabled(enablePicManager);
}
void ScribusMainWindow::newActWin(QMdiSubWindow *w)
{
if (w == NULL)
{
if (mdiArea->subWindowList().count() == 0)
ActWin = NULL;
return;
}
if (w->widget() == NULL)
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() == NULL)
return;
if (doc != NULL)
{
if (doc->appMode == modeEditClip)
view->requestMode(submodeEndNodeEdit);
if ((HaveDoc) && (doc != ActWin->doc()))
outlinePalette->buildReopenVals();
}
docCheckerPalette->clearErrorList();
if (HaveDoc && (doc != NULL) && 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();
zoomSpinBox->disconnect();
zoomDefaultToolbarButton->disconnect();
zoomOutToolbarButton->disconnect();
zoomInToolbarButton->disconnect();
layerMenu->disconnect();
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->DocName);
if ((doc != NULL) && 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)));
connect(zoomSpinBox, SIGNAL(valueChanged(double)), doc->view(), SLOT(setZoom()));
connect(zoomDefaultToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoom100()));
connect(zoomOutToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomOut()));
connect(zoomInToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomIn()));
connect(layerMenu, SIGNAL(activated(int)), doc->view(), SLOT(GotoLa(int)));
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(GotoPage(int)), this, SLOT(setCurrentPage(int)));
pageSelector->setEnabled(true);
}
if (view!=NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, qreal)), alignDistributePalette, SLOT(setGuide(int, qreal)));
if (ScCore->usingGUI())
disconnect(doc->m_Selection, SIGNAL(selectionIsMultiple(bool)), 0, 0);
}
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);
connect(view, SIGNAL(signalGuideInformation(int, qreal)), alignDistributePalette, SLOT(setGuide(int, qreal)));
if (ScCore->usingGUI())
connect(doc->m_Selection, SIGNAL(selectionIsMultiple(bool)), actionManager, SLOT( handleMultipleSelections(bool)));
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->DocName);
propertiesPalette->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();
setLayerMenuText(doc->activeLayerName());
//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 superflous 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();
}
}
void ScribusMainWindow::HaveNewDoc()
{
appModeHelper->mainWindowHasNewDoc(doc, (ScMimeData::clipboardHasScribusData()) || (scrapbookPalette->tempHasContents()));
//Update palettes
updateActiveWindowCaption(doc->DocName);
propertiesPalette->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();
setLayerMenuText(doc->activeLayerName());
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(changeUN(int)), this, SLOT(slotChangeUnit(int)), Qt::UniqueConnection);
connect(view, SIGNAL(changeLA(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(PStatus(int, uint)), nodePalette, SLOT(PolyStatus(int, uint)), 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(PaintingDone()), this, SLOT(slotSelect()), 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&)), propertiesPalette->textPal, SLOT(updateCharStyle(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(HasTextSel()), this, SLOT(EnableTxEdit()), Qt::UniqueConnection);
connect(view, SIGNAL(HasNoTextSel()), this, SLOT(DisableTxEdit()), Qt::UniqueConnection);
connect(view, SIGNAL(CopyItem()), this, SLOT(slotEditCopy()), Qt::UniqueConnection);
connect(view, SIGNAL(CutItem()), this, SLOT(slotEditCut()), Qt::UniqueConnection);
connect(view, SIGNAL(LoadPic()), this, SLOT(slotGetContent()), Qt::UniqueConnection);
connect(view, SIGNAL(StatusPic()), this, SLOT(StatusPic()), Qt::UniqueConnection);
connect(view, SIGNAL(AppendText()), this, SLOT(slotFileAppend()), Qt::UniqueConnection);
connect(view, SIGNAL(AnnotProps()), this, SLOT(ModifyAnnot()), 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);
connect(view, SIGNAL(DoGroup()), this, SLOT(GroupObj()), Qt::UniqueConnection);
connect(view, SIGNAL(callGimp()), this, SLOT(callImageEditor()), Qt::UniqueConnection);
}
void ScribusMainWindow::HaveNewSel()
{
if (doc == NULL)
return;
int SelectedType = -1;
PageItem *currItem = NULL;
const uint docSelectionCount = doc->m_Selection->count();
if (docSelectionCount > 0)
{
currItem = doc->m_Selection->itemAt(0);
SelectedType = currItem->itemType();
}
assert (docSelectionCount == 0 || currItem != NULL); // help coverity analysis
setStatusBarTextSelectedItemInfo();
actionManager->disconnectNewSelectionActions();
charPalette->setEnabled(false, 0);
view->horizRuler->textMode(false);
view->horizRuler->update();
if (!doc->inAnEditMode())
appModeHelper->enableActionsForSelection(this, doc);
switch (SelectedType)
{
case -1: // None
outlinePalette->slotShowSelect(doc->currentPageNumber(), NULL);
propertiesPalette->setGradientEditMode(false);
break;
case PageItem::TextFrame: //Text Frame
if (doc->appMode == modeEdit)
{
setTBvals(currItem);
charPalette->setEnabled(true, currItem);
if (currItem->asTextFrame())
{
appModeHelper->enableTextActions(true, currItem->currentStyle().charStyle().font().scName());
currItem->asTextFrame()->toggleEditModeActions();
}
view->horizRuler->setItem(currItem);
view->horizRuler->update();
}
else
{
doc->currentStyle = currItem->itemText.defaultStyle();
propertiesPalette->textPal->showParStyle(doc->currentStyle.parent());
propertiesPalette->textPal->showCharStyle(doc->currentStyle.charStyle().parent());
emit TextStyle(doc->currentStyle);
// to go: (av)
propertiesPalette->textPal->updateStyle(doc->currentStyle);
setStyleEffects(doc->currentStyle.charStyle().effects());
}
break;
case PageItem::Table:
if (doc->appMode == modeEditTable)
{
charPalette->setEnabled(true, currItem);
PageItem *i2 = currItem->asTable()->activeCell().textFrame();
appModeHelper->enableTextActions(true, i2->currentCharStyle().font().scName());
}
break;
case PageItem::PathText: //Path Text
if (doc->appMode == modeEdit)
setTBvals(currItem);
else
{
doc->currentStyle = currItem->itemText.defaultStyle();
propertiesPalette->textPal->showParStyle(doc->currentStyle.parent());
propertiesPalette->textPal->showCharStyle(doc->currentStyle.charStyle().parent());
emit TextStyle(doc->currentStyle);
// to go: (av)
propertiesPalette->textPal->updateStyle(doc->currentStyle);
setStyleEffects(doc->currentStyle.charStyle().effects());
}
break;
}
doc->CurrentSel = SelectedType;
propertiesPalette->xyzPal->basePointWidget->setCheckedId(doc->RotMode());
if (docSelectionCount != 0)
{
actionManager->setPDFActions(view);
updateItemLayerList();
rebuildScrapbookMenu();
propertiesPalette->setTextFlowMode(currItem->textFlowMode());
}
if (SelectedType != -1)
{
outlinePalette->slotShowSelect(currItem->OwnPage, currItem);
actionManager->connectNewSelectionActions(view, doc);
}
PluginManager& pluginManager(PluginManager::instance());
QStringList pluginNames(pluginManager.pluginNames(false));
ScPlugin* plugin;
ScActionPlugin* ixplug;
ScrAction* pluginAction = 0;
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
if (plugin->inherits("ScActionPlugin"))
{
ixplug = dynamic_cast<ScActionPlugin*>(plugin);
Q_ASSERT(ixplug);
ScActionPlugin::ActionInfo ai(ixplug->actionInfo());
pluginAction = ScCore->primaryMainWindow()->scrActions[ai.name];
if (pluginAction != 0)
pluginAction->setEnabled(ixplug->handleSelection(doc, SelectedType));
}
}
}
void ScribusMainWindow::slotDocCh(bool /*reb*/)
{
if (!doc->isModified())
doc->setModified(true);
updateActiveWindowCaption(doc->DocName + "*");
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(QString fn)
{
if (RecentDocs.indexOf(fn) != -1)
RecentDocs.removeAll(fn);
RecentDocs.prepend(fn);
rebuildRecentFileMenu();
}
void ScribusMainWindow::removeRecent(QString fn, bool fromFileWatcher)
{
if (RecentDocs.indexOf(fn) != -1)
{
RecentDocs.removeAll(fn);
//#9845: if (!fromFileWatcher)
//#9845: ScCore->fileWatcher->removeFile(fn);
}
rebuildRecentFileMenu();
}
void ScribusMainWindow::removeRecentFromWatcher(QString filename)
{
removeRecent(filename, true);
}
void ScribusMainWindow::loadRecent(QString filename)
{
QFileInfo fd(filename);
if (!fd.exists())
removeRecent(filename);
else
loadDoc(filename);
}
void ScribusMainWindow::rebuildRecentFileMenu()
{
scrMenuMgr->clearMenuStrings("FileOpenRecent");
scrRecentFileActions.clear();
uint max = qMin(m_prefsManager->appPrefs.uiPrefs.recentDocCount, RecentDocs.count());
QString strippedName, localName;
for (uint m = 0; m < max; ++m)
{
strippedName = localName = QDir::toNativeSeparators(RecentDocs[m]);
strippedName.remove(QDir::separator());
strippedName.prepend(QString("%1").arg(m+1, 2, 10, QChar('0')));
scrRecentFileActions.insert(strippedName, new ScrAction(ScrAction::RecentFile, QPixmap(), QPixmap(), QString("%1 &%2").arg(m+1).arg(localName.replace("&","&&")), QKeySequence(), this, RecentDocs[m]));
connect( scrRecentFileActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(loadRecent(QString)) );
scrMenuMgr->addMenuItemString(strippedName, "FileOpenRecent");
}
scrMenuMgr->addMenuItemStringstoRememberedMenu("FileOpenRecent", scrRecentFileActions);
fileToolBar->rebuildRecentFileMenu();
}
void ScribusMainWindow::rebuildRecentPasteMenu()
{
scrMenuMgr->clearMenuStrings("EditPasteRecent");
scrRecentPasteActions.clear();
int max = qMin(m_prefsManager->appPrefs.scrapbookPrefs.numScrapbookCopies, scrapbookPalette->tempBView->objectMap.count());
if (max > 0)
{
QMap<QString,BibView::Elem>::Iterator it;
it = scrapbookPalette->tempBView->objectMap.end();
it--;
QString strippedName;
for (int m = 0; m < max; ++m)
{
strippedName = it.key();
QPixmap pm = it.value().Preview;
scrRecentPasteActions.insert(strippedName, new ScrAction(ScrAction::RecentPaste, pm, QPixmap(), QString("&%1 %2").arg(m+1).arg(strippedName), QKeySequence(), this, it.key()));
connect( scrRecentPasteActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(pasteRecent(QString)) );
scrMenuMgr->addMenuItemString(strippedName, "EditPasteRecent");
it--;
}
scrMenuMgr->addMenuItemStringstoRememberedMenu("EditPasteRecent", scrRecentPasteActions);
}
}
void ScribusMainWindow::rebuildScrapbookMenu()
{
scrMenuMgr->clearMenuStrings("ItemSendToScrapbook");
scrScrapActions.clear();
if (!HaveDoc)
return;
QStringList scrapNames = scrapbookPalette->getOpenScrapbooksNames();
scrapNames.removeAt(1);
for (int i = 0; i < scrapNames.count(); ++i)
{
ScrAction *act = new ScrAction( ScrAction::DataInt, QPixmap(), QPixmap(), 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(QString fn)
{
if (!HaveDoc)
return;
view->dragX = 0;
view->dragY = 0;
doPasteRecent(scrapbookPalette->activeBView->objectMap[fn].Data);
}
void ScribusMainWindow::pasteRecent(QString fn)
{
doPasteRecent(scrapbookPalette->tempBView->objectMap[fn].Data);
}
void ScribusMainWindow::doPasteRecent(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->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,"",Um::ICreate);
view->Deselect(true);
uint ac = 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) && (view->dragY == 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 as = ac; as < doc->Items->count(); ++as)
{
PageItem* currItem = doc->Items->at(as);
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 != 0)
{
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)");
qSort(formats);
allFormats += formats.join(";;");
PrefsContext* dirs = PrefsManager::instance()->prefsFile->getContext("dirs");
QString wdir = dirs->get("pastefile", ".");
CustomFDialog dia(this, wdir, tr("Open"), allFormats, fdExistingFiles);
QString fileName("");
if (dia.exec() == QDialog::Accepted)
{
fileName = dia.selectedFile();
if (fileName.isEmpty())
return;
}
else
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.xpm");
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, QPixmap(), QPixmap(), (*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( QMap<QString, QPointer<ScrAction> >::Iterator 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( QMap<QString, QPointer<ScrAction> >::Iterator it = scrLayersActions.begin(); it!=itend; ++it )
{
disconnect( (*it), SIGNAL(triggeredData(int)), 0, 0 );
(*it)->setChecked(false);
}
if (!doc->m_Selection->isEmpty() && doc->m_Selection->itemAt(0))
scrLayersActions[QString("%1").arg(doc->m_Selection->itemAt(0)->LayerID)]->setChecked(true);
for( QMap<QString, QPointer<ScrAction> >::Iterator 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));
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());
bool ret = false;
MergeDoc *dia = new MergeDoc(this, false, doc->DocPages.count(), doc->currentPage()->pageNr() + 1);
UndoTransaction activeTransaction;
if(UndoManager::undoEnabled())
activeTransaction = m_undoManager->beginTransaction(Um::ImportPage, Um::IGroup, Um::ImportPage, 0, Um::ILock);
if (dia->exec())
{
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();
delete dia;
return ret;
}
bool ScribusMainWindow::loadPage(QString fileName, int Nr, bool Mpa, const QString& renamedPageName)
{
bool ret = false;
if (!fileName.isEmpty())
{
FileLoader *fl = new FileLoader(fileName);
if (fl->testFile() == -1)
{
delete fl;
return false;
}
doc->setLoading(true);
uint 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);
}
uint docItemsCount=doc->Items->count();
for (uint i = oldItemsCount; i < docItemsCount; ++i)
{
PageItem *ite = doc->Items->at(i);
if ((ite->asTextFrame()) && (ite->isBookmark))
AddBookMark(ite);
}
propertiesPalette->updateColorList();
emit UpdateRequest(reqArrowStylesUpdate | reqLineStylesUpdate | reqStyleComboDocUpdate | reqInlinePalUpdate);
symbolPalette->updateSymbolList();
slotDocCh();
rebuildLayersList();
updateLayerMenu();
layerPalette->rebuildList();
doc->setLoading(false);
ret = true;
}
if (!Mpa)
pagePalette->Rebuild();
view->reformPages();
view->DrawNew();
return ret;
}
bool ScribusMainWindow::loadDoc(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 = NULL;
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 FName = fi.absoluteFilePath();
QString platfName(QDir::toNativeSeparators(FName));
uint windowCount = windows.count();
for ( uint 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 in use."
"You'll be switched into its window now."));
windowsMenuActivated(i);
return true;
}
}
UndoBlocker undoBlocker;
if (!fileName.isEmpty())
{
FileLoader *fileLoader = new FileLoader(FName);
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(FName)+"</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()+"/", FName);
QDir docFontDir(fi.absolutePath() + "/fonts");
if (docFontDir.exists())
m_prefsManager->appPrefs.fontPrefs.AvailFonts.AddScalableFonts(fi.absolutePath()+"/fonts", FName);
QDir docFontDir2(fi.absolutePath() + "/Fonts");
if (docFontDir2.exists())
m_prefsManager->appPrefs.fontPrefs.AvailFonts.AddScalableFonts(fi.absolutePath()+"/Fonts", FName);
QDir docFontDir3(fi.absolutePath() + "/Document fonts");
if (docFontDir3.exists())
m_prefsManager->appPrefs.fontPrefs.AvailFonts.AddScalableFonts(fi.absolutePath()+"/Document fonts", FName);
m_prefsManager->appPrefs.fontPrefs.AvailFonts.updateFontMap();
if (view != NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, qreal)), alignDistributePalette, SLOT(setGuide(int, qreal)));
}
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 theres a replacement required.
if (loadSuccess && ScCore->usingGUI())
loadSuccess = fileLoader->postLoad(doc);
if (!loadSuccess)
{
view->close();
delete fileLoader;
delete doc;
doc=NULL;
mdiArea->removeSubWindow(w->getSubWin());
delete w;
view=NULL;
doc=NULL;
setScriptRunning(false);
qApp->restoreOverrideCursor();
m_mainWindowStatusLabel->setText("");
mainWindowProgressBar->reset();
ActWin = NULL;
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->Deselect(true);
m_mainWindowStatusLabel->setText("");
mainWindowProgressBar->reset();
HaveDoc++;
if (doc->checkerProfiles().count() == 0)
{
m_prefsManager->initDefaultCheckerPrefs(&(doc->checkerProfiles()));
doc->setCurCheckProfile(CommonStrings::PostScript);
}
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