Rev 18490 |
Rev 18533 |
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 <QQuickView>
#include <QRegExp>
#include <QStyleFactory>
#include <QTableWidget>
#include <QTextCodec>
#include <QToolButton>
#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 "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 "langmgr.h"
#include "marks.h"
#include "notesstyles.h"
#include "pageitem_group.h"
#include "pageitem_imageframe.h"
#include "pageitem_latexframe.h"
#include "pageitem_table.h"
#include "pageitem_textframe.h"
#include "pageitem_noteframe.h"
#include "pagesize.h"
#include "pdflib.h"
#include "pdfoptions.h"
#include "pluginmanager.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 "scmimedata.h"
#include "scpage.h"
#include "scpaths.h"
#include "scprintengine_ps.h"
#include "scraction.h"
#include "scribus.h"
#include "scribusdoc.h"
#include "scribusXml.h"
#include "scribusapp.h"
#include "scribuscore.h"
#include "scribusview.h"
#include "scribuswin.h"
#include "selection.h"
#include "serializer.h"
#include "ui/about.h"
#include "ui/aboutplugins.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/cpalette.h"
#include "ui/customfdialog.h"
#include "ui/delpages.h"
#include "ui/effectsdialog.h"
#include "ui/fontcombo.h"
#include "ui/guidemanager.h"
#include "ui/helpbrowser.h"
#include "ui/hruler.h"
#include "ui/imageinfodialog.h"
#include "ui/inlinepalette.h"
#include "ui/insertaframe.h"
#include "ui/inspage.h"
#include "ui/javadocs.h"
#include "ui/layers.h"
#include "ui/loremipsum.h"
#include "ui/marginwidget.h"
#include "ui/margindialog.h"
#include "ui/mark2item.h"
#include "ui/mark2mark.h"
#include "ui/markanchor.h"
#include "ui/marknote.h"
#include "ui/markvariabletext.h"
#include "ui/markinsert.h"
#include "ui/marksmanager.h"
#include "ui/masterpagepalette.h"
#include "ui/mergedoc.h"
#include "ui/movepage.h"
#include "ui/multipleduplicate.h"
#include "ui/newfile.h"
#include "ui/newtemp.h"
#include "nfttemplate.h"
#include "ui/nftdialog.h"
#include "ui_nftdialog.h"
#include "ui/nftwidget.h"
#include "ui/nodeeditpalette.h"
#include "ui/notesstyleseditor.h"
#ifdef HAVE_OSG
#include "ui/osgeditor.h"
#include <osgDB/ReaderWriter>
#include <osgDB/PluginQuery>
#endif
#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/pdfopts.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/sccombobox.h"
#include "ui/scfilewidget.h"
#include "ui/scmessagebox.h"
#include "ui/scrapbookpalette.h"
#include "ui/scmwmenumanager.h"
#include "ui/selectobjects.h"
#include "ui/search.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 "tocgenerator.h"
#include "ui/transformdialog.h"
#include "ui/transparencypalette.h"
#include "ui/copypagetomasterpagedialog.h"
#include "ui/edittoolbar.h"
#include "ui/filetoolbar.h"
#include "ui/modetoolbar.h"
#include "ui/pdftoolbar.h"
#include "undogui.h"
#include "undomanager.h"
#include "undostate.h"
#include "units.h"
#include "urllauncher.h"
#include "util.h"
#include "util_formats.h"
#include "util_ghostscript.h"
#include "util_icon.h"
#include "util_math.h"
#include "ui/vruler.h"
#include "loadsaveplugin.h"
#include "plugins/formatidlist.h"
#include "scimagecachemanager.h"
#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;
scrMenuMgr=0;
prefsManager=0;
formatsManager=0;
UrlLauncher::instance();
mainWindowStatusLabel=0;
ExternalApp=0;
#ifdef Q_OS_MAC
noIcon = loadIcon("noicon.xpm");
#endif
}
/*
static QCoreApplication::EventFilter origEventFilter = 0;
bool reportFocusChanges(void *message, long *result)
{
unsigned* data = static_cast<unsigned*>(message);
if (QApplication::focusWidget())
qDebug() << QApplication::applicationFilePath() << reinterpret_cast<void*>(QApplication::focusWidget()) << typeid(*QApplication::focusWidget()).name() << QApplication::focusWidget()->objectName() << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
else
qDebug() << QApplication::applicationFilePath() << "no focus" << message << data[0] << data[1] << data[2] << data[3] << data[4] << data[5] << data[6] << data[7];
return origEventFilter && origEventFilter(message, result);
}
*/
/*
* 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));
}
// origEventFilter = qApp->setEventFilter(reportFocusChanges);
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(loadIcon("AppIcon.png"));
setObjectName("MainWindow");
scrActionGroups.clear();
scrActions.clear();
scrRecentFileActions.clear();
scrRecentPasteActions.clear();
scrWindowsActions.clear();
scrLayersActions.clear();
scrScrapActions.clear();
scrMenuMgr = new ScMWMenuManager(menuBar());
prefsManager = PrefsManager::instance();
formatsManager = FormatsManager::instance();
objectSpecificUndo = false;
undoManager = UndoManager::instance();
PrefsContext *undoPrefs = prefsManager->prefsFile->getContext("undo");
undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
tocGenerator = new TOCGenerator();
m_marksCount = 0;
initDefaultValues();
initStatusBar();
qApp->processEvents();
actionManager = new ActionManager(this);
actionManager->init(this);
// if (primaryMainWindow)
// ScCore->setSplashStatus( tr("Applying User Shortcuts") );
// prefsManager->applyLoadedShortCuts();
// initKeyboardShortcuts();
initMenuBar();
initToolBars();
ScCore->pluginManager->setupPluginActions(this);
ScCore->pluginManager->enableOnlyStartupPluginActions(this);
ScCore->pluginManager->languageChange();
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Applying User Shortcuts") );
prefsManager->applyLoadedShortCuts();
initKeyboardShortcuts();
resize(610, 600);
mdiArea = new QMdiArea(this);
mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
if (prefsManager->appPrefs.uiPrefs.useTabs)
mdiArea->setViewMode(QMdiArea::TabbedView);
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();
prefsManager->setupMainWindow(this);
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Initializing Story Editor") );
storyEditor = new StoryEditor(this);
DocDir = prefsManager->documentDir();
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Initializing Languages") );
LanguageManager::instance();
QString preLang(prefsManager->appPrefs.hyphPrefs.Language);
initHyphenator();
if (!LanguageManager::instance()->getHyphFilename( preLang ).isEmpty() )
prefsManager->appPrefs.hyphPrefs.Language = preLang;
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Reading Scrapbook") );
initScrapbook();
scrActions["helpTooltips"]->setChecked(prefsManager->appPrefs.displayPrefs.showToolTips);
scrActions["showMouseCoordinates"]->setChecked(prefsManager->appPrefs.displayPrefs.showMouseCoordinates);
scrActions["stickyTools"]->setChecked(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(this, SIGNAL(TextStyle(const ParagraphStyle&)), propertiesPalette, SLOT(updateStyle(const ParagraphStyle&)));
// connect(this, SIGNAL(TextEffects(int)), propertiesPalette, SLOT(setStil(int)));
connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
// connect(ClipB, SIGNAL(selectionChanged()), 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, prefsManager->appPrefs.colorPrefs.DColors, prefsManager->appPrefs.defaultGradients, prefsManager->appPrefs.defaultPatterns, false);
else
{
if (prefsManager->appPrefs.colorPrefs.DColorSet != "Scribus Small")
{
QStringList CustomColorSets = csm.userPaletteNames();
if (CustomColorSets.contains(prefsManager->appPrefs.colorPrefs.DColorSet))
Cpfad = csm.userPaletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
else
Cpfad = csm.paletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
csm.loadPalette(Cpfad, m_doc, prefsManager->appPrefs.colorPrefs.DColors, prefsManager->appPrefs.defaultGradients, prefsManager->appPrefs.defaultPatterns, false);
}
}
return retVal;
}
ScribusMainWindow::~ScribusMainWindow()
{
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");
undoManager->registerGui(uWidget);
modeToolBar = new ModeToolBar(this);
pdfToolBar = new PDFToolBar(this);
addScToolBar(fileToolBar, fileToolBar->objectName());
addScToolBar(editToolBar, editToolBar->objectName());
addScToolBar(modeToolBar, modeToolBar->objectName());
addScToolBar(pdfToolBar, pdfToolBar->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)) );
}
void ScribusMainWindow::initDefaultValues()
{
HaveDoc = false;
ScriptRunning = 0;
view = NULL;
doc = NULL;
DocNr = 1;
PrinterUsed = false;
PDef.Pname = "";
PDef.Dname = "";
PDef.Command = "";
keyrep = false;
_arrowKeyDown = false;
ClipB = QApplication::clipboard();
palettesStatus[0] = false;
guidesStatus[0] = 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(";;") + ";;";
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();
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)));
//CB dont need this until we have a doc...
//propertiesPalette->Cpal->setColors(prefsManager->colorSet());
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)));
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);
// measurementPalette = new Measurements(this);
// connect( scrActions["toolsMeasurements"], SIGNAL(toggled(bool)) , measurementPalette, SLOT(setPaletteShown(bool)) );
connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool, int)) , this, SLOT(setAppModeByToggle(bool, int)) );
// connect( measurementPalette, SIGNAL(paletteShown(bool)), scrActions["toolsMeasurements"], SLOT(setChecked(bool)));
// measurementPalette->installEventFilter(this);
// measurementPalette->hide();
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);
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
styleManager = new StyleManager(this, "styleManager");
styleManager->addStyle(new SMLineStyle());
SMCharacterStyle *tmpCS = new SMCharacterStyle();
styleManager->addStyle(new SMParagraphStyle(tmpCS->tmpStyles()));
styleManager->addStyle(tmpCS);
styleManager->addStyle(new SMTableStyle());
styleManager->addStyle(new SMCellStyle());
connect( scrActions["editStyles"], SIGNAL(toggled(bool)), styleManager, SLOT(setPaletteShown(bool)) );
connect( styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
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(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, int)));
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(manageMasterPages(QString)));
// connect(outlinePalette, SIGNAL(selectElement(int, int, bool)), this, SLOT(selectItemsFromOutlines(int, int, bool)));
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(manageMasterPages(QString)));
// connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
// connect(nodePalette, SIGNAL(paletteClosed()), propertiesPalette, SLOT(endEdit2()));
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(prefsManager->preferencesLocation()+"/scrap13.scs");
QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
if (scrapbookFileInfoO.exists())
{
scrapbookPalette->readOldContents(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main"));
QDir d = QDir();
d.rename(scrapbookFileO, QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrap13.backup"));
}
QString scrapbookTemp = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/tmp");
QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
if (scrapbookTempInfo.exists())
scrapbookPalette->readTempContents(scrapbookTemp);
QString scrapbookFile = QDir::toNativeSeparators(prefsManager->preferencesLocation()+"/scrapbook/main");
QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
if (scrapbookFileInfo.exists())
scrapbookPalette->readContents(scrapbookFile);
scrapbookPalette->setScrapbookFileName(scrapbookFile);
ScCore->fileWatcher->addDir(scrapbookFile, true);
scrapbookPalette->setOpenScrapbooks(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 = QMessageBox::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);
if (t == QMessageBox::Ok)
retval = true;
return retval;
}
void ScribusMainWindow::initMenuBar()
{
RecentDocs.clear();
scrMenuMgr->createMenu("File", ActionManager::defaultMenuNameEntryTranslated("File"));
scrMenuMgr->addMenuItem(scrActions["fileNew"], "File", true);
scrMenuMgr->addMenuItem(scrActions["fileNewFromTemplate"], "File", true);
scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File", true);
scrMenuMgr->createMenu("FileOpenRecent", tr("Open &Recent"), "File");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["fileClose"], "File", false);
scrMenuMgr->addMenuItem(scrActions["fileSave"], "File", false);
scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File", false);
scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File", false);
scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File", false);
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport", false);
// scrMenuMgr->addMenuItem(scrActions["fileImportText2"], "FileImport", false);
scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport", false);
scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport", false);
scrMenuMgr->addMenuItem(scrActions["fileImportVector"], "FileImport", true);
scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport", false);
scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport", false);
scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport", false);
scrMenuMgr->addMenuSeparator("File");
// scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File", false);
scrMenuMgr->addMenuItem(scrActions["fileDocSetup150"], "File", false);
// scrMenuMgr->addMenuItem(scrActions["filePreferences"], "File", true);
scrMenuMgr->addMenuItem(scrActions["filePreferences150"], "File", true);
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["filePrint"], "File", false);
scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File", false);
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File", true);
scrMenuMgr->setMenuEnabled("FileImport", false);
scrMenuMgr->setMenuEnabled("FileExport", false);
scrMenuMgr->createMenu("Edit", ActionManager::defaultMenuNameEntryTranslated("Edit"));
scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit", true);
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit", false);
scrMenuMgr->createMenu("EditPasteRecent", tr("Paste Recent"), "Edit");
scrMenuMgr->createMenu("EditContents", tr("Contents"), "Edit");
scrMenuMgr->addMenuItem(scrActions["editCopyContents"], "EditContents", false);
scrMenuMgr->addMenuItem(scrActions["editPasteContents"], "EditContents", false);
scrMenuMgr->addMenuItem(scrActions["editPasteContentsAbs"], "EditContents", false);
scrMenuMgr->addMenuItem(scrActions["editClearContents"], "EditContents", false);
scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Edit", false);
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editSelectAllOnLayer"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit", false);
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit" , false);
scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editEditRenderSource"], "Edit", false);
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit", true);
scrMenuMgr->addMenuItem(scrActions["editReplaceColors"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editStyles"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editMarks"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editNotesStyles"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit", false);
scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit", false);
scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
scrMenuMgr->setMenuEnabled("EditContents", false);
//Item Menu
scrMenuMgr->createMenu("Item", ActionManager::defaultMenuNameEntryTranslated("Item"));
scrMenuMgr->createMenu("DuplicateTransform", tr("Duplicate/Transform"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "DuplicateTransform", false);
scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "DuplicateTransform", false);
scrMenuMgr->addMenuItem(scrActions["itemTransform"], "DuplicateTransform", false);
scrMenuMgr->createMenu("Grouping", tr("Grouping"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Grouping", false);
scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Grouping", false);
scrMenuMgr->addMenuItem(scrActions["itemGroupAdjust"], "Grouping", false);
scrMenuMgr->createMenu("Locking", tr("Locking"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemLock"], "Locking", false);
scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Locking", false);
scrMenuMgr->createMenu("ItemLevel", tr("Level"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel", false);
scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel", false);
scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel", false);
scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel", false);
scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
scrMenuMgr->createMenu("SendTo", tr("Send to"), "Item");
scrMenuMgr->createMenu("itemSendToScrapbook", tr("Scrapbook"));
scrMenuMgr->addMenuToMenu("itemSendToScrapbook", "SendTo");
scrMenuMgr->addMenuItem(scrActions["itemSendToPattern"], "SendTo", false);
scrMenuMgr->addMenuItem(scrActions["itemSendToInline"], "SendTo", false);
scrMenuMgr->createMenu("Adjust", tr("Adjust"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameHeightToText"], "Adjust", false);
scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Adjust", false);
scrMenuMgr->addMenuItem(scrActions["itemAdjustImageToFrame"], "Adjust", false);
scrMenuMgr->createMenu("Image", tr("Image"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Image", false);
scrMenuMgr->addMenuItem(scrActions["styleImageEffects"], "Image", false);
scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Image", false);
scrMenuMgr->addMenuItem(scrActions["itemToggleInlineImage"], "Image", false);
scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Image");
scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "ItemPreviewSettings", false);
scrMenuMgr->addMenuSeparator("ItemPreviewSettings");
scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings", false);
scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings", false);
scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings", false);
scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item", false);
scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions", false);
scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions", false);
scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions", false);
scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions", false);
scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo", false);
scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo", false);
scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo", false);
scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo", false);
scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo", false);
scrMenuMgr->addMenuItem(scrActions["itemConvertToSymbolFrame"], "ItemConvertTo", false);
scrMenuMgr->createMenu("TextLinking", tr("Text Frame Links"), "Item");
scrMenuMgr->addMenuItem(scrActions["toolsLinkTextFrame"], "TextLinking", false);
scrMenuMgr->addMenuItem(scrActions["toolsUnlinkTextFrame"], "TextLinking", false);
scrMenuMgr->addMenuItem(scrActions["toolsUnlinkTextFrameWithTextCopy"], "TextLinking", false);
scrMenuMgr->addMenuItem(scrActions["toolsUnlinkTextFrameWithTextCut"], "TextLinking", false);
scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "ItemPathOps", false);
scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "ItemPathOps", false);
scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "ItemPathOps", false);
scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "ItemPathOps", false);
scrActions["itemPrintingEnabled"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrMenuMgr->createMenu("Weld", tr("Welding"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemsUnWeld"], "Weld", false);
scrMenuMgr->addMenuItem(scrActions["itemWeld"], "Weld", false);
scrMenuMgr->addMenuItem(scrActions["itemEditWeld"], "Weld", false);
scrMenuMgr->addMenuItem(scrActions["editMark"], "Item", false);
//Insert menu
scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
scrMenuMgr->addMenuItem(scrActions["insertFrame"], "Insert", false);
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertRenderFrame"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertTable"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertArc"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertSpiral"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert", false);
scrMenuMgr->addMenuItem(scrActions["toolsInsertCalligraphicLine"], "Insert", false);
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["stickyTools"], "Insert", true);
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert", false);
scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodePageCount"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSoftHyphen"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar", false);
scrMenuMgr->addMenuSeparator("InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar", false);
scrMenuMgr->addMenuSeparator("InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar", false);
scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar", false);
scrMenuMgr->createMenu("InsertQuote", tr("&Quote"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote", false);
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote", false);
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote", false);
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote", false);
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote", false);
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote", false);
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote", false);
scrMenuMgr->createMenu("InsertSpace", tr("S&paces && Breaks"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace", false);
scrMenuMgr->addMenuSeparator("InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace", false);
scrMenuMgr->addMenuItem(scrActions["unicodeZerowidthSpace"], "InsertSpace", false);
scrMenuMgr->createMenu("InsertLigature", tr("Liga&ture"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature", false);
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature", false);
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert", false);
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->createMenu("InsertMark", tr("Marks"), "Insert");
scrMenuMgr->addMenuItem(scrActions["insertMarkAnchor"], "InsertMark", false);
scrMenuMgr->addMenuItem(scrActions["insertMarkVariableText"], "InsertMark", false);
scrMenuMgr->addMenuItem(scrActions["insertMarkItem"], "InsertMark", false);
scrMenuMgr->addMenuItem(scrActions["insertMark2Mark"], "InsertMark", false);
scrMenuMgr->addMenuItem(scrActions["insertMarkNote"], "InsertMark", false);
// scrMenuMgr->addMenuItem(scrActions["insertMarkIndex"], "InsertMark", false);
//Page menu
scrMenuMgr->createMenu("Page", ActionManager::defaultMenuNameEntryTranslated("Page"));
scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page", false);
scrMenuMgr->addMenuSeparator("Page");
scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page", false);
scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page", false);
scrMenuMgr->addMenuSeparator("Page");
scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page", true);
scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page", true);
scrMenuMgr->addMenuItem(scrActions["viewSnapToElements"], "Page", true);
//View menu
scrMenuMgr->createMenu("View", ActionManager::defaultMenuNameEntryTranslated("View"));
scrMenuMgr->createMenu("ViewZoom", tr("Zoom"), "View");
scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFitWidth"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFit50"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFit75"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFit100"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFit200"], "ViewZoom", false);
scrMenuMgr->addMenuItem(scrActions["viewFit400"], "ViewZoom", false);
scrMenuMgr->createMenu("ViewPreview", tr("Preview"), "View");
scrMenuMgr->addMenuItem(scrActions["viewPreviewMode"], "ViewPreview", true);
scrMenuMgr->createMenu("ViewMeasuring", tr("Measures"), "View");
scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "ViewMeasuring", false);
scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "ViewMeasuring", true);
scrMenuMgr->addMenuItem(scrActions["showMouseCoordinates"], "ViewMeasuring", true);
scrMenuMgr->createMenu("ViewTextFrames", tr("Text Frames"), "View");
scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "ViewTextFrames", true);
scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "ViewTextFrames", true);
scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "ViewTextFrames", true);
scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "ViewTextFrames", true);
scrMenuMgr->createMenu("ViewImageFrames", tr("Image Frames"), "View");
scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "ViewImageFrames", true);
scrMenuMgr->createMenu("ViewDocument", tr("Document"), "View");
scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "ViewDocument", true);
scrMenuMgr->addMenuItem(scrActions["viewShowBleeds"], "ViewDocument", true);
scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "ViewDocument", true);
scrMenuMgr->addMenuItem(scrActions["viewShowLayerMarkers"], "ViewDocument", true);
scrMenuMgr->createMenu("ViewGrids", tr("Grids and Guides"), "View");
scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "ViewGrids", true);
scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "ViewGrids", true);
//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->addMenuItem(scrActions["tableInsertRows"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableInsertColumns"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableDeleteRows"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableDeleteColumns"], "ItemTable", false);
scrMenuMgr->addMenuSeparator("ItemTable");
scrMenuMgr->addMenuItem(scrActions["tableMergeCells"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableSplitCells"], "ItemTable", false);
scrMenuMgr->addMenuSeparator("ItemTable");
scrMenuMgr->addMenuItem(scrActions["tableSetRowHeights"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableSetColumnWidths"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableDistributeRowsEvenly"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableDistributeColumnsEvenly"], "ItemTable", false);
scrMenuMgr->addMenuSeparator("ItemTable");
scrMenuMgr->addMenuItem(scrActions["tableAdjustFrameToTable"], "ItemTable", false);
scrMenuMgr->addMenuItem(scrActions["tableAdjustTableToFrame"], "ItemTable", false);
//Extra menu
scrMenuMgr->createMenu("Extras", ActionManager::defaultMenuNameEntryTranslated("Extras"));
scrMenuMgr->addMenuItem(scrActions["extrasManageImages"], "Extras", false);
scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras", false);
scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras", false);
scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras", false);
scrMenuMgr->addMenuItem(scrActions["extrasUpdateDocument"], "Extras", false);
scrMenuMgr->addMenuItem(scrActions["itemUpdateMarks"], "Extras", true);
scrMenuMgr->addMenuItem(scrActions["extrasTestQTQuick2_1"], "Extras", true);
connect(scrMenuMgr->getLocalPopupMenu("Extras"), SIGNAL(aboutToShow()), this, SLOT(extrasMenuAboutToShow()));
//Window menu
scrMenuMgr->createMenu("Windows", ActionManager::defaultMenuNameEntryTranslated("Windows"), QString::null, true);
connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
addDefaultWindowMenuItems();
//Help menu
scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help", true);
//scrMenuMgr->addMenuItem(scrActions["helpManual2"], "Help", true);
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help", true);
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpOnlineWWW"], "Help", true);
scrMenuMgr->addMenuItem(scrActions["helpOnlineDocs"], "Help", true);
scrMenuMgr->addMenuItem(scrActions["helpOnlineWiki"], "Help", true);
scrMenuMgr->createMenu("HelpOnlineTutorials", tr("Online &Tutorials"), "Help");
scrMenuMgr->addMenuItem(scrActions["helpOnlineTutorial1"], "HelpOnlineTutorials", true);
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpCheckUpdates"], "Help", true);
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help", true);
scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help", true);
scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help", true);
scrMenuMgr->addMenuToMenuBar("File");
scrMenuMgr->addMenuToMenuBar("Edit");
scrMenuMgr->addMenuToMenuBar("Item");
scrMenuMgr->addMenuToMenuBar("Insert");
scrMenuMgr->addMenuToMenuBar("Page");
scrMenuMgr->addMenuToMenuBar("ItemTable");
scrMenuMgr->addMenuToMenuBar("Extras");
scrMenuMgr->addMenuToMenuBar("View");
scrMenuMgr->addMenuToMenuBar("Windows");
menuBar()->addSeparator();
scrMenuMgr->addMenuToMenuBar("Help");
}
void ScribusMainWindow::addDefaultWindowMenuItems()
{
scrMenuMgr->clearMenu("Windows");
scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows", true);
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows", true);
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows", true);
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsSymbols"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsInline"], "Windows", true);
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows", true);
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows", true);
scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows", true);
}
void ScribusMainWindow::initStatusBar()
{
mainWindowStatusLabel = new QLabel( " ", statusBar());
mainWindowProgressBar = new QProgressBar(statusBar());
mainWindowProgressBar->setAlignment(Qt::AlignHCenter);
mainWindowProgressBar->setFixedWidth( 100 );
mainWindowProgressBar->reset();
mainWindowXPosLabel = new QLabel( tr("X-Pos:"), statusBar());
mainWindowYPosLabel = new QLabel( tr("Y-Pos:"), statusBar());
mainWindowXPosDataLabel = new QLabel( " ", statusBar());
mainWindowYPosDataLabel = new QLabel( " ", statusBar());
statusBar()->addPermanentWidget(mainWindowStatusLabel, 6);
statusBar()->addPermanentWidget(mainWindowProgressBar, 0);
statusBar()->addPermanentWidget(mainWindowXPosLabel, 0);
statusBar()->addPermanentWidget(mainWindowXPosDataLabel, 1);
statusBar()->addPermanentWidget(mainWindowYPosLabel, 0);
statusBar()->addPermanentWidget(mainWindowYPosDataLabel, 1);
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, true));
mainWindowYPosDataLabel->setText(value2String(yn, doc->unitIndex(), true, true));
}
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::setTempStatusBarText(const QString &text)
{
if (mainWindowStatusLabel)
{
if (text.isEmpty())
mainWindowStatusLabel->setText(statusLabelText);
else
mainWindowStatusLabel->setText(text);
}
}
void ScribusMainWindow::setStatusBarInfoText(QString newText)
{
if (mainWindowStatusLabel)
mainWindowStatusLabel->setText(newText);
statusLabelText = newText;
}
//AV to be replaced with Selection::update and listener in PropertiesPalette
void ScribusMainWindow::setTBvals(PageItem *currItem)
{
scrActions["editMark"]->setEnabled(false);
if (currItem->itemText.length() != 0)
{
// int ChPos = qMin(currItem->CPos, static_cast<int>(currItem->itemText.length()-1));
const ParagraphStyle& currPStyle( (doc->appMode == modeEdit) ? currItem->currentStyle() : currItem->itemText.defaultStyle());
setAlignmentValue(currPStyle.alignment());
propertiesPalette->textPal->displayParStyle(currPStyle.parent());
propertiesPalette->textPal->displayCharStyle(currItem->currentCharStyle().parent());
doc->currentStyle = currItem->currentStyle();
// #8112 : do not use operator= here as it does not update style features
doc->currentStyle.charStyle().setStyle( currItem->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 && currItem->itemText.cursorPosition() < currItem->itemText.length())
{
if (currItem->itemText.hasMark(currItem->itemText.cursorPosition()))
{
Mark* mark = currItem->itemText.mark(currItem->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(const QString& actionName, int unicodevalue)
{
if (HaveDoc)
{
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 = NULL;
if (currItem->HasSel){
if (UndoManager::undoEnabled())
activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::Selection, Um::IGroup, Um::ReplaceText, "", Um::IDelete));
currItem->deleteSelectedTextFromFrame();
}
if (UndoManager::undoEnabled())
{
SimpleState *ss = dynamic_cast<SimpleState*>(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", "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());
}
undoManager->action(undoTarget, ss);
}
}
currItem->itemText.insertChars(QString(QChar(unicodevalue)), true);
if (activeTransaction)
{
activeTransaction->commit();
delete activeTransaction;
activeTransaction = NULL;
}
}
else if (actionName=="unicodeSoftHyphen") //ignore the char as we use an attribute if the text item, for now.
{
// this code is currently dead since unicodeSoftHyphen
// doesnt 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*>(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", "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());
}
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 (!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 (currKeySeq == scrActions["specialToggleAllPalettes"]->shortcut())
scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
else
if (currKeySeq == scrActions["specialToggleAllGuides"]->shortcut())
scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
else
// CB These were moved to ActionManager via the setShortcutContext(Qt::ApplicationShortcut) calls, leaving for notes for now
// if (currKeySeq == scrActions["toolsProperties"]->accel())
// scrActions["toolsProperties"]->toggle();
// else
// if (currKeySeq == scrActions["toolsOutline"]->accel())
// scrActions["toolsOutline"]->toggle();
// else
// if (currKeySeq == scrActions["toolsScrapbook"]->accel())
// scrActions["toolsScrapbook"]->toggle();
// else
// if (currKeySeq == scrActions["toolsLayers"]->accel())
// scrActions["toolsLayers"]->toggle();
// else
// if (currKeySeq == scrActions["toolsPages"]->accel())
// scrActions["toolsPages"]->toggle();
// else
// if (currKeySeq == scrActions["toolsBookmarks"]->accel())
// scrActions["toolsBookmarks"]->toggle();
// else
// if (currKeySeq == scrActions["toolsActionHistory"]->accel())
// scrActions["toolsActionHistory"]->toggle();
// else
// if (currKeySeq == scrActions["toolsPreflightVerifier"]->accel())
// scrActions["toolsPreflightVerifier"]->toggle();
// else
// if (currKeySeq == scrActions["toolsAlignDistribute"]->accel())
// scrActions["toolsAlignDistribute"]->toggle();
// else
//Edit actions
/* if (currKeySeq == scrActions["editStyles"]->shortcut())
scrActions["editStyles"]->toggle();
else
if (currKeySeq == scrActions["editUndoAction"]->shortcut() && scrActions["editUndoAction"]->isEnabled())
scrActions["editUndoAction"]->activate(QAction::Trigger);
else
if (currKeySeq == scrActions["editRedoAction"]->shortcut() && scrActions["editRedoAction"]->isEnabled())
scrActions["editRedoAction"]->activate(QAction::Trigger);
else
//Other actions
if (currKeySeq == scrActions["fileQuit"]->shortcut())
scrActions["fileQuit"]->activate(QAction::Trigger);
else
//Zoom actions
if (currKeySeq == scrActions["toolsZoomIn"]->shortcut())
scrActions["toolsZoomIn"]->activate(QAction::Trigger);
else
if (currKeySeq == scrActions["toolsZoomOut"]->shortcut())
scrActions["toolsZoomOut"]->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(QCursor(loadIcon("LupeZm.xpm")));
return;
}
}
if (keyrep)
return;
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))
{
keyrep = false;
PageItem *currItem;
if (doc->m_Selection->count() != 0)
{
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:
currItem->PoLine.resize(qMax(0, static_cast<int>(currItem->PoLine.size())-2));
if (currItem->PoLine.size() < 4)
{
view->Deselect(false);
doc->Items->removeOne(currItem);
}
else
{
doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem, false, false);
currItem->setPolyClip(qRound(qMax(currItem->lineWidth() / 2.0, 1.0)));
doc->AdjustItemSize(currItem);
currItem->ContourLine = currItem->PoLine.copy();
currItem->ClipEdited = true;
currItem->FrameType = 3;
slotDocCh();
}
view->FirstPoly = true;
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->count() == 0)
HaveNewSel(-1);
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) && (!view->zoomSpinBox->hasFocus()) && (!view->pageSelector->hasFocus()))
{
//Show our context menu
QKeySequence currKeySeq = QKeySequence(kk | keyMod);
if (currKeySeq.matches(scrActions["viewShowContextMenu"]->shortcut()) == QKeySequence::ExactMatch)
{
ContextMenu* cmen=NULL;
if (doc->m_Selection->count() == 0)
{
//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->count() == 0))
{
int pg;
int wheelVal = 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:
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, -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);
}
keyrep = false;
return;
break;
case Qt::Key_PageDown:
if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
view->scrollBy(0, 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);
}
keyrep = false;
return;
break;
case Qt::Key_Left:
view->scrollBy(-wheelVal, 0);
keyrep = false;
return;
break;
case Qt::Key_Right:
view->scrollBy(wheelVal, 0);
keyrep = false;
return;
break;
case Qt::Key_Up:
view->scrollBy(0, -wheelVal);
keyrep = false;
return;
break;
case Qt::Key_Down:
view->scrollBy(0, wheelVal);
keyrep = false;
return;
break;
case Qt::Key_Tab:
if (buttonModifiers == Qt::ControlModifier)
{
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;
}
}
/** Now if we have an item selected
* - In normal mode we can:
* -- Use backspace or delete to delete the item
* -- In edit mode of an image frame, use the arrow keys to resize the image:
(flows to pageitem_imageframe for control)
Alt right arrow, move right side of image outwards (expand)
Alt left arrow, move right side inwards (shrink)
Alt down arrow, move bottom side downwards (expand)
Alt up arrow, move top side inwards (shrink)
*/
if (doc->m_Selection->count() != 0)
{
PageItem *currItem = doc->m_Selection->itemAt(0);
if (doc->appMode == modeEdit)
{
if (currItem->asImageFrame() && !currItem->locked())
{
currItem->handleModeEditKey(k, keyrep);
}
//FIXME:av view->oldCp = currItem->CPos;
if (currItem->isTextFrame())
{
bool kr=keyrep;
view->canvasMode()->keyPressEvent(k); //Hack for 1.4.x for stopping the cursor blinking while moving about
currItem->handleModeEditKey(k, keyrep);
if (currItem->isAutoNoteFrame() && currItem->asNoteFrame()->notesList().isEmpty())
{
if (!currItem->asNoteFrame()->isEndNotesFrame())
{
currItem->asNoteFrame()->masterFrame()->invalidateLayout(false);
currItem->asNoteFrame()->masterFrame()->updateLayout();
}
}
keyrep=kr;
}
if (!currItem->isTextFrame() || (currItem->isAutoNoteFrame() && currItem->asNoteFrame()->notesList().isEmpty()))
slotDocCh(false);
doc->regionsChanged()->update(QRectF());
}
}
}
switch(kk)
{
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
_arrowKeyDown = true;
}
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(QCursor(loadIcon("LupeZ.xpm")));
}
if (k->isAutoRepeat() || !_arrowKeyDown)
return;
switch(k->key())
{
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
_arrowKeyDown = false;
if ((HaveDoc) && (!view->zoomSpinBox->hasFocus()) && (!view->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
// Preferences *prefsWin = findChild<Preferences *>(QString::fromLocal8Bit("PreferencesWindow"));
PreferencesDialog *prefsDialog = findChild<PreferencesDialog *>(QString::fromLocal8Bit("PreferencesDialog"));
NewDoc *newDocWin = findChild<NewDoc *>(QString::fromLocal8Bit("NewDocumentWindow"));
// if (prefsWin!=NULL || prefsDialog!=NULL || newDocWin!=NULL)
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();
ActWin->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();
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 (!prefsManager->appPrefs.scrapbookPrefs.persistentScrapbook)
scrapbookPalette->CleanUpTemp();
prefsManager->appPrefs.scrapbookPrefs.RecentScrapbooks.clear();
prefsManager->appPrefs.scrapbookPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
if (!emergencyActivated)
prefsManager->SavePrefs();
UndoManager::deleteInstance();
PrefsManager::deleteInstance();
FormatsManager::deleteInstance();
UrlLauncher::deleteInstance();
// qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
qApp->exit(0);
}
void ScribusMainWindow::requestUpdate(int val)
{
emit UpdateRequest(val);
}
/////////////////////////////////////////////////////////////////////
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
bool ScribusMainWindow::arrowKeyDown()
{
return _arrowKeyDown;
}
void ScribusMainWindow::startUpDialog()
{
bool docSet = false;
PrefsContext* docContext = 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);
}
}
prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
delete dia;
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());
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();
undoManager->setUndoEnabled(false);
MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
QString newDocName( tr("Document")+"-"+QString::number(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 (prefsManager->appPrefs.colorPrefs.DColorSet != "Scribus Small")
{
QStringList CustomColorSets = csm.userPaletteNames();
if (CustomColorSets.contains(prefsManager->appPrefs.colorPrefs.DColorSet))
Cpfad = csm.userPaletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
else
Cpfad = csm.paletteFileFromName(prefsManager->appPrefs.colorPrefs.DColorSet);
csm.loadPalette(Cpfad, doc, colorList, gradientsList, patternsList, false);
doc->PageColors = colorList;
doc->docGradients = gradientsList;
doc->docPatterns = patternsList;
}
else
doc->PageColors = prefsManager->appPrefs.colorPrefs.DColors;
}
tempDoc->PageColors.ensureDefaultColors();
tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
if (requiresGUI)
{
HaveDoc++;
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->docHyphenator->ignoredWords = prefsManager->appPrefs.hyphPrefs.ignoredWords;
tempDoc->docHyphenator->specialWords = prefsManager->appPrefs.hyphPrefs.specialWords;
}
tempDoc->setLoading(false);
//run after setGUI to set up guidepalette ok
tempView->setScale(prefsManager->displayScale());
if (requiresGUI)
{
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));
//#9250 : transfered to newActWin()
//connect(undoManager, SIGNAL(undoRedoBegin()), tempDoc, SLOT(undoRedoBegin()));
//connect(undoManager, SIGNAL(undoRedoDone()), tempDoc, SLOT(undoRedoDone()));
//connect(undoManager, SIGNAL(undoRedoDone()), tempView, SLOT(DrawNew()));
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["fileSave"]->setEnabled(false);
tempView->cmsToolbarButton->setChecked(tempDoc->HasCMS);
undoManager->switchStack(tempDoc->DocName);
styleManager->setDoc(tempDoc);
marksManager->setDoc(tempDoc);
nsEditor->setDoc(tempDoc);
tocGenerator->setDoc(tempDoc);
}
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(prefsManager->displayScale());
w->setView(view);
ActWin = w;
w->setCentralWidget(view);
actionManager->connectNewViewActions(view);
alignDistributePalette->setDoc(doc);
connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
view->show();
}
void ScribusMainWindow::windowsMenuAboutToShow()
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrWindowsActions.begin(); it!=scrWindowsActions.end(); ++it )
scrMenuMgr->removeMenuItem((*it), "Windows");
scrWindowsActions.clear();
addDefaultWindowMenuItems();
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());
if (windowCount>1)
scrMenuMgr->addMenuSeparator("Windows");
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)) );
if (windowCount>1)
scrMenuMgr->addMenuItem(scrWindowsActions[docInWindow], "Windows", true);
scrWindowsActions[docInWindow]->setChecked(mdiArea->activeSubWindow() == windows.at(i));
}
}
}
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(undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
disconnect(undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
disconnect(undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
}
doc = ActWin->doc();
undoManager->switchStack(doc->DocName);
if ((doc != NULL) && doc->hasGUI())
{
connect(undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
connect(undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
connect(undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
}
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);
//disconnect(doc->m_Selection, SIGNAL(empty()), 0, 0);
}
}
view = ActWin->view();
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)), propertiesPalette, SLOT( setMultipleSelection(bool)));
connect(doc->m_Selection, SIGNAL(selectionIsMultiple(bool)), actionManager, SLOT( handleMultipleSelections(bool)));
//connect(doc->m_Selection, SIGNAL(empty()), propertiesPalette, SLOT( unsetItem()));
}
pagePalette->setView(view);
alignDistributePalette->setDoc(doc);
if (!doc->isLoading())
{
SwitchWin();
view->requestMode(doc->appMode);
}
view->setFocus();
// mdiArea->setScrollBarsEnabled(!(w->isMaximized()));
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())
{
if (doc->m_Selection->count() != 0)
{
HaveNewSel(doc->m_Selection->itemAt(0)->itemType());
doc->m_Selection->itemAt(0)->emitAllToGUI();
}
else
HaveNewSel(-1);
}
docCheckerPalette->setDoc(doc);
tocGenerator->setDoc(doc);
styleManager->setDoc(doc);
marksManager->setDoc(doc);
nsEditor->setDoc(doc);
symbolPalette->setDoc(doc);
inlinePalette->setDoc(doc);
modeToolBar->Angle->setValue(doc->itemToolPrefs().calligrapicPenAngle);
modeToolBar->PWidth->setValue(doc->itemToolPrefs().calligrapicPenWidth);
// 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);
// scrActions["shade100"]->setChecked(true);
propertiesPalette->setDoc(doc);
marksManager->setDoc(doc);
nsEditor->setDoc(doc);
//propertiesPalette->Cpal->displayGradient(0);
pagePalette->setView(view);
layerPalette->setDoc(doc);
guidePalette->setDoc(doc);
charPalette->setDoc(doc);
outlinePalette->setDoc(doc);
symbolPalette->setDoc(doc);
inlinePalette->setDoc(doc);
rebuildLayersList();
view->updateLayerMenu();
view->setLayerMenuText(doc->activeLayerName());
//Do not set this!, it doesnt 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);
} */
scrActions["fileClose"]->setEnabled(true);
if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
{
scrActions["pageInsert"]->setEnabled(false);
scrActions["pageDelete"]->setEnabled(false);
scrActions["pageCopy"]->setEnabled(false);
scrActions["pageMove"]->setEnabled(false);
scrActions["pageApplyMasterPage"]->setEnabled(false);
scrActions["pageCopyToMasterPage"]->setEnabled(false);
scrActions["editMasterPages"]->setEnabled(false);
scrActions["fileNew"]->setEnabled(false);
scrActions["fileNewFromTemplate"]->setEnabled(false);
if (doc->symbolEditMode() || doc->inlineEditMode())
{
scrActions["fileCollect"]->setEnabled(false);
scrActions["fileSaveAs"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileExport", false);
scrActions["fileExportAsEPS"]->setEnabled(false);
scrActions["fileExportAsPDF"]->setEnabled(false);
scrActions["fileSave"]->setEnabled(false);
}
else
scrActions["fileSave"]->setEnabled(!doc->isConverted);
scrActions["fileOpen"]->setEnabled(false);
scrActions["fileRevert"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileOpenRecent", false);
pagePalette->enablePalette(false);
scrActions["toolsPDFPushButton"]->setEnabled(false);
scrActions["toolsPDFRadioButton"]->setEnabled(false);
scrActions["toolsPDFTextField"]->setEnabled(false);
scrActions["toolsPDFCheckBox"]->setEnabled(false);
scrActions["toolsPDFComboBox"]->setEnabled(false);
scrActions["toolsPDFListBox"]->setEnabled(false);
scrActions["toolsPDFAnnotText"]->setEnabled(false);
#ifdef HAVE_OSG
scrActions["toolsPDFAnnot3D"]->setEnabled(false);
#endif
}
else
{
scrActions["editMasterPages"]->setEnabled(true);
scrActions["fileNew"]->setEnabled(true);
scrActions["fileNewFromTemplate"]->setEnabled(true);
scrActions["fileOpen"]->setEnabled(true);
scrActions["fileClose"]->setEnabled(true);
scrActions["fileSave"]->setEnabled(!doc->isConverted);
scrActions["fileRevert"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileOpenRecent", true);
if (doc->isModified())
slotDocCh(false);
else
{
bool setter = doc->DocPages.count() > 1 ? true : false;
scrActions["pageDelete"]->setEnabled(setter);
scrActions["pageMove"]->setEnabled(setter);
}
// scrMenuMgr->setMenuEnabled("Page", true);
scrActions["pageInsert"]->setEnabled(true);
scrActions["pageImport"]->setEnabled(true);
scrActions["pageCopy"]->setEnabled(true);
scrActions["pageApplyMasterPage"]->setEnabled(true);
scrActions["pageCopyToMasterPage"]->setEnabled(true);
scrActions["pageManageGuides"]->setEnabled(true);
scrActions["pageManageMargins"]->setEnabled(true);
scrActions["fileSaveAs"]->setEnabled(true);
scrActions["fileCollect"]->setEnabled(true);
scrActions["toolsPDFPushButton"]->setEnabled(true);
scrActions["toolsPDFRadioButton"]->setEnabled(true);
scrActions["toolsPDFTextField"]->setEnabled(true);
scrActions["toolsPDFCheckBox"]->setEnabled(true);
scrActions["toolsPDFComboBox"]->setEnabled(true);
scrActions["toolsPDFListBox"]->setEnabled(true);
scrActions["toolsPDFAnnotText"]->setEnabled(true);
#ifdef HAVE_OSG
scrActions["toolsPDFAnnot3D"]->setEnabled(true);
#endif
pagePalette->enablePalette(true);
setPreviewToolbar();
}
scrMenuMgr->setMenuEnabled("ItemLayer", doc->layerCount() > 1);
}
void ScribusMainWindow::HaveNewDoc()
{
scrActions["filePrint"]->setEnabled(true);
scrActions["fileSave"]->setEnabled(!doc->isConverted);
scrActions["fileClose"]->setEnabled(true);
// scrActions["fileDocSetup"]->setEnabled(true);
scrActions["fileDocSetup150"]->setEnabled(true);
scrActions["fileRevert"]->setEnabled(false);
scrActions["fileCollect"]->setEnabled(true);
scrActions["fileSaveAs"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("FileImport", true);
scrMenuMgr->setMenuEnabled("FileExport", true);
scrActions["fileExportAsEPS"]->setEnabled(true);
scrActions["fileExportAsPDF"]->setEnabled(true);
scrActions["pageImport"]->setEnabled(true);
//scrActions["toolsPreflightVerifier"]->setEnabled(true);
if ( ScCore->haveGS() || ScCore->isWinGUI() )
scrActions["PrintPreview"]->setEnabled(true);
if (scrActions["SaveAsDocumentTemplate"])
scrActions["SaveAsDocumentTemplate"]->setEnabled(true);
scrActions["editCut"]->setEnabled(false);
scrActions["editCopy"]->setEnabled(false);
scrActions["editPaste"]->setEnabled((ScMimeData::clipboardHasScribusData()) || (scrapbookPalette->tempBView->objectMap.count() > 0));
scrMenuMgr->setMenuEnabled("EditPasteRecent", scrapbookPalette->tempBView->objectMap.count() > 0);
scrMenuMgr->setMenuEnabled("EditContents", false);
scrActions["editCopyContents"]->setEnabled(false);
scrActions["editPasteContents"]->setEnabled(false);
scrActions["editPasteContentsAbs"]->setEnabled(false);
scrActions["editSelectAll"]->setEnabled(true);
scrActions["editSelectAllOnLayer"]->setEnabled(true);
scrActions["editDeselectAll"]->setEnabled(false);
scrActions["editReplaceColors"]->setEnabled(true);
// scrActions["editPatterns"]->setEnabled(true);
// scrActions["editGradients"]->setEnabled(true);
scrActions["editStyles"]->setEnabled(true);
scrActions["editMarks"]->setEnabled(true);
scrActions["editNotesStyles"]->setEnabled(true);
scrActions["editMasterPages"]->setEnabled(true);
scrActions["editJavascripts"]->setEnabled(true);
// scrMenuMgr->setMenuEnabled("View", true);
scrActions["viewFitInWindow"]->setEnabled(true);
scrActions["viewFitWidth"]->setEnabled(true);
scrActions["viewFit50"]->setEnabled(true);
scrActions["viewFit75"]->setEnabled(true);
scrActions["viewFit100"]->setEnabled(true);
scrActions["viewFit200"]->setEnabled(true);
scrActions["viewFit400"]->setEnabled(true);
scrActions["viewSnapToGrid"]->setChecked(doc->SnapGrid);
scrActions["viewSnapToGuides"]->setChecked(doc->SnapGuides);
scrActions["viewSnapToElements"]->setChecked(doc->SnapElement);
scrActions["viewShowRulers"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("Insert", true);
scrActions["insertFrame"]->setEnabled(true);
//scrMenuMgr->setMenuEnabled("Windows", true);
// scrMenuMgr->setMenuEnabled("Page", true);
//scrMenuMgr->setMenuEnabled("Extras", true);
scrActions["toolsSelect"]->setEnabled(true);
scrActions["toolsZoom"]->setEnabled(true);
scrActions["toolsInsertTextFrame"]->setEnabled(true);
scrActions["toolsInsertImageFrame"]->setEnabled(true);
scrActions["toolsInsertTable"]->setEnabled(true);
scrActions["toolsInsertShape"]->setEnabled(true);
scrActions["toolsInsertLine"]->setEnabled(true);
scrActions["toolsInsertBezier"]->setEnabled(true);
scrActions["toolsInsertFreehandLine"]->setEnabled(true);
scrActions["toolsInsertCalligraphicLine"]->setEnabled(true);
scrActions["toolsInsertPolygon"]->setEnabled(true);
scrActions["toolsInsertArc"]->setEnabled(true);
scrActions["toolsInsertSpiral"]->setEnabled(true);
scrActions["toolsInsertRenderFrame"]->setEnabled(true);
scrActions["toolsMeasurements"]->setEnabled(true);
scrActions["toolsEyeDropper"]->setEnabled(true);
scrActions["toolsPDFPushButton"]->setEnabled(true);
scrActions["toolsPDFRadioButton"]->setEnabled(true);
scrActions["toolsPDFTextField"]->setEnabled(true);
scrActions["toolsPDFCheckBox"]->setEnabled(true);
scrActions["toolsPDFComboBox"]->setEnabled(true);
scrActions["toolsPDFListBox"]->setEnabled(true);
scrActions["toolsPDFAnnotText"]->setEnabled(true);
scrActions["toolsPDFAnnotLink"]->setEnabled(true);
#ifdef HAVE_OSG
scrActions["toolsPDFAnnot3D"]->setEnabled(true);
#endif
bool setter = doc->DocPages.count() > 1 ? true : false;
scrActions["pageDelete"]->setEnabled(setter);
scrActions["pageMove"]->setEnabled(setter);
scrActions["pageInsert"]->setEnabled(true);
scrActions["pageImport"]->setEnabled(true);
scrActions["pageCopy"]->setEnabled(true);
scrActions["pageApplyMasterPage"]->setEnabled(true);
scrActions["pageCopyToMasterPage"]->setEnabled(true);
scrActions["pageManageGuides"]->setEnabled(true);
scrActions["pageManageMargins"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("ItemLayer", doc->layerCount() > 1);
//Update palettes
updateActiveWindowCaption(doc->DocName);
// scrActions["shade100"]->setChecked(true);
propertiesPalette->setDoc(doc);
nsEditor->setDoc(doc);
marksManager->setDoc(doc);
symbolPalette->setDoc(doc);
inlinePalette->setDoc(doc);
// propertiesPalette->Cpal->displayGradient(0);
// propertiesPalette->updateColorList();
pagePalette->setView(view);
layerPalette->setDoc(doc);
guidePalette->setDoc(doc);
charPalette->setDoc(doc);
outlinePalette->setDoc(doc);
if (outlinePalette->isVisible())
outlinePalette->BuildTree();
rebuildLayersList();
view->updateLayerMenu();
view->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(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(int)), this, SLOT(HaveNewSel(int)), Qt::UniqueConnection);
// connect(view, SIGNAL(SetAngle(double)), propertiesPalette, SLOT(setR(double)), Qt::UniqueConnection);
// connect(view, SIGNAL(SetSizeValue(double)), propertiesPalette, SLOT(setLineWidth(double)), Qt::UniqueConnection);
// connect(view, SIGNAL(SetLocalValues(double, double, double, double)), propertiesPalette, SLOT(setScaleAndOffset(double, double, double, double)), Qt::UniqueConnection);
// connect(view, SIGNAL(SetLineArt(Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle)), propertiesPalette, SLOT( setLIvalue(Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle)), Qt::UniqueConnection);
// connect(view, SIGNAL(ItemTextAttr(double)), propertiesPalette, SLOT(setLsp(double)), Qt::UniqueConnection);
// connect(view, SIGNAL(ItemTextCols(int, double)), propertiesPalette, SLOT(setCols(int, double)), Qt::UniqueConnection);
// connect(view, SIGNAL(SetDistValues(double, double, double, double)), propertiesPalette, SLOT(setTextToFrameDistances(double, double, double, double)), Qt::UniqueConnection);
//connect(view, SIGNAL(ItemRadius(double)), propertiesPalette, SLOT(setRR(double)), Qt::UniqueConnection);
// connect(view, SIGNAL(Amode(int)), this, SLOT(setAppMode(int)), Qt::UniqueConnection);
connect(view, SIGNAL(PaintingDone()), this, SLOT(slotSelect()), Qt::UniqueConnection);
connect(view, SIGNAL(DocChanged()), this, SLOT(slotDocCh()), Qt::UniqueConnection);
//connect(view, SIGNAL(HavePoint(bool, bool)), nodePalette, SLOT(HaveNode(bool, bool)), Qt::UniqueConnection);
connect(view, SIGNAL(MousePos(double, double)), this, SLOT(setStatusBarMousePosition(double, double)), Qt::UniqueConnection);
//connect(view, SIGNAL(ItemRadius(double)), propertiesPalette, SLOT(setRR(double)), Qt::UniqueConnection);
connect(view, SIGNAL(ItemCharStyle(const CharStyle&)), propertiesPalette->textPal, SLOT(updateCharStyle(const CharStyle&)), Qt::UniqueConnection);
// connect(view, SIGNAL(ItemTextEffects(int)), propertiesPalette, SLOT(setStil(int)), 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(EndNodeEdit()), this, SLOT(ToggleFrameEdit()), Qt::UniqueConnection);
// connect(view, SIGNAL(LevelChanged(uint )), propertiesPalette, SLOT(setLevel(uint)), Qt::UniqueConnection);
connect(view, SIGNAL(callGimp()), this, SLOT(callImageEditor()), Qt::UniqueConnection);
}
void ScribusMainWindow::HaveNewSel(int SelectedType)
{
PageItem *currItem = NULL;
const uint docSelectionCount=doc->m_Selection->count();
if (SelectedType != -1)
{
if (docSelectionCount != 0)
currItem = doc->m_Selection->itemAt(0);
// {
// int lowestItem = 999999;
// for (int a = 0; a < doc->m_Selection->count(); ++a)
// {
// currItem = doc->m_Selection->itemAt(a);
// lowestItem = qMin(lowestItem, doc->Items->indexOf(currItem));
// }
// currItem = doc->Items->at(lowestItem);
// if ((docSelectionCount == 1) && currItem && currItem->asImageFrame())
// isRaster = currItem->isRaster;
// doc->m_Selection->removeItem(currItem);
// doc->m_Selection->prependItem(currItem);
// currItem = doc->m_Selection->itemAt(0);
// assert(currItem);
// if (!currItem)
// SelectedType=-1;
// }
else
SelectedType = -1;
}
else if (docSelectionCount > 0)
{
currItem = doc->m_Selection->itemAt(0);
}
assert (docSelectionCount == 0 || currItem != NULL); // help coverity analysis
if (docSelectionCount == 0)
setStatusBarInfoText("");
else if (docSelectionCount == 1)
{
QString whatSel = tr("Unknown");
switch (currItem->itemType())
{
case 2:
whatSel = tr("Image Frame");
break;
case 4:
whatSel = tr("Text Frame");
break;
case 5:
whatSel = tr("Line");
break;
case 6:
whatSel = tr("Polygon");
break;
case 7:
whatSel = tr("Polyline");
break;
case 8:
whatSel = tr("Text on Path");
break;
case 9:
whatSel = tr("Latex Frame");
break;
case 11:
whatSel = tr("Symbol");
break;
case 12:
whatSel = tr("Group");
break;
case 13:
whatSel = tr("RegularPolygon");
break;
case 14:
whatSel = tr("Arc");
break;
case 15:
whatSel = tr("Spiral");
break;
case 16:
whatSel = tr("Table");
break;
default:
whatSel = "Unknown";
break;
}
QString widthTxt = value2String(doc->m_Selection->width(), doc->unitIndex(), true, true);
QString heightTxt = value2String(doc->m_Selection->height(), doc->unitIndex(), true, true);
QString txtBody = tr("selected, Size");
setStatusBarInfoText( QString("%1 %2 = %3 x %4").arg(whatSel).arg(txtBody).arg(widthTxt).arg(heightTxt));
}
else
{
QString widthTxt = value2String(doc->m_Selection->width(), doc->unitIndex(), true, true);
QString heightTxt = value2String(doc->m_Selection->height(), doc->unitIndex(), true, true);
setStatusBarInfoText( tr("%1 Objects selected, Selection Size = %2 x %3").arg(docSelectionCount).arg(widthTxt).arg(heightTxt));
}
actionManager->disconnectNewSelectionActions();
scrActions["editSelectAllOnLayer"]->setEnabled(true);
scrActions["editDeselectAll"]->setEnabled(SelectedType != -1);
scrActions["itemDetachTextFromPath"]->setEnabled(false);
charPalette->setEnabled(false, 0);
scrActions["itemUpdateImage"]->setEnabled(SelectedType==PageItem::ImageFrame && (currItem->PictureIsAvailable || currItem->asLatexFrame()));
scrActions["itemAdjustFrameToImage"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable);
scrActions["itemAdjustImageToFrame"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable);
scrActions["itemExtendedImageProperties"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable && currItem->pixm.imgInfo.valid);
scrActions["itemToggleInlineImage"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable);
scrMenuMgr->setMenuEnabled("ItemPreviewSettings", SelectedType==PageItem::ImageFrame);
scrActions["itemImageIsVisible"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["itemPreviewLow"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["itemPreviewNormal"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["itemPreviewFull"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["styleImageEffects"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->isRaster);
scrActions["editCopyContents"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable);
scrActions["editPasteContents"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["editPasteContentsAbs"]->setEnabled(SelectedType==PageItem::ImageFrame);
scrActions["editEditWithImageEditor"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem->PictureIsAvailable && currItem->isRaster);
#ifdef HAVE_OSG
scrActions["editEditRenderSource"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem && (currItem->asLatexFrame() || currItem->asOSGFrame()));
#else
scrActions["editEditRenderSource"]->setEnabled(SelectedType==PageItem::ImageFrame && currItem && (currItem->asLatexFrame()));
#endif
scrActions["itemAdjustFrameHeightToText"]->setEnabled(SelectedType==PageItem::TextFrame && currItem->itemText.length() >0);
if (SelectedType!=PageItem::ImageFrame)
{
scrActions["itemImageIsVisible"]->setChecked(false);
scrActions["itemPreviewLow"]->setChecked(false);
scrActions["itemPreviewNormal"]->setChecked(false);
scrActions["itemPreviewFull"]->setChecked(false);
}
if ((SelectedType==-1) || (SelectedType!=-1 && !currItem->asTextFrame()))
enableTextActions(&scrActions, false);
scrActions["insertSampleText"]->setEnabled(false);
view->horizRuler->textMode(false);
view->horizRuler->update();
switch (SelectedType)
{
case -1: // None
scrActions["fileImportText"]->setEnabled(false);
scrActions["fileImportText2"]->setEnabled(false);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(false);
scrActions["fileExportText"]->setEnabled(false);
scrActions["itemDuplicate"]->setEnabled(false);
scrActions["itemMulDuplicate"]->setEnabled(false);
scrActions["itemTransform"]->setEnabled(false);
scrActions["itemDelete"]->setEnabled(false);
scrActions["itemRaise"]->setEnabled(false);
scrActions["itemLower"]->setEnabled(false);
scrActions["itemRaiseToTop"]->setEnabled(false);
scrActions["itemLowerToBottom"]->setEnabled(false);
// scrActions["itemSendToScrapbook"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("itemSendToScrapbook", false);
scrActions["itemSendToPattern"]->setEnabled(false);
scrActions["itemSendToInline"]->setEnabled(false);
scrActions["itemAdjustFrameToImage"]->setEnabled(false);
scrActions["itemAdjustImageToFrame"]->setEnabled(false);
scrActions["itemExtendedImageProperties"]->setEnabled(false);
scrActions["itemUpdateImage"]->setEnabled(false);
scrActions["itemPreviewLow"]->setEnabled(false);
scrActions["itemPreviewNormal"]->setEnabled(false);
scrActions["itemPreviewFull"]->setEnabled(false);
scrActions["itemAttributes"]->setEnabled(false);
scrActions["itemPreviewLow"]->setEnabled(false);
// scrMenuMgr->setMenuEnabled("Item", false);
//scrMenuMgr->setMenuEnabled("ItemShapes", false);
// scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrMenuMgr->setMenuEnabled("EditContents", false);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(false);
scrActions["itemLock"]->setEnabled(false);
scrActions["itemLockSize"]->setEnabled(false);
scrActions["itemPrintingEnabled"]->setEnabled(false);
scrActions["editCut"]->setEnabled(false);
scrActions["editCopy"]->setEnabled(false);
scrActions["editCopyContents"]->setEnabled(false);
scrActions["editSearchReplace"]->setEnabled(false);
scrActions["extrasHyphenateText"]->setEnabled(false);
scrActions["extrasDeHyphenateText"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(false);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
scrActions["toolsEditContents"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
scrActions["toolsRotate"]->setEnabled(false);
scrActions["toolsCopyProperties"]->setEnabled(false);
//CB 061005 moved to cpalette choosegrad
//propertiesPalette->Cpal->gradientQCombo->setCurrentItem(0);
outlinePalette->slotShowSelect(doc->currentPageNumber(), NULL);
propertiesPalette->setGradientEditMode(false);
break;
case PageItem::ImageFrame: //Image Frame
scrActions["fileImportAppendText"]->setEnabled(false);
scrActions["fileImportText"]->setEnabled(false);
scrActions["fileImportText2"]->setEnabled(false);
scrActions["fileImportImage"]->setEnabled(true);
scrActions["editCut"]->setEnabled(true);
scrActions["editCopy"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("EditContents", true);
scrActions["editClearContents"]->setEnabled(true);
scrActions["editSearchReplace"]->setEnabled(false);
scrActions["extrasHyphenateText"]->setEnabled(false);
scrActions["extrasDeHyphenateText"]->setEnabled(false);
scrActions["itemDuplicate"]->setEnabled(true);
scrActions["itemMulDuplicate"]->setEnabled(true);
scrActions["itemTransform"]->setEnabled(true);
scrActions["itemDelete"]->setEnabled(true);
scrActions["itemRaise"]->setEnabled(true);
scrActions["itemLower"]->setEnabled(true);
scrActions["itemRaiseToTop"]->setEnabled(true);
scrActions["itemLowerToBottom"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("itemSendToScrapbook", true);
scrActions["itemSendToPattern"]->setEnabled(true);
scrActions["itemSendToInline"]->setEnabled(true);
scrActions["itemAdjustFrameToImage"]->setEnabled(true);
scrActions["itemAdjustImageToFrame"]->setEnabled(true);
scrActions["itemExtendedImageProperties"]->setEnabled(currItem->pixm.imgInfo.valid);
scrActions["itemUpdateImage"]->setEnabled(true);
scrActions["itemPreviewLow"]->setEnabled(true);
scrActions["itemPreviewNormal"]->setEnabled(true);
scrActions["itemPreviewFull"]->setEnabled(true);
scrActions["itemAttributes"]->setEnabled(true);
scrActions["itemPreviewLow"]->setEnabled(true);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(false);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
scrActions["toolsEditContents"]->setEnabled(currItem->ScaleType);
scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
scrActions["toolsRotate"]->setEnabled(true);
scrActions["toolsCopyProperties"]->setEnabled(true);
scrActions["itemImageIsVisible"]->setChecked(currItem->imageShown());
scrActions["itemToggleInlineImage"]->setChecked(currItem->isImageInline());
scrActions["itemPreviewLow"]->setChecked(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewLow"]->actionInt());
scrActions["itemPreviewNormal"]->setChecked(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewNormal"]->actionInt());
scrActions["itemPreviewFull"]->setChecked(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewFull"]->actionInt());
break;
case PageItem::TextFrame: //Text Frame
scrActions["fileImportText"]->setEnabled(true);
scrActions["fileImportText2"]->setEnabled(true);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(true);
scrActions["fileExportText"]->setEnabled(true);
scrActions["editCut"]->setEnabled(true);
scrActions["editCopy"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("EditContents", true);
scrActions["editClearContents"]->setEnabled(true);
scrActions["editSearchReplace"]->setEnabled(currItem->itemText.length() != 0);
scrActions["extrasHyphenateText"]->setEnabled(true);
scrActions["extrasDeHyphenateText"]->setEnabled(true);
// scrMenuMgr->setMenuEnabled("Item", true);
scrActions["itemDuplicate"]->setEnabled(true);
scrActions["itemMulDuplicate"]->setEnabled(true);
scrActions["itemTransform"]->setEnabled(true);
scrActions["itemDelete"]->setEnabled(true);
scrActions["itemRaise"]->setEnabled(true);
scrActions["itemLower"]->setEnabled(true);
scrActions["itemRaiseToTop"]->setEnabled(true);
scrActions["itemLowerToBottom"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("itemSendToScrapbook", true);
scrActions["itemSendToPattern"]->setEnabled(true);
scrActions["itemSendToInline"]->setEnabled(true);
scrActions["itemAdjustFrameToImage"]->setEnabled(false);
scrActions["itemAdjustImageToFrame"]->setEnabled(false);
scrActions["itemExtendedImageProperties"]->setEnabled(false);
scrActions["itemUpdateImage"]->setEnabled(false);
scrActions["itemPreviewLow"]->setEnabled(false);
scrActions["itemPreviewNormal"]->setEnabled(false);
scrActions["itemPreviewFull"]->setEnabled(false);
scrActions["itemAttributes"]->setEnabled(true);
scrActions["itemPreviewLow"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", !((doc->appMode == modeEdit) || (currItem->isAnnotation())));
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToOutlines"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToPolygon"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["toolsRotate"]->setEnabled(true);
scrActions["toolsCopyProperties"]->setEnabled(true);
scrActions["toolsEditWithStoryEditor"]->setEnabled(true);
scrActions["insertSampleText"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("InsertMark",true);
if ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0))
{
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(true);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(true);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(true);
// FIXME: once there's one itemtext per story, always enable editcontents
if ((currItem->prevInChain() != 0) && (currItem->itemText.length() == 0))
scrActions["toolsEditContents"]->setEnabled(false);
else
scrActions["toolsEditContents"]->setEnabled(true);
}
else
{
scrActions["toolsEditContents"]->setEnabled(true);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(false);
}
if (currItem->nextInChain() == 0)
scrActions["toolsLinkTextFrame"]->setEnabled(true);
// if (doc->masterPageMode())
// scrActions["toolsLinkTextFrame"]->setEnabled(false);
if (doc->appMode == modeEdit)
{
setTBvals(currItem);
scrActions["editSelectAll"]->setEnabled(true);
scrActions["editSelectAllOnLayer"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("InsertMark",true);
charPalette->setEnabled(true, currItem);
if (currItem->asTextFrame())
{
enableTextActions(&scrActions, true, currItem->currentStyle().charStyle().font().scName());
currItem->asTextFrame()->togleEditModeActions();
}
view->horizRuler->setItem(currItem);
view->horizRuler->update();
}
else
{
scrMenuMgr->setMenuEnabled("InsertMark",false);
doc->currentStyle = currItem->itemText.defaultStyle();
propertiesPalette->textPal->displayParStyle(doc->currentStyle.parent());
propertiesPalette->textPal->displayCharStyle(doc->currentStyle.charStyle().parent());
emit TextStyle(doc->currentStyle);
// to go: (av)
propertiesPalette->textPal->updateStyle(doc->currentStyle);
setStyleEffects(doc->currentStyle.charStyle().effects());
}
// doc->docParagraphStyles[0].setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(currItem->lineSpacingMode()));
// doc->docParagraphStyles[0].setLineSpacing(currItem->lineSpacing());
// doc->docParagraphStyles[0].setAlignment(currItem->textAlignment);
break;
case PageItem::Table:
scrActions["editCut"]->setEnabled(true);
scrActions["editCopy"]->setEnabled(true);
if (doc->appMode == modeEditTable)
{
charPalette->setEnabled(true, currItem);
PageItem *i2 = currItem->asTable()->activeCell().textFrame();
enableTextActions(&scrActions, true, i2->currentCharStyle().font().scName());
scrActions["insertSampleText"]->setEnabled(true);
scrActions["toolsEditWithStoryEditor"]->setEnabled(true);
}
break;
case PageItem::PathText: //Path Text
scrActions["fileImportText"]->setEnabled(true);
scrActions["fileImportText2"]->setEnabled(true);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(true);
scrActions["fileExportText"]->setEnabled(true);
scrActions["editCut"]->setEnabled(true);
scrActions["editCopy"]->setEnabled(true);
scrActions["editClearContents"]->setEnabled(false);
scrActions["editSearchReplace"]->setEnabled(false);
scrActions["extrasHyphenateText"]->setEnabled(false);
scrActions["extrasDeHyphenateText"]->setEnabled(false);
// scrMenuMgr->setMenuEnabled("Item", true);
scrActions["itemDuplicate"]->setEnabled(true);
scrActions["itemMulDuplicate"]->setEnabled(true);
scrActions["itemTransform"]->setEnabled(true);
scrActions["itemDelete"]->setEnabled(true);
scrActions["itemRaise"]->setEnabled(true);
scrActions["itemLower"]->setEnabled(true);
scrActions["itemRaiseToTop"]->setEnabled(true);
scrActions["itemLowerToBottom"]->setEnabled(true);
// scrActions["itemSendToScrapbook"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("itemSendToScrapbook", true);
scrActions["itemSendToPattern"]->setEnabled(true);
scrActions["itemSendToInline"]->setEnabled(true);
scrActions["itemAdjustFrameToImage"]->setEnabled(false);
scrActions["itemAdjustImageToFrame"]->setEnabled(false);
scrActions["itemExtendedImageProperties"]->setEnabled(false);
scrActions["itemUpdateImage"]->setEnabled(false);
scrActions["itemPreviewLow"]->setEnabled(false);
scrActions["itemPreviewNormal"]->setEnabled(false);
scrActions["itemPreviewFull"]->setEnabled(false);
scrActions["itemAttributes"]->setEnabled(true);
scrActions["itemPreviewLow"]->setEnabled(false);
//scrMenuMgr->setMenuEnabled("ItemShapes", false);
scrActions["itemDetachTextFromPath"]->setEnabled(true);
// scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(true);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(true);
scrActions["toolsRotate"]->setEnabled(true);
scrActions["toolsCopyProperties"]->setEnabled(true);
scrActions["toolsEditContents"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(true);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(false);
if (doc->appMode == modeEdit)
setTBvals(currItem);
else
{
doc->currentStyle = currItem->itemText.defaultStyle();
propertiesPalette->textPal->displayParStyle(doc->currentStyle.parent());
propertiesPalette->textPal->displayCharStyle(doc->currentStyle.charStyle().parent());
emit TextStyle(doc->currentStyle);
// to go: (av)
propertiesPalette->textPal->updateStyle(doc->currentStyle);
setStyleEffects(doc->currentStyle.charStyle().effects());
}
break;
default:
scrActions["fileImportText"]->setEnabled(false);
scrActions["fileImportText2"]->setEnabled(false);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(false);
scrActions["fileExportText"]->setEnabled(false);
scrActions["editCut"]->setEnabled(true);
scrActions["editCopy"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("EditContents", false);
scrActions["editClearContents"]->setEnabled(false);
scrActions["editSearchReplace"]->setEnabled(false);
scrActions["extrasHyphenateText"]->setEnabled(false);
scrActions["extrasDeHyphenateText"]->setEnabled(false);
// scrMenuMgr->setMenuEnabled("Item", true);
scrActions["itemDuplicate"]->setEnabled(true);
scrActions["itemMulDuplicate"]->setEnabled(true);
scrActions["itemTransform"]->setEnabled(true);
scrActions["itemDelete"]->setEnabled(true);
scrActions["itemRaise"]->setEnabled(true);
scrActions["itemLower"]->setEnabled(true);
scrActions["itemRaiseToTop"]->setEnabled(true);
scrActions["itemLowerToBottom"]->setEnabled(true);
// scrActions["itemSendToScrapbook"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("itemSendToScrapbook", true);
scrActions["itemSendToPattern"]->setEnabled(true);
scrActions["itemSendToInline"]->setEnabled(true);
scrActions["itemAdjustFrameToImage"]->setEnabled(false);
scrActions["itemAdjustImageToFrame"]->setEnabled(false);
scrActions["itemExtendedImageProperties"]->setEnabled(false);
scrActions["itemUpdateImage"]->setEnabled(false);
scrActions["itemPreviewLow"]->setEnabled(false);
scrActions["itemPreviewNormal"]->setEnabled(false);
scrActions["itemPreviewFull"]->setEnabled(true);
scrActions["itemAttributes"]->setEnabled(true);
scrActions["itemPreviewLow"]->setEnabled(true);
if (SelectedType == PageItem::Polygon) //Polygon
{
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToImageFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
}
else if ((SelectedType == PageItem::RegularPolygon) || (SelectedType == PageItem::Arc)) // Regular Polygon + Arc
{
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToImageFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
}
else if (SelectedType == PageItem::PolyLine) //Polyline
{
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
}
else if ((SelectedType == PageItem::Line) || (SelectedType == PageItem::Spiral)) // Line
{
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(true);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
if (SelectedType == PageItem::Spiral)
scrActions["itemConvertToPolygon"]->setEnabled(doc->appMode != modeEdit);
else
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(doc->appMode != modeEdit);
}
else if (SelectedType == PageItem::Symbol)
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrActions["toolsEditContents"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCopy"]->setEnabled(false);
scrActions["toolsUnlinkTextFrameWithTextCut"]->setEnabled(false);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
// if (SelectedType != 5)
scrActions["toolsRotate"]->setEnabled(true);
// else
// scrActions["toolsRotate"]->setEnabled(false);
scrActions["toolsCopyProperties"]->setEnabled(true);
break;
}
doc->CurrentSel = SelectedType;
propertiesPalette->xyzPal->basePointWidget->setCheckedId(doc->RotMode());
if (docSelectionCount == 1)
{
PageItem* bx = doc->m_Selection->itemAt(0);
scrActions["itemsUnWeld"]->setEnabled(bx->isWelded());
scrActions["itemEditWeld"]->setEnabled(bx->isWelded());
}
if (docSelectionCount > 1)
{
if (!doc->m_Selection->itemsAreSameType())
{
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
//scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemConvertToSymbolFrame"]->setEnabled(false