Rev 9657 |
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 <q3accel.h>
#include <QApplication>
#include <qeventloop.h>
#include <qcolordialog.h>
#include <qcolor.h>
#include <qicon.h>
#include <q3textstream.h>
#include <qstylefactory.h>
#include <qregexp.h>
#include <qtextcodec.h>
#include <qcursor.h>
#include <q3vbox.h>
#include <qpixmap.h>
#include <qkeysequence.h>
//Added by qt3to4:
#include <QMouseEvent>
#include <Q3Frame>
#include <QDesktopWidget>
#include <QDropEvent>
#include <QCloseEvent>
#include <Q3ValueList>
#include <QLabel>
#include <QEvent>
#include <QWheelEvent>
#include <QTranslator>
#include <QDragEnterEvent>
#include <QKeyEvent>
#include <QByteArray>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#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 "sccombobox.h"
#include "scribusapp.h"
#include "scribuscore.h"
#include "scribus.h"
//#include "scribus.moc"
#include "newfile.h"
#include "page.h"
#include "query.h"
#include "mdup.h"
#include "multipleduplicate.h"
#include "docinfo.h"
#include "reformdoc.h"
#include "serializer.h"
#include "aligndistribute.h"
//#include "fmitem.h"
#include "fontprefs.h"
#include "prefs.h"
#include "prefscontext.h"
#include "prefstable.h"
#include "pdfopts.h"
#include "pdflib.h"
#include "inspage.h"
#include "delpages.h"
#include "movepage.h"
#include "helpbrowser.h"
#include "scribusXml.h"
#include "about.h"
#include "aboutplugins.h"
#include "pslib.h"
#include "druck.h"
#include "editformats.h"
#include "muster.h"
#include "newtemp.h"
#include "applytemplatedialog.h"
#include "picstatus.h"
#include "customfdialog.h"
#include "cmsprefs.h"
#include "annot.h"
#include "annota.h"
#include "javadocs.h"
#include "colorm.h"
#include "mpalette.h"
#include "cpalette.h"
#include "bookpalette.h"
#include "seiten.h"
#include "layers.h"
#include "frameedit.h"
#include "splash.h"
#include "measurements.h"
#include "gtgettext.h"
#include "fileloader.h"
#include "arrowchooser.h"
#include "tabtypography.h"
#include "tabguides.h"
#include "tabtools.h"
#include "undogui.h"
#include "filewatcher.h"
#include "charselect.h"
#include "checkDocument.h"
#include "tabcheckdoc.h"
#include "tabpdfoptions.h"
#include "docitemattrprefs.h"
#include "pageitemattributes.h"
#include "pageitem_textframe.h"
#include "pageitem_imageframe.h"
#include "tocindexprefs.h"
#include "tocgenerator.h"
#include "collect4output.h"
#include "fpoint.h"
#include "fpointarray.h"
#include "hysettings.h"
#include "guidemanager.h"
#include "mergedoc.h"
#include "lineformats.h"
#include "story.h"
#include "autoform.h"
#include "tabmanager.h"
#include "search.h"
#include "fontcombo.h"
#include "colorcombo.h"
#include "prefsfile.h"
#include "undomanager.h"
#include "polygonwidget.h"
#include "werktoolb.h"
#include "units.h"
#include "hruler.h"
#include "vruler.h"
#include "pageselector.h"
#include "scraction.h"
#include "menumanager.h"
#include "undostate.h"
#include "tree.h"
#include "scrap.h"
#include "pluginmanager.h"
#include "scpaths.h"
#include "pdfoptions.h"
#include "actionmanager.h"
#include "documentinformation.h"
#include "effectsdialog.h"
#include "documentchecker.h"
#include "gsutil.h"
#include "pagesize.h"
#include "loremipsum.h"
#include "marginWidget.h"
#include "margindialog.h"
#include "prefsmanager.h"
#include "pagelayout.h"
#include "commonstrings.h"
#include "preview.h"
#include "scribuswin.h"
#include "hyphenator.h"
#include "scmessagebox.h"
#include "imageinfodialog.h"
#include "resourcecollection.h"
#include "selection.h"
#include "stylemanager.h"
#include "smlinestyle.h"
#include "util.h"
#include "text/nlsconfig.h"
#include "plugins/formatidlist.h"
#include "scgtplugin.h"
#include "stencilreader.h"
#include "langmgr.h"
#include "smtextstyles.h"
#include "insertaframe.h"
#include "patterndialog.h"
#include "sccolorengine.h"
#include "desaxe/saxXML.h"
#include "desaxe/digester.h"
#include "desaxe/simple_actions.h"
#if defined(_WIN32)
#include "scwinprint.h"
#include "scdocoutput_ps2.h"
#endif
using namespace std;
bool previewDinUse;
bool printDinUse;
QString DocDir;
//extern ScribusCore* ScCore;
extern ScribusQApp* ScQApp;
extern bool emergencyActivated;
ScribusMainWindow::ScribusMainWindow()
{
actionManager=0;
scrMenuMgr=0;
prefsManager=0;
mainWindowStatusLabel=0;
ExternalApp=0;
#ifdef Q_WS_MAC
noIcon = loadIcon("noicon.xpm");
#endif
} // ScribusMainWindow::ScribusMainWindow()
/*
* retval 0 - ok, 1 - no fonts, ...
*/
int ScribusMainWindow::initScMW(bool primaryMainWindow)
{
int retVal=0;
// CommonStrings::languageChange();
previewDinUse = false;
printDinUse = false;
// guiLanguage = newGuiLanguage;
// initSplash(showSplash);
setUsesBigPixmaps(true);
CurrStED = NULL;
setCaption( tr("Scribus " VERSION));
setKeyCompression(false);
setIcon(loadIcon("AppIcon.png"));
scrActionGroups.clear();
scrActionGroups.setAutoDelete(true);
scrActions.clear();
scrRecentFileActions.clear();
scrRecentPasteActions.clear();
scrWindowsActions.clear();
scrLayersActions.clear();
scrMenuMgr = new MenuManager(menuBar());
prefsManager = PrefsManager::instance();
objectSpecificUndo = false;
undoManager = UndoManager::instance();
PrefsContext *undoPrefs = prefsManager->prefsFile->getContext("undo");
undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
tocGenerator = new TOCGenerator();
initDefaultValues();
initStatusBar();
qApp->processEvents();
BuFromApp = false;
actionManager = new ActionManager(this, "actionManager");
actionManager->init(this);
initMenuBar();
initToolBars();
//Qt4 buildFontMenu();
ScCore->pluginManager->setupPluginActions(this);
ScCore->pluginManager->languageChange();
initKeyboardShortcuts();
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Setting up Shortcuts") );
SetShortCut();
resize(610, 600);
// Q3VBox* vb = new Q3VBox( this );
// vb->setFrameStyle( Q3Frame::StyledPanel | Q3Frame::Sunken );
wsp = new QWorkspace( this );
setCentralWidget( wsp );
connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
//Connect windows cascade and tile actions to the workspace after its created. Only depends on wsp created.
connect( scrActions["windowsCascade"], SIGNAL(activated()) , wsp, SLOT(cascade()) );
connect( scrActions["windowsTile"], SIGNAL(activated()) , wsp, SLOT(tile()) );
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 Hyphenator") );
QString preLang = prefsManager->appPrefs.Language;
initHyphenator();
if (Sprachen.contains(preLang))
prefsManager->appPrefs.Language = preLang;
if (primaryMainWindow)
ScCore->setSplashStatus( tr("Reading Scrapbook") );
initScrapbook();
scrActions["helpTooltips"]->setOn(prefsManager->appPrefs.showToolTips);
scrActions["stickyTools"]->setOn(prefsManager->appPrefs.stickyTools);
ToggleTips();
propertiesPalette->setFontSize();
if (scrActions["SaveAsDocumentTemplate"])
scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
//Qt4 connect(this, SIGNAL(TextIFont(const QString&)), this, SLOT(AdjustFontMenu(const QString&)));
connect(this, SIGNAL(TextStyle(const ParagraphStyle&)), propertiesPalette, SLOT(updateStyle(const ParagraphStyle&)));
connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
// connect(ClipB, SIGNAL(selectionChanged()), this, SLOT(ClipChange()));
setAcceptDrops(true);
QCoreApplication::instance()->installEventFilter(this);
return retVal;
}
ScribusMainWindow::~ScribusMainWindow()
{
}
void ScribusMainWindow::initToolBars()
{
fileToolBar = new ScToolBar( tr("File"), "File", this);
scrActions["fileNew"]->addTo(fileToolBar);
scrActions["fileOpen"]->addTo(fileToolBar);
scrMenuMgr->addMenuToWidgetOfAction("FileOpenRecent", scrActions["fileOpen"]);
scrActions["fileSave"]->addTo(fileToolBar);
scrActions["fileClose"]->addTo(fileToolBar);
scrActions["filePrint"]->addTo(fileToolBar);
scrActions["toolsPreflightVerifier"]->addTo(fileToolBar);
scrActions["fileExportAsPDF"]->addTo(fileToolBar);
editToolBar = new ScToolBar( tr("Edit"), "Edit", this);
UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
undoManager->registerGui(uWidget);
mainToolBar = new ModeToolBar(this);
pdfToolBar = new PDFToolBar(this);
connect(mainToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setOn(bool)));
connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setShown(bool)));
connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setOn(bool)));
connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), mainToolBar, SLOT(setShown(bool)) );
}
void ScribusMainWindow::initDefaultValues()
{
HaveDoc = false;
ScriptRunning = false;
view = NULL;
doc = NULL;
Buffer2 = "";
DocNr = 1;
PrinterUsed = false;
PDef.Pname = "";
PDef.Dname = "";
PDef.Command = "";
keyrep = false;
_arrowKeyDown = false;
ClipB = QApplication::clipboard();
palettesStatus[0] = false;
guidesStatus[0] = false;
}
void ScribusMainWindow::initKeyboardShortcuts()
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrActions.begin(); it!=scrActions.end(); ++it )
{
if ((ScrAction*)(it.data())!=NULL)
{
QString accelerator=it.data()->accel();
prefsManager->setKeyEntry(it.key(), it.data()->cleanMenuText(), accelerator,0);
}
//else
// qDebug(it.key());
//qDebug(QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.data()->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 Tree(this);
outlinePalette->setMainWindow(this);
connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)) );
connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setOn(bool)));
propertiesPalette = new Mpalette(this);
propertiesPalette->setMainWindow(this);
connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)) );
connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setOn(bool)));
//CB dont need this until we have a doc...
//propertiesPalette->Cpal->SetColors(prefsManager->colorSet());
propertiesPalette->Fonts->RebuildList(0);
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(setOn(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(setOn(bool)));
scrapbookPalette->installEventFilter(this);
pagePalette = new PagePalette(this);
connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , this, SLOT(setPagePalette(bool)) );
connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setOn(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(setOn(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(setOn(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(setOn(bool)));
connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
docCheckerPalette->installEventFilter(this);
docCheckerPalette->hide();
alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette", false);
connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setOn(bool)));
connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
alignDistributePalette->installEventFilter(this);
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);
connect( scrActions["editStyles"], SIGNAL(toggled(bool)) , styleManager, SLOT(setPaletteShown(bool)) );
connect( styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setOn(bool)));
styleManager->installEventFilter(this);
connect(docCheckerPalette, SIGNAL(selectElement(int, int)), this, SLOT(selectItemsFromOutlines(int, 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(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(manageMasterPages(QString)));
connect(propertiesPalette->paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setNewParStyle(const QString&)));
connect(propertiesPalette->charStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setNewCharStyle(const QString&)));
// connect(propertiesPalette, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
connect(nodePalette, SIGNAL(Schliessen()), this, SLOT(NoFrameEdit()));
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 *)), this, SLOT(selectItemsFromOutlines(PageItem *)));
// guides
connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setOn(bool)));
// char palette
connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setOn(bool)));
}
void ScribusMainWindow::initScrapbook()
{
QString scrapbookFileO = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrap13.scs");
QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
if (scrapbookFileInfoO.exists())
{
scrapbookPalette->readOldContents(scrapbookFileO, QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/main"));
QDir d = QDir();
d.rename(scrapbookFileO, QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrap13.backup"));
}
QString scrapbookTemp = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/tmp");
QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
if (scrapbookTempInfo.exists())
scrapbookPalette->readTempContents(scrapbookTemp);
QString scrapbookFile = QDir::convertSeparators(prefsManager->preferencesLocation()+"/scrapbook/main");
QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
if (scrapbookFileInfo.exists())
scrapbookPalette->readContents(scrapbookFile);
scrapbookPalette->setScrapbookFileName(scrapbookFile);
scrapbookPalette->setOpenScrapbooks(prefsManager->appPrefs.RecentScrapbooks);
rebuildRecentPasteMenu();
connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
}
bool ScribusMainWindow::warningVersion(QWidget *parent)
{
bool retval = false;
int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
QObject::tr("You are running a development version of Scribus 1.3.x. The document you are working with was created in Scribus 1.2.x. Saving the current file under 1.3.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", tr("&File"));
scrMenuMgr->addMenuItem(scrActions["fileNew"], "File");
scrMenuMgr->addMenuItem(scrActions["fileOpen"], "File");
recentFileMenuName="FileOpenRecent";
scrMenuMgr->createMenu(recentFileMenuName, QIcon(noIcon), tr("Open &Recent"), "File");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["fileClose"], "File");
scrMenuMgr->addMenuItem(scrActions["fileSave"], "File");
scrMenuMgr->addMenuItem(scrActions["fileSaveAs"], "File");
scrMenuMgr->addMenuItem(scrActions["fileRevert"], "File");
scrMenuMgr->addMenuItem(scrActions["fileCollect"], "File");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->createMenu("FileImport", QIcon(noIcon), tr("&Import"), "File");
scrMenuMgr->addMenuItem(scrActions["fileImportText"], "FileImport");
// scrMenuMgr->addMenuItem(scrActions["fileImportText2"], "FileImport");
scrMenuMgr->addMenuItem(scrActions["fileImportAppendText"], "FileImport");
scrMenuMgr->addMenuItem(scrActions["fileImportImage"], "FileImport");
scrMenuMgr->createMenu("FileExport", QIcon(noIcon), tr("&Export"), "File");
scrMenuMgr->addMenuItem(scrActions["fileExportText"], "FileExport");
scrMenuMgr->addMenuItem(scrActions["fileExportAsEPS"], "FileExport");
scrMenuMgr->addMenuItem(scrActions["fileExportAsPDF"], "FileExport");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["fileDocSetup"], "File");
scrMenuMgr->addMenuItem(scrActions["filePreferences"], "File");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["filePrint"], "File");
scrMenuMgr->addMenuItem(scrActions["PrintPreview"], "File");
scrMenuMgr->addMenuSeparator("File");
scrMenuMgr->addMenuItem(scrActions["fileQuit"], "File");
scrActions["fileClose"]->setEnabled(false);
scrActions["fileSave"]->setEnabled(false);
scrActions["fileSaveAs"]->setEnabled(false);
scrActions["fileRevert"]->setEnabled(false);
scrActions["fileCollect"]->setEnabled(false);
scrActions["fileImportText"]->setEnabled(false);
scrActions["fileImportText2"]->setEnabled(false);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(false);
scrActions["pageImport"]->setEnabled(false);
scrActions["fileExportText"]->setEnabled(false);
scrActions["fileExportAsEPS"]->setEnabled(false);
scrActions["fileExportAsPDF"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileImport", false);
scrMenuMgr->setMenuEnabled("FileExport", false);
scrActions["fileDocSetup"]->setEnabled(false);
scrActions["filePrint"]->setEnabled(false);
scrActions["PrintPreview"]->setEnabled(false);
scrMenuMgr->createMenu("Edit", tr("&Edit"));
scrMenuMgr->addMenuItem(scrActions["editUndoAction"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editRedoAction"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editActionMode"], "Edit");
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editCut"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editCopy"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editPaste"], "Edit");
recentPasteMenuName="EditPasteRecent";
scrMenuMgr->createMenu(recentPasteMenuName, QIcon(noIcon), tr("Paste Recent"), "Edit");
scrMenuMgr->createMenu("EditContents", QPixmap(noIcon), tr("Contents"), "Edit");
scrMenuMgr->addMenuItem(scrActions["editCopyContents"], "EditContents");
scrMenuMgr->addMenuItem(scrActions["editPasteContents"], "EditContents");
scrMenuMgr->addMenuItem(scrActions["editPasteContentsAbs"], "EditContents");
scrMenuMgr->addMenuItem(scrActions["editClearContents"], "EditContents");
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editSelectAll"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editDeselectAll"], "Edit");
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editSearchReplace"], "Edit");
scrMenuMgr->addMenuItem(scrActions["toolsEditWithStoryEditor"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editEditWithImageEditor"], "Edit");
scrMenuMgr->addMenuSeparator("Edit");
scrMenuMgr->addMenuItem(scrActions["editColors"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editPatterns"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editStyles"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editMasterPages"], "Edit");
scrMenuMgr->addMenuItem(scrActions["editJavascripts"], "Edit");
scrActions["editUndoAction"]->setEnabled(false);
scrActions["editRedoAction"]->setEnabled(false);
scrActions["editActionMode"]->setEnabled(true);
scrActions["editCut"]->setEnabled(false);
scrActions["editCopy"]->setEnabled(false);
scrActions["editPaste"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
scrMenuMgr->setMenuEnabled("EditContents", false);
scrActions["editCopyContents"]->setEnabled(false);
scrActions["editPasteContents"]->setEnabled(false);
scrActions["editPasteContentsAbs"]->setEnabled(false);
scrActions["editClearContents"]->setEnabled(false);
scrActions["editSelectAll"]->setEnabled(false);
scrActions["editDeselectAll"]->setEnabled(false);
scrActions["editSearchReplace"]->setEnabled(false);
scrActions["editPatterns"]->setEnabled(false);
scrActions["editStyles"]->setEnabled(false);
scrActions["editMasterPages"]->setEnabled(false);
scrActions["editJavascripts"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
scrActions["editEditWithImageEditor"]->setEnabled(false);
/*Qt4
//Style Menu
scrMenuMgr->createMenu("Style", tr("St&yle"));
//Color menu
// CB TODO
scrMenuMgr->createMenu("Color", tr("&Color"));
ColorMenC = new ColorCombo(false);
ColorMenC->setEditable(false);
scrMenuMgr->addMenuItem(ColorMenC, "Color");
//Text size menu
scrMenuMgr->createMenu("FontSize", tr("&Size"));
scrActionGroups["fontSize"]->addTo(scrMenuMgr->getLocalPopupMenu("FontSize"));
//Shade menu
scrMenuMgr->createMenu("Shade", tr("&Shade"));
scrActionGroups["shade"]->addTo(scrMenuMgr->getLocalPopupMenu("Shade"));
//Font menu
scrMenuMgr->createMenu("Font", tr("&Font"));
FontMenu = scrMenuMgr->getLocalPopupMenu("Font");
//Type style menu
scrMenuMgr->createMenu("TypeEffects", tr("&Effects"));
scrActionGroups["typeEffects"]->addTo(scrMenuMgr->getLocalPopupMenu("TypeEffects"));
*/
//Item Menu
scrMenuMgr->createMenu("Item", tr("&Item"));
scrMenuMgr->addMenuItem(scrActions["itemDuplicate"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemMulDuplicate"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemDelete"], "Item");
scrMenuMgr->addMenuSeparator("Item");
scrMenuMgr->addMenuItem(scrActions["itemGroup"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemUngroup"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemLock"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemLockSize"], "Item");
scrMenuMgr->addMenuSeparator("Item");
scrMenuMgr->createMenu("ItemLevel", tr("Level"));
scrMenuMgr->addMenuToMenu("ItemLevel", "Item");
scrMenuMgr->addMenuItem(scrActions["itemRaise"], "ItemLevel");
scrMenuMgr->addMenuItem(scrActions["itemLower"], "ItemLevel");
scrMenuMgr->addMenuItem(scrActions["itemRaiseToTop"], "ItemLevel");
scrMenuMgr->addMenuItem(scrActions["itemLowerToBottom"], "ItemLevel");
scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"));
scrMenuMgr->addMenuToMenu("ItemLayer", "Item");
layerMenuName="ItemLayer";
scrMenuMgr->addMenuItem(scrActions["itemSendToScrapbook"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemSendToPattern"], "Item");
scrMenuMgr->addMenuSeparator("Item");
scrMenuMgr->addMenuItem(scrActions["itemAdjustFrameToImage"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemExtendedImageProperties"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemUpdateImage"], "Item");
scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"), "Item");
scrMenuMgr->addMenuItem(scrActions["itemImageIsVisible"], "ItemPreviewSettings");
scrMenuMgr->addMenuSeparator("ItemPreviewSettings");
scrMenuMgr->addMenuItem(scrActions["itemPreviewLow"], "ItemPreviewSettings");
scrMenuMgr->addMenuItem(scrActions["itemPreviewNormal"], "ItemPreviewSettings");
scrMenuMgr->addMenuItem(scrActions["itemPreviewFull"], "ItemPreviewSettings");
scrMenuMgr->addMenuSeparator("Item");
scrMenuMgr->addMenuItem(scrActions["itemAttributes"], "Item");
scrMenuMgr->createMenu("ItemPDFOptions", tr("&PDF Options"));
scrMenuMgr->addMenuToMenu("ItemPDFOptions", "Item");
scrMenuMgr->addMenuItem(scrActions["itemPDFIsAnnotation"], "ItemPDFOptions");
scrMenuMgr->addMenuItem(scrActions["itemPDFIsBookmark"], "ItemPDFOptions");
scrMenuMgr->addMenuItem(scrActions["itemPDFAnnotationProps"], "ItemPDFOptions");
scrMenuMgr->addMenuItem(scrActions["itemPDFFieldProps"], "ItemPDFOptions");
scrMenuMgr->createMenu("ItemShapes", tr("&Shape"), "Item");
// CB TODO
//Shape menu
//Qt4 SCustom = new Autoforms(0);
//Qt4 scrMenuMgr->addMenuItem(SCustom, "ItemShapes");
//Qt4 connect(SCustom, SIGNAL(FormSel(int, int, double *)), this, SLOT(MakeFrame(int, int, double *)));
//Qt4 scrMenuMgr->addMenuItem(scrActions["itemShapeEdit"], "ItemShapes");
scrMenuMgr->createMenu("ItemConvertTo", QPixmap(noIcon), tr("C&onvert To"), "Item");
//scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert To"));
//scrMenuMgr->addMenuToMenu("ItemConvertTo", "Item");
scrMenuMgr->addMenuItem(scrActions["itemConvertToBezierCurve"], "ItemConvertTo");
scrMenuMgr->addMenuItem(scrActions["itemConvertToImageFrame"], "ItemConvertTo");
scrMenuMgr->addMenuItem(scrActions["itemConvertToOutlines"], "ItemConvertTo");
scrMenuMgr->addMenuItem(scrActions["itemConvertToPolygon"], "ItemConvertTo");
scrMenuMgr->addMenuItem(scrActions["itemConvertToTextFrame"], "ItemConvertTo");
scrMenuMgr->addMenuItem(scrActions["itemAttachTextToPath"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemDetachTextFromPath"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemCombinePolygons"], "Item");
scrMenuMgr->addMenuItem(scrActions["itemSplitPolygons"], "Item");
scrMenuMgr->setMenuEnabled("ItemShapes", false);
scrActions["itemGroup"]->setEnabled(false);
scrActions["itemUngroup"]->setEnabled(false);
scrActions["itemAttachTextToPath"]->setEnabled(false);
scrActions["itemDetachTextFromPath"]->setEnabled(false);
scrActions["itemCombinePolygons"]->setEnabled(false);
scrActions["itemSplitPolygons"]->setEnabled(false);
scrActions["itemLock"]->setEnabled(false);
scrActions["itemLockSize"]->setEnabled(false);
scrActions["itemPrintingEnabled"]->setEnabled(false);
scrActions["itemImageIsVisible"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
//Insert menu
scrMenuMgr->createMenu("Insert", tr("I&nsert"));
scrMenuMgr->addMenuItem(scrActions["insertFrame"], "Insert");
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertTextFrame"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertImageFrame"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertTableFrame"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertShape"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertPolygon"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertLine"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertBezier"], "Insert");
scrMenuMgr->addMenuItem(scrActions["toolsInsertFreehandLine"], "Insert");
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["stickyTools"], "Insert");
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["insertGlyph"], "Insert");
scrMenuMgr->createMenu("InsertChar", QPixmap(noIcon), tr("&Character"), "Insert");
//scrMenuMgr->addMenuToMenu("InsertChar", "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodePageNumber"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeSmartHyphen"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingHyphen"], "InsertChar");
scrMenuMgr->addMenuSeparator("InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeCopyRight"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeRegdTM"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeTM"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeSolidus"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeBullet"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeMidpoint"], "InsertChar");
scrMenuMgr->addMenuSeparator("InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeDashEm"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeDashEn"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeDashFigure"], "InsertChar");
scrMenuMgr->addMenuItem(scrActions["unicodeDashQuotation"], "InsertChar");
scrMenuMgr->createMenu("InsertQuote", QPixmap(noIcon), tr("&Quote"), "Insert");
//scrMenuMgr->addMenuToMenu("InsertQuote", "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteApostrophe"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteStraight"], "InsertQuote");
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeft"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRight"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeft"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRight"], "InsertQuote");
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleReversed"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleReversed"], "InsertQuote");
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowSingleComma"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteLowDoubleComma"], "InsertQuote");
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote");
scrMenuMgr->addMenuSeparator("InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleLeft"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKSingleRight"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote");
scrMenuMgr->addMenuItem(scrActions["unicodeQuoteCJKDoubleRight"], "InsertQuote");
scrMenuMgr->createMenu("InsertSpace", QPixmap(noIcon), tr("S&paces && Breaks"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeNonBreakingSpace"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEN"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceEM"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThin"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceThick"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceMid"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeSpaceHair"], "InsertSpace");
scrMenuMgr->addMenuSeparator("InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeNewLine"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeFrameBreak"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeColumnBreak"], "InsertSpace");
scrMenuMgr->addMenuItem(scrActions["unicodeZerowidthSpace"], "InsertSpace");
scrMenuMgr->createMenu("InsertLigature", QPixmap(noIcon), tr("Liga&ture"), "Insert");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ff"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fi"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_fl"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffi"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ffl"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_ft"], "InsertLigature");
scrMenuMgr->addMenuItem(scrActions["unicodeLigature_st"], "InsertLigature");
scrMenuMgr->addMenuSeparator("Insert");
scrMenuMgr->addMenuItem(scrActions["insertSampleText"], "Insert");
scrActions["insertFrame"]->setEnabled(false);
//Page menu
scrMenuMgr->createMenu("Page", tr("&Page"));
scrMenuMgr->addMenuItem(scrActions["pageInsert"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageImport"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageDelete"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageCopy"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageMove"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageApplyMasterPage"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageCopyToMasterPage"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageManageGuides"], "Page");
scrMenuMgr->addMenuItem(scrActions["pageManageMargins"], "Page");
scrMenuMgr->addMenuSeparator("Page");
scrMenuMgr->addMenuItem(scrActions["viewSnapToGrid"], "Page");
scrMenuMgr->addMenuItem(scrActions["viewSnapToGuides"], "Page");
scrActions["pageDelete"]->setEnabled(false);
scrActions["pageMove"]->setEnabled(false);
//View menu
scrMenuMgr->createMenu("View", tr("&View"));
scrMenuMgr->addMenuItem(scrActions["viewFitInWindow"], "View");
scrMenuMgr->addMenuItem(scrActions["viewFitWidth"], "View");
scrMenuMgr->addMenuItem(scrActions["viewFit50"], "View");
scrMenuMgr->addMenuItem(scrActions["viewFit75"], "View");
scrMenuMgr->addMenuItem(scrActions["viewFit100"], "View");
scrMenuMgr->addMenuItem(scrActions["viewFit200"], "View");
scrMenuMgr->addMenuSeparator("View");
scrMenuMgr->addMenuItem(scrActions["viewFitPreview"], "View");
scrMenuMgr->addMenuSeparator("View");
scrMenuMgr->addMenuItem(scrActions["viewShowMargins"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowBleeds"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowFrames"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowLayerMarkers"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowImages"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowGrid"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowGuides"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowColumnBorders"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowBaseline"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowTextChain"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowTextControls"], "View");
scrMenuMgr->addMenuItem(scrActions["viewShowRulers"], "View");
scrMenuMgr->addMenuItem(scrActions["viewRulerMode"], "View");
scrActions["viewShowRulers"]->setEnabled(false);
//CB If this is viewNewView imeplemented, it should be on the windows menu
// scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
//Tool menu
/*
scrMenuMgr->createMenu("Tools", tr("&Tools"));
scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Tools");
scrMenuMgr->addMenuSeparator("Tools");
scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Tools");
scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Tools");
//scrActions["toolsPreflightVerifier"]->setEnabled(false);*/
//Extra menu
scrMenuMgr->createMenu("Extras", tr("E&xtras"));
scrMenuMgr->addMenuItem(scrActions["extrasManagePictures"], "Extras");
scrMenuMgr->addMenuItem(scrActions["extrasHyphenateText"], "Extras");
scrMenuMgr->addMenuItem(scrActions["extrasDeHyphenateText"], "Extras");
scrMenuMgr->addMenuItem(scrActions["extrasGenerateTableOfContents"], "Extras");
scrMenuMgr->setMenuEnabled("Extras", false);
scrActions["extrasHyphenateText"]->setEnabled(false);
scrActions["extrasDeHyphenateText"]->setEnabled(false);
//Window menu
scrMenuMgr->createMenu("Windows", tr("&Windows"), QString::null, true);
//Qt4 connect(FontMenu, SIGNAL(aboutToShow()), this, SLOT(fontMenuAboutToShow()));
connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
addDefaultWindowMenuItems();
//Help menu
scrMenuMgr->createMenu("Help", tr("&Help"));
scrMenuMgr->addMenuItem(scrActions["helpManual"], "Help");
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpTooltips"], "Help");
scrMenuMgr->addMenuSeparator("Help");
scrMenuMgr->addMenuItem(scrActions["helpAboutScribus"], "Help");
scrMenuMgr->addMenuItem(scrActions["helpAboutPlugins"], "Help");
scrMenuMgr->addMenuItem(scrActions["helpAboutQt"], "Help");
scrMenuMgr->addMenuToMenuBar("File");
scrMenuMgr->addMenuToMenuBar("Edit");
scrMenuMgr->addMenuToMenuBar("Style");
scrMenuMgr->setMenuEnabled("Style", false);
scrMenuMgr->addMenuToMenuBar("Item");
scrMenuMgr->setMenuEnabled("Item", false);
scrMenuMgr->addMenuToMenuBar("Insert");
scrMenuMgr->setMenuEnabled("Insert", false);
scrMenuMgr->addMenuToMenuBar("Page");
scrMenuMgr->setMenuEnabled("Page", false);
scrMenuMgr->addMenuToMenuBar("View");
scrMenuMgr->setMenuEnabled("View", false);
//scrMenuMgr->addMenuToMenuBar("Tools");
scrMenuMgr->addMenuToMenuBar("Extras");
scrMenuMgr->setMenuEnabled("Extras", false);
scrMenuMgr->addMenuToMenuBar("Windows");
//scrMenuMgr->setMenuEnabled("Windows", false);
menuBar()->insertSeparator();
scrMenuMgr->addMenuToMenuBar("Help");
//Alignment menu
scrMenuMgr->createMenu("Alignment", tr("&Alignment"));
scrMenuMgr->addMenuItem(scrActions["alignLeft"], "Alignment");
scrMenuMgr->addMenuItem(scrActions["alignCenter"], "Alignment");
scrMenuMgr->addMenuItem(scrActions["alignRight"], "Alignment");
scrMenuMgr->addMenuItem(scrActions["alignBlock"], "Alignment");
scrMenuMgr->addMenuItem(scrActions["alignForced"], "Alignment");
//Qt4 connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
//Qt4 connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
}
void ScribusMainWindow::addDefaultWindowMenuItems()
{
scrMenuMgr->clearMenu("Windows");
scrMenuMgr->addMenuItem(scrActions["windowsCascade"], "Windows");
scrMenuMgr->addMenuItem(scrActions["windowsTile"], "Windows");
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsProperties"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsOutline"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsScrapbook"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsLayers"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsPages"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsBookmarks"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsMeasurements"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsActionHistory"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsPreflightVerifier"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsAlignDistribute"], "Windows");
scrMenuMgr->addMenuSeparator("Windows");
scrMenuMgr->addMenuItem(scrActions["toolsToolbarTools"], "Windows");
scrMenuMgr->addMenuItem(scrActions["toolsToolbarPDF"], "Windows");
}
void ScribusMainWindow::initStatusBar()
{
mainWindowStatusLabel = new QLabel( " ", statusBar(), "ft");
mainWindowProgressBar = new Q3ProgressBar(statusBar(), "p");
mainWindowProgressBar->setCenterIndicator(true);
mainWindowProgressBar->setFixedWidth( 100 );
mainWindowProgressBar->reset();
mainWindowXPosLabel = new QLabel( "X-Pos:", statusBar(), "xt");
mainWindowYPosLabel = new QLabel( "Y-Pos:", statusBar(), "yt");
mainWindowXPosDataLabel = new QLabel( " ", statusBar(), "dt");
mainWindowYPosDataLabel = new QLabel( " ", statusBar(), "ydt");
statusBar()->addWidget(mainWindowStatusLabel, 6, true);
statusBar()->addWidget(mainWindowProgressBar, 0, true);
statusBar()->addWidget(mainWindowXPosLabel, 0, true);
statusBar()->addWidget(mainWindowXPosDataLabel, 1, true);
statusBar()->addWidget(mainWindowYPosLabel, 0, true);
statusBar()->addWidget(mainWindowYPosDataLabel, 1, true);
}
void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
{
double xn = xp;
double yn = yp;
if (doc->guidesSettings.rulerMode)
{
xn -= doc->currentPage()->xOffset();
yn -= doc->currentPage()->yOffset();
}
xn -= doc->rulerXoffset;
yn -= doc->rulerYoffset;
QString suffix=unitGetSuffixFromIndex(doc->unitIndex());
int multiplier=unitGetDecimalsFromIndex(doc->unitIndex());
double divisor=static_cast<double>(multiplier);
int precision=unitGetPrecisionFromIndex(doc->unitIndex());
QString tmp;
mainWindowXPosDataLabel->setText(tmp.setNum(qRound(xn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
mainWindowYPosDataLabel->setText(tmp.setNum(qRound(yn*doc->unitRatio() * multiplier) / divisor, 'f', precision) + suffix);
}
void ScribusMainWindow::setStatusBarInfoText(QString newText)
{
if (mainWindowStatusLabel)
mainWindowStatusLabel->setText(newText);
}
//CB-->Doc
void ScribusMainWindow::setTBvals(PageItem *currItem)
{
if (currItem->itemText.length() != 0)
{
// int ChPos = qMin(currItem->CPos, static_cast<int>(currItem->itemText.length()-1));
const ParagraphStyle& currPStyle(currItem->currentStyle());
setAbsValue(currPStyle.alignment());
propertiesPalette->setParStyle(currPStyle.parent());
propertiesPalette->setCharStyle(currItem->currentCharStyle().parent());
doc->currentStyle = currItem->currentStyle();
doc->currentStyle.charStyle() = currItem->currentCharStyle();
emit TextStyle(doc->currentStyle);
// to go: (av)
emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
emit TextFarben(doc->currentStyle.charStyle().strokeColor(),
doc->currentStyle.charStyle().fillColor(),
doc->currentStyle.charStyle().strokeShade(),
doc->currentStyle.charStyle().fillShade());
emit TextIFont(doc->currentStyle.charStyle().font().scName());
emit TextISize(doc->currentStyle.charStyle().fontSize());
emit TextUSval(doc->currentStyle.charStyle().tracking());
emit TextStil(doc->currentStyle.charStyle().effects());
emit TextScale(doc->currentStyle.charStyle().scaleH());
emit TextScaleV(doc->currentStyle.charStyle().scaleV());
emit TextBase(doc->currentStyle.charStyle().baselineOffset());
emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
}
}
void ScribusMainWindow::wheelEvent(QWheelEvent *w)
{
if (HaveDoc)
{
int wheelVal=prefsManager->mouseWheelValue();
if ((w->orientation() != Qt::Vertical) || ( w->state() & Qt::ShiftButton ))
{
if (w->delta() < 0)
view->scrollBy(wheelVal, 0);
else
view->scrollBy(-wheelVal, 0);
}
else
{
if (w->delta() < 0)
view->scrollBy(0, wheelVal);
else
view->scrollBy(0, -wheelVal);
}
w->accept();
}
}
//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->appMode==modeEdit)
{
if (doc->m_Selection->count() == 1)
{
PageItem *currItem = doc->m_Selection->itemAt(0);
if (currItem!=NULL)
{
if (unicodevalue!=-1)
{
if (currItem->HasSel && currItem->itemType()==PageItem::TextFrame)
currItem->asTextFrame()->deleteSelectedTextFromFrame();
currItem->itemText.insertChars(currItem->CPos, QString(QChar(unicodevalue)), true);
currItem->CPos += 1;
// currItem->Tinput = true;
view->RefreshItem(currItem);
}
else if (actionName=="unicodeSmartHyphen") //ignore the char as we use an attribute if the text item, for now.
{
// this code is currently dead since unicodeSmartHyphen
// doesnt have unicodevalue == -1 any more
if (currItem->CPos-1>0)
{
#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
currItem->itemText.insertChars(currItem->CPos, QString(SpecialChars::SHYPHEN), true);
currItem->CPos += 1;
#endif
// currItem->Tinput = true;
view->RefreshItem(currItem);
}
}
}
}
}
}
}
bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
{
bool retVal;
if (e->type() == QEvent::ToolTip)
{
if (prefsManager->appPrefs.showToolTips)
return false;
else
return true;
}
if ( e->type() == QEvent::KeyPress ) {
QKeyEvent *k = (QKeyEvent *)e;
int keyMod=0;
if (k->state() & Qt::ShiftButton)
keyMod |= Qt::SHIFT;
if (k->state() & Qt::ControlButton)
keyMod |= Qt::CTRL;
if (k->state() & Qt::AltButton)
keyMod |= Qt::ALT;
QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
if (QString(currKeySeq).isNull())
return false;
retVal=true;
//Palette actions
if (currKeySeq == scrActions["specialToggleAllPalettes"]->accel())
scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
else
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"]->accel())
scrActions["editStyles"]->toggle();
else
if (currKeySeq == scrActions["editUndoAction"]->accel() && scrActions["editUndoAction"]->isEnabled())
scrActions["editUndoAction"]->activate(QAction::Trigger);
else
if (currKeySeq == scrActions["editRedoAction"]->accel() && scrActions["editRedoAction"]->isEnabled())
scrActions["editRedoAction"]->activate(QAction::Trigger);
else
//Other actions
if (currKeySeq == scrActions["fileQuit"]->accel())
scrActions["fileQuit"]->activate(QAction::Trigger);
else
//Zoom actions
if (currKeySeq == scrActions["toolsZoomIn"]->accel())
scrActions["toolsZoomIn"]->activate(QAction::Trigger);
else
if (currKeySeq == scrActions["toolsZoomOut"]->accel())
scrActions["toolsZoomOut"]->activate(QAction::Trigger);
else
retVal=false;
}
else
retVal=false;
//Return false to pass event to object
return retVal;
}
void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
{
QWidgetList windows;
QWidget* w = NULL;
int kk = k->key();
QString uc = k->text();
QString cr, Tcha, Twort;
if (HaveDoc)
{
if ((doc->appMode == modeMagnifier) && (kk == Qt::Key_Shift))
{
qApp->changeOverrideCursor(QCursor(loadIcon("LupeZm.xpm")));
return;
}
}
if (keyrep)
return;
keyrep = true;
int KeyMod;
switch (k->state())
{
case Qt::ShiftButton:
KeyMod = Qt::SHIFT;
break;
case Qt::AltButton:
KeyMod = Qt::ALT;
break;
case Qt::ControlButton:
KeyMod = Qt::CTRL;
break;
default:
KeyMod = 0;
break;
}
//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:
currItem->Sizing = false;
if (doc->SubMode != -1)
{
view->Deselect(false);
doc->Items->remove(currItem->ItemNr);
}
else
view->Deselect(false);
break;
case modeEdit:
break;
case modeLinkFrames:
case modeUnlinkFrames:
case modeRotation:
case modeEditGradientVectors:
case modeCopyProperties:
view->Deselect(false);
case modePanning:
break;
case modeDrawBezierLine:
currItem->PoLine.resize(currItem->PoLine.size()-2);
if (currItem->PoLine.size() < 4)
{
view->Deselect(false);
doc->Items->remove(currItem->ItemNr);
}
else
{
doc->SizeItem(currItem->PoLine.WidthHeight().x(), currItem->PoLine.WidthHeight().y(), currItem->ItemNr, 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:
view->Deselect(false);
doc->Items->remove(currItem->ItemNr);
break;
}
}
view->m_MouseButtonPressed = false;
doc->DragP = false;
doc->leaveDrag = false;
view->operItemMoving = false;
view->operItemResizing = false;
view->inItemCreation = false;
view->MidButt = false;
doc->SubMode = -1;
doc->ElemToLink = NULL;
NoFrameEdit();
slotSelect();
return;
}
Qt::ButtonState buttonState = k->state();
/**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()))
{
/**
* 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->mouseWheelValue();
if ((buttonState & Qt::ShiftButton) && !(buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
wheelVal = qMax(qRound(wheelVal / 10.0), 1);
switch (kk)
{
case Qt::Key_Space:
keyrep = false;
if (doc->appMode == modePanning)
setAppMode(modeNormal);
else
setAppMode(modePanning);
return;
break;
case Qt::Key_Prior:
if (doc->masterPageMode())
view->scrollBy(0, -prefsManager->mouseWheelValue());
else
{
pg = doc->currentPageNumber();
if ((buttonState & Qt::ShiftButton) && !(buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
pg--;
else
pg -= doc->pageSets[doc->currentPageLayout].Columns;
if (pg > -1)
view->GotoPage(pg);
}
keyrep = false;
return;
break;
case Qt::Key_Next:
if (doc->masterPageMode())
view->scrollBy(0, prefsManager->mouseWheelValue());
else
{
pg = doc->currentPageNumber();
if ((buttonState & Qt::ShiftButton) && !(buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
pg++;
else
pg += doc->pageSets[doc->currentPageLayout].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:
keyrep = false;
windows = wsp->windowList();
if (windows.count() > 1)
{
for (int i = 0; i < static_cast<int>(windows.count()); ++i)
{
if (wsp->activeWindow() == 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
* -- Use PageUp to raise an item
* -- Use PageDown to lower an item
* -- Use the arrow keys to move an item or group around for !inches:
With no meta, by 1.0 unit
Ctrl, by 10.0 units
Shift by 0.1 units
Ctrl Shift 0.01 units
- For inches:
With no meta, by 1.0 pt
Ctrl, by 1.0 unit
Shift by 0.1 units
Ctrl Shift 0.01 units
* -- Use the arrow keys to resize an item:
Alt right arrow, move right side outwards (expand)
Alt left arrow, move left side outwards (expand)
Alt Shift right arrow, move left side inwards (shrink)
Alt Shift left arrow, move right side inwards (shrink)
* -- 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)
{
double moveBy=1.0;
if (doc->unitIndex()!=SC_INCHES)
{
if ((buttonState & Qt::ShiftButton) && !(buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=0.1;
else if (!(buttonState & Qt::ShiftButton) && (buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=10.0;
else if ((buttonState & Qt::ShiftButton) && (buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=0.01;
moveBy/=doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
}
else
{
if ((buttonState & Qt::ShiftButton) && !(buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=0.1/doc->unitRatio();
else if (!(buttonState & Qt::ShiftButton) && (buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=1.0/doc->unitRatio();
else if ((buttonState & Qt::ShiftButton) && (buttonState & Qt::ControlButton) && !(buttonState & Qt::AltButton))
moveBy=0.01/doc->unitRatio();
}
bool resizing=((buttonState & Qt::AltButton) && !(buttonState & Qt::ControlButton));
bool resizingsmaller=(resizing && (buttonState & Qt::ShiftButton));
double resizeBy=1.0;
//CB with control locked out due to the requirement of moveby of 0.01, we cannot support
//resizeby 10 units unless we move to supporting modifier keys that most people dont have.
//if (buttonState & Qt::ControlButton)
// resizeBy*=10.0;
resizeBy/=doc->unitRatio();
if (resizingsmaller)
resizeBy*=-1.0;
PageItem *currItem = doc->m_Selection->itemAt(0);
switch (doc->appMode)
{
case modeNormal:
switch (kk)
{
case Qt::Key_Backspace:
case Qt::Key_Delete:
doc->itemSelection_DeleteItem();
break;
case Qt::Key_Prior:
if (!currItem->locked())
{
view->RaiseItem();
}
break;
case Qt::Key_Next:
if (!currItem->locked())
{
view->LowerItem();
}
break;
case Qt::Key_Left:
if (!currItem->locked())
{
if (!resizing)
{
if ((doc->EditClip) && (view->ClRe != -1))
{
FPoint np;
if (view->EditContour)
np = currItem->ContourLine.point(view->ClRe);
else
np = currItem->PoLine.point(view->ClRe);
np = np - FPoint(moveBy, 0);
view->MoveClipPoint(currItem, np);
}
else
{
/* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
/* as the user might be trying to fine tune a position */
bool sav1 = doc->SnapGuides;
bool sav2 = doc->useRaster;
doc->SnapGuides = false;
doc->useRaster = false;
view->moveGroup(-moveBy, 0);
doc->SnapGuides = sav1;
doc->useRaster = sav2;
}
}
else
{
//CB If in EditContour mode, allow contour line to be scaled with arrow keys too
if(view->EditContour)
view->TransformPoly(10, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
else
{
if (resizingsmaller)
{
currItem->Sizing = false;
doc->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
}
else
{
doc->MoveItem(-resizeBy, 0, currItem, false);
currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
currItem->Sizing = false;
doc->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
}
}
}
view->updateContents();
slotDocCh();
}
break;
case Qt::Key_Right:
if (!currItem->locked())
{
if (!resizing)
{
if ((doc->EditClip) && (view->ClRe != -1))
{
FPoint np;
if (view->EditContour)
np = currItem->ContourLine.point(view->ClRe);
else
np = currItem->PoLine.point(view->ClRe);
np = np + FPoint(moveBy, 0);
view->MoveClipPoint(currItem, np);
}
else
{
/* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
/* as the user might be trying to fine tune a position */
bool sav1 = doc->SnapGuides;
bool sav2 = doc->useRaster;
doc->SnapGuides = false;
doc->useRaster = false;
view->moveGroup(moveBy, 0);
doc->SnapGuides = sav1;
doc->useRaster = sav2;
}
}
else
{
//CB If in EditContour mode, allow contour line to be scaled with arrow keys too
if(view->EditContour)
view->TransformPoly(11, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
else
{
if (resizingsmaller)
{
doc->MoveItem(-resizeBy, 0, currItem, false);
currItem->moveImageXYOffsetBy(resizeBy/currItem->imageXScale(), 0);
currItem->Sizing = false;
doc->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
}
else
{
currItem->Sizing = false;
doc->SizeItem(currItem->width()+resizeBy, currItem->height(), currItem->ItemNr, true);
}
}
}
view->updateContents();
slotDocCh();
}
break;
case Qt::Key_Up:
if (!currItem->locked())
{
if (!resizing)
{
if ((doc->EditClip) && (view->ClRe != -1))
{
FPoint np;
if (view->EditContour)
np = currItem->ContourLine.point(view->ClRe);
else
np = currItem->PoLine.point(view->ClRe);
np = np - FPoint(0, moveBy);
view->MoveClipPoint(currItem, np);
}
else
{
/* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
/* as the user might be trying to fine tune a position */
bool sav1 = doc->SnapGuides;
bool sav2 = doc->useRaster;
doc->SnapGuides = false;
doc->useRaster = false;
view->moveGroup(0, -moveBy);
doc->SnapGuides = sav1;
doc->useRaster = sav2;
}
}
else
{
//CB If in EditContour mode, allow contour line to be scaled with arrow keys too
if(view->EditContour)
view->TransformPoly(12, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
else
{
if (resizingsmaller)
{
currItem->Sizing = false;
doc->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
}
else
{
doc->MoveItem(0, -resizeBy, currItem, false);
currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
currItem->Sizing = false;
doc->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
}
}
}
view->updateContents();
slotDocCh();
}
break;
case Qt::Key_Down:
if (!currItem->locked())
{
if (!resizing)
{
if ((doc->EditClip) && (view->ClRe != -1))
{
FPoint np;
if (view->EditContour)
np = currItem->ContourLine.point(view->ClRe);
else
np = currItem->PoLine.point(view->ClRe);
np = np + FPoint(0, moveBy);
view->MoveClipPoint(currItem, np);
}
else
{
/* Don't use Grid or Guide Snapping when dragging Items or Groups with the keyboard */
/* as the user might be trying to fine tune a position */
bool sav1 = doc->SnapGuides;
bool sav2 = doc->useRaster;
doc->SnapGuides = false;
doc->useRaster = false;
view->moveGroup(0, moveBy);
doc->SnapGuides = sav1;
doc->useRaster = sav2;
}
}
else
{
//CB If in EditContour mode, allow contour line to be scaled with arrow keys too
if(view->EditContour)
view->TransformPoly(13, 0, resizeBy/unitGetRatioFromIndex(doc->unitIndex()));
else
{
if (resizingsmaller)
{
doc->MoveItem(0, -resizeBy, currItem, false);
currItem->moveImageXYOffsetBy(0, resizeBy/currItem->imageYScale());
currItem->Sizing = false;
doc->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
}
else
{
currItem->Sizing = false;
doc->SizeItem(currItem->width(), currItem->height()+resizeBy, currItem->ItemNr, true);
}
}
}
view->updateContents();
slotDocCh();
}
break;
default:
break;
}
break;
case modeEdit:
if (currItem->asImageFrame() && !currItem->locked())
{
currItem->handleModeEditKey(k, keyrep);
/*
double dX=0.0,dY=0.0;
switch (kk)
{
case Qt::Key_Left:
dX=-moveBy;
break;
case Qt::Key_Right:
dX=moveBy;
break;
case Qt::Key_Up:
dY=-moveBy;
break;
case Qt::Key_Down:
dY=moveBy;
break;
}
if (dX!=0.0 || dY!=0.0)
{
currItem->moveImageInFrame(dX, dY);
view->updateContents(currItem->getRedrawBounding(view->scale()));
}*/
}
view->oldCp = currItem->CPos;
if (currItem->itemType() == PageItem::TextFrame)
{
bool kr=keyrep;
currItem->handleModeEditKey(k, keyrep);
keyrep=kr;
}
slotDocCh(false);
break;
}
}
}
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)
{
if (HaveDoc && (k->state() & Qt::ControlButton))
{
if ((doc->appMode == modePanning) && (k->state() & Qt::RightButton))
setAppMode(modeNormal);
}
if (HaveDoc)
{
if (doc->appMode == modeMagnifier)
qApp->changeOverrideCursor(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()))
{
uint docSelectionCount=doc->m_Selection->count();
if ((docSelectionCount != 0) && (doc->appMode == modeNormal) && (doc->EditClip) && (view->ClRe != -1))
view->updateContents();
for (uint i = 0; i < docSelectionCount; ++i)
doc->m_Selection->itemAt(i)->checkChanges(true);
if (docSelectionCount > 1 && view->groupTransactionStarted())
undoManager->commit();
}
break;
}
}
void ScribusMainWindow::closeEvent(QCloseEvent *ce)
{
QWidgetList windows = wsp->windowList();
ScribusWin* tw;
disconnect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
if (!windows.isEmpty())
{
uint windowCount=windows.count();
for ( uint i = 0; i < windowCount; ++i )
{
newActWin(windows.at(i));
tw = ActWin;
slotSelect();
ActWin->close();
if (tw == ActWin)
{
ce->ignore();
connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
return;
}
}
}
propertiesPalette->hide();
outlinePalette->hide();
scrapbookPalette->hide();
bookmarkPalette->hide();
layerPalette->hide();
pagePalette->hide();
measurementPalette->hide();
docCheckerPalette->hide();
undoPalette->hide();
alignDistributePalette->hide();
guidePalette->hide();
charPalette->hide();
// Clean up plugins, THEN save prefs to disk
ScCore->pluginManager->cleanupPlugins();
if (!prefsManager->appPrefs.persistentScrapbook)
scrapbookPalette->CleanUpTemp();
prefsManager->appPrefs.RecentScrapbooks.clear();
prefsManager->appPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
if (!emergencyActivated)
prefsManager->SavePrefs();
UndoManager::deleteInstance();
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
exit(0);
}
/////////////////////////////////////////////////////////////////////
// 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);
if (dia->exec())
{
if (dia->tabSelected == 0)
{
int facingPages = dia->choosenLayout;
int firstPage = dia->firstPage->currentItem();
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->Dist;
double pageWidth = dia->pageWidth;
double pageHeight = dia->pageHeight;
double numberCols = dia->numberOfCols->value();
bool autoframes = dia->autoTextFrame->isChecked();
int orientation = dia->Orient;
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->currentItem(), firstPage, orientation, 1, pagesize, true, pageCount);
doc->pageSets[facingPages].FirstPage = firstPage;
doc->bleeds.Bottom = dia->bleedBottom;
doc->bleeds.Top = dia->bleedTop;
doc->bleeds.Left = dia->bleedLeft;
doc->bleeds.Right = dia->bleedRight;
HaveNewDoc();
}
else
{
if (dia->tabSelected == 1)
{
QString fileName(dia->fileDialog->selectedFile());
if (!fileName.isEmpty())
{
docContext->set("docsopen", fileName.left(fileName.findRev("/")));
loadDoc(fileName);
}
}
else
{
QString fileName(dia->recentDocListBox->currentText());
if (!fileName.isEmpty())
loadRecent(ScPaths::separatorsToSlashes(fileName));
}
}
}
prefsManager->setShowStartupDialog(!dia->startUpDialog->isChecked());
delete dia;
mainWindowStatusLabel->setText( tr("Ready"));
if (docSet)
slotDocSetup();
}
bool ScribusMainWindow::slotFileNew()
{
if (HaveDoc && doc->EditClip)
ToggleFrameEdit();
bool retVal = false;
bool docSet = false;
NewDoc* dia = new NewDoc(this, RecentDocs);
if (dia->exec())
{
int facingPages = dia->choosenLayout;
int firstPage = dia->firstPage->currentItem();
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->Dist;
double pageWidth = dia->pageWidth;
double pageHeight = dia->pageHeight;
double numberCols = dia->numberOfCols->value();
bool autoframes = dia->autoTextFrame->isChecked();
int orientation = dia->Orient;
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->currentItem(), firstPage, orientation, 1, pagesize, true, pageCount))
{
doc->pageSets[facingPages].FirstPage = firstPage;
doc->bleeds.Bottom = dia->bleedBottom;
doc->bleeds.Top = dia->bleedTop;
doc->bleeds.Left = dia->bleedLeft;
doc->bleeds.Right = dia->bleedRight;
mainWindowStatusLabel->setText( tr("Ready"));
HaveNewDoc();
retVal = true;
}
}
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)
{
return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView);
/* TODO CB finish later this week.
if (HaveDoc)
doc->OpenNodes = outlinePalette->buildReopenVals();
MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
QString newDocName(tr("Document")+"-"+QString::number(DocNr));
doc = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
doc->setLoading(true);
doc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
HaveDoc++;
DocNr++;
if (ScCore->haveCMS() && doc->CMSSettings.CMSinUse)
recalcColors();
//CB NOTE should be all done now
doc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement);
doc->setMasterPageMode(false);
doc->addMasterPage(0, CommonStrings::masterPageNormal);
int createCount=qMax(pageCount,1);
for (int i = 0; i < createCount; ++i)
doc->addPage(i, CommonStrings::masterPageNormal, true);
doc->addSection();
doc->setFirstSectionFromFirstPageNumber();
doc->setModified(false);
doc->OpenNodes.clear();
actionManager->disconnectNewDocActions();
actionManager->connectNewDocActions(doc);
//<<View and window code
ScribusWin* w = new ScribusWin(wsp, doc);
w->setMainWindow(this);
if (view!=NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
}
view = new ScribusView(w, this, doc);
doc->setCurrentPage(doc->Pages->at(0));
doc->setGUI(this, view);
doc->setLoading(false);
//run after setGUI to set up guidepalette ok
view->setScale(prefsManager->displayScale());
actionManager->connectNewViewActions(view);
alignDistributePalette->setDoc(doc);
docCheckerPalette->clearErrorList();
w->setView(view);
ActWin = w;
doc->WinHan = w;
w->setCentralWidget(view);
doc->connectDocSignals(); //Must be before the first reformpages
view->reformPages(true);
//>>
connect(undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
//connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
connect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
// connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
//Independent finishing tasks after doc setup
if (showView)
{
if ( wsp->windowList().isEmpty() )
w->showMaximized();
else
w->show();
view->show();
}
connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), doc, SLOT(updatePict(QString)));
connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), doc, SLOT(removePict(QString)));
scrActions["fileSave"]->setEnabled(false);
undoManager->switchStack(doc->DocName);
styleManager->currentDoc(doc);
tocGenerator->setDoc(doc);
return doc;
*/
}
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)
{
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 = new ScribusDoc(newDocName, unitindex, pagesize, margins, pagesSetup);
tempDoc->setLoading(true);
outlinePalette->setDoc(tempDoc);
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->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
QWorkspace* qwsp=0;
if (requiresGUI)
qwsp=wsp;
ScribusWin* w = new ScribusWin(qwsp, tempDoc);
w->setMainWindow(this);
if (requiresGUI && view!=NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
}
ScribusView* tempView = new ScribusView(w, this, tempDoc);
if (requiresGUI)
view = tempView;
tempDoc->setCurrentPage(tempDoc->Pages->at(0));
tempDoc->setGUI(requiresGUI, this, tempView);
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();
}
w->setView(tempView);
ActWin = w;
tempDoc->WinHan = w;
w->setCentralWidget(tempView);
if (requiresGUI)
tempDoc->connectDocSignals(); //Must be before the first reformpages
tempView->reformPages(true);
//>>
if (requiresGUI)
{
wsp->addWindow(w);
connect(undoManager, SIGNAL(undoRedoDone()), tempView, SLOT(DrawNew()));
//connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
connect(tempView, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
// connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
}
//Independent finishing tasks after tempDoc setup
if (showView)
{
if ( wsp->windowList().isEmpty() )
w->showMaximized();
else
w->show();
tempView->show();
}
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)));
//scrActions["fileSave"]->setEnabled(false);
tempView->cmsToolbarButton->setOn(tempDoc->HasCMS);
undoManager->switchStack(tempDoc->DocName);
styleManager->setDoc(tempDoc);
tocGenerator->setDoc(tempDoc);
}
undoManager->setUndoEnabled(true);
return tempDoc;
}
void ScribusMainWindow::newView()
{
ScribusWin* w = new ScribusWin(wsp, 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();
//connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
}
void ScribusMainWindow::fontMenuAboutToShow()
{
/* Qt4
QString df;
if (doc->m_Selection->count() != 0)
{
PageItem *currItem = doc->m_Selection->itemAt(0);
FontSub->RebuildList(doc, currItem->isAnnotation());
}
FontSub->setCurrentText(currentFontForFontMenu);
//propertiesPalette->Fonts->setCurrentFont(nf);
for (uint a = 2; a < FontMenu->count(); ++a)
{
df = FontID[FontMenu->idAt(a)];
FontMenu->setItemChecked(FontMenu->idAt(a), (df == currentFontForFontMenu));
}
*/
}
void ScribusMainWindow::windowsMenuAboutToShow()
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrWindowsActions.begin(); it!=scrWindowsActions.end(); ++it )
scrMenuMgr->removeMenuItem((*it), "Windows");
scrWindowsActions.clear();
addDefaultWindowMenuItems();
QWidgetList windows = wsp->windowList();
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)->caption();
scrWindowsActions.insert(docInWindow, new ScrAction( ScrAction::Window, QPixmap(), QPixmap(), docInWindow, QKeySequence(), this, docInWindow, i));
scrWindowsActions[docInWindow]->setToggleAction(true);
connect( scrWindowsActions[docInWindow], SIGNAL(activatedData(int)), this, SLOT(windowsMenuActivated(int)) );
if (windowCount>1)
scrMenuMgr->addMenuItem(scrWindowsActions[docInWindow], "Windows");
scrWindowsActions[docInWindow]->setOn(wsp->activeWindow() == windows.at(i));
}
}
}
void ScribusMainWindow::newActWin(QWidget *w)
{
if (w == NULL)
{
ActWin = NULL;
return;
}
if (doc!=0 && doc->EditClip)
ToggleFrameEdit();
ScribusWin* scw = (ScribusWin*)w;
if (scw && scw->doc())
if (!scw->doc()->hasGUI())
return;
ActWin = scw;
if (ActWin->doc()==NULL)
return;
if (doc != NULL)
{
if ((HaveDoc) && (doc != ActWin->doc()))
outlinePalette->buildReopenVals();
}
docCheckerPalette->clearErrorList();
doc = ActWin->doc();
undoManager->switchStack(doc->DocName);
if (view!=NULL)
{
actionManager->disconnectNewViewActions();
disconnect(view, SIGNAL(signalGuideInformation(int, double)), alignDistributePalette, SLOT(setGuide(int, double)));
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, double)), alignDistributePalette, SLOT(setGuide(int, double)));
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())
{
scanDocument();
docCheckerPalette->buildErrorList(doc);
SwitchWin();
QWidgetList windows = wsp->windowList();
ScribusWin* swin;
for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
{
swin = (ScribusWin*)windows.at(i);
if (swin==ActWin && doc->masterPageMode())
swin->setMasterPagesPaletteShown(true);
else
swin->setMasterPagesPaletteShown(false);
}
//if (doc->masterPageMode())
// ActWin->setMasterPagesPaletteShown(true);
setAppMode(doc->appMode);
}
w->setFocus();
wsp->setScrollBarsEnabled(!(w->isMaximized()));
scrActions["viewShowMargins"]->setOn(doc->guidesSettings.marginsShown);
scrActions["viewShowBleeds"]->setOn(doc->guidesSettings.showBleed);
scrActions["viewShowFrames"]->setOn(doc->guidesSettings.framesShown);
scrActions["viewShowLayerMarkers"]->setOn(doc->guidesSettings.layerMarkersShown);
scrActions["viewShowGrid"]->setOn(doc->guidesSettings.gridShown);
scrActions["viewShowGuides"]->setOn(doc->guidesSettings.guidesShown);
scrActions["viewShowColumnBorders"]->setOn(doc->guidesSettings.colBordersShown);
scrActions["viewShowBaseline"]->setOn(doc->guidesSettings.baseShown);
scrActions["viewShowImages"]->setOn(doc->guidesSettings.showPic);
scrActions["viewShowTextChain"]->setOn(doc->guidesSettings.linkShown);
scrActions["viewShowTextControls"]->setOn(doc->guidesSettings.showControls);
scrActions["viewShowRulers"]->setOn(doc->guidesSettings.rulersShown);
scrActions["viewRulerMode"]->setOn(doc->guidesSettings.rulerMode);
scrActions["extrasGenerateTableOfContents"]->setEnabled(doc->hasTOCSetup());
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);
}
tocGenerator->setDoc(doc);
styleManager->setDoc(doc);
}
void ScribusMainWindow::windowsMenuActivated( int id )
{
QWidget* windowWidget = wsp->windowList().at( id );
if ( windowWidget )
windowWidget->showNormal();
newActWin(windowWidget);
}
void ScribusMainWindow::docSetup(ReformDoc* dia)
{
slotChangeUnit(dia->getSelectedUnit(), false);
dia->updateDocumentSettings();
if (dia->imageResolutionChanged())
{
setStatusBarInfoText( tr("Updating Pictures"));
mainWindowProgressBar->reset();
qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
qApp->processEvents();
doc->recalcPicturesRes(true);
qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
setStatusBarInfoText("");
mainWindowProgressBar->reset();
}
// Qt4
// FontSub->RebuildList(doc);
propertiesPalette->Fonts->RebuildList(doc);
scrActions["viewShowMargins"]->setOn(doc->guidesSettings.marginsShown);
scrActions["viewShowBleeds"]->setOn(doc->guidesSettings.showBleed);
scrActions["viewShowFrames"]->setOn(doc->guidesSettings.framesShown);
scrActions["viewShowLayerMarkers"]->setOn(doc->guidesSettings.layerMarkersShown);
scrActions["viewShowGrid"]->setOn(doc->guidesSettings.gridShown);
scrActions["viewShowGuides"]->setOn(doc->guidesSettings.guidesShown);
scrActions["viewShowColumnBorders"]->setOn(doc->guidesSettings.colBordersShown);
scrActions["viewShowBaseline"]->setOn(doc->guidesSettings.baseShown);
scrActions["viewShowImages"]->setOn(doc->guidesSettings.showPic);
scrActions["viewShowTextChain"]->setOn(doc->guidesSettings.linkShown);
scrActions["viewShowTextControls"]->setOn(doc->guidesSettings.showControls);
scrActions["viewShowRulers"]->setOn(doc->guidesSettings.rulersShown);
scrActions["viewRulerMode"]->setOn(doc->guidesSettings.rulerMode);
scrActions["extrasGenerateTableOfContents"]->setEnabled(doc->hasTOCSetup());
view->cmsToolbarButton->setOn(doc->HasCMS);
//doc emits changed() via this
doc->setMasterPageMode(true);
view->reformPages();
doc->setMasterPageMode(false);
/* doc->setLoading(true);
uint pageCount=doc->DocPages.count();
for (uint c=0; c<pageCount; ++c)
Apply_MasterPage(doc->DocPages.at(c)->MPageNam, c, false);
doc->setLoading(false); */
view->reformPages();
view->GotoPage(doc->currentPage()->pageNr());
view->DrawNew();
propertiesPalette->ShowCMS();
pagePalette->RebuildPage();
}
bool ScribusMainWindow::slotDocSetup()
{
bool ret = false;
ReformDoc* dia = new ReformDoc(this, doc);
Q_CHECK_PTR(dia);
if (dia->exec())
{
docSetup(dia);
ret = true;
}
delete dia;
return ret;
}
void ScribusMainWindow::SwitchWin()
{
//qt4 updateColorMenu();
//Qt4 buildFontMenu();
propertiesPalette->Cpal->ChooseGrad(0);
updateActiveWindowCaption(doc->DocName);
scrActions["shade100"]->setOn(true);
propertiesPalette->setDoc(doc);
pagePalette->setView(view);
// Qt4
// FontSub->RebuildList(doc);
propertiesPalette->Fonts->RebuildList(doc);
layerPalette->setDoc(doc);
guidePalette->setDoc(doc);
charPalette->setDoc(doc);
outlinePalette->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);
if (doc->EditClip)
{
doc->EditClip = !doc->EditClip;
ToggleFrameEdit();
}
scrActions["fileClose"]->setEnabled(true);
if (doc->masterPageMode())
{
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["fileSave"]->setEnabled(true);
scrActions["fileOpen"]->setEnabled(false);
scrActions["fileClose"]->setEnabled(false);
scrActions["fileRevert"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileOpenRecent", false);
pagePalette->enablePalette(false);
}
else
{
scrMenuMgr->setMenuEnabled("Page", true);
scrActions["editMasterPages"]->setEnabled(true);
scrActions["fileNew"]->setEnabled(true);
scrActions["fileOpen"]->setEnabled(true);
scrActions["fileClose"]->setEnabled(true);
scrActions["fileSave"]->setEnabled(true);
//CB TODO Huh? Why different to the above?, fileMenu->setItemEnabled(M_FileSave, ActWin->MenuStat[2]);
scrActions["fileSaveAs"]->setEnabled(ActWin->menuStatus(3));
scrActions["fileCollect"]->setEnabled(ActWin->menuStatus(3));
scrActions["fileRevert"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("FileOpenRecent", true);
if (doc->isModified())
slotDocCh(false);
else
{
bool setter = doc->Pages->count() > 1 ? true : false;
scrActions["pageDelete"]->setEnabled(setter);
scrActions["pageMove"]->setEnabled(setter);
}
scrActions["fileSaveAs"]->setEnabled(true);
scrActions["fileCollect"]->setEnabled(true);
pagePalette->enablePalette(true);
}
}
void ScribusMainWindow::HaveNewDoc()
{
scrActions["filePrint"]->setEnabled(true);
scrActions["fileSave"]->setEnabled(true);
scrActions["fileClose"]->setEnabled(true);
scrActions["fileDocSetup"]->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()==0 || ScCore->isWinGUI() )
scrActions["PrintPreview"]->setEnabled(true);
if (scrActions["SaveAsDocumentTemplate"])
scrActions["SaveAsDocumentTemplate"]->setEnabled(true);
scrActions["editCut"]->setEnabled(false);
scrActions["editCopy"]->setEnabled(false);
scrActions["editPaste"]->setEnabled((!Buffer2.isEmpty()) || (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["editDeselectAll"]->setEnabled(false);
scrActions["editPatterns"]->setEnabled(true);
scrActions["editStyles"]->setEnabled(true);
scrActions["editMasterPages"]->setEnabled(true);
scrActions["editJavascripts"]->setEnabled(true);
scrMenuMgr->setMenuEnabled("View", true);
scrActions["viewSnapToGrid"]->setOn(doc->useRaster);
scrActions["viewSnapToGuides"]->setOn(doc->SnapGuides);
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["toolsInsertTableFrame"]->setEnabled(true);
scrActions["toolsInsertShape"]->setEnabled(true);
scrActions["toolsInsertLine"]->setEnabled(true);
scrActions["toolsInsertBezier"]->setEnabled(true);
scrActions["toolsInsertFreehandLine"]->setEnabled(true);
scrActions["toolsInsertPolygon"]->setEnabled(true);
scrActions["toolsMeasurements"]->setEnabled(true);
scrActions["toolsEyeDropper"]->setEnabled(true);
scrActions["toolsPDFPushButton"]->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);
bool setter = doc->Pages->count() > 1 ? true : false;
scrActions["pageDelete"]->setEnabled(setter);
scrActions["pageMove"]->setEnabled(setter);
//qt4 updateColorMenu();
//Update palettes
updateActiveWindowCaption(doc->DocName);
scrActions["shade100"]->setOn(true);
propertiesPalette->setDoc(doc);
propertiesPalette->Cpal->ChooseGrad(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());
//Qt4 buildFontMenu();
windowsMenuAboutToShow();
connect(view, SIGNAL(changeUN(int)), this, SLOT(slotChangeUnit(int)));
connect(view, SIGNAL(changeLA(int)), layerPalette, SLOT(markActiveLayer(int)));
connect(view->horizRuler, SIGNAL(MarkerMoved(double, double)), this, SLOT(setStatusBarMousePosition(double, double)));
connect(view->horizRuler, SIGNAL(DocChanged(bool)), this, SLOT(slotDocCh(bool)));
connect(view, SIGNAL(ClipPo(double, double)), nodePalette, SLOT(SetXY(double, double)));
connect(view, SIGNAL(PolyOpen()), nodePalette, SLOT(IsOpen()));
connect(view, SIGNAL(PStatus(int, uint)), nodePalette, SLOT(PolyStatus(int, uint)));
connect(view, SIGNAL(ItemPos(double, double)), propertiesPalette, SLOT(setXY(double, double)));
connect(view, SIGNAL(ItemGeom(double, double)), propertiesPalette, SLOT(setBH(double, double)));
connect(view, SIGNAL(ChBMText(PageItem *)), this, SLOT(BookMarkTxT(PageItem *)));
connect(view, SIGNAL(HaveSel(int)), this, SLOT(HaveNewSel(int)));
connect(view, SIGNAL(SetAngle(double)), propertiesPalette, SLOT(setR(double)));
connect(view, SIGNAL(SetSizeValue(double)), propertiesPalette, SLOT(setSvalue(double)));
connect(view, SIGNAL(SetLocalValues(double, double, double, double)), propertiesPalette, SLOT(setLvalue(double, double, double, double)));
connect(view, SIGNAL(SetLineArt(Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle)), propertiesPalette, SLOT( setLIvalue(Qt::PenStyle, Qt::PenCapStyle, Qt::PenJoinStyle)));
// connect(view, SIGNAL(ItemFarben(QString, QString, int, int)), this, SLOT(setCSMenu(QString, QString, int, int)));
// connect(view, SIGNAL(ItemFarben(QString, QString, int, int)), propertiesPalette->Cpal, SLOT(setActFarben(QString, QString, int, int)));
// connect(view, SIGNAL(ItemGradient(int)), propertiesPalette->Cpal, SLOT(setActGradient(int)));
// connect(view, SIGNAL(ItemTrans(double, double)), propertiesPalette->Cpal, SLOT(setActTrans(double, double)));
// connect(view, SIGNAL(ItemBlend(int, int)), propertiesPalette->Cpal, SLOT(setActBlend(int, int)));
connect(view, SIGNAL(ItemTextAttr(double)), propertiesPalette, SLOT(setLsp(double)));
connect(view, SIGNAL(ItemTextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
// connect(view, SIGNAL(ItemTextCols(int, double)), propertiesPalette, SLOT(setCols(int, double)));
connect(view, SIGNAL(SetDistValues(double, double, double, double)), propertiesPalette, SLOT(setDvals(double, double, double, double)));
connect(view, SIGNAL(ItemTextAbs(int)), propertiesPalette, SLOT(setAli(int)));
//Qt4 connect(view, SIGNAL(ItemTextFont(const QString&)), this, SLOT(AdjustFontMenu(const QString&)));
connect(view, SIGNAL(ItemTextFont(const QString&)), propertiesPalette, SLOT(setFontFace(const QString&)));
connect(view, SIGNAL(ItemTextSize(int)), propertiesPalette, SLOT(setSize(int)));
//connect(view, SIGNAL(ItemRadius(double)), propertiesPalette, SLOT(setRR(double)));
connect(view, SIGNAL(Amode(int)), this, SLOT(setAppMode(int)));
connect(view, SIGNAL(PaintingDone()), this, SLOT(slotSelect()));
connect(view, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
//connect(view, SIGNAL(HavePoint(bool, bool)), nodePalette, SLOT(HaveNode(bool, bool)));
connect(view, SIGNAL(MousePos(double, double)), this, SLOT(setStatusBarMousePosition(double, double)));
//connect(view, SIGNAL(ItemRadius(double)), propertiesPalette, SLOT(setRR(double)));
connect(view, SIGNAL(ItemTextStil(int)), propertiesPalette, SLOT(setStil(int)));
connect(view, SIGNAL(ItemTextSca(int)), propertiesPalette, SLOT(setTScale(int)));
connect(view, SIGNAL(ItemTextScaV(int)), propertiesPalette, SLOT(setTScaleV(int)));
connect(view, SIGNAL(ItemTextBase(int)), propertiesPalette, SLOT(setTBase(int)));
connect(view, SIGNAL(ItemTextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
connect(view, SIGNAL(ItemTextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
connect(view, SIGNAL(ItemTextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
connect(view, SIGNAL(ItemTextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
connect(view, SIGNAL(ItemTextSize(int)), this, SLOT(setFSizeMenu(int)));
connect(view, SIGNAL(ItemTextStil(int)), this, SLOT(setStilvalue(int)));
connect(view, SIGNAL(ItemTextAbs(int)), this, SLOT(setAbsValue(int)));
connect(view, SIGNAL(ItemTextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
connect(view, SIGNAL(HasTextSel()), this, SLOT(EnableTxEdit()));
connect(view, SIGNAL(HasNoTextSel()), this, SLOT(DisableTxEdit()));
connect(view, SIGNAL(CopyItem()), this, SLOT(slotEditCopy()));
connect(view, SIGNAL(CutItem()), this, SLOT(slotEditCut()));
connect(view, SIGNAL(LoadPic()), this, SLOT(slotGetContent()));
connect(view, SIGNAL(AppendText()), this, SLOT(slotFileAppend()));
connect(view, SIGNAL(AnnotProps()), this, SLOT(ModifyAnnot()));
//connect(view, SIGNAL(EditGuides()), this, SLOT(ManageGuides()));
connect(view, SIGNAL(LoadElem(QString, double ,double, bool, bool, ScribusDoc *, ScribusView*)), this, SLOT(slotElemRead(QString, double, double, bool, bool, ScribusDoc *, ScribusView*)));
connect(view, SIGNAL(AddBM(PageItem *)), this, SLOT(AddBookMark(PageItem *)));
connect(view, SIGNAL(DelBM(PageItem *)), this, SLOT(DelBookMark(PageItem *)));
connect(view, SIGNAL(RasterPic(bool)), this, SLOT(HaveRaster(bool)));
connect(view, SIGNAL(DoGroup()), this, SLOT(GroupObj()));
connect(view, SIGNAL(EndNodeEdit()), this, SLOT(ToggleFrameEdit()));
connect(view, SIGNAL(LevelChanged(uint )), propertiesPalette, SLOT(setLevel(uint)));
connect(view, SIGNAL(callGimp()), this, SLOT(callImageEditor()));
}
void ScribusMainWindow::HaveNewSel(int Nr)
{
PageItem *currItem = NULL;
if (Nr != -1)
{
if (doc->m_Selection->count() != 0)
{
uint lowestItem = 999999;
for (uint a=0; a<doc->m_Selection->count(); ++a)
{
currItem = doc->m_Selection->itemAt(a);
lowestItem = qMin(lowestItem, currItem->ItemNr);
}
currItem = doc->Items->at(lowestItem);
// doc->m_Selection->removeItem(currItem);
// doc->m_Selection->prependItem(currItem);
// currItem = doc->m_Selection->itemAt(0);
if (!currItem)
Nr=-1;
}
else
Nr = -1;
}
actionManager->disconnectNewSelectionActions();
scrActions["editDeselectAll"]->setEnabled(Nr!=-1);
scrActions["itemDetachTextFromPath"]->setEnabled(false);
charPalette->setEnabled(false, 0);
scrActions["itemUpdateImage"]->setEnabled(Nr==PageItem::ImageFrame && currItem->PicAvail);
scrActions["itemAdjustFrameToImage"]->setEnabled(Nr==PageItem::ImageFrame && currItem->PicAvail && !currItem->isTableItem);
scrActions["itemExtendedImageProperties"]->setEnabled(Nr==PageItem::ImageFrame && currItem->PicAvail && currItem->pixm.imgInfo.valid);
scrMenuMgr->setMenuEnabled("ItemPreviewSettings", Nr==PageItem::ImageFrame);
scrActions["itemImageIsVisible"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["itemPreviewLow"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["itemPreviewNormal"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["itemPreviewFull"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["styleImageEffects"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["editCopyContents"]->setEnabled(Nr==PageItem::ImageFrame && currItem->PicAvail);
scrActions["editPasteContents"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["editPasteContentsAbs"]->setEnabled(Nr==PageItem::ImageFrame);
scrActions["editEditWithImageEditor"]->setEnabled(Nr==PageItem::ImageFrame && currItem->PicAvail && currItem->isRaster);
if (Nr!=PageItem::ImageFrame)
{
scrActions["itemImageIsVisible"]->setOn(false);
scrActions["itemPreviewLow"]->setOn(false);
scrActions["itemPreviewNormal"]->setOn(false);
scrActions["itemPreviewFull"]->setOn(false);
}
if ((Nr==-1) || (Nr!=-1 && !currItem->asTextFrame()))
enableTextActions(&scrActions, false);
scrActions["insertSampleText"]->setEnabled(false);
view->horizRuler->ItemPosValid = false;
view->horizRuler->repaint();
switch (Nr)
{
case -1: // None
scrActions["fileImportText"]->setEnabled(false);
scrActions["fileImportText2"]->setEnabled(false);
scrActions["fileImportImage"]->setEnabled(false);
scrActions["fileImportAppendText"]->setEnabled(false);
scrActions["fileExportText"]->setEnabled(false);
scrMenuMgr->setMenuEnabled("Item", false);
scrMenuMgr->setMenuEnabled("ItemShapes", false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->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["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(), -1);
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);
scrMenuMgr->setMenuEnabled("Item", true);
scrMenuMgr->setMenuEnabled("ItemShapes", !(currItem->isTableItem && currItem->isSingleSel));
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(!currItem->isTableItem && doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["toolsUnlinkTextFrame"]->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"]->setOn(currItem->imageShown());
scrActions["itemPreviewLow"]->setOn(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewLow"]->actionInt());
scrActions["itemPreviewNormal"]->setOn(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewNormal"]->actionInt());
scrActions["itemPreviewFull"]->setOn(currItem->pixm.imgInfo.lowResType==scrActions["itemPreviewFull"]->actionInt());
break;
case PageItem::TextFrame: //Text Frame
// FontSub->RebuildList(doc, currItem->isAnnotation());
propertiesPalette->Fonts->RebuildList(doc, currItem->isAnnotation());
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(currItem->itemText.length() != 0);
scrActions["extrasDeHyphenateText"]->setEnabled(currItem->itemText.length() != 0);
scrMenuMgr->setMenuEnabled("Item", true);
scrMenuMgr->setMenuEnabled("ItemShapes", !(currItem->isTableItem && currItem->isSingleSel));
scrMenuMgr->setMenuEnabled("ItemConvertTo", true);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(doc->appMode != modeEdit);
scrActions["itemConvertToOutlines"]->setEnabled(!currItem->isTableItem && doc->appMode != modeEdit);
scrActions["itemConvertToPolygon"]->setEnabled(!currItem->isTableItem && doc->appMode != modeEdit);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["toolsRotate"]->setEnabled(true);
scrActions["toolsCopyProperties"]->setEnabled(true);
scrActions["toolsEditWithStoryEditor"]->setEnabled(true);
scrActions["insertSampleText"]->setEnabled(true);
if ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0))
{
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
// scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->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);
}
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);
charPalette->setEnabled(true, currItem);
if (currItem->asTextFrame())
enableTextActions(&scrActions, true, currItem->currentStyle().charStyle().font().scName());
view->horizRuler->setItem(currItem);
if (currItem->lineColor() != CommonStrings::None)
view->horizRuler->lineCorr = currItem->lineWidth() / 2.0;
else
view->horizRuler->lineCorr = 0;
view->horizRuler->ColGap = currItem->ColGap;
view->horizRuler->Cols = currItem->Cols;
view->horizRuler->Extra = currItem->textToFrameDistLeft();
view->horizRuler->RExtra = currItem->textToFrameDistRight();
view->horizRuler->First = currItem->currentStyle().firstIndent();
view->horizRuler->Indent = currItem->currentStyle().leftMargin();
double columnWidth = (currItem->width() - (currItem->columnGap() * (currItem->columns() - 1))
- currItem->textToFrameDistLeft() - currItem->textToFrameDistLeft()
- 2*view->horizRuler->lineCorr) / currItem->columns();
view->horizRuler->RMargin = columnWidth - currItem->currentStyle().rightMargin();
if (currItem->imageFlippedH() || (currItem->reversed()))
view->horizRuler->Revers = true;
else
view->horizRuler->Revers = false;
view->horizRuler->ItemPosValid = true;
view->horizRuler->TabValues = currItem->currentStyle().tabValues();
view->horizRuler->repaint();
}
else
{
doc->currentStyle = currItem->itemText.defaultStyle();
emit TextStyle(doc->currentStyle);
// to go: (av)
emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
emit TextFarben(doc->currentStyle.charStyle().strokeColor(), doc->currentStyle.charStyle().fillColor(), doc->currentStyle.charStyle().strokeShade(), doc->currentStyle.charStyle().fillShade());
emit TextScale(doc->currentStyle.charStyle().scaleH());
emit TextScaleV(doc->currentStyle.charStyle().scaleV());
emit TextBase(doc->currentStyle.charStyle().baselineOffset());
emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
// emit TextStil(doc->currentStyle.charStyle().effects());
setStilvalue(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::PathText: //Path Text
// FontSub->RebuildList(doc, currItem->isAnnotation());
propertiesPalette->Fonts->RebuildList(doc, currItem->isAnnotation());
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);
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["toolsRotate"]->setEnabled(true);
scrActions["toolsCopyProperties"]->setEnabled(true);
scrActions["toolsEditContents"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(true);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
if (doc->appMode == modeEdit)
setTBvals(currItem);
else
{
doc->currentStyle = currItem->itemText.defaultStyle();
emit TextStyle(doc->currentStyle);
// to go: (av)
emit TextStrike(doc->currentStyle.charStyle().strikethruOffset(), doc->currentStyle.charStyle().strikethruWidth());
emit TextUnderline(doc->currentStyle.charStyle().underlineOffset(), doc->currentStyle.charStyle().underlineWidth());
emit TextShadow(doc->currentStyle.charStyle().shadowXOffset(), doc->currentStyle.charStyle().shadowYOffset());
emit TextFarben(doc->currentStyle.charStyle().strokeColor(), doc->currentStyle.charStyle().fillColor(), doc->currentStyle.charStyle().strokeShade(), doc->currentStyle.charStyle().fillShade());
emit TextScale(doc->currentStyle.charStyle().scaleH());
emit TextScaleV(doc->currentStyle.charStyle().scaleV());
emit TextBase(doc->currentStyle.charStyle().baselineOffset());
emit TextOutline(doc->currentStyle.charStyle().outlineWidth());
// emit TextStil(doc->currentStyle.charStyle().effects());
setStilvalue(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);
if (Nr == 6) //Polygon
{
scrMenuMgr->setMenuEnabled("ItemShapes", true);
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["toolsEditContents"]->setEnabled(false);
scrActions["toolsEditWithStoryEditor"]->setEnabled(false);
scrActions["toolsUnlinkTextFrame"]->setEnabled(false);
scrActions["toolsLinkTextFrame"]->setEnabled(false);
// if (Nr != 5)
scrActions["toolsRotate"]->setEnabled(true);
// else
// scrActions["toolsRotate"]->setEnabled(false);
scrActions["toolsCopyProperties"]->setEnabled(true);
break;
}
doc->CurrentSel = Nr;
rebuildStyleMenu(Nr);
propertiesPalette->RotationGroup->setButton(doc->RotMode);
uint docSelectionCount=doc->m_Selection->count();
if (docSelectionCount > 1)
{
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
//scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["editSearchReplace"]->setEnabled(false);
bool hPoly = false;
bool isGroup = true;
int firstElem = -1;
if (currItem->Groups.count() != 0)
firstElem = currItem->Groups.top();
for (uint bx=0; bx<docSelectionCount; ++bx)
{
PageItem* bxi=doc->m_Selection->itemAt(bx);
if ((bxi->asPolygon()) || (bxi->asPolyLine()))
hPoly = true;
if (bxi->Groups.count() != 0)
{
if (bxi->Groups.top() != firstElem)
isGroup = false;
}
else
isGroup = false;
}
scrActions["itemGroup"]->setEnabled(!isGroup);
scrActions["itemCombinePolygons"]->setEnabled(hPoly);
if (docSelectionCount == 2)
{
PageItem* bx=doc->m_Selection->itemAt(1);
if ((currItem->asTextFrame() && (bx->asPolygon() || bx->asPolyLine())) || (bx->asTextFrame() && (currItem->asPolygon() || currItem->asPolyLine())))
{
if ((currItem->nextInChain() == 0) && (currItem->prevInChain() == 0) && (bx->nextInChain() == 0) && (bx->prevInChain() == 0) && (currItem->Groups.count() == 0) && (bx->Groups.count() == 0))
scrActions["itemAttachTextToPath"]->setEnabled(true);
}
}
}
else
{
scrActions["itemGroup"]->setEnabled(false);
scrActions["itemAttachTextToPath"]->setEnabled(false);
scrActions["itemCombinePolygons"]->setEnabled(false);
}
if (docSelectionCount != 0)
{
actionManager->setPDFActions(view);
updateItemLayerList();
//propertiesPalette->textFlowsAroundFrame->setChecked(currItem->textFlowsAroundFrame());
propertiesPalette->setTextFlowMode(currItem->textFlowMode());
scrActions["itemLock"]->setEnabled(true);
scrActions["itemLockSize"]->setEnabled(true);
scrActions["itemPrintingEnabled"]->setEnabled(true);
if (currItem->Groups.count() != 0)
scrActions["itemUngroup"]->setEnabled(true);
else
{
scrActions["itemUngroup"]->setEnabled(false);
scrActions["itemSplitPolygons"]->setEnabled( (currItem->asPolygon()) && (currItem->Segments.count() != 0) );
}
if (currItem->locked())
{
scrMenuMgr->setMenuEnabled("ItemShapes", false);
scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
scrActions["itemConvertToBezierCurve"]->setEnabled(false);
scrActions["itemConvertToImageFrame"]->setEnabled(false);
scrActions["itemConvertToOutlines"]->setEnabled(false);
scrActions["itemConvertToPolygon"]->setEnabled(false);
scrActions["itemConvertToTextFrame"]->setEnabled(false);
scrActions["itemSplitPolygons"]->setEnabled(false);
scrActions["itemAttachTextToPath"]->setEnabled(false);
scrActions["itemDetachTextFromPath"]->setEnabled(false);
scrActions["itemCombinePolygons"]->setEnabled(false);
scrActions["itemDelete"]->setEnabled(false);
scrActions["itemLowerToBottom"]->setEnabled(false);
scrActions["itemRaiseToTop"]->setEnabled(false);
scrActions["itemRaise"]->setEnabled(false);
scrActions["itemLower"]->setEnabled(false);
scrActions["itemSendToScrapbook"]->setEnabled(!(currItem->isTableItem && currItem->isSingleSel));
scrActions["itemSendToPattern"]->setEnabled(!(currItem->isTableItem && currItem->isSingleSel));
scrActions["editCut"]->setEnabled(false);
scrActions["editClearContents"]->setEnabled(false);
scrActions["toolsRotate"]->setEnabled(false);
}
else
{
bool setter=!(currItem->isTableItem && currItem->isSingleSel && currItem->isGroupControl);
scrActions["itemDuplicate"]->setEnabled(setter);
scrActions["itemMulDuplicate"]->setEnabled(setter);
scrActions["itemDelete"]->setEnabled(!currItem->isSingleSel);
scrActions["itemLowerToBottom"]->setEnabled(setter);
scrActions["itemRaiseToTop"]->setEnabled(setter);
scrActions["itemRaise"]->setEnabled(setter);
scrActions["itemLower"]->setEnabled(setter);
scrActions["itemSendToScrapbook"]->setEnabled(setter);
scrActions["itemSendToPattern"]->setEnabled(setter);
}
scrActions["itemLock"]->setOn(currItem->locked());
scrActions["itemLockSize"]->setOn(currItem->sizeLocked());
scrActions["itemPrintingEnabled"]->setOn(currItem->printEnabled());
}
//propertiesPalette->NewSel(Nr);
if (Nr != -1)
{
//propertiesPalette->SetCurItem(currItem);
outlinePalette->slotShowSelect(currItem->OwnPage, currItem->ItemNr);
/*Qt4
if (currItem->FrameType == 0)
SCustom->setPixmap(SCustom->getIconPixmap(0));
if (currItem->FrameType == 1)
SCustom->setPixmap(SCustom->getIconPixmap(1));
if (currItem->FrameType > 3)
SCustom->setPixmap(SCustom->getIconPixmap(currItem->FrameType-2));
*/
actionManager->connectNewSelectionActions(view, doc);
// propertiesPalette->NewSel(Nr);
}
else
propertiesPalette->NewSel(Nr);
}
void ScribusMainWindow::rebuildStyleMenu(int itemType)
{
scrMenuMgr->clearMenu("Style");
int iT=itemType;
if (!HaveDoc)
iT=-1;
if (iT != -1)
{
if (doc->m_Selection->count() == 0)
iT = -1;
else
{
PageItem *currItem = doc->m_Selection->itemAt(0);
if (!currItem)
iT=-1;
}
}
if (iT==PageItem::TextFrame || iT==PageItem::PathText)
{
scrMenuMgr->addMenuToMenu("Font","Style");
scrMenuMgr->addMenuToMenu("FontSize","Style");
scrMenuMgr->addMenuToMenu("TypeEffects","Style");
scrMenuMgr->addMenuToMenu("Alignment","Style");
scrMenuMgr->addMenuToMenu("Color","Style");
scrMenuMgr->addMenuToMenu("Shade","Style");
if (itemType==PageItem::TextFrame)
scrMenuMgr->addMenuItem(scrActions["styleTabulators"], "Style");
scrMenuMgr->setMenuEnabled("Style", true);
}
else
scrMenuMgr->setMenuEnabled("Style", false);
}
void ScribusMainWindow::slotDocCh(bool /*reb*/)
{
if (!doc->isLoading() && docCheckerPalette->isVisible())
{
scanDocument();
docCheckerPalette->buildErrorList(doc);
}
if (!doc->isModified())
doc->setModified(true);
updateActiveWindowCaption(doc->DocName + "*");
// scrActions["fileSave"]->setEnabled(true);
// scrActions["fileSaveAs"]->setEnabled(true);
scrActions["fileCollect"]->setEnabled(true);
if (!doc->masterPageMode())
{
scrActions["fileClose"]->setEnabled(true);
if (doc->hasName)
scrActions["fileRevert"]->setEnabled(true);
bool setter = doc->Pages->count() > 1 ? true : false;
scrActions["pageDelete"]->setEnabled(setter);
scrActions["pageMove"]->setEnabled(setter);
}
ActWin->setMenuStatus(0, scrActions["fileSave"]->isEnabled());
ActWin->setMenuStatus(1, scrActions["fileClose"]->isEnabled());
ActWin->setMenuStatus(2, scrActions["fileSave"]->isEnabled());
ActWin->setMenuStatus(3, scrActions["fileSaveAs"]->isEnabled());
if (outlinePalette->isVisible())
outlinePalette->BuildTree();
}
void ScribusMainWindow::updateRecent(QString fn)
{
if (RecentDocs.findIndex(fn) == -1)
{
RecentDocs.prepend(fn);
ScCore->fileWatcher->addFile(fn);
}
else
{
RecentDocs.remove(fn);
RecentDocs.prepend(fn);
}
rebuildRecentFileMenu();
}
void ScribusMainWindow::removeRecent(QString fn)
{
if (RecentDocs.findIndex(fn) != -1)
{
RecentDocs.remove(fn);
ScCore->fileWatcher->removeFile(fn);
}
rebuildRecentFileMenu();
}
void ScribusMainWindow::loadRecent(QString fn)
{
QFileInfo fd(fn);
if (!fd.exists())
{
removeRecent(fn);
return;
}
loadDoc(fn);
}
void ScribusMainWindow::rebuildRecentFileMenu()
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrRecentFileActions.begin(); it!=scrRecentFileActions.end(); ++it )
scrMenuMgr->removeMenuItem((*it), recentFileMenuName);
scrRecentFileActions.clear();
uint max = qMin(prefsManager->appPrefs.RecentDCount, RecentDocs.count());
QString strippedName, localName;
for (uint m = 0; m < max; ++m)
{
strippedName=RecentDocs[m];
strippedName.remove(QDir::separator());
localName=QDir::convertSeparators(RecentDocs[m]);
scrRecentFileActions.insert(strippedName, new ScrAction(ScrAction::RecentFile, QPixmap(), QPixmap(), QString("&%1 %2").arg(m+1).arg(localName), QKeySequence(), this, strippedName,0,0.0,RecentDocs[m]));
connect( scrRecentFileActions[strippedName], SIGNAL(activatedData(QString)), this, SLOT(loadRecent(QString)) );
scrMenuMgr->addMenuItem(scrRecentFileActions[strippedName], recentFileMenuName);
}
}
void ScribusMainWindow::rebuildRecentPasteMenu()
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrRecentPasteActions.begin(); it!=scrRecentPasteActions.end(); ++it )
scrMenuMgr->removeMenuItem((*it), recentPasteMenuName);
scrRecentPasteActions.clear();
int max = qMin(prefsManager->appPrefs.numScrapbookCopies, scrapbookPalette->tempBView->objectMap.count());
if (max > 0)
{
QMap<QString,BibView::Elem>::Iterator it;
it = scrapbookPalette->tempBView->objectMap.end();
it--;
QString strippedName;
for (int m = 0; m < max; ++m)
{
strippedName = it.key();
QPixmap pm = it.data().Preview;
scrRecentPasteActions.insert(strippedName, new ScrAction(ScrAction::RecentPaste, pm, QPixmap(), QString("&%1 %2").arg(m+1).arg(strippedName), QKeySequence(), this, strippedName,0,0.0,it.key()));
connect( scrRecentPasteActions[strippedName], SIGNAL(activatedData(QString)), this, SLOT(pasteRecent(QString)) );
scrMenuMgr->addMenuItem(scrRecentPasteActions[strippedName], recentPasteMenuName);
it--;
}
}
}
void ScribusMainWindow::pasteRecent(QString fn)
{
QString data = scrapbookPalette->tempBView->objectMap[fn].Data;
QFileInfo fi(data);
if (fi.extension(true).lower() == "sml")
{
QString f = "";
loadText(data, &f);
StencilReader *pre = new StencilReader();
data = pre->createObjects(f);
delete pre;
}
else if (fi.extension(true).lower() == "shape")
{
QString f = "";
loadText(data, &f);
StencilReader *pre = new StencilReader();
data = pre->createShape(f);
delete pre;
}
else if (fi.extension(true).lower() == "sce")
{
QString f = "";
loadText(data, &f);
data = f;
}
view->Deselect(true);
uint ac = doc->Items->count();
bool savedAlignGrid = doc->useRaster;
bool savedAlignGuides = doc->SnapGuides;
doc->useRaster = false;
doc->SnapGuides = false;
slotElemRead(data, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, true, doc, view);
doc->useRaster = savedAlignGrid;
doc->SnapGuides = savedAlignGuides;
for (uint as = ac; as < doc->Items->count(); ++as)
{
PageItem* currItem = doc->Items->at(as);
if (currItem->isBookmark)
AddBookMark(currItem);
view->SelectItemNr(as);
}
slotDocCh(false);
}
void ScribusMainWindow::rebuildLayersList()
{
if (HaveDoc)
{
for( QMap<QString, QPointer<ScrAction> >::Iterator it0 = scrLayersActions.begin(); it0 != scrLayersActions.end(); ++it0 )
scrMenuMgr->removeMenuItem((*it0), layerMenuName);
scrLayersActions.clear();
Q3ValueList<Layer>::iterator it;
if (doc->Layers.count()!= 0)
{
for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
{
scrLayersActions.insert(QString("%1").arg((*it).LNr), new ScrAction( ScrAction::Layer, QPixmap(), QPixmap(), (*it).Name, QKeySequence(), this, (*it).Name, (*it).LNr));
scrLayersActions[QString("%1").arg((*it).LNr)]->setToggleAction(true);
}
}
int currActiveLayer=doc->activeLayer();
bool found=false;
for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
{
if ((*it).LNr == currActiveLayer)
{
found=true;
break;
}
}
Q_ASSERT(found);
scrLayersActions[QString("%1").arg((*it).LNr)]->setOn(true);
for( QMap<QString, QPointer<ScrAction> >::Iterator it = scrLayersActions.begin(); it