1 /*
2 For general Scribus (>=1.3.2) copyright and licensing information please refer
3 to the COPYING file provided with the program. Following this notice may exist
4 a copyright and/or license notice that predates the release of Scribus 1.3.2
5 for which a new license (GPL+exception) is in place.
6 */
7 /***************************************************************************
8 scribus.cpp - description
9 -------------------
10 begin : Fre Apr 6 21:09:31 CEST 2001
11 copyright : (C) 2001 by Franz Schmid
12 email : Franz.Schmid@altmuehlnet.de
13 ***************************************************************************/
14
15 /***************************************************************************
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 ***************************************************************************/
23
24 #include <QAction>
25 #include <QApplication>
26 #include <QByteArray>
27 #include <QCloseEvent>
28 #include <QColor>
29 #include <QColorDialog>
30 #include <QCursor>
31 #include <QDrag>
32 #include <QDragEnterEvent>
33 #include <QDropEvent>
34 #include <QEvent>
35 #include <QEventLoop>
36 #include <QFileDialog>
37 #include <QFrame>
38 #include <QFont>
39 #include <QHBoxLayout>
40 #include <QIcon>
41 #include <QInputDialog>
42 #include <QKeyEvent>
43 #include <QKeySequence>
44 #include <QLabel>
45 #include <QList>
46 #include <QLocale>
47 #include <QMdiArea>
48 #include <QMdiSubWindow>
49 #include <QMessageBox>
50 #include <QMouseEvent>
51 #include <QMultiMap>
52 #include <QPixmap>
53 #include <QProgressBar>
54 #include <QPushButton>
55 //<<QML testing
56 //#include <QQuickView>
57 //#include <QQmlEngine>
58 //#include <QQmlComponent>
59 //#include <QQuickItem>
60 //#include <QQmlProperty>
61 //>>
62 #include <QRegExp>
63 #include <QScopedPointer>
64 #include <QScreen>
65 #include <QStyleFactory>
66 #include <QTableWidget>
67 #include <QTextCodec>
68 #include <QTranslator>
69 #include <QWindow>
70 #include <QWheelEvent>
71
72 #ifdef DEBUG_LOAD_TIMES
73 #include <QDebug>
74 #include <QTime>
75 #include <sys/times.h>
76 #endif
77
78 #include <cstdio>
79 #include <cstdlib>
80 #include <cassert>
81
82 #include "scconfig.h"
83
84 #ifdef HAVE_DLFCN_H
85 #include <dlfcn.h>
86 #endif
87
88 #ifdef HAVE_UNISTD_H
89 #include <unistd.h>
90 #endif
91
92 #include <iostream>
93 #include <sstream>
94 #include <csignal>
95 #include <string>
96
97 #include "actionmanager.h"
98 #include "actionsearch.h"
99 #include "api/api_application.h"
100 #include "appmodehelper.h"
101 #include "appmodes.h"
102 #include "canvasmode.h"
103 #include "canvasmode_imageimport.h"
104 #include "commonstrings.h"
105 #include "desaxe/digester.h"
106 #include "desaxe/saxXML.h"
107 #include "desaxe/simple_actions.h"
108 #include "documentchecker.h"
109 #include "documentinformation.h"
110 #include "fileloader.h"
111 #include "filewatcher.h"
112 #include "fpoint.h"
113 #include "fpointarray.h"
114 #include "gtgettext.h"
115 #include "hyphenator.h"
116 #include "iconmanager.h"
117 #include "langmgr.h"
118 #include "localemgr.h"
119 #include "loadsaveplugin.h"
120 #include "marks.h"
121 #include "nfttemplate.h"
122 #include "notesstyles.h"
123 #include "pageitem_group.h"
124 #include "pageitem_imageframe.h"
125 #include "pageitem_latexframe.h"
126 #include "pageitem_noteframe.h"
127 #include "pageitem_table.h"
128 #include "pageitem_textframe.h"
129 #include "pagesize.h"
130 #include "pdflib.h"
131 #include "pdfoptions.h"
132 #include "pluginmanager.h"
133 #include "plugins/formatidlist.h"
134 #include "plugins/formatidlist.h"
135 #include "prefscontext.h"
136 #include "prefsfile.h"
137 #include "prefsmanager.h"
138 #include "prefstable.h"
139 #include "pslib.h"
140 #include "resourcecollection.h"
141 #include "sccolorengine.h"
142 #include "scgtplugin.h"
143 #include "scimagecachemanager.h"
144 #include "scmimedata.h"
145 #include "scpage.h"
146 #include "scpaths.h"
147 #include "scprintengine_pdf.h"
148 #include "scprintengine_ps.h"
149 #include "scraction.h"
150 #include "scribusXml.h"
151 #include "scribusapp.h"
152 #include "scribuscore.h"
153 #include "scribusdoc.h"
154 #include "scribusview.h"
155 #include "scribuswin.h"
156 #include "selection.h"
157 #include "serializer.h"
158 #include "storyloader.h"
159 #include "styleoptions.h"
160 #include "tocgenerator.h"
161 #include "ui/about.h"
162 #include "ui/aboutplugins.h"
163 #include "ui/actionsearchdialog.h"
164 #include "ui/aligndistribute.h"
165 #include "ui/annot.h"
166 #include "ui/annota.h"
167 #include "ui/applytemplatedialog.h"
168 #include "ui/arrowchooser.h"
169 #include "ui/autoform.h"
170 #include "ui/basepointwidget.h"
171 #include "ui/bookmarkpalette.h"
172 #include "ui/charselect.h"
173 #include "ui/checkDocument.h"
174 #include "ui/collectforoutput_ui.h"
175 #include "ui/colorcombo.h"
176 #include "ui/contentpalette.h"
177 #include "ui/contextmenu.h"
178 #include "ui/copypagetomasterpagedialog.h"
179 #include "ui/cpalette.h"
180 #include "ui/customfdialog.h"
181 #include "ui/delpages.h"
182 #include "ui/downloadspalette.h"
183 #include "ui/edittoolbar.h"
184 #include "ui/effectsdialog.h"
185 #include "ui/filetoolbar.h"
186 #include "ui/fontcombo.h"
187 #include "ui/guidemanager.h"
188 #include "ui/helpbrowser.h"
189 #include "ui/hruler.h"
190 #include "ui/imageinfodialog.h"
191 #include "ui/inlinepalette.h"
192 #include "ui/insertaframe.h"
193 #include "ui/inspage.h"
194 #include "ui/javadocs.h"
195 #include "ui/layers.h"
196 #include "ui/loremipsum.h"
197 #include "ui/marginwidget.h"
198 #include "ui/mark2item.h"
199 #include "ui/mark2mark.h"
200 #include "ui/markanchor.h"
201 #include "ui/markinsert.h"
202 #include "ui/marknote.h"
203 #include "ui/marksmanager.h"
204 #include "ui/markvariabletext.h"
205 #include "ui/mergedoc.h"
206 #include "ui/modetoolbar.h"
207 #include "ui/movepage.h"
208 #include "ui/multipleduplicate.h"
209 #include "ui/newdocdialog.h"
210 #include "ui/newtemp.h"
211 #include "ui/nftdialog.h"
212 #include "ui/nftwidget.h"
213 #include "ui/nodeeditpalette.h"
214 #include "ui/notesstyleseditor.h"
215 #include "ui/outlinepalette.h"
216 #include "ui/outputpreview_pdf.h"
217 #include "ui/outputpreview_ps.h"
218 #include "ui/pageitemattributes.h"
219 #include "ui/pagelayout.h"
220 #include "ui/pagepalette.h"
221 #include "ui/pagepropertiesdialog.h"
222 #include "ui/pageselector.h"
223 #include "ui/colorsandfills.h"
224 #include "ui/pdfexportdialog.h"
225 #include "ui/pdftoolbar.h"
226 #include "ui/picstatus.h"
227 #include "ui/polygonwidget.h"
228 #include "ui/preferencesdialog.h"
229 #include "ui/printdialog.h"
230 #include "ui/printpreview.h"
231 #include "ui/propertiespalette.h"
232 #include "ui/propertiespalette_line.h"
233 #include "ui/propertiespalette_shape.h"
234 #include "ui/propertiespalette_xyz.h"
235 #include "ui/query.h"
236 #include "ui/recoverdialog.h"
237 #include "ui/replacecolors.h"
238 #include "ui/resourcemanager.h"
239 #include "ui/scfilewidget.h"
240 #include "ui/scmessagebox.h"
241 #include "ui/scmwmenumanager.h"
242 #include "ui/scrapbookpalette.h"
243 #include "ui/scrspinbox.h"
244 #include "ui/search.h"
245 #include "ui/selectobjects.h"
246 #include "ui/smcellstyle.h"
247 #include "ui/smlinestyle.h"
248 #include "ui/smtablestyle.h"
249 #include "ui/smtextstyles.h"
250 #include "ui/splash.h"
251 #include "ui/storyeditor.h"
252 #include "ui/stylemanager.h"
253 #include "ui/symbolpalette.h"
254 #include "ui/tabmanager.h"
255 #include "ui/transformdialog.h"
256 #include "ui/transparencypalette.h"
257 #include "ui/viewtoolbar.h"
258 #include "ui/vruler.h"
259 #include "ui_nftdialog.h"
260 #include "undogui.h"
261 #include "undomanager.h"
262 #include "undostate.h"
263 #include "units.h"
264 #include "urllauncher.h"
265 #include "usertaskstructs.h"
266 #include "util.h"
267 #include "util_file.h"
268 #include "util_formats.h"
269 #include "util_ghostscript.h"
270 #include "util_math.h"
271
272 #ifdef HAVE_SVNVERSION
273 #include "svnversion.h"
274 #endif
275
276 #ifdef HAVE_OSG
277 #include "ui/osgeditor.h"
278 #include <osgDB/ReaderWriter>
279 #include <osgDB/PluginQuery>
280 #endif
281
282 #if defined(_WIN32)
283 #include "scdocoutput_ps2.h"
284 #include "scprintengine_gdi.h"
285 #endif
286
287 #include "sclimits.h"
288
289 using namespace std;
290
291 bool previewDinUse;
292 bool printDinUse;
293
294 QString DocDir;
295
296
297 //extern ScribusQApp* ScQApp;
298 extern bool emergencyActivated;
299
300
ScribusMainWindow()301 ScribusMainWindow::ScribusMainWindow() :
302 m_prefsManager(PrefsManager::instance())
303 {
304 #ifdef Q_OS_MAC
305 //commenting this out until this is resolved :https://bugreports.qt.io/browse/QTBUG-44565
306 //ScQApp->setAttribute(Qt::AA_DontShowIconsInMenus);
307 //noIcon = IconManager::instance().loadPixmap("noicon.png");
308 #endif
309 }
310
311 /*
312 * retval 0 - ok, 1 - no fonts, ...
313 */
initScMW(bool primaryMainWindow)314 int ScribusMainWindow::initScMW(bool primaryMainWindow)
315 {
316 int retVal=0;
317 qsrand(1234);
318 QByteArray stylesheet;
319 if (loadRawText(ScPaths::preferencesDir() + "/stylesheet.css", stylesheet))
320 {
321 qApp->setStyleSheet(QString(stylesheet));
322 }
323
324 qApp->setLayoutDirection(QLocale(ScCore->getGuiLanguage()).textDirection());
325 previewDinUse = false;
326 printDinUse = false;
327 internalCopy = false;
328 internalCopyBuffer.clear();
329 m_doc = new ScribusDoc();
330 m_doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
331 m_doc->setPage(100, 100, 0, 0, 0, 0, 0, 0, false, false);
332 m_doc->addPage(0);
333 m_doc->setGUI(false, this, nullptr);
334 CurrStED = nullptr;
335 QString scribusTitle(ScribusAPI::getVersionScribusTranslated());
336 if (ScribusAPI::isSVN() && ScribusAPI::haveSVNRevision())
337 scribusTitle.append(QString(" (r%1)").arg(ScribusAPI::getSVNRevision()));
338 setWindowTitle(scribusTitle);
339 setAttribute(Qt::WA_KeyCompression, false);
340 setAttribute(Qt::WA_InputMethodEnabled, true);
341 setWindowIcon(IconManager::instance().loadIcon("AppIcon.png"));
342 setObjectName("MainWindow");
343 scrActionGroups.clear();
344 scrActions.clear();
345 scrRecentFileActions.clear();
346 scrRecentPasteActions.clear();
347 scrWindowsActions.clear();
348 scrLayersActions.clear();
349 scrScrapActions.clear();
350 actionManager = new ActionManager(this);
351 appModeHelper = new AppModeHelper();
352 appModeHelper->setup(actionManager, &scrActions, &scrRecentFileActions, &scrWindowsActions, &scrScrapActions, &scrLayersActions, &scrRecentPasteActions);
353 scrMenuMgr = new ScMWMenuManager(menuBar(), actionManager);
354 m_formatsManager = FormatsManager::instance();
355 m_objectSpecificUndo = false;
356
357 m_undoManager = UndoManager::instance();
358 PrefsContext *undoPrefs = m_prefsManager.prefsFile->getContext("undo");
359 m_undoManager->setUndoEnabled(undoPrefs->getBool("enabled", true));
360 m_tocGenerator = new TOCGenerator();
361 m_marksCount = 0;
362
363 initDefaultValues();
364 initStatusBar();
365
366 qApp->processEvents();
367
368 actionManager->init(this);
369
370 initMdiArea();
371 initMenuBar();
372 createMenuBar();
373 initToolBars();
374 ScCore->pluginManager->setupPluginActions(this);
375 ScCore->pluginManager->enableOnlyStartupPluginActions(this);
376 ScCore->pluginManager->languageChange();
377
378 if (primaryMainWindow)
379 ScCore->setSplashStatus( tr("Applying User Shortcuts") );
380 m_prefsManager.applyLoadedShortCuts();
381 initKeyboardShortcuts();
382
383 resize(610, 600);
384 connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(newActWin(QMdiSubWindow*)));
385 //Connect windows cascade and tile actions to the workspace after its created. Only depends on mdiArea created.
386 connect( scrActions["windowsCascade"], SIGNAL(triggered()) , mdiArea, SLOT(cascadeSubWindows()) );
387 connect( scrActions["windowsTile"], SIGNAL(triggered()) , mdiArea, SLOT(tileSubWindows()) );
388 initPalettes();
389
390
391 viewToolBar->previewQualitySwitcher->setCurrentIndex(m_prefsManager.appPrefs.itemToolPrefs.imageLowResType);
392 if (primaryMainWindow)
393 ScCore->setSplashStatus( tr("Initializing Story Editor") );
394 storyEditor = new StoryEditor(this);
395
396 DocDir = m_prefsManager.documentDir();
397
398 if (primaryMainWindow)
399 ScCore->setSplashStatus( tr("Initializing Languages") );
400 LanguageManager::instance();
401
402 initHyphenator();
403 // QString preLang(m_prefsManager.appPrefs.hyphPrefs.Language);
404 // if (!LanguageManager::instance()->getHyphFilename( preLang ).isEmpty() )
405 // m_prefsManager.appPrefs.hyphPrefs.Language = preLang;
406 if (primaryMainWindow)
407 ScCore->setSplashStatus( tr("Reading Scrapbook") );
408 initScrapbook();
409
410 scrActions["helpTooltips"]->setChecked(m_prefsManager.appPrefs.displayPrefs.showToolTips);
411 scrActions["showMouseCoordinates"]->setChecked(m_prefsManager.appPrefs.displayPrefs.showMouseCoordinates);
412 scrActions["stickyTools"]->setChecked(m_prefsManager.appPrefs.uiPrefs.stickyTools);
413 ToggleTips();
414 ToggleMouseTips();
415 propertiesPalette->setFontSize();
416 contentPalette->setFontSize();
417 if (scrActions["SaveAsDocumentTemplate"])
418 scrActions["SaveAsDocumentTemplate"]->setEnabled(false);
419
420 connect(ScQApp, SIGNAL(iconSetChanged()), this, SLOT(iconSetChange()));
421 connect(ScQApp, SIGNAL(localeChanged()), this, SLOT(localeChange()));
422 connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), this, SLOT(removeRecentFromWatcher(QString)));
423 connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
424 setAcceptDrops(true);
425 QCoreApplication::instance()->installEventFilter(this);
426 scrActions["toolsSelect"]->setChecked(true);
427
428 ColorSetManager csm;
429 csm.findPaletteLocations();
430 csm.findPalettes();
431 csm.findUserPalettes();
432 QString Cpfad = QDir::toNativeSeparators(ScPaths::applicationDataDir())+"DefaultColors.xml";
433 QFile fc(Cpfad);
434 if (fc.exists())
435 csm.loadPalette(Cpfad, m_doc, m_prefsManager.appPrefs.colorPrefs.DColors, m_prefsManager.appPrefs.defaultGradients, m_prefsManager.appPrefs.defaultPatterns, false);
436 else
437 {
438 if (m_prefsManager.appPrefs.colorPrefs.DColorSet != "Scribus Small")
439 {
440 QStringList CustomColorSets = csm.userPaletteNames();
441 if (CustomColorSets.contains(m_prefsManager.appPrefs.colorPrefs.DColorSet))
442 Cpfad = csm.userPaletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
443 else
444 Cpfad = csm.paletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
445 if (!Cpfad.isEmpty())
446 csm.loadPalette(Cpfad, m_doc, m_prefsManager.appPrefs.colorPrefs.DColors, m_prefsManager.appPrefs.defaultGradients, m_prefsManager.appPrefs.defaultPatterns, false);
447 }
448 }
449 appModeHelper->setStartupActionsEnabled(false);
450
451 setStyleSheet();
452
453 return retVal;
454 }
455
setupMainWindow()456 void ScribusMainWindow::setupMainWindow()
457 {
458 setDefaultPrinter(m_prefsManager.appPrefs.printerPrefs.PrinterName, m_prefsManager.appPrefs.printerPrefs.PrinterFile, m_prefsManager.appPrefs.printerPrefs.PrinterCommand);
459
460 uint max = qMin(m_prefsManager.appPrefs.uiPrefs.recentDocCount, m_prefsManager.appPrefs.uiPrefs.RecentDocs.count());
461 for (uint m = 0; m < max; ++m)
462 {
463 QFileInfo fd(m_prefsManager.appPrefs.uiPrefs.RecentDocs[m]);
464 if (fd.exists())
465 {
466 m_recentDocsList.append(m_prefsManager.appPrefs.uiPrefs.RecentDocs[m]);
467 //#9845: ScCore->fileWatcher->addFile(appPrefs.uiPrefs.RecentDocs[m]);
468 }
469 }
470 rebuildRecentFileMenu();
471 //For 1.3.5, we dump prefs first time around.
472 if (!m_prefsManager.firstTimeIgnoreOldPrefs())
473 m_prefsManager.readPrefsXML();
474 if (m_prefsManager.appPrefs.verifierPrefs.checkerPrefsList.count() == 0)
475 {
476 m_prefsManager.initDefaultCheckerPrefs(m_prefsManager.appPrefs.verifierPrefs.checkerPrefsList);
477 m_prefsManager.appPrefs.verifierPrefs.curCheckProfile = CommonStrings::PDF_1_4;
478 }
479
480 const WindowPrefs& mainWinSettings = m_prefsManager.appPrefs.uiPrefs.mainWinSettings;
481 QWindow* w = windowHandle();
482 QList<QScreen*> screens = QGuiApplication::screens();
483 QScreen* s = nullptr;
484 if (w != nullptr)
485 {
486 s = screens.at(qMin(mainWinSettings.screenNumber, QGuiApplication::screens().count() - 1));
487 windowHandle()->setScreen(s);
488 }
489 else
490 s = QGuiApplication::primaryScreen();
491 QRect r(0, 0, 0, 0);
492 if (s != nullptr)
493 r = s->geometry();
494 move(r.left() + abs(mainWinSettings.xPosition), r.top() + abs(mainWinSettings.yPosition));
495 resize(mainWinSettings.width, mainWinSettings.height);
496
497 if (mainWinSettings.maximized)
498 this->setWindowState((this->windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen)) | Qt::WindowMaximized);
499
500 if (!m_prefsManager.appPrefs.uiPrefs.mainWinState.isEmpty())
501 restoreState(m_prefsManager.appPrefs.uiPrefs.mainWinState);
502 }
503
getScreenNumber() const504 int ScribusMainWindow::getScreenNumber() const
505 {
506 QList<QScreen*> screens = QGuiApplication::screens();
507 int screenNumber = -1;
508
509 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
510 QWindow* w = ScCore->primaryMainWindow()->windowHandle();
511 if (w != nullptr)
512 screenNumber = screens.indexOf(w->screen());
513 #else
514 QScreen* s = ScCore->primaryMainWindow()->screen();
515 screenNumber = screens.indexOf(s);
516 #endif
517 if (screenNumber < 0)
518 screenNumber = screens.indexOf(QGuiApplication::primaryScreen());
519 if (screenNumber < 0)
520 screenNumber = 0;
521 return screenNumber;
522 }
523
getScreen() const524 QScreen* ScribusMainWindow::getScreen() const
525 {
526 QList<QScreen*> screens = QGuiApplication::screens();
527 return screens.at(getScreenNumber());
528 }
529
getScreenPosition(int & xPos,int & yPos) const530 void ScribusMainWindow::getScreenPosition(int& xPos, int& yPos) const
531 {
532 QScreen* screen(getScreen());
533 QRect screenGeom = screen->geometry();
534 xPos = screenGeom.left();
535 yPos = screenGeom.top();
536 }
537
getScreenDPI(int & dpiX,int & dpiY) const538 void ScribusMainWindow::getScreenDPI(int& dpiX, int& dpiY) const
539 {
540 QScreen* screen(getScreen());
541 dpiX = screen->physicalDotsPerInchX();
542 dpiY = screen->physicalDotsPerInchY();
543 }
544
~ScribusMainWindow()545 ScribusMainWindow::~ScribusMainWindow()
546 {
547 delete actionManager;
548 delete appModeHelper;
549 delete m_doc;
550 delete m_tocGenerator;
551 }
552
addScToolBar(ScToolBar * tb,const QString & name)553 void ScribusMainWindow::addScToolBar(ScToolBar *tb, const QString & name)
554 {
555 if (!scrToolBars.contains(name))
556 scrToolBars.insert(name, tb);
557 addToolBar(tb);
558 }
559
initToolBars()560 void ScribusMainWindow::initToolBars()
561 {
562 fileToolBar = new FileToolBar(this);
563 editToolBar = new EditToolBar(this);
564 UndoWidget* uWidget = new UndoWidget(editToolBar, "uWidget");
565 m_undoManager->registerGui(uWidget);
566 modeToolBar = new ModeToolBar(this);
567 pdfToolBar = new PDFToolBar(this);
568 viewToolBar = new ViewToolBar(this);
569
570 addScToolBar(fileToolBar, fileToolBar->objectName());
571 addScToolBar(editToolBar, editToolBar->objectName());
572 addScToolBar(modeToolBar, modeToolBar->objectName());
573 addScToolBar(pdfToolBar, pdfToolBar->objectName());
574 addScToolBar(viewToolBar, viewToolBar->objectName());
575 connect(modeToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarTools"], SLOT(setChecked(bool)));
576 connect(scrActions["toolsToolbarPDF"], SIGNAL(toggled(bool)), pdfToolBar, SLOT(setVisible(bool)));
577 connect(pdfToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarPDF"], SLOT(setChecked(bool)));
578 connect(scrActions["toolsToolbarTools"], SIGNAL(toggled(bool)), modeToolBar, SLOT(setVisible(bool)) );
579 connect(viewToolBar, SIGNAL(visibilityChanged(bool)), scrActions["toolsToolbarView"], SLOT(setChecked(bool)));
580 connect(scrActions["toolsToolbarView"], SIGNAL(toggled(bool)), viewToolBar, SLOT(setVisible(bool)) );
581 }
582
setStyleSheet()583 void ScribusMainWindow::setStyleSheet()
584 {
585 QByteArray stylesheet;
586 if (loadRawText(ScPaths::instance().libDir() + "scribus.css", stylesheet))
587 {
588 QString downArrow(IconManager::instance().pathForIcon("16/go-down.png"));
589 QByteArray da;
590 da.append(downArrow.toUtf8());
591 stylesheet.replace("___downArrow___", da);
592 QString toolbararrow(IconManager::instance().pathForIcon("stylesheet/down_arrow.png"));
593 QByteArray tba;
594 tba.append(toolbararrow.toUtf8());
595 stylesheet.replace("___tb_menu_arrow___", tba);
596 }
597
598 layerMenu->setStyleSheet(stylesheet);
599 unitSwitcher->setStyleSheet(stylesheet);
600 zoomDefaultToolbarButton->setStyleSheet(stylesheet);
601 zoomInToolbarButton->setStyleSheet(stylesheet);
602 zoomOutToolbarButton->setStyleSheet(stylesheet);
603 zoomSpinBox->setStyleSheet(stylesheet);
604
605 fileToolBar->setStyleSheet(stylesheet);
606 editToolBar->setStyleSheet(stylesheet);
607 modeToolBar->setStyleSheet(stylesheet);
608 pdfToolBar->setStyleSheet(stylesheet);
609 viewToolBar->setStyleSheet(stylesheet);
610 }
611
612
initDefaultValues()613 void ScribusMainWindow::initDefaultValues()
614 {
615 HaveDoc = false;
616 view = nullptr;
617 doc = nullptr;
618 m_DocNr = 1;
619 m_PrinterUsed = false;
620 PDef.Pname.clear();
621 PDef.Dname.clear();
622 PDef.Command.clear();
623 //m_keyrep = false;
624 //m_arrowKeyDown = false;
625 ClipB = QApplication::clipboard();
626 for (int i=0; i<PAL_MAX ; ++i)
627 m_palettesStatus[i] = false;
628 for (int i=0; i<GS_MAX ; ++i)
629 m_guidesStatus[i] = false;
630 #ifdef HAVE_OSG
631 QStringList supportedExts;
632 supportedExts << "osg" << "dxf" << "flt" << "ive" << "geo" << "sta" << "stl" << "logo" << "3ds" << "ac" << "obj";
633 QStringList realSupportedExts;
634 QMap<QString, QString> formats;
635 osgDB::FileNameList plugins = osgDB::listAllAvailablePlugins();
636 for (osgDB::FileNameList::iterator itr = plugins.begin(); itr != plugins.end(); ++itr)
637 {
638 osgDB::ReaderWriterInfoList infoList;
639 if (QString::fromStdString(*itr).contains("qfont"))
640 continue;
641 if (osgDB::queryPlugin(*itr, infoList))
642 {
643 for (auto rwi_itr = infoList.begin(); rwi_itr != infoList.end(); ++rwi_itr)
644 {
645 osgDB::ReaderWriterInfo& info = *(*rwi_itr);
646 osgDB::ReaderWriter::FormatDescriptionMap::iterator fdm_itr;
647 for (fdm_itr = info.extensions.begin(); fdm_itr != info.extensions.end(); ++fdm_itr)
648 {
649 if (supportedExts.contains(QString::fromStdString(fdm_itr->first)))
650 formats.insert("*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper(), QString::fromStdString(fdm_itr->second) + " (*." + QString::fromStdString(fdm_itr->first) + " *." + QString::fromStdString(fdm_itr->first).toUpper() + ")");
651 }
652 }
653 }
654 }
655 realSupportedExts = formats.keys();
656 QString docexts = realSupportedExts.join(" ");
657 QStringList longList = formats.values();
658 QString longDesc = longList.join(";;") + ";;";
659 m_osgFilterString = tr("All Supported Formats (%1);;%2All Files (*)").arg(docexts).arg(longDesc);
660 #endif
661 }
662
663
initKeyboardShortcuts()664 void ScribusMainWindow::initKeyboardShortcuts()
665 {
666 for (auto it = scrActions.begin(); it!=scrActions.end(); ++it )
667 {
668 if ((ScrAction*)(it.value()) != nullptr)
669 {
670 QString accelerator = it.value()->shortcut().toString();
671 m_prefsManager.setKeyEntry(it.key(), it.value()->cleanMenuText(), accelerator,0);
672 }
673 //else
674 // qDebug() << it.key();
675 //qDebug() << QString("|-\n|%1||%2||%3").arg(it.key()).arg(it.value()->cleanMenuText()).arg(QString(it.data()->accel()));
676 }
677 }
678
679
initPalettes()680 void ScribusMainWindow::initPalettes()
681 {
682 //CB TODO hide the publicly available members of some palettes
683 // these must be filtered too as they take control of the palettes events
684 outlinePalette = new OutlinePalette(this);
685 outlinePalette->setMainWindow(this);
686 connect( scrActions["toolsOutline"], SIGNAL(toggled(bool)) , outlinePalette, SLOT(setPaletteShown(bool)));
687 connect( outlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsOutline"], SLOT(setChecked(bool)));
688
689 propertiesPalette = new PropertiesPalette(this);
690 propertiesPalette->setMainWindow(this);
691 connect( scrActions["toolsProperties"], SIGNAL(toggled(bool)) , propertiesPalette, SLOT(setPaletteShown(bool)));
692 connect( propertiesPalette, SIGNAL(paletteShown(bool)), scrActions["toolsProperties"], SLOT(setChecked(bool)));
693 emit UpdateRequest(reqDefFontListUpdate);
694 propertiesPalette->installEventFilter(this);
695
696 contentPalette = new ContentPalette(this);
697 contentPalette->setMainWindow(this);
698 connect( scrActions["toolsContent"], &QAction::toggled, contentPalette, &ContentPalette::setPaletteShown);
699 connect( contentPalette, &ContentPalette::paletteShown, scrActions["toolsContent"], &QAction::setChecked);
700 contentPalette->installEventFilter(this);
701
702 nodePalette = new NodePalette(this);
703 nodePalette->installEventFilter(this);
704 layerPalette = new LayerPalette(this);
705 guidePalette = new GuideManager(this);
706 charPalette = new CharSelect(this);
707 connect( scrActions["toolsLayers"], SIGNAL(toggled(bool)) , layerPalette, SLOT(setPaletteShown(bool)));
708 connect( layerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsLayers"], SLOT(setChecked(bool)));
709 layerPalette->installEventFilter(this);
710 scrapbookPalette = new Biblio(this);
711 connect( scrActions["toolsScrapbook"], SIGNAL(toggled(bool)) , scrapbookPalette, SLOT(setPaletteShown(bool)));
712 connect( scrapbookPalette, SIGNAL(paletteShown(bool)), scrActions["toolsScrapbook"], SLOT(setChecked(bool)));
713 connect( scrapbookPalette, SIGNAL(pasteToActualPage(QString)), this, SLOT(pasteFromScrapbook(QString)));
714 connect( scrapbookPalette, SIGNAL(scrapbookListChanged()), this, SLOT(rebuildScrapbookMenu()));
715 scrapbookPalette->installEventFilter(this);
716 pagePalette = new PagePalette(this);
717 connect( scrActions["toolsPages"], SIGNAL(toggled(bool)) , pagePalette, SLOT(setPaletteShown(bool)) );
718 connect( pagePalette, SIGNAL(paletteShown(bool)), scrActions["toolsPages"], SLOT(setChecked(bool)));
719 pagePalette->installEventFilter(this);
720 bookmarkPalette = new BookPalette(this);
721 connect( scrActions["toolsBookmarks"], SIGNAL(toggled(bool)) , bookmarkPalette, SLOT(setPaletteShown(bool)) );
722 connect( bookmarkPalette, SIGNAL(paletteShown(bool)), scrActions["toolsBookmarks"], SLOT(setChecked(bool)));
723 bookmarkPalette->installEventFilter(this);
724 downloadsPalette = new DownloadsPalette(this);
725 connect( scrActions["toolsDownloads"], SIGNAL(toggled(bool)) , downloadsPalette, SLOT(setPaletteShown(bool)) );
726 connect( downloadsPalette, SIGNAL(paletteShown(bool)), scrActions["toolsDownloads"], SLOT(setChecked(bool)));
727 downloadsPalette->installEventFilter(this);
728 connect( scrActions["toolsMeasurements"], SIGNAL(toggledData(bool,int)) , this, SLOT(setAppModeByToggle(bool,int)) );
729 docCheckerPalette = new CheckDocument(this, false);
730 connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , docCheckerPalette, SLOT(setPaletteShown(bool)) );
731 connect( scrActions["toolsPreflightVerifier"], SIGNAL(toggled(bool)) , this, SLOT(docCheckToggle(bool)) );
732 connect( docCheckerPalette, SIGNAL(paletteShown(bool)), scrActions["toolsPreflightVerifier"], SLOT(setChecked(bool)));
733 connect( docCheckerPalette, SIGNAL(paletteShown(bool)), this, SLOT(docCheckToggle(bool)));
734 docCheckerPalette->installEventFilter(this);
735 docCheckerPalette->hide();
736
737 alignDistributePalette = new AlignDistributePalette(this, "AlignDistributePalette");
738 connect( scrActions["toolsAlignDistribute"], SIGNAL(toggled(bool)) , alignDistributePalette, SLOT(setPaletteShown(bool)) );
739 connect( alignDistributePalette, SIGNAL(paletteShown(bool)), scrActions["toolsAlignDistribute"], SLOT(setChecked(bool)));
740 connect( alignDistributePalette, SIGNAL(documentChanged()), this, SLOT(slotDocCh()));
741 alignDistributePalette->installEventFilter(this);
742
743 symbolPalette = new SymbolPalette(this);
744 symbolPalette->setMainWindow(this);
745 connect(scrActions["toolsSymbols"], SIGNAL(toggled(bool)), symbolPalette, SLOT(setPaletteShown(bool)));
746 connect(symbolPalette, SIGNAL(paletteShown(bool)), scrActions["toolsSymbols"], SLOT(setChecked(bool)));
747 connect(symbolPalette, SIGNAL(startEdit(QString)), this, SLOT(editSymbolStart(QString)));
748 connect(symbolPalette, SIGNAL(endEdit()), this, SLOT(editSymbolEnd()));
749 connect(symbolPalette, SIGNAL(objectDropped()), this, SLOT(PutToPatterns()));
750 symbolPalette->installEventFilter(this);
751 symbolPalette->hide();
752
753 inlinePalette = new InlinePalette(this);
754 inlinePalette->setMainWindow(this);
755 connect(scrActions["toolsInline"], SIGNAL(toggled(bool)), inlinePalette, SLOT(setPaletteShown(bool)));
756 connect(inlinePalette, SIGNAL(paletteShown(bool)), scrActions["toolsInline"], SLOT(setChecked(bool)));
757 connect(inlinePalette, SIGNAL(startEdit(int)), this, SLOT(editInlineStart(int)));
758 connect(inlinePalette, SIGNAL(endEdit()), this, SLOT(editInlineEnd()));
759 connect(inlinePalette, SIGNAL(objectDropped(QString)), this, SLOT(PutToInline(QString)));
760 inlinePalette->installEventFilter(this);
761 inlinePalette->hide();
762
763 undoPalette = new UndoPalette(this, "undoPalette");
764 undoPalette->installEventFilter(this);
765 m_undoManager->registerGui(undoPalette);
766 connect(undoPalette, SIGNAL(paletteShown(bool)), this, SLOT(setUndoPalette(bool)));
767 connect(undoPalette, SIGNAL(objectMode(bool)), this, SLOT(setUndoMode(bool)));
768
769 // initializing style manager here too even it's not strictly a palette
770 m_styleManager = new StyleManager(this, "styleManager");
771 SMCharacterStyle *tmpCS = new SMCharacterStyle();
772 m_styleManager->addStyle(new SMParagraphStyle(tmpCS));
773 m_styleManager->addStyle(tmpCS);
774 m_styleManager->addStyle(new SMTableStyle());
775 m_styleManager->addStyle(new SMCellStyle());
776 m_styleManager->addStyle(new SMLineStyle());
777 connect( scrActions["editStyles"], SIGNAL(toggled(bool)), m_styleManager, SLOT(setPaletteShown(bool)) );
778 connect( m_styleManager, SIGNAL(paletteShown(bool)), scrActions["editStyles"], SLOT(setChecked(bool)));
779 m_styleManager->installEventFilter(this);
780
781 // initializing mark`s manager
782 marksManager = new MarksManager(this, "marksManager");
783 connect( scrActions["editMarks"], SIGNAL(toggled(bool)), marksManager, SLOT(setPaletteShown(bool)) );
784 connect( marksManager, SIGNAL(paletteShown(bool)), scrActions["editMarks"], SLOT(setChecked(bool)));
785 marksManager->installEventFilter(this);
786 // initializing notes styles manager
787 nsEditor = new NotesStylesEditor(this, "notesStylesEditor");
788 connect( scrActions["editNotesStyles"], SIGNAL(toggled(bool)), nsEditor, SLOT(setPaletteShown(bool)) );
789 connect( nsEditor, SIGNAL(paletteShown(bool)), scrActions["editNotesStyles"], SLOT(setChecked(bool)));
790 nsEditor->installEventFilter(this);
791
792 connect(docCheckerPalette, SIGNAL(selectElementByItem(PageItem*,bool)), this, SLOT(selectItemsFromOutlines(PageItem*,bool)));
793 connect(docCheckerPalette, SIGNAL(selectElement(PageItem*,bool,int)), this, SLOT(selectItemFromOutlines(PageItem*,bool,int)));
794 connect(docCheckerPalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
795 connect(docCheckerPalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
796 connect(outlinePalette, SIGNAL(selectElementByItem(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem*,bool)));
797 connect(outlinePalette, SIGNAL(editElementByItem(PageItem *)), this, SLOT(editItemsFromOutlines(PageItem *)));
798 connect(outlinePalette, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
799 connect(outlinePalette, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
800 connect(nodePalette, SIGNAL(paletteClosed()), this, SLOT(slotSelect()));
801 connect(nodePalette, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
802 connect(layerPalette, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
803
804 connect(bookmarkPalette->BView, SIGNAL(markMoved()), this, SLOT(StoreBookmarks()));
805 connect(bookmarkPalette->BView, SIGNAL(changed()), this, SLOT(slotDocCh()));
806 connect(bookmarkPalette->BView, SIGNAL(selectElement(PageItem *, bool)), this, SLOT(selectItemsFromOutlines(PageItem *, bool)));
807 // guides
808 connect(scrActions["pageManageGuides"], SIGNAL(toggled(bool)), guidePalette, SLOT(setPaletteShown(bool)));
809 connect(guidePalette, SIGNAL(paletteShown(bool)), scrActions["pageManageGuides"], SLOT(setChecked(bool)));
810 // char palette
811 connect(scrActions["insertGlyph"], SIGNAL(toggled(bool)), charPalette, SLOT(setPaletteShown(bool)));
812 connect(charPalette, SIGNAL(paletteShown(bool)), scrActions["insertGlyph"], SLOT(setChecked(bool)));
813 }
814
815
initScrapbook()816 void ScribusMainWindow::initScrapbook()
817 {
818 QString scrapbookFileO = QDir::toNativeSeparators(m_prefsManager.preferencesLocation()+"/scrap13.scs");
819 QFileInfo scrapbookFileInfoO = QFileInfo(scrapbookFileO);
820 if (scrapbookFileInfoO.exists())
821 {
822 scrapbookPalette->readOldContents(scrapbookFileO, ScPaths::scrapbookDir(true) + "main");
823 QDir d = QDir();
824 d.rename(scrapbookFileO, QDir::toNativeSeparators(m_prefsManager.preferencesLocation()+"/scrap13.backup"));
825 }
826 QString scrapbookTemp = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "tmp");
827 QFileInfo scrapbookTempInfo = QFileInfo(scrapbookTemp);
828 if (scrapbookTempInfo.exists())
829 scrapbookPalette->readTempContents(scrapbookTemp);
830 QString scrapbookFile = QDir::toNativeSeparators(ScPaths::scrapbookDir(true) + "main");
831 QFileInfo scrapbookFileInfo = QFileInfo(scrapbookFile);
832 if (scrapbookFileInfo.exists())
833 scrapbookPalette->readContents(scrapbookFile);
834 scrapbookPalette->setScrapbookFileName(scrapbookFile);
835 ScCore->fileWatcher->addDir(scrapbookFile, true);
836 scrapbookPalette->setOpenScrapbooks(m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks);
837 rebuildRecentPasteMenu();
838 connect(scrapbookPalette, SIGNAL(updateRecentMenue()), this, SLOT(rebuildRecentPasteMenu()));
839 connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString )), scrapbookPalette, SLOT(reloadLib(QString )));
840 connect(ScCore->fileWatcher, SIGNAL(dirDeleted(QString )), scrapbookPalette, SLOT(closeOnDel(QString )));
841 }
842
warningVersion(QWidget * parent)843 bool ScribusMainWindow::warningVersion(QWidget *parent)
844 {
845 bool retval = false;
846 int t = ScMessageBox::warning(parent, QObject::tr("Scribus Development Version"), "<qt>" +
847 QObject::tr("You are running a development version of Scribus 1.5.x. The document you are working with was created in Scribus 1.2.x. Saving the current file under 1.5.x renders it unable to be edited in Scribus 1.2.x versions. To preserve the ability to edit in 1.2.x, save this file under a different name and further edit the newly named file and the original will be untouched. Are you sure you wish to proceed with this operation?") + "</qt>",
848 QMessageBox::Ok | QMessageBox::Cancel,
849 QMessageBox::Cancel, // GUI default
850 QMessageBox::Ok); // batch default
851 if (t == QMessageBox::Ok)
852 retval = true;
853 return retval;
854 }
855
initMdiArea()856 void ScribusMainWindow::initMdiArea()
857 {
858 mdiArea = new QMdiArea(this);
859 mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
860 mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
861 if (m_prefsManager.appPrefs.uiPrefs.useTabs)
862 {
863 mdiArea->setViewMode(QMdiArea::TabbedView);
864 mdiArea->setTabsClosable(true);
865 mdiArea->setDocumentMode(true);
866 }
867 else
868 mdiArea->setViewMode(QMdiArea::SubWindowView);
869 setCentralWidget(mdiArea);
870 }
871
initMenuBar()872 void ScribusMainWindow::initMenuBar()
873 {
874 m_recentDocsList.clear();
875 scrMenuMgr->createMenu("File", ActionManager::defaultMenuNameEntryTranslated("File"));
876 scrMenuMgr->addMenuItemString("fileNew", "File");
877 scrMenuMgr->addMenuItemString("fileNewFromTemplate", "File");
878 scrMenuMgr->addMenuItemString("fileOpen", "File");
879 scrMenuMgr->addMenuItemString("FileOpenRecent", "File");
880 scrMenuMgr->createMenu("FileOpenRecent", tr("Open &Recent"), "File", false, true);
881 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
882 scrMenuMgr->addMenuItemString("fileClose", "File");
883 scrMenuMgr->addMenuItemString("fileSave", "File");
884 scrMenuMgr->addMenuItemString("fileSaveAs", "File");
885 scrMenuMgr->addMenuItemString("fileRevert", "File");
886 scrMenuMgr->addMenuItemString("fileCollect", "File");
887 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
888 scrMenuMgr->createMenu("FileImport", tr("&Import"), "File");
889 scrMenuMgr->addMenuItemString("FileImport", "File");
890 scrMenuMgr->addMenuItemString("fileImportText", "FileImport");
891 scrMenuMgr->addMenuItemString("fileImportAppendText", "FileImport");
892 scrMenuMgr->addMenuItemString("fileImportImage", "FileImport");
893 scrMenuMgr->addMenuItemString("fileImportVector", "FileImport");
894 scrMenuMgr->addMenuItemString("FileExport", "File");
895 scrMenuMgr->createMenu("FileExport", tr("&Export"), "File");
896 scrMenuMgr->addMenuItemString("fileExportText", "FileExport");
897 scrMenuMgr->addMenuItemString("fileExportAsEPS", "FileExport");
898 scrMenuMgr->addMenuItemString("fileExportAsPDF", "FileExport");
899 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
900 scrMenuMgr->addMenuItemString("fileDocSetup150", "File");
901 scrMenuMgr->addMenuItemString("filePreferences150", "File");
902 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
903 scrMenuMgr->addMenuItemString("filePrint", "File");
904 if (ScCore->haveGS() || ScCore->isWinGUI())
905 scrMenuMgr->addMenuItemString("PrintPreview", "File");
906 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
907 if (ScCore->haveGS())
908 {
909 scrMenuMgr->addMenuItemString("FileOutputPreview", "File");
910 scrMenuMgr->createMenu("FileOutputPreview", tr("&Output Preview"), "File");
911 scrMenuMgr->addMenuItemString("OutputPreviewPDF", "FileOutputPreview");
912 scrMenuMgr->addMenuItemString("OutputPreviewPS", "FileOutputPreview");
913 scrMenuMgr->addMenuItemString("SEPARATOR", "File");
914 }
915 scrMenuMgr->addMenuItemString("fileQuit", "File");
916
917 scrMenuMgr->setMenuEnabled("FileImport", false);
918 scrMenuMgr->setMenuEnabled("FileExport", false);
919 scrMenuMgr->setMenuEnabled("FileOutputPreview", false);
920
921 scrMenuMgr->createMenu("Edit", ActionManager::defaultMenuNameEntryTranslated("Edit"));
922 scrMenuMgr->addMenuItemString("editUndoAction", "Edit");
923 scrMenuMgr->addMenuItemString("editRedoAction", "Edit");
924 scrMenuMgr->addMenuItemString("editActionMode", "Edit");
925 scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
926 scrMenuMgr->addMenuItemString("editCut", "Edit");
927 scrMenuMgr->addMenuItemString("editCopy", "Edit");
928 scrMenuMgr->addMenuItemString("editPaste", "Edit");
929 scrMenuMgr->createMenu("EditPasteRecent", tr("Paste Recent"), "Edit", false, true);
930 scrMenuMgr->addMenuItemString("itemDelete", "Edit");
931 scrMenuMgr->createMenu("EditContents", tr("Contents"), "Edit", false, true);
932 scrMenuMgr->addMenuItemString("EditContents", "Edit");
933 scrMenuMgr->addMenuItemString("editCopyContents", "EditContents");
934 scrMenuMgr->addMenuItemString("editPasteContents", "EditContents");
935 scrMenuMgr->addMenuItemString("editPasteContentsAbs", "EditContents");
936 scrMenuMgr->addMenuItemString("editClearContents", "EditContents");
937 scrMenuMgr->addMenuItemString("editTruncateContents", "EditContents");
938 scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
939 scrMenuMgr->addMenuItemString("editSelectAll", "Edit");
940 scrMenuMgr->addMenuItemString("editSelectAllOnLayer", "Edit");
941 scrMenuMgr->addMenuItemString("editDeselectAll", "Edit");
942 scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
943 scrMenuMgr->addMenuItemString("editSearchReplace", "Edit");
944 scrMenuMgr->addMenuItemString("toolsEditWithStoryEditor", "Edit");
945 scrMenuMgr->addMenuItemString("editEditWithImageEditor", "Edit");
946 scrMenuMgr->addMenuItemString("editEditRenderSource", "Edit");
947 scrMenuMgr->addMenuItemString("SEPARATOR", "Edit");
948 scrMenuMgr->addMenuItemString("editColorsAndFills", "Edit");
949 scrMenuMgr->addMenuItemString("editReplaceColors", "Edit");
950 scrMenuMgr->addMenuItemString("editStyles", "Edit");
951 scrMenuMgr->addMenuItemString("editMarks", "Edit");
952 scrMenuMgr->addMenuItemString("editNotesStyles", "Edit");
953 scrMenuMgr->addMenuItemString("editMasterPages", "Edit");
954 scrMenuMgr->addMenuItemString("editJavascripts", "Edit");
955 scrMenuMgr->setMenuEnabled("EditPasteRecent", false);
956 scrMenuMgr->setMenuEnabled("EditContents", false);
957
958
959 //Item Menu
960 scrMenuMgr->createMenu("Item", ActionManager::defaultMenuNameEntryTranslated("Item"));
961 scrMenuMgr->createMenu("DuplicateTransform", tr("Duplicate/Transform"), "Item");
962 scrMenuMgr->addMenuItemString("DuplicateTransform", "Item");
963 scrMenuMgr->addMenuItemString("itemDuplicate", "DuplicateTransform");
964 scrMenuMgr->addMenuItemString("itemMulDuplicate", "DuplicateTransform");
965 scrMenuMgr->addMenuItemString("itemTransform", "DuplicateTransform");
966 scrMenuMgr->createMenu("Grouping", tr("Grouping"), "Item");
967 scrMenuMgr->addMenuItemString("Grouping", "Item");
968 scrMenuMgr->addMenuItemString("itemGroup", "Grouping");
969 scrMenuMgr->addMenuItemString("itemUngroup", "Grouping");
970 scrMenuMgr->addMenuItemString("itemGroupAdjust", "Grouping");
971 scrMenuMgr->createMenu("Locking", tr("Locking"), "Item");
972 scrMenuMgr->addMenuItemString("Locking", "Item");
973 scrMenuMgr->addMenuItemString("itemLock", "Locking");
974 scrMenuMgr->addMenuItemString("itemLockSize", "Locking");
975 scrMenuMgr->createMenu("ItemLevel", tr("Level"), "Item");
976 scrMenuMgr->addMenuItemString("ItemLevel", "Item");
977 scrMenuMgr->addMenuItemString("itemRaise", "ItemLevel");
978 scrMenuMgr->addMenuItemString("itemLower", "ItemLevel");
979 scrMenuMgr->addMenuItemString("itemRaiseToTop", "ItemLevel");
980 scrMenuMgr->addMenuItemString("itemLowerToBottom", "ItemLevel");
981 scrMenuMgr->createMenu("ItemLayer", tr("Send to La&yer"), QString(), false, true);
982 scrMenuMgr->addMenuItemString("ItemLayer", "Item");
983 scrMenuMgr->createMenu("SendTo", tr("Send to"), "Item");
984 scrMenuMgr->addMenuItemString("SendTo", "Item");
985 scrMenuMgr->createMenu("ItemSendToScrapbook", tr("Scrapbook"), QString(), false, true);
986 scrMenuMgr->addMenuItemString("ItemSendToScrapbook", "SendTo");
987 scrMenuMgr->addMenuItemString("itemSendToPattern", "SendTo");
988 scrMenuMgr->addMenuItemString("itemSendToInline", "SendTo");
989 scrMenuMgr->createMenu("Adjust", tr("Adjust"), "Item");
990 scrMenuMgr->addMenuItemString("Adjust", "Item");
991 scrMenuMgr->addMenuItemString("itemAdjustFrameHeightToText", "Adjust");
992 scrMenuMgr->addMenuItemString("itemAdjustFrameToImage", "Adjust");
993 scrMenuMgr->addMenuItemString("itemAdjustImageToFrame", "Adjust");
994 scrMenuMgr->createMenu("Image", tr("Image"), "Item");
995 scrMenuMgr->addMenuItemString("Image", "Item");
996 scrMenuMgr->addMenuItemString("itemUpdateImage", "Image");
997 scrMenuMgr->addMenuItemString("styleImageEffects", "Image");
998 scrMenuMgr->addMenuItemString("itemExtendedImageProperties", "Image");
999 scrMenuMgr->addMenuItemString("itemToggleInlineImage", "Image");
1000 scrMenuMgr->createMenu("ItemPreviewSettings", tr("Preview Settings"));
1001 scrMenuMgr->addMenuItemString("ItemPreviewSettings", "Image");
1002 scrMenuMgr->addMenuItemString("itemImageIsVisible", "ItemPreviewSettings");
1003 scrMenuMgr->addMenuItemString("SEPARATOR", "ItemPreviewSettings");
1004 scrMenuMgr->addMenuItemString("itemPreviewFull", "ItemPreviewSettings");
1005 scrMenuMgr->addMenuItemString("itemPreviewNormal", "ItemPreviewSettings");
1006 scrMenuMgr->addMenuItemString("itemPreviewLow", "ItemPreviewSettings");
1007 scrMenuMgr->createMenu("ItemPDFOptions", tr("P&DF Options"));
1008 scrMenuMgr->addMenuItemString("ItemPDFOptions", "Item");
1009 scrMenuMgr->addMenuItemString("itemPDFIsAnnotation", "ItemPDFOptions");
1010 scrMenuMgr->addMenuItemString("itemPDFIsBookmark", "ItemPDFOptions");
1011 scrMenuMgr->addMenuItemString("itemPDFAnnotationProps", "ItemPDFOptions");
1012 scrMenuMgr->addMenuItemString("itemPDFFieldProps", "ItemPDFOptions");
1013 scrMenuMgr->createMenu("ItemConvertTo", tr("C&onvert to"), "Item");
1014 scrMenuMgr->addMenuItemString("ItemConvertTo", "Item");
1015 scrMenuMgr->addMenuItemString("itemConvertToTextFrame", "ItemConvertTo");
1016 scrMenuMgr->addMenuItemString("itemConvertToImageFrame", "ItemConvertTo");
1017 scrMenuMgr->addMenuItemString("itemConvertToPolygon", "ItemConvertTo");
1018 scrMenuMgr->addMenuItemString("itemConvertToBezierCurve", "ItemConvertTo");
1019 scrMenuMgr->addMenuItemString("itemConvertToOutlines", "ItemConvertTo");
1020 scrMenuMgr->addMenuItemString("itemConvertToSymbolFrame", "ItemConvertTo");
1021 scrMenuMgr->createMenu("TextLinking", tr("Text Frame Links"), "Item");
1022 scrMenuMgr->addMenuItemString("TextLinking", "Item");
1023 scrMenuMgr->addMenuItemString("toolsLinkTextFrame", "TextLinking");
1024 scrMenuMgr->addMenuItemString("toolsUnlinkTextFrame", "TextLinking");
1025 scrMenuMgr->addMenuItemString("toolsUnlinkTextFrameAndCutText", "TextLinking");
1026 scrMenuMgr->createMenu("ItemPathOps", tr("Path Tools"), "Item");
1027 scrMenuMgr->addMenuItemString("ItemPathOps", "Item");
1028 scrMenuMgr->addMenuItemString("itemCombinePolygons", "ItemPathOps");
1029 scrMenuMgr->addMenuItemString("itemSplitPolygons", "ItemPathOps");
1030 scrMenuMgr->addMenuItemString("itemAttachTextToPath", "ItemPathOps");
1031 scrMenuMgr->addMenuItemString("itemDetachTextFromPath", "ItemPathOps");
1032
1033 scrActions["itemPrintingEnabled"]->setEnabled(false);
1034 scrMenuMgr->setMenuEnabled("ItemConvertTo", false);
1035
1036 scrMenuMgr->createMenu("Weld", tr("Welding"), "Item");
1037 scrMenuMgr->addMenuItemString("Weld", "Item");
1038 scrMenuMgr->addMenuItemString("itemWeld", "Weld");
1039 scrMenuMgr->addMenuItemString("itemsUnWeld", "Weld");
1040 scrMenuMgr->addMenuItemString("itemEditWeld", "Weld");
1041 scrMenuMgr->addMenuItemString("editMark", "Item");
1042
1043 //Insert menu
1044 scrMenuMgr->createMenu("Insert", ActionManager::defaultMenuNameEntryTranslated("Insert"));
1045 scrMenuMgr->addMenuItemString("insertFrame", "Insert");
1046 scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1047 scrMenuMgr->addMenuItemString("toolsInsertTextFrame", "Insert");
1048 scrMenuMgr->addMenuItemString("toolsInsertImageFrame", "Insert");
1049 scrMenuMgr->addMenuItemString("toolsInsertRenderFrame", "Insert");
1050 scrMenuMgr->addMenuItemString("toolsInsertTable", "Insert");
1051 scrMenuMgr->addMenuItemString("toolsInsertShape", "Insert");
1052 scrMenuMgr->addMenuItemString("toolsInsertPolygon", "Insert");
1053 scrMenuMgr->addMenuItemString("toolsInsertArc", "Insert");
1054 scrMenuMgr->addMenuItemString("toolsInsertSpiral", "Insert");
1055 scrMenuMgr->addMenuItemString("toolsInsertLine", "Insert");
1056 scrMenuMgr->addMenuItemString("toolsInsertBezier", "Insert");
1057 scrMenuMgr->addMenuItemString("toolsInsertFreehandLine", "Insert");
1058 scrMenuMgr->addMenuItemString("toolsInsertCalligraphicLine", "Insert");
1059 scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1060 scrMenuMgr->addMenuItemString("stickyTools", "Insert");
1061 scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1062 scrMenuMgr->addMenuItemString("insertGlyph", "Insert");
1063
1064 scrMenuMgr->createMenu("InsertChar", tr("&Character"), "Insert");
1065 scrMenuMgr->addMenuItemString("InsertChar", "Insert");
1066 scrMenuMgr->addMenuItemString("unicodePageNumber", "InsertChar");
1067 scrMenuMgr->addMenuItemString("unicodePageCount", "InsertChar");
1068 scrMenuMgr->addMenuItemString("unicodeSoftHyphen", "InsertChar");
1069 scrMenuMgr->addMenuItemString("unicodeNonBreakingHyphen", "InsertChar");
1070 scrMenuMgr->addMenuItemString("unicodeZWJ", "InsertChar");
1071 scrMenuMgr->addMenuItemString("unicodeZWNJ", "InsertChar");
1072 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
1073 scrMenuMgr->addMenuItemString("unicodeCopyRight", "InsertChar");
1074 scrMenuMgr->addMenuItemString("unicodeRegdTM", "InsertChar");
1075 scrMenuMgr->addMenuItemString("unicodeTM", "InsertChar");
1076 scrMenuMgr->addMenuItemString("unicodeSolidus", "InsertChar");
1077 scrMenuMgr->addMenuItemString("unicodeBullet", "InsertChar");
1078 scrMenuMgr->addMenuItemString("unicodeMidpoint", "InsertChar");
1079 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertChar");
1080 scrMenuMgr->addMenuItemString("unicodeDashEm", "InsertChar");
1081 scrMenuMgr->addMenuItemString("unicodeDashEn", "InsertChar");
1082 scrMenuMgr->addMenuItemString("unicodeDashFigure", "InsertChar");
1083 scrMenuMgr->addMenuItemString("unicodeDashQuotation", "InsertChar");
1084
1085 scrMenuMgr->createMenu("InsertQuote", tr("&Quote"), "Insert");
1086 scrMenuMgr->addMenuItemString("InsertQuote", "Insert");
1087 scrMenuMgr->addMenuItemString("unicodeQuoteApostrophe", "InsertQuote");
1088 scrMenuMgr->addMenuItemString("unicodeQuoteStraight", "InsertQuote");
1089 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1090 scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeft", "InsertQuote");
1091 scrMenuMgr->addMenuItemString("unicodeQuoteSingleRight", "InsertQuote");
1092 scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeft", "InsertQuote");
1093 scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRight", "InsertQuote");
1094 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1095 scrMenuMgr->addMenuItemString("unicodeQuoteSingleReversed", "InsertQuote");
1096 scrMenuMgr->addMenuItemString("unicodeQuoteDoubleReversed", "InsertQuote");
1097 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1098 scrMenuMgr->addMenuItemString("unicodeQuoteLowSingleComma", "InsertQuote");
1099 scrMenuMgr->addMenuItemString("unicodeQuoteLowDoubleComma", "InsertQuote");
1100 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1101 scrMenuMgr->addMenuItemString("unicodeQuoteSingleLeftGuillemet", "InsertQuote");
1102 scrMenuMgr->addMenuItemString("unicodeQuoteSingleRightGuillemet", "InsertQuote");
1103 scrMenuMgr->addMenuItemString("unicodeQuoteDoubleLeftGuillemet", "InsertQuote");
1104 scrMenuMgr->addMenuItemString("unicodeQuoteDoubleRightGuillemet", "InsertQuote");
1105 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertQuote");
1106 scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleLeft", "InsertQuote");
1107 scrMenuMgr->addMenuItemString("unicodeQuoteCJKSingleRight", "InsertQuote");
1108 scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleLeft", "InsertQuote");
1109 scrMenuMgr->addMenuItemString("unicodeQuoteCJKDoubleRight", "InsertQuote");
1110
1111 scrMenuMgr->createMenu("InsertSpace", tr("S&paces && Breaks"), "Insert");
1112 scrMenuMgr->addMenuItemString("InsertSpace", "Insert");
1113 scrMenuMgr->addMenuItemString("unicodeNonBreakingSpace", "InsertSpace");
1114 scrMenuMgr->addMenuItemString("unicodeNarrowNoBreakSpace", "InsertSpace");
1115 scrMenuMgr->addMenuItemString("unicodeSpaceEN", "InsertSpace");
1116 scrMenuMgr->addMenuItemString("unicodeSpaceEM", "InsertSpace");
1117 scrMenuMgr->addMenuItemString("unicodeSpaceThin", "InsertSpace");
1118 scrMenuMgr->addMenuItemString("unicodeSpaceThick", "InsertSpace");
1119 scrMenuMgr->addMenuItemString("unicodeSpaceMid", "InsertSpace");
1120 scrMenuMgr->addMenuItemString("unicodeSpaceHair", "InsertSpace");
1121 scrMenuMgr->addMenuItemString("SEPARATOR", "InsertSpace");
1122 scrMenuMgr->addMenuItemString("unicodeZerowidthSpace", "InsertSpace");
1123 scrMenuMgr->addMenuItemString("unicodeNewLine", "InsertSpace");
1124 scrMenuMgr->addMenuItemString("unicodeColumnBreak", "InsertSpace");
1125 scrMenuMgr->addMenuItemString("unicodeFrameBreak", "InsertSpace");
1126
1127 scrMenuMgr->createMenu("InsertLigature", tr("Liga&ture"), "Insert");
1128 scrMenuMgr->addMenuItemString("InsertLigature", "Insert");
1129 scrMenuMgr->addMenuItemString("unicodeLigature_ff", "InsertLigature");
1130 scrMenuMgr->addMenuItemString("unicodeLigature_fi", "InsertLigature");
1131 scrMenuMgr->addMenuItemString("unicodeLigature_fl", "InsertLigature");
1132 scrMenuMgr->addMenuItemString("unicodeLigature_ffi", "InsertLigature");
1133 scrMenuMgr->addMenuItemString("unicodeLigature_ffl", "InsertLigature");
1134 scrMenuMgr->addMenuItemString("unicodeLigature_ft", "InsertLigature");
1135 scrMenuMgr->addMenuItemString("unicodeLigature_st", "InsertLigature");
1136
1137 scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1138 scrMenuMgr->addMenuItemString("insertSampleText", "Insert");
1139 scrMenuMgr->addMenuItemString("SEPARATOR", "Insert");
1140 scrMenuMgr->createMenu("InsertMark", tr("Marks"), "Insert");
1141 scrMenuMgr->addMenuItemString("InsertMark", "Insert");
1142 scrMenuMgr->addMenuItemString("insertMarkAnchor", "InsertMark");
1143 scrMenuMgr->addMenuItemString("insertMarkNote", "InsertMark");
1144 scrMenuMgr->addMenuItemString("insertMarkItem", "InsertMark");
1145 scrMenuMgr->addMenuItemString("insertMark2Mark", "InsertMark");
1146 scrMenuMgr->addMenuItemString("insertMarkVariableText", "InsertMark");
1147
1148 //Page menu
1149 scrMenuMgr->createMenu("Page", ActionManager::defaultMenuNameEntryTranslated("Page"));
1150 scrMenuMgr->addMenuItemString("pageInsert", "Page");
1151 scrMenuMgr->addMenuItemString("pageImport", "Page");
1152 scrMenuMgr->addMenuItemString("pageDelete", "Page");
1153 scrMenuMgr->addMenuItemString("pageCopy", "Page");
1154 scrMenuMgr->addMenuItemString("pageMove", "Page");
1155 scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
1156 scrMenuMgr->addMenuItemString("pageApplyMasterPage", "Page");
1157 scrMenuMgr->addMenuItemString("pageCopyToMasterPage", "Page");
1158 scrMenuMgr->addMenuItemString("pageManageGuides", "Page");
1159 scrMenuMgr->addMenuItemString("pageManageProperties", "Page");
1160 scrMenuMgr->addMenuItemString("SEPARATOR", "Page");
1161 scrMenuMgr->addMenuItemString("viewSnapToGrid", "Page");
1162 scrMenuMgr->addMenuItemString("viewSnapToGuides", "Page");
1163 scrMenuMgr->addMenuItemString("viewSnapToElements", "Page");
1164
1165 //View menu
1166 scrMenuMgr->createMenu("View", ActionManager::defaultMenuNameEntryTranslated("View"));
1167 scrMenuMgr->createMenu("ViewZoom", tr("Zoom"), "View");
1168 scrMenuMgr->addMenuItemString("ViewZoom", "View");
1169 scrMenuMgr->addMenuItemString("viewFitInWindow", "ViewZoom");
1170 scrMenuMgr->addMenuItemString("viewFitWidth", "ViewZoom");
1171 scrMenuMgr->addMenuItemString("viewFit50", "ViewZoom");
1172 scrMenuMgr->addMenuItemString("viewFit75", "ViewZoom");
1173 scrMenuMgr->addMenuItemString("viewFit100", "ViewZoom");
1174 scrMenuMgr->addMenuItemString("viewFit200", "ViewZoom");
1175 scrMenuMgr->addMenuItemString("viewFit400", "ViewZoom");
1176 scrMenuMgr->createMenu("ViewPreview", tr("Preview"), "View");
1177 scrMenuMgr->addMenuItemString("ViewPreview", "View");
1178 scrMenuMgr->addMenuItemString("viewPreviewMode", "ViewPreview");
1179 scrMenuMgr->createMenu("ViewMeasuring", tr("Measurement"), "View");
1180 scrMenuMgr->addMenuItemString("ViewMeasuring", "View");
1181 scrMenuMgr->addMenuItemString("viewShowRulers", "ViewMeasuring");
1182 scrMenuMgr->addMenuItemString("viewRulerMode", "ViewMeasuring");
1183 scrMenuMgr->addMenuItemString("showMouseCoordinates", "ViewMeasuring");
1184 scrMenuMgr->createMenu("ViewTextFrames", tr("Text Frames"), "View");
1185 scrMenuMgr->addMenuItemString("ViewTextFrames", "View");
1186 scrMenuMgr->addMenuItemString("viewShowBaseline", "ViewTextFrames");
1187 scrMenuMgr->addMenuItemString("viewShowColumnBorders", "ViewTextFrames");
1188 scrMenuMgr->addMenuItemString("viewShowTextChain", "ViewTextFrames");
1189 scrMenuMgr->addMenuItemString("viewShowTextControls", "ViewTextFrames");
1190 scrMenuMgr->createMenu("ViewImageFrames", tr("Image Frames"), "View");
1191 scrMenuMgr->addMenuItemString("ViewImageFrames", "View");
1192 scrMenuMgr->addMenuItemString("viewShowImages", "ViewImageFrames");
1193 scrMenuMgr->createMenu("ViewDocument", tr("Document"), "View");
1194 scrMenuMgr->addMenuItemString("ViewDocument", "View");
1195 scrMenuMgr->addMenuItemString("viewShowMargins", "ViewDocument");
1196 scrMenuMgr->addMenuItemString("viewShowBleeds", "ViewDocument");
1197 scrMenuMgr->addMenuItemString("viewShowFrames", "ViewDocument");
1198 scrMenuMgr->addMenuItemString("viewShowLayerMarkers", "ViewDocument");
1199 scrMenuMgr->createMenu("ViewGrids", tr("Grids and Guides"), "View");
1200 scrMenuMgr->addMenuItemString("ViewGrids", "View");
1201 scrMenuMgr->addMenuItemString("viewShowGrid", "ViewGrids");
1202 scrMenuMgr->addMenuItemString("viewShowGuides", "ViewGrids");
1203
1204 //CB If this is viewNewView imeplemented, it should be on the windows menu
1205 // scrMenuMgr->addMenuItem(scrActions["viewNewView"], "View");
1206
1207 // Table menu.
1208 scrMenuMgr->createMenu("ItemTable", ActionManager::defaultMenuNameEntryTranslated("Table"));
1209 scrMenuMgr->addMenuItemString("tableInsertRows", "ItemTable");
1210 scrMenuMgr->addMenuItemString("tableInsertColumns", "ItemTable");
1211 scrMenuMgr->addMenuItemString("tableDeleteRows", "ItemTable");
1212 scrMenuMgr->addMenuItemString("tableDeleteColumns", "ItemTable");
1213 scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1214 scrMenuMgr->addMenuItemString("tableMergeCells", "ItemTable");
1215 scrMenuMgr->addMenuItemString("tableSplitCells", "ItemTable");
1216 scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1217 scrMenuMgr->addMenuItemString("tableSetRowHeights", "ItemTable");
1218 scrMenuMgr->addMenuItemString("tableSetColumnWidths", "ItemTable");
1219 scrMenuMgr->addMenuItemString("tableDistributeRowsEvenly", "ItemTable");
1220 scrMenuMgr->addMenuItemString("tableDistributeColumnsEvenly", "ItemTable");
1221 scrMenuMgr->addMenuItemString("SEPARATOR", "ItemTable");
1222 scrMenuMgr->addMenuItemString("tableAdjustFrameToTable", "ItemTable");
1223 scrMenuMgr->addMenuItemString("tableAdjustTableToFrame", "ItemTable");
1224
1225 //Extra menu
1226 scrMenuMgr->createMenu("Extras", ActionManager::defaultMenuNameEntryTranslated("Extras"));
1227 scrMenuMgr->addMenuItemString("extrasHyphenateText", "Extras");
1228 scrMenuMgr->addMenuItemString("extrasDeHyphenateText", "Extras");
1229 scrMenuMgr->addMenuItemString("extrasGenerateTableOfContents", "Extras");
1230 scrMenuMgr->addMenuItemString("itemUpdateMarks", "Extras");
1231 scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
1232 scrMenuMgr->addMenuItemString("extrasManageImages", "Extras");
1233 scrMenuMgr->addMenuItemString("SEPARATOR", "Extras");
1234 scrMenuMgr->addMenuItemString("extrasUpdateDocument", "Extras");
1235 // Disabled for release as it does nothing useful
1236 // scrMenuMgr->addMenuItemString("extrasTestQTQuick2_1", "Extras");
1237
1238 //Window menu
1239 scrMenuMgr->createMenu("Windows", ActionManager::defaultMenuNameEntryTranslated("Windows"), QString(), true);
1240
1241 //Help menu
1242 scrMenuMgr->createMenu("Help", ActionManager::defaultMenuNameEntryTranslated("Help"));
1243 scrMenuMgr->addMenuItemString("helpManual", "Help");
1244 scrMenuMgr->addMenuItemString("helpChat", "Help");
1245 scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1246 scrMenuMgr->addMenuItemString("helpActionSearch", "Help");
1247 scrMenuMgr->addMenuItemString("helpTooltips", "Help");
1248 scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1249 scrMenuMgr->addMenuItemString("helpOnlineWWW", "Help");
1250 scrMenuMgr->addMenuItemString("helpOnlineDocs", "Help");
1251 scrMenuMgr->addMenuItemString("helpOnlineWiki", "Help");
1252 scrMenuMgr->addMenuItemString("HelpOnlineTutorials", "Help");
1253 scrMenuMgr->addMenuItemString("helpOnlineTutorial1", "Help");
1254 scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1255 scrMenuMgr->addMenuItemString("helpCheckUpdates", "Help");
1256 scrMenuMgr->addMenuItemString("SEPARATOR", "Help");
1257 scrMenuMgr->addMenuItemString("helpAboutScribus", "Help");
1258 scrMenuMgr->addMenuItemString("helpAboutPlugins", "Help");
1259 scrMenuMgr->addMenuItemString("helpAboutQt", "Help");
1260 }
1261
createMenuBar()1262 void ScribusMainWindow::createMenuBar()
1263 {
1264 scrMenuMgr->addMenuStringToMenuBar("File");
1265 scrMenuMgr->addMenuItemStringsToMenuBar("File", scrActions);
1266 scrMenuMgr->addMenuStringToMenuBar("Edit");
1267 scrMenuMgr->addMenuItemStringsToMenuBar("Edit", scrActions);
1268 scrMenuMgr->addMenuStringToMenuBar("Item");
1269 scrMenuMgr->addMenuItemStringsToMenuBar("Item", scrActions);
1270 scrMenuMgr->addMenuStringToMenuBar("Insert");
1271 scrMenuMgr->addMenuItemStringsToMenuBar("Insert", scrActions);
1272 scrMenuMgr->addMenuStringToMenuBar("Page");
1273 scrMenuMgr->addMenuItemStringsToMenuBar("Page", scrActions);
1274 scrMenuMgr->addMenuStringToMenuBar("ItemTable");
1275 scrMenuMgr->addMenuItemStringsToMenuBar("ItemTable", scrActions);
1276 scrMenuMgr->addMenuStringToMenuBar("Extras");
1277 scrMenuMgr->addMenuItemStringsToMenuBar("Extras", scrActions);
1278 scrMenuMgr->addMenuStringToMenuBar("View");
1279 scrMenuMgr->addMenuItemStringsToMenuBar("View", scrActions);
1280 scrMenuMgr->addMenuStringToMenuBar("Windows", true);
1281 addDefaultWindowMenuItems();
1282 menuBar()->addSeparator();
1283 scrMenuMgr->addMenuStringToMenuBar("Help");
1284 scrMenuMgr->addMenuItemStringsToMenuBar("Help", scrActions);
1285 connect(scrMenuMgr->getLocalPopupMenu("Extras"), SIGNAL(aboutToShow()), this, SLOT(extrasMenuAboutToShow()));
1286 connect(scrMenuMgr->getLocalPopupMenu("Windows"), SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
1287
1288 }
1289
1290
addDefaultWindowMenuItems()1291 void ScribusMainWindow::addDefaultWindowMenuItems()
1292 {
1293 scrMenuMgr->clearMenu("Windows");
1294 scrMenuMgr->addMenuItemString("windowsCascade", "Windows");
1295 scrMenuMgr->addMenuItemString("windowsTile", "Windows");
1296 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1297 scrMenuMgr->addMenuItemString("toolsProperties", "Windows");
1298 scrMenuMgr->addMenuItemString("toolsContent", "Windows");
1299 scrMenuMgr->addMenuItemString("toolsActionHistory", "Windows");
1300 scrMenuMgr->addMenuItemString("toolsAlignDistribute", "Windows");
1301 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1302 scrMenuMgr->addMenuItemString("toolsOutline", "Windows");
1303 scrMenuMgr->addMenuItemString("toolsPages", "Windows");
1304 scrMenuMgr->addMenuItemString("toolsLayers", "Windows");
1305 scrMenuMgr->addMenuItemString("toolsBookmarks", "Windows");
1306 // scrMenuMgr->addMenuItemString("toolsDownloads", "Windows");
1307 scrMenuMgr->addMenuItemString("toolsResources", "Windows");
1308 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1309 scrMenuMgr->addMenuItemString("toolsScrapbook", "Windows");
1310 scrMenuMgr->addMenuItemString("toolsSymbols", "Windows");
1311 scrMenuMgr->addMenuItemString("toolsInline", "Windows");
1312 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1313 scrMenuMgr->addMenuItemString("toolsMeasurements", "Windows");
1314 scrMenuMgr->addMenuItemString("toolsPreflightVerifier", "Windows");
1315 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1316 scrMenuMgr->addMenuItemString("toolsToolbarTools", "Windows");
1317 scrMenuMgr->addMenuItemString("toolsToolbarPDF", "Windows");
1318 scrMenuMgr->addMenuItemString("toolsToolbarView", "Windows");
1319 scrMenuMgr->addMenuItemString("SEPARATOR", "Windows");
1320 scrMenuMgr->addMenuItemStringsToMenuBar("Windows", scrActions);
1321 }
1322
1323
initStatusBar()1324 void ScribusMainWindow::initStatusBar()
1325 {
1326 QFont fo = QFont(font());
1327 int posi = fo.pointSize() - (ScCore->isWinGUI() ? 1 : 2);
1328 fo.setPointSize(posi);
1329 unitSwitcher = new QComboBox( this );
1330 unitSwitcher->setObjectName("unitSwitcher");
1331 unitSwitcher->setFocusPolicy(Qt::NoFocus);
1332 unitSwitcher->setFont(fo);
1333 int maxUindex = unitGetMaxIndex() - 2;
1334 for (int i = 0; i <= maxUindex; ++i)
1335 unitSwitcher->addItem(unitGetStrFromIndex(i));
1336
1337
1338 QWidget* zoomWidget = new QWidget( statusBar() );
1339 QHBoxLayout* zoomLayout = new QHBoxLayout( zoomWidget );
1340 zoomLayout->setContentsMargins(0, 0, 0, 0);
1341 zoomLayout->setSpacing(3);
1342
1343 zoomSpinBox = new ScrSpinBox( 1, 32000, zoomWidget, 6 );
1344 zoomSpinBox->setFont(fo);
1345 zoomSpinBox->setValue( 100 );
1346 zoomSpinBox->setSingleStep(10);
1347 zoomSpinBox->setFocusPolicy(Qt::ClickFocus);
1348 zoomSpinBox->setSuffix( tr( " %" ) );
1349 layerMenu = new QComboBox( this );
1350 layerMenu->setObjectName("layerMenu");
1351 layerMenu->setEditable(false);
1352 layerMenu->setFont(fo);
1353 layerMenu->setFocusPolicy(Qt::NoFocus);
1354 layerMenu->setSizeAdjustPolicy(QComboBox::AdjustToContents);
1355
1356 pageSelector = new PageSelector(this, 1);
1357 pageSelector->setObjectName("pageSelector");
1358 pageSelector->setFont(fo);
1359 pageSelector->setFocusPolicy(Qt::ClickFocus);
1360
1361 zoomDefaultToolbarButton = new QPushButton(zoomWidget);
1362 zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
1363 zoomDefaultToolbarButton->setDefault( false );
1364 zoomDefaultToolbarButton->setAutoDefault( false );
1365 zoomOutToolbarButton = new QPushButton(zoomWidget);
1366 zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
1367 zoomOutToolbarButton->setDefault( false );
1368 zoomOutToolbarButton->setAutoDefault( false );
1369 zoomInToolbarButton = new QPushButton(zoomWidget);
1370 zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
1371 zoomInToolbarButton->setDefault( false );
1372 zoomInToolbarButton->setAutoDefault( false );
1373
1374 zoomDefaultToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-original.png"));
1375 zoomOutToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-out.png"));
1376 zoomInToolbarButton->setIcon(IconManager::instance().loadIcon("16/zoom-in.png"));
1377
1378 zoomLayout->addWidget( zoomSpinBox );
1379 zoomLayout->addWidget( zoomOutToolbarButton );
1380 zoomLayout->addWidget( zoomDefaultToolbarButton );
1381 zoomLayout->addWidget( zoomInToolbarButton );
1382
1383 m_mainWindowStatusLabel = new QLabel( " ", statusBar());
1384 m_mainWindowStatusLabel->setFont(fo);
1385 mainWindowProgressBar = new QProgressBar(statusBar());
1386 mainWindowProgressBar->setAlignment(Qt::AlignHCenter);
1387 mainWindowProgressBar->setFixedWidth( 100 );
1388 mainWindowProgressBar->reset();
1389 mainWindowXPosLabel = new QLabel( tr("X:"), statusBar());
1390 mainWindowXPosLabel->setFont(fo);
1391 mainWindowYPosLabel = new QLabel( tr("Y:"), statusBar());
1392 mainWindowYPosLabel->setFont(fo);
1393 mainWindowXPosDataLabel = new QLabel(QString(), statusBar());
1394 mainWindowXPosDataLabel->setFont(fo);
1395 mainWindowYPosDataLabel = new QLabel(QString(), statusBar());
1396 mainWindowYPosDataLabel->setFont(fo);
1397 mainWindowXPosDataLabel->setMinimumWidth(mainWindowXPosDataLabel->fontMetrics().horizontalAdvance("99999.999"));
1398 mainWindowYPosDataLabel->setMinimumWidth(mainWindowYPosDataLabel->fontMetrics().horizontalAdvance("99999.999"));
1399 statusBarLanguageChange();
1400
1401 layerMenu->setObjectName("layerMenu");
1402 unitSwitcher->setObjectName("unitSwitcher");
1403 zoomDefaultToolbarButton->setObjectName("zoomDefaultToolbarButton");
1404 zoomInToolbarButton->setObjectName("zoomInToolbarButton");
1405 zoomOutToolbarButton->setObjectName("zoomOutToolbarButton");
1406 zoomSpinBox->setObjectName("zoomSpinBox");
1407
1408 statusBar()->setFont(fo);
1409 statusBar()->addPermanentWidget(m_mainWindowStatusLabel, 5);
1410 QLabel *s = new QLabel(QString());
1411 QLabel *s2 = new QLabel(QString());
1412 QLabel *s3 = new QLabel(QString());
1413 statusBar()->addPermanentWidget(s,1);
1414 statusBar()->addPermanentWidget(s2,1);
1415 statusBar()->addPermanentWidget(zoomWidget,0);
1416 statusBar()->addPermanentWidget(pageSelector,0);
1417 statusBar()->addPermanentWidget(layerMenu,1);
1418 statusBar()->addPermanentWidget(s3,3);
1419 statusBar()->addPermanentWidget(mainWindowXPosLabel, 0);
1420 statusBar()->addPermanentWidget(mainWindowXPosDataLabel, 0);
1421 statusBar()->addPermanentWidget(mainWindowYPosLabel, 0);
1422 statusBar()->addPermanentWidget(mainWindowYPosDataLabel, 0);
1423
1424 statusBar()->addPermanentWidget(unitSwitcher,0);
1425 statusBar()->addPermanentWidget(mainWindowProgressBar, 0);
1426 connect(statusBar(), SIGNAL(messageChanged(const QString &)), this, SLOT(setTempStatusBarText(const QString &)));
1427
1428 }
1429
1430
setStatusBarMousePosition(double xp,double yp)1431 void ScribusMainWindow::setStatusBarMousePosition(double xp, double yp)
1432 {
1433 if (!HaveDoc)
1434 {
1435 mainWindowXPosDataLabel->clear();
1436 mainWindowYPosDataLabel->clear();
1437 return;
1438 }
1439 if (doc->Pages->count() == 0)
1440 return;
1441 double xn = xp;
1442 double yn = yp;
1443 if (doc->guidesPrefs().rulerMode)
1444 {
1445 xn -= doc->currentPage()->xOffset();
1446 yn -= doc->currentPage()->yOffset();
1447 }
1448 xn -= doc->rulerXoffset;
1449 yn -= doc->rulerYoffset;
1450 mainWindowXPosDataLabel->setText(value2String(xn, doc->unitIndex(), true, false));
1451 mainWindowYPosDataLabel->setText(value2String(yn, doc->unitIndex(), true, false));
1452 }
1453
setStatusBarTextPosition(double base,double xp)1454 void ScribusMainWindow::setStatusBarTextPosition(double base, double xp)
1455 {
1456 if (doc->Pages->count() == 0)
1457 return;
1458 mainWindowXPosDataLabel->setText(base + xp >= 0? value2String(xp, doc->unitIndex(), true, true): QString("-"));
1459 mainWindowYPosDataLabel->setText("-");
1460 }
1461
setStatusBarTextSelectedItemInfo()1462 void ScribusMainWindow::setStatusBarTextSelectedItemInfo()
1463 {
1464 const int docSelectionCount = doc->m_Selection->count();
1465 if (docSelectionCount == 0)
1466 {
1467 setStatusBarInfoText("");
1468 return;
1469 }
1470 QString widthTxt = value2String(doc->m_Selection->width(), doc->unitIndex(), true, true);
1471 QString heightTxt = value2String(doc->m_Selection->height(), doc->unitIndex(), true, true);
1472 if (docSelectionCount == 1)
1473 {
1474 QString whatSel = tr("Unknown");
1475 switch (doc->m_Selection->itemAt(0)->itemType())
1476 {
1477 case 2:
1478 whatSel = CommonStrings::itemType_ImageFrame;
1479 break;
1480 case 4:
1481 whatSel = CommonStrings::itemType_TextFrame;
1482 break;
1483 case 5:
1484 whatSel = CommonStrings::itemType_Line;
1485 break;
1486 case 6:
1487 whatSel = CommonStrings::itemType_Polygon;
1488 break;
1489 case 7:
1490 whatSel = CommonStrings::itemType_Polyline;
1491 break;
1492 case 8:
1493 whatSel = CommonStrings::itemType_PathText;
1494 break;
1495 case 9:
1496 whatSel = CommonStrings::itemType_LatexFrame;
1497 break;
1498 case 11:
1499 whatSel = CommonStrings::itemType_Symbol;
1500 break;
1501 case 12:
1502 whatSel = CommonStrings::itemType_Group;
1503 break;
1504 case 13:
1505 whatSel = CommonStrings::itemType_RegularPolygon;
1506 break;
1507 case 14:
1508 whatSel = CommonStrings::itemType_Arc;
1509 break;
1510 case 15:
1511 whatSel = CommonStrings::itemType_Spiral;
1512 break;
1513 case 16:
1514 whatSel = CommonStrings::itemType_Table;
1515 break;
1516 default:
1517 whatSel = "Unknown";
1518 break;
1519 }
1520 QString txtBody = tr("%1 selected").arg(whatSel) + " : " + tr("Size");
1521 setStatusBarInfoText( QString("%1 = %3 x %4").arg(txtBody, widthTxt, heightTxt));
1522 }
1523 else
1524 {
1525 setStatusBarInfoText( tr("%1 Objects selected, Selection Size = %2 x %3").arg(docSelectionCount).arg(widthTxt, heightTxt));
1526 }
1527 }
1528
setTempStatusBarText(const QString & text)1529 void ScribusMainWindow::setTempStatusBarText(const QString &text)
1530 {
1531 if (m_mainWindowStatusLabel)
1532 {
1533 if (text.isEmpty())
1534 m_mainWindowStatusLabel->setText(m_statusLabelText);
1535 else
1536 m_mainWindowStatusLabel->setText(text);
1537 }
1538 }
1539
setStatusBarInfoText(const QString & newText)1540 void ScribusMainWindow::setStatusBarInfoText(const QString & newText)
1541 {
1542 if (m_mainWindowStatusLabel)
1543 m_mainWindowStatusLabel->setText(newText);
1544 m_statusLabelText = newText;
1545 }
1546
1547
1548 //AV to be replaced with Selection::update and listener in contentPalette
setTBvals(PageItem * currItem)1549 void ScribusMainWindow::setTBvals(PageItem *currItem)
1550 {
1551 scrActions["editMark"]->setEnabled(false);
1552
1553 PageItem* item = currItem;
1554 bool inEditMode = (doc->appMode == modeEdit);
1555 if (doc->appMode == modeEditTable)
1556 {
1557 if (currItem->isTable())
1558 item = currItem->asTable()->activeCell().textFrame();
1559 inEditMode = item->isTextFrame();
1560 }
1561 if (!item || item->itemText.length() <= 0)
1562 return;
1563
1564 const ParagraphStyle& currPStyle(inEditMode ? item->currentStyle() : item->itemText.defaultStyle());
1565 setAlignmentValue(currPStyle.alignment());
1566
1567 // Assignment operator does not perform style context assignment
1568 // Do it in this case, otherwise we might get some crashes if previous
1569 // text object was deleted or things like that
1570 const ParagraphStyle& curStyle = item->currentStyle();
1571 doc->currentStyle.setContext(curStyle.context());
1572 doc->currentStyle = curStyle;
1573 if (doc->appMode == modeEdit || doc->appMode == modeEditTable)
1574 item->currentTextProps(doc->currentStyle);
1575 else
1576 doc->currentStyle.charStyle().setStyle(item->currentCharStyle());
1577 emit TextStyle(doc->currentStyle);
1578 // to go: (av)
1579 contentPalette->update(doc->currentStyle);
1580 //check if mark in cursor place and enable editMark action
1581 if (doc->appMode == modeEdit && item->itemText.cursorPosition() < item->itemText.length())
1582 {
1583 if (item->itemText.hasMark(item->itemText.cursorPosition()))
1584 {
1585 Mark* mark = item->itemText.mark(item->itemText.cursorPosition());
1586 scrActions["editMark"]->setEnabled(true);
1587 if ((mark->isType(MARKNoteMasterType) || mark->isType(MARKNoteFrameType)) && (mark->getNotePtr() != nullptr))
1588 nsEditor->setNotesStyle(mark->getNotePtr()->notesStyle());
1589 }
1590 else
1591 scrActions["editMark"]->setEnabled(false);
1592 }
1593 }
1594
1595 //Special keys assigned to actions are stolen by the action and not passed to
1596 //keyPressEvent so process them here.
specialActionKeyEvent(int unicodevalue)1597 void ScribusMainWindow::specialActionKeyEvent(int unicodevalue)
1598 {
1599 if (!HaveDoc)
1600 return;
1601 if (doc->m_Selection->count() != 1)
1602 return;
1603 if ((doc->appMode != modeEdit) && (doc->appMode != modeEditTable))
1604 return;
1605
1606 PageItem* selItem = doc->m_Selection->itemAt(0);
1607 if (!selItem->isTextFrame() && !selItem->isTable())
1608 return;
1609
1610 PageItem_TextFrame *currItem;
1611 if (doc->appMode == modeEditTable)
1612 currItem = selItem->asTable()->activeCell().textFrame();
1613 else
1614 currItem = selItem->asTextFrame();
1615 if (currItem == nullptr)
1616 return;
1617
1618 if (unicodevalue!=-1)
1619 {
1620 UndoTransaction activeTransaction;
1621 if (currItem->HasSel)
1622 {
1623 if (UndoManager::undoEnabled())
1624 activeTransaction = m_undoManager->beginTransaction(Um::Selection, Um::IGroup, Um::ReplaceText, QString(), Um::IDelete);
1625 currItem->deleteSelectedTextFromFrame();
1626 }
1627 if (UndoManager::undoEnabled())
1628 {
1629 SimpleState *ss = dynamic_cast<SimpleState*>(m_undoManager->getLastUndo());
1630 UndoObject *undoTarget = currItem;
1631 if (ss && (ss->get("ETEA") == "insert_frametext") && (ss->undoObject() == undoTarget))
1632 ss->set("TEXT_STR", ss->get("TEXT_STR") + QString(QChar(unicodevalue)));
1633 else
1634 {
1635 ss = new SimpleState(Um::InsertText, QString(), Um::ICreate);
1636 ss->set("INSERT_FRAMETEXT");
1637 ss->set("ETEA", QString("insert_frametext"));
1638 ss->set("TEXT_STR", QString(QChar(unicodevalue)));
1639 ss->set("START", currItem->itemText.cursorPosition());
1640 if (currItem->isNoteFrame())
1641 {
1642 undoTarget = doc;
1643 ss->set("noteframeName", currItem->getUName());
1644 }
1645 m_undoManager->action(undoTarget, ss);
1646 }
1647 }
1648 currItem->itemText.insertChars(QString(QChar(unicodevalue)), true);
1649 if (activeTransaction)
1650 activeTransaction.commit();
1651 }
1652 else if (unicodevalue == SpecialChars::SHYPHEN.unicode()) //ignore the char as we use an attribute if the text item, for now.
1653 {
1654 // this code is currently dead since unicodeSoftHyphen
1655 // doesn't have unicodevalue == -1 any more
1656 if (currItem->itemText.cursorPosition() <= 1)
1657 return;
1658 #if 0
1659 StyleFlag fl = currItem->itemText.item(qMax(currItem->CPos-1,0))->effects();
1660 fl |= ScStyle_HyphenationPossible;
1661 currItem->itemText.item(qMax(currItem->CPos-1,0))->setEffects(fl);
1662 #else
1663 if (UndoManager::undoEnabled())
1664 {
1665 SimpleState *ss = dynamic_cast<SimpleState*>(m_undoManager->getLastUndo());
1666 UndoObject *undoTarget = currItem;
1667 if (ss && (ss->get("ETEA") == "insert_frametext") && (ss->undoObject() == undoTarget))
1668 ss->set("TEXT_STR", ss->get("TEXT_STR") + QString(SpecialChars::SHYPHEN));
1669 else
1670 {
1671 ss = new SimpleState(Um::InsertText, QString(), Um::ICreate);
1672 ss->set("INSERT_FRAMETEXT");
1673 ss->set("ETEA", QString("insert_frametext"));
1674 ss->set("TEXT_STR", QString(SpecialChars::SHYPHEN));
1675 ss->set("START", currItem->itemText.cursorPosition());
1676 if (currItem->isNoteFrame())
1677 {
1678 undoTarget = doc;
1679 ss->set("noteframeName", currItem->getUName());
1680 }
1681 m_undoManager->action(undoTarget, ss);
1682 }
1683 }
1684 currItem->itemText.insertChars(QString(SpecialChars::SHYPHEN), true);
1685 #endif
1686 }
1687 if (doc->appMode == modeEditTable)
1688 selItem->asTable()->update();
1689 else
1690 currItem->update();
1691 }
1692
eventFilter(QObject *,QEvent * e)1693 bool ScribusMainWindow::eventFilter( QObject* /*o*/, QEvent *e )
1694 {
1695 if (e->type() == QEvent::ToolTip)
1696 return (!m_prefsManager.appPrefs.displayPrefs.showToolTips);
1697
1698 bool retVal = false;
1699 if (e->type() == QEvent::KeyPress)
1700 {
1701 QKeyEvent *k = dynamic_cast<QKeyEvent *>(e);
1702 if (!k)
1703 return false;
1704 int keyMod=0;
1705 if (k->modifiers() & Qt::ShiftModifier)
1706 keyMod |= Qt::SHIFT;
1707 if (k->modifiers() & Qt::ControlModifier)
1708 keyMod |= Qt::CTRL;
1709 if (k->modifiers() & Qt::AltModifier)
1710 keyMod |= Qt::ALT;
1711
1712 QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
1713 if (QString(currKeySeq.toString()).isNull())
1714 return false;
1715 retVal = true;
1716 //Palette actions
1717 if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllPalettes"))
1718 scrActions["specialToggleAllPalettes"]->activate(QAction::Trigger);
1719 else if (actionManager->compareKeySeqToShortcut(currKeySeq, "specialToggleAllGuides"))
1720 scrActions["specialToggleAllGuides"]->activate(QAction::Trigger);
1721 else
1722 retVal = false;
1723 }
1724 else if (e->type() == QEvent::KeyRelease)
1725 {
1726 QKeyEvent *k = dynamic_cast<QKeyEvent *>(e);
1727 if (!k)
1728 return false;
1729 #if defined(Q_OS_MAC)
1730 if ((k->key() == Qt::Key_QuoteLeft) && (k->modifiers() & Qt::ControlModifier))
1731 {
1732 if (k->modifiers() & Qt::ShiftModifier)
1733 mdiArea->activatePreviousSubWindow();
1734 else
1735 mdiArea->activateNextSubWindow();
1736 retVal = true;
1737 }
1738 #endif
1739 }
1740 //Return false to pass event to object
1741 return retVal;
1742 }
1743
1744
inputMethodEvent(QInputMethodEvent * event)1745 void ScribusMainWindow::inputMethodEvent ( QInputMethodEvent * event )
1746 {
1747 //qDebug() << "IMEmw" << event->commitString() << event->preeditString() << "attributes:" << event->attributes().count();
1748 }
1749
inputMethodQuery(Qt::InputMethodQuery query) const1750 QVariant ScribusMainWindow::inputMethodQuery ( Qt::InputMethodQuery query ) const
1751 {
1752 //qDebug() << "IMQmw" << query;
1753 return QVariant();
1754 }
1755
1756 //AV -> CanvasMode
keyPressEvent(QKeyEvent * k)1757 void ScribusMainWindow::keyPressEvent(QKeyEvent *k)
1758 {
1759 if (HaveDoc && view && (view->hasFocus() || view->widget()->hasFocus()))
1760 {
1761 view->canvasMode()->keyPressEvent(k);
1762 return;
1763 }
1764
1765 QMainWindow::keyPressEvent(k);
1766 }
1767
keyReleaseEvent(QKeyEvent * k)1768 void ScribusMainWindow::keyReleaseEvent(QKeyEvent *k)
1769 {
1770 if (HaveDoc && view && (view->hasFocus() || view->widget()->hasFocus()))
1771 {
1772 view->canvasMode()->keyReleaseEvent(k);
1773 return;
1774 }
1775
1776 QMainWindow::keyReleaseEvent(k);
1777 }
1778
changeEvent(QEvent * e)1779 void ScribusMainWindow::changeEvent(QEvent *e)
1780 {
1781 if (e->type() == QEvent::LanguageChange)
1782 languageChange();
1783 else
1784 QMainWindow::changeEvent(e);
1785 }
1786
closeEvent(QCloseEvent * ce)1787 void ScribusMainWindow::closeEvent(QCloseEvent *ce)
1788 {
1789 //Do not quit if Preferences or new doc window is open
1790 PreferencesDialog *prefsDialog = findChild<PreferencesDialog *>(QString::fromLocal8Bit("PreferencesDialog"));
1791 NewDocDialog *newDocWin = findChild<NewDocDialog *>(QString::fromLocal8Bit("NewDocumentWindow"));
1792 if (prefsDialog != nullptr || newDocWin != nullptr)
1793 {
1794 ce->ignore();
1795 return;
1796 }
1797 QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
1798 ScribusWin* tw;
1799 disconnect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(newActWin(QMdiSubWindow *)));
1800 if (!windows.isEmpty())
1801 {
1802 int windowCount = windows.count();
1803 for ( int i = 0; i < windowCount; ++i )
1804 {
1805 tw = qobject_cast<ScribusWin *>(windows.at(i));
1806 QMdiSubWindow *tws = windows.at(i);
1807 ScribusWin* scw = dynamic_cast<ScribusWin *>(tws->widget());
1808 if (scw)
1809 {
1810 newActWin(windows.at(i));
1811 tw = ActWin;
1812 slotSelect();
1813 tws->close();
1814 if (tw == ActWin)
1815 {
1816 ce->ignore();
1817 connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(newActWin(QMdiSubWindow*)));
1818 return;
1819 }
1820 }
1821 }
1822 }
1823 fileToolBar->connectPrefsSlot(false);
1824 editToolBar->connectPrefsSlot(false);
1825 modeToolBar->connectPrefsSlot(false);
1826 pdfToolBar->connectPrefsSlot(false);
1827
1828 m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.clear();
1829 QList<QTabBar *> bars = findChildren<QTabBar *>(QString());
1830 for (int i = 0; i < bars.count(); ++i)
1831 {
1832 QTabBar *bar = bars[i];
1833 tabPrefs currentTab;
1834 for (int ii = 0; ii < bar->count(); ii++)
1835 {
1836 currentTab.activeTab = bar->currentIndex();
1837 QObject *obj = (QObject*)bar->tabData(ii).toULongLong();
1838 if (obj != nullptr)
1839 currentTab.palettes.append(obj->objectName());
1840 }
1841 if (!currentTab.palettes.isEmpty())
1842 m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.append(currentTab);
1843 }
1844
1845 propertiesPalette->hide();
1846 contentPalette->hide();
1847 outlinePalette->hide();
1848 scrapbookPalette->hide();
1849 bookmarkPalette->hide();
1850 downloadsPalette->hide();
1851 layerPalette->hide();
1852 pagePalette->hide();
1853 docCheckerPalette->hide();
1854 undoPalette->hide();
1855 alignDistributePalette->hide();
1856 guidePalette->hide();
1857 charPalette->hide();
1858 symbolPalette->hide();
1859 inlinePalette->hide();
1860
1861 // Clean up plugins, THEN save prefs to disk
1862 ScCore->pluginManager->cleanupPlugins();
1863 if (!m_prefsManager.appPrefs.scrapbookPrefs.persistentScrapbook)
1864 scrapbookPalette->cleanUpTemp();
1865 m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks.clear();
1866 m_prefsManager.appPrefs.scrapbookPrefs.RecentScrapbooks = scrapbookPalette->getOpenScrapbooks();
1867 if (!emergencyActivated)
1868 m_prefsManager.savePrefs();
1869 UndoManager::deleteInstance();
1870 FormatsManager::deleteInstance();
1871 // qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1872 ce->accept();
1873 }
1874
requestUpdate(int val)1875 void ScribusMainWindow::requestUpdate(int val)
1876 {
1877 emit UpdateRequest(val);
1878 }
1879
1880 /////////////////////////////////////////////////////////////////////
1881 // SLOT IMPLEMENTATION
1882 /////////////////////////////////////////////////////////////////////
1883
1884 /*
1885 bool ScribusMainWindow::arrowKeyDown()
1886 {
1887 return m_arrowKeyDown;
1888 }
1889 */
1890
findRecoverableFile()1891 QStringList ScribusMainWindow::findRecoverableFile()
1892 {
1893 QSet<QString> foundFiles;
1894 QDir::SortFlags sortflags = QDir::Name | QDir::Time;
1895 QDir::Filters filterflags = QDir::Files | QDir::NoSymLinks | QDir::NoDot | QDir::NoDotDot;
1896 if (!m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir.isEmpty())
1897 {
1898 QDir dirAuto(m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir, "*_emergency_*.sla", sortflags, filterflags);
1899 QFileInfoList aList = dirAuto.entryInfoList();
1900 if (aList.count() > 0)
1901 {
1902 for (int i = 0; i < aList.count(); i++)
1903 foundFiles.insert(aList[i].absoluteFilePath());
1904 }
1905 QDir dirAuto2(m_prefsManager.appPrefs.docSetupPrefs.AutoSaveDir, "*_autosave_*.sla", sortflags, filterflags);
1906 QFileInfoList aList2 = dirAuto2.entryInfoList();
1907 if (aList2.count() > 0)
1908 {
1909 for (int i = 0; i < aList2.count(); i++)
1910 foundFiles.insert(aList2[i].absoluteFilePath());
1911 }
1912 }
1913 QDir dirDoc(m_prefsManager.documentDir(), "*_emergency_*.sla", sortflags, filterflags);
1914 QFileInfoList dList = dirDoc.entryInfoList();
1915 for (int i = 0; i < dList.count(); i++)
1916 foundFiles.insert(dList[i].absoluteFilePath());
1917
1918 QDir dirDoc2(m_prefsManager.documentDir(), "*_autosave_*.sla", sortflags, filterflags);
1919 QFileInfoList dList2 = dirDoc2.entryInfoList();
1920 for (int i = 0; i < dList2.count(); i++)
1921 foundFiles.insert(dList2[i].absoluteFilePath());
1922
1923 QDir dirHome(QDir::toNativeSeparators(QDir::homePath()), "*_emergency_*.sla", sortflags, filterflags);
1924 QFileInfoList hList = dirHome.entryInfoList();
1925 for (int i = 0; i < hList.count(); i++)
1926 foundFiles.insert(hList[i].absoluteFilePath());
1927
1928 QDir dirHome2(QDir::toNativeSeparators(QDir::homePath()), "*_autosave_*.sla", sortflags, filterflags);
1929 QFileInfoList hList2 = dirHome2.entryInfoList();
1930 for (int i = 0; i < hList2.count(); i++)
1931 foundFiles.insert(hList2[i].absoluteFilePath());
1932
1933 return foundFiles.values();
1934 }
1935
recoverFile(const QStringList & foundFiles)1936 bool ScribusMainWindow::recoverFile(const QStringList& foundFiles)
1937 {
1938 appModeHelper->setStartupActionsEnabled(false);
1939 bool ret = false;
1940 RecoverDialog* dia = new RecoverDialog(this, foundFiles);
1941 if (dia->exec())
1942 {
1943 if (!dia->recoverFiles.isEmpty())
1944 {
1945 for (int i = 0; i < dia->recoverFiles.count(); ++i)
1946 {
1947 loadDoc(dia->recoverFiles[i]);
1948 doc->setDocumentFileName(dia->recoverNames[i]);
1949 doc->hasName = true;
1950 updateActiveWindowCaption(doc->documentFileName());
1951 outlinePalette->setDoc(doc);
1952 if (outlinePalette->isVisible())
1953 outlinePalette->BuildTree();
1954 }
1955 ret = true;
1956 }
1957 }
1958 delete dia;
1959 return ret;
1960 }
1961
startUpDialog()1962 void ScribusMainWindow::startUpDialog()
1963 {
1964 bool docSet = false;
1965 PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
1966 NewDocDialog* dia = new NewDocDialog(this, m_recentDocsList, true, ScCore->getGuiLanguage());
1967 if (dia->exec())
1968 {
1969 if (dia->tabSelected() == NewDocDialog::NewDocumentTab)
1970 {
1971 int facingPages = dia->choosenLayout();
1972 int firstPage = dia->firstPage->currentIndex();
1973 docSet = dia->startDocSetup->isChecked();
1974 double topMargin = dia->marginGroup->top();
1975 double bottomMargin = dia->marginGroup->bottom();
1976 double leftMargin = dia->marginGroup->left();
1977 double rightMargin = dia->marginGroup->right();
1978 double columnDistance = dia->distance();
1979 double pageWidth = dia->pageWidth();
1980 double pageHeight = dia->pageHeight();
1981 double numberCols = dia->numberOfCols->value();
1982 bool autoframes = dia->autoTextFrame->isChecked();
1983 int orientation = dia->orientation();
1984 int pageCount=dia->pageCountSpinBox->value();
1985 QString pagesize;
1986 if (dia->pageSizeComboBox->currentText() == CommonStrings::trCustomPageSize)
1987 pagesize = CommonStrings::customPageSize;
1988 else
1989 {
1990 PageSize ps2(dia->pageSizeComboBox->currentText());
1991 pagesize = ps2.name();
1992 }
1993 doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentIndex(), firstPage, orientation, 1, pagesize, true, pageCount, true, dia->marginGroup->getMarginPreset());
1994 doc->setPageSetFirstPage(facingPages, firstPage);
1995 doc->bleeds()->set(dia->bleedTop(), dia->bleedLeft(), dia->bleedBottom(), dia->bleedRight());
1996 HaveNewDoc();
1997 doc->reformPages(true);
1998 // Don's disturb user with "save?" dialog just after new doc
1999 // doc changing should be rewritten maybe... maybe later...
2000 doc->setModified(false);
2001 updateActiveWindowCaption(doc->documentFileName());
2002 }
2003 else if (dia->tabSelected() == NewDocDialog::NewFromTemplateTab)
2004 {
2005 QString fileName = QDir::cleanPath(dia->selectedFile());
2006 if (!fileName.isEmpty() && loadDoc(fileName))
2007 {
2008 doc->hasName = false;
2009 UndoManager::instance()->renameStack(dia->nftGui->currentDocumentTemplate->name);
2010 doc->setDocumentFileName(dia->nftGui->currentDocumentTemplate->name);
2011 updateActiveWindowCaption(QObject::tr("Document Template: ") + dia->nftGui->currentDocumentTemplate->name);
2012 QDir::setCurrent(PrefsManager::instance().documentDir());
2013 removeRecent(fileName);
2014 }
2015 }
2016 else if (dia->tabSelected() == NewDocDialog::OpenExistingTab)
2017 {
2018 QString fileName = dia->selectedFile();
2019 if (!fileName.isEmpty())
2020 {
2021 QFileInfo fi(fileName);
2022 docContext->set("docsopen", fi.absolutePath());
2023 loadDoc(fileName);
2024 }
2025 }
2026 else // NewDocDialog::OpenRecentTab
2027 {
2028 QString fileName = dia->selectedFile();
2029 if (!fileName.isEmpty())
2030 loadRecent(fileName);
2031 }
2032 }
2033 else
2034 {
2035 appModeHelper->setStartupActionsEnabled(false);
2036 }
2037 m_prefsManager.setShowStartupDialog(!dia->startUpDialog->isChecked());
2038 delete dia;
2039 m_mainWindowStatusLabel->setText( tr("Ready"));
2040 if (docSet)
2041 slotDocSetup();
2042 }
2043
slotFileNew()2044 bool ScribusMainWindow::slotFileNew()
2045 {
2046 if (HaveDoc && doc->appMode == modeEditClip)
2047 view->requestMode(submodeEndNodeEdit);
2048 bool retVal = false;
2049 bool docSet = false;
2050 NewDocDialog* dia = new NewDocDialog(this, m_recentDocsList);
2051 if (dia->exec())
2052 {
2053 int facingPages = dia->choosenLayout();
2054 int firstPage = dia->firstPage->currentIndex();
2055 docSet = dia->startDocSetup->isChecked();
2056 double topMargin = dia->marginGroup->top();
2057 double bottomMargin = dia->marginGroup->bottom();
2058 double leftMargin = dia->marginGroup->left();
2059 double rightMargin = dia->marginGroup->right();
2060 double columnDistance = dia->distance();
2061 double pageWidth = dia->pageWidth();
2062 double pageHeight = dia->pageHeight();
2063 double numberCols = dia->numberOfCols->value();
2064 bool autoframes = dia->autoTextFrame->isChecked();
2065 int orientation = dia->orientation();
2066 int pageCount=dia->pageCountSpinBox->value();
2067 QString pagesize;
2068 if (dia->pageSizeComboBox->currentText() == CommonStrings::trCustomPageSize)
2069 pagesize = CommonStrings::customPageSize;
2070 else
2071 {
2072 PageSize ps2(dia->pageSizeComboBox->currentText());
2073 pagesize = ps2.name();
2074 }
2075 if (doFileNew(pageWidth, pageHeight, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, numberCols, autoframes, facingPages, dia->unitOfMeasureComboBox->currentIndex(), firstPage, orientation, 1, pagesize, true, pageCount, true, dia->marginGroup->getMarginPreset()))
2076 {
2077 doc->setPageSetFirstPage(facingPages, firstPage);
2078 doc->bleeds()->set(dia->bleedTop(), dia->bleedLeft(), dia->bleedBottom(), dia->bleedRight());
2079 m_mainWindowStatusLabel->setText( tr("Ready"));
2080 HaveNewDoc();
2081 doc->reformPages(true);
2082 retVal = true;
2083 // Don's disturb user with "save?" dialog just after new doc
2084 // doc changing should be rewritten maybe... maybe later...
2085 doc->setModified(false);
2086 updateActiveWindowCaption(doc->documentFileName());
2087 }
2088 }
2089 delete dia;
2090 if (docSet)
2091 slotDocSetup();
2092 return retVal;
2093 }
2094
2095 //TODO move to core, assign doc to doc list, optionally create gui for it
newDoc(double width,double height,double topMargin,double leftMargin,double rightMargin,double bottomMargin,double columnDistance,double columnCount,bool autoTextFrames,int pageArrangement,int unitIndex,int firstPageLocation,int orientation,int firstPageNumber,const QString & defaultPageSize,bool requiresGUI,int pageCount,bool showView,int marginPreset)2096 ScribusDoc *ScribusMainWindow::newDoc(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView, int marginPreset)
2097 {
2098 return doFileNew(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnDistance, columnCount, autoTextFrames, pageArrangement, unitIndex, firstPageLocation, orientation, firstPageNumber, defaultPageSize, requiresGUI, pageCount, showView, marginPreset);
2099 }
2100
doFileNew(double width,double height,double topMargin,double leftMargin,double rightMargin,double bottomMargin,double columnDistance,double columnCount,bool autoTextFrames,int pageArrangement,int unitIndex,int firstPageLocation,int orientation,int firstPageNumber,const QString & defaultPageSize,bool requiresGUI,int pageCount,bool showView,int marginPreset)2101 ScribusDoc *ScribusMainWindow::doFileNew(double width, double height, double topMargin, double leftMargin, double rightMargin, double bottomMargin, double columnDistance, double columnCount, bool autoTextFrames, int pageArrangement, int unitIndex, int firstPageLocation, int orientation, int firstPageNumber, const QString& defaultPageSize, bool requiresGUI, int pageCount, bool showView, int marginPreset)
2102 {
2103 if (HaveDoc)
2104 outlinePalette->buildReopenVals();
2105 m_undoManager->setUndoEnabled(false);
2106 MarginStruct margins(topMargin, leftMargin, bottomMargin, rightMargin);
2107 DocPagesSetup pagesSetup(pageArrangement, firstPageLocation, firstPageNumber, orientation, autoTextFrames, columnDistance, columnCount);
2108 QString newDocName( tr("Document")+"-"+QString::number(m_DocNr));
2109 ScribusDoc *tempDoc = new ScribusDoc();
2110 if (requiresGUI)
2111 doc=tempDoc;
2112 tempDoc->setLoading(true);
2113 outlinePalette->setDoc(tempDoc);
2114 ColorSetManager csm;
2115 csm.findPaletteLocations();
2116 csm.findPalettes();
2117 csm.findUserPalettes();
2118 ColorList colorList;
2119 QHash<QString, VGradient> gradientsList;
2120 QHash<QString, ScPattern> patternsList;
2121 QString Cpfad = QDir::toNativeSeparators(ScPaths::applicationDataDir())+"DefaultColors.xml";
2122 QFile fc(Cpfad);
2123 if (fc.exists())
2124 {
2125 csm.loadPalette(Cpfad, doc, colorList, gradientsList, patternsList, false);
2126 doc->PageColors = colorList;
2127 doc->docGradients = gradientsList;
2128 doc->docPatterns = patternsList;
2129 }
2130 else
2131 {
2132 if (m_prefsManager.appPrefs.colorPrefs.DColorSet != "Scribus Small")
2133 {
2134 QStringList CustomColorSets = csm.userPaletteNames();
2135 if (CustomColorSets.contains(m_prefsManager.appPrefs.colorPrefs.DColorSet))
2136 Cpfad = csm.userPaletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
2137 else
2138 Cpfad = csm.paletteFileFromName(m_prefsManager.appPrefs.colorPrefs.DColorSet);
2139 if (!Cpfad.isEmpty())
2140 csm.loadPalette(Cpfad, doc, colorList, gradientsList, patternsList, false);
2141 doc->PageColors = colorList;
2142 doc->docGradients = gradientsList;
2143 doc->docPatterns = patternsList;
2144 }
2145 else
2146 doc->PageColors = m_prefsManager.appPrefs.colorPrefs.DColors;
2147 }
2148 tempDoc->PageColors.ensureDefaultColors();
2149 tempDoc->setup(unitIndex, pageArrangement, firstPageLocation, orientation, firstPageNumber, defaultPageSize, newDocName);
2150 if (requiresGUI)
2151 {
2152 HaveDoc++;
2153 m_DocNr++;
2154 }
2155 if (ScCore->haveCMS() && tempDoc->cmsSettings().CMSinUse)
2156 recalcColors();
2157 //CB NOTE should be all done now
2158 tempDoc->setPage(width, height, topMargin, leftMargin, rightMargin, bottomMargin, columnCount, columnDistance, autoTextFrames, pageArrangement);
2159 tempDoc->setMarginPreset(marginPreset);
2160 tempDoc->setMasterPageMode(false);
2161 tempDoc->createDefaultMasterPages();
2162 tempDoc->createNewDocPages(pageCount);
2163 tempDoc->addSection();
2164 tempDoc->setFirstSectionFromFirstPageNumber();
2165 tempDoc->setModified(false);
2166 tempDoc->OpenNodes.clear();
2167 if (requiresGUI)
2168 {
2169 actionManager->disconnectNewDocActions();
2170 actionManager->connectNewDocActions(tempDoc);
2171 }
2172 //<<View and window code
2173 QMdiArea* qwsp = nullptr;
2174 if (requiresGUI)
2175 qwsp = mdiArea;
2176
2177 ScribusWin* w = new ScribusWin(qwsp, tempDoc);
2178 w->setMainWindow(this);
2179 if (requiresGUI && view != nullptr)
2180 actionManager->disconnectNewViewActions();
2181
2182 ScribusView* tempView = new ScribusView(w, this, tempDoc);
2183 if (requiresGUI)
2184 view = tempView;
2185 tempDoc->setCurrentPage(tempDoc->Pages->at(0));
2186 tempDoc->setGUI(requiresGUI, this, tempView);
2187 if (requiresGUI)
2188 {
2189 tempDoc->createHyphenator();
2190 tempDoc->docHyphenator->ignoredWords = m_prefsManager.appPrefs.hyphPrefs.ignoredWords;
2191 tempDoc->docHyphenator->specialWords = m_prefsManager.appPrefs.hyphPrefs.specialWords;
2192 }
2193 tempDoc->setLoading(false);
2194 //run after setGUI to set up guidepalette ok
2195
2196 tempView->setScale(m_prefsManager.displayScale());
2197 if (requiresGUI)
2198 {
2199 //done in newactinw actionManager->connectNewViewActions(tempView);
2200 alignDistributePalette->setDoc(tempDoc);
2201 docCheckerPalette->clearErrorList();
2202 symbolPalette->setDoc(tempDoc);
2203 inlinePalette->setDoc(tempDoc);
2204 }
2205 w->setView(tempView);
2206 ActWin = w;
2207 tempDoc->WinHan = w;
2208 if (requiresGUI)
2209 tempDoc->connectDocSignals(); //Must be before the first reformpages
2210 tempView->reformPages(true);
2211 //>>
2212 if (requiresGUI)
2213 w->setSubWin(mdiArea->addSubWindow(w));
2214 //Independent finishing tasks after tempDoc setup
2215 if (showView)
2216 {
2217 if (mdiArea->subWindowList().count() == 1)
2218 w->showMaximized();
2219 else
2220 w->show();
2221 tempView->show();
2222 // Seems to fix crash on loading
2223 ActWin = nullptr;
2224 newActWin(w->getSubWin());
2225 }
2226 if (requiresGUI)
2227 {
2228 connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), tempDoc, SLOT(updatePict(QString)));
2229 connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), tempDoc, SLOT(removePict(QString)));
2230 connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString)), tempDoc, SLOT(updatePictDir(QString)));
2231 connect(doc, SIGNAL(updateAutoSaveClock()), view->clockLabel, SLOT(resetTime()));
2232 view->clockLabel->resetTime();
2233 scrActions["viewToggleCMS"]->setChecked(tempDoc->HasCMS);
2234 m_undoManager->switchStack(tempDoc->documentFileName());
2235 m_styleManager->setDoc(tempDoc);
2236 marksManager->setDoc(tempDoc);
2237 nsEditor->setDoc(tempDoc);
2238 m_tocGenerator->setDoc(tempDoc);
2239 }
2240 m_undoManager->setUndoEnabled(true);
2241 return tempDoc;
2242 }
2243
newFileFromTemplate()2244 void ScribusMainWindow::newFileFromTemplate()
2245 {
2246 nftdialog* nftdia = new nftdialog(this, ScCore->getGuiLanguage());
2247 if (nftdia->exec() && nftdia->isTemplateSelected())
2248 {
2249 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
2250 nfttemplate* currentTemplate = nftdia->currentTemplate();
2251 if (loadDoc(QDir::cleanPath(currentTemplate->file)))
2252 {
2253 doc->hasName = false;
2254 UndoManager::instance()->renameStack(currentTemplate->name);
2255 doc->setDocumentFileName(currentTemplate->name);
2256 updateActiveWindowCaption(QObject::tr("Document Template: ") + currentTemplate->name);
2257 QDir::setCurrent(PrefsManager::instance().documentDir());
2258 removeRecent(QDir::cleanPath(currentTemplate->file));
2259 }
2260 qApp->restoreOverrideCursor();
2261 }
2262 delete nftdia;
2263 }
2264
newView()2265 void ScribusMainWindow::newView()
2266 {
2267 ScribusWin* w = new ScribusWin(mdiArea, doc);
2268 w->setMainWindow(this);
2269 view = new ScribusView(w, this, doc);
2270 view->setScale(m_prefsManager.displayScale());
2271 w->setView(view);
2272 ActWin = w;
2273 w->setCentralWidget(view);
2274 actionManager->connectNewViewActions(view);
2275 alignDistributePalette->setDoc(doc);
2276 connect(m_undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
2277 view->show();
2278 }
2279
windowsMenuAboutToShow()2280 void ScribusMainWindow::windowsMenuAboutToShow()
2281 {
2282 if (!scrWindowsActions.isEmpty())
2283 {
2284 for (auto it = scrWindowsActions.begin(); it != scrWindowsActions.end(); ++it)
2285 {
2286 scrMenuMgr->removeMenuItem(it.key(), it.value(), "Windows");
2287 }
2288 scrWindowsActions.clear();
2289 }
2290 QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
2291 bool windowsListNotEmpty=!windows.isEmpty();
2292 scrActions["windowsCascade"]->setEnabled(windowsListNotEmpty);
2293 scrActions["windowsTile"]->setEnabled(windowsListNotEmpty);
2294 if (windowsListNotEmpty)
2295 {
2296 int windowCount=static_cast<int>(windows.count());
2297 for ( int i = 0; i < windowCount; ++i )
2298 {
2299 QString docInWindow(windows.at(i)->windowTitle());
2300 scrWindowsActions.insert(docInWindow, new ScrAction( ScrAction::Window, QString(), QString(), docInWindow, QKeySequence(), this, i));
2301 scrWindowsActions[docInWindow]->setToggleAction(true);
2302 connect( scrWindowsActions[docInWindow], SIGNAL(triggeredData(int)), this, SLOT(windowsMenuActivated(int)) );
2303 scrWindowsActions[docInWindow]->setChecked(mdiArea->activeSubWindow() == windows.at(i));
2304 scrMenuMgr->addMenuItemString(docInWindow, "Windows");
2305 }
2306 if (windowCount>1)
2307 scrMenuMgr->addMenuItemStringsToRememberedMenu("Windows", scrWindowsActions);
2308 }
2309 }
2310
extrasMenuAboutToShow()2311 void ScribusMainWindow::extrasMenuAboutToShow()
2312 {
2313 // There is only Picture Manager handled now.
2314 // As it can be opened all the time of the document life.
2315 // This is only check for availability of any ImageFrame
2316 // in the doc.
2317 bool enablePicManager = false;
2318 if (HaveDoc)
2319 {
2320 QList<PageItem*> allItems;
2321 for (int i = 0; i < doc->Items->count(); ++i)
2322 {
2323 PageItem *currItem = doc->Items->at(i);
2324 if (currItem->isGroup())
2325 allItems = currItem->getAllChildren();
2326 else
2327 allItems.append(currItem);
2328 for (int j = 0; j < allItems.count(); j++)
2329 {
2330 PageItem* item = allItems.at(j);
2331 if ((item->itemType() == PageItem::ImageFrame) && (!item->isLatexFrame()) && (!item->isOSGFrame()))
2332 {
2333 enablePicManager = true;
2334 break;
2335 }
2336 }
2337 allItems.clear();
2338 }
2339 }
2340 scrActions["extrasManageImages"]->setEnabled(enablePicManager);
2341 }
2342
newActWin(QMdiSubWindow * w)2343 void ScribusMainWindow::newActWin(QMdiSubWindow *w)
2344 {
2345 if (w == nullptr)
2346 {
2347 if (mdiArea->subWindowList().count() == 0)
2348 ActWin = nullptr;
2349 return;
2350 }
2351 if (w->widget() == nullptr)
2352 return;
2353 ScribusWin* scw = dynamic_cast<ScribusWin *>(w->widget());
2354 if (!scw)
2355 return;
2356 if (scw && scw->doc())
2357 {
2358 if (!scw->doc()->hasGUI())
2359 return;
2360 }
2361 if (scw == ActWin)
2362 return;
2363 ActWin = scw;
2364 if (ActWin->doc() == nullptr)
2365 return;
2366 if (doc != nullptr)
2367 {
2368 if (doc->appMode == modeEditClip)
2369 view->requestMode(submodeEndNodeEdit);
2370 if ((HaveDoc) && (doc != ActWin->doc()))
2371 outlinePalette->buildReopenVals();
2372 }
2373 docCheckerPalette->clearErrorList();
2374 if (HaveDoc && (doc != nullptr) && doc->hasGUI())
2375 {
2376 disconnect(m_undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
2377 disconnect(m_undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
2378 disconnect(m_undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
2379 disconnect(doc, SIGNAL(addBookmark(PageItem *)), this, SLOT(AddBookMark(PageItem *)));
2380 disconnect(doc, SIGNAL(deleteBookmark(PageItem *)), this, SLOT(DelBookMark(PageItem *)));
2381 unitSwitcher->disconnect();
2382 unitSwitcher->setEnabled(false);
2383 zoomSpinBox->disconnect();
2384 zoomSpinBox->setEnabled(false);
2385 zoomDefaultToolbarButton->disconnect();
2386 zoomDefaultToolbarButton->setEnabled(false);
2387 zoomOutToolbarButton->disconnect();
2388 zoomDefaultToolbarButton->setEnabled(false);
2389 zoomInToolbarButton->disconnect();
2390 zoomInToolbarButton->setEnabled(false);
2391 layerMenu->disconnect();
2392 layerMenu->setEnabled(false);
2393 disconnect(viewToolBar->previewQualitySwitcher, SIGNAL(activated(int)), this, SLOT(changePreviewQuality(int)));
2394 disconnect(viewToolBar->visualMenu, SIGNAL(activated(int)), doc->view(), SLOT(switchPreviewVisual(int)));
2395 pageSelector->disconnect();
2396 pageSelector->setEnabled(false);
2397 }
2398 doc = ActWin->doc();
2399 m_undoManager->switchStack(doc->documentFileName());
2400 if ((doc != nullptr) && doc->hasGUI())
2401 {
2402 connect(m_undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
2403 connect(m_undoManager, SIGNAL(undoRedoDone()) , doc, SLOT(undoRedoDone()));
2404 connect(m_undoManager, SIGNAL(undoRedoDone()) , doc->view(), SLOT(DrawNew()));
2405 connect(doc, SIGNAL(addBookmark(PageItem*)), this, SLOT(AddBookMark(PageItem*)));
2406 connect(doc, SIGNAL(deleteBookmark(PageItem*)), this, SLOT(DelBookMark(PageItem*)));
2407 connect(unitSwitcher, SIGNAL(activated(int)), doc->view(), SLOT(ChgUnit(int)));
2408 unitSwitcher->setEnabled(true);
2409 connect(zoomSpinBox, SIGNAL(valueChanged(double)), doc->view(), SLOT(setZoom()));
2410 zoomSpinBox->setEnabled(true);
2411 connect(zoomDefaultToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoom100()));
2412 zoomDefaultToolbarButton->setEnabled(true);
2413 connect(zoomOutToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomOut()));
2414 zoomOutToolbarButton->setEnabled(true);
2415 connect(zoomInToolbarButton, SIGNAL(clicked()), doc->view(), SLOT(slotZoomIn()));
2416 zoomInToolbarButton->setEnabled(true);
2417 connect(layerMenu, SIGNAL(activated(int)), doc->view(), SLOT(GotoLayer(int)));
2418 layerMenu->setEnabled(true);
2419 scrActions["viewPreviewMode"]->blockSignals(true);
2420 scrActions["viewPreviewMode"]->setChecked(doc->drawAsPreview);
2421 scrActions["viewPreviewMode"]->blockSignals(false);
2422 appModeHelper->setPreviewMode(doc->drawAsPreview);
2423 scrActions["viewEditInPreview"]->setEnabled(doc->drawAsPreview);
2424 scrActions["viewToggleCMS"]->blockSignals(true);
2425 scrActions["viewToggleCMS"]->setChecked(doc->HasCMS);
2426 scrActions["viewToggleCMS"]->blockSignals(false);
2427 viewToolBar->previewQualitySwitcher->setCurrentIndex(doc->previewQuality());
2428 connect(viewToolBar->previewQualitySwitcher, SIGNAL(activated(int)), this, SLOT(changePreviewQuality(int)));
2429 viewToolBar->visualMenu->setCurrentIndex(doc->previewVisual);
2430 connect(viewToolBar->visualMenu, SIGNAL(activated(int)), doc->view(), SLOT(switchPreviewVisual(int)));
2431 viewToolBar->setDoc(doc);
2432 pageSelector->setMaximum(doc->masterPageMode() ? 1 : doc->Pages->count());
2433 slotSetCurrentPage(doc->currentPageNumber());
2434 connect(pageSelector, SIGNAL(pageChanged(int)), this, SLOT(setCurrentPage(int)));
2435 pageSelector->setEnabled(true);
2436 }
2437 if (view != nullptr)
2438 {
2439 actionManager->disconnectNewViewActions();
2440 if (ScCore->usingGUI())
2441 doc->m_Selection->disconnect(SIGNAL(selectionChanged()), actionManager, SLOT(handleMultipleSelections()));
2442 }
2443 view = ActWin->view();
2444 bool b = zoomSpinBox->blockSignals(true);
2445 zoomSpinBox->setValue(view->scale() * 100.0 / PrefsManager::instance().appPrefs.displayPrefs.displayScale);
2446 zoomSpinBox->blockSignals(b);
2447 actionManager->connectNewViewActions(view);
2448 actionManager->disconnectNewDocActions();
2449 actionManager->connectNewDocActions(doc);
2450 if (ScCore->usingGUI())
2451 connect(doc->m_Selection, SIGNAL(selectionChanged()), actionManager, SLOT(handleMultipleSelections()));
2452 pagePalette->setView(view);
2453 alignDistributePalette->setDoc(doc);
2454 if (!doc->isLoading())
2455 {
2456 SwitchWin();
2457 view->requestMode(doc->appMode);
2458 }
2459 view->setFocus();
2460 view->setRulersShown(doc->guidesPrefs().rulersShown);
2461 scrActions["viewShowMargins"]->setChecked(doc->guidesPrefs().marginsShown);
2462 scrActions["viewShowBleeds"]->setChecked(doc->guidesPrefs().showBleed);
2463 scrActions["viewShowFrames"]->setChecked(doc->guidesPrefs().framesShown);
2464 scrActions["viewShowLayerMarkers"]->setChecked(doc->guidesPrefs().layerMarkersShown);
2465 scrActions["viewShowGrid"]->setChecked(doc->guidesPrefs().gridShown);
2466 scrActions["viewShowGuides"]->setChecked(doc->guidesPrefs().guidesShown);
2467 scrActions["viewShowColumnBorders"]->setChecked(doc->guidesPrefs().colBordersShown);
2468 scrActions["viewShowBaseline"]->setChecked(doc->guidesPrefs().baselineGridShown);
2469 scrActions["viewShowImages"]->setChecked(doc->guidesPrefs().showPic);
2470 scrActions["viewShowTextChain"]->setChecked(doc->guidesPrefs().linkShown);
2471 scrActions["viewShowTextControls"]->setChecked(doc->guidesPrefs().showControls);
2472 scrActions["viewShowRulers"]->setChecked(doc->guidesPrefs().rulersShown);
2473 scrActions["viewRulerMode"]->setChecked(doc->guidesPrefs().rulerMode);
2474 scrActions["extrasGenerateTableOfContents"]->setEnabled(doc->hasTOCSetup());
2475 scrActions["extrasUpdateDocument"]->setEnabled(true);
2476 if (!doc->masterPageMode())
2477 pagePalette->rebuild();
2478 outlinePalette->setDoc(doc);
2479 if (outlinePalette->isVisible())
2480 {
2481 outlinePalette->BuildTree(false);
2482 outlinePalette->reopenTree();
2483 }
2484 RestoreBookMarks();
2485 if (!doc->isLoading())
2486 {
2487 HaveNewSel();
2488 if (!doc->m_Selection->isEmpty())
2489 doc->m_Selection->itemAt(0)->emitAllToGUI();
2490 }
2491 docCheckerPalette->setDoc(doc);
2492 m_tocGenerator->setDoc(doc);
2493 m_styleManager->setDoc(doc);
2494 marksManager->setDoc(doc);
2495 nsEditor->setDoc(doc);
2496 symbolPalette->setDoc(doc);
2497 inlinePalette->setDoc(doc);
2498 modeToolBar->setDoc(doc);
2499 // Give plugins a chance to react on changing the current document
2500 PluginManager& pluginManager(PluginManager::instance());
2501 QStringList pluginNames(pluginManager.pluginNames(false));
2502 ScPlugin* plugin;
2503 QString pName;
2504 for (int i = 0; i < pluginNames.count(); ++i)
2505 {
2506 pName = pluginNames.at(i);
2507 plugin = pluginManager.getPlugin(pName, true);
2508 Q_ASSERT(plugin); // all the returned names should represent loaded plugins
2509 plugin->setDoc(doc);
2510 }
2511 }
2512
windowsMenuActivated(int id)2513 void ScribusMainWindow::windowsMenuActivated(int id)
2514 {
2515 QMdiSubWindow* windowWidget = mdiArea->subWindowList().at( id );
2516 if (windowWidget)
2517 {
2518 if (windowWidget->isShaded() || windowWidget->isMinimized())
2519 windowWidget->showNormal();
2520 windowWidget->raise();
2521 }
2522 newActWin(windowWidget);
2523 }
2524
2525
SwitchWin()2526 void ScribusMainWindow::SwitchWin()
2527 {
2528 updateActiveWindowCaption(doc->documentFileName());
2529 propertiesPalette->setDoc(doc);
2530 contentPalette->setDoc(doc);
2531 marksManager->setDoc(doc);
2532 nsEditor->setDoc(doc);
2533 pagePalette->setView(view);
2534 layerPalette->setDoc(doc);
2535 guidePalette->setDoc(doc);
2536 charPalette->setDoc(doc);
2537 outlinePalette->setDoc(doc);
2538 symbolPalette->setDoc(doc);
2539 inlinePalette->setDoc(doc);
2540 rebuildLayersList();
2541 updateLayerMenu();
2542 //Do not set this!, it doesn't get valid pointers unless its in EditClip mode and its not
2543 //if we are switching windows #4357
2544 //nodePalette->setDoc(doc, view);
2545 slotChangeUnit(doc->unitIndex(), false);
2546 /* FIXME: check if this is really superflous now
2547 if (doc->appMode == modeEditClip)
2548 {
2549 doc->appMode = modeNormal;
2550 view->requestMode(submodeEndNodeEdit);
2551 } */
2552 appModeHelper->mainWindowSwitchWin(doc);
2553
2554 if (doc->masterPageMode() || doc->symbolEditMode() || doc->inlineEditMode())
2555 pagePalette->enablePalette(false);
2556 else
2557 {
2558 if (doc->isModified())
2559 slotDocCh(false);
2560 pagePalette->enablePalette(true);
2561 setPreviewToolbar();
2562 }
2563
2564 bool setter = !doc->layerLocked( doc->activeLayer() );
2565 scrMenuMgr->setMenuEnabled("EditPasteRecent", ((scrapbookPalette->tempBView->objectMap.count() > 0) && (setter)));
2566 scrMenuMgr->setMenuEnabled("Insert", setter);
2567 scrMenuMgr->setMenuEnabled("ItemLayer", doc->layerCount() > 1);
2568 appModeHelper->changeLayer(doc, (ScMimeData::clipboardHasScribusData() || (scrapbookPalette->tempHasContents())));
2569 }
2570
HaveNewDoc()2571 void ScribusMainWindow::HaveNewDoc()
2572 {
2573 appModeHelper->mainWindowHasNewDoc(doc, (ScMimeData::clipboardHasScribusData()) || (scrapbookPalette->tempHasContents()));
2574
2575 //Update palettes
2576 updateActiveWindowCaption(doc->documentFileName());
2577 propertiesPalette->setDoc(doc);
2578 contentPalette->setDoc(doc);
2579 nsEditor->setDoc(doc);
2580
2581 marksManager->setDoc(doc);
2582 symbolPalette->setDoc(doc);
2583 inlinePalette->setDoc(doc);
2584 pagePalette->setView(view);
2585 layerPalette->setDoc(doc);
2586 guidePalette->setDoc(doc);
2587 charPalette->setDoc(doc);
2588 outlinePalette->setDoc(doc);
2589 if (outlinePalette->isVisible())
2590 outlinePalette->BuildTree();
2591 rebuildLayersList();
2592 updateLayerMenu();
2593 slotChangeUnit(doc->unitIndex());
2594 windowsMenuAboutToShow();
2595
2596 // #9275 : scripter must call HaveNewDoc() in case new doc has been created in a script
2597 // We may consequently have to call HaveNewDoc several times for the same doc.
2598 // Use Qt::UniqueConnection here to avoid multiple identical signal connections
2599 connect(view, SIGNAL(unitChanged(int)), this, SLOT(slotChangeUnit(int)), Qt::UniqueConnection);
2600 connect(view, SIGNAL(layerChanged(int)), layerPalette, SLOT(markActiveLayer(int)), Qt::UniqueConnection);
2601 connect(this, SIGNAL(changeLayers(int)), layerPalette, SLOT(markActiveLayer(int)), Qt::UniqueConnection);
2602 connect(view->horizRuler, SIGNAL(MarkerMoved(double,double)), this, SLOT(setStatusBarTextPosition(double,double)), Qt::UniqueConnection);
2603 connect(view->horizRuler, SIGNAL(DocChanged(bool)), this, SLOT(slotDocCh(bool)), Qt::UniqueConnection);
2604 connect(view, SIGNAL(ClipPo(double,double)), nodePalette, SLOT(SetXY(double,double)), Qt::UniqueConnection);
2605 connect(view, SIGNAL(PolyOpen()), nodePalette, SLOT(IsOpen()), Qt::UniqueConnection);
2606 connect(view, SIGNAL(ItemGeom()), propertiesPalette->xyzPal, SLOT(handleSelectionChanged()), Qt::UniqueConnection);
2607 connect(view, SIGNAL(ChBMText(PageItem*)), this, SLOT(BookMarkTxT(PageItem*)), Qt::UniqueConnection);
2608 connect(view, SIGNAL(HaveSel()), this, SLOT(HaveNewSel()), Qt::UniqueConnection);
2609 connect(view, SIGNAL(DocChanged()), this, SLOT(slotDocCh()), Qt::UniqueConnection);
2610 connect(view, SIGNAL(MousePos(double,double)), this, SLOT(setStatusBarMousePosition(double,double)), Qt::UniqueConnection);
2611 connect(view, SIGNAL(ItemCharStyle(const CharStyle&)), contentPalette, SLOT(update(const CharStyle&)), Qt::UniqueConnection);
2612 connect(view, SIGNAL(ItemTextEffects(int)), this, SLOT(setStyleEffects(int)), Qt::UniqueConnection);
2613 connect(view, SIGNAL(ItemTextAlign(int)), this, SLOT(setAlignmentValue(int)), Qt::UniqueConnection);
2614 connect(view, SIGNAL(LoadElem(QString,double,double,bool,bool,ScribusDoc*,ScribusView*)), this, SLOT(slotElemRead(QString,double,double,bool,bool,ScribusDoc*,ScribusView*)), Qt::UniqueConnection);
2615 connect(view, SIGNAL(AddBM(PageItem*)), this, SLOT(AddBookMark(PageItem*)), Qt::UniqueConnection);
2616 connect(view, SIGNAL(DelBM(PageItem*)), this, SLOT(DelBookMark(PageItem*)), Qt::UniqueConnection);
2617 }
2618
HaveNewSel()2619 void ScribusMainWindow::HaveNewSel()
2620 {
2621 if (doc == nullptr)
2622 return;
2623 int selectedType = -1;
2624 PageItem *currItem = nullptr;
2625 const int docSelectionCount = doc->m_Selection->count();
2626 if (docSelectionCount > 0)
2627 {
2628 currItem = doc->m_Selection->itemAt(0);
2629 selectedType = currItem->itemType();
2630 }
2631 assert (docSelectionCount == 0 || currItem != nullptr); // help coverity analysis
2632
2633 setStatusBarTextSelectedItemInfo();
2634
2635 actionManager->disconnectNewSelectionActions();
2636
2637 charPalette->setEnabled(false, nullptr);
2638 view->horizRuler->textMode(false);
2639 view->horizRuler->update();
2640 if (!doc->inAnEditMode())
2641 appModeHelper->enableActionsForSelection(this, doc);
2642
2643 switch (selectedType)
2644 {
2645 case -1: // None
2646 outlinePalette->slotShowSelect(doc->currentPageNumber(), nullptr);
2647 propertiesPalette->setGradientEditMode(false);
2648 break;
2649 case PageItem::TextFrame: //Text Frame
2650 if (doc->appMode == modeEdit)
2651 {
2652 setTBvals(currItem);
2653 charPalette->setEnabled(true, currItem);
2654 if (currItem->isTextFrame())
2655 {
2656 appModeHelper->enableTextActions(true, currItem->currentStyle().charStyle().font().scName());
2657 currItem->asTextFrame()->toggleEditModeActions();
2658 }
2659 view->horizRuler->setItem(currItem);
2660 view->horizRuler->update();
2661 }
2662 else
2663 {
2664 const ParagraphStyle& curStyle = currItem->itemText.defaultStyle();
2665 doc->currentStyle.setContext(curStyle.context());
2666 doc->currentStyle = curStyle;
2667 emit TextStyle(doc->currentStyle);
2668 // to go: (av)
2669 contentPalette->update(doc->currentStyle);
2670 setStyleEffects(doc->currentStyle.charStyle().effects());
2671 }
2672 break;
2673 case PageItem::Table:
2674 if (doc->appMode == modeEditTable)
2675 {
2676 charPalette->setEnabled(true, currItem);
2677 PageItem *cellItem = currItem->asTable()->activeCell().textFrame();
2678 setTBvals(cellItem);
2679 appModeHelper->enableTextActions(true, cellItem->currentCharStyle().font().scName());
2680 }
2681 break;
2682 case PageItem::PathText: //Path Text
2683 if (doc->appMode == modeEdit)
2684 setTBvals(currItem);
2685 else
2686 {
2687 const ParagraphStyle& curStyle = currItem->itemText.defaultStyle();
2688 doc->currentStyle.setContext(curStyle.context());
2689 doc->currentStyle = curStyle;
2690 emit TextStyle(doc->currentStyle);
2691 // to go: (av)
2692 contentPalette->update(doc->currentStyle);
2693 setStyleEffects(doc->currentStyle.charStyle().effects());
2694 }
2695 break;
2696 }
2697 propertiesPalette->xyzPal->basePointWidget->setCheckedId(doc->rotationMode());
2698
2699 if (docSelectionCount != 0)
2700 {
2701 actionManager->setPDFActions(view);
2702 updateItemLayerList();
2703 rebuildScrapbookMenu();
2704 propertiesPalette->setTextFlowMode(currItem->textFlowMode());
2705 }
2706
2707 if (selectedType != -1)
2708 {
2709 outlinePalette->slotShowSelect(currItem->OwnPage, currItem);
2710 actionManager->connectNewSelectionActions(view, doc);
2711 }
2712
2713 appModeHelper->updateActionPluginsActions(doc);
2714 }
2715
slotDocCh(bool)2716 void ScribusMainWindow::slotDocCh(bool /*reb*/)
2717 {
2718 if (!doc->isModified())
2719 doc->setModified(true);
2720 updateActiveWindowCaption(doc->documentFileName() + "*");
2721 if (!doc->masterPageMode())
2722 {
2723 if (!doc->symbolEditMode() && !doc->inlineEditMode())
2724 {
2725 if (doc->hasName)
2726 scrActions["fileRevert"]->setEnabled(true);
2727 bool multiPages = doc->DocPages.count() > 1;
2728 scrActions["pageDelete"]->setEnabled(multiPages);
2729 scrActions["pageMove"]->setEnabled(multiPages);
2730 scrActions["fileCollect"]->setEnabled(true);
2731 }
2732 scrActions["fileClose"]->setEnabled(true);
2733 }
2734
2735 if (outlinePalette->isVisible())
2736 outlinePalette->BuildTree();
2737 // Give plugins a chance to react on changes in the current document
2738 PluginManager& pluginManager(PluginManager::instance());
2739 QStringList pluginNames(pluginManager.pluginNames(false));
2740 ScPlugin* plugin;
2741 QString pName;
2742 for (int i = 0; i < pluginNames.count(); ++i)
2743 {
2744 pName = pluginNames.at(i);
2745 plugin = pluginManager.getPlugin(pName, true);
2746 Q_ASSERT(plugin); // all the returned names should represent loaded plugins
2747 plugin->changedDoc(doc);
2748 }
2749 if (doc->flag_NumUpdateRequest)
2750 {
2751 doc->setupNumerations();
2752 emit UpdateRequest(reqNumUpdate);
2753 }
2754 while (doc->flag_Renumber)
2755 {
2756 doc->updateNumbers();
2757 if (!doc->flag_Renumber)
2758 doc->regionsChanged()->update(QRect());
2759 }
2760 if (m_marksCount != doc->marksList().count() || doc->notesChanged() || doc->flag_updateEndNotes || doc->flag_updateMarksLabels)
2761 {
2762 bool sendUpdateReqest = false;
2763 if (m_marksCount != doc->marksList().count() || doc->flag_updateMarksLabels)
2764 sendUpdateReqest = true;
2765 m_marksCount = doc->marksList().count();
2766 doc->updateMarks(doc->notesChanged());
2767 doc->updateChangedEndNotesFrames();
2768 if (sendUpdateReqest)
2769 emit UpdateRequest(reqMarksUpdate);
2770 doc->setNotesChanged(false);
2771 doc->flag_updateEndNotes = false;
2772 doc->flag_updateMarksLabels = false;
2773 }
2774 }
2775
updateRecent(const QString & fn)2776 void ScribusMainWindow::updateRecent(const QString& fn)
2777 {
2778 if (m_recentDocsList.indexOf(fn) != -1)
2779 m_recentDocsList.removeAll(fn);
2780 m_recentDocsList.prepend(fn);
2781 rebuildRecentFileMenu();
2782 }
2783
removeRecent(const QString & fn,bool fromFileWatcher)2784 void ScribusMainWindow::removeRecent(const QString& fn, bool fromFileWatcher)
2785 {
2786 if (m_recentDocsList.indexOf(fn) != -1)
2787 {
2788 m_recentDocsList.removeAll(fn);
2789 //#9845: if (!fromFileWatcher)
2790 //#9845: ScCore->fileWatcher->removeFile(fn);
2791 }
2792 rebuildRecentFileMenu();
2793 }
2794
removeRecentFromWatcher(const QString & filename)2795 void ScribusMainWindow::removeRecentFromWatcher(const QString& filename)
2796 {
2797 removeRecent(filename, true);
2798 }
2799
loadRecent(const QString & filename)2800 void ScribusMainWindow::loadRecent(const QString& filename)
2801 {
2802 QFileInfo fd(filename);
2803 if (!fd.exists())
2804 removeRecent(filename);
2805 else
2806 loadDoc(filename);
2807 }
2808
rebuildRecentFileMenu()2809 void ScribusMainWindow::rebuildRecentFileMenu()
2810 {
2811 QString strippedName, localName;
2812 scrMenuMgr->clearMenuStrings("FileOpenRecent");
2813 scrRecentFileActions.clear();
2814 int max = qMin(m_prefsManager.appPrefs.uiPrefs.recentDocCount, m_recentDocsList.count());
2815 for (int i = 0; i < max; ++i)
2816 {
2817 strippedName = localName = QDir::toNativeSeparators(m_recentDocsList[i]);
2818 strippedName.remove(QDir::separator());
2819 strippedName.prepend(QString("%1").arg(i+1, 2, 10, QChar('0')));
2820 scrRecentFileActions.insert(strippedName, new ScrAction(ScrAction::RecentFile, QString(), QString(), QString("&%1 %2").arg(i + 1).arg(localName.replace("&","&&")), QKeySequence(), this, m_recentDocsList[i]));
2821 connect( scrRecentFileActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(loadRecent(QString)) );
2822 scrMenuMgr->addMenuItemString(strippedName, "FileOpenRecent");
2823 }
2824 scrMenuMgr->addMenuItemStringsToRememberedMenu("FileOpenRecent", scrRecentFileActions);
2825 fileToolBar->rebuildRecentFileMenu();
2826 }
2827
rebuildRecentPasteMenu()2828 void ScribusMainWindow::rebuildRecentPasteMenu()
2829 {
2830 scrMenuMgr->clearMenuStrings("EditPasteRecent");
2831
2832 scrRecentPasteActions.clear();
2833 int max = qMin(m_prefsManager.appPrefs.scrapbookPrefs.numScrapbookCopies, scrapbookPalette->tempBView->objectMap.count());
2834 if (max > 0)
2835 {
2836 QMap<QString,BibView::Elem>::Iterator it;
2837 it = scrapbookPalette->tempBView->objectMap.end();
2838 it--;
2839 QString strippedName;
2840 for (int m = 0; m < max; ++m)
2841 {
2842 strippedName = it.key();
2843 QPixmap pm = it.value().Preview;
2844 scrRecentPasteActions.insert(strippedName, new ScrAction(ScrAction::RecentPaste, pm, QString(), QString("&%1 %2").arg(m+1).arg(strippedName), QKeySequence(), this, it.key()));
2845 connect( scrRecentPasteActions[strippedName], SIGNAL(triggeredData(QString)), this, SLOT(pasteRecent(QString)) );
2846 scrMenuMgr->addMenuItemString(strippedName, "EditPasteRecent");
2847 it--;
2848 }
2849 scrMenuMgr->addMenuItemStringsToRememberedMenu("EditPasteRecent", scrRecentPasteActions);
2850 }
2851 }
2852
rebuildScrapbookMenu()2853 void ScribusMainWindow::rebuildScrapbookMenu()
2854 {
2855 scrMenuMgr->clearMenuStrings("ItemSendToScrapbook");
2856 scrScrapActions.clear();
2857 if (!HaveDoc)
2858 return;
2859 QStringList scrapNames = scrapbookPalette->getOpenScrapbooksNames();
2860 scrapNames.removeAt(1);
2861 for (int i = 0; i < scrapNames.count(); ++i)
2862 {
2863 ScrAction *act = new ScrAction( ScrAction::DataInt, QString(), QString(), scrapNames[i], QKeySequence(), this, i);
2864 scrScrapActions.insert(scrapNames[i], act);
2865 connect(act, SIGNAL(triggeredData(int)), this, SLOT(PutScrap(int)));
2866 scrMenuMgr->addMenuItemString(scrapNames[i], "ItemSendToScrapbook");
2867 }
2868 scrMenuMgr->addMenuItemStringsToRememberedMenu("ItemSendToScrapbook", scrScrapActions);
2869 }
2870
pasteFromScrapbook(const QString & fn)2871 void ScribusMainWindow::pasteFromScrapbook(const QString& fn)
2872 {
2873 if (!HaveDoc)
2874 return;
2875 view->dragX = 0;
2876 view->dragY = 0;
2877 doPasteRecent(scrapbookPalette->activeBView->objectMap[fn].Data);
2878 }
2879
pasteRecent(const QString & fn)2880 void ScribusMainWindow::pasteRecent(const QString& fn)
2881 {
2882 doPasteRecent(scrapbookPalette->tempBView->objectMap[fn].Data);
2883 }
2884
doPasteRecent(const QString & data)2885 void ScribusMainWindow::doPasteRecent(const QString& data)
2886 {
2887 if (!HaveDoc)
2888 return;
2889 QFileInfo fi(data);
2890 QString formatD(FormatsManager::instance()->extensionListForFormat(FormatsManager::RASTORIMAGES, 1));
2891 QStringList rasterFiles = formatD.split("|");
2892 QStringList vectorFiles = LoadSavePlugin::getExtensionsForPreview(FORMATID_FIRSTUSER);
2893 if (vectorFiles.contains(fi.suffix().toLower()))
2894 {
2895 FileLoader *fileLoader = new FileLoader(data);
2896 int testResult = fileLoader->testFile();
2897 delete fileLoader;
2898 if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
2899 {
2900 const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
2901 if (fmt)
2902 {
2903 fmt->loadFile(data, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
2904 }
2905 }
2906 if (!doc->m_Selection->isEmpty())
2907 {
2908 double x2, y2, w, h;
2909 doc->m_Selection->getGroupRect(&x2, &y2, &w, &h);
2910 doc->moveGroup(doc->currentPage()->xOffset() - x2, doc->currentPage()->yOffset() - y2);
2911 emit UpdateRequest(reqColorsUpdate|reqTextStylesUpdate|reqLineStylesUpdate);
2912 }
2913 }
2914 else if (rasterFiles.contains(fi.suffix().toLower()))
2915 {
2916 int z = doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), 1, 1, doc->itemToolPrefs().shapeLineWidth, doc->itemToolPrefs().imageFillColor, doc->itemToolPrefs().imageStrokeColor);
2917 PageItem *b = doc->Items->at(z);
2918 b->m_layerID = doc->activeLayer();
2919 doc->loadPict(data, b);
2920 b->setWidth(static_cast<double>(b->OrigW * 72.0 / b->pixm.imgInfo.xres));
2921 b->setHeight(static_cast<double>(b->OrigH * 72.0 / b->pixm.imgInfo.yres));
2922 b->OldB2 = b->width();
2923 b->OldH2 = b->height();
2924 b->updateClip();
2925 b->adjustPictScale();
2926 }
2927 else
2928 {
2929 UndoTransaction pasteAction;
2930 if (UndoManager::undoEnabled())
2931 pasteAction = m_undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Create, QString(), Um::ICreate);
2932 view->deselectItems(true);
2933 int docItemCount = doc->Items->count();
2934 bool savedAlignGrid = doc->SnapGrid;
2935 bool savedAlignGuides = doc->SnapGuides;
2936 bool savedAlignElement = doc->SnapElement;
2937 doc->SnapGrid = false;
2938 doc->SnapGuides = false;
2939 doc->SnapElement = false;
2940 if ((view->dragX == 0.0) && (view->dragY == 0.0))
2941 slotElemRead(data, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), true, true, doc, view);
2942 else
2943 slotElemRead(data, view->dragX, view->dragY, true, false, doc, view);
2944 doc->SnapGrid = savedAlignGrid;
2945 doc->SnapGuides = savedAlignGuides;
2946 doc->SnapElement = savedAlignElement;
2947 Selection tmpSelection(this, false);
2948 tmpSelection.copy(*doc->m_Selection, true);
2949 for (int i = docItemCount; i < doc->Items->count(); ++i)
2950 {
2951 PageItem* currItem = doc->Items->at(i);
2952 doc->setRedrawBounding(currItem);
2953 tmpSelection.addItem(currItem, true);
2954 if (currItem->isBookmark)
2955 AddBookMark(currItem);
2956 }
2957 doc->m_Selection->copy(tmpSelection, false);
2958 if (pasteAction)
2959 pasteAction.commit();
2960 }
2961 slotDocCh(false);
2962 doc->regionsChanged()->update(QRectF());
2963 view->dragX = 0;
2964 view->dragY = 0;
2965 }
2966
importVectorFile()2967 void ScribusMainWindow::importVectorFile()
2968 {
2969 QStringList formats;
2970 QString allFormats = tr("All Supported Formats")+" (";
2971 int fmtCode = FORMATID_FIRSTUSER;
2972 const FileFormat *fmt = LoadSavePlugin::getFormatById(fmtCode);
2973 while (fmt != nullptr)
2974 {
2975 if (fmt->load)
2976 {
2977 formats.append(fmt->filter);
2978 int an = fmt->filter.indexOf("(");
2979 int en = fmt->filter.indexOf(")");
2980 while (an != -1)
2981 {
2982 allFormats += fmt->filter.mid(an+1, en-an-1)+" ";
2983 an = fmt->filter.indexOf("(", en);
2984 en = fmt->filter.indexOf(")", an);
2985 }
2986 }
2987 fmtCode++;
2988 fmt = LoadSavePlugin::getFormatById(fmtCode);
2989 }
2990 allFormats += "*.sce *.SCE);;";
2991 formats.append("Scribus Objects (*.sce *.SCE)");
2992 formats.sort(Qt::CaseInsensitive);
2993 allFormats += formats.join(";;");
2994
2995 PrefsContext* dirs = PrefsManager::instance().prefsFile->getContext("dirs");
2996 QString wdir = dirs->get("pastefile", ".");
2997 CustomFDialog dia(this, wdir, tr("Open"), allFormats, fdExistingFiles | fdDisableOk);
2998 if (dia.exec() != QDialog::Accepted)
2999 return;
3000
3001 QString fileName = dia.selectedFile();
3002 if (fileName.isEmpty())
3003 return;
3004
3005 PrefsManager::instance().prefsFile->getContext("dirs")->set("pastefile", fileName.left(fileName.lastIndexOf("/")));
3006 QFileInfo fi(fileName);
3007 QString suffix = fi.suffix().toLower();
3008 if ((suffix == "sce") || (suffix == "shape"))
3009 {
3010 QList<QUrl> urls;
3011 QMimeData* md = new QMimeData();
3012 urls.append( QUrl::fromLocalFile(fileName) );
3013 md->setUrls(urls);
3014 QDrag* dr = new QDrag(this);
3015 dr->setMimeData(md);
3016 const QPixmap& dragCursor = IconManager::instance().loadPixmap("dragpix.png");
3017 dr->setPixmap(dragCursor);
3018 dr->exec();
3019 }
3020 else
3021 {
3022 FileLoader *fileLoader = new FileLoader(fileName);
3023 int testResult = fileLoader->testFile();
3024 delete fileLoader;
3025 if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
3026 {
3027 const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
3028 if (fmt)
3029 {
3030 doc->dontResize = true;
3031 fmt->loadFile(fileName, LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive);
3032 doc->dontResize = false;
3033 }
3034 }
3035 }
3036 requestUpdate(reqColorsUpdate | reqSymbolsUpdate | reqLineStylesUpdate | reqTextStylesUpdate);
3037 }
3038
rebuildLayersList()3039 void ScribusMainWindow::rebuildLayersList()
3040 {
3041 if (!HaveDoc)
3042 return;
3043 scrMenuMgr->clearMenuStrings("ItemLayer");
3044 scrLayersActions.clear();
3045 ScLayers::iterator it;
3046 if (doc->Layers.count()!= 0)
3047 {
3048 for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
3049 {
3050 scrLayersActions.insert(QString("%1").arg((*it).ID), new ScrAction(ScrAction::Layer, QString(), QString(), (*it).Name, QKeySequence(), this, (*it).ID));
3051 scrLayersActions[QString("%1").arg((*it).ID)]->setToggleAction(true);
3052 QPixmap pm(20,15);
3053 pm.fill((*it).markerColor);
3054 scrLayersActions[QString("%1").arg((*it).ID)]->setIcon(pm);
3055 }
3056 }
3057 int currActiveLayer = doc->activeLayer();
3058 bool found = false;
3059 for (it = doc->Layers.begin(); it != doc->Layers.end(); ++it)
3060 {
3061 if ((*it).ID == currActiveLayer)
3062 {
3063 found=true;
3064 break;
3065 }
3066 }
3067 Q_ASSERT(found);
3068 scrLayersActions[QString("%1").arg((*it).ID)]->setChecked(true);
3069
3070 for (auto it = scrLayersActions.begin(); it != scrLayersActions.end(); ++it )
3071 {
3072 scrMenuMgr->addMenuItemString(it.key(), "ItemLayer");
3073 connect( (*it), SIGNAL(triggeredData(int)), doc, SLOT(itemSelection_SendToLayer(int)) );
3074 }
3075 scrMenuMgr->addMenuItemStringsToRememberedMenu("ItemLayer", scrLayersActions);
3076 }
3077
updateItemLayerList()3078 void ScribusMainWindow::updateItemLayerList()
3079 {
3080 if (!HaveDoc)
3081 return;
3082 QMap<QString, QPointer<ScrAction> >::Iterator itend=scrLayersActions.end();
3083 for (auto it = scrLayersActions.begin(); it!=itend; ++it)
3084 {
3085 (*it)->disconnect(SIGNAL(triggeredData(int)));
3086 (*it)->setChecked(false);
3087 }
3088 if (!doc->m_Selection->isEmpty() && doc->m_Selection->itemAt(0))
3089 scrLayersActions[QString("%1").arg(doc->m_Selection->itemAt(0)->m_layerID)]->setChecked(true);
3090 for (auto it = scrLayersActions.begin(); it != itend; ++it)
3091 connect( (*it), SIGNAL(triggeredData(int)), doc, SLOT(itemSelection_SendToLayer(int)) );
3092 }
3093
updateColorLists()3094 void ScribusMainWindow::updateColorLists()
3095 {
3096 if (!HaveDoc)
3097 return;
3098 requestUpdate(reqColorsUpdate | reqLineStylesUpdate);
3099 m_styleManager->updateColorList();
3100 }
3101
slotFileOpen()3102 bool ScribusMainWindow::slotFileOpen()
3103 {
3104 PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
3105 QString docDir(".");
3106 QString prefsDocDir(m_prefsManager.documentDir());
3107 if (!prefsDocDir.isEmpty())
3108 docDir = docContext->get("docsopen", prefsDocDir);
3109 else
3110 docDir = docContext->get("docsopen", ".");
3111 QString formats(FileLoader::getLoadFilterString());
3112 QString fileName(CFileDialog( docDir, tr("Open"), formats, "", fdDisableOk));
3113 if (fileName.isEmpty()) // User cancelled
3114 return false;
3115 QFileInfo fi(fileName);
3116 docContext->set("docsopen", fi.absolutePath());
3117 return loadDoc(fileName);
3118 }
3119
slotPageImport()3120 bool ScribusMainWindow::slotPageImport()
3121 {
3122 Q_ASSERT(!doc->masterPageMode());
3123
3124 QScopedPointer<MergeDoc> dia(new MergeDoc(this, false, doc->DocPages.count(), doc->currentPage()->pageNr() + 1));
3125 if (!dia->exec())
3126 return false;
3127
3128 bool ret = false;
3129 UndoTransaction activeTransaction;
3130 if (UndoManager::undoEnabled())
3131 activeTransaction = m_undoManager->beginTransaction(Um::ImportPage, Um::IGroup, Um::ImportPage, nullptr, Um::ILock);
3132
3133 m_mainWindowStatusLabel->setText( tr("Importing Pages..."));
3134 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
3135 std::vector<int> pageNs;
3136 parsePagesString(dia->getPageNumbers(), &pageNs, dia->getPageCounter());
3137 int startPage=0, nrToImport=pageNs.size();
3138 bool doIt = true;
3139 if (doc->masterPageMode())
3140 {
3141 if (nrToImport > 1)
3142 loadPage(dia->getFromDoc(), pageNs[0] - 1, false);
3143 doIt = false;
3144 }
3145 else if (dia->getCreatePageChecked())
3146 {
3147 int importWhere = dia->getImportWhere();
3148 if (importWhere == 0)
3149 startPage = dia->getImportWherePage();
3150 else if (importWhere == 1)
3151 startPage = dia->getImportWherePage() + 1;
3152 else
3153 startPage = doc->DocPages.count() + 1;
3154 addNewPages(dia->getImportWherePage(), importWhere, nrToImport, doc->pageHeight(), doc->pageWidth(), doc->pageOrientation(), doc->pageSize(), true);
3155 }
3156 else
3157 {
3158 startPage = doc->currentPage()->pageNr() + 1;
3159 if (nrToImport > (doc->DocPages.count() - doc->currentPage()->pageNr()))
3160 {
3161 qApp->setOverrideCursor(QCursor(Qt::ArrowCursor));
3162 ScMessageBox msgBox;
3163 msgBox.setIcon(QMessageBox::Information);
3164 msgBox.setText(tr("Import Page(s)"));
3165 msgBox.setInformativeText("<qt>" +
3166 QObject::tr("<p>You are trying to import more pages than there are available in the current document counting from the active page.</p>Choose one of the following:"
3167 "<ul><li><b>Create</b> missing pages</li>"
3168 "<li><b>Import</b> pages until the last page</li>"
3169 "<li><b>Cancel</b></li></ul>") + "</qt>");
3170 QPushButton *createButton = msgBox.addButton(tr("C&reate"), QMessageBox::AcceptRole);
3171 QPushButton *importButton = msgBox.addButton(tr("&Import"), QMessageBox::AcceptRole);
3172 QPushButton *cancelButton = msgBox.addButton(CommonStrings::tr_Cancel, QMessageBox::RejectRole);
3173 msgBox.setDefaultButton(cancelButton);
3174 msgBox.setDefaultBatchButton(createButton);
3175 msgBox.exec();
3176 if (msgBox.clickedButton() == createButton)
3177 {
3178 addNewPages(doc->DocPages.count(), 2,
3179 nrToImport - (doc->DocPages.count() - doc->currentPage()->pageNr()),
3180 doc->pageHeight(), doc->pageWidth(), doc->pageOrientation(), doc->pageSize(), true);
3181 }
3182 else if (msgBox.clickedButton() == importButton)
3183 {
3184 nrToImport = doc->DocPages.count() - doc->currentPage()->pageNr();
3185 }
3186 else
3187 {
3188 doIt = false;
3189 m_mainWindowStatusLabel->setText("");
3190 }
3191 qApp->restoreOverrideCursor();
3192 }
3193 }
3194 if (doIt)
3195 {
3196 if (nrToImport > 0)
3197 {
3198 mainWindowProgressBar->reset();
3199 mainWindowProgressBar->setMaximum(nrToImport);
3200 int counter = startPage;
3201 for (int i = 0; i < nrToImport; ++i)
3202 {
3203 view->GotoPa(counter);
3204 loadPage(dia->getFromDoc(), pageNs[i] - 1, false);
3205 counter++;
3206 mainWindowProgressBar->setValue(i + 1);
3207 }
3208 view->GotoPa(startPage);
3209 mainWindowProgressBar->reset();
3210 m_mainWindowStatusLabel->setText( tr("Import done"));
3211 }
3212 else
3213 {
3214 m_mainWindowStatusLabel->setText( tr("Found nothing to import"));
3215 doIt = false;
3216 }
3217 }
3218 qApp->restoreOverrideCursor();
3219 ret = doIt;
3220
3221 if (activeTransaction)
3222 activeTransaction.commit();
3223 return ret;
3224 }
3225
loadPage(const QString & fileName,int Nr,bool Mpa,const QString & renamedPageName)3226 bool ScribusMainWindow::loadPage(const QString& fileName, int Nr, bool Mpa, const QString& renamedPageName)
3227 {
3228 if (fileName.isEmpty())
3229 return false;
3230
3231 FileLoader *fl = new FileLoader(fileName);
3232 if (fl->testFile() == -1)
3233 {
3234 delete fl;
3235 return false;
3236 }
3237 doc->setLoading(true);
3238 int oldItemsCount = doc->Items->count();
3239 if (!fl->loadPage(doc, Nr, Mpa, renamedPageName))
3240 {
3241 delete fl;
3242 doc->setLoading(false);
3243 return false;
3244 }
3245 delete fl;
3246 if (ScCore->haveCMS() && doc->cmsSettings().CMSinUse)
3247 {
3248 recalcColors();
3249 doc->RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK);
3250 }
3251 int docItemsCount = doc->Items->count();
3252 for (int i = oldItemsCount; i < docItemsCount; ++i)
3253 {
3254 PageItem *ite = doc->Items->at(i);
3255 if ((ite->isTextFrame()) && (ite->isBookmark))
3256 AddBookMark(ite);
3257 }
3258 propertiesPalette->updateColorList();
3259 contentPalette->updateColorList();
3260 emit UpdateRequest(reqArrowStylesUpdate | reqLineStylesUpdate | reqStyleComboDocUpdate | reqInlinePalUpdate);
3261 symbolPalette->updateSymbolList();
3262 slotDocCh();
3263 rebuildLayersList();
3264 updateLayerMenu();
3265 layerPalette->rebuildList();
3266 doc->setLoading(false);
3267
3268 if (!Mpa)
3269 pagePalette->rebuild();
3270 view->reformPages();
3271 view->DrawNew();
3272 return true;
3273 }
3274
loadDoc(const QString & fileName)3275 bool ScribusMainWindow::loadDoc(const QString& fileName)
3276 {
3277 #ifdef DEBUG_LOAD_TIMES
3278 QTime t;
3279 struct tms tms1, tms2;
3280 t.start();
3281 times(&tms1);
3282 #endif
3283
3284 QFileInfo fi(fileName);
3285 if (!fi.exists())
3286 {
3287 ScMessageBox::warning(this, CommonStrings::trWarning, tr("File does not exist on the specified path :\n%1").arg(QDir::toNativeSeparators(fileName)), QMessageBox::Ok);
3288 return false;
3289 }
3290
3291 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
3292 if (HaveDoc)
3293 outlinePalette->buildReopenVals();
3294 bool ret = false;
3295 QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
3296 ScribusWin* ActWinOld = nullptr;
3297 if (windows.count() != 0)
3298 {
3299 ActWinOld = ActWin;
3300 }
3301
3302 // PV - 5780: Scribus doesn't track what documents are already opened
3303 // The goal of this part of code is to disallow user to open one
3304 // doc multiple times.
3305 QString filename = fi.absoluteFilePath();
3306 QString platfName(QDir::toNativeSeparators(filename));
3307 int windowCount = windows.count();
3308 for (int i = 0; i < windowCount; ++i)
3309 {
3310 QString docNameUnmodified(windows.at(i)->windowTitle());
3311 ScribusWin * mx = qobject_cast<ScribusWin*>(windows.at(i)->widget());
3312 if (mx && mx->doc()->isModified() && docNameUnmodified.endsWith("*"))
3313 docNameUnmodified.resize(docNameUnmodified.length() - 1);
3314
3315 if (docNameUnmodified == platfName)
3316 {
3317 qApp->restoreOverrideCursor();
3318 ScMessageBox::information(this, tr("Document is already opened"), tr("This document is already open. It will be set as the active document."));
3319 windowsMenuActivated(i);
3320 return true;
3321 }
3322 }
3323 UndoBlocker undoBlocker;
3324 if (!fileName.isEmpty())
3325 {
3326 FileLoader *fileLoader = new FileLoader(filename);
3327 int testResult = fileLoader->testFile();
3328 if (testResult == -1)
3329 {
3330 delete fileLoader;
3331 qApp->restoreOverrideCursor();
3332 QString title = tr("Fatal Error") ;
3333 QString msg = "<qt>"+ tr("File %1 is not in an acceptable format").arg(filename)+"</qt>";
3334 QString infoMsg = "<qt>" + tr("The file may be damaged or may have been produced in a later version of Scribus.") + "</qt>";
3335 ScMessageBox msgBox(QMessageBox::Critical, title, msg, QMessageBox::Ok | QMessageBox::Help, this);
3336 msgBox.setInformativeText(infoMsg);
3337 int i = msgBox.exec();
3338 if (i == QMessageBox::Help)
3339 slotOnlineHelp("", "fileproblems.html");
3340 return false;
3341 }
3342 bool is12doc=false;
3343 if (testResult == 0)
3344 {
3345 qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
3346 //Scribus 1.3.x warning, remove at a later stage
3347 is12doc=true;
3348 }
3349 QDir docProfileDir(fi.absolutePath() + "/profiles");
3350 ScCore->getCMSProfilesDir(fi.absolutePath() + "/", false, false);
3351 if (docProfileDir.exists())
3352 ScCore->getCMSProfilesDir(fi.absolutePath() + "/profiles", false, false);
3353
3354 m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/", filename);
3355 QDir docFontDir(fi.absolutePath() + "/fonts");
3356 if (docFontDir.exists())
3357 m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/fonts", filename);
3358 QDir docFontDir2(fi.absolutePath() + "/Fonts");
3359 if (docFontDir2.exists())
3360 m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/Fonts", filename);
3361 QDir docFontDir3(fi.absolutePath() + "/Document fonts");
3362 if (docFontDir3.exists())
3363 m_prefsManager.appPrefs.fontPrefs.AvailFonts.addScalableFonts(fi.absolutePath() + "/Document fonts", filename);
3364 m_prefsManager.appPrefs.fontPrefs.AvailFonts.updateFontMap();
3365 if (view != nullptr)
3366 actionManager->disconnectNewViewActions();
3367 doc = new ScribusDoc();
3368 doc->saveFilePermissions(QFile::permissions(fileName));
3369 doc->is12doc=is12doc;
3370 doc->appMode = modeNormal;
3371 doc->HasCMS = false;
3372 doc->OpenNodes.clear();
3373 doc->setLoading(true);
3374 m_mainWindowStatusLabel->setText( tr("Loading..."));
3375 mainWindowProgressBar->reset();
3376 ScribusWin* w = new ScribusWin(mdiArea, doc);
3377 w->setMainWindow(this);
3378 view = new ScribusView(w, this, doc);
3379 doc->setGUI(true, this, view);
3380 view->setScale(m_prefsManager.displayScale());
3381 w->setView(view);
3382 alignDistributePalette->setDoc(doc);
3383 ActWin = w;
3384 doc->WinHan = w;
3385 w->setSubWin(mdiArea->addSubWindow(w));
3386 w->setUpdatesEnabled(false);
3387 view->updatesOn(false);
3388 doc->SoftProofing = false;
3389 doc->Gamut = false;
3390 setScriptRunning(true);
3391 bool loadSuccess = fileLoader->loadFile(doc);
3392 //Do the font replacement check from here, when we have a GUI. TODO do this also somehow without the GUI
3393 //This also gives the user the opportunity to cancel the load when finding theres a replacement required.
3394 if (loadSuccess && ScCore->usingGUI())
3395 loadSuccess = fileLoader->postLoad(doc);
3396 if (!loadSuccess)
3397 {
3398 view->close();
3399 delete fileLoader;
3400 delete doc;
3401 doc = nullptr;
3402 mdiArea->removeSubWindow(w->getSubWin());
3403 delete w;
3404 view = nullptr;
3405 doc = nullptr;
3406 setScriptRunning(false);
3407 qApp->restoreOverrideCursor();
3408 m_mainWindowStatusLabel->setText("");
3409 mainWindowProgressBar->reset();
3410 ActWin = nullptr;
3411 if (windows.count() != 0)
3412 {
3413 newActWin(ActWinOld->getSubWin());
3414 if (ActWin)
3415 {
3416 if ((mdiArea->subWindowList().isEmpty()) || (mdiArea->subWindowList().count() == 1))
3417 ActWin->showMaximized();
3418 }
3419 }
3420 return false;
3421 }
3422 symbolPalette->setDoc(doc);
3423 outlinePalette->setDoc(doc);
3424 fileLoader->informReplacementFonts();
3425 setCurrentComboItem(unitSwitcher, unitGetStrFromIndex(doc->unitIndex()));
3426 bool b = zoomSpinBox->blockSignals(true);
3427 zoomSpinBox->setValue(view->scale());
3428 zoomSpinBox->blockSignals(b);
3429 view->unitChange();
3430 setScriptRunning(false);
3431 view->deselectItems(true);
3432 m_mainWindowStatusLabel->setText("");
3433 mainWindowProgressBar->reset();
3434 HaveDoc++;
3435 if (doc->checkerProfiles().count() == 0)
3436 {
3437 m_prefsManager.initDefaultCheckerPrefs(doc->checkerProfiles());
3438 doc->setCurCheckProfile(CommonStrings::PDF_1_4);
3439 }
3440 m_prefsManager.insertMissingCheckerProfiles(doc->checkerProfiles());
3441 if (doc->pdfOptions().LPISettings.count() == 0)
3442 {
3443 struct LPIData lpo;
3444 lpo.Frequency = 133;
3445 lpo.SpotFunc = 3;
3446 lpo.Angle = 105;
3447 doc->pdfOptions().LPISettings.insert("Cyan", lpo);
3448 lpo.Angle = 75;
3449 doc->pdfOptions().LPISettings.insert("Magenta", lpo);
3450 lpo.Angle = 90;
3451 doc->pdfOptions().LPISettings.insert("Yellow", lpo);
3452 lpo.Angle = 45;
3453 doc->pdfOptions().LPISettings.insert("Black", lpo);
3454 }
3455 if (!doc->cmsSettings().CMSinUse)
3456 doc->HasCMS = false;
3457 if ((ScCore->haveCMS()) && (doc->cmsSettings().CMSinUse))
3458 {
3459 QString missing, replacement;
3460 QMultiMap<QString, QString> missingMap;
3461 if (!ScCore->InputProfiles.contains(doc->cmsSettings().DefaultImageRGBProfile))
3462 {
3463 missing = doc->cmsSettings().DefaultImageRGBProfile;
3464 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
3465 if (!missingMap.contains(missing, replacement))
3466 missingMap.insert(missing, replacement);
3467 doc->cmsSettings().DefaultImageRGBProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
3468 }
3469 if (!ScCore->InputProfilesCMYK.contains(doc->cmsSettings().DefaultImageCMYKProfile))
3470 {
3471 missing = doc->cmsSettings().DefaultImageCMYKProfile;
3472 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageCMYKProfile;
3473 if (!missingMap.contains(missing, replacement))
3474 missingMap.insert(missing, replacement);
3475 doc->cmsSettings().DefaultImageCMYKProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageCMYKProfile;
3476 }
3477 if (!ScCore->InputProfiles.contains(doc->cmsSettings().DefaultSolidColorRGBProfile))
3478 {
3479 missing = doc->cmsSettings().DefaultSolidColorRGBProfile;
3480 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
3481 if (!missingMap.contains(missing, replacement))
3482 missingMap.insert(missing, replacement);
3483 doc->cmsSettings().DefaultSolidColorRGBProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
3484 }
3485 if (!ScCore->InputProfilesCMYK.contains(doc->cmsSettings().DefaultSolidColorCMYKProfile))
3486 {
3487 missing = doc->cmsSettings().DefaultSolidColorCMYKProfile;
3488 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile;
3489 if (!missingMap.contains(missing, replacement))
3490 missingMap.insert(missing, replacement);
3491 doc->cmsSettings().DefaultSolidColorCMYKProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile;
3492 }
3493 if (!ScCore->MonitorProfiles.contains(doc->cmsSettings().DefaultMonitorProfile))
3494 {
3495 missing = doc->cmsSettings().DefaultMonitorProfile;
3496 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultMonitorProfile;
3497 if (!missingMap.contains(missing, replacement))
3498 missingMap.insert(missing, replacement);
3499 doc->cmsSettings().DefaultMonitorProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultMonitorProfile;
3500 }
3501 if (!ScCore->PrinterProfiles.contains(doc->cmsSettings().DefaultPrinterProfile))
3502 {
3503 missing = doc->cmsSettings().DefaultPrinterProfile;
3504 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
3505 if (!missingMap.contains(missing, replacement))
3506 missingMap.insert(missing, replacement);
3507 doc->cmsSettings().DefaultPrinterProfile = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
3508 }
3509 if (!ScCore->PrinterProfiles.contains(doc->pdfOptions().PrintProf))
3510 {
3511 missing = doc->pdfOptions().PrintProf;
3512 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultPrinterProfile;
3513 if (!missingMap.contains(missing, replacement))
3514 missingMap.insert(missing, replacement);
3515 doc->pdfOptions().PrintProf = doc->cmsSettings().DefaultPrinterProfile;
3516 }
3517 if (!ScCore->InputProfiles.contains(doc->pdfOptions().ImageProf))
3518 {
3519 missing = doc->pdfOptions().ImageProf;
3520 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultImageRGBProfile;
3521 if (!missingMap.contains(missing, replacement))
3522 missingMap.insert(missing, replacement);
3523 doc->pdfOptions().ImageProf = doc->cmsSettings().DefaultImageRGBProfile;
3524 }
3525 if (!ScCore->InputProfiles.contains(doc->pdfOptions().SolidProf))
3526 {
3527 missing = doc->pdfOptions().SolidProf;
3528 replacement = m_prefsManager.appPrefs.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
3529 if (!missingMap.contains(missing, replacement))
3530 missingMap.insert(missing, replacement);
3531 doc->pdfOptions().SolidProf = doc->cmsSettings().DefaultSolidColorRGBProfile;
3532 }
3533 if (missingMap.count() > 0)
3534 {
3535 qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
3536 QString mess = tr("Some color profiles used by this document are not installed:")+"\n\n";
3537 for (auto it = missingMap.constBegin(); it != missingMap.constEnd(); ++it)
3538 {
3539 mess += it.key() + tr(" was replaced by: ") + it.value() +"\n";
3540 }
3541 ScMessageBox::warning(this, CommonStrings::trWarning, mess);
3542 }
3543 doc->SoftProofing = doc->cmsSettings().SoftProofOn;
3544 doc->Gamut = doc->cmsSettings().GamutCheck;
3545 doc->IntentColors = doc->cmsSettings().DefaultIntentColors;
3546 doc->IntentImages = doc->cmsSettings().DefaultIntentImages;
3547 if (doc->OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles))
3548 {
3549 doc->HasCMS = true;
3550 doc->pdfOptions().SComp = doc->cmsSettings().ComponentsInput2;
3551 }
3552 else
3553 {
3554 doc->SetDefaultCMSParams();
3555 doc->HasCMS = false;
3556 }
3557 if (doc->HasCMS)
3558 {
3559 recalcColors();
3560 doc->RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK);
3561 }
3562 }
3563 else
3564 {
3565 doc->cmsSettings().CMSinUse = false;
3566 }
3567 if (fileLoader->fileType() > FORMATID_NATIVEIMPORTEND)
3568 {
3569 doc->setDocumentFileName(filename+ tr("(converted)"));
3570 QFileInfo fi(doc->documentFileName());
3571 doc->setDocumentFileName(fi.fileName());
3572 doc->isConverted = true;
3573 }
3574 else
3575 doc->setDocumentFileName(filename);
3576 doc->setMasterPageMode(false);
3577 doc->createHyphenator();
3578 HaveNewDoc();
3579 doc->hasName = true;
3580 if (doc->MasterPages.count() == 0)
3581 {
3582 ScPage *docPage = doc->Pages->at(0);
3583 ScPage *addedPage = doc->addMasterPage(0, CommonStrings::masterPageNormal);
3584 addedPage->setSize(docPage->size());
3585 addedPage->setInitialHeight(docPage->height());
3586 addedPage->setInitialWidth(docPage->width());
3587 addedPage->setHeight(docPage->height());
3588 addedPage->setWidth(docPage->width());
3589 addedPage->initialMargins = docPage->initialMargins;
3590 addedPage->LeftPg = docPage->LeftPg;
3591 addedPage->setOrientation(docPage->orientation());
3592 }
3593 //Add doc sections if we have none
3594 if (doc->sections().count()==0)
3595 {
3596 doc->addSection(-1);
3597 doc->setFirstSectionFromFirstPageNumber();
3598 }
3599 doc->RePos = true;
3600 doc->setMasterPageMode(true);
3601 doc->reformPages();
3602 doc->refreshGuides();
3603 doc->setLoading(false);
3604 for (auto itm = doc->MasterItems.begin(); itm != doc->MasterItems.end(); ++itm)
3605 {
3606 PageItem* ite = *itm;
3607 // TODO fix that for Groups on Masterpages
3608 // if (ite->Groups.count() != 0)
3609 // view->GroupOnPage(ite);
3610 // qDebug() << QString("load M: %1 %2 %3").arg(azz).arg((uint)ite).arg(ite->itemType());
3611 ite->layout();
3612 }
3613 doc->setMasterPageMode(false);
3614 /*QTime t;
3615 t.start();*/
3616 doc->flag_Renumber = false;
3617 doc->updateNumbers(true);
3618 for (auto iti = doc->Items->begin(); iti != doc->Items->end(); ++iti)
3619 {
3620 PageItem* ite = *iti;
3621 if ((ite->nextInChain() == nullptr) && !ite->isNoteFrame()) //do not layout notes frames
3622 ite->layout();
3623 }
3624 if (!doc->marksList().isEmpty())
3625 {
3626 doc->setLoading(true);
3627 doc->updateMarks(true);
3628 doc->setLoading(false);
3629 }
3630 for (auto itf = doc->FrameItems.begin(); itf != doc->FrameItems.end(); ++itf)
3631 {
3632 PageItem *ite = itf.value();
3633 // qDebug() << QString("load F: %1 %2 %3").arg(azz).arg((uint)ite).arg(ite->itemType());
3634 if (ite->nextInChain() == nullptr)
3635 ite->layout();
3636 }
3637 /*qDebug("Time elapsed: %d ms", t.elapsed());*/
3638 doc->RePos = false;
3639 doc->setModified(false);
3640 inlinePalette->setDoc(doc);
3641 updateRecent(filename);
3642 m_mainWindowStatusLabel->setText( tr("Ready"));
3643 ret = true;
3644 doc->setLoading(true);
3645 for (int p = 0; p < doc->DocPages.count(); ++p)
3646 {
3647 Apply_MasterPage(doc->DocPages.at(p)->masterPageName(), p, false);
3648 }
3649 view->reformPages(false);
3650 doc->setLoading(false);
3651 delete fileLoader;
3652 view->updatesOn(true);
3653 w->setUpdatesEnabled(true);
3654 disconnect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow *)), this, SLOT(newActWin(QMdiSubWindow *)));
3655 if ((mdiArea->subWindowList().isEmpty()) || (mdiArea->subWindowList().count() == 1))
3656 w->showMaximized();
3657 else
3658 w->show();
3659 view->show();
3660 // Seems to fix crash on loading
3661 ActWin = nullptr;
3662 newActWin(w->getSubWin());
3663 emit UpdateRequest(reqNumUpdate);
3664 doc->setCurrentPage(doc->DocPages.at(0));
3665 scrActions["viewToggleCMS"]->setChecked(doc->HasCMS);
3666 view->zoom();
3667 view->GotoPage(0);
3668 connect(mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(newActWin(QMdiSubWindow*)));
3669 connect(ScCore->fileWatcher, SIGNAL(fileChanged(QString)), doc, SLOT(updatePict(QString)));
3670 connect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString)), doc, SLOT(removePict(QString)));
3671 connect(ScCore->fileWatcher, SIGNAL(dirChanged(QString)), doc, SLOT(updatePictDir(QString)));
3672 connect(m_undoManager, SIGNAL(undoRedoBegin()), doc, SLOT(undoRedoBegin()));
3673 connect(m_undoManager, SIGNAL(undoRedoDone()), doc, SLOT(undoRedoDone()));
3674 connect(m_undoManager, SIGNAL(undoRedoDone()), view, SLOT(DrawNew()));
3675 doc->connectDocSignals();
3676 if (doc->autoSave())
3677 doc->autoSaveTimer->start(doc->autoSaveTime());
3678 connect(doc, SIGNAL(updateAutoSaveClock()), view->clockLabel, SLOT(resetTime()));
3679 view->clockLabel->resetTime();
3680 doc->NrItems = bookmarkPalette->BView->NrItems;
3681 doc->First = bookmarkPalette->BView->First;
3682 doc->Last = bookmarkPalette->BView->Last;
3683 if (doc->drawAsPreview)
3684 view->togglePreview(true);
3685 }
3686 else
3687 {
3688 pagePalette->setView(nullptr);
3689 }
3690
3691 m_undoManager->switchStack(doc->documentFileName());
3692 pagePalette->rebuild();
3693 qApp->restoreOverrideCursor();
3694 doc->setModified(false);
3695 foreach (NotesStyle* NS, doc->m_docNotesStylesList)
3696 doc->updateNotesFramesStyles(NS);
3697 #ifdef DEBUG_LOAD_TIMES
3698 times(&tms2);
3699 double ticks = sysconf(_SC_CLK_TCK);
3700 double user = (tms2.tms_utime - tms1.tms_utime)/ticks;
3701 double sys = (tms2.tms_stime - tms1.tms_stime)/ticks;
3702 double cuser = (tms2.tms_cutime - tms1.tms_cutime)/ticks;
3703 double csys = (tms2.tms_cstime - tms1.tms_cstime)/ticks;
3704 qDebug("loaded document in %.3f seconds (%.3f user + %.3f sys = %.3f sec, child %.3f user + %.3f sys = %.3f sec)",
3705 t.elapsed()/1000.0, user, sys, user + sys, cuser, csys, cuser + csys);
3706 #endif
3707 return ret;
3708 }
3709
postLoadDoc()3710 bool ScribusMainWindow::postLoadDoc()
3711 {
3712 //FIXME Just return for now, if we arent using the GUI
3713 return ScCore->usingGUI();
3714 }
3715
3716 // This method was once named slotFileOpen(...) but it hasn't had anything to
3717 // do with file->open for a LONG time. It's used for get text / get picture.
slotGetContent()3718 void ScribusMainWindow::slotGetContent()
3719 {
3720 if (doc->m_Selection->isEmpty())
3721 return;
3722
3723 PageItem *currItem = doc->m_Selection->itemAt(0);
3724 if (currItem->itemType() == PageItem::ImageFrame)
3725 {
3726 QString formatD(FormatsManager::instance()->fileDialogFormatList(FormatsManager::IMAGESIMGFRAME));
3727
3728 QString prefsDocDir = m_prefsManager.documentDir();
3729 PrefsContext *dirsContext = m_prefsManager.prefsFile->getContext("dirs");
3730 QString docDir = dirsContext->get("images", prefsDocDir.isEmpty() ? "." : prefsDocDir);
3731
3732 QStringList fileNames;
3733 CustomFDialog *dia = new CustomFDialog(qApp->activeWindow(), docDir, tr("Open"), formatD, fdShowPreview | fdExistingFilesI | fdDisableOk);
3734 if (dia->exec() == QDialog::Accepted)
3735 fileNames = dia->selectedFiles();
3736 delete dia;
3737 //QStringList fileNames = CFileDialog( docDir, tr("Open"), formatD, "", fdShowPreview | fdExistingFiles);
3738 if (!fileNames.isEmpty())
3739 {
3740 dirsContext->set("images", fileNames[0].left(fileNames[0].lastIndexOf("/")));
3741 view->requestMode(modeImportImage);
3742 CanvasMode_ImageImport* cii = qobject_cast<CanvasMode_ImageImport*>(view->canvasMode());
3743 if (cii)
3744 cii->setImageList(fileNames);
3745 }
3746 }
3747 else if (currItem->isTextFrame())
3748 {
3749 gtGetText* gt = new gtGetText(doc);
3750 ImportSetup impsetup=gt->run();
3751 if (impsetup.runDialog)
3752 {
3753 if (currItem->itemText.length() != 0)
3754 {
3755 int t = ScMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to clear all your text?"),
3756 QMessageBox::Yes | QMessageBox::No,
3757 QMessageBox::No, // GUI default
3758 QMessageBox::Yes); // batch default
3759 if (t == QMessageBox::No)
3760 {
3761 delete gt;
3762 return;
3763 }
3764 }
3765 gt->launchImporter(impsetup.importer, impsetup.filename, impsetup.textOnly, impsetup.encoding, false, impsetup.prefixNames);
3766 }
3767 delete gt;
3768 if (doc->docHyphenator->AutoCheck)
3769 doc->docHyphenator->slotHyphenate(currItem);
3770 for (int a = 0; a < doc->Items->count(); ++a)
3771 {
3772 if (doc->Items->at(a)->isBookmark)
3773 bookmarkPalette->BView->changeText(doc->Items->at(a));
3774 }
3775 if (!impsetup.textOnly)
3776 doc->flag_NumUpdateRequest = true;
3777 view->DrawNew();
3778 slotDocCh();
3779 m_styleManager->setDoc(doc);
3780 marksManager->setDoc(doc);
3781 nsEditor->setDoc(doc);
3782 inlinePalette->unsetDoc();
3783 inlinePalette->setDoc(doc);
3784 if (outlinePalette->isVisible())
3785 outlinePalette->BuildTree();
3786 propertiesPalette->updateColorList();
3787 contentPalette->updateColorList();
3788 emit UpdateRequest(reqArrowStylesUpdate | reqLineStylesUpdate | reqStyleComboDocUpdate | reqInlinePalUpdate);
3789 symbolPalette->updateSymbolList();
3790 }
3791 }
3792
updateFromDrop()3793 void ScribusMainWindow::updateFromDrop()
3794 {
3795 m_styleManager->setDoc(doc);
3796 marksManager->setDoc(doc);
3797 nsEditor->setDoc(doc);
3798 inlinePalette->unsetDoc();
3799 inlinePalette->setDoc(doc);
3800 if (outlinePalette->isVisible())
3801 outlinePalette->BuildTree();
3802 propertiesPalette->updateColorList();
3803 contentPalette->updateColorList();
3804 emit UpdateRequest(reqArrowStylesUpdate | reqLineStylesUpdate | reqStyleComboDocUpdate | reqInlinePalUpdate);
3805 symbolPalette->updateSymbolList();
3806 }
3807
slotGetContent2()3808 void ScribusMainWindow::slotGetContent2() // kk2006
3809 {
3810 if (doc->m_Selection->isEmpty())
3811 return; // nothing to do, no selection
3812
3813 PageItem *currItem = doc->m_Selection->itemAt(0);
3814
3815 if (!currItem->isTextFrame())
3816 return; // not a text frame
3817
3818 ScGTPluginManager::instance()->run();
3819 if (doc->docHyphenator->AutoCheck)
3820 doc->docHyphenator->slotHyphenate(currItem);
3821 for (int a = 0; a < doc->Items->count(); ++a)
3822 {
3823 if (doc->Items->at(a)->isBookmark)
3824 bookmarkPalette->BView->changeText(doc->Items->at(a));
3825 }
3826 view->DrawNew();
3827 slotDocCh();
3828 }
3829
slotGetClipboardImage()3830 void ScribusMainWindow::slotGetClipboardImage()
3831 {
3832 if (!HaveDoc || doc->m_Selection->isEmpty())
3833 return;
3834 if (!QApplication::clipboard()->mimeData()->hasImage())
3835 return;
3836
3837 PageItem *currItem = doc->m_Selection->itemAt(0);
3838 if (currItem->itemType() != PageItem::ImageFrame)
3839 return;
3840
3841 int t = QMessageBox::Yes;
3842 if (currItem->imageIsAvailable)
3843 t = ScMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to replace your existing image?"),
3844 QMessageBox::Yes | QMessageBox::No,
3845 QMessageBox::No, // GUI default
3846 QMessageBox::Yes); // batch default
3847 if (t != QMessageBox::Yes)
3848 return;
3849
3850 QImage img = QApplication::clipboard()->image();
3851 if (img.isNull())
3852 return;
3853
3854 QTemporaryFile *tempFile = new QTemporaryFile(QDir::tempPath() + "/scribus_temp_XXXXXX.png");
3855 tempFile->setAutoRemove(false);
3856 if (!tempFile->open())
3857 {
3858 delete tempFile;
3859 return;
3860 }
3861 QString fileName = getLongPathName(tempFile->fileName());
3862 tempFile->close();
3863 delete tempFile;
3864
3865 if (!img.save(fileName, "PNG"))
3866 {
3867 QFile::remove(fileName);
3868 return;
3869 }
3870
3871 currItem->pixm.imgInfo.isRequest = false;
3872 currItem->UseEmbedded = true;
3873 currItem->EmbeddedProfile.clear();
3874 currItem->ImageProfile = doc->cmsSettings().DefaultImageRGBProfile;
3875 currItem->ImageIntent = doc->cmsSettings().DefaultIntentImages;
3876 qApp->setOverrideCursor( QCursor(Qt::WaitCursor) );
3877 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
3878
3879 currItem->isInlineImage = true;
3880 currItem->isTempFile = true;
3881 currItem->Pfile = fileName;
3882 doc->loadPict(fileName, currItem, false, true);
3883 // Call to showScaleAndOffset() is now very likely unnecessary
3884 // due to mecanisms used to update properties in PP in 1.5.x+
3885 //propertiesPalette->imagePal->showScaleAndOffset(currItem->imageXScale(), currItem->imageYScale(), currItem->imageXOffset(), currItem->imageYOffset());
3886 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
3887 view->DrawNew();
3888 emit UpdateRequest(reqColorsUpdate | reqCmsOptionsUpdate);
3889 currItem->emitAllToGUI();
3890 qApp->restoreOverrideCursor();
3891 }
3892
toogleInlineState()3893 void ScribusMainWindow::toogleInlineState()
3894 {
3895 if (!HaveDoc)
3896 return;
3897 if (doc->m_Selection->isEmpty())
3898 return;
3899 PageItem *currItem = doc->m_Selection->itemAt(0);
3900 if (currItem->itemType() != PageItem::ImageFrame)
3901 return;
3902 if (!currItem->imageIsAvailable)
3903 return;
3904 if (currItem->isImageInline())
3905 {
3906 QFileInfo fiB(currItem->Pfile);
3907
3908 PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
3909 QString wdir = ".";
3910 if (doc->hasName)
3911 {
3912 QFileInfo fi(doc->documentFileName());
3913 wdir = QDir::fromNativeSeparators( fi.path() );
3914 }
3915 else
3916 {
3917 QString prefsDocDir = m_prefsManager.documentDir();
3918 if (!prefsDocDir.isEmpty())
3919 wdir = docContext->get("place_as", prefsDocDir);
3920 else
3921 wdir = docContext->get("place_as", ".");
3922 wdir = QDir::fromNativeSeparators( wdir );
3923 }
3924 QString fileName = CFileDialog(wdir, tr("Filename and Path for Image"), tr("All Files (*)"), fiB.fileName(), fdHidePreviewCheckBox);
3925 if (!fileName.isEmpty())
3926 {
3927 if (ScCore->fileWatcher->isWatching(currItem->Pfile))
3928 ScCore->fileWatcher->removeFile(currItem->Pfile);
3929 docContext->set("place_as", fileName.left(fileName.lastIndexOf("/")));
3930 if (overwrite(this, fileName))
3931 {
3932 currItem->makeImageExternal(fileName);
3933 ScCore->fileWatcher->addFile(currItem->Pfile);
3934 bool fho = currItem->imageFlippedH();
3935 bool fvo = currItem->imageFlippedV();
3936 doc->loadPict(currItem->Pfile, currItem, true);
3937 currItem->setImageFlippedH(fho);
3938 currItem->setImageFlippedV(fvo);
3939 }
3940 }
3941 }
3942 else
3943 {
3944 if (ScCore->fileWatcher->isWatching(currItem->Pfile))
3945 ScCore->fileWatcher->removeFile(currItem->Pfile);
3946 currItem->makeImageInline();
3947 ScCore->fileWatcher->addFile(currItem->Pfile);
3948 bool fho = currItem->imageFlippedH();
3949 bool fvo = currItem->imageFlippedV();
3950 doc->loadPict(currItem->Pfile, currItem, true);
3951 currItem->setImageFlippedH(fho);
3952 currItem->setImageFlippedV(fvo);
3953 }
3954 scrActions["itemToggleInlineImage"]->setChecked(currItem->isImageInline());
3955 }
3956
slotFileAppend()3957 void ScribusMainWindow::slotFileAppend()
3958 {
3959 if (!doc->m_Selection->isEmpty())
3960 {
3961 gtGetText* gt = new gtGetText(doc);
3962 ImportSetup impsetup=gt->run();
3963 if (impsetup.runDialog)
3964 {
3965 gt->launchImporter(impsetup.importer, impsetup.filename, impsetup.textOnly, impsetup.encoding, true, impsetup.prefixNames);
3966 }
3967 delete gt;
3968 //CB Hyphenating now emits doc changed, plus we change lang as appropriate
3969 if (doc->docHyphenator->AutoCheck)
3970 doc->itemSelection_DoHyphenate();
3971 view->DrawNew();
3972 //slotDocCh();
3973 }
3974 }
3975
slotFileRevert()3976 void ScribusMainWindow::slotFileRevert()
3977 {
3978 if ((doc->hasName) && (doc->isModified()) && (!doc->masterPageMode()) && (!doc->isConverted))
3979 {
3980 ScribusWin* tw = ActWin;
3981 if (!scriptIsRunning())
3982 {
3983 int t = ScMessageBox::warning(this, CommonStrings::trWarning, "<qt>" +
3984 QObject::tr("The changes to your document have not been saved and you have requested to revert them. Do you wish to continue?") + "</qt>",
3985 QMessageBox::Yes | QMessageBox::No,
3986 QMessageBox::No, // GUI default
3987 QMessageBox::Yes); // batch default
3988 if (t == QMessageBox::No)
3989 return;
3990 }
3991
3992 mdiArea->setActiveSubWindow(tw->getSubWin());
3993 ActWin = tw;
3994 QString fn(doc->documentFileName());
3995 doc->setModified(false);
3996 if (doc==storyEditor->currentDocument())
3997 storyEditor->close();
3998 slotFileClose();
3999 qApp->processEvents();
4000 loadDoc(fn);
4001 m_undoManager->clearStack();
4002 }
4003 }
4004
slotFileSave()4005 bool ScribusMainWindow::slotFileSave()
4006 {
4007 bool ret = false;
4008 if ((doc->hasName) && (!doc->isConverted))
4009 {
4010 //Scribus 1.3.x warning, remove at a later stage
4011 if (doc->is12doc && !warningVersion(this))
4012 return false;
4013
4014 QString fn(doc->documentFileName()), savedFileName;
4015 ret = DoFileSave(fn, &savedFileName);
4016 if (!ret && !savedFileName.isEmpty())
4017 ScMessageBox::warning(this, CommonStrings::trWarning, tr("Your document was saved to a temporary file and could not be moved: \n%1").arg( QDir::toNativeSeparators(savedFileName) ));
4018 else if (!ret)
4019 ScMessageBox::warning(this, CommonStrings::trWarning, tr("Cannot write the file: \n%1").arg( QDir::toNativeSeparators(fn) ));
4020 }
4021 else
4022 ret = slotFileSaveAs();
4023 return ret;
4024 }
4025
slotFileSaveAs()4026 bool ScribusMainWindow::slotFileSaveAs()
4027 {
4028 //Scribus 1.3.x warning, remove at a later stage
4029 if (doc->is12doc)
4030 if (!warningVersion(this))
4031 return false;
4032 //Turn off the warnings once the docs is saved.
4033 doc->is12doc=false;
4034 bool ret = false;
4035 QString filename;
4036 PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
4037 QString wdir = ".";
4038 if (doc->hasName)
4039 {
4040 QFileInfo fi(doc->documentFileName());
4041 QString completeBaseName = fi.completeBaseName();
4042 if (completeBaseName.endsWith(".sla", Qt::CaseInsensitive))
4043 completeBaseName.chop(4);
4044 else if (completeBaseName.endsWith(".gz", Qt::CaseInsensitive))
4045 completeBaseName.chop(3);
4046 wdir = QDir::fromNativeSeparators( fi.path() );
4047 filename = QDir::fromNativeSeparators( fi.path()+"/"+completeBaseName+".sla" );
4048 }
4049 else
4050 {
4051 QString prefsDocDir=m_prefsManager.documentDir();
4052 if (!prefsDocDir.isEmpty())
4053 wdir = docContext->get("save_as", prefsDocDir);
4054 else
4055 wdir = docContext->get("save_as", ".");
4056 wdir = QDir::fromNativeSeparators( wdir );
4057 if (wdir.right(1) != "/")
4058 filename = wdir + "/";
4059 else
4060 filename = wdir;
4061 filename += doc->documentFileName() + ".sla";
4062 }
4063 bool saveCompressed=m_prefsManager.appPrefs.docSetupPrefs.saveCompressed;
4064 if (saveCompressed)
4065 filename.append(".gz");
4066
4067 QString fileSpec = tr("Documents (*.sla *.sla.gz);;All Files (*)");
4068 int optionFlags = fdCompressFile | fdHidePreviewCheckBox;
4069 QString fn = CFileDialog( wdir, tr("Save As"), fileSpec, filename, optionFlags, &saveCompressed);
4070 if (!fn.isEmpty())
4071 {
4072 docContext->set("save_as", fn.left(fn.lastIndexOf("/")));
4073 if ((fn.endsWith(".sla")) || (fn.endsWith(".sla.gz")))
4074 filename = fn;
4075 else
4076 filename = fn+".sla";
4077 if (overwrite(this, filename))
4078 {
4079 QString savedFileName;
4080 ret = DoFileSave(filename, &savedFileName);
4081 if (!ret && !savedFileName.isEmpty())
4082 ScMessageBox::warning(this, CommonStrings::trWarning, tr("Your document was saved to a temporary file and could not be moved: \n%1").arg( QDir::toNativeSeparators(savedFileName) ));
4083 else if (!ret)
4084 ScMessageBox::warning(this, CommonStrings::trWarning, tr("Cannot write the file: \n%1").arg( QDir::toNativeSeparators(fn) ));
4085 else
4086 doc->pdfOptions().fileName.clear(); // #1482 reset the pdf file name
4087 }
4088 }
4089 m_mainWindowStatusLabel->setText( tr("Ready"));
4090 return ret;
4091 }
4092
DoFileSave(const QString & fileName,QString * savedFileName)4093 bool ScribusMainWindow::DoFileSave(const QString& fileName, QString* savedFileName)
4094 {
4095 ScCore->fileWatcher->forceScan();
4096 ScCore->fileWatcher->stop();
4097 doc->reorganiseFonts();
4098 m_mainWindowStatusLabel->setText( tr("Saving..."));
4099 mainWindowProgressBar->reset();
4100 bool ret = doc->save(fileName, savedFileName);
4101 qApp->processEvents();
4102 if (ret)
4103 {
4104 updateActiveWindowCaption(fileName);
4105 m_undoManager->renameStack(fileName);
4106 scrActions["fileRevert"]->setEnabled(false);
4107 updateRecent(fileName);
4108 }
4109 m_mainWindowStatusLabel->setText("");
4110 mainWindowProgressBar->reset();
4111 ScCore->fileWatcher->start();
4112 return ret;
4113 }
4114
slotFileClose()4115 bool ScribusMainWindow::slotFileClose()
4116 {
4117 ScribusWin* tw = ActWin;
4118 mdiArea->closeActiveSubWindow();
4119 windowsMenuAboutToShow();
4120 return (tw != ActWin);
4121 }
4122
DoFileClose()4123 bool ScribusMainWindow::DoFileClose()
4124 {
4125 slotEndSpecialEdit();
4126 view->deselectItems(false);
4127 if (doc == storyEditor->currentDocument())
4128 storyEditor->close();
4129 actionManager->disconnectNewDocActions();
4130 actionManager->disconnectNewViewActions();
4131 m_undoManager->removeStack(doc->documentFileName());
4132 closeActiveWindowMasterPageEditor();
4133 slotSelect();
4134 doc->autoSaveTimer->stop();
4135 doc->disconnectDocSignals();
4136 disconnect(ScCore->fileWatcher, SIGNAL(fileChanged(QString )), doc, SLOT(updatePict(QString)));
4137 disconnect(ScCore->fileWatcher, SIGNAL(fileDeleted(QString )), doc, SLOT(removePict(QString)));
4138 disconnect(ScCore->fileWatcher, SIGNAL(dirChanged(QString )), doc, SLOT(updatePictDir(QString )));
4139 if (ScCore->haveCMS())
4140 doc->CloseCMSProfiles();
4141 //<<Palettes
4142 propertiesPalette->unsetDoc();
4143 contentPalette->unsetDoc();
4144 inlinePalette->unsetDoc();
4145 symbolPalette->unsetDoc();
4146 pagePalette->setView(nullptr);
4147 pagePalette->rebuild();
4148 if (doc->appMode == modeEditClip)
4149 view->requestMode(submodeEndNodeEdit);
4150 bookmarkPalette->BView->clear();
4151 bookmarkPalette->BView->NrItems = 0;
4152 bookmarkPalette->BView->First = 1;
4153 bookmarkPalette->BView->Last = 0;
4154 outlinePalette->unsetDoc();
4155 alignDistributePalette->setDoc(nullptr);
4156 //>>
4157
4158 if ((mdiArea->subWindowList().isEmpty()) || (mdiArea->subWindowList().count() == 1))
4159 {
4160 PluginManager& pluginManager(PluginManager::instance());
4161 pluginManager.enableOnlyStartupPluginActions(this);
4162 appModeHelper->mainWindowCloseLastDoc();
4163 m_mainWindowStatusLabel->setText( tr("Ready"));
4164 m_PrinterUsed = false;
4165 }
4166 // Give plugins a chance to react on closing the document
4167 PluginManager& pluginManager(PluginManager::instance());
4168 QStringList pluginNames(pluginManager.pluginNames(false));
4169 ScPlugin* plugin;
4170 QString pName;
4171 for (int i = 0; i < pluginNames.count(); ++i)
4172 {
4173 pName = pluginNames.at(i);
4174 plugin = pluginManager.getPlugin(pName, true);
4175 Q_ASSERT(plugin); // all the returned names should represent loaded plugins
4176 plugin->unsetDoc();
4177 }
4178 view->close();
4179 //CB Yes, we are setting it to nullptr without deleting it. ActWin(ScribusWin) owns the view
4180 //due to it being the central widget and will delete it at the correct moment from its own pointer.
4181 view = nullptr;
4182 doc->setLoading(true);
4183 guidePalette->setDoc(nullptr);
4184 charPalette->setDoc(nullptr);
4185 m_tocGenerator->setDoc(nullptr);
4186 m_styleManager->setDoc(nullptr);
4187 marksManager->setDoc(nullptr);
4188 nsEditor->setDoc(nullptr);
4189 layerPalette->clearContent();
4190 docCheckerPalette->buildErrorList(nullptr);
4191 HaveDoc--;
4192 delete doc;
4193 doc = nullptr;
4194 ActWin = nullptr;
4195 if (HaveDoc == 0)
4196 {
4197 QString prefsDocDir( PrefsManager::instance().documentDir() );
4198 if ( QDir().exists(prefsDocDir) )
4199 QDir::setCurrent( PrefsManager::instance().documentDir() );
4200 else
4201 QDir::setCurrent( QDir::homePath() );
4202 }
4203 pageSelector->disconnect();
4204 pageSelector->setMaximum(1);
4205 pageSelector->setEnabled(false);
4206 updateLayerMenu();
4207 updateTableMenuActions();
4208 rebuildScrapbookMenu();
4209 mainWindowXPosDataLabel->clear();
4210 mainWindowYPosDataLabel->clear();
4211 //not running view's togglePreview as we don't want to affect the doc settings.
4212 scrActions["viewPreviewMode"]->setChecked(false);
4213 appModeHelper->setPreviewMode(false);
4214 return true;
4215 }
4216
slotFilePrint()4217 void ScribusMainWindow::slotFilePrint()
4218 {
4219 if (doc->checkerProfiles()[doc->curCheckProfile()].autoCheck)
4220 {
4221 if (scanDocument())
4222 {
4223 if (doc->checkerProfiles()[doc->curCheckProfile()].ignoreErrors)
4224 {
4225 int t = ScMessageBox::warning(this, CommonStrings::trWarning,
4226 "<qt>"+ tr("Scribus has detected some errors. Consider using the Preflight Verifier to correct them")+"</qt>",
4227 QMessageBox::Abort | QMessageBox::Ignore,
4228 QMessageBox::NoButton, // GUI default
4229 QMessageBox::Ignore); // batch default
4230 if (t == QMessageBox::Abort)
4231 return;
4232 }
4233 else
4234 {
4235 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(slotReallyPrint()));
4236 docCheckerPalette->setIgnoreEnabled(true);
4237 docCheckerPalette->checkMode = CheckDocument::checkPrint;
4238 docCheckerPalette->buildErrorList(doc);
4239 docCheckerPalette->show();
4240 scrActions["toolsPreflightVerifier"]->setChecked(true);
4241 return;
4242 }
4243 }
4244 }
4245 slotReallyPrint();
4246 }
4247
slotReallyPrint()4248 void ScribusMainWindow::slotReallyPrint()
4249 {
4250 bool done;
4251 if (docCheckerPalette->isIgnoreEnabled())
4252 {
4253 docCheckerPalette->setIgnoreEnabled(false);
4254 docCheckerPalette->hide();
4255 docCheckerPalette->checkMode = CheckDocument::checkNULL;
4256 scrActions["toolsPreflightVerifier"]->setChecked(false);
4257 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(slotReallyPrint()));
4258 }
4259 QString printError;
4260 PrintOptions options;
4261 m_mainWindowStatusLabel->setText( tr("Printing..."));
4262 if (doc->Print_Options.firstUse)
4263 {
4264 doc->Print_Options.printer.clear();
4265 if (!doc->documentFileName().startsWith( tr("Document")))
4266 {
4267 QFileInfo fi(doc->documentFileName());
4268 QString completeBaseName = fi.completeBaseName();
4269 if (completeBaseName.endsWith(".sla", Qt::CaseInsensitive))
4270 if (completeBaseName.length() > 4) completeBaseName.chop(4);
4271 if (completeBaseName.endsWith(".gz", Qt::CaseInsensitive))
4272 if (completeBaseName.length() > 3) completeBaseName.chop(3);
4273 doc->Print_Options.filename = fi.path()+"/"+completeBaseName+".ps";
4274 }
4275 else
4276 {
4277 QDir di = QDir();
4278 doc->Print_Options.filename = di.currentPath()+"/"+doc->documentFileName()+".ps";
4279 }
4280 }
4281 doc->Print_Options.copies = 1;
4282
4283 PrintDialog *printer = new PrintDialog(this, doc, doc->Print_Options);
4284 printer->setMinMax(1, doc->Pages->count(), doc->currentPage()->pageNr()+1);
4285 printDinUse = true;
4286 connect(printer, SIGNAL(doPreview()), this, SLOT(doPrintPreview()));
4287 if (printer->exec())
4288 {
4289 ReOrderText(doc, view);
4290 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
4291 doc->Print_Options.pageNumbers.clear();
4292 if (printer->doPrintCurrentPage())
4293 doc->Print_Options.pageNumbers.push_back(doc->currentPage()->pageNr()+1);
4294 else
4295 {
4296 if (printer->doPrintAll())
4297 parsePagesString("*", &doc->Print_Options.pageNumbers, doc->DocPages.count());
4298 else
4299 parsePagesString(printer->getPageString(), &doc->Print_Options.pageNumbers, doc->DocPages.count());
4300 }
4301 m_PrinterUsed = true;
4302 done = doPrint(doc->Print_Options, printError);
4303 qApp->restoreOverrideCursor();
4304 if (!done)
4305 {
4306 QString message = tr("Printing failed!");
4307 if (!printError.isEmpty())
4308 message += QString("\n%1").arg(printError);
4309 ScMessageBox::warning(this, CommonStrings::trWarning, message);
4310 }
4311 else
4312 doc->Print_Options.firstUse = false;
4313 getDefaultPrinter(PDef.Pname, PDef.Pname, PDef.Command);
4314 }
4315 printDinUse = false;
4316 disconnect(printer, SIGNAL(doPreview()), this, SLOT(doPrintPreview()));
4317 delete printer;
4318 m_mainWindowStatusLabel->setText( tr("Ready"));
4319 }
4320
slotEndSpecialEdit()4321 void ScribusMainWindow::slotEndSpecialEdit()
4322 {
4323 if (doc->symbolEditMode())
4324 editSymbolEnd();
4325 else if (doc->inlineEditMode())
4326 editInlineEnd();
4327 else if (doc->masterPageMode())
4328 editMasterPagesEnd();
4329 }
4330
doPrint(PrintOptions & options,QString & error)4331 bool ScribusMainWindow::doPrint(PrintOptions &options, QString& error)
4332 {
4333 bool printDone = false;
4334 QString filename(options.filename);
4335 if (options.toFile)
4336 {
4337 qApp->setOverrideCursor(QCursor(Qt::ArrowCursor));
4338 if (!overwrite(this, filename))
4339 {
4340 qApp->restoreOverrideCursor();
4341 return true;
4342 }
4343 qApp->restoreOverrideCursor();
4344 }
4345 ScCore->fileWatcher->forceScan();
4346 ScCore->fileWatcher->stop();
4347 ScPrintEngine* prnEngine = nullptr;
4348 #if defined(_WIN32)
4349 if (doc->Print_Options.toFile && (options.prnLanguage == PrintLanguage::PDF))
4350 prnEngine = dynamic_cast<ScPrintEngine*>(new ScPrintEngine_PDF(*doc));
4351 else if (doc->Print_Options.toFile)
4352 prnEngine = dynamic_cast<ScPrintEngine*>(new ScPrintEngine_PS(*doc));
4353 else
4354 prnEngine = dynamic_cast<ScPrintEngine*>(new ScPrintEngine_GDI(*doc));
4355 #else
4356 if (options.prnLanguage == PrintLanguage::PDF)
4357 prnEngine = qobject_cast<ScPrintEngine*>(new ScPrintEngine_PDF(*doc));
4358 else
4359 prnEngine = qobject_cast<ScPrintEngine*>(new ScPrintEngine_PS(*doc));
4360 #endif
4361 if (prnEngine)
4362 {
4363 printDone = prnEngine->print(options);
4364 if (!printDone)
4365 error = prnEngine->errorMessage();
4366 delete prnEngine;
4367 }
4368 else
4369 error = tr( "Print engine initialization failed");
4370 ScCore->fileWatcher->start();
4371 return printDone;
4372 }
4373
slotFileQuit()4374 void ScribusMainWindow::slotFileQuit()
4375 {
4376 ScCore->pluginManager->savePreferences();
4377 close();
4378 }
4379
slotEditCut()4380 void ScribusMainWindow::slotEditCut()
4381 {
4382 if (!HaveDoc)
4383 return;
4384 if (doc->appMode == modeEditClip)
4385 view->requestMode(submodeEndNodeEdit);
4386 if (doc->m_Selection->isEmpty())
4387 return;
4388 int docSelectionCount = doc->m_Selection->count();
4389 UndoTransaction activeTransaction;
4390 PageItem *currItem;
4391 for (int i = 0; i < docSelectionCount; ++i)
4392 {
4393 currItem = doc->m_Selection->itemAt(i);
4394 if ((currItem->isTextFrame() || currItem->isPathText()) && currItem==storyEditor->currentItem() && doc==storyEditor->currentDocument())
4395 {
4396 ScMessageBox::critical(this, tr("Cannot Cut In-Use Item"), tr("The item %1 is currently being edited by Story Editor. The cut operation will be cancelled").arg(currItem->itemName()));
4397 return;
4398 }
4399 }
4400 if (UndoManager::undoEnabled())
4401 {
4402 if (docSelectionCount > 1)
4403 activeTransaction = m_undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Cut, QString(), Um::ICut);
4404 else
4405 {
4406 PageItem* item = doc->m_Selection->itemAt(0);
4407 activeTransaction = m_undoManager->beginTransaction(item->getUName(), item->getUPixmap(), Um::Cut, QString(), Um::ICut);
4408 }
4409 }
4410 currItem = doc->m_Selection->itemAt(0);
4411 if (((doc->appMode == modeEdit) || (doc->appMode == modeEditTable)) && (currItem->isTextFrame() || currItem->isTable()))
4412 {
4413 PageItem_TextFrame *cItem;
4414 if (doc->appMode == modeEditTable)
4415 cItem = currItem->asTable()->activeCell().textFrame();
4416 else
4417 cItem = currItem->asTextFrame();
4418 if (cItem->HasSel)
4419 {
4420 if (cItem->itemText.length() == 0)
4421 return;
4422 StoryText itemText(doc);
4423 itemText.setDefaultStyle(cItem->itemText.defaultStyle());
4424 itemText.insert(0, cItem->itemText, true);
4425
4426 QByteArray storyData;
4427 QScopedPointer<StoryLoader> storyLoader(new StoryLoader());
4428 if (storyLoader->saveStory(storyData, *doc, itemText))
4429 {
4430 ScTextMimeData* mimeData = new ScTextMimeData();
4431 mimeData->setScribusText(storyData);
4432 mimeData->setText(itemText.text(0, itemText.length()));
4433 QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
4434 cItem->deleteSelectedTextFromFrame();
4435 if (doc->appMode == modeEditTable)
4436 currItem->asTable()->update();
4437 else
4438 cItem->update();
4439 }
4440 }
4441 }
4442 else
4443 {
4444 if ((currItem->isSingleSel) && (currItem->isGroup()))
4445 return;
4446 ScriXmlDoc ss;
4447 QString BufferS = ss.writeElem(doc, doc->m_Selection);
4448 if ((m_prefsManager.appPrefs.scrapbookPrefs.doCopyToScrapbook) && (!internalCopy))
4449 {
4450 scrapbookPalette->objFromCopyAction(BufferS, currItem->itemName());
4451 rebuildRecentPasteMenu();
4452 }
4453 ScElemMimeData* mimeData = new ScElemMimeData();
4454 mimeData->setScribusElem(BufferS);
4455 QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
4456 for (int i=0; i < doc->m_Selection->count(); ++i)
4457 {
4458 PageItem* frame = doc->m_Selection->itemAt(i);
4459 if (frame->asTextFrame() && frame->prevInChain() == nullptr)
4460 frame->clearContents();
4461 }
4462 doc->itemSelection_DeleteItem();
4463 }
4464 slotDocCh();
4465 scrActions["editPaste"]->setEnabled(true);
4466 scrMenuMgr->setMenuEnabled("EditPasteRecent", scrapbookPalette->tempBView->objectMap.count() != 0);
4467 if (activeTransaction)
4468 activeTransaction.commit();
4469 }
4470
slotEditCopy()4471 void ScribusMainWindow::slotEditCopy()
4472 {
4473 if (!HaveDoc)
4474 return;
4475 if (doc->appMode == modeEditClip)
4476 view->requestMode(submodeEndNodeEdit);
4477 if (doc->m_Selection->isEmpty())
4478 return;
4479 PageItem *currItem = doc->m_Selection->itemAt(0);
4480 if (((doc->appMode == modeEdit) || (doc->appMode == modeEditTable)) && (currItem->isTextFrame() || currItem->isTable()))
4481 {
4482 PageItem_TextFrame *cItem;
4483 if (doc->appMode == modeEditTable)
4484 cItem = currItem->asTable()->activeCell().textFrame();
4485 else
4486 cItem = currItem->asTextFrame();
4487 if (cItem->HasSel)
4488 {
4489 StoryText itemText(doc);
4490 itemText.setDefaultStyle(cItem->itemText.defaultStyle());
4491 itemText.insert(0, cItem->itemText, true);
4492
4493 QByteArray storyData;
4494 QScopedPointer<StoryLoader> storyLoader(new StoryLoader());
4495 if (storyLoader->saveStory(storyData, *doc, itemText))
4496 {
4497 ScTextMimeData* mimeData = new ScTextMimeData();
4498 mimeData->setScribusText(storyData);
4499 mimeData->setText(itemText.text(0, itemText.length()));
4500 QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
4501 }
4502 }
4503 }
4504 else
4505 {
4506 if ((currItem->isSingleSel) && (currItem->isGroup()))
4507 return;
4508
4509 // Do not copy notes frames
4510 if ((doc->m_Selection->count() == 1) && currItem->isNoteFrame())
4511 return;
4512
4513 // Sort items in Z-order
4514 QList<PageItem*> selectedItems = doc->m_Selection->items();
4515 std::stable_sort(selectedItems.begin(), selectedItems.end(), compareItemLevel);
4516
4517 Selection tempSelection(this, false);
4518 for (int i = 0; i < selectedItems.count(); ++i)
4519 tempSelection.addItem(selectedItems.at(i));
4520
4521 // Deselect notesframes
4522 for (int i = 0; i < doc->m_Selection->count(); ++i)
4523 {
4524 if (doc->m_Selection->itemAt(i)->isNoteFrame())
4525 tempSelection.removeItem(doc->m_Selection->itemAt(i));
4526 }
4527
4528 ScriXmlDoc ss;
4529 QString BufferS = ss.writeElem(doc, &tempSelection);
4530 if (!internalCopy)
4531 {
4532 if ((m_prefsManager.appPrefs.scrapbookPrefs.doCopyToScrapbook) && (!internalCopy))
4533 {
4534 scrapbookPalette->objFromCopyAction(BufferS, currItem->itemName());
4535 rebuildRecentPasteMenu();
4536 }
4537 ScElemMimeData* mimeData = new ScElemMimeData();
4538 mimeData->setScribusElem(BufferS);
4539 QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
4540 }
4541 else
4542 internalCopyBuffer = BufferS;
4543 }
4544 if (!internalCopy)
4545 {
4546 scrActions["editPaste"]->setEnabled(true);
4547 scrMenuMgr->setMenuEnabled("EditPasteRecent", scrapbookPalette->tempBView->objectMap.count() != 0);
4548 }
4549 }
4550
slotEditPaste()4551 void ScribusMainWindow::slotEditPaste()
4552 {
4553 if (!HaveDoc)
4554 return;
4555 if (doc->appMode == modeEditClip)
4556 view->requestMode(submodeEndNodeEdit);
4557 UndoTransaction activeTransaction;
4558 if (!ScMimeData::clipboardHasScribusData() && (!internalCopy))
4559 return;
4560 if (UndoManager::undoEnabled())
4561 activeTransaction = m_undoManager->beginTransaction(doc->currentPage()->getUName(), nullptr, Um::Paste, QString(), Um::IPaste);
4562 PageItem* selItem = doc->m_Selection->itemAt(0);
4563 if (((doc->appMode == modeEdit) || (doc->appMode == modeEditTable)) && selItem && (selItem->isTextFrame() || selItem->isTable()))
4564 {
4565 PageItem_TextFrame *currItem;
4566 if (doc->appMode == modeEditTable)
4567 currItem = selItem->asTable()->activeCell().textFrame();
4568 else
4569 currItem = selItem->asTextFrame();
4570 assert(currItem != nullptr);
4571 if (currItem->HasSel)
4572 {
4573 //removing marks and notes from selected text
4574 // if (currItem->isTextFrame() && !currItem->asTextFrame()->removeMarksFromText(!ScCore->usingGUI()))
4575 // return;
4576 currItem->deleteSelectedTextFromFrame();
4577 }
4578
4579 if (ScMimeData::clipboardHasScribusText())
4580 {
4581 StoryText story(doc);
4582 QScopedPointer<StoryLoader> storyLoader(new StoryLoader());
4583
4584 QByteArray xml = ScMimeData::clipboardScribusText();
4585 if (storyLoader->loadStory(xml, *doc, story, currItem))
4586 {
4587 //avoid pasting notes marks into notes frames
4588 if (currItem->isNoteFrame())
4589 {
4590 for (int pos = story.length() - 1; pos >= 0; --pos)
4591 {
4592 if (story.hasMark(pos) && (story.mark(pos)->isNoteType()))
4593 story.removeChars(pos, 1);
4594 }
4595 }
4596 if (UndoManager::undoEnabled())
4597 {
4598 ScItemState<StoryText> *is = new ScItemState<StoryText>(Um::Paste);
4599 is->set("PASTE_TEXT");
4600 is->set("START", currItem->itemText.cursorPosition());
4601 is->setItem(story);
4602 m_undoManager->action(currItem, is);
4603 }
4604 currItem->itemText.insert(story);
4605 }
4606 }
4607 else if (ScMimeData::clipboardHasScribusElem() || ScMimeData::clipboardHasScribusFragment())
4608 {
4609 bool savedAlignGrid = doc->SnapGrid;
4610 bool savedAlignGuides = doc->SnapGuides;
4611 bool savedAlignElement = doc->SnapElement;
4612 int ac = doc->Items->count();
4613 bool isGroup = false;
4614 double gx, gy, gh, gw;
4615 FPoint minSize = doc->minCanvasCoordinate;
4616 FPoint maxSize = doc->maxCanvasCoordinate;
4617 doc->SnapGrid = false;
4618 doc->SnapGuides = false;
4619 doc->SnapElement = false;
4620 // HACK #6541 : undo does not handle text modification => do not record embedded item creation
4621 // if embedded item is deleted, undo system will not be aware of its deletion => crash - JG
4622 m_undoManager->setUndoEnabled(false);
4623 QString buffer = ScMimeData::clipboardScribusElem();
4624 slotElemRead(buffer, 0, 0, false, true, doc, view);
4625
4626 doc->SnapGrid = savedAlignGrid;
4627 doc->SnapGuides = savedAlignGuides;
4628 doc->SnapElement = savedAlignElement;
4629 Selection tempSelection(*doc->m_Selection);
4630 doc->m_Selection->clear();
4631 if (doc->Items->count() - ac > 1)
4632 isGroup = true;
4633 doc->m_Selection->delaySignalsOn();
4634 for (int as = ac; as < doc->Items->count(); ++as)
4635 {
4636 doc->m_Selection->addItem(doc->Items->at(as));
4637 }
4638 if (isGroup)
4639 doc->GroupCounter++;
4640 doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
4641 PageItem* currItem3 = doc->Items->at(ac);
4642 currItem3->isEmbedded = true;
4643 currItem3->setIsAnnotation(false);
4644 currItem3->isBookmark = false;
4645 currItem3->gXpos = currItem3->xPos() - gx;
4646 currItem3->gYpos = currItem3->yPos() - gy;
4647 currItem3->gWidth = gw;
4648 currItem3->gHeight = gh;
4649 int fIndex = doc->addToInlineFrames(currItem3);
4650 int acc = doc->Items->count();
4651 for (int as = ac; as < acc; ++as)
4652 {
4653 doc->Items->takeAt(ac);
4654 }
4655 doc->m_Selection->clear();
4656 *doc->m_Selection=tempSelection;
4657 doc->minCanvasCoordinate = minSize;
4658 doc->maxCanvasCoordinate = maxSize;
4659 if (outlinePalette->isVisible())
4660 outlinePalette->BuildTree();
4661 m_undoManager->setUndoEnabled(true);
4662 if (UndoManager::undoEnabled())
4663 {
4664 SimpleState *is = new SimpleState(Um::Paste, QString(), Um::IPaste);
4665 is->set("PASTE_INLINE");
4666 is->set("START", currItem->itemText.cursorPosition());
4667 is->set("INDEX", fIndex);
4668 m_undoManager->action(currItem, is);
4669 }
4670 currItem->itemText.insertObject(fIndex);
4671 doc->m_Selection->delaySignalsOff();
4672 }
4673 else if (ScMimeData::clipboardHasKnownData())
4674 {
4675 bool savedAlignGrid = doc->SnapGrid;
4676 bool savedAlignGuides = doc->SnapGuides;
4677 bool savedAlignElement = doc->SnapElement;
4678 FPoint minSize = doc->minCanvasCoordinate;
4679 FPoint maxSize = doc->maxCanvasCoordinate;
4680 doc->SnapGrid = false;
4681 doc->SnapGuides = false;
4682 doc->SnapElement = false;
4683 QString ext = ScMimeData::clipboardKnownDataExt();
4684 QByteArray bitsBits = ScMimeData::clipboardKnownDataData();
4685 double x0 = (view->contentsX() / view->scale()) + ((view->visibleWidth() / 2.0) / view->scale());
4686 double y0 = (view->contentsY() / view->scale()) + ((view->visibleHeight() / 2.0) / view->scale());
4687 PageItem *retObj = getVectorFileFromData(doc, bitsBits, ext, x0, y0);
4688 if (retObj != nullptr)
4689 {
4690 double x = (view->contentsX() / view->scale()) + ((view->visibleWidth() / 2.0) / view->scale()) - (retObj->width() / 2.0);
4691 double y = (view->contentsY() / view->scale()) + ((view->visibleHeight() / 2.0) / view->scale()) - (retObj->height() / 2.0);
4692 retObj->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
4693 retObj->setXYPos(x, y, true);
4694 doc->SnapGrid = savedAlignGrid;
4695 doc->SnapGuides = savedAlignGuides;
4696 doc->SnapElement = savedAlignElement;
4697 Selection tempSelection(*doc->m_Selection);
4698 doc->m_Selection->clear();
4699 doc->m_Selection->delaySignalsOn();
4700 doc->m_Selection->addItem(retObj);
4701 double gx, gy, gh, gw;
4702 doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
4703 retObj->isEmbedded = true;
4704 retObj->setIsAnnotation(false);
4705 retObj->isBookmark = false;
4706 retObj->gXpos = retObj->xPos() - gx;
4707 retObj->gYpos = retObj->yPos() - gy;
4708 retObj->gWidth = gw;
4709 retObj->gHeight = gh;
4710 int fIndex = doc->addToInlineFrames(retObj);
4711 doc->Items->removeAll(retObj);
4712 doc->m_Selection->clear();
4713 *doc->m_Selection=tempSelection;
4714 doc->minCanvasCoordinate = minSize;
4715 doc->maxCanvasCoordinate = maxSize;
4716 if (outlinePalette->isVisible())
4717 outlinePalette->BuildTree();
4718 m_undoManager->setUndoEnabled(true);
4719 if (UndoManager::undoEnabled())
4720 {
4721 SimpleState *is = new SimpleState(Um::Paste, QString(), Um::IPaste);
4722 is->set("PASTE_INLINE");
4723 is->set("START", currItem->itemText.cursorPosition());
4724 is->set("INDEX", fIndex);
4725 m_undoManager->action(currItem, is);
4726 }
4727 currItem->itemText.insertObject(fIndex);
4728 doc->m_Selection->delaySignalsOff();
4729 inlinePalette->unsetDoc();
4730 inlinePalette->setDoc(doc);
4731 }
4732 }
4733 else
4734 {
4735 // K.I.S.S.:
4736 QString text = QApplication::clipboard()->text(QClipboard::Clipboard);
4737 text = text.replace("\r\n", SpecialChars::PARSEP);
4738 text = text.replace('\n', SpecialChars::PARSEP);
4739 if (UndoManager::undoEnabled())
4740 {
4741 SimpleState *is = new SimpleState(Um::Paste, QString(), Um::IPaste);
4742 is->set("PASTE_PLAINTEXT");
4743 is->set("START", currItem->itemText.cursorPosition());
4744 is->set("TEXT", text);
4745 m_undoManager->action(currItem, is);
4746 }
4747 currItem->itemText.insertChars(text, true);
4748 }
4749 if (doc->appMode == modeEditTable)
4750 selItem->asTable()->update();
4751 else
4752 currItem->update();
4753 }
4754 else if (ScMimeData::clipboardHasScribusElem() || ScMimeData::clipboardHasScribusFragment() || internalCopy)
4755 {
4756 view->deselectItems(true);
4757 int docItemCount = doc->Items->count();
4758 bool savedAlignGrid = doc->SnapGrid;
4759 bool savedAlignGuides = doc->SnapGuides;
4760 bool savedAlignElement = doc->SnapElement;
4761 doc->SnapGrid = false;
4762 doc->SnapGuides = false;
4763 doc->SnapElement = false;
4764 if (internalCopy)
4765 slotElemRead(internalCopyBuffer, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, true, doc, view);
4766 else
4767 {
4768 QString buffer = ScMimeData::clipboardScribusElem();
4769 slotElemRead(buffer, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, true, doc, view);
4770 }
4771
4772 doc->SnapGrid = savedAlignGrid;
4773 doc->SnapGuides = savedAlignGuides;
4774 doc->SnapElement = savedAlignElement;
4775 doc->m_Selection->delaySignalsOn();
4776 for (int i = docItemCount; i < doc->Items->count(); ++i)
4777 {
4778 PageItem* currItem = doc->Items->at(i);
4779 if (currItem->isBookmark)
4780 AddBookMark(currItem);
4781 doc->m_Selection->addItem(currItem);
4782 }
4783 doc->m_Selection->delaySignalsOff();
4784 if (doc->m_Selection->count() > 1)
4785 doc->m_Selection->setGroupRect();
4786 }
4787 else if (ScMimeData::clipboardHasKnownData())
4788 {
4789 QString ext = ScMimeData::clipboardKnownDataExt();
4790 QByteArray bitsBits = ScMimeData::clipboardKnownDataData();
4791 double x0 = (view->contentsX() / view->scale()) + ((view->visibleWidth() / 2.0) / view->scale());
4792 double y0 = (view->contentsY() / view->scale()) + ((view->visibleHeight() / 2.0) / view->scale());
4793 PageItem *retObj = getVectorFileFromData(doc, bitsBits, ext, x0, y0);
4794 if (retObj != nullptr)
4795 {
4796 double x = (view->contentsX() / view->scale()) + ((view->visibleWidth() / 2.0) / view->scale()) - (retObj->width() / 2.0);
4797 double y = (view->contentsY() / view->scale()) + ((view->visibleHeight() / 2.0) / view->scale()) - (retObj->height() / 2.0);
4798 retObj->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
4799 retObj->setXYPos(x, y, true);
4800 }
4801 }
4802 if (activeTransaction)
4803 activeTransaction.commit();
4804 if (doc->notesChanged())
4805 doc->notesFramesUpdate();
4806
4807 // update style lists:
4808 requestUpdate(reqColorsUpdate | reqArrowStylesUpdate | reqLineStylesUpdate | reqTextStylesUpdate);
4809
4810 m_styleManager->setDoc(doc);
4811 propertiesPalette->unsetDoc();
4812 propertiesPalette->setDoc(doc);
4813 contentPalette->unsetDoc();
4814 contentPalette->setDoc(doc);
4815 marksManager->setDoc(doc);
4816 nsEditor->setDoc(doc);
4817 symbolPalette->unsetDoc();
4818 symbolPalette->setDoc(doc);
4819 inlinePalette->unsetDoc();
4820 inlinePalette->setDoc(doc);
4821
4822 view->DrawNew();
4823 slotDocCh(false);
4824 }
4825
4826 //CB-->Doc ?????
SelectAllOnLayer()4827 void ScribusMainWindow::SelectAllOnLayer()
4828 {
4829 ColorList UsedC;
4830 doc->getUsedColors(UsedC);
4831 QScopedPointer<selectDialog> dia(new selectDialog(this, UsedC, doc->unitIndex()));
4832 if (!dia->exec())
4833 return;
4834
4835 PageItem *currItem;
4836 view->deselectItems();
4837 int docItemsCount = doc->Items->count();
4838 int docCurrentPage = doc->currentPageNumber();
4839 doc->m_Selection->delaySignalsOn();
4840 int range = dia->getSelectionRange();
4841 for (int i = 0; i < docItemsCount; ++i)
4842 {
4843 currItem = doc->Items->at(i);
4844 if ((currItem->m_layerID == doc->activeLayer()) && (!doc->layerLocked(currItem->m_layerID)))
4845 {
4846 if ((range == 0) && (currItem->OwnPage != docCurrentPage))
4847 continue;
4848 if ((range == 2) && (currItem->OwnPage != -1))
4849 continue;
4850 if (dia->useAttributes())
4851 {
4852 bool useType = false;
4853 bool useFill = false;
4854 bool useLine = false;
4855 bool useLWidth = false;
4856 bool usePrint = false;
4857 bool useLocked = false;
4858 bool useResize = false;
4859 dia->getUsedAttributes(useType, useFill, useLine, useLWidth, usePrint, useLocked, useResize);
4860 int Type = 0;
4861 QString fill;
4862 QString line;
4863 double LWidth = 0.0;
4864 bool Print = false;
4865 bool Locked = false;
4866 bool Resize = false;
4867 dia->getUsedAttributesValues(Type, fill, line, LWidth, Print, Locked, Resize);
4868 LWidth = LWidth / doc->unitRatio();
4869 if ((useType) && (Type != currItem->realItemType()))
4870 continue;
4871 if ((useFill) && ((fill != currItem->fillColor()) || (currItem->GrType != 0)))
4872 continue;
4873 if ((useLine) && (line != currItem->lineColor()))
4874 continue;
4875 if ((useLWidth) && ((LWidth != currItem->lineWidth()) || (currItem->lineColor() == CommonStrings::None)))
4876 continue;
4877 if ((usePrint) && (Print != currItem->printEnabled()))
4878 continue;
4879 if ((useLocked) && (Locked != currItem->locked()))
4880 continue;
4881 if ((useResize) && (Resize != currItem->sizeLocked()))
4882 continue;
4883 doc->m_Selection->addItem(currItem);
4884 }
4885 else
4886 doc->m_Selection->addItem(currItem);
4887 }
4888 }
4889 doc->m_Selection->delaySignalsOff();
4890 if (doc->m_Selection->count() > 1)
4891 doc->m_Selection->setGroupRect();
4892 view->DrawNew();
4893 }
4894
SelectAll(bool docWideSelect)4895 void ScribusMainWindow::SelectAll(bool docWideSelect)
4896 {
4897 if (doc->appMode == modeEdit || doc->appMode == modeEditTable)
4898 {
4899 PageItem *currItem = doc->m_Selection->itemAt(0);
4900 if (doc->appMode == modeEditTable)
4901 currItem = currItem->asTable()->activeCell().textFrame();
4902 PageItem *nextItem = currItem;
4903 nextItem->itemText.selectAll();
4904 while (nextItem != nullptr)
4905 {
4906 if (nextItem->prevInChain() != nullptr)
4907 nextItem = nextItem->prevInChain();
4908 else
4909 break;
4910 }
4911 while (nextItem != nullptr)
4912 {
4913 nextItem->HasSel = true;
4914 nextItem = nextItem->nextInChain();
4915 }
4916 setCopyCutEnabled(true);
4917 }
4918 else
4919 {
4920 PageItem *currItem;
4921 view->deselectItems();
4922 doc->m_Selection->delaySignalsOn();
4923 int docItemsCount = doc->Items->count();
4924 int docCurrentPage = doc->currentPageNumber();
4925 for (int i = 0; i < docItemsCount; ++i)
4926 {
4927 currItem = doc->Items->at(i);
4928 if (doc->canSelectItemOnLayer(currItem->m_layerID))
4929 {
4930 if (docWideSelect)
4931 doc->m_Selection->addItem(currItem);
4932 else
4933 {
4934 if (currItem->OwnPage == docCurrentPage)
4935 doc->m_Selection->addItem(currItem);
4936 }
4937 }
4938 }
4939 doc->m_Selection->delaySignalsOff();
4940 if (doc->m_Selection->count() > 1)
4941 doc->m_Selection->setGroupRect();
4942 }
4943 view->DrawNew();
4944 }
4945
deselectAll()4946 void ScribusMainWindow::deselectAll()
4947 {
4948 if (!HaveDoc)
4949 return;
4950 if (doc->inAnEditMode())
4951 {
4952 if (doc->m_Selection->isEmpty())
4953 return;
4954 PageItem *currItem = doc->m_Selection->itemAt(0);
4955 if (doc->appMode == modeEditTable)
4956 currItem = currItem->asTable()->activeCell().textFrame();
4957 if (currItem->isTextFrame())
4958 {
4959 currItem->itemText.deselectAll();
4960 doc->regionsChanged()->update(currItem->getBoundingRect());
4961 }
4962 else
4963 {
4964 doc->view()->deselectItems(true);
4965 doc->view()->requestMode(modeNormal);
4966 }
4967 }
4968 else if (view != nullptr)
4969 view->deselectItems(true);
4970 }
4971
ClipChange()4972 void ScribusMainWindow::ClipChange()
4973 {
4974 bool textFrameEditMode = false;
4975 bool tableEditMode = false;
4976 bool hasScribusData = ScMimeData::clipboardHasScribusElem() || ScMimeData::clipboardHasScribusFragment();
4977 bool hasExternalData = ScMimeData::clipboardHasKnownData();
4978 if (HaveDoc && !doc->m_Selection->isEmpty())
4979 {
4980 PageItem *currItem = nullptr;
4981 currItem = doc->m_Selection->itemAt(0);
4982 textFrameEditMode = ((doc->appMode == modeEdit) && (currItem->isTextFrame()));
4983 tableEditMode = ((doc->appMode == modeEditTable) && (currItem->isTable()));
4984 }
4985 scrActions["editPaste"]->setEnabled(HaveDoc && (hasScribusData || textFrameEditMode || tableEditMode || hasExternalData));
4986 }
4987
setCopyCutEnabled(bool b)4988 void ScribusMainWindow::setCopyCutEnabled(bool b)
4989 {
4990 scrActions["editCut"]->setEnabled(b);
4991 scrActions["editCopy"]->setEnabled(b);
4992 }
4993
slotHelpAbout()4994 void ScribusMainWindow::slotHelpAbout()
4995 {
4996 About dia(this);
4997 dia.exec();
4998 }
4999
slotHelpAboutPlugins()5000 void ScribusMainWindow::slotHelpAboutPlugins()
5001 {
5002 AboutPlugins dia(this);
5003 dia.exec();
5004 }
5005
slotHelpAboutQt()5006 void ScribusMainWindow::slotHelpAboutQt()
5007 {
5008 ScMessageBox::aboutQt(this, tr("About Qt"));
5009 }
5010
slotHelpActionSearch()5011 void ScribusMainWindow::slotHelpActionSearch()
5012 {
5013 ActionSearch actionSearch(this->menuBar());
5014 actionSearch.update();
5015
5016 QScopedPointer<ActionSearchDialog> dialog(new ActionSearchDialog(this, actionSearch.getActionNames()));
5017 dialog->setModal(true);
5018
5019 int result = dialog->exec();
5020 if (result != QDialog::Accepted)
5021 return;
5022
5023 QString actionName = dialog->getActionName();
5024 if (actionName.isEmpty())
5025 return;
5026 actionSearch.execute(actionName);
5027 }
5028
slotHelpCheckUpdates()5029 void ScribusMainWindow::slotHelpCheckUpdates()
5030 {
5031 About dia(this, About::CheckUpdates);
5032 dia.exec();
5033 }
5034
slotOnlineHelp(const QString & jumpToSection,const QString & jumpToFile)5035 void ScribusMainWindow::slotOnlineHelp(const QString & jumpToSection, const QString & jumpToFile)
5036 {
5037 if (!m_helpBrowser)
5038 {
5039 m_helpBrowser = new HelpBrowser(nullptr, tr("Scribus Manual"), ScCore->getGuiLanguage(), jumpToSection, jumpToFile);
5040 connect(m_helpBrowser, SIGNAL(closed()), this, SLOT(slotOnlineHelpClosed()));
5041 }
5042 else //just set the requested page
5043 {
5044 if (!jumpToSection.isNull() || !jumpToFile.isNull())
5045 {
5046 m_helpBrowser->jumpToHelpSection(jumpToSection, jumpToFile, true);
5047 }
5048 }
5049 slotRaiseOnlineHelp();
5050 }
5051
slotRaiseOnlineHelp()5052 void ScribusMainWindow::slotRaiseOnlineHelp()
5053 {
5054 if (m_helpBrowser)
5055 m_helpBrowser->show();
5056 }
5057
slotOnlineHelpClosed()5058 void ScribusMainWindow::slotOnlineHelpClosed()
5059 {
5060 if (m_helpBrowser)
5061 m_helpBrowser->deleteLater();
5062 }
5063
slotResourceManager()5064 void ScribusMainWindow::slotResourceManager()
5065 {
5066 if (!resourceManager) // in case its allocated???? maybe can remove in future
5067 {
5068 resourceManager = new ResourceManager(this);
5069 resourceManager->exec();
5070 resourceManager->deleteLater();
5071 resourceManager = nullptr;
5072 }
5073 }
5074
ToggleTips()5075 void ScribusMainWindow::ToggleTips()
5076 {
5077 m_prefsManager.appPrefs.displayPrefs.showToolTips = scrActions["helpTooltips"]->isChecked();
5078 }
5079
ToggleMouseTips()5080 void ScribusMainWindow::ToggleMouseTips()
5081 {
5082 m_prefsManager.appPrefs.displayPrefs.showMouseCoordinates = scrActions["showMouseCoordinates"]->isChecked();
5083 }
5084
SaveText()5085 void ScribusMainWindow::SaveText()
5086 {
5087 PrefsContext* dirsContext = m_prefsManager.prefsFile->getContext("dirs");
5088 PrefsContext* textContext = m_prefsManager.prefsFile->getContext("textsave_dialog");
5089 QString prefsDocDir = m_prefsManager.documentDir();
5090 QString workingDir = dirsContext->get("save_text", prefsDocDir.isEmpty() ? "." : prefsDocDir);
5091 QString textEncoding = textContext->get("encoding");
5092
5093 CustomFDialog dia(this, workingDir, tr("Save as"), tr("Text Files (*.txt);;All Files (*)"), fdShowCodecs|fdHidePreviewCheckBox);
5094 dia.setTextCodec(textEncoding);
5095 if (dia.exec() != QDialog::Accepted)
5096 return;
5097
5098 QString fileName = dia.selectedFile();
5099 if (fileName.isEmpty())
5100 return;
5101 textEncoding = dia.textCodec();
5102
5103 dirsContext->set("save_text", fileName.left(fileName.lastIndexOf("/")));
5104 textContext->set("encoding", dia.textCodec());
5105 const StoryText& story (doc->m_Selection->itemAt(0)->itemText);
5106 Serializer::writeWithEncoding(fileName, textEncoding, story.plainText());
5107 }
5108
applyNewMaster(const QString & name)5109 void ScribusMainWindow::applyNewMaster(const QString& name)
5110 {
5111 Apply_MasterPage(name, doc->currentPage()->pageNr(), false);
5112 view->reformPages();
5113 view->DrawNew();
5114 pagePalette->rebuild();
5115 }
5116
slotNewPageP(int wo,const QString & templ)5117 void ScribusMainWindow::slotNewPageP(int wo, const QString& templ)
5118 {
5119 if (!HaveDoc)
5120 return;
5121 if (doc->appMode == modeEditClip)
5122 view->requestMode(submodeEndNodeEdit);
5123 view->deselectItems(true);
5124 int where = 1;
5125 if (wo == 0)
5126 where = 0;
5127 else if (wo == doc->Pages->count())
5128 where = 2;
5129 slotNewPage(wo, templ); //master page is applied now
5130 //applyNewMaster(templ);
5131 if (where == 2)
5132 {
5133 doc->addPageToAnnotLinks(wo, where, 1);
5134 doc->addPageToSection(wo, where, 1);
5135 }
5136 else
5137 {
5138 doc->addPageToAnnotLinks(wo + 1, where, 1);
5139 doc->addPageToSection(wo + 1, where, 1);
5140 }
5141
5142 doc->updateEndnotesFrames();
5143 doc->changed();
5144 updateGUIAfterPagesChanged();
5145 }
5146
5147 /** Erzeugt eine neue Seite */
slotNewPageM()5148 void ScribusMainWindow::slotNewPageM()
5149 {
5150 if (!HaveDoc)
5151 return;
5152 if (doc->appMode == modeEditClip)
5153 view->requestMode(submodeEndNodeEdit);
5154 view->deselectItems(true);
5155 InsPage *dia = new InsPage(this, doc, doc->currentPage()->pageNr(), doc->Pages->count());
5156 if (dia->exec())
5157 {
5158 QStringList base(dia->getMasterPages());
5159 double width = dia->pageWidth();
5160 double height = dia->pageHeight();
5161 int orientation = dia->orientation();
5162 addNewPages(dia->getWherePage(), dia->getWhere(), dia->getCount(), height, width, orientation,
5163 dia->prefsPageSizeName, dia->moveObjects(), &base, dia->overrideMasterPageSizing());
5164 }
5165 delete dia;
5166 }
5167
addNewPages(int wo,int where,int numPages,double height,double width,int orient,const QString & siz,bool mov,QStringList * basedOn,bool overrideMasterPageSizing)5168 void ScribusMainWindow::addNewPages(int wo, int where, int numPages, double height, double width, int orient, const QString& siz, bool mov, QStringList* basedOn, bool overrideMasterPageSizing)
5169 {
5170 UndoTransaction activeTransaction;
5171 if (UndoManager::undoEnabled())
5172 {
5173 activeTransaction = m_undoManager->beginTransaction(doc->getUName(), Um::IDocument, (numPages == 1) ? Um::AddPage : Um::AddPages, QString(), Um::ICreate);
5174 SimpleState *ss = new SimpleState(Um::AddPage, QString(), Um::ICreate);
5175 ss->set("ADD_PAGE");
5176 ss->set("PAGE", wo);
5177 ss->set("WHERE", where);
5178 ss->set("COUNT", numPages);
5179 ss->set("MASTER_PAGE_MODE", doc->masterPageMode());
5180 if (basedOn != nullptr)
5181 ss->set("BASED", basedOn->join("|"));
5182 else
5183 {
5184 int setcol = doc->pageSets()[doc->pagePositioning()].Columns;
5185 if (setcol == 1)
5186 ss->set("BASED", CommonStrings::trMasterPageNormal);
5187 else if (setcol == 2)
5188 ss->set("BASED", CommonStrings::trMasterPageNormalLeft+"|"+ CommonStrings::trMasterPageNormalRight);
5189 else if ((setcol == 3) || (setcol == 4))
5190 ss->set("BASED", CommonStrings::trMasterPageNormalLeft+"|"+ CommonStrings::trMasterPageNormalMiddle+"|"+ CommonStrings::trMasterPageNormalRight);
5191 }
5192 ss->set("HEIGHT", height);
5193 ss->set("WIDTH", width);
5194 ss->set("ORIENT", orient);
5195 ss->set("SIZE", siz);
5196 ss->set("MOVED", mov);
5197 m_undoManager->action(this, ss);
5198 }
5199 // disable recording of undo actions related to new page creating
5200 // and object moving related to that
5201 m_undoManager->setUndoEnabled(false);
5202
5203 QStringList base;
5204 if (basedOn != nullptr)
5205 {
5206 base = *basedOn;
5207 // #10211 case when restoring page deletion, basedOn contains only masterpage name
5208 if (base.count() == 1)
5209 {
5210 int setcol = doc->pageSets()[doc->pagePositioning()].Columns;
5211 while (base.count() < setcol)
5212 base.append (base.at(0));
5213 }
5214 }
5215 if (base.empty())
5216 {
5217 int setcol = doc->pageSets()[doc->pagePositioning()].Columns;
5218 if (setcol == 1)
5219 base.append( CommonStrings::trMasterPageNormal);
5220 else if (setcol == 2)
5221 {
5222 base.append( CommonStrings::trMasterPageNormalLeft);
5223 base.append( CommonStrings::trMasterPageNormalRight);
5224 }
5225 else if (setcol == 3)
5226 {
5227 base.append( CommonStrings::trMasterPageNormalLeft);
5228 base.append( CommonStrings::trMasterPageNormalMiddle);
5229 base.append( CommonStrings::trMasterPageNormalRight);
5230 }
5231 else if (setcol == 4)
5232 {
5233 base.append( CommonStrings::trMasterPageNormalLeft);
5234 base.append( CommonStrings::trMasterPageNormalMiddle);
5235 base.append( CommonStrings::trMasterPageNormalMiddle);
5236 base.append( CommonStrings::trMasterPageNormalRight);
5237 }
5238 }
5239
5240 int wot = wo;
5241 if (where == 0)
5242 --wot;
5243 else if (where == 2)
5244 wot = doc->Pages->count();
5245
5246 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
5247 view->updatesOn(false);
5248 const PageSet& pageSet = doc->pageSets()[doc->pagePositioning()];
5249 ScPage* currentPage = doc->currentPage();
5250 for (int i = 0; i < numPages; ++i)
5251 {
5252 slotNewPage(wot, base[(wot + pageSet.FirstPage) % pageSet.Columns], mov); //Avoid the master page application with QString()
5253 // slotNewPage(wot, QString(), mov); //Avoid the master page application with QString()
5254 //CB: #8212: added overrideMasterPageSizing, but keeping default to true for other calls for now, off for calls from InsPage
5255 if (overrideMasterPageSizing)
5256 {
5257 doc->currentPage()->setInitialHeight(height);
5258 doc->currentPage()->setInitialWidth(width);
5259 doc->currentPage()->setOrientation(orient);
5260 doc->currentPage()->setSize(siz);
5261 }
5262 //CB If we want to add this master page setting into the slotnewpage call, the pagenumber must be +1 I think
5263 //Apply_MasterPage(base[(doc->currentPage()->pageNr()+doc->pageSets[doc->currentPageLayout].FirstPage) % doc->pageSets[doc->currentPageLayout].Columns],
5264 // doc->currentPage()->pageNr(), false); // this Apply_MasterPage avoids DreawNew and PagePalette->ReBuild, which is much faster for 100 pp :-)
5265 ++wot;
5266 }
5267 doc->setCurrentPage(currentPage);
5268 view->updatesOn(true);
5269 qApp->restoreOverrideCursor();
5270 //Use wo, the dialog currently returns a page Index +1 due to old numbering scheme, function now does the -1 as required
5271 doc->changed();
5272 doc->addPageToAnnotLinks(wot, where, numPages);
5273 doc->addPageToSection(wo, where, numPages);
5274 doc->reformPages();
5275 doc->updateEndnotesFrames();
5276 updateGUIAfterPagesChanged();
5277
5278 m_undoManager->setUndoEnabled(true);
5279
5280 if (activeTransaction)
5281 activeTransaction.commit();
5282 }
5283
slotNewMasterPage(int w,const QString & name)5284 void ScribusMainWindow::slotNewMasterPage(int w, const QString& name)
5285 {
5286 if (doc->masterPageMode())
5287 {
5288 doc->addMasterPage(w, name);
5289 view->addPage(w);
5290 }
5291 }
5292
slotNewPage(int w,const QString & masterPageName,bool mov)5293 void ScribusMainWindow::slotNewPage(int w, const QString& masterPageName, bool mov)
5294 {
5295 doc->addPage(w, masterPageName, true);
5296 view->addPage(w, mov);
5297 slotSetCurrentPage(w);
5298 }
5299
5300
duplicateToMasterPage()5301 void ScribusMainWindow::duplicateToMasterPage()
5302 {
5303 if (!HaveDoc)
5304 return;
5305 view->deselectItems(true);
5306 int pageLocationIndex = -1;
5307 int pageLocationCount = 0;
5308 if (doc->pagePositioning() != singlePage)
5309 {
5310 QStringList locationEntries;
5311 QList<PageSet> pageSet(doc->pageSets());
5312 QStringList pageNames = pageSet[doc->pagePositioning()].pageNames;
5313 for (auto pNames = pageNames.cbegin(); pNames != pageNames.cend(); ++pNames)
5314 {
5315 locationEntries << CommonStrings::translatePageSetLocString(*pNames);
5316 }
5317 pageLocationIndex = doc->columnOfPage(doc->currentPageNumber());
5318 pageLocationCount = locationEntries.count();
5319 }
5320
5321 CopyPageToMasterPageDialog copyDialog(doc->MasterNames.count(), doc->pageSets()[doc->pagePositioning()].pageNames, pageLocationIndex, this);
5322 if (copyDialog.exec())
5323 {
5324 bool copyFromMaster=false;
5325 QString masterPageName;
5326 int pageLocation = 0;
5327 copyDialog.values(masterPageName, copyFromMaster, pageLocation);
5328 bool badMasterPageName = doc->MasterNames.contains(masterPageName);
5329 badMasterPageName |= (masterPageName == CommonStrings::masterPageNormal);
5330 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormal);
5331 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalLeft);
5332 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalMiddle);
5333 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalRight);
5334 badMasterPageName |= masterPageName.isEmpty();
5335 while (badMasterPageName)
5336 {
5337 if (!copyDialog.exec())
5338 return;
5339 copyDialog.values(masterPageName, copyFromMaster, pageLocation);
5340 badMasterPageName = doc->MasterNames.contains(masterPageName);
5341 badMasterPageName |= (masterPageName == CommonStrings::masterPageNormal);
5342 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormal);
5343 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalLeft);
5344 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalMiddle);
5345 badMasterPageName |= (masterPageName == CommonStrings::trMasterPageNormalRight);
5346 badMasterPageName |= masterPageName.isEmpty();
5347 }
5348 int currentPageNumber = doc->currentPage()->pageNr();
5349 bool ok = doc->copyPageToMasterPage(currentPageNumber, pageLocation, pageLocationCount, masterPageName, copyFromMaster);
5350 Q_ASSERT(ok); //TODO get a return value in case the copy was not possible
5351 pagePalette->rebuild();
5352 }
5353 }
5354
slotZoom(double zoomFactor)5355 void ScribusMainWindow::slotZoom(double zoomFactor)
5356 {
5357 double finalZoomFactor=0.0;
5358 //Zoom to Fit
5359 if (zoomFactor == -100.0)
5360 {
5361 finalZoomFactor = (view->height()-70) / (doc->currentPage()->height()+30);
5362 }
5363 else if (zoomFactor == -200.0)
5364 {
5365 finalZoomFactor = (view->width()-50) / (doc->currentPage()->width()+30);
5366 }
5367 //Zoom to %
5368 else
5369 finalZoomFactor = zoomFactor*m_prefsManager.displayScale()/100.0;
5370
5371 if (finalZoomFactor == view->scale())
5372 return;
5373
5374 int x = qRound(qMax(view->contentsX() / view->scale(), 0.0));
5375 int y = qRound(qMax(view->contentsY() / view->scale(), 0.0));
5376 int w = qRound(qMin(view->visibleWidth() / view->scale(), doc->currentPage()->width()));
5377 int h = qRound(qMin(view->visibleHeight() / view->scale(), doc->currentPage()->height()));
5378
5379 if (zoomFactor == -200.0)
5380 view->rememberOldZoomLocation(qRound(doc->currentPage()->xOffset() + doc->currentPage()->width() / 2.0), h / 2 + y);
5381 else if (zoomFactor == -100.0)
5382 view->rememberOldZoomLocation(w / 2 + x, qRound(doc->currentPage()->yOffset() + doc->currentPage()->height() / 2.0));
5383 else
5384 view->rememberOldZoomLocation(w / 2 + x, h / 2 + y);
5385
5386 view->zoom(finalZoomFactor);
5387 }
5388
ToggleStickyTools()5389 void ScribusMainWindow::ToggleStickyTools()
5390 {
5391 m_prefsManager.appPrefs.uiPrefs.stickyTools = !m_prefsManager.appPrefs.uiPrefs.stickyTools;
5392 scrActions["stickyTools"]->setChecked(m_prefsManager.appPrefs.uiPrefs.stickyTools);
5393 if (HaveDoc && doc->appMode!=modeNormal && !m_prefsManager.appPrefs.uiPrefs.stickyTools)
5394 view->requestMode(modeNormal);
5395 }
5396
ToggleAllPalettes()5397 void ScribusMainWindow::ToggleAllPalettes()
5398 {
5399 if (m_palettesStatus[PAL_ALL])
5400 {
5401 m_palettesStatus[PAL_ALL] = false;
5402 if (m_palettesStatus[PAL_PROPERTIES])
5403 propertiesPalette->show();
5404 if (m_palettesStatus[PAL_CONTENT])
5405 contentPalette->show();
5406 if (m_palettesStatus[PAL_OUTLINE])
5407 outlinePalette->show();
5408 if (m_palettesStatus[PAL_SCRAPBOOK])
5409 scrapbookPalette->show();
5410 if (m_palettesStatus[PAL_LAYER])
5411 layerPalette->show();
5412 if (m_palettesStatus[PAL_PAGE])
5413 pagePalette->show();
5414 if (m_palettesStatus[PAL_BOOKMARK])
5415 bookmarkPalette->show();
5416 if (m_palettesStatus[PAL_VERIFIER])
5417 docCheckerPalette->show();
5418 if (m_palettesStatus[PAL_DOWNLOADS])
5419 downloadsPalette->show();
5420 setUndoPalette(m_palettesStatus[PAL_UNDO]);
5421 }
5422 else
5423 {
5424 m_palettesStatus[PAL_PROPERTIES] = propertiesPalette->isVisible();
5425 m_palettesStatus[PAL_CONTENT] = contentPalette->isVisible();
5426 m_palettesStatus[PAL_OUTLINE] = outlinePalette->isVisible();
5427 m_palettesStatus[PAL_SCRAPBOOK] = scrapbookPalette->isVisible();
5428 m_palettesStatus[PAL_LAYER] = layerPalette->isVisible();
5429 m_palettesStatus[PAL_PAGE] = pagePalette->isVisible();
5430 m_palettesStatus[PAL_BOOKMARK] = bookmarkPalette->isVisible();
5431 m_palettesStatus[PAL_UNDO] = undoPalette->isVisible();
5432 m_palettesStatus[PAL_VERIFIER] = docCheckerPalette->isVisible();
5433 m_palettesStatus[PAL_DOWNLOADS] = downloadsPalette->isVisible();
5434 propertiesPalette->hide();
5435 contentPalette->hide();
5436 outlinePalette->hide();
5437 scrapbookPalette->hide();
5438 bookmarkPalette->hide();
5439 pagePalette->hide();
5440 layerPalette->hide();
5441 docCheckerPalette->hide();
5442 downloadsPalette->hide();
5443 setUndoPalette(false);
5444 m_palettesStatus[PAL_ALL] = true;
5445 }
5446 }
5447
toggleCheckPal()5448 void ScribusMainWindow::toggleCheckPal()
5449 {
5450 m_palettesStatus[PAL_ALL] = false;
5451 }
5452
setUndoPalette(bool visible)5453 void ScribusMainWindow::setUndoPalette(bool visible)
5454 {
5455 undoPalette->setPaletteShown(visible);
5456 scrActions["toolsActionHistory"]->setChecked(visible);
5457 }
5458
togglePagePalette()5459 void ScribusMainWindow::togglePagePalette()
5460 {
5461 m_palettesStatus[PAL_ALL] = false;
5462 }
5463
toggleUndoPalette()5464 void ScribusMainWindow::toggleUndoPalette()
5465 {
5466 setUndoPalette(!undoPalette->isVisible());
5467 m_palettesStatus[PAL_ALL] = false;
5468 }
5469
toggleImageVisibility()5470 void ScribusMainWindow::toggleImageVisibility()
5471 {
5472 if (!doc)
5473 return;
5474 doc->guidesPrefs().showPic = !doc->guidesPrefs().showPic;
5475 QList<PageItem*> allItems;
5476 for (int i = 0; i < doc->DocItems.count(); ++i)
5477 {
5478 PageItem *currItem = doc->DocItems.at(i);
5479 if (currItem->isGroup())
5480 allItems = currItem->getAllChildren();
5481 else
5482 allItems.append(currItem);
5483 for (int j = 0; j < allItems.count(); j++)
5484 {
5485 PageItem* item = allItems.at(j);
5486 if (item->isImageFrame())
5487 item->setImageVisible(doc->guidesPrefs().showPic);
5488 }
5489 }
5490 for (int i=0; i<doc->MasterItems.count(); ++i)
5491 {
5492 PageItem *currItem = doc->MasterItems.at(i);
5493 if (currItem->isGroup())
5494 allItems = currItem->getAllChildren();
5495 else
5496 allItems.append(currItem);
5497 for (int j = 0; j < allItems.count(); j++)
5498 {
5499 PageItem* item = allItems.at(j);
5500 if (item->isImageFrame())
5501 item->setImageVisible(doc->guidesPrefs().showPic);
5502 }
5503 }
5504 view->DrawNew();
5505 }
5506
ToggleAllGuides()5507 void ScribusMainWindow::ToggleAllGuides()
5508 {
5509 if (!doc)
5510 return;
5511 //m_keyrep=false;
5512 if (m_guidesStatus[GS_ALL])
5513 {
5514 m_guidesStatus[GS_ALL] = false;
5515 doc->guidesPrefs().marginsShown = m_guidesStatus[GS_MARGINS];
5516 doc->guidesPrefs().framesShown = m_guidesStatus[GS_FRAMES];
5517 doc->guidesPrefs().gridShown = m_guidesStatus[GS_GRID];
5518 doc->guidesPrefs().guidesShown = m_guidesStatus[GS_GUIDES];
5519 doc->guidesPrefs().baselineGridShown = m_guidesStatus[GS_BASELINE];
5520 doc->guidesPrefs().linkShown = m_guidesStatus[GS_LINKS];
5521 doc->guidesPrefs().showControls = m_guidesStatus[GS_CONTROLS];
5522 doc->guidesPrefs().rulerMode = m_guidesStatus[GS_RULERMODE];
5523 doc->guidesPrefs().rulersShown = m_guidesStatus[GS_RULERS];
5524 doc->guidesPrefs().colBordersShown = m_guidesStatus[GS_COLUMNBORDERS];
5525 doc->guidesPrefs().layerMarkersShown = m_guidesStatus[GS_LAYERMARKERS] ;
5526 doc->guidesPrefs().showBleed = m_guidesStatus[GS_BLEED];
5527 toggleMarks();
5528 toggleFrames();
5529 toggleLayerMarkers();
5530 toggleGrid();
5531 toggleGuides();
5532 toggleColumnBorders();
5533 toggleBase();
5534 toggleTextLinks();
5535 toggleTextControls();
5536 toggleRulerMode();
5537 toggleRulers();
5538 toggleBleeds();
5539 }
5540 else
5541 {
5542 m_guidesStatus[GS_ALL] = true;
5543 m_guidesStatus[GS_MARGINS] = !doc->guidesPrefs().marginsShown;
5544 m_guidesStatus[GS_FRAMES] = !doc->guidesPrefs().framesShown;
5545 m_guidesStatus[GS_GRID] = !doc->guidesPrefs().gridShown;
5546 m_guidesStatus[GS_GUIDES] = !doc->guidesPrefs().guidesShown;
5547 m_guidesStatus[GS_BASELINE] = !doc->guidesPrefs().baselineGridShown;
5548 m_guidesStatus[GS_LINKS] = !doc->guidesPrefs().linkShown;
5549 m_guidesStatus[GS_CONTROLS] = !doc->guidesPrefs().showControls;
5550 m_guidesStatus[GS_RULERMODE] = !doc->guidesPrefs().rulerMode;
5551 m_guidesStatus[GS_RULERS] = !doc->guidesPrefs().rulersShown;
5552 m_guidesStatus[GS_COLUMNBORDERS] = !doc->guidesPrefs().colBordersShown;
5553 m_guidesStatus[GS_LAYERMARKERS] = !doc->guidesPrefs().layerMarkersShown;
5554 m_guidesStatus[GS_BLEED] = !doc->guidesPrefs().showBleed;
5555 doc->guidesPrefs().marginsShown = false;
5556 doc->guidesPrefs().framesShown = false;
5557 doc->guidesPrefs().gridShown = false;
5558 doc->guidesPrefs().guidesShown = false;
5559 doc->guidesPrefs().baselineGridShown = false;
5560 doc->guidesPrefs().linkShown = false;
5561 doc->guidesPrefs().showControls = false;
5562 doc->guidesPrefs().rulerMode = false;
5563 doc->guidesPrefs().rulersShown = false;
5564 doc->guidesPrefs().colBordersShown = false;
5565 doc->guidesPrefs().layerMarkersShown = false;
5566 doc->guidesPrefs().showBleed = false;
5567 view->setRulersShown(doc->guidesPrefs().rulersShown);
5568 }
5569 scrActions["viewShowMargins"]->setChecked(doc->guidesPrefs().marginsShown);
5570 scrActions["viewShowBleeds"]->setChecked(doc->guidesPrefs().showBleed);
5571 scrActions["viewShowFrames"]->setChecked(doc->guidesPrefs().framesShown);
5572 scrActions["viewShowLayerMarkers"]->setChecked(doc->guidesPrefs().layerMarkersShown);
5573 scrActions["viewShowGrid"]->setChecked(doc->guidesPrefs().gridShown);
5574 scrActions["viewShowGuides"]->setChecked(doc->guidesPrefs().guidesShown);
5575 scrActions["viewShowColumnBorders"]->setChecked(doc->guidesPrefs().colBordersShown);
5576 scrActions["viewShowBaseline"]->setChecked(doc->guidesPrefs().baselineGridShown);
5577 scrActions["viewShowTextChain"]->setChecked(doc->guidesPrefs().linkShown);
5578 scrActions["viewShowTextControls"]->setChecked(doc->guidesPrefs().showControls);
5579 scrActions["viewShowRulers"]->setChecked(doc->guidesPrefs().rulersShown);
5580 scrActions["viewRulerMode"]->setChecked(doc->guidesPrefs().rulerMode);
5581 view->DrawNew();
5582 }
5583
toggleMarks()5584 void ScribusMainWindow::toggleMarks()
5585 {
5586 if (!doc)
5587 return;
5588 m_guidesStatus[GS_ALL] = false;
5589 doc->guidesPrefs().marginsShown = !doc->guidesPrefs().marginsShown;
5590 view->DrawNew();
5591 }
5592
toggleBleeds()5593 void ScribusMainWindow::toggleBleeds()
5594 {
5595 if (!doc)
5596 return;
5597 m_guidesStatus[GS_ALL] = false;
5598 doc->guidesPrefs().showBleed = !doc->guidesPrefs().showBleed;
5599 view->DrawNew();
5600 }
5601
toggleFrames()5602 void ScribusMainWindow::toggleFrames()
5603 {
5604 if (!doc)
5605 return;
5606 m_guidesStatus[GS_ALL] = false;
5607 doc->guidesPrefs().framesShown = !doc->guidesPrefs().framesShown;
5608 view->DrawNew();
5609 }
5610
toggleLayerMarkers()5611 void ScribusMainWindow::toggleLayerMarkers()
5612 {
5613 if (!doc)
5614 return;
5615 m_guidesStatus[GS_ALL] = false;
5616 doc->guidesPrefs().layerMarkersShown = !doc->guidesPrefs().layerMarkersShown;
5617 view->DrawNew();
5618 }
5619
toggleGrid()5620 void ScribusMainWindow::toggleGrid()
5621 {
5622 if (!doc)
5623 return;
5624 m_guidesStatus[GS_ALL] = false;
5625 doc->guidesPrefs().gridShown = !doc->guidesPrefs().gridShown;
5626 view->DrawNew();
5627 }
5628
toggleGuides()5629 void ScribusMainWindow::toggleGuides()
5630 {
5631 if (!doc)
5632 return;
5633 m_guidesStatus[GS_ALL] = false;
5634 doc->guidesPrefs().guidesShown = !doc->guidesPrefs().guidesShown;
5635 view->DrawNew();
5636 }
5637
toggleColumnBorders()5638 void ScribusMainWindow::toggleColumnBorders()
5639 {
5640 if (!doc)
5641 return;
5642 m_guidesStatus[GS_ALL] = false;
5643 doc->guidesPrefs().colBordersShown = !doc->guidesPrefs().colBordersShown;
5644 view->DrawNew();
5645 }
5646
toggleBase()5647 void ScribusMainWindow::toggleBase()
5648 {
5649 if (!doc)
5650 return;
5651 m_guidesStatus[GS_ALL] = false;
5652 doc->guidesPrefs().baselineGridShown = !doc->guidesPrefs().baselineGridShown;
5653 view->DrawNew();
5654 }
5655
toggleTextLinks()5656 void ScribusMainWindow::toggleTextLinks()
5657 {
5658 if (!doc)
5659 return;
5660 m_guidesStatus[GS_ALL] = false;
5661 doc->guidesPrefs().linkShown = !doc->guidesPrefs().linkShown;
5662 view->DrawNew();
5663 }
5664
toggleTextControls()5665 void ScribusMainWindow::toggleTextControls()
5666 {
5667 if (!doc)
5668 return;
5669 m_guidesStatus[GS_ALL] = false;
5670 doc->guidesPrefs().showControls = !doc->guidesPrefs().showControls;
5671 view->DrawNew();
5672 }
5673
toggleRulers()5674 void ScribusMainWindow::toggleRulers()
5675 {
5676 if (!doc)
5677 return;
5678 m_guidesStatus[GS_ALL] = false;
5679 doc->guidesPrefs().rulersShown = !doc->guidesPrefs().rulersShown;
5680 view->setRulersShown(doc->guidesPrefs().rulersShown);
5681 }
5682
toggleRulerMode()5683 void ScribusMainWindow::toggleRulerMode()
5684 {
5685 if (!doc)
5686 return;
5687 m_guidesStatus[GS_ALL] = false;
5688 doc->guidesPrefs().rulerMode = !doc->guidesPrefs().rulerMode;
5689 if (doc->guidesPrefs().rulerMode)
5690 {
5691 doc->rulerXoffset = 0;
5692 doc->rulerYoffset = 0;
5693 }
5694 else
5695 {
5696 doc->rulerXoffset += doc->currentPage()->xOffset();
5697 doc->rulerYoffset += doc->currentPage()->yOffset();
5698 }
5699 if (doc->m_Selection->count()==1)
5700 {
5701 PageItem* currItem = doc->m_Selection->itemAt(0);
5702 if (currItem != nullptr)
5703 currItem->emitAllToGUI();
5704 }
5705 //TODO emit from selection, handle group widths
5706 guidePalette->setupPage();
5707 view->DrawNew();
5708 }
5709
toggleSnapGrid()5710 void ScribusMainWindow::toggleSnapGrid()
5711 {
5712 if (!doc)
5713 return;
5714 doc->SnapGrid = !doc->SnapGrid;
5715 slotDocCh();
5716 }
5717
toggleSnapGuides()5718 void ScribusMainWindow::toggleSnapGuides()
5719 {
5720 if (!doc)
5721 return;
5722 doc->SnapGuides = !doc->SnapGuides;
5723 slotDocCh();
5724 }
5725
toggleSnapElements()5726 void ScribusMainWindow::toggleSnapElements()
5727 {
5728 if (!doc)
5729 return;
5730 doc->SnapElement = !doc->SnapElement;
5731 slotDocCh();
5732 }
5733
SetSnapElements(bool b)5734 void ScribusMainWindow::SetSnapElements(bool b)
5735 {
5736 if (doc && doc->SnapElement != b)
5737 toggleSnapElements();
5738 }
5739
5740
toggleNodeEdit()5741 void ScribusMainWindow::toggleNodeEdit()
5742 {
5743 if (!doc)
5744 return;
5745 int i = modeEditClip;
5746 if (doc->appMode == modeEditClip)
5747 i = submodeEndNodeEdit;
5748 view->requestMode(i);
5749 }
5750
enablePalettes(bool b)5751 void ScribusMainWindow::enablePalettes(bool b)
5752 {
5753 if (doc->appMode == modeEdit) //Keep Palettes enabled when editing text
5754 return;
5755 layerPalette->setEnabled(b);
5756 outlinePalette->setEnabled(b);
5757 guidePalette->setEnabled(b);
5758 scrapbookPalette->setEnabled(b);
5759 pagePalette->setEnabled(b);
5760 bookmarkPalette->setEnabled(b);
5761 docCheckerPalette->setEnabled(b);
5762 inlinePalette->setEnabled(b);
5763 symbolPalette->setEnabled(b);
5764 alignDistributePalette->setEnabled(b);
5765 downloadsPalette->setEnabled(b);
5766 }
5767
ToggleFrameEdit()5768 void ScribusMainWindow::ToggleFrameEdit()
5769 {
5770 if (!doc)
5771 return;
5772
5773 nodePalette->setDoc(doc, view);
5774 nodePalette->MoveN();
5775 nodePalette->HaveNode(false, false);
5776 nodePalette->MoveNode->setChecked(true);
5777 nodePalette->show();
5778 // qDebug() << "nodepalette show:" << nodePalette->geometry();
5779 connect(view, SIGNAL(HavePoint(bool,bool)), nodePalette, SLOT(HaveNode(bool,bool)));
5780 connect(view, SIGNAL(PolyStatus(int,uint)), nodePalette, SLOT(PolyStatus(int,uint)));
5781 doc->nodeEdit.reset();
5782 appModeHelper->setFrameEditMode(true);
5783 enablePalettes(false);
5784 m_styleManager->setEnabled(false);
5785 pageSelector->setEnabled(false);
5786 layerMenu->setEnabled(false);
5787 if (!doc->m_Selection->isEmpty())
5788 {
5789 PageItem *currItem = doc->m_Selection->itemAt(0);
5790 nodePalette->EditCont->setEnabled(!currItem->ContourLine.empty());
5791 nodePalette->ResetCont->setEnabled(false);
5792 nodePalette->ResetContClip->setEnabled(false);
5793 nodePalette->PolyStatus(currItem->itemType(), currItem->PoLine.size());
5794 nodePalette->setDefaults(currItem);
5795 if ((currItem->isImageFrame()) && (!currItem->imageClip.empty()))
5796 {
5797 nodePalette->ResetContClip->setSizePolicy(QSizePolicy(static_cast<QSizePolicy::Policy>(3), static_cast<QSizePolicy::Policy>(3)));
5798 nodePalette->ResetContClip->show();
5799 nodePalette->ResetShape2Clip->setSizePolicy(QSizePolicy(static_cast<QSizePolicy::Policy>(3), static_cast<QSizePolicy::Policy>(3)));
5800 nodePalette->ResetShape2Clip->show();
5801 nodePalette->layout()->activate();
5802 nodePalette->resize(QSize(170, 380).expandedTo(nodePalette->minimumSizeHint()));
5803 }
5804 else
5805 {
5806 nodePalette->ResetContClip->setSizePolicy(QSizePolicy(static_cast<QSizePolicy::Policy>(6), static_cast<QSizePolicy::Policy>(6)));
5807 nodePalette->ResetShape2Clip->setSizePolicy(QSizePolicy(static_cast<QSizePolicy::Policy>(6), static_cast<QSizePolicy::Policy>(6)));
5808 nodePalette->layout()->activate();
5809 nodePalette->ResetContClip->hide();
5810 nodePalette->ResetShape2Clip->hide();
5811 nodePalette->layout()->activate();
5812 nodePalette->resize(QSize(170, 380).expandedTo(nodePalette->minimumSizeHint()));
5813 }
5814 }
5815 }
5816
NoFrameEdit()5817 void ScribusMainWindow::NoFrameEdit()
5818 {
5819 disconnect(view, SIGNAL(HavePoint(bool, bool)), nodePalette, SLOT(HaveNode(bool, bool)));
5820 disconnect(view, SIGNAL(PolyStatus(int, uint)), nodePalette, SLOT(PolyStatus(int, uint)));
5821 actionManager->disconnectModeActions();
5822 nodePalette->setDoc(nullptr, nullptr);
5823 nodePalette->hide();
5824 appModeHelper->setFrameEditMode(false);
5825 scrActions["toolsSelect"]->setChecked(true);
5826 scrActions["toolsEditContents"]->setChecked(false);
5827 scrActions["toolsEditWithStoryEditor"]->setChecked(false);
5828 enablePalettes(true);
5829 m_styleManager->setEnabled(true);
5830 pageSelector->setEnabled(true);
5831 layerMenu->setEnabled(true);
5832 if (HaveDoc)
5833 {
5834 doc->nodeEdit.reset();
5835 HaveNewSel();
5836 if (!doc->m_Selection->isEmpty())
5837 {
5838 doc->m_Selection->itemAt(0)->emitAllToGUI();
5839 view->DrawNew();
5840 }
5841 }
5842 actionManager->connectModeActions();
5843 }
5844
5845 /** This is the safest method to return to modeNormal
5846 */
slotSelect()5847 void ScribusMainWindow::slotSelect()
5848 {
5849 if (doc)
5850 view->requestMode(modeNormal);
5851 else
5852 appModeHelper->resetApplicationMode(modeNormal);
5853 }
5854
setAppModeByToggle(bool isOn,int newMode)5855 void ScribusMainWindow::setAppModeByToggle(bool isOn, int newMode)
5856 {
5857 //m_keyrep=false;
5858
5859 if (newMode==modeDrawLatex && !m_prefsManager.renderFrameConfigured())
5860 {
5861 ScMessageBox::critical(this, "Render Frames Not Configured", "Your Render Frame configuration seems to be invalid. Please check the settings in the External Tools section of the Preferences dialog.");
5862 return;
5863 }
5864
5865 if (doc && isOn)
5866 view->requestMode(newMode);
5867 else
5868 slotSelect();
5869 }
5870
setMainWindowActive()5871 void ScribusMainWindow::setMainWindowActive()
5872 {
5873 activateWindow();
5874 if (!scriptIsRunning())
5875 raise();
5876 }
5877
setItemTypeStyle(int id)5878 void ScribusMainWindow::setItemTypeStyle(int id)
5879 {
5880 int b = 0;
5881 if (id == 0)
5882 {
5883 scrActions["typeEffectNormal"]->setChecked(true);
5884 scrActions["typeEffectUnderline"]->setChecked(false);
5885 scrActions["typeEffectUnderlineWords"]->setChecked(false);
5886 scrActions["typeEffectStrikeThrough"]->setChecked(false);
5887 scrActions["typeEffectSmallCaps"]->setChecked(false);
5888 scrActions["typeEffectAllCaps"]->setChecked(false);
5889 scrActions["typeEffectSuperscript"]->setChecked(false);
5890 scrActions["typeEffectSubscript"]->setChecked(false);
5891 scrActions["typeEffectOutline"]->setChecked(false);
5892 scrActions["typeEffectShadow"]->setChecked(false);
5893 }
5894 else
5895 {
5896 scrActions["typeEffectNormal"]->setChecked(false);
5897 if (id == 4)
5898 scrActions["typeEffectSubscript"]->setChecked(false);
5899 if (id == 5)
5900 scrActions["typeEffectSuperscript"]->setChecked(false);
5901 if (id == 3)
5902 scrActions["typeEffectAllCaps"]->setChecked(false);
5903 if (id == 7)
5904 scrActions["typeEffectSmallCaps"]->setChecked(false);
5905 if (id == 8)
5906 scrActions["typeEffectUnderline"]->setChecked(false);
5907 if (id == 1)
5908 scrActions["typeEffectUnderlineWords"]->setChecked(false);
5909 if (scrActions["typeEffectUnderline"]->isChecked())
5910 b |= 8;
5911 if (scrActions["typeEffectUnderlineWords"]->isChecked())
5912 b |= 512;
5913 if (scrActions["typeEffectShadow"]->isChecked())
5914 b |= 256;
5915 if (scrActions["typeEffectStrikeThrough"]->isChecked())
5916 b |= 16;
5917 if (scrActions["typeEffectAllCaps"]->isChecked())
5918 b |= 32;
5919 if (scrActions["typeEffectSmallCaps"]->isChecked())
5920 b |= 64;
5921 if (scrActions["typeEffectSuperscript"]->isChecked())
5922 b |= 1;
5923 if (scrActions["typeEffectSubscript"]->isChecked())
5924 b |= 2;
5925 if (scrActions["typeEffectOutline"]->isChecked())
5926 b |= 4;
5927 }
5928 setItemEffects(b);
5929 }
5930
setStyleEffects(int s)5931 void ScribusMainWindow::setStyleEffects(int s)
5932 {
5933 int i = s & 1919;
5934 scrActions["typeEffectNormal"]->setChecked(i==0);
5935 scrActions["typeEffectSuperscript"]->setChecked(i & 1);
5936 scrActions["typeEffectSubscript"]->setChecked(i & 2);
5937 scrActions["typeEffectOutline"]->setChecked(i & 4);
5938 scrActions["typeEffectUnderline"]->setChecked(i & 8);
5939 scrActions["typeEffectStrikeThrough"]->setChecked(i & 16);
5940 scrActions["typeEffectAllCaps"]->setChecked(i & 32);
5941 scrActions["typeEffectSmallCaps"]->setChecked(i & 64);
5942 scrActions["typeEffectShadow"]->setChecked(i & 256);
5943 scrActions["typeEffectUnderlineWords"]->setChecked(i & 512);
5944 emit TextEffects(s);
5945 }
5946
setItemEffects(int h)5947 void ScribusMainWindow::setItemEffects(int h)
5948 {
5949 if (doc->m_Selection->isEmpty())
5950 return;
5951 setStyleEffects(h);
5952 doc->itemSelection_SetEffects(h);
5953 }
5954
5955 //CB-->Doc partly
deletePage2(int pg)5956 void ScribusMainWindow::deletePage2(int pg)
5957 {
5958 if (HaveDoc && doc->appMode == modeEditClip)
5959 view->requestMode(submodeEndNodeEdit);
5960 view->deselectItems(true);
5961 if (doc->Pages->count() == 1)
5962 return;
5963 deletePage(pg + 1, pg + 1);
5964 }
5965
deletePage()5966 void ScribusMainWindow::deletePage()
5967 {
5968 if (HaveDoc && doc->appMode == modeEditClip)
5969 view->requestMode(submodeEndNodeEdit);
5970 view->deselectItems(true);
5971 DelPages *dia = new DelPages(this, doc->currentPage()->pageNr()+1, doc->Pages->count());
5972 if (dia->exec())
5973 deletePage(dia->getFromPage(), dia->getToPage());
5974 delete dia;
5975 }
5976
deletePage(int from,int to)5977 void ScribusMainWindow::deletePage(int from, int to)
5978 {
5979 UndoTransaction activeTransaction;
5980 assert( from > 0 );
5981 assert( from <= to );
5982 assert( to <= static_cast<int>(doc->Pages->count()) );
5983 int oldPg = doc->currentPageNumber();
5984 guidePalette->setDoc(nullptr);
5985 if (UndoManager::undoEnabled())
5986 activeTransaction = m_undoManager->beginTransaction(doc->documentFileName(), Um::IDocument,
5987 (from - to == 0) ? Um::DeletePage : Um::DeletePages, QString(),
5988 Um::IDelete);
5989 PageItem* ite;
5990 doc->m_Selection->clear();
5991 Selection tmpSelection(this, false);
5992 for (int a = to - 1; a >= from - 1; a--)
5993 {
5994 for (int d = 0; d < doc->Items->count(); ++d)
5995 {
5996 ite = doc->Items->at(d);
5997 //do not delete notes frames
5998 if (ite->isAutoNoteFrame())
5999 continue;
6000 if (ite->OwnPage == a)
6001 {
6002 ite->setLocked(false);
6003 ite->isSingleSel = false;
6004 if (ite->isBookmark)
6005 DelBookMark(ite);
6006 ite->isBookmark = false;
6007 tmpSelection.addItem(ite);
6008 }
6009 }
6010 ScPage *page = doc->Pages->at(a); // need to remove guides too to get their undo/redo actions working
6011 page->guides.clearHorizontals(GuideManagerCore::Standard);
6012 page->guides.clearHorizontals(GuideManagerCore::Auto);
6013 page->guides.clearVerticals(GuideManagerCore::Standard);
6014 page->guides.clearVerticals(GuideManagerCore::Auto);
6015 }
6016 if (tmpSelection.count() != 0)
6017 doc->itemSelection_DeleteItem(&tmpSelection);
6018 bool b = pageSelector->blockSignals(true);
6019 view->updatesOn(false);
6020 for (int a = to - 1; a >= from - 1; a--)
6021 {
6022 if (UndoManager::undoEnabled())
6023 {
6024 SimpleState *ss = new SimpleState(Um::DeletePage, QString(), Um::ICreate);
6025 ss->set("DELETE_PAGE");
6026 ss->set("PAGENR", a + 1);
6027 ss->set("PAGENAME", doc->Pages->at(a)->pageName());
6028 ss->set("MASTERPAGE", doc->Pages->at(a)->masterPageName());
6029 ss->set("MASTER_PAGE_MODE", doc->masterPageMode());
6030 // replace the deleted page in the undostack by a dummy object that will
6031 // replaced with the "undone" page if user choose to undo the action
6032 DummyUndoObject *duo = new DummyUndoObject();
6033 uint id = static_cast<uint>(duo->getUId());
6034 m_undoManager->replaceObject(doc->Pages->at(a)->getUId(), duo);
6035 ss->set("DUMMY_ID", id);
6036 m_undoManager->action(this, ss);
6037 }
6038 bool isMasterPage = !(doc->Pages->at(a)->pageNameEmpty());
6039 if (doc->masterPageMode())
6040 doc->deleteMasterPage(a);
6041 else
6042 doc->deletePage(a);
6043 if (!isMasterPage) // Master pages are not added to sections when created
6044 {
6045 doc->removePageFromAnnotLinks(a);
6046 doc->removePageFromSection(a);
6047 }
6048 }
6049 pageSelector->setMaximum(doc->Pages->count());
6050 pageSelector->blockSignals(b);
6051 m_undoManager->setUndoEnabled(false); // ugly hack to disable object moving when undoing page deletion
6052 view->reformPagesView();
6053 m_undoManager->setUndoEnabled(true); // ugly hack continues
6054 view->updatesOn(true);
6055 view->GotoPage(qMin(doc->Pages->count()-1, oldPg));
6056 doc->updateEndnotesFrames();
6057 updateGUIAfterPagesChanged();
6058 doc->rebuildMasterNames();
6059 pagePalette->rebuildMasters();
6060 if (activeTransaction)
6061 activeTransaction.commit();
6062 }
6063
movePage()6064 void ScribusMainWindow::movePage()
6065 {
6066 if (HaveDoc && doc->appMode == modeEditClip)
6067 view->requestMode(submodeEndNodeEdit);
6068 int currentPage = doc->currentPage()->pageNr();
6069 QScopedPointer<MovePages> dia(new MovePages(this, currentPage + 1, doc->Pages->count(), true));
6070 if (!dia->exec())
6071 return;
6072 int from = dia->getFromPage();
6073 int to = dia->getToPage();
6074 int wie = dia->getWhere();
6075 int wo = dia->getWherePage();
6076 if (wie == 3)
6077 {
6078 doc->swapPage(from-1, wo-1);
6079 updateGUIAfterPagesChanged();
6080 return;
6081 }
6082 if ((wie < 2) && (from <= wo) && (wo <= to))
6083 return;
6084 if (wie == 2 && to == signed(doc->Pages->count()))
6085 return;
6086 doc->movePage(from-1, to, wo-1, wie);
6087 updateGUIAfterPagesChanged();
6088 doc->updateEndnotesFrames();
6089 }
6090
copyPage()6091 void ScribusMainWindow::copyPage()
6092 {
6093 if (!HaveDoc)
6094 return;
6095 if (doc->appMode == modeEditClip)
6096 view->requestMode(submodeEndNodeEdit);
6097 QScopedPointer<MovePages> dia(new MovePages(this, doc->currentPage()->pageNr()+1, doc->Pages->count(), false));
6098 if (!dia->exec())
6099 return;
6100 int pageNumberToCopy=dia->getFromPage()-1;
6101 int whereToInsert=dia->getWhere();
6102 int copyCount=dia->getCopyCount();
6103 int wo = dia->getWherePage();
6104 doc->copyPage(pageNumberToCopy, wo, whereToInsert, copyCount);
6105 view->deselectItems(true);
6106 doc->updateEndnotesFrames();
6107 updateGUIAfterPagesChanged();
6108 slotDocCh();
6109 }
6110
changePageProperties()6111 void ScribusMainWindow::changePageProperties()
6112 {
6113 if (!HaveDoc)
6114 return;
6115 if (doc->appMode == modeEditClip)
6116 view->requestMode(submodeEndNodeEdit);
6117 QString currPageMasterPageName(doc->currentPage()->masterPageName());
6118 QScopedPointer<PagePropertiesDialog> dia(new PagePropertiesDialog(this, doc));
6119 if (!dia->exec())
6120 return;
6121
6122 int orientation = dia->getPageOrientation();
6123 double pageHeight = dia->getPageHeight();
6124 double pageWidth = dia->getPageWidth();
6125 QString pageSizeName = dia->getPrefsPageSizeName();
6126 int lp=0;
6127 if (doc->masterPageMode() && doc->pagePositioning() != singlePage)
6128 lp = dia->pageOrder();
6129 doc->changePageProperties(dia->top(), dia->bottom(), dia->left(), dia->right(),
6130 pageHeight, pageWidth, pageHeight, pageWidth, orientation,
6131 pageSizeName, dia->getMarginPreset(), dia->getMoveObjects(), doc->currentPage()->pageNr(), lp);
6132 if (!doc->masterPageMode() && dia->masterPage() != currPageMasterPageName)
6133 Apply_MasterPage(dia->masterPage(), doc->currentPage()->pageNr());
6134 doc->updateEndnotesFrames();
6135 }
6136
setItemFontSize(int fontSize)6137 void ScribusMainWindow::setItemFontSize(int fontSize)
6138 {
6139 int fs=fontSize;
6140 if (fs != -1)
6141 doc->itemSelection_SetFontSize(fs*10);
6142 else
6143 {
6144 bool ok = false;
6145 Query dia(this, "New", true, tr("&Size:"), tr("Size"));
6146 if (dia.exec())
6147 {
6148 fs = qRound(dia.getEditText().toDouble(&ok));
6149 if (ok && (fs < 1025) && (fs > 0))
6150 doc->itemSelection_SetFontSize(fs*10);
6151 }
6152 }
6153 contentPalette->updateTextFontSize(fs*10);
6154 }
6155
setItemLanguage(const QString & language)6156 void ScribusMainWindow::setItemLanguage(const QString& language)
6157 {
6158 Query dia(this, "New", true, tr("&Language:"), tr("Language"));
6159 if (dia.exec())
6160 doc->itemSelection_SetLanguage(language);
6161
6162 contentPalette->updateTextLanguage(language);
6163 }
6164
6165 //CB-->Doc
setNewAlignment(int i)6166 void ScribusMainWindow::setNewAlignment(int i)
6167 {
6168 if (!HaveDoc)
6169 return;
6170 doc->itemSelection_SetAlignment(i);
6171 contentPalette->updateTextAlignment(i);
6172 PageItem *currItem = doc->m_Selection->itemAt(0);
6173 setTBvals(currItem);
6174 }
6175
setNewDirection(int i)6176 void ScribusMainWindow::setNewDirection(int i)
6177 {
6178 if (!HaveDoc)
6179 return;
6180 doc->itemSelection_SetDirection(i);
6181 contentPalette->updateTextDirection(i);
6182 PageItem *currItem = doc->m_Selection->itemAt(0);
6183 setTBvals(currItem);
6184 }
6185
setNewParStyle(const QString & name)6186 void ScribusMainWindow::setNewParStyle(const QString& name)
6187 {
6188 if (!HaveDoc)
6189 return;
6190 doc->itemSelection_SetNamedParagraphStyle(name);
6191 PageItem *currItem = doc->m_Selection->itemAt(0);
6192 setTBvals(currItem);
6193 }
6194
setNewCharStyle(const QString & name)6195 void ScribusMainWindow::setNewCharStyle(const QString& name)
6196 {
6197 if (!HaveDoc)
6198 return;
6199 doc->itemSelection_SetNamedCharStyle(name);
6200 PageItem *currItem = doc->m_Selection->itemAt(0);
6201 setTBvals(currItem);
6202 }
6203
setAlignmentValue(int i)6204 void ScribusMainWindow::setAlignmentValue(int i)
6205 {
6206 contentPalette->updateTextAlignment(i);
6207 QString alignment[] = {"Left", "Center", "Right", "Block", "Forced"};
6208 for (int j=0; j<5; ++j)
6209 {
6210 QString actionName="align"+alignment[j];
6211 if (scrActions[actionName])
6212 scrActions[actionName]->setChecked(i==j);
6213 }
6214 }
6215
setDirectionValue(int i)6216 void ScribusMainWindow::setDirectionValue(int i)
6217 {
6218 contentPalette->updateTextDirection(i);
6219 QString direction[] = {"Left", "Right"};
6220 for (int j=0; j<2; ++j)
6221 {
6222 QString actionName="direction"+direction[j];
6223 if (scrActions[actionName])
6224 scrActions[actionName]->setChecked(i==j);
6225 }
6226 }
6227
6228 //CB-->??
MakeFrame(int f,int c,double * vals)6229 void ScribusMainWindow::MakeFrame(int f, int c, double *vals)
6230 {
6231 PageItem *currItem = doc->m_Selection->itemAt(0);
6232 switch (f)
6233 {
6234 case 0:
6235 currItem->SetRectFrame();
6236 doc->setRedrawBounding(currItem);
6237 break;
6238 case 1:
6239 currItem->SetOvalFrame();
6240 doc->setRedrawBounding(currItem);
6241 break;
6242 default:
6243 currItem->SetFrameShape(c, vals);
6244 doc->setRedrawBounding(currItem);
6245 currItem->FrameType = f+2;
6246 break;
6247 }
6248 currItem->update();
6249 slotDocCh();
6250 }
6251
duplicateItem()6252 void ScribusMainWindow::duplicateItem()
6253 {
6254 slotSelect();
6255
6256 double shiftGapH = doc->opToolPrefs().dispX * doc->unitRatio();
6257 double shiftGapV = doc->opToolPrefs().dispY * doc->unitRatio();
6258
6259 internalCopy = true;
6260
6261 doc->itemSelection_Duplicate(shiftGapH, shiftGapV);
6262
6263 internalCopy = false;
6264 internalCopyBuffer.clear();
6265 }
6266
duplicateItemMulti()6267 void ScribusMainWindow::duplicateItemMulti()
6268 {
6269 if (!HaveDoc)
6270 return;
6271 slotSelect();
6272 if (doc->appMode == modeEditClip)
6273 view->requestMode(submodeEndNodeEdit);
6274 internalCopy = true;
6275 QScopedPointer<MultipleDuplicate> dia(new MultipleDuplicate(this, doc));
6276 if (dia->exec())
6277 {
6278 ItemMultipleDuplicateData mdData;
6279 dia->getMultiplyData(mdData);
6280 doc->itemSelection_MultipleDuplicate(mdData);
6281 }
6282 internalCopy = false;
6283 }
6284
editItemsFromOutlines(PageItem * ite)6285 void ScribusMainWindow::editItemsFromOutlines(PageItem *ite)
6286 {
6287 if (ite->locked())
6288 return;
6289 if (!doc->m_Selection->isEmpty())
6290 {
6291 if (doc->m_Selection->itemAt(0) != ite)
6292 selectItemsFromOutlines(ite, ite->isGroup());
6293 }
6294 if (ite->isLatexFrame())
6295 {
6296 if (ite->imageVisible())
6297 view->requestMode(modeEdit);
6298 }
6299 else if (ite->isOSGFrame())
6300 view->requestMode(submodeEditExternal);
6301 else if ((ite->itemType() == PageItem::Polygon) || (ite->itemType() == PageItem::PolyLine) || (ite->itemType() == PageItem::Group) || (ite->itemType() == PageItem::ImageFrame) || (ite->itemType() == PageItem::PathText))
6302 {
6303 if (ite->itemType() == PageItem::ImageFrame)
6304 {
6305 if (ite->Pfile.isEmpty())
6306 view->requestMode(submodeLoadPic);
6307 else if (!ite->imageIsAvailable)
6308 view->requestMode(submodeStatusPic);
6309 else if (ite->imageVisible())
6310 view->requestMode(modeEdit);
6311 }
6312 else if (ite->itemType() == PageItem::TextFrame)
6313 view->requestMode(modeEdit);
6314 else
6315 {
6316 view->requestMode(modeEditClip);
6317 scrActions["itemUngroup"]->setEnabled(false);
6318 scrActions["itemGroupAdjust"]->setEnabled(false);
6319 }
6320 }
6321 else if (ite->itemType() == PageItem::TextFrame)
6322 {
6323 if (ite->isAnnotation())
6324 {
6325 view->requestMode(submodeAnnotProps);
6326 }
6327 else if (doc->appMode != modeEdit)
6328 {
6329 view->requestMode(modeEdit);
6330 }
6331 }
6332 else if (ite->isSymbol())
6333 {
6334 if (!doc->symbolEditMode())
6335 view->requestMode(submodeEditSymbol);
6336 }
6337 else if (ite->isArc())
6338 view->requestMode(modeEditArc);
6339 else if (ite->isRegularPolygon())
6340 view->requestMode(modeEditPolygon);
6341 else if (ite->isSpiral())
6342 view->requestMode(modeEditSpiral);
6343 else if (ite->isTable())
6344 view->requestMode(modeEditTable);
6345 }
6346
selectItemsFromOutlines(PageItem * ite,bool single,int position)6347 void ScribusMainWindow::selectItemsFromOutlines(PageItem* ite, bool single, int position)
6348 {
6349 if (HaveDoc && doc->appMode == modeEditClip)
6350 view->requestMode(submodeEndNodeEdit);
6351 activateWindow();
6352 view->deselectItems(true);
6353 if (!doc->symbolEditMode() && !doc->inlineEditMode())
6354 {
6355 int itemPage = ite->OwnPage;
6356 PageItem* parentItem = ite->Parent;
6357 while (parentItem && parentItem->isGroup())
6358 {
6359 itemPage = parentItem->OwnPage;
6360 parentItem = parentItem->Parent;
6361 }
6362 if ((itemPage != -1) && (itemPage != static_cast<int>(doc->currentPage()->pageNr())))
6363 view->GotoPage(itemPage);
6364 }
6365 doc->m_Selection->delaySignalsOn();
6366 view->selectItem(ite, true, single);
6367 doc->m_Selection->delaySignalsOff();
6368
6369 if (doc->m_Selection->isEmpty())
6370 return;
6371 doc->m_Selection->connectItemToGUI();
6372
6373 PageItem *currItem = doc->m_Selection->itemAt(0);
6374 QTransform itemTrans = currItem->getTransform();
6375 double xOffset = 0.0, yOffset = 0.0;
6376 switch (position)
6377 {
6378 case 1: //top left
6379 break;
6380 default: //center
6381 xOffset = currItem->width() / 2.0;
6382 yOffset = currItem->height() / 2.0;
6383 break;
6384 }
6385
6386 QPointF point = itemTrans.map(QPointF(xOffset, yOffset));
6387 view->setCanvasCenterPos(point.x(), point.y());
6388 }
6389
selectItemFromOutlines(PageItem * ite,bool single,int cPos)6390 void ScribusMainWindow::selectItemFromOutlines(PageItem *ite, bool single, int cPos)
6391 {
6392 selectItemsFromOutlines(ite, single);
6393 if (doc->m_Selection->isEmpty())
6394 return;
6395 PageItem *currItem = doc->m_Selection->itemAt(0);
6396 if (currItem->isTextFrame())
6397 {
6398 view->requestMode(modeEdit);
6399 currItem->itemText.setCursorPosition(cPos);
6400 currItem->update();
6401 }
6402 }
6403
selectPagesFromOutlines(int Page)6404 void ScribusMainWindow::selectPagesFromOutlines(int Page)
6405 {
6406 if (HaveDoc && doc->appMode == modeEditClip)
6407 view->requestMode(submodeEndNodeEdit);
6408 activateWindow();
6409 view->deselectItems(true);
6410 if (Page < 0)
6411 return;
6412 view->GotoPage(Page);
6413 }
6414
slotPrefsOrg()6415 void ScribusMainWindow::slotPrefsOrg()
6416 {
6417 QString oldMonitorProfile(ScCore->monitorProfile.productDescription());
6418 slotSelect();
6419 struct ApplicationPrefs oldPrefs(m_prefsManager.appPrefs);
6420 PreferencesDialog prefsDialog(this, oldPrefs);
6421 int prefsResult = prefsDialog.exec();
6422 if (prefsResult != QDialog::Accepted)
6423 return;
6424
6425 struct ApplicationPrefs newPrefs(prefsDialog.prefs());
6426 m_prefsManager.setNewPrefs(newPrefs);
6427 m_prefsManager.applyLoadedShortCuts();
6428
6429 //TODO: and the other dirs?
6430 DocDir = m_prefsManager.documentDir();
6431 if (oldPrefs.pathPrefs.documents != newPrefs.pathPrefs.documents)
6432 {
6433 PrefsContext* docContext = m_prefsManager.prefsFile->getContext("docdirs", false);
6434 docContext->set("docsopen", newPrefs.pathPrefs.documents);
6435 }
6436
6437 ScQApp->neverSplash(!m_prefsManager.appPrefs.uiPrefs.showSplashOnStartup);
6438
6439 QString newUILanguage = m_prefsManager.uiLanguage();
6440 if (oldPrefs.uiPrefs.language != newUILanguage || ScQApp->currGUILanguage() != newUILanguage)
6441 ScQApp->changeGUILanguage(newUILanguage);
6442 m_prefsManager.appPrefs.uiPrefs.language = ScQApp->currGUILanguage();
6443 LocaleManager::instance().setUserPreferredLocale(m_prefsManager.appPrefs.uiPrefs.userPreferredLocale);
6444 ScQApp->setLocale();
6445 QString newUIStyle = m_prefsManager.guiStyle();
6446 if (oldPrefs.uiPrefs.style != newUIStyle)
6447 {
6448 QString styleName = m_prefsManager.guiSystemStyle();
6449 if (!newUIStyle.isEmpty())
6450 styleName = newUIStyle;
6451 QStyle * newStyle = QStyleFactory::create(styleName);
6452 if (newStyle)
6453 ScQApp->setStyle(newStyle);
6454 else
6455 m_prefsManager.appPrefs.uiPrefs.style = oldPrefs.uiPrefs.style;
6456 }
6457
6458 QString newIconSet = m_prefsManager.guiIconSet();
6459 if (oldPrefs.uiPrefs.iconSet != newIconSet)
6460 ScQApp->changeIconSet(newIconSet);
6461
6462 int newUIFontSize = m_prefsManager.guiFontSize();
6463 if (oldPrefs.uiPrefs.applicationFontSize != newUIFontSize)
6464 {
6465 QFont apf = qApp->font();
6466 apf.setPointSize(newUIFontSize);
6467 qApp->setFont(apf);
6468 }
6469 emit UpdateRequest(reqDefFontListUpdate);
6470 if (m_prefsManager.appPrefs.uiPrefs.useTabs)
6471 {
6472 mdiArea->setViewMode(QMdiArea::TabbedView);
6473 mdiArea->setTabsClosable(true);
6474 mdiArea->setDocumentMode(true);
6475 }
6476 else
6477 mdiArea->setViewMode(QMdiArea::SubWindowView);
6478 bool shadowChanged = oldPrefs.displayPrefs.showPageShadow != m_prefsManager.showPageShadow();
6479 QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
6480 if (!windows.isEmpty())
6481 {
6482 int windowCount = windows.count();
6483 for (int i = 0; i < windowCount; ++i)
6484 {
6485 QWidget* w = windows.at(i)->widget();
6486 ScribusWin* scw = dynamic_cast<ScribusWin *>(w);
6487 if (!scw)
6488 qFatal("ScribusMainWindow::slotPrefsOrg !scw");
6489 ScribusView* scw_v = scw->view();
6490 if (oldPrefs.displayPrefs.displayScale != m_prefsManager.displayScale())
6491 {
6492 int x = qRound(qMax(scw_v->contentsX() / scw_v->scale(), 0.0));
6493 int y = qRound(qMax(scw_v->contentsY() / scw_v->scale(), 0.0));
6494 int w = qRound(qMin(scw_v->visibleWidth() / scw_v->scale(), scw->doc()->currentPage()->width()));
6495 int h = qRound(qMin(scw_v->visibleHeight() / scw_v->scale(), scw->doc()->currentPage()->height()));
6496 scw_v->rememberOldZoomLocation(w / 2 + x,h / 2 + y);
6497 scw_v->zoom((scw_v->scale() / oldPrefs.displayPrefs.displayScale) * m_prefsManager.displayScale());
6498 zoomSpinBox->setMaximum(doc->opToolPrefs().magMax);
6499 }
6500 if (shadowChanged)
6501 scw->view()->DrawNew();
6502 }
6503 }
6504
6505 QString newMonitorProfile(newPrefs.colorPrefs.DCMSset.DefaultMonitorProfile);
6506 if (oldMonitorProfile != newMonitorProfile)
6507 {
6508 bool success = false;
6509 if (ScCore->MonitorProfiles.contains(newMonitorProfile))
6510 {
6511 QString profilePath = ScCore->MonitorProfiles[newMonitorProfile];
6512 ScColorProfile newProfile = ScCore->defaultEngine.openProfileFromFile(profilePath);
6513 if (!newProfile.isNull())
6514 {
6515 ScCore->monitorProfile = newProfile;
6516 success = true;
6517 }
6518 }
6519 if (!success)
6520 {
6521 newPrefs.colorPrefs.DCMSset.DefaultMonitorProfile = oldMonitorProfile;
6522 m_prefsManager.setNewPrefs(newPrefs);
6523 QString message = tr("An error occurred while opening monitor profile.\nFormer monitor profile will be used." );
6524 if (ScCore->usingGUI())
6525 ScMessageBox::warning(this, CommonStrings::trWarning, message);
6526 else
6527 qWarning( "%s", message.toLocal8Bit().data() );
6528 }
6529 }
6530 ScImageCacheManager & icm = ScImageCacheManager::instance();
6531 icm.setEnabled(newPrefs.imageCachePrefs.cacheEnabled);
6532 icm.setMaxCacheSizeMiB(newPrefs.imageCachePrefs.maxCacheSizeMiB);
6533 icm.setMaxCacheEntries(newPrefs.imageCachePrefs.maxCacheEntries);
6534 icm.setCompressionLevel(newPrefs.imageCachePrefs.compressionLevel);
6535
6536 m_prefsManager.savePrefs();
6537 m_mainWindowStatusLabel->setText( tr("Ready"));
6538 }
6539
slotDocSetup()6540 void ScribusMainWindow::slotDocSetup()
6541 {
6542 if (!doc)
6543 return;
6544 struct ApplicationPrefs oldDocPrefs(doc->prefsData());
6545 PreferencesDialog prefsDialog(this, oldDocPrefs, doc);
6546 int prefsResult = prefsDialog.exec();
6547 if (prefsResult != QDialog::Accepted)
6548 return;
6549
6550 struct ApplicationPrefs newDocPrefs(prefsDialog.prefs());
6551 bool resizePages, resizeMasterPages, resizePageMargins, resizeMasterPageMargins;
6552 prefsDialog.getResizeDocumentPages(resizePages, resizeMasterPages, resizePageMargins, resizeMasterPageMargins);
6553 doc->setNewPrefs(newDocPrefs, oldDocPrefs, resizePages, resizeMasterPages, resizePageMargins, resizeMasterPageMargins);
6554
6555 slotChangeUnit(doc->unitIndex(), false);
6556
6557 if (oldDocPrefs.itemToolPrefs.imageLowResType != newDocPrefs.itemToolPrefs.imageLowResType)
6558 {
6559 setStatusBarInfoText( tr("Updating Images"));
6560 mainWindowProgressBar->reset();
6561 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
6562 qApp->processEvents();
6563 doc->recalcPicturesRes(ScribusDoc::RecalcPicRes_ApplyNewRes);
6564 qApp->restoreOverrideCursor();
6565 setStatusBarInfoText("");
6566 mainWindowProgressBar->reset();
6567 viewToolBar->setDoc(doc);
6568 }
6569
6570 emit UpdateRequest(reqDocFontListUpdate);
6571 scrActions["viewShowMargins"]->setChecked(doc->guidesPrefs().marginsShown);
6572 scrActions["viewShowBleeds"]->setChecked(doc->guidesPrefs().showBleed);
6573 scrActions["viewShowFrames"]->setChecked(doc->guidesPrefs().framesShown);
6574 scrActions["viewShowLayerMarkers"]->setChecked(doc->guidesPrefs().layerMarkersShown);
6575 scrActions["viewShowGrid"]->setChecked(doc->guidesPrefs().gridShown);
6576 scrActions["viewShowGuides"]->setChecked(doc->guidesPrefs().guidesShown);
6577 scrActions["viewShowColumnBorders"]->setChecked(doc->guidesPrefs().colBordersShown);
6578 scrActions["viewShowBaseline"]->setChecked(doc->guidesPrefs().baselineGridShown);
6579 scrActions["viewShowImages"]->setChecked(doc->guidesPrefs().showPic);
6580 scrActions["viewShowTextChain"]->setChecked(doc->guidesPrefs().linkShown);
6581 scrActions["viewShowTextControls"]->setChecked(doc->guidesPrefs().showControls);
6582 scrActions["viewShowRulers"]->setChecked(doc->guidesPrefs().rulersShown);
6583 scrActions["viewRulerMode"]->setChecked(doc->guidesPrefs().rulerMode);
6584 scrActions["extrasGenerateTableOfContents"]->setEnabled(doc->hasTOCSetup());
6585 scrActions["extrasUpdateDocument"]->setEnabled(true);
6586 scrActions["viewToggleCMS"]->setChecked(doc->HasCMS);
6587 view->setRulersShown(doc->guidesPrefs().rulersShown);
6588 //doc emits changed() via this
6589 doc->setMasterPageMode(true);
6590 view->reformPages();
6591 doc->setMasterPageMode(false);
6592 view->reformPages();
6593 view->GotoPage(doc->currentPage()->pageNr());
6594 view->DrawNew();
6595 pagePalette->rebuildPages();
6596 emit UpdateRequest(reqCmsOptionsUpdate);
6597 doc->changed();
6598 modeToolBar->setDoc(doc);
6599 }
6600
ShowSubs()6601 int ScribusMainWindow::ShowSubs()
6602 {
6603 propertiesPalette->startup();
6604 contentPalette->startup();
6605 outlinePalette->startup();
6606 scrapbookPalette->startup();
6607 bookmarkPalette->startup();
6608 downloadsPalette->startup();
6609 pagePalette->startup();
6610 layerPalette->startup();
6611 docCheckerPalette->startup();
6612 alignDistributePalette->startup();
6613 undoPalette->startup();
6614 guidePalette->startup();
6615 inlinePalette->startup();
6616 charPalette->startup();
6617 m_styleManager->startup();
6618 marksManager->startup();
6619 nsEditor->startup();
6620 symbolPalette->startup();
6621
6622 if (!m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.isEmpty())
6623 {
6624 for (int i = 0; i < m_prefsManager.appPrefs.uiPrefs.tabbedPalettes.count(); i++)
6625 {
6626 QStringList actTab = m_prefsManager.appPrefs.uiPrefs.tabbedPalettes[i].palettes;
6627 QDockWidget *container = findChild<QDockWidget *>(actTab[0]);
6628 if (!container)
6629 continue;
6630 QList<QTabBar *> bars = findChildren<QTabBar *>(QString());
6631 bool found = false;
6632 for (int j = 0; j < bars.count(); ++j)
6633 {
6634 QTabBar *bar = bars[j];
6635 for (int k = 0; k < bar->count(); k++)
6636 {
6637 QObject *obj = (QObject*) bar->tabData(k).toULongLong();
6638 if (obj == nullptr)
6639 continue;
6640 if (obj->objectName() != container->objectName())
6641 continue;
6642 if (m_prefsManager.appPrefs.uiPrefs.tabbedPalettes[i].activeTab > -1)
6643 {
6644 bar->setCurrentIndex(m_prefsManager.appPrefs.uiPrefs.tabbedPalettes[i].activeTab);
6645 found = true;
6646 break;
6647 }
6648 }
6649 if (found)
6650 break;
6651 }
6652 }
6653 }
6654
6655 // init the toolbars
6656 fileToolBar->initVisibility();
6657 editToolBar->initVisibility();
6658 modeToolBar->initVisibility();
6659 pdfToolBar->initVisibility();
6660
6661 activateWindow();
6662 if (!scriptIsRunning())
6663 raise();
6664 return 0;
6665 }
6666
printPreview()6667 void ScribusMainWindow::printPreview()
6668 {
6669 const CheckerPrefs& checkerProfile = doc->checkerProfiles()[doc->curCheckProfile()];
6670 if (checkerProfile.autoCheck)
6671 {
6672 if (scanDocument())
6673 {
6674 if (checkerProfile.ignoreErrors)
6675 {
6676 int i = ScMessageBox::warning(this, CommonStrings::trWarning,
6677 "<qt>"+ tr("Scribus has detected some errors. Consider using the Preflight Verifier to correct them")+"</qt>",
6678 QMessageBox::Abort | QMessageBox::Ignore,
6679 QMessageBox::NoButton, // GUI default
6680 QMessageBox::Ignore); // batch default
6681 if (i == QMessageBox::Abort)
6682 return;
6683 }
6684 else
6685 {
6686 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doPrintPreview()));
6687 docCheckerPalette->setIgnoreEnabled(true);
6688 docCheckerPalette->checkMode = CheckDocument::checkPrintPreview;
6689 docCheckerPalette->buildErrorList(doc);
6690 docCheckerPalette->show();
6691 scrActions["toolsPreflightVerifier"]->setChecked(true);
6692 return;
6693 }
6694 }
6695 }
6696 doPrintPreview();
6697 }
6698
doPrintPreview()6699 void ScribusMainWindow::doPrintPreview()
6700 {
6701 if (!HaveDoc)
6702 return;
6703 if (!( ScCore->haveGS() || ScCore->isWinGUI() ))
6704 return;
6705 if (docCheckerPalette->isIgnoreEnabled())
6706 {
6707 docCheckerPalette->hide();
6708 docCheckerPalette->checkMode = CheckDocument::checkNULL;
6709 docCheckerPalette->setIgnoreEnabled(false);
6710 scrActions["toolsPreflightVerifier"]->setChecked(false);
6711 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doPrintPreview()));
6712 }
6713 PrefsContext* prefs = PrefsManager::instance().prefsFile->getContext("print_options");
6714 QString currentPrinter(prefs->get("CurrentPrn"));
6715 PrintLanguage currentEngine = (PrintLanguage) prefs->get("CurrentPrnEngine", "3").toInt();
6716 if (PrintPreview::usesGhostscript(currentPrinter, currentEngine) && (!ScCore->haveGS()) )
6717 {
6718 QString mess(tr("Ghostscript is missing : PostScript Print Preview is not available") + "\n\n");
6719 ScMessageBox::warning(this, CommonStrings::trWarning, mess);
6720 return;
6721 }
6722 PrintPreview *dia = new PrintPreview(this, doc, currentPrinter, currentEngine);
6723 previewDinUse = true;
6724 connect(dia, SIGNAL(doPrint()), this, SLOT(slotReallyPrint()));
6725 dia->exec();
6726 PrefsManager& prefsManager = PrefsManager::instance();
6727 prefsManager.appPrefs.printPreviewPrefs.PrPr_Mode = dia->isCMYKPreviewEnabled();
6728 prefsManager.appPrefs.printPreviewPrefs.PrPr_AntiAliasing = dia->isAntialiasingEnabled();
6729 prefsManager.appPrefs.printPreviewPrefs.PrPr_Transparency = dia->isTransparencyEnabled();
6730 if (ScCore->haveTIFFSep() && dia->useGhostscriptPreview())
6731 {
6732 prefsManager.appPrefs.printPreviewPrefs.PrPr_C = dia->isInkChannelVisible("Cyan");
6733 prefsManager.appPrefs.printPreviewPrefs.PrPr_M = dia->isInkChannelVisible("Magenta");
6734 prefsManager.appPrefs.printPreviewPrefs.PrPr_Y = dia->isInkChannelVisible("Yellow");
6735 prefsManager.appPrefs.printPreviewPrefs.PrPr_K = dia->isInkChannelVisible("Black");
6736 prefsManager.appPrefs.printPreviewPrefs.PrPr_InkCoverage = dia->isInkCoverageEnabled();
6737 prefsManager.appPrefs.printPreviewPrefs.PrPr_InkThreshold = dia->inkCoverageThreshold();
6738 }
6739 disconnect(dia, SIGNAL(doPrint()), this, SLOT(slotReallyPrint()));
6740 previewDinUse = false;
6741 delete dia;
6742 }
6743
outputPreviewPDF()6744 void ScribusMainWindow::outputPreviewPDF()
6745 {
6746 const CheckerPrefs& checkerProfile = doc->checkerProfiles()[doc->curCheckProfile()];
6747 if (checkerProfile.autoCheck)
6748 {
6749 if (scanDocument())
6750 {
6751 if (checkerProfile.ignoreErrors)
6752 {
6753 int i = ScMessageBox::warning(this, CommonStrings::trWarning,
6754 "<qt>"+ tr("Scribus has detected some errors. Consider using the Preflight Verifier to correct them")+"</qt>",
6755 QMessageBox::Abort | QMessageBox::Ignore,
6756 QMessageBox::NoButton, // GUI default
6757 QMessageBox::Ignore); // batch default
6758 if (i == QMessageBox::Abort)
6759 return;
6760 }
6761 else
6762 {
6763 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPDF()));
6764 docCheckerPalette->setIgnoreEnabled(true);
6765 docCheckerPalette->checkMode = CheckDocument::checkOutputPreviewPDF;
6766 docCheckerPalette->buildErrorList(doc);
6767 docCheckerPalette->show();
6768 scrActions["toolsPreflightVerifier"]->setChecked(true);
6769 return;
6770 }
6771 }
6772 }
6773 doOutputPreviewPDF();
6774 }
6775
doOutputPreviewPDF()6776 void ScribusMainWindow::doOutputPreviewPDF()
6777 {
6778 if (!HaveDoc)
6779 return;
6780 if (!ScCore->haveGS())
6781 return;
6782
6783 if (docCheckerPalette->isIgnoreEnabled())
6784 {
6785 docCheckerPalette->hide();
6786 docCheckerPalette->checkMode = CheckDocument::checkNULL;
6787 docCheckerPalette->setIgnoreEnabled(false);
6788 scrActions["toolsPreflightVerifier"]->setChecked(false);
6789 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPDF()));
6790 }
6791
6792 OutputPreview_PDF *dia = new OutputPreview_PDF(this, doc);
6793 previewDinUse = true;
6794 connect(dia, SIGNAL(doExport()), this, SLOT(doSaveAsPDF()));
6795 dia->exec();
6796 disconnect(dia, SIGNAL(doExport()), this, SLOT(doSaveAsPDF()));
6797 previewDinUse = false;
6798
6799 PrefsManager& prefsManager = PrefsManager::instance();
6800 prefsManager.appPrefs.pdfOutputPreviewPrefs.cmykPreviewMode = dia->isCMYKPreviewEnabled();
6801 prefsManager.appPrefs.pdfOutputPreviewPrefs.enableAntiAliasing = dia->isAntialiasingEnabled();
6802 prefsManager.appPrefs.pdfOutputPreviewPrefs.showTransparency = dia->isTransparencyEnabled();
6803 if (ScCore->haveTIFFSep())
6804 {
6805 prefsManager.appPrefs.pdfOutputPreviewPrefs.isCyanVisible = dia->isInkChannelVisible("Cyan");
6806 prefsManager.appPrefs.pdfOutputPreviewPrefs.isMagentaVisible = dia->isInkChannelVisible("Magenta");
6807 prefsManager.appPrefs.pdfOutputPreviewPrefs.isYellowVisible = dia->isInkChannelVisible("Yellow");
6808 prefsManager.appPrefs.pdfOutputPreviewPrefs.isBlackVisible = dia->isInkChannelVisible("Black");
6809 prefsManager.appPrefs.pdfOutputPreviewPrefs.displayInkCoverage = dia->isInkCoverageEnabled();
6810 prefsManager.appPrefs.pdfOutputPreviewPrefs.inkCoverageThreshold = dia->inkCoverageThreshold();
6811 }
6812
6813 delete dia;
6814 }
6815
outputPreviewPS()6816 void ScribusMainWindow::outputPreviewPS()
6817 {
6818 const CheckerPrefs& checkerProfile = doc->checkerProfiles()[doc->curCheckProfile()];
6819 if (checkerProfile.autoCheck)
6820 {
6821 if (scanDocument())
6822 {
6823 if (checkerProfile.ignoreErrors)
6824 {
6825 int i = ScMessageBox::warning(this, CommonStrings::trWarning,
6826 "<qt>"+ tr("Scribus has detected some errors. Consider using the Preflight Verifier to correct them")+"</qt>",
6827 QMessageBox::Abort | QMessageBox::Ignore,
6828 QMessageBox::NoButton, // GUI default
6829 QMessageBox::Ignore); // batch default
6830 if (i == QMessageBox::Abort)
6831 return;
6832 }
6833 else
6834 {
6835 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPS()));
6836 docCheckerPalette->setIgnoreEnabled(true);
6837 docCheckerPalette->checkMode = CheckDocument::checkOutputPreviewPS;
6838 docCheckerPalette->buildErrorList(doc);
6839 docCheckerPalette->show();
6840 scrActions["toolsPreflightVerifier"]->setChecked(true);
6841 return;
6842 }
6843 }
6844 }
6845 doOutputPreviewPS();
6846 }
6847
doOutputPreviewPS()6848 void ScribusMainWindow::doOutputPreviewPS()
6849 {
6850 if (!HaveDoc)
6851 return;
6852 if (!ScCore->haveGS())
6853 return;
6854
6855 if (docCheckerPalette->isIgnoreEnabled())
6856 {
6857 docCheckerPalette->hide();
6858 docCheckerPalette->checkMode = CheckDocument::checkNULL;
6859 docCheckerPalette->setIgnoreEnabled(false);
6860 scrActions["toolsPreflightVerifier"]->setChecked(false);
6861 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPS()));
6862 }
6863
6864 OutputPreview_PS *dia = new OutputPreview_PS(this, doc);
6865 previewDinUse = true;
6866 connect(dia, SIGNAL(doExport()), this, SLOT(slotReallyPrint()));
6867 dia->exec();
6868 disconnect(dia, SIGNAL(doExport()), this, SLOT(slotReallyPrint()));
6869 previewDinUse = false;
6870
6871 PrefsManager& prefsManager = PrefsManager::instance();
6872 prefsManager.appPrefs.psOutputPreviewPrefs.psLevel = dia->postscriptLevel();
6873 prefsManager.appPrefs.psOutputPreviewPrefs.cmykPreviewMode = dia->isCMYKPreviewEnabled();
6874 prefsManager.appPrefs.psOutputPreviewPrefs.enableAntiAliasing = dia->isAntialiasingEnabled();
6875 prefsManager.appPrefs.psOutputPreviewPrefs.showTransparency = dia->isTransparencyEnabled();
6876 if (ScCore->haveTIFFSep())
6877 {
6878 prefsManager.appPrefs.psOutputPreviewPrefs.isCyanVisible = dia->isInkChannelVisible("Cyan");
6879 prefsManager.appPrefs.psOutputPreviewPrefs.isMagentaVisible = dia->isInkChannelVisible("Magenta");
6880 prefsManager.appPrefs.psOutputPreviewPrefs.isYellowVisible = dia->isInkChannelVisible("Yellow");
6881 prefsManager.appPrefs.psOutputPreviewPrefs.isBlackVisible = dia->isInkChannelVisible("Black");
6882 prefsManager.appPrefs.psOutputPreviewPrefs.displayInkCoverage = dia->isInkCoverageEnabled();
6883 prefsManager.appPrefs.psOutputPreviewPrefs.inkCoverageThreshold = dia->inkCoverageThreshold();
6884 }
6885
6886 delete dia;
6887 }
6888
DoSaveAsEps(const QString & fn,QString & error)6889 bool ScribusMainWindow::DoSaveAsEps(const QString& fn, QString& error)
6890 {
6891 QStringList spots;
6892 bool return_value = true;
6893 ReOrderText(doc, view);
6894 ScCore->fileWatcher->forceScan();
6895 ScCore->fileWatcher->stop();
6896 PrintOptions options;
6897 options.pageNumbers.push_back(doc->currentPage()->pageNr()+1);
6898 options.outputSeparations = false;
6899 options.separationName = "All";
6900 options.allSeparations = spots;
6901 options.useSpotColors = true;
6902 options.useColor = true;
6903 options.mirrorH = false;
6904 options.mirrorV = false;
6905 options.doGCR = m_prefsManager.appPrefs.printerPrefs.GCRMode;
6906 options.setDevParam = false;
6907 options.doClip = true;
6908 options.cropMarks = false;
6909 options.bleedMarks = false;
6910 options.registrationMarks = false;
6911 options.colorMarks = false;
6912 options.includePDFMarks = false;
6913 options.markLength = 20.0;
6914 options.markOffset = 0.0;
6915 options.bleeds.set(0, 0, 0, 0);
6916 PSLib *pslib = new PSLib(doc, options, PSLib::OutputEPS);
6917 if (pslib != nullptr)
6918 {
6919 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
6920 int psRet = pslib->createPS(fn);
6921 if (psRet == 1)
6922 {
6923 error = pslib->errorMessage();
6924 return_value = false;
6925 }
6926 delete pslib;
6927 qApp->restoreOverrideCursor();
6928 }
6929 ScCore->fileWatcher->start();
6930 return return_value;
6931 }
6932
SaveAsEps()6933 void ScribusMainWindow::SaveAsEps()
6934 {
6935 if (doc->checkerProfiles()[doc->curCheckProfile()].autoCheck)
6936 {
6937 if (scanDocument())
6938 {
6939 if (doc->checkerProfiles()[doc->curCheckProfile()].ignoreErrors)
6940 {
6941 int t = ScMessageBox::warning(this, CommonStrings::trWarning,
6942 tr("Scribus detected some errors.\nConsider using the Preflight Verifier to correct them."),
6943 QMessageBox::Abort | QMessageBox::Ignore,
6944 QMessageBox::NoButton, // GUI default,
6945 QMessageBox::Ignore); // batch default
6946 if (t == QMessageBox::Abort)
6947 return;
6948 }
6949 else
6950 {
6951 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(reallySaveAsEps()));
6952 docCheckerPalette->setIgnoreEnabled(true);
6953 docCheckerPalette->checkMode = CheckDocument::checkEPS;
6954 docCheckerPalette->buildErrorList(doc);
6955 docCheckerPalette->show();
6956 scrActions["toolsPreflightVerifier"]->setChecked(true);
6957 return;
6958 }
6959 }
6960 }
6961 reallySaveAsEps();
6962 }
6963
reallySaveAsEps()6964 void ScribusMainWindow::reallySaveAsEps()
6965 {
6966 QString filename;
6967 if (docCheckerPalette->isIgnoreEnabled())
6968 {
6969 docCheckerPalette->hide();
6970 docCheckerPalette->checkMode = CheckDocument::checkNULL;
6971 docCheckerPalette->setIgnoreEnabled(false);
6972 scrActions["toolsPreflightVerifier"]->setChecked(false);
6973 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(reallySaveAsEps()));
6974 }
6975 if (!doc->documentFileName().startsWith( tr("Document")))
6976 {
6977 QFileInfo fi(doc->documentFileName());
6978 if (!doc->m_Selection->isEmpty())
6979 filename = fi.path() + "/" + fi.completeBaseName() + "_selection.eps";
6980 else
6981 filename = fi.path() + "/" + getFileNameByPage(doc, doc->currentPage()->pageNr(), "eps");
6982 }
6983 else
6984 {
6985 QDir di = QDir();
6986 if (!doc->m_Selection->isEmpty())
6987 filename = di.currentPath() + "/" + doc->documentFileName() + "_selection.eps";
6988 else
6989 filename = di.currentPath() + "/" + getFileNameByPage(doc, doc->currentPage()->pageNr(), "eps");
6990 }
6991 filename = QDir::toNativeSeparators(filename);
6992
6993 PrefsContext* dirsContext = m_prefsManager.prefsFile->getContext("dirs");
6994 QString prefsDocDir = m_prefsManager.documentDir();
6995 QString workingDir = dirsContext->get("eps", prefsDocDir.isEmpty() ? "." : prefsDocDir);
6996 QString fn = CFileDialog(workingDir, tr("Save As"), tr("%1;;All Files (*)").arg(m_formatsManager->extensionsForFormat(FormatsManager::EPS)), filename, fdHidePreviewCheckBox | fdNone);
6997 if (fn.isEmpty())
6998 return;
6999
7000 m_prefsManager.prefsFile->getContext("dirs")->set("eps", fn.left(fn.lastIndexOf("/")));
7001 if (!overwrite(this, fn))
7002 return;
7003
7004 QString epsError;
7005 if (!DoSaveAsEps(fn, epsError))
7006 {
7007 QString message = tr("Cannot write the file: \n%1").arg(fn);
7008 if (!epsError.isEmpty())
7009 message += QString("\n%1").arg(epsError);
7010 ScMessageBox::warning(this, CommonStrings::trWarning, message);
7011 }
7012 }
7013
getPDFDriver(const QString & filename,const std::vector<int> & pageNumbers,const QMap<int,QImage> & thumbs,QString & error,bool * cancelled)7014 bool ScribusMainWindow::getPDFDriver(const QString &filename, const std::vector<int> & pageNumbers,
7015 const QMap<int, QImage>& thumbs, QString& error, bool* cancelled)
7016 {
7017 ScCore->fileWatcher->forceScan();
7018 ScCore->fileWatcher->stop();
7019 PDFlib pdflib(*doc);
7020 bool ret = pdflib.doExport(filename, pageNumbers, thumbs);
7021 if (!ret)
7022 error = pdflib.errorMessage();
7023 if (cancelled)
7024 *cancelled = pdflib.exportAborted();
7025 ScCore->fileWatcher->start();
7026 return ret;
7027 }
7028
SaveAsPDF()7029 void ScribusMainWindow::SaveAsPDF()
7030 {
7031 if (doc->checkerProfiles()[doc->curCheckProfile()].autoCheck)
7032 {
7033 if (scanDocument())
7034 {
7035 if (doc->checkerProfiles()[doc->curCheckProfile()].ignoreErrors)
7036 {
7037 int t = ScMessageBox::warning(this, CommonStrings::trWarning,
7038 tr("Detected some errors.\nConsider using the Preflight Verifier to correct them"),
7039 QMessageBox::Abort | QMessageBox::Ignore,
7040 QMessageBox::NoButton, // GUI default
7041 QMessageBox::Ignore); // batch default
7042 if (t == QMessageBox::Abort)
7043 return;
7044 }
7045 else
7046 {
7047 connect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doSaveAsPDF()));
7048 docCheckerPalette->setIgnoreEnabled(true);
7049 docCheckerPalette->checkMode = CheckDocument::checkPDF;
7050 docCheckerPalette->buildErrorList(doc);
7051 docCheckerPalette->show();
7052 scrActions["toolsPreflightVerifier"]->setChecked(true);
7053 return;
7054 }
7055 }
7056 }
7057 doSaveAsPDF();
7058 }
7059
doSaveAsPDF()7060 void ScribusMainWindow::doSaveAsPDF()
7061 {
7062 if (docCheckerPalette->isIgnoreEnabled())
7063 {
7064 docCheckerPalette->hide();
7065 docCheckerPalette->checkMode = CheckDocument::checkNULL;
7066 docCheckerPalette->setIgnoreEnabled(false);
7067 scrActions["toolsPreflightVerifier"]->setChecked(false);
7068 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doSaveAsPDF()));
7069 }
7070 QMap<QString, int> ReallyUsed = doc->reorganiseFonts();
7071 if (doc->pdfOptions().EmbedList.count() != 0)
7072 {
7073 QList<QString> tmpEm;
7074 QList<QString>::Iterator itef;
7075 for (itef = doc->pdfOptions().EmbedList.begin(); itef != doc->pdfOptions().EmbedList.end(); ++itef)
7076 {
7077 if (ReallyUsed.contains((*itef)))
7078 tmpEm.append((*itef));
7079 }
7080 doc->pdfOptions().EmbedList = tmpEm;
7081 }
7082 if (doc->pdfOptions().SubsetList.count() != 0)
7083 {
7084 QList<QString> tmpEm;
7085 QList<QString>::Iterator itef;
7086 for (itef = doc->pdfOptions().SubsetList.begin(); itef != doc->pdfOptions().SubsetList.end(); ++itef)
7087 {
7088 if (ReallyUsed.contains((*itef)))
7089 tmpEm.append((*itef));
7090 }
7091 doc->pdfOptions().SubsetList = tmpEm;
7092 }
7093 MarginStruct optBleeds(doc->pdfOptions().bleeds);
7094 PDFExportDialog dia(this, doc->documentFileName(), ReallyUsed, view, doc->pdfOptions(), ScCore->PDFXProfiles, m_prefsManager.appPrefs.fontPrefs.AvailFonts, ScCore->PrinterProfiles);
7095 if (!dia.exec())
7096 return;
7097
7098 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
7099 dia.updateDocOptions();
7100 doc->pdfOptions().firstUse = false;
7101 ReOrderText(doc, view);
7102 QString pageString(dia.getPagesString());
7103 std::vector<int> pageNs;
7104 uint pageNumbersSize;
7105 QMap<int, QImage> allThumbs, thumbs;
7106 QString fileName = doc->pdfOptions().fileName;
7107 QString errorMsg;
7108 parsePagesString(pageString, &pageNs, doc->DocPages.count());
7109 if (doc->pdfOptions().useDocBleeds)
7110 doc->pdfOptions().bleeds = *doc->bleeds();
7111
7112 // If necssary, generate thumbnails in one go : if color management is enabled
7113 // we gain lots of time by avoiding multiple color management settings change
7114 // and hence multiple reloading of images
7115 bool cmsCorr = false;
7116 if (doc->pdfOptions().Thumbnails &&
7117 doc->cmsSettings().CMSinUse &&
7118 doc->cmsSettings().GamutCheck)
7119 {
7120 cmsCorr = true;
7121 doc->cmsSettings().GamutCheck = false;
7122 doc->enableCMS(true);
7123 }
7124 pageNumbersSize = pageNs.size();
7125 for (uint i = 0; i < pageNumbersSize; ++i)
7126 {
7127 QImage thumb(10, 10, QImage::Format_ARGB32_Premultiplied);
7128 if (doc->pdfOptions().Thumbnails)
7129 {
7130 // No need to load full res images for drawing small thumbnail
7131 PageToPixmapFlags flags = Pixmap_DontReloadImages | Pixmap_DrawWhiteBackground;
7132 thumb = view->PageToPixmap(pageNs[i] - 1, 100, flags);
7133 }
7134 allThumbs.insert(pageNs[i], thumb);
7135 }
7136 if (cmsCorr)
7137 {
7138 doc->cmsSettings().GamutCheck = true;
7139 doc->enableCMS(true);
7140 }
7141
7142 if (doc->pdfOptions().doMultiFile)
7143 {
7144 bool cancelled = false;
7145 QFileInfo fi(fileName);
7146 QString ext = fi.suffix();
7147 QString path = fi.path();
7148 QString name = fi.completeBaseName();
7149 uint aa = 0;
7150 while (aa < pageNs.size() && !cancelled)
7151 {
7152 thumbs.clear();
7153 std::vector<int> pageNs2;
7154 pageNs2.clear();
7155 pageNs2.push_back(pageNs[aa]);
7156 pageNumbersSize = pageNs2.size();
7157 QImage thumb(10, 10, QImage::Format_ARGB32_Premultiplied);
7158 if (doc->pdfOptions().Thumbnails)
7159 thumb = allThumbs[pageNs[aa]];
7160 thumbs.insert(1, thumb);
7161 QString realName = QDir::toNativeSeparators(path + "/" + name + tr("-Page%1").arg(pageNs[aa], 3, 10, QChar('0')) + "." + ext);
7162 if (!getPDFDriver(realName, pageNs2, thumbs, errorMsg, &cancelled))
7163 {
7164 qApp->restoreOverrideCursor();
7165 QString message = tr("Cannot write the file: \n%1").arg(doc->pdfOptions().fileName);
7166 if (!errorMsg.isEmpty())
7167 message = QString("%1\n%2").arg(message, errorMsg);
7168 ScMessageBox::warning(this, CommonStrings::trWarning, message);
7169 return;
7170 }
7171 aa++;
7172 }
7173 }
7174 else
7175 {
7176 if (!getPDFDriver(fileName, pageNs, allThumbs, errorMsg))
7177 {
7178 qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
7179 QString message = tr("Cannot write the file: \n%1").arg(doc->pdfOptions().fileName);
7180 if (!errorMsg.isEmpty())
7181 message = QString("%1\n%2").arg(message, errorMsg);
7182 ScMessageBox::warning(this, CommonStrings::trWarning, message);
7183 }
7184 }
7185 if (doc->pdfOptions().useDocBleeds)
7186 doc->pdfOptions().bleeds = optBleeds;
7187 qApp->restoreOverrideCursor();
7188 if (errorMsg.isEmpty() && doc->pdfOptions().openAfterExport && !doc->pdfOptions().doMultiFile)
7189 {
7190 QString pdfViewer(PrefsManager::instance().appPrefs.extToolPrefs.pdfViewerExecutable);
7191 if (pdfViewer.isEmpty())
7192 {
7193 pdfViewer = QFileDialog::getOpenFileName(this, tr("Locate your PDF viewer"), QString(), QString());
7194 if (!QFileInfo::exists(pdfViewer))
7195 pdfViewer.clear();
7196 PrefsManager::instance().appPrefs.extToolPrefs.pdfViewerExecutable = pdfViewer;
7197 }
7198 if (!pdfViewer.isEmpty())
7199 {
7200 QStringList args;
7201 args << QDir::toNativeSeparators(doc->pdfOptions().fileName);
7202 QProcess::startDetached(pdfViewer, args);
7203 }
7204 }
7205 }
7206
7207 //CB-->Doc, stop _storing_ bookmarks in the palette
AddBookMark(PageItem * ite)7208 void ScribusMainWindow::AddBookMark(PageItem *ite)
7209 {
7210 bookmarkPalette->BView->addPageItem(ite);
7211 }
7212
7213 //CB-->Doc, stop _storing_ bookmarks in the palette
DelBookMark(PageItem * ite)7214 void ScribusMainWindow::DelBookMark(PageItem *ite)
7215 {
7216 bookmarkPalette->BView->deleteItem(ite);
7217 }
7218
7219 //CB-->Doc, stop _storing_ bookmarks in the palette
BookMarkTxT(PageItem * ite)7220 void ScribusMainWindow::BookMarkTxT(PageItem *ite)
7221 {
7222 bookmarkPalette->BView->changeText(ite);
7223 }
7224
7225 //CB-->Doc, stop _storing_ bookmarks in the palette
RestoreBookMarks()7226 void ScribusMainWindow::RestoreBookMarks()
7227 {
7228 QList<ScribusDoc::BookMa>::Iterator it2 = doc->BookMarks.begin();
7229 bookmarkPalette->BView->clear();
7230 bookmarkPalette->BView->NrItems = 0;
7231 bookmarkPalette->BView->First = 1;
7232 bookmarkPalette->BView->Last = 0;
7233 if (doc->BookMarks.count() == 0)
7234 return;
7235 BookMItem* ip;
7236 BookMItem* ip2 = nullptr;
7237 BookMItem* ip3 = nullptr;
7238 BookMItem *ite = new BookMItem(bookmarkPalette->BView, &(*it2));
7239 bookmarkPalette->BView->NrItems++;
7240 ++it2;
7241 for ( ; it2 != doc->BookMarks.end(); ++it2)
7242 {
7243 if ((*it2).Parent == 0)
7244 {
7245 ite = new BookMItem(bookmarkPalette->BView, ite, &(*it2));
7246 bookmarkPalette->BView->NrItems++;
7247 }
7248 else
7249 {
7250 QTreeWidgetItemIterator it3(bookmarkPalette->BView);
7251 while (*it3)
7252 {
7253 ip = (BookMItem*)(*it3);
7254 if ((*it2).Parent == ip->ItemNr)
7255 {
7256 ip2 = ip;
7257 break;
7258 }
7259 ++it3;
7260 }
7261 if ((*it2).Prev == 0)
7262 {
7263 (void) new BookMItem(ip2, &(*it2));
7264 bookmarkPalette->BView->NrItems++;
7265 }
7266 else
7267 {
7268 QTreeWidgetItemIterator it4(bookmarkPalette->BView);
7269 while (*it4)
7270 {
7271 ip = (BookMItem*)(*it4);
7272 if ((*it2).Prev == ip->ItemNr)
7273 {
7274 ip3 = ip;
7275 break;
7276 }
7277 ++it4;
7278 }
7279 (void) new BookMItem(ip2, ip3, &(*it2));
7280 bookmarkPalette->BView->NrItems++;
7281 }
7282 }
7283 }
7284 bookmarkPalette->BView->Last = bookmarkPalette->BView->NrItems;
7285 bookmarkPalette->BView->rebuildTree();
7286 }
7287
scrapbookNames()7288 QStringList ScribusMainWindow::scrapbookNames()
7289 {
7290 return scrapbookPalette->getOpenScrapbooksNames();
7291 }
7292
updateLayerMenu()7293 void ScribusMainWindow::updateLayerMenu()
7294 {
7295 bool b = layerMenu->blockSignals(true);
7296 layerMenu->clear();
7297 if (doc == nullptr)
7298 {
7299 layerMenu->blockSignals(b);
7300 return;
7301 }
7302
7303 QStringList newNames;
7304 doc->orderedLayerList(&newNames);
7305 for (QStringList::Iterator it = newNames.begin(); it != newNames.end(); ++it)
7306 {
7307 QPixmap pm(20,15);
7308 pm.fill(doc->Layers.layerByName(*it)->markerColor);
7309 layerMenu->addItem(pm, *it);
7310 }
7311
7312 if (layerMenu->count() != 0)
7313 {
7314 QString layerName = doc->activeLayerName();
7315 setCurrentComboItem(layerMenu, layerName);
7316 }
7317
7318 layerMenu->blockSignals(b);
7319 }
7320
7321
gotoLayer(int l)7322 void ScribusMainWindow::gotoLayer(int l)
7323 {
7324 if (!HaveDoc)
7325 return;
7326 int level = doc->layerCount()-l-1;
7327 int layerID = doc->layerIDFromLevel(level);
7328 if (layerID == -1)
7329 return;
7330 doc->setActiveLayer(layerID);
7331 changeLayer(doc->activeLayer());
7332 emit changeLayers(layerID);
7333 }
7334
7335 //CB-->Doc, stop _storing_ bookmarks in the palette
StoreBookmarks()7336 void ScribusMainWindow::StoreBookmarks()
7337 {
7338 doc->BookMarks.clear();
7339 BookMItem* ip;
7340 QTreeWidgetItemIterator it(bookmarkPalette->BView);
7341 struct ScribusDoc::BookMa Boma;
7342 while (*it)
7343 {
7344 ip = (BookMItem*)(*it);
7345 Boma.Title = ip->Title;
7346 Boma.Text = ip->text(0);
7347 Boma.Aktion = ip->Action;
7348 Boma.ItemNr = ip->ItemNr;
7349 Boma.PageObject = ip->PageObject;
7350 // Boma.Seite = ip->Seite;
7351 // Boma.Element = ip->Element;
7352 Boma.Parent = ip->Pare;
7353 Boma.First = ip->First;
7354 Boma.Prev = ip->Prev;
7355 Boma.Next = ip->Next;
7356 Boma.Last = ip->Last;
7357 doc->BookMarks.append(Boma);
7358 ++it;
7359 }
7360 doc->NrItems = bookmarkPalette->BView->NrItems;
7361 doc->First = bookmarkPalette->BView->First;
7362 doc->Last = bookmarkPalette->BView->Last;
7363 }
7364
slotElemRead(const QString & xml,double x,double y,bool art,bool loca,ScribusDoc * docc,ScribusView * vie)7365 void ScribusMainWindow::slotElemRead(const QString& xml, double x, double y, bool art, bool loca, ScribusDoc* docc, ScribusView* vie)
7366 {
7367 if (doc == docc && docc->appMode == modeEditClip)
7368 view->requestMode(submodeEndNodeEdit);
7369
7370 ScriXmlDoc ss;
7371 if (ss.readElem(xml, docc, x, y, art, loca))
7372 {
7373 vie->DrawNew();
7374 if (doc == docc)
7375 {
7376 emit UpdateRequest(reqColorsUpdate | reqTextStylesUpdate | reqLineStylesUpdate);
7377 slotDocCh();
7378 }
7379 }
7380 }
7381
slotChangeUnit(int unitIndex,bool draw)7382 void ScribusMainWindow::slotChangeUnit(int unitIndex, bool draw)
7383 {
7384 // Hack
7385 QByteArray stylesheet;
7386 if (loadRawText(ScPaths::preferencesDir() + "/stylesheet.css", stylesheet))
7387 {
7388 qApp->setStyleSheet(QString(stylesheet));
7389 }
7390 doc->setUnitIndex(unitIndex);
7391 setCurrentComboItem(unitSwitcher, unitGetStrFromIndex(doc->unitIndex()));
7392 view->unitChange();
7393 propertiesPalette->unitChange();
7394 contentPalette->unitChange();
7395 nodePalette->unitChange();
7396 alignDistributePalette->unitChange();
7397 guidePalette->setupPage();
7398 m_styleManager->unitChange();
7399 if (draw)
7400 view->DrawNew();
7401 }
7402
ManageJava()7403 void ScribusMainWindow::ManageJava()
7404 {
7405 JavaDocs *dia = new JavaDocs(this, doc, view);
7406 connect(dia, SIGNAL(docChanged(bool)), this, SLOT(slotDocCh(bool)));
7407 dia->exec();
7408 disconnect(dia, SIGNAL(docChanged(bool)), this, SLOT(slotDocCh(bool)));
7409 delete dia;
7410 }
7411
editSelectedSymbolStart()7412 void ScribusMainWindow::editSelectedSymbolStart()
7413 {
7414 if (doc->m_Selection->count() > 0)
7415 editSymbolStart(doc->m_Selection->itemAt(0)->pattern());
7416 }
7417
editSymbolStart(const QString & temp)7418 void ScribusMainWindow::editSymbolStart(const QString& temp)
7419 {
7420 if (!HaveDoc || !doc->docPatterns.contains(temp))
7421 return;
7422 if (doc->symbolEditMode())
7423 {
7424 QString editedSymbol = doc->getEditedSymbol();
7425 if (editedSymbol == temp)
7426 return;
7427 editSymbolEnd();
7428 }
7429 m_WasAutoSave = doc->autoSave();
7430 if (m_WasAutoSave)
7431 {
7432 doc->autoSaveTimer->stop();
7433 doc->setAutoSave(false);
7434 }
7435 view->deselectItems(true);
7436 view->saveViewState();
7437 view->showSymbolPage(temp);
7438 appModeHelper->setSymbolEditMode(true, doc);
7439 pagePalette->enablePalette(false);
7440 layerPalette->setEnabled(false);
7441 patternsDependingOnThis.clear();
7442 QStringList mainPatterns = doc->docPatterns.keys();
7443 for (int a = 0; a < mainPatterns.count(); a++)
7444 {
7445 if (mainPatterns[a] != temp)
7446 {
7447 QStringList subPatterns;
7448 subPatterns = doc->getUsedPatternsHelper(mainPatterns[a], subPatterns);
7449 if (subPatterns.contains(temp))
7450 patternsDependingOnThis.prepend(mainPatterns[a]);
7451 }
7452 }
7453 patternsDependingOnThis.prepend(temp);
7454 symbolPalette->editingStart(patternsDependingOnThis);
7455 propertiesPalette->colorPalette->hideEditedPatterns(patternsDependingOnThis);
7456 propertiesPalette->transparencyPalette->hideEditedPatterns(patternsDependingOnThis);
7457 if (outlinePalette->isVisible())
7458 outlinePalette->BuildTree(false);
7459 updateActiveWindowCaption( tr("Editing Symbol: %1").arg(temp));
7460 }
7461
editSymbolEnd()7462 void ScribusMainWindow::editSymbolEnd()
7463 {
7464 view->hideSymbolPage();
7465 if (m_WasAutoSave)
7466 {
7467 doc->setAutoSave(true);
7468 doc->restartAutoSaveTimer();
7469 }
7470 slotSelect();
7471 appModeHelper->setSymbolEditMode(false, doc);
7472
7473 if ( ScCore->haveGS() || ScCore->isWinGUI() )
7474 scrActions["PrintPreview"]->setEnabled(true);
7475 if ( ScCore->haveGS() )
7476 scrActions["OutputPreviewPDF"]->setEnabled(true);
7477 pagePalette->enablePalette(true);
7478 pagePalette->rebuildMasters();
7479 view->restoreViewState();
7480 view->DrawNew();
7481 pagePalette->rebuild();
7482 propertiesPalette->updateColorList();
7483 contentPalette->updateColorList();
7484 symbolPalette->editingFinished();
7485 layerPalette->setEnabled(true);
7486 if (outlinePalette->isVisible())
7487 outlinePalette->BuildTree(false);
7488 updateActiveWindowCaption(doc->documentFileName());
7489 }
7490
editInlineStart(int id)7491 void ScribusMainWindow::editInlineStart(int id)
7492 {
7493 if (!HaveDoc)
7494 return;
7495 m_WasAutoSave = doc->autoSave();
7496 if (m_WasAutoSave)
7497 {
7498 doc->autoSaveTimer->stop();
7499 doc->setAutoSave(false);
7500 }
7501 view->deselectItems(true);
7502 view->saveViewState();
7503 view->showInlinePage(id);
7504 appModeHelper->setInlineEditMode(true, doc);
7505 pagePalette->enablePalette(false);
7506 layerPalette->setEnabled(false);
7507 inlinePalette->editingStart(id);
7508 if (outlinePalette->isVisible())
7509 outlinePalette->BuildTree(false);
7510 updateActiveWindowCaption( tr("Editing Inline Item"));
7511 }
7512
editInlineEnd()7513 void ScribusMainWindow::editInlineEnd()
7514 {
7515 view->hideInlinePage();
7516 if (m_WasAutoSave)
7517 {
7518 doc->setAutoSave(true);
7519 doc->restartAutoSaveTimer();
7520 }
7521 slotSelect();
7522 appModeHelper->setInlineEditMode(false, doc);
7523 pagePalette->enablePalette(true);
7524 pagePalette->rebuildMasters();
7525 view->restoreViewState();
7526 doc->invalidateAll();
7527 view->DrawNew();
7528 pagePalette->rebuild();
7529 propertiesPalette->unsetItem();
7530 propertiesPalette->updateColorList();
7531 contentPalette->unsetItem();
7532 contentPalette->updateColorList();
7533 inlinePalette->editingFinished();
7534 layerPalette->setEnabled(true);
7535 if (outlinePalette->isVisible())
7536 outlinePalette->BuildTree(false);
7537 updateActiveWindowCaption(doc->documentFileName());
7538 }
7539
editMasterPagesStart(const QString & temp)7540 void ScribusMainWindow::editMasterPagesStart(const QString& temp)
7541 {
7542 if (!HaveDoc)
7543 return;
7544 m_pagePalVisible = pagePalette->isVisible();
7545 QString mpName;
7546 if (temp.isEmpty())
7547 mpName = doc->currentPage()->masterPageName();
7548 else
7549 mpName = temp;
7550 view->deselectItems(true);
7551 if (doc->drawAsPreview)
7552 {
7553 view->togglePreview(false);
7554 scrActions["viewPreviewMode"]->setChecked(false);
7555 }
7556 m_WasAutoSave = doc->autoSave();
7557 if (m_WasAutoSave)
7558 {
7559 doc->autoSaveTimer->stop();
7560 doc->setAutoSave(false);
7561 }
7562
7563 if (doc->masterPageMode())
7564 {
7565 pagePalette->startMasterPageMode(mpName);
7566 return;
7567 }
7568
7569 view->saveViewState();
7570
7571 pagePalette->startMasterPageMode(mpName);
7572 if (!pagePalette->isVisible())
7573 {
7574 pagePalette->show();
7575 scrActions["toolsPages"]->setChecked(true);
7576 }
7577 appModeHelper->setMasterPageEditMode(true, doc);
7578 }
7579
editMasterPagesEnd()7580 void ScribusMainWindow::editMasterPagesEnd()
7581 {
7582 view->hideMasterPage();
7583 if (m_WasAutoSave)
7584 {
7585 doc->setAutoSave(true);
7586 doc->restartAutoSaveTimer();
7587 }
7588 slotSelect();
7589 appModeHelper->setMasterPageEditMode(false, doc);
7590 int pageCount = doc->DocPages.count();
7591 for (int i = 0; i < pageCount; ++i)
7592 Apply_MasterPage(doc->DocPages.at(i)->masterPageName(), i, false);
7593
7594 pagePalette->endMasterPageMode();
7595 if (pagePalette->isFloating())
7596 {
7597 pagePalette->setVisible(m_pagePalVisible);
7598 scrActions["toolsPages"]->setChecked(m_pagePalVisible);
7599 }
7600
7601 ScribusView::ViewState viewState = view->topViewState();
7602 doc->setLoading(true);
7603 view->restoreViewState();
7604 view->reformPages(false);
7605 view->setContentsPos(viewState.contentX, viewState.contentY);
7606 doc->setLoading(false);
7607 view->DrawNew();
7608 }
7609
ApplyMasterPage()7610 void ScribusMainWindow::ApplyMasterPage()
7611 {
7612 Q_ASSERT(!doc->masterPageMode());
7613
7614 QScopedPointer<ApplyMasterPageDialog> dia(new ApplyMasterPageDialog(this));
7615 dia->setup(doc, doc->currentPage()->masterPageName());
7616 if (!dia->exec())
7617 return;
7618
7619 QString masterPageName(dia->getMasterPageName());
7620 int pageSelection = dia->getPageSelection(); //0=current, 1=even, 2=odd, 3=all
7621 if (pageSelection == 0) //current page only
7622 Apply_MasterPage(masterPageName, doc->currentPage()->pageNr(), false);
7623 else
7624 {
7625 int startPage, endPage;
7626 if (dia->usingRange())
7627 {
7628 startPage = dia->getFromPage()-1; //Pages start from 0, not 1
7629 endPage = dia->getToPage();
7630 }
7631 else
7632 {
7633 startPage = pageSelection==1 ? 1 : 0; //if even, startPage is 1 (real page 2)
7634 endPage = doc->DocPages.count();
7635 }
7636 for (int pageNum = startPage; pageNum < endPage; ++pageNum)// +=pageStep)
7637 {
7638 //Increment by 1 and not 2 even for even/odd application as user
7639 //can select to eg apply to even pages with a single odd page selected
7640 if (pageSelection == 1 && (pageNum %2 != 0)) //Even, %2!=0 as 1st page is numbered 0
7641 Apply_MasterPage(masterPageName, pageNum, false);
7642 else
7643 if (pageSelection == 2 && (pageNum %2 == 0)) //Odd, %2==0 as 1st page is numbered 0
7644 Apply_MasterPage(masterPageName, pageNum, false);
7645 else
7646 if (pageSelection == 3) //All
7647 Apply_MasterPage(masterPageName, pageNum, false);
7648 }
7649 }
7650
7651 view->reformPages();
7652 view->DrawNew();
7653 pagePalette->rebuild();
7654 // #9476 : call setupPage with false arg to setup only guidePalette GUI
7655 // Otherwise setupPage() will apply guides to current page, doesn't need that,
7656 // Apply_MasterPage() has already done it
7657 guidePalette->setupPage(false);
7658 }
7659
Apply_MasterPage(const QString & pageName,int pageNumber,bool reb)7660 void ScribusMainWindow::Apply_MasterPage(const QString& pageName, int pageNumber, bool reb)
7661 {
7662 if (!HaveDoc)
7663 return;
7664 doc->applyMasterPage(pageName, pageNumber);
7665 if (reb)
7666 view->DrawNew();
7667 }
7668
7669 //CB-->Doc
GroupObj(bool showLockDia)7670 void ScribusMainWindow::GroupObj(bool showLockDia)
7671 {
7672 if (!HaveDoc)
7673 return;
7674 Selection* itemSelection = doc->m_Selection;
7675 if (itemSelection->count() < 2)
7676 return;
7677 bool lockObject = false;
7678 bool modifyLock = false;
7679 int selectedItemCount=itemSelection->count();
7680 if (showLockDia)
7681 {
7682 int lockedCount=0;
7683 for (int i=0; i<selectedItemCount; ++i)
7684 {
7685 if (itemSelection->itemAt(i)->locked())
7686 ++lockedCount;
7687 }
7688 if (lockedCount!=0 && lockedCount!=selectedItemCount)
7689 {
7690 ScMessageBox msgBox;
7691 QPushButton *abortButton = msgBox.addButton(QMessageBox::Cancel);
7692 QPushButton *lockButton = msgBox.addButton(tr("&Lock All"), QMessageBox::AcceptRole);
7693 msgBox.addButton(tr("&Unlock All"), QMessageBox::AcceptRole);
7694 msgBox.setIcon(QMessageBox::Warning);
7695 msgBox.setWindowTitle(CommonStrings::trWarning);
7696 msgBox.setText( tr("Some objects are locked."));
7697 msgBox.setDefaultBatchButton(lockButton);
7698 msgBox.exec();
7699 if (msgBox.clickedButton() == abortButton)
7700 return;
7701 if (msgBox.clickedButton() == lockButton)
7702 lockObject = true;
7703 modifyLock = true;
7704 }
7705 }
7706 doc->itemSelection_GroupObjects(modifyLock, lockObject);
7707 }
7708
7709 //CB-->Doc
UnGroupObj()7710 void ScribusMainWindow::UnGroupObj()
7711 {
7712 if (HaveDoc)
7713 doc->itemSelection_UnGroupObjects();
7714 }
7715
AdjustGroupObj()7716 void ScribusMainWindow::AdjustGroupObj()
7717 {
7718 if (HaveDoc)
7719 doc->itemSelection_resizeGroupToContents();
7720 }
7721
restore(UndoState * state,bool isUndo)7722 void ScribusMainWindow::restore(UndoState* state, bool isUndo)
7723 {
7724 SimpleState *ss = dynamic_cast<SimpleState*>(state);
7725 if (ss)
7726 {
7727 if (ss->contains("ADD_PAGE"))
7728 restoreAddPage(ss, isUndo);
7729 else if (ss->contains("DELETE_PAGE"))
7730 restoreDeletePage(ss, isUndo);
7731 }
7732 }
7733
restoreDeletePage(SimpleState * state,bool isUndo)7734 void ScribusMainWindow::restoreDeletePage(SimpleState *state, bool isUndo)
7735 {
7736 int where, wo;
7737 int pagenr = state->getUInt("PAGENR");
7738 QStringList tmpl;
7739 tmpl << state->get("MASTERPAGE");
7740 QString pageName = state->get("PAGENAME");
7741 bool savedMasterPageMode = state->getBool("MASTER_PAGE_MODE");
7742 bool currMasterPageMode = doc->masterPageMode();
7743 if (currMasterPageMode != savedMasterPageMode)
7744 doc->setMasterPageMode(savedMasterPageMode);
7745 if (pagenr == 1)
7746 {
7747 where = 0;
7748 wo = 1;
7749 }
7750 else if (pagenr > doc->Pages->count())
7751 {
7752 where = 2;
7753 wo = doc->Pages->count();
7754 }
7755 else
7756 {
7757 where = 1;
7758 wo = pagenr - 1;
7759 }
7760
7761 if (isUndo)
7762 {
7763 if (savedMasterPageMode)
7764 {
7765 slotNewMasterPage(wo, pageName);
7766 }
7767 else
7768 {
7769 addNewPages(wo, where, 1, doc->pageHeight(), doc->pageWidth(), doc->pageOrientation(), doc->pageSize(), true, &tmpl);
7770 }
7771 UndoObject *tmp =
7772 m_undoManager->replaceObject(state->getUInt("DUMMY_ID"), doc->Pages->at(pagenr - 1));
7773 delete tmp;
7774 }
7775 else
7776 {
7777 DummyUndoObject *duo = new DummyUndoObject();
7778 uint id = static_cast<uint>(duo->getUId());
7779 m_undoManager->replaceObject(doc->Pages->at(pagenr - 1)->getUId(), duo);
7780 state->set("DUMMY_ID", id);
7781 deletePage(pagenr, pagenr);
7782 }
7783 if (currMasterPageMode!=savedMasterPageMode)
7784 doc->setMasterPageMode(currMasterPageMode);
7785 doc->rebuildMasterNames();
7786 pagePalette->updateMasterPageList();
7787 pagePalette->rebuildPages();
7788 if (outlinePalette->isVisible())
7789 outlinePalette->BuildTree();
7790 }
7791
restoreAddPage(SimpleState * state,bool isUndo)7792 void ScribusMainWindow::restoreAddPage(SimpleState *state, bool isUndo)
7793 {
7794 if (!HaveDoc)
7795 return;
7796 int wo = state->getInt("PAGE");
7797 int where = state->getInt("WHERE");
7798 int count = state->getInt("COUNT");
7799 QStringList based = state->get("BASED").split("|", Qt::SkipEmptyParts);
7800 double height = state->getDouble("HEIGHT");
7801 double width = state->getDouble("WIDTH");
7802 int orient = state->getInt("ORIENT");
7803 QString siz = state->get("SIZE");
7804 bool mov = static_cast<bool>(state->getInt("MOVED"));
7805 bool savedMasterPageMode = state->getBool("MASTER_PAGE_MODE");
7806
7807 int delFrom = 0;
7808 int delTo = 0;
7809 bool currMasterPageMode = doc->masterPageMode();
7810 if (currMasterPageMode != savedMasterPageMode)
7811 doc->setMasterPageMode(savedMasterPageMode);
7812 switch (where)
7813 {
7814 case 0:
7815 delTo = wo + count - 1;
7816 delFrom = delTo - count + 1;
7817 break;
7818 case 1:
7819 delFrom = wo + 1;
7820 delTo = wo + count;
7821 break;
7822 case 2:
7823 delTo = doc->Pages->count();
7824 delFrom = doc->Pages->count() - count + 1;
7825 if (!isUndo)
7826 {
7827 delFrom += count;
7828 delTo += count;
7829 }
7830 break;
7831 }
7832
7833 if (isUndo)
7834 {
7835 for (int i = delFrom - 1; i < delTo; ++i)
7836 {
7837 DummyUndoObject *duo = new DummyUndoObject();
7838 ulong did = duo->getUId();
7839 m_undoManager->replaceObject(doc->Pages->at(i)->getUId(), duo);
7840 state->set(QString("Page%1").arg(i), static_cast<uint>(did));
7841 }
7842 if (doc->appMode == modeEditClip)
7843 view->requestMode(submodeEndNodeEdit);
7844 view->deselectItems(true);
7845 deletePage(delFrom, delTo);
7846 }
7847 else
7848 {
7849 if (savedMasterPageMode)
7850 {
7851 assert (count == 1);
7852 slotNewMasterPage(wo, based[0]);
7853 }
7854 else
7855 {
7856 addNewPages(wo, where, count, height, width, orient, siz, mov, &based);
7857 }
7858 for (int i = delFrom - 1; i < delTo; ++i)
7859 {
7860 UndoObject *tmp = m_undoManager->replaceObject(state->getUInt(QString("Page%1").arg(i)), doc->Pages->at(i));
7861 delete tmp;
7862 }
7863 }
7864 if (currMasterPageMode!=savedMasterPageMode)
7865 doc->setMasterPageMode(currMasterPageMode);
7866 doc->rebuildMasterNames();
7867 pagePalette->updateMasterPageList();
7868 pagePalette->rebuildPages();
7869 if (outlinePalette->isVisible())
7870 outlinePalette->BuildTree();
7871 }
7872
restoreGrouping(SimpleState * state,bool isUndo)7873 void ScribusMainWindow::restoreGrouping(SimpleState *state, bool isUndo)
7874 {
7875 int itemCount = state->getInt("itemcount");
7876 view->deselectItems();
7877 for (int i = 0; i < itemCount; ++i)
7878 {
7879 int itemNr = doc->getItemNrFromUniqueID(state->getUInt(QString("item%1").arg(i)));
7880 if (doc->Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
7881 view->selectItemByNumber(itemNr);
7882 }
7883 if (isUndo)
7884 UnGroupObj();
7885 else
7886 GroupObj(false);
7887 }
7888
restoreUngrouping(SimpleState * state,bool isUndo)7889 void ScribusMainWindow::restoreUngrouping(SimpleState *state, bool isUndo)
7890 {
7891 int itemCount = state->getInt("itemcount");
7892 view->deselectItems();
7893 for (int i = 0; i < itemCount; ++i)
7894 {
7895 int itemNr = doc->getItemNrFromUniqueID(state->getUInt(QString("item%1").arg(i)));
7896 if (doc->Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
7897 view->selectItemByNumber(itemNr);
7898 }
7899 if (isUndo)
7900 GroupObj(false);
7901 else
7902 UnGroupObj();
7903 }
7904
StatusPic()7905 void ScribusMainWindow::StatusPic()
7906 {
7907 if (!HaveDoc)
7908 return;
7909 PicStatus *dia = new PicStatus(this, doc);
7910 connect(dia, SIGNAL(selectPage(int)), this, SLOT(selectPagesFromOutlines(int)));
7911 connect(dia, SIGNAL(selectMasterPage(QString)), this, SLOT(editMasterPagesStart(QString)));
7912 connect(dia, SIGNAL(selectElementByItem(PageItem*,bool,int)), this, SLOT(selectItemsFromOutlines(PageItem*,bool,int)));
7913 dia->exec();
7914 delete dia;
7915 }
7916
CFileDialog(const QString & workingDirectory,const QString & dialogCaption,const QString & fileFilter,const QString & defaultFilename,int optionFlags,bool * useCompression,bool * useFonts,bool * useProfiles)7917 QString ScribusMainWindow::CFileDialog(const QString& workingDirectory, const QString& dialogCaption, const QString& fileFilter, const QString& defaultFilename, int optionFlags, bool *useCompression, bool *useFonts, bool *useProfiles)
7918 {
7919 // changed from "this" to qApp->activeWindow() to be sure it will be opened
7920 // with the current active window as parent. E.g. it won't hide StoryEditor etc. -- PV
7921 CustomFDialog *dia = new CustomFDialog(qApp->activeWindow(), workingDirectory, dialogCaption, fileFilter, optionFlags);
7922 if (!defaultFilename.isEmpty())
7923 {
7924 QString tmpFileName = defaultFilename;
7925 if (tmpFileName.endsWith(".gz", Qt::CaseInsensitive))
7926 tmpFileName.chop(3);
7927 QFileInfo f(tmpFileName);
7928 dia->setExtension(f.suffix());
7929 dia->setZipExtension(f.suffix() + ".gz");
7930 dia->setSelection(defaultFilename);
7931 if (useCompression != nullptr)
7932 dia->setSaveZipFile(*useCompression);
7933 }
7934 if (optionFlags & fdDirectoriesOnly)
7935 {
7936 if (useCompression != nullptr)
7937 dia->setSaveZipFile(*useCompression);
7938 if (useFonts != nullptr)
7939 dia->setIncludeFonts(*useFonts);
7940 if (useProfiles != nullptr)
7941 dia->setIncludeProfiles(*useProfiles);
7942 }
7943 QString retVal;
7944 if (dia->exec() == QDialog::Accepted)
7945 {
7946 LoadEnc.clear();
7947 if (!(optionFlags & fdDirectoriesOnly))
7948 {
7949 LoadEnc = (optionFlags & fdShowCodecs) ? dia->textCodec() : QString();
7950 if (optionFlags & fdCompressFile)
7951 {
7952 if (dia->saveZipFile())
7953 dia->handleCompress();
7954 }
7955 }
7956 else
7957 {
7958 if (useCompression != nullptr && dia->isSaveZipFileShown())
7959 *useCompression = dia->saveZipFile();
7960 if (useFonts != nullptr)
7961 *useFonts = dia->includeFonts();
7962 if (useProfiles != nullptr)
7963 *useProfiles = dia->includeProfiles();
7964 }
7965 this->repaint();
7966 retVal = dia->selectedFile();
7967 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
7968 }
7969 delete dia;
7970 return retVal;
7971 }
7972
7973
7974
recalcColors()7975 void ScribusMainWindow::recalcColors()
7976 {
7977 if (!HaveDoc)
7978 return;
7979 doc->recalculateColors();
7980 propertiesPalette->updateColorList();
7981 contentPalette->updateColorList();
7982 }
7983
ModifyAnnot()7984 void ScribusMainWindow::ModifyAnnot()
7985 {
7986 if (doc->m_Selection->isEmpty())
7987 return;
7988
7989 PageItem *currItem = doc->m_Selection->itemAt(0);
7990 if ((currItem->annotation().Type() == 0) || (currItem->annotation().Type() == 1) || ((currItem->annotation().Type() > 9) && (currItem->annotation().Type() < 13)))
7991 {
7992 int AnType = currItem->annotation().Type();
7993 int AnActType = currItem->annotation().ActionType();
7994 QString AnAction = currItem->annotation().Action();
7995 QString An_Extern = currItem->annotation().Extern();
7996 Annota *dia = new Annota(this, currItem, doc, view);
7997 if (dia->exec())
7998 slotDocCh();
7999 else
8000 {
8001 currItem->annotation().setType(AnType);
8002 currItem->annotation().setActionType(AnActType);
8003 currItem->annotation().setAction(AnAction);
8004 currItem->annotation().setExtern(An_Extern);
8005 }
8006 delete dia;
8007 }
8008 else
8009 {
8010 ScAnnot *dia = new ScAnnot(this, currItem, doc, view);
8011 if (dia->exec())
8012 slotDocCh();
8013 delete dia;
8014 }
8015 currItem->update();
8016 }
8017
SetShortCut()8018 void ScribusMainWindow::SetShortCut()
8019 {
8020 for (QMap<QString,Keys>::Iterator it = m_prefsManager.appPrefs.keyShortcutPrefs.KeyActions.begin(); it != m_prefsManager.appPrefs.keyShortcutPrefs.KeyActions.end(); ++it )
8021 {
8022 if (!it.value().actionName.isEmpty())
8023 if (scrActions[it.value().actionName])
8024 scrActions[it.value().actionName]->setShortcut(it.value().keySequence);
8025 }
8026 }
8027
PutScrap(int scID)8028 void ScribusMainWindow::PutScrap(int scID)
8029 {
8030 if (!HaveDoc)
8031 return;
8032 if (doc->m_Selection->isEmpty())
8033 return;
8034 ScriXmlDoc ss;
8035 QString objectString = ss.writeElem(doc, doc->m_Selection);
8036 QDomDocument docu("scridoc");
8037 docu.setContent(objectString);
8038 QDomElement elem = docu.documentElement();
8039 QDomNode DOC = elem.firstChild();
8040 bool first = true;
8041 DOC = elem.firstChild();
8042 while (!DOC.isNull())
8043 {
8044 QDomElement pg = DOC.toElement();
8045 if (pg.tagName() == "ITEM")
8046 {
8047 if (first)
8048 pg.setAttribute("ANNAME", doc->m_Selection->itemAt(0)->itemName());
8049 first = false;
8050 }
8051 DOC = DOC.nextSibling();
8052 }
8053 objectString = docu.toString();
8054 scrapbookPalette->objFromMainMenu(objectString, scID);
8055 }
8056
changeLayer(int)8057 void ScribusMainWindow::changeLayer(int )
8058 {
8059 if (doc->appMode == modeEdit)
8060 slotSelect();
8061 else if (doc->appMode == modeEditClip)
8062 NoFrameEdit();
8063 view->deselectItems(true);
8064 rebuildLayersList();
8065 layerPalette->rebuildList();
8066 layerPalette->markActiveLayer();
8067 updateLayerMenu();
8068 view->DrawNew();
8069 bool setter = !doc->layerLocked( doc->activeLayer() );
8070 scrMenuMgr->setMenuEnabled("EditPasteRecent", ((scrapbookPalette->tempBView->objectMap.count() > 0) && (setter)));
8071 scrMenuMgr->setMenuEnabled("Insert", setter);
8072 scrMenuMgr->setMenuEnabled("ItemLayer", doc->layerCount() > 1);
8073 appModeHelper->changeLayer(doc, (ScMimeData::clipboardHasScribusData() || (scrapbookPalette->tempHasContents())));
8074 }
8075
setLayerMenuText(const QString & layerName)8076 void ScribusMainWindow::setLayerMenuText(const QString &layerName)
8077 {
8078 bool b = layerMenu->blockSignals(true);
8079 if (layerMenu->count() != 0)
8080 setCurrentComboItem(layerMenu, layerName);
8081 layerMenu->blockSignals(b);
8082 }
8083
showLayer()8084 void ScribusMainWindow::showLayer()
8085 {
8086 view->DrawNew();
8087 }
8088
8089 //TODO: use this only from this class, or just from doc->setcurrentpage
slotSetCurrentPage(int pageIndex)8090 void ScribusMainWindow::slotSetCurrentPage(int pageIndex)
8091 {
8092 if (scriptIsRunning())
8093 return;
8094 bool blocked = pageSelector->blockSignals(true);
8095 pageSelector->setMaximum(doc->masterPageMode() ? 1 : doc->Pages->count());
8096 if ((!doc->isLoading()) && (!doc->masterPageMode()))
8097 pageSelector->setGUIForPage(pageIndex);
8098 pageSelector->blockSignals(blocked);
8099 }
8100
setCurrentPage(int p)8101 void ScribusMainWindow::setCurrentPage(int p)
8102 {
8103 doc->view()->deselectItems();
8104 int p0=p-1; //p is what the user sees.. p0 is our count from 0
8105 doc->setCurrentPage(doc->Pages->at(p0));
8106 if (scriptIsRunning())
8107 return;
8108 slotSetCurrentPage(p0);
8109 doc->view()->setCanvasPos(doc->currentPage()->xOffset() - 10, doc->currentPage()->yOffset() - 10);
8110 HaveNewSel();
8111 doc->view()->setFocus();
8112 }
8113
initHyphenator()8114 void ScribusMainWindow::initHyphenator()
8115 {
8116 //Build our list of hyphenation dictionaries we have in the install dir
8117 //Grab the language abbreviation from it, get the full language text
8118 //Insert the name as key and a new string list into the map
8119 // QString hyphDirName = QDir::toNativeSeparators(ScPaths::instance().dictDir()+"/hyph/");
8120 // QDir hyphDir(hyphDirName, "hyph*.dic", QDir::Name, QDir::Files | QDir::NoSymLinks);
8121 //IL if ((hyphDir.exists()) && (hyphDir.count() != 0))
8122 //IL {
8123 // LanguageManager langmgr;
8124 // langmgr.init(false);
8125 //IL QString languageOfHyphFile;
8126 //IL for (uint dc = 0; dc < hyphDir.count(); ++dc)
8127 //IL {
8128 //IL QFileInfo fi(hyphDir[dc]);
8129 //IL QString fileLangAbbrev=fi.baseName().section('_', 1);
8130 //IL InstLang.insert(fileLangAbbrev, QStringList());
8131 //<<hunspell
8132 // languageOfHyphFile = LanguageManager::instance()->getLangFromAbbrev(fileLangAbbrev, false);
8133 // InstLang.insert(languageOfHyphFile, QStringList());
8134 //>>hunspell
8135 //IL }
8136 //IL }
8137
8138 //For each qm file existing, load the file and find the translations of the names
8139 QString transPath = ScPaths::instance().translationDir();
8140 QDir transDir(transPath, "*.*", QDir::Name, QDir::Files | QDir::NoSymLinks);
8141 if ((transDir.exists()) && (transDir.count() != 0))
8142 {
8143 for (uint i = 0; i < transDir.count(); i++)
8144 {
8145 QFileInfo fi(transPath + transDir[i]);
8146 QString ext(fi.suffix().toLower());
8147 if (ext == "qm")
8148 {
8149 //IL QTranslator *trans = new QTranslator(0);
8150 //IL trans->load(pfad + d2[dc]);
8151
8152 //IL QString translatedLang;
8153 //IL for (QMap<QString, QStringList>::Iterator it=InstLang.begin(); it!=InstLang.end(); ++it)
8154 //IL {
8155 //IL translatedLang="";
8156 //IL translatedLang = trans->translate("QObject", LanguageManager::instance()->getLangFromAbbrev(it.key(), false).toLocal8Bit().data(), "");
8157 //IL if (!translatedLang.isEmpty())
8158 //IL it.value().append(translatedLang);
8159 //IL }
8160 //IL delete trans;
8161 }
8162 }
8163 }
8164 //For each hyphenation file, grab the strings and the hyphenation data.
8165 // QString lang = QString(QLocale::system().name()).left(2);
8166 // m_prefsManager.appPrefs.hyphPrefs.Language = "en_GB";
8167 // if (!LanguageManager::instance()->getHyphFilename(lang).isEmpty() )
8168 // m_prefsManager.appPrefs.hyphPrefs.Language = lang;
8169
8170 /*
8171 if ((hyphDir.exists()) && (hyphDir.count() != 0))
8172 {
8173 LanguageManager *langmgr(LanguageManager::instance());
8174 // langmgr.init(false);
8175 QString tLang = "";
8176 for (uint dc = 0; dc < hyphDir.count(); ++dc)
8177 {
8178 QFileInfo fi(hyphDir[dc]);
8179 QString fileLangAbbrev = fi.baseName().section('_', 1);
8180 tLang = langmgr->getLangFromAbbrev(fileLangAbbrev);
8181 //IL LangTransl.insert(fileLangAbbrev, tLang);
8182 langmgr->addHyphLang(fileLangAbbrev, hyphDir[dc]);
8183 if (fileLangAbbrev == lang)
8184 prefsManager.appPrefs.hyphPrefs.Language = fileLangAbbrev;
8185 }
8186 if (tLang.isEmpty())
8187 prefsManager.appPrefs.hyphPrefs.Language = "en_GB";
8188 }
8189 */
8190 }
8191
ImageEffects()8192 void ScribusMainWindow::ImageEffects()
8193 {
8194 if (!HaveDoc)
8195 return;
8196 if (doc->m_Selection->isEmpty())
8197 return;
8198 PageItem *currItem = doc->m_Selection->itemAt(0);
8199 EffectsDialog* dia = new EffectsDialog(this, currItem, doc);
8200 if (dia->exec())
8201 doc->itemSelection_ApplyImageEffects(dia->effectsList);
8202 delete dia;
8203 }
8204
fileCollect(bool compress,bool withFonts,const bool withProfiles,const QString &)8205 QString ScribusMainWindow::fileCollect(bool compress, bool withFonts, const bool withProfiles, const QString& )
8206 {
8207 if ((doc->hasName) && doc->documentFileName().endsWith(".gz"))
8208 compress=true;
8209 CollectForOutput_UI c(this, doc, QString(), withFonts, withProfiles, compress);
8210 QString newFileName;
8211 QString errorMsg=c.collect(newFileName);
8212 qDebug()<<errorMsg;
8213 return newFileName;
8214 }
8215
docCheckToggle(bool visible)8216 void ScribusMainWindow::docCheckToggle(bool visible)
8217 {
8218 if (!visible)
8219 {
8220 if (docCheckerPalette->checkMode == CheckDocument::checkPDF)
8221 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doSaveAsPDF()));
8222 if (docCheckerPalette->checkMode == CheckDocument::checkEPS)
8223 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(reallySaveAsEps()));
8224 if (docCheckerPalette->checkMode == CheckDocument::checkPrint)
8225 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(slotReallyPrint()));
8226 if (docCheckerPalette->checkMode == CheckDocument::checkPrintPreview)
8227 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doPrintPreview()));
8228 if (docCheckerPalette->checkMode == CheckDocument::checkOutputPreviewPDF)
8229 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPDF()));
8230 if (docCheckerPalette->checkMode == CheckDocument::checkOutputPreviewPS)
8231 disconnect(docCheckerPalette, SIGNAL(ignoreAllErrors()), this, SLOT(doOutputPreviewPS()));
8232 docCheckerPalette->setIgnoreEnabled(false);
8233 docCheckerPalette->checkMode = CheckDocument::checkNULL;
8234 }
8235 else
8236 {
8237 if (HaveDoc)
8238 {
8239 scanDocument();
8240 docCheckerPalette->buildErrorList(doc);
8241 }
8242 }
8243 }
8244
scanDocument()8245 bool ScribusMainWindow::scanDocument()
8246 {
8247 return DocumentChecker::checkDocument(doc);
8248 }
8249
slotStoryEditor(bool fromTable)8250 void ScribusMainWindow::slotStoryEditor(bool fromTable)
8251 {
8252 if (doc->m_Selection->isEmpty())
8253 return;
8254
8255 PageItem *currItem = doc->m_Selection->itemAt(0);
8256 PageItem *i2 = currItem;
8257 if (fromTable)
8258 i2 = currItem->asTable()->activeCell().textFrame();
8259 PageItem *currItemSE = storyEditor->currentItem();
8260 ScribusDoc *currDocSE = storyEditor->currentDocument();
8261 storyEditor->activFromApp = true;
8262 //CB shouldn't these be after the if?
8263 //Why are we resetting the doc and item in this case. My original code didn't do this.
8264 storyEditor->setCurrentDocumentAndItem(doc, i2);
8265 if (i2 == currItemSE && doc == currDocSE)
8266 {
8267 storyEditor->show();
8268 storyEditor->raise();
8269 return;
8270 }
8271 CurrStED = storyEditor;
8272 connect(storyEditor, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
8273 storyEditor->show();
8274 storyEditor->raise();
8275 }
8276
emergencySave()8277 void ScribusMainWindow::emergencySave()
8278 {
8279 emergencyActivated = true;
8280 if (!m_prefsManager.appPrefs.miscPrefs.saveEmergencyFile)
8281 return;
8282 std::cout << "Calling Emergency Save" << std::endl;
8283 QList<QMdiSubWindow *> windows = mdiArea->subWindowList();
8284 if (windows.isEmpty())
8285 return;
8286
8287 int windowCount = windows.count();
8288 for (int i = 0; i < windowCount; ++i)
8289 {
8290 ActWin = dynamic_cast<ScribusWin*>(windows.at(i)->widget());
8291 doc = ActWin->doc();
8292 view = ActWin->view();
8293 doc->autoSaveTimer->stop();
8294 doc->setMasterPageMode(false);
8295 doc->setModified(false);
8296 QString base = tr("Document");
8297 QString path = m_prefsManager.documentDir();
8298 QString fileName;
8299 if (doc->hasName)
8300 {
8301 QFileInfo fi(doc->documentFileName());
8302 base = fi.baseName();
8303 path = fi.absolutePath();
8304 }
8305 QDateTime dat = QDateTime::currentDateTime();
8306 if ((!doc->prefsData().docSetupPrefs.AutoSaveLocation) && (!doc->prefsData().docSetupPrefs.AutoSaveDir.isEmpty()))
8307 path = doc->prefsData().docSetupPrefs.AutoSaveDir;
8308 fileName = QDir::cleanPath(path + "/" + base + QString("_emergency_%1.sla").arg(dat.toString("dd_MM_yyyy_hh_mm")));
8309 std::cout << "Saving: " << fileName.toStdString() << std::endl;
8310 FileLoader fl(fileName);
8311 fl.saveFile(fileName, doc, nullptr);
8312 // ActWin->close() will trigger ScribusWin::closeEvent()
8313 // so no need to manually close view or delete doc
8314 ActWin->getSubWin()->close();
8315 }
8316 }
8317
EditTabs()8318 void ScribusMainWindow::EditTabs()
8319 {
8320 if (!HaveDoc || doc->m_Selection->isEmpty())
8321 return;
8322
8323 PageItem *currItem = doc->m_Selection->itemAt(0);
8324 TabManager *dia = new TabManager(this, doc->unitIndex(), currItem->itemText.defaultStyle().tabValues(), currItem->width());
8325 if (dia->exec())
8326 {
8327 ParagraphStyle newTabs(currItem->itemText.defaultStyle());
8328 newTabs.setTabValues(dia->tabList());
8329 currItem->itemText.setDefaultStyle(newTabs);
8330 currItem->update();
8331 slotDocCh();
8332 }
8333 delete dia;
8334 }
8335
SearchText()8336 void ScribusMainWindow::SearchText()
8337 {
8338 bool wasModeEdit = (doc->appMode == modeEdit);
8339
8340 PageItem *currItem = doc->m_Selection->itemAt(0);
8341 if (!wasModeEdit)
8342 {
8343 view->requestMode(modeEdit);
8344 currItem->itemText.setCursorPosition(0);
8345 }
8346
8347 SearchReplace* dia = new SearchReplace(this, doc, currItem);
8348 if (wasModeEdit)
8349 {
8350 QString selText = currItem->itemText.selectedText();
8351 if (!selText.isEmpty())
8352 dia->setSearchedText(selText);
8353 }
8354 dia->exec();
8355 dia->disconnect();
8356 delete dia;
8357 //slotSelect();
8358 }
8359
8360 /* call gimp and wait upon completion */
callImageEditor()8361 void ScribusMainWindow::callImageEditor()
8362 {
8363 if (doc->m_Selection->isEmpty())
8364 return;
8365
8366 //NOTE to reviewers: I added my code to this function,
8367 // - as it performs a similar function,
8368 // - when the frame is a latex frame it makes only sense
8369 // to run a latex editor
8370 // - IMHO ScribusMainWindow has way to many slots already
8371 // - my code here is short and without sideeffects
8372 PageItem *currItem = doc->m_Selection->itemAt(0);
8373 if (currItem->isLatexFrame())
8374 {
8375 currItem->asLatexFrame()->runEditor();
8376 return; //Don't process the functions for imageframes!
8377 }
8378 #ifdef HAVE_OSG
8379 if (currItem->isOSGFrame())
8380 {
8381 OSGEditorDialog *dia = new OSGEditorDialog(this, currItem->asOSGFrame(), m_osgFilterString);
8382 dia->exec();
8383 return;
8384 }
8385 #endif
8386 QString imageEditorExecutable=m_prefsManager.imageEditorExecutable();
8387 if (currItem->imageIsAvailable)
8388 {
8389 bool startFailed=false;
8390 #ifdef Q_OS_MACOS
8391 QString osxcmd(imageEditorExecutable);
8392 if (osxcmd.endsWith(".app"))
8393 osxcmd.prepend("open -a \"");
8394 else
8395 osxcmd.prepend("\"");
8396 osxcmd.append("\" \"");
8397 osxcmd.append(QDir::toNativeSeparators(currItem->Pfile));
8398 osxcmd.append("\"");
8399 if (!QProcess::startDetached(osxcmd))
8400 startFailed=true;
8401 #else
8402 QStringList cmd(QDir::toNativeSeparators(currItem->Pfile));
8403 if (!QProcess::startDetached(QDir::fromNativeSeparators(imageEditorExecutable), cmd))
8404 startFailed=true;
8405 #endif
8406 if (startFailed)
8407 ScMessageBox::critical(this, CommonStrings::trWarning, "<qt>" + tr("The program %1 is missing or failed to open").arg(imageEditorExecutable) + "</qt>");
8408 }
8409 }
8410
slotCharSelect()8411 void ScribusMainWindow::slotCharSelect()
8412 {
8413 charPalette->setVisible(scrActions["insertGlyph"]->isChecked());
8414 }
8415
setUndoMode(bool isObjectSpecific)8416 void ScribusMainWindow::setUndoMode(bool isObjectSpecific)
8417 {
8418 m_objectSpecificUndo = isObjectSpecific;
8419
8420 if (!m_objectSpecificUndo && HaveDoc)
8421 m_undoManager->showObject(Um::GLOBAL_UNDO_MODE);
8422 else if (HaveDoc)
8423 {
8424 int docSelectionCount = doc->m_Selection->count();
8425 if (docSelectionCount == 1)
8426 m_undoManager->showObject(doc->m_Selection->itemAt(0)->getUId());
8427 else if (docSelectionCount == 0)
8428 m_undoManager->showObject(doc->currentPage()->getUId());
8429 else
8430 m_undoManager->showObject(Um::NO_UNDO_STACK);
8431 }
8432 }
8433
isObjectSpecificUndo()8434 bool ScribusMainWindow::isObjectSpecificUndo()
8435 {
8436 return m_objectSpecificUndo;
8437 }
8438
getImageInfo()8439 void ScribusMainWindow::getImageInfo()
8440 {
8441 if ((!HaveDoc) || (doc->m_Selection->count() != 1))
8442 return;
8443
8444 PageItem *pageItem = doc->m_Selection->itemAt(0);
8445 if (pageItem == nullptr)
8446 return;
8447 if (pageItem->itemType() == PageItem::ImageFrame)
8448 {
8449 ImageInfoDialog *dia = new ImageInfoDialog(this, &pageItem->pixm.imgInfo);
8450 dia->exec();
8451 delete dia;
8452 }
8453 }
8454
objectAttributes()8455 void ScribusMainWindow::objectAttributes()
8456 {
8457 if ((!HaveDoc) || (doc->m_Selection->count() != 1))
8458 return;
8459
8460 PageItem *pageItem = doc->m_Selection->itemAt(0);
8461 if (pageItem == nullptr)
8462 return;
8463 PageItemAttributes *pageItemAttrs = new PageItemAttributes( this );
8464 pageItemAttrs->setup(pageItem->getObjectAttributes(), &doc->itemAttributes());
8465 //CB TODO Probably want this non modal in the future
8466 if (pageItemAttrs->exec() == QDialog::Accepted)
8467 pageItem->setObjectAttributes(pageItemAttrs->getNewAttributes());
8468 delete pageItemAttrs;
8469 }
8470
generateTableOfContents()8471 void ScribusMainWindow::generateTableOfContents()
8472 {
8473 if (HaveDoc)
8474 m_tocGenerator->generateDefault();
8475 }
8476
updateDocument()8477 void ScribusMainWindow::updateDocument()
8478 {
8479 if (!HaveDoc)
8480 return;
8481 doc->updateNumbers(true);
8482 doc->updateMarks(true);
8483 doc->regionsChanged()->update(QRect());
8484 emit UpdateRequest(reqNumUpdate);
8485 }
8486
insertSampleText()8487 void ScribusMainWindow::insertSampleText()
8488 {
8489 if (!HaveDoc)
8490 return;
8491 LoremManager loremMgr(doc, this);
8492 if (m_prefsManager.appPrefs.miscPrefs.useStandardLI)
8493 {
8494 loremMgr.insertLoremIpsum("la.xml", m_prefsManager.appPrefs.miscPrefs.paragraphsLI);
8495 return;
8496 }
8497
8498 if (loremMgr.exec())
8499 loremMgr.insertLoremIpsum(loremMgr.getName(), loremMgr.paragraphCount(), loremMgr.randomize());
8500 }
8501
iconSetChange()8502 void ScribusMainWindow::iconSetChange()
8503 {
8504 IconManager& iconManager = IconManager::instance();
8505
8506 setWindowIcon(iconManager.loadIcon("AppIcon.png"));
8507 setStyleSheet();
8508
8509 zoomDefaultToolbarButton->setIcon(iconManager.loadIcon("16/zoom-original.png"));
8510 zoomOutToolbarButton->setIcon(iconManager.loadIcon("16/zoom-out.png"));
8511 zoomInToolbarButton->setIcon(iconManager.loadIcon("16/zoom-in.png"));
8512 }
8513
languageChange()8514 void ScribusMainWindow::languageChange()
8515 {
8516 if (!ScCore->initialized())
8517 return;
8518
8519 //Update colours in case someone has a translated None colour in their preference settings
8520 //before changing the tr_NoneColor to the new value. See #9267, #5529
8521 m_prefsManager.languageChange();
8522 CommonStrings::languageChange();
8523 LanguageManager::instance()->languageChange();
8524 qApp->setLayoutDirection(QLocale(ScCore->getGuiLanguage()).textDirection());
8525 //Update actions
8526 if (actionManager != nullptr)
8527 {
8528 actionManager->languageChange();
8529 ScCore->pluginManager->languageChange();
8530 initKeyboardShortcuts();
8531 }
8532 //Update menu texts
8533 if (scrMenuMgr != nullptr && !scrMenuMgr->empty())
8534 scrMenuMgr->languageChange();
8535 if (m_undoManager != nullptr)
8536 m_undoManager->languageChange();
8537 statusBarLanguageChange();
8538 viewToolBar->languageChange();
8539 }
8540
localeChange()8541 void ScribusMainWindow::localeChange()
8542 {
8543 const QLocale& l(LocaleManager::instance().userPreferredLocale());
8544 zoomSpinBox->setLocale(l);
8545 mainWindowXPosDataLabel->setText(" ");
8546 mainWindowYPosDataLabel->setText(" ");
8547 }
8548
statusBarLanguageChange()8549 void ScribusMainWindow::statusBarLanguageChange()
8550 {
8551 zoomSpinBox->setToolTip( tr("Current zoom level"));
8552 zoomDefaultToolbarButton->setToolTip( tr("Zoom to 100%"));
8553 zoomOutToolbarButton->setToolTip( tr("Zoom out by the stepping value in Tools preferences"));
8554 zoomInToolbarButton->setToolTip( tr("Zoom in by the stepping value in Tools preferences"));
8555 layerMenu->setToolTip( tr("Select the current layer"));
8556 unitSwitcher->setToolTip( tr("Select the current unit"));
8557 mainWindowXPosLabel->setText( tr("X:"));
8558 mainWindowYPosLabel->setText( tr("Y:"));
8559 mainWindowXPosDataLabel->setText(" ");
8560 mainWindowYPosDataLabel->setText(" ");
8561 m_mainWindowStatusLabel->setText( tr("Ready"));
8562 }
8563
setDefaultPrinter(const QString & name,const QString & file,const QString & command)8564 void ScribusMainWindow::setDefaultPrinter(const QString& name, const QString& file, const QString& command)
8565 {
8566 PDef.Pname = name;
8567 PDef.Dname = file;
8568 PDef.Command = command;
8569 }
8570
getDefaultPrinter(QString & name,QString & file,QString & command)8571 void ScribusMainWindow::getDefaultPrinter(QString& name, QString& file, QString& command)
8572 {
8573 name = PDef.Pname;
8574 file = PDef.Dname;
8575 command = PDef.Command;
8576 }
8577
closeActiveWindowMasterPageEditor()8578 void ScribusMainWindow::closeActiveWindowMasterPageEditor()
8579 {
8580 if (!HaveDoc)
8581 return;
8582 if (!doc->masterPageMode())
8583 return;
8584 editMasterPagesEnd();
8585 qApp->processEvents();
8586 }
8587
updateActiveWindowCaption(const QString & newCaption)8588 void ScribusMainWindow::updateActiveWindowCaption(const QString &newCaption)
8589 {
8590 if (!HaveDoc)
8591 return;
8592 ActWin->setWindowTitle(QDir::toNativeSeparators(newCaption));
8593 }
8594
dragEnterEvent(QDragEnterEvent * e)8595 void ScribusMainWindow::dragEnterEvent ( QDragEnterEvent* e)
8596 {
8597 bool accepted = false;
8598 if ( e->mimeData()->hasFormat("text/uri-list"))
8599 {
8600 QString fileUrl;
8601 QList<QUrl> fileUrls = e->mimeData()->urls();
8602 for (int i = 0; i < fileUrls.count(); ++i)
8603 {
8604 fileUrl = fileUrls[i].toLocalFile().toLower();
8605 if (fileUrl.endsWith(".sla") || fileUrl.endsWith(".sla.gz") || fileUrl.endsWith(".shape") || fileUrl.endsWith(".sce"))
8606 {
8607 accepted = true;
8608 break;
8609 }
8610 QUrl url( fileUrls[i] );
8611 FileLoader *fileLoader = new FileLoader(url.path());
8612 int testResult = fileLoader->testFile();
8613 delete fileLoader;
8614 if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
8615 {
8616 accepted = true;
8617 break;
8618 }
8619 }
8620 }
8621 else if (e->mimeData()->hasText())
8622 {
8623 QString text = e->mimeData()->text();
8624 if ((text.startsWith("<SCRIBUSELEM")) || (text.startsWith("SCRIBUSELEMUTF8")))
8625 accepted = true;
8626 }
8627 if (accepted)
8628 e->accept();
8629 }
8630
dropEvent(QDropEvent * e)8631 void ScribusMainWindow::dropEvent ( QDropEvent * e)
8632 {
8633 bool accepted = false;
8634 if (e->mimeData()->hasFormat("text/uri-list"))
8635 {
8636 QString fileUrl;
8637 QList<QUrl> fileUrls = e->mimeData()->urls();
8638 for (int i = 0; i < fileUrls.count(); ++i)
8639 {
8640 fileUrl = fileUrls[i].toLocalFile().toLower();
8641 if (fileUrl.endsWith(".sla") || fileUrl.endsWith(".sla.gz"))
8642 {
8643 QUrl url( fileUrls[i] );
8644 QFileInfo fi(url.toLocalFile());
8645 if (fi.exists())
8646 {
8647 accepted = true;
8648 loadDoc( fi.absoluteFilePath() );
8649 }
8650 }
8651 else if (fileUrl.endsWith(".sce"))
8652 {
8653 QUrl url( fileUrls[i] );
8654 QFileInfo fi(url.toLocalFile());
8655 if (fi.exists())
8656 {
8657 accepted = true;
8658 QString data;
8659 QByteArray cf;
8660 loadRawText(url.toLocalFile(), cf);
8661 data = QString::fromUtf8(cf.data());
8662 double gx, gy, gw, gh;
8663 ScriXmlDoc ss;
8664 if (ss.readElemHeader(data, false, &gx, &gy, &gw, &gh))
8665 {
8666 doFileNew(gw, gh, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
8667 HaveNewDoc();
8668 doc->reformPages(true);
8669 slotElemRead(data, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, false, doc, view);
8670 slotDocCh(false);
8671 doc->regionsChanged()->update(QRectF());
8672 }
8673 }
8674 }
8675 else
8676 {
8677 QUrl url( fileUrls[i] );
8678 FileLoader *fileLoader = new FileLoader(url.toLocalFile());
8679 int testResult = fileLoader->testFile();
8680 delete fileLoader;
8681 if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
8682 {
8683 QFileInfo fi(url.toLocalFile());
8684 if (fi.exists())
8685 {
8686 accepted = true;
8687 loadDoc( fi.absoluteFilePath() );
8688 }
8689 }
8690 }
8691 }
8692 }
8693 else
8694 {
8695 if (e->mimeData()->hasText())
8696 {
8697 QString text = e->mimeData()->text();
8698 if ((text.startsWith("<SCRIBUSELEM")) || (text.startsWith("SCRIBUSELEMUTF8")))
8699 {
8700 double gx, gy, gw, gh;
8701 ScriXmlDoc ss;
8702 if (ss.readElemHeader(text, false, &gx, &gy, &gw, &gh))
8703 {
8704 doFileNew(gw, gh, 0, 0, 0, 0, 0, 0, false, false, 0, false, 0, 1, "Custom", true);
8705 HaveNewDoc();
8706 doc->reformPages(true);
8707 slotElemRead(text, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, false, doc, view);
8708 slotDocCh(false);
8709 doc->regionsChanged()->update(QRectF());
8710 }
8711 accepted = true;
8712 }
8713 }
8714 }
8715 if (accepted)
8716 e->accept();
8717 }
8718
slotEditCopyContents()8719 void ScribusMainWindow::slotEditCopyContents()
8720 {
8721 PageItem *currItem = nullptr;
8722 if (!HaveDoc || (currItem = doc->m_Selection->itemAt(0)) == nullptr)
8723 return;
8724 if (currItem->itemType() != PageItem::ImageFrame)
8725 return;
8726
8727 PageItem_ImageFrame* imageItem = currItem->asImageFrame();
8728 if (!imageItem->imageIsAvailable)
8729 return;
8730 contentsBuffer.contentsFileName.clear();
8731 contentsBuffer.sourceType = PageItem::ImageFrame;
8732 contentsBuffer.contentsFileName = imageItem->Pfile;
8733 contentsBuffer.LocalScX = imageItem->imageXScale();
8734 contentsBuffer.LocalScY = imageItem->imageYScale();
8735 contentsBuffer.LocalX = imageItem->imageXOffset();
8736 contentsBuffer.LocalY = imageItem->imageYOffset();
8737 contentsBuffer.LocalRot = imageItem->imageRotation();
8738 contentsBuffer.ItemX = imageItem->xPos();
8739 contentsBuffer.ItemY = imageItem->yPos();
8740 contentsBuffer.effects = imageItem->effectsInUse;
8741 contentsBuffer.inputProfile = imageItem->ImageProfile;
8742 contentsBuffer.useEmbedded = imageItem->UseEmbedded;
8743 contentsBuffer.renderingIntent = imageItem->ImageIntent;
8744 }
8745
slotEditPasteContents(int absolute)8746 void ScribusMainWindow::slotEditPasteContents(int absolute)
8747 {
8748 if (!HaveDoc || contentsBuffer.contentsFileName.isEmpty())
8749 return;
8750 PageItem *currItem = nullptr;
8751 if ((currItem = doc->m_Selection->itemAt(0)) == nullptr)
8752 return;
8753 if (contentsBuffer.sourceType != PageItem::ImageFrame || currItem->itemType() != PageItem::ImageFrame)
8754 return;
8755
8756 PageItem_ImageFrame* imageItem = currItem->asImageFrame();
8757 int i=QMessageBox::Yes;
8758 if (imageItem->imageIsAvailable)
8759 i = ScMessageBox::warning(this, CommonStrings::trWarning,
8760 tr("Do you really want to replace your existing image?"),
8761 QMessageBox::Yes | QMessageBox::No,
8762 QMessageBox::No, // GUI default
8763 QMessageBox::Yes); // batch default
8764 if (i != QMessageBox::Yes)
8765 return;
8766
8767 imageItem->pixm.imgInfo.isRequest = false;
8768 imageItem->EmbeddedProfile.clear();
8769 imageItem->ImageProfile = doc->cmsSettings().DefaultImageRGBProfile;
8770 imageItem->ImageIntent = doc->cmsSettings().DefaultIntentImages;
8771 imageItem->effectsInUse = contentsBuffer.effects;
8772 qApp->setOverrideCursor( QCursor(Qt::WaitCursor) );
8773 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
8774 doc->loadPict(contentsBuffer.contentsFileName, imageItem);
8775 imageItem->setImageXYScale(contentsBuffer.LocalScX, contentsBuffer.LocalScY);
8776 if (absolute == 0)
8777 imageItem->setImageXYOffset(contentsBuffer.LocalX, contentsBuffer.LocalY);
8778 else
8779 imageItem->setImageXYOffset(((contentsBuffer.ItemX - imageItem->xPos()) / contentsBuffer.LocalScX) + contentsBuffer.LocalX,
8780 ((contentsBuffer.ItemY - imageItem->yPos()) / contentsBuffer.LocalScY) + contentsBuffer.LocalY);
8781 imageItem->setImageRotation(contentsBuffer.LocalRot);
8782 imageItem->ImageProfile = contentsBuffer.inputProfile;
8783 imageItem->ImageIntent = contentsBuffer.renderingIntent;
8784 imageItem->UseEmbedded = contentsBuffer.useEmbedded;
8785 qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
8786 view->DrawNew();
8787 propertiesPalette->updateColorList();
8788 contentPalette->updateColorList();
8789 emit UpdateRequest(reqCmsOptionsUpdate);
8790 currItem->emitAllToGUI();
8791 qApp->restoreOverrideCursor();
8792 }
8793
slotInsertFrame()8794 void ScribusMainWindow::slotInsertFrame()
8795 {
8796 if (!HaveDoc)
8797 return;
8798
8799 view->requestMode(modeNormal);
8800 if (!doc->m_Selection->isEmpty())
8801 view->deselectItems(false);
8802
8803 InsertAFrame dia(this, doc);
8804 if (dia.exec())
8805 {
8806 InsertAFrameData iafData;
8807 dia.getNewFrameProperties(iafData);
8808 doc->itemAddUserFrame(iafData);
8809 }
8810 }
8811
slotItemTransform()8812 void ScribusMainWindow::slotItemTransform()
8813 {
8814 if (!HaveDoc)
8815 return;
8816 if (doc->m_Selection->isEmpty())
8817 return;
8818
8819 TransformDialog td(this, doc);
8820 if (td.exec() == 0)
8821 return;
8822 UndoTransaction trans;
8823 if (UndoManager::undoEnabled())
8824 trans = m_undoManager->beginTransaction(Um::Selection, Um::IPolygon, Um::Transform, QString(), Um::IMove);
8825 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
8826 int count=td.getCount();
8827 QTransform matrix(td.getTransformMatrix());
8828 int basepoint=td.getBasepoint();
8829 doc->itemSelection_Transform(count, matrix, basepoint);
8830 qApp->restoreOverrideCursor();
8831 if (trans)
8832 {
8833 trans.commit();
8834 }
8835 }
8836
PutToInline(const QString & buffer)8837 void ScribusMainWindow::PutToInline(const QString& buffer)
8838 {
8839 if (!HaveDoc)
8840 return;
8841 Selection tempSelection(*doc->m_Selection);
8842 bool savedAlignGrid = doc->SnapGrid;
8843 bool savedAlignGuides = doc->SnapGuides;
8844 bool savedAlignElement = doc->SnapElement;
8845 int ac = doc->Items->count();
8846 bool isGroup = false;
8847 double gx, gy, gh, gw;
8848 FPoint minSize = doc->minCanvasCoordinate;
8849 FPoint maxSize = doc->maxCanvasCoordinate;
8850 doc->SnapGrid = false;
8851 doc->SnapGuides = false;
8852 doc->SnapElement = false;
8853 m_undoManager->setUndoEnabled(false);
8854 slotElemRead(buffer, 0, 0, false, true, doc, view);
8855 doc->SnapGrid = savedAlignGrid;
8856 doc->SnapGuides = savedAlignGuides;
8857 doc->SnapElement = savedAlignElement;
8858 doc->m_Selection->clear();
8859 if (doc->Items->count() - ac > 1)
8860 isGroup = true;
8861 doc->m_Selection->delaySignalsOn();
8862 for (int as = ac; as < doc->Items->count(); ++as)
8863 {
8864 doc->m_Selection->addItem(doc->Items->at(as));
8865 }
8866 if (isGroup)
8867 doc->GroupCounter++;
8868 doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
8869 PageItem* currItem3 = doc->Items->at(ac);
8870 currItem3->isEmbedded = true;
8871 currItem3->setIsAnnotation(false);
8872 currItem3->isBookmark = false;
8873 currItem3->gXpos = currItem3->xPos() - gx;
8874 currItem3->gYpos = currItem3->yPos() - gy;
8875 currItem3->gWidth = gw;
8876 currItem3->gHeight = gh;
8877 doc->addToInlineFrames(currItem3);
8878 int acc = doc->Items->count();
8879 for (int as = ac; as < acc; ++as)
8880 {
8881 doc->Items->takeAt(ac);
8882 }
8883 doc->m_Selection->clear();
8884 doc->m_Selection->delaySignalsOff();
8885 *doc->m_Selection=tempSelection;
8886 doc->minCanvasCoordinate = minSize;
8887 doc->maxCanvasCoordinate = maxSize;
8888 m_undoManager->setUndoEnabled(true);
8889 inlinePalette->unsetDoc();
8890 inlinePalette->setDoc(doc);
8891 if (outlinePalette->isVisible())
8892 outlinePalette->BuildTree();
8893 view->deselectItems(false);
8894 }
8895
PutToInline()8896 void ScribusMainWindow::PutToInline()
8897 {
8898 if (!HaveDoc)
8899 return;
8900 Selection tempSelection(*doc->m_Selection);
8901 bool savedAlignGrid = doc->SnapGrid;
8902 bool savedAlignGuides = doc->SnapGuides;
8903 bool savedAlignElement = doc->SnapElement;
8904 int ac = doc->Items->count();
8905 bool isGroup = false;
8906 double gx, gy, gh, gw;
8907 FPoint minSize = doc->minCanvasCoordinate;
8908 FPoint maxSize = doc->maxCanvasCoordinate;
8909 doc->SnapGrid = false;
8910 doc->SnapGuides = false;
8911 doc->SnapElement = false;
8912 m_undoManager->setUndoEnabled(false);
8913 internalCopy = true;
8914 slotEditCopy();
8915 slotElemRead(internalCopyBuffer, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, true, doc, view);
8916 internalCopy = false;
8917 doc->SnapGrid = savedAlignGrid;
8918 doc->SnapGuides = savedAlignGuides;
8919 doc->SnapElement = savedAlignElement;
8920 doc->m_Selection->clear();
8921 if (doc->Items->count() - ac > 1)
8922 isGroup = true;
8923 doc->m_Selection->delaySignalsOn();
8924 for (int as = ac; as < doc->Items->count(); ++as)
8925 {
8926 doc->m_Selection->addItem(doc->Items->at(as));
8927 }
8928 if (isGroup)
8929 doc->GroupCounter++;
8930 doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
8931 PageItem* currItem3 = doc->Items->at(ac);
8932 currItem3->isEmbedded = true;
8933 currItem3->setIsAnnotation(false);
8934 currItem3->isBookmark = false;
8935 currItem3->gXpos = currItem3->xPos() - gx;
8936 currItem3->gYpos = currItem3->yPos() - gy;
8937 currItem3->gWidth = gw;
8938 currItem3->gHeight = gh;
8939 doc->addToInlineFrames(currItem3);
8940 int acc = doc->Items->count();
8941 for (int as = ac; as < acc; ++as)
8942 {
8943 doc->Items->takeAt(ac);
8944 }
8945 doc->m_Selection->clear();
8946 doc->m_Selection->delaySignalsOff();
8947 *doc->m_Selection=tempSelection;
8948 doc->minCanvasCoordinate = minSize;
8949 doc->maxCanvasCoordinate = maxSize;
8950 m_undoManager->setUndoEnabled(true);
8951 inlinePalette->unsetDoc();
8952 inlinePalette->setDoc(doc);
8953 if (outlinePalette->isVisible())
8954 outlinePalette->BuildTree();
8955 view->deselectItems(false);
8956 }
8957
PutToPatterns()8958 void ScribusMainWindow::PutToPatterns()
8959 {
8960 if (!HaveDoc)
8961 return;
8962
8963 QString patternName("Pattern_" + doc->m_Selection->itemAt(0)->itemName());
8964 patternName = patternName.trimmed().simplified().replace(" ", "_");
8965 patternName = doc->getUniquePatternName(patternName);
8966
8967 bool savedAlignGrid = doc->SnapGrid;
8968 bool savedAlignGuides = doc->SnapGuides;
8969 bool savedAlignElement = doc->SnapElement;
8970 int ac = doc->Items->count();
8971 FPoint minSize = doc->minCanvasCoordinate;
8972 FPoint maxSize = doc->maxCanvasCoordinate;
8973 doc->SnapGrid = false;
8974 doc->SnapGuides = false;
8975 doc->SnapElement = false;
8976 m_undoManager->setUndoEnabled(false);
8977 internalCopy = true;
8978 slotEditCopy();
8979 slotElemRead(internalCopyBuffer, doc->currentPage()->xOffset(), doc->currentPage()->yOffset(), false, true, doc, view);
8980 internalCopy = false;
8981 doc->SnapGrid = savedAlignGrid;
8982 doc->SnapGuides = savedAlignGuides;
8983 doc->SnapElement = savedAlignElement;
8984 doc->m_Selection->clear();
8985 view->deselectItems(true);
8986 PageItem* currItem;
8987 doc->m_Selection->delaySignalsOn();
8988 for (int as = ac; as < doc->Items->count(); ++as)
8989 {
8990 doc->m_Selection->addItem(doc->Items->at(as));
8991 }
8992 if (doc->Items->count() - ac > 1)
8993 currItem = doc->groupObjectsSelection(doc->m_Selection);
8994 else
8995 currItem = doc->m_Selection->itemAt(0);
8996 QList<PageItem*> allItems;
8997 if (currItem->isGroup())
8998 allItems = currItem->getAllChildren();
8999 else
9000 allItems.append(currItem);
9001 QStringList results;
9002 for (int ii = 0; ii < allItems.count(); ii++)
9003 {
9004 PageItem *item = allItems.at(ii);
9005 if ((!results.contains(item->pattern())) && ((item->GrType == Gradient_Pattern) || (item->itemType() == PageItem::Symbol)))
9006 results.append(item->pattern());
9007 if (!item->strokePattern().isEmpty())
9008 {
9009 if (!results.contains(item->strokePattern()))
9010 results.append(item->strokePattern());
9011 }
9012 if (!item->patternMask().isEmpty())
9013 {
9014 if (!results.contains(item->patternMask()))
9015 results.append(item->patternMask());
9016 }
9017 }
9018 patternsDependingOnThis.clear();
9019 QStringList mainPatterns = doc->docPatterns.keys();
9020 for (int i = 0; i < results.count(); i++)
9021 {
9022 QString temp(results[i]);
9023 for (int j = 0; j < mainPatterns.count(); j++)
9024 {
9025 if (mainPatterns[j] != temp)
9026 {
9027 QStringList subPatterns;
9028 subPatterns = doc->getUsedPatternsHelper(mainPatterns[j], subPatterns);
9029 if (subPatterns.contains(temp))
9030 patternsDependingOnThis.prepend(mainPatterns[j]);
9031 }
9032 }
9033 patternsDependingOnThis.prepend(temp);
9034 }
9035 allItems.clear();
9036
9037 Query dia(this, "tt", 1, tr("&Name:"), tr("New Entry"));
9038 dia.setEditText(patternName, true);
9039 dia.setForbiddenList(patternsDependingOnThis);
9040 dia.setTestList(doc->docPatterns.keys());
9041 dia.setCheckMode(true);
9042 if (dia.exec() != QDialog::Accepted)
9043 {
9044 doc->m_Selection->clear();
9045 doc->m_Selection->delaySignalsOff();
9046 doc->Items->removeAll(currItem);
9047 delete currItem;
9048 doc->minCanvasCoordinate = minSize;
9049 doc->maxCanvasCoordinate = maxSize;
9050 if (outlinePalette->isVisible())
9051 outlinePalette->BuildTree();
9052 m_undoManager->setUndoEnabled(true);
9053 return;
9054 }
9055 patternName = dia.getEditText();
9056
9057 ScPattern pat = ScPattern();
9058 pat.setDoc(doc);
9059 double minx = std::numeric_limits<double>::max();
9060 double miny = std::numeric_limits<double>::max();
9061 double maxx = -std::numeric_limits<double>::max();
9062 double maxy = -std::numeric_limits<double>::max();
9063 double x1, x2, y1, y2;
9064 currItem->getVisualBoundingRect(&x1, &y1, &x2, &y2);
9065 minx = qMin(minx, x1);
9066 miny = qMin(miny, y1);
9067 maxx = qMax(maxx, x2);
9068 maxy = qMax(maxy, y2);
9069 pat.pattern = currItem->DrawObj_toImage(qMin(qMax(maxx - minx, maxy - miny), 500.0));
9070 pat.width = maxx - minx;
9071 pat.height = maxy - miny;
9072 pat.items.append(currItem);
9073 // #11274 : OwnPage is not meaningful for pattern items
9074 // We set consequently pattern item's OwnPage to -1
9075 QList<PageItem*> patternItems = pat.items;
9076 while (patternItems.count() > 0)
9077 {
9078 PageItem* patItem = patternItems.takeAt(0);
9079 if (patItem->isGroup())
9080 patternItems += patItem->groupItemList;
9081 patItem->OwnPage = -1;
9082 }
9083 if (doc->docPatterns.contains(patternName))
9084 doc->docPatterns.remove(patternName);
9085 currItem->gXpos = currItem->xPos() - minx;
9086 currItem->gYpos = currItem->yPos() - miny;
9087 currItem->setXYPos(currItem->gXpos, currItem->gYpos, true);
9088 doc->addPattern(patternName, pat);
9089 doc->Items->removeAll(currItem);
9090 doc->m_Selection->clear();
9091 doc->m_Selection->delaySignalsOff();
9092 propertiesPalette->updateColorList();
9093 contentPalette->updateColorList();
9094 symbolPalette->updateSymbolList();
9095 emit UpdateRequest(reqColorsUpdate);
9096 doc->minCanvasCoordinate = minSize;
9097 doc->maxCanvasCoordinate = maxSize;
9098 view->DrawNew();
9099 if (outlinePalette->isVisible())
9100 outlinePalette->BuildTree();
9101 m_undoManager->setUndoEnabled(true);
9102 }
9103
ConvertToSymbol()9104 void ScribusMainWindow::ConvertToSymbol()
9105 {
9106 if (!HaveDoc)
9107 return;
9108 if (doc->m_Selection->isEmpty())
9109 return;
9110
9111 QString patternName("Pattern_" + doc->m_Selection->itemAt(0)->itemName());
9112 patternName = patternName.trimmed().simplified().replace(" ", "_");
9113 patternName = doc->getUniquePatternName(patternName);
9114
9115 Query dia(this, "tt", 1, tr("&Name:"), tr("New Entry"));
9116 dia.setEditText(patternName, true);
9117 patternsDependingOnThis.clear();
9118 dia.setForbiddenList(patternsDependingOnThis);
9119 dia.setTestList(doc->docPatterns.keys());
9120 dia.setCheckMode(true);
9121 if (!dia.exec())
9122 return;
9123 patternName = dia.getEditText();
9124 m_undoManager->setUndoEnabled(false);
9125 doc->itemSelection_convertItemsToSymbol(patternName);
9126 propertiesPalette->updateColorList();
9127 contentPalette->updateColorList();
9128 symbolPalette->updateSymbolList();
9129 emit UpdateRequest(reqColorsUpdate);
9130 if (outlinePalette->isVisible())
9131 outlinePalette->BuildTree();
9132 view->DrawNew();
9133 m_undoManager->setUndoEnabled(true);
9134 }
9135
manageColorsAndFills()9136 void ScribusMainWindow::manageColorsAndFills()
9137 {
9138 ColorList edc;
9139 QHash<QString, VGradient> *Gradients;
9140 QHash<QString, ScPattern> *docPatterns;
9141 ScribusDoc* tmpDoc;
9142 if (HaveDoc)
9143 {
9144 Gradients = &doc->docGradients;
9145 edc = doc->PageColors;
9146 docPatterns = &doc->docPatterns;
9147 tmpDoc = doc;
9148 }
9149 else
9150 {
9151 Gradients = &m_prefsManager.appPrefs.defaultGradients;
9152 edc = m_prefsManager.colorSet();
9153 docPatterns = &m_prefsManager.appPrefs.defaultPatterns;
9154 tmpDoc = m_doc;
9155 doc = m_doc;
9156 }
9157 m_undoManager->setUndoEnabled(false);
9158 ColorsAndFillsDialog *dia = new ColorsAndFillsDialog(this, Gradients, edc, m_prefsManager.colorSetName(), docPatterns, tmpDoc, this);
9159 if (dia->exec())
9160 {
9161 if (HaveDoc)
9162 {
9163 slotDocCh();
9164 doc->PageColors = dia->m_colorList;
9165 if (dia->replaceColorMap.isEmpty())
9166 {
9167 // invalidate all charstyles, as replaceNamedResources() won't do it if all maps are empty
9168 const StyleSet<CharStyle> dummy;
9169 doc->redefineCharStyles(dummy, false);
9170 }
9171 else
9172 {
9173 ResourceCollection colorrsc;
9174 colorrsc.mapColors(dia->replaceColorMap);
9175 // Update tools colors
9176 PrefsManager::replaceToolColors(doc->itemToolPrefs(), colorrsc.colors());
9177 // Update objects and styles colors
9178 doc->replaceNamedResources(colorrsc);
9179 // Temporary code until LineStyle is effectively used
9180 doc->replaceLineStyleColors(dia->replaceColorMap);
9181 }
9182 doc->setGradients(dia->dialogGradients);
9183 if (!dia->replaceMap.isEmpty())
9184 {
9185 ResourceCollection gradrsc;
9186 gradrsc.mapPatterns(dia->replaceMap);
9187 doc->replaceNamedResources(gradrsc);
9188 }
9189 doc->setPatterns(dia->dialogPatterns);
9190 if (!dia->replaceMapPatterns.isEmpty())
9191 {
9192 ResourceCollection colorrsc;
9193 colorrsc.mapPatterns(dia->replaceMapPatterns);
9194 doc->replaceNamedResources(colorrsc);
9195 }
9196 doc->recalculateColors();
9197 if (doc->useImageColorEffects())
9198 doc->recalcPicturesRes(ScribusDoc::RecalcPicRes_ImageWithColorEffectsOnly);
9199 symbolPalette->updateSymbolList();
9200 updateColorLists();
9201 if (!doc->m_Selection->isEmpty())
9202 doc->m_Selection->itemAt(0)->emitAllToGUI();
9203 view->DrawNew();
9204 }
9205 else
9206 {
9207 // Update tools colors if needed
9208 m_prefsManager.replaceToolColors(dia->replaceColorMap);
9209 m_prefsManager.setColorSet(dia->m_colorList);
9210 propertiesPalette->colorPalette->setColors(m_prefsManager.colorSet());
9211 m_prefsManager.appPrefs.defaultGradients = dia->dialogGradients;
9212 m_prefsManager.appPrefs.defaultPatterns = dia->dialogPatterns;
9213 QString Cpfad = QDir::toNativeSeparators(ScPaths::applicationDataDir())+"DefaultColors.xml";
9214 const FileFormat *fmt = LoadSavePlugin::getFormatById(FORMATID_SLA150EXPORT);
9215 if (fmt)
9216 {
9217 ScribusDoc *s_doc = new ScribusDoc();
9218 s_doc->setup(0, 1, 1, 1, 1, "Custom", "Custom");
9219 s_doc->setPage(100, 100, 0, 0, 0, 0, 0, 0, false, false);
9220 s_doc->addPage(0);
9221 s_doc->setGUI(false, this, nullptr);
9222 s_doc->PageColors = dia->m_colorList;
9223 s_doc->setGradients(dia->dialogGradients);
9224 s_doc->setPatterns(dia->dialogPatterns);
9225 fmt->setupTargets(s_doc, nullptr, this, mainWindowProgressBar, &(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts));
9226 fmt->savePalette(Cpfad);
9227 delete s_doc;
9228 }
9229 m_prefsManager.setColorSetName(dia->getColorSetName());
9230 doc = nullptr;
9231 }
9232 }
9233 if (!HaveDoc)
9234 doc = nullptr;
9235 delete dia;
9236 m_undoManager->setUndoEnabled(true);
9237 }
9238
slotReplaceColors()9239 void ScribusMainWindow::slotReplaceColors()
9240 {
9241 if (!HaveDoc)
9242 return;
9243
9244 ColorList UsedC;
9245 doc->getUsedColors(UsedC);
9246 QScopedPointer<replaceColorsDialog> dia2(new replaceColorsDialog(this, doc->PageColors, UsedC));
9247 if (!dia2->exec())
9248 return;
9249
9250 ResourceCollection colorrsc;
9251 colorrsc.mapColors(dia2->replaceMap);
9252 PrefsManager::replaceToolColors(doc->itemToolPrefs(), colorrsc.colors());
9253 doc->replaceNamedResources(colorrsc);
9254 doc->replaceLineStyleColors(dia2->replaceMap);
9255 doc->recalculateColors();
9256 if (doc->useImageColorEffects())
9257 doc->recalcPicturesRes(ScribusDoc::RecalcPicRes_ImageWithColorEffectsOnly);
9258 requestUpdate(reqColorsUpdate | reqLineStylesUpdate);
9259 m_styleManager->updateColorList();
9260 if (!doc->m_Selection->isEmpty())
9261 doc->m_Selection->itemAt(0)->emitAllToGUI();
9262 view->DrawNew();
9263 }
9264
updateGUIAfterPagesChanged()9265 void ScribusMainWindow::updateGUIAfterPagesChanged()
9266 {
9267 view->DrawNew();
9268 pagePalette->rebuildPages();
9269 if (outlinePalette->isVisible())
9270 outlinePalette->BuildTree();
9271 }
9272
updateTableMenuActions()9273 void ScribusMainWindow::updateTableMenuActions()
9274 {
9275 appModeHelper->updateTableMenuActions(doc);
9276 }
9277
insertMark(MarkType mType)9278 void ScribusMainWindow::insertMark(MarkType mType)
9279 {
9280 if (!HaveDoc)
9281 return;
9282 if (doc->m_Selection->count() != 1)
9283 return;
9284 if (doc->appMode != modeEdit)
9285 return;
9286
9287 PageItem* currItem = doc->m_Selection->itemAt(0);
9288 if (!currItem->isTextFrame())
9289 return;
9290
9291 UndoTransaction trans;
9292 if (UndoManager::undoEnabled())
9293 trans = m_undoManager->beginTransaction();
9294
9295 ScItemsState* is = nullptr;
9296 if (insertMarkDialog(currItem->asTextFrame(), mType, is))
9297 {
9298 Mark* mrk = currItem->itemText.mark(currItem->itemText.cursorPosition() -1);
9299 view->updatesOn(false);
9300 currItem->invalidateLayout();
9301 currItem->layout();
9302 if (mType == MARKNoteMasterType)
9303 {
9304 doc->setNotesChanged(true);
9305 if (mrk->getNotePtr()->isEndNote())
9306 doc->flag_updateEndNotes = true;
9307 doc->setCursor2MarkPos(mrk->getNotePtr()->noteMark());
9308 nsEditor->setNotesStyle(mrk->getNotePtr()->notesStyle());
9309 }
9310 doc->changed();
9311 if (is != nullptr)
9312 is->set("label", mrk->label);
9313 view->updatesOn(true);
9314 view->DrawNew();
9315 }
9316 if (trans)
9317 trans.commit();
9318 }
9319
slotEditMark()9320 void ScribusMainWindow::slotEditMark()
9321 {
9322 if (!HaveDoc)
9323 return;
9324 if (doc->m_Selection->count() != 1)
9325 return;
9326 if (doc->appMode != modeEdit)
9327 return;
9328 PageItem * currItem = doc->m_Selection->itemAt(0);
9329 if (currItem->itemText.cursorPosition() < currItem->itemText.length())
9330 {
9331 if (currItem->itemText.hasMark(currItem->itemText.cursorPosition()))
9332 {
9333 Mark* mark = currItem->itemText.mark(currItem->itemText.cursorPosition());
9334 if (editMarkDlg(mark, currItem->asTextFrame()))
9335 {
9336 if (mark->isType(MARKVariableTextType))
9337 doc->flag_updateMarksLabels = true;
9338 else
9339 currItem->invalid = true;
9340 //doc->updateMarks();
9341 doc->changed();
9342 doc->regionsChanged()->update(QRectF());
9343 view->DrawNew();
9344 }
9345 if (mark->isNoteType())
9346 nsEditor->setNotesStyle(mark->getNotePtr()->notesStyle());
9347 }
9348 }
9349 }
9350
slotUpdateMarks()9351 void ScribusMainWindow::slotUpdateMarks()
9352 {
9353 if (!HaveDoc)
9354 return;
9355 if (doc->marksList().isEmpty())
9356 return;
9357 if (doc->updateMarks(true))
9358 {
9359 doc->changed();
9360 doc->regionsChanged()->update(QRectF());
9361 }
9362 }
9363
slotInsertMarkNote()9364 void ScribusMainWindow::slotInsertMarkNote()
9365 {
9366 if (!HaveDoc)
9367 return;
9368 if (doc->m_docNotesStylesList.count() == 1)
9369 { //fast insert note with the only default notes style avaiable
9370 PageItem* currItem = doc->m_Selection->itemAt(0);
9371 Q_ASSERT(currItem->isTextFrame() && !currItem->isNoteFrame());
9372 UndoTransaction trans;
9373 if (currItem->HasSel)
9374 {
9375 if (UndoManager::undoEnabled())
9376 trans = m_undoManager->beginTransaction(Um::Selection, Um::IDelete, Um::Delete, QString(), Um::IDelete);
9377 //inserting mark replace some selected text
9378 currItem->asTextFrame()->deleteSelectedTextFromFrame();
9379 }
9380 NotesStyle* nStyle = doc->m_docNotesStylesList.at(0);
9381 QString label = "NoteMark_" + nStyle->name();
9382 if (nStyle->range() == NSRstory)
9383 label += " in " + currItem->firstInChain()->itemName();
9384 if (doc->getMark(label + "_1", MARKNoteMasterType) != nullptr)
9385 getUniqueName(label,doc->marksLabelsList(MARKNoteMasterType), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9386 else
9387 label = label + "_1";
9388 Mark* mrk = doc->newMark();
9389 mrk->label = label;
9390 mrk->setType(MARKNoteMasterType);
9391 mrk->setNotePtr(doc->newNote(nStyle));
9392 mrk->getNotePtr()->setMasterMark(mrk);
9393 mrk->clearString();
9394 mrk->OwnPage = currItem->OwnPage;
9395 currItem->itemText.insertMark(mrk);
9396 currItem->invalidateLayout();
9397 currItem->layout();
9398 if (mrk->getNotePtr()->isEndNote())
9399 doc->flag_updateEndNotes = true;
9400 doc->regionsChanged()->update(QRectF());
9401 doc->changed();
9402 doc->setCursor2MarkPos(mrk->getNotePtr()->noteMark());
9403 if (UndoManager::undoEnabled())
9404 {
9405 ScItemsState* is = new ScItemsState(UndoManager::InsertNote);
9406 is->set("ETEA", mrk->label);
9407 is->set("MARK", QString("new"));
9408 is->set("label", mrk->label);
9409 is->set("type", (int) MARKNoteMasterType);
9410 is->set("strtxt", QString());
9411 is->set("nStyle", nStyle->name());
9412 is->set("at", currItem->itemText.cursorPosition() -1);
9413 is->insertItem("inItem", currItem);
9414 m_undoManager->action(doc, is);
9415 }
9416 if (trans)
9417 trans.commit();
9418 }
9419 else
9420 insertMark(MARKNoteMasterType);
9421 }
9422
insertMarkDialog(PageItem_TextFrame * currItem,MarkType mrkType,ScItemsState * & is)9423 bool ScribusMainWindow::insertMarkDialog(PageItem_TextFrame* currItem, MarkType mrkType, ScItemsState* &is)
9424 {
9425 if (doc->masterPageMode() && (mrkType != MARKVariableTextType))
9426 //avoid inserting in master pages other marks than Variable Text
9427 return false;
9428
9429 QScopedPointer<MarkInsert> insertMDialog;
9430 switch (mrkType)
9431 {
9432 case MARKAnchorType:
9433 insertMDialog.reset((MarkInsert*) new MarkAnchor(this));
9434 break;
9435 case MARKVariableTextType:
9436 insertMDialog.reset((MarkInsert*) new MarkVariableText(doc->marksList(), this));
9437 break;
9438 case MARK2ItemType:
9439 insertMDialog.reset((MarkInsert*) new Mark2Item(this));
9440 break;
9441 case MARK2MarkType:
9442 insertMDialog.reset((MarkInsert*) new Mark2Mark(doc->marksList(), nullptr, this));
9443 break;
9444 case MARKNoteMasterType:
9445 insertMDialog.reset((MarkInsert*) new MarkNote(doc->m_docNotesStylesList, this));
9446 break;
9447 case MARKIndexType:
9448 break;
9449 default:
9450 break;
9451 }
9452 if (insertMDialog.isNull())
9453 {
9454 qDebug() << "Dialog not implemented for such marks type " << mrkType;
9455 return false;
9456 }
9457 bool docWasChanged = false;
9458
9459 insertMDialog->setWindowTitle(tr("Insert new ") + insertMDialog->windowTitle());
9460 if (insertMDialog->exec() != QDialog::Accepted)
9461 return false;
9462
9463 UndoTransaction trans;
9464 if (currItem->HasSel)
9465 {
9466 if (UndoManager::undoEnabled())
9467 trans = m_undoManager->beginTransaction(Um::Selection, Um::IDelete, Um::Delete, QString(), Um::IDelete);
9468 //inserting mark replace some selected text
9469 currItem->asTextFrame()->deleteSelectedTextFromFrame();
9470 }
9471
9472 Mark* mrk = nullptr;
9473 Mark oldMark;
9474 MarkData markdata;
9475 if (currItem != nullptr)
9476 markdata.itemName = currItem->itemName();
9477 QString label, text;
9478 NotesStyle* NStyle = nullptr;
9479 bool insertExistedMark = false;
9480 switch (mrkType)
9481 {
9482 case MARKAnchorType:
9483 //only gets label for new mark
9484 insertMDialog->values(label);
9485 if (label.isEmpty())
9486 label = tr("Anchor mark");
9487 markdata.itemPtr = currItem;
9488 break;
9489 case MARKVariableTextType:
9490 mrk = insertMDialog->values(label, text);
9491 if ((mrk == nullptr) && (text.isEmpty()))
9492 return false; //FIX ME here user should be warned that inserting of mark fails and why
9493 if (label.isEmpty())
9494 label = tr("Mark with <%1> variable text").arg(text);
9495 markdata.strtxt = text;
9496 break;
9497 case MARK2ItemType:
9498 insertMDialog->values(label, markdata.itemPtr);
9499 if (markdata.itemPtr == nullptr)
9500 return false; //FIX ME here user should be warned that inserting of mark fails and why
9501 if (label.isEmpty())
9502 label = tr("Mark to %1 item").arg(markdata.itemPtr->itemName());
9503 markdata.strtxt = QString::number(markdata.itemPtr->OwnPage +1);
9504 break;
9505 case MARK2MarkType:
9506 //gets pointer to referenced mark
9507 Mark* mrkPtr;
9508 insertMDialog->values(label, mrkPtr);
9509 if (mrkPtr == nullptr)
9510 return false; //FIX ME here user should be warned that inserting of mark fails and why
9511 if (label.isEmpty())
9512 label = tr("Mark to %1 mark").arg(mrkPtr->label);
9513 markdata.strtxt = QString::number(mrkPtr->OwnPage + 1);
9514 markdata.destmarkName = mrkPtr->label;
9515 markdata.destmarkType = mrkPtr->getType();
9516 break;
9517 case MARKNoteMasterType:
9518 //gets pointer to chosen notes style
9519 NStyle = insertMDialog->values();
9520 if (NStyle == nullptr)
9521 return false;
9522
9523 markdata.notePtr = doc->newNote(NStyle);
9524 label = "NoteMark_" + NStyle->name();
9525 if (NStyle->range() == NSRstory)
9526 label += " in " + currItem->firstInChain()->itemName();
9527 break;
9528 case MARKIndexType:
9529 return false;
9530 break;
9531 default:
9532 return false;
9533 break;
9534 }
9535
9536 if (mrk == nullptr)
9537 {
9538 //check if label for new mark can be used as is
9539 if (mrkType == MARKNoteMasterType)
9540 {
9541 if (doc->getMark(label + "_1", mrkType) != nullptr)
9542 getUniqueName(label, doc->marksLabelsList(mrkType), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9543 else
9544 label = label + "_1";
9545 }
9546 else
9547 getUniqueName(label, doc->marksLabelsList(mrkType), "_");
9548 mrk = doc->newMark();
9549 mrk->setValues(label, currItem->OwnPage, mrkType, markdata);
9550 }
9551 else
9552 { // that must be variable text mark
9553 oldMark = *mrk;
9554 mrk->setString(markdata.strtxt);
9555 mrk->label = label;
9556 insertExistedMark = true;
9557 doc->flag_updateMarksLabels = true;
9558 }
9559
9560 currItem->itemText.insertMark(mrk);
9561 mrk->OwnPage = currItem->OwnPage;
9562
9563 if (mrkType == MARKNoteMasterType)
9564 {
9565 mrk->getNotePtr()->setMasterMark(mrk);
9566 mrk->clearString();
9567 }
9568
9569 if (UndoManager::undoEnabled())
9570 {
9571 if (mrk->isType(MARKNoteMasterType))
9572 is = new ScItemsState(UndoManager::InsertNote);
9573 else if (insertExistedMark && ((oldMark.label != mrk->label) || (oldMark.getString() != mrk->getString())))
9574 is = new ScItemsState(UndoManager::EditMark);
9575 else
9576 is = new ScItemsState(UndoManager::InsertMark);
9577 is->set("ETEA", mrk->label);
9578 is->set("label", mrk->label);
9579 is->set("type", (int) mrk->getType());
9580 if (insertExistedMark)
9581 {
9582 is->set("MARK", QString("insert_existing"));
9583 if (mrk->label != oldMark.label)
9584 {
9585 is->set("labelOLD", oldMark.label);
9586 is->set("labelNEW", mrk->label);
9587 doc->flag_updateMarksLabels = true;
9588 }
9589 if (oldMark.getString() != mrk->getString())
9590 {
9591 is->set("strOLD", oldMark.getString());
9592 is->set("strNEW", mrk->getString());
9593 }
9594 }
9595 else
9596 {
9597 is->set("MARK", QString("new"));
9598 is->set("strtxt", mrk->getString());
9599 if (mrk->isType(MARK2MarkType))
9600 {
9601 QString dName;
9602 MarkType dType;
9603 mrk->getMark(dName, dType);
9604 is->set("dName", dName);
9605 is->set("dType", (int) dType);
9606 }
9607 if (mrk->isType(MARK2ItemType))
9608 is->insertItem("itemPtr", mrk->getItemPtr());
9609 if (mrk->isType(MARKNoteMasterType))
9610 is->set("nStyle", mrk->getNotePtr()->notesStyle()->name());
9611 }
9612 is->set("at", currItem->itemText.cursorPosition() -1);
9613 if (currItem->isNoteFrame())
9614 is->set("noteframeName", currItem->getUName());
9615 else
9616 is->insertItem("inItem", currItem);
9617 m_undoManager->action(doc, is);
9618 docWasChanged = true;
9619 }
9620
9621 if (trans)
9622 trans.commit();
9623 return docWasChanged;
9624 }
9625
editMarkDlg(Mark * mrk,PageItem_TextFrame * currItem)9626 bool ScribusMainWindow::editMarkDlg(Mark *mrk, PageItem_TextFrame* currItem)
9627 {
9628 MarkInsert* editMDialog = nullptr;
9629 switch (mrk->getType())
9630 {
9631 case MARKAnchorType:
9632 editMDialog = (MarkInsert*) new MarkAnchor(this);
9633 editMDialog->setValues(mrk->label);
9634 break;
9635 case MARKVariableTextType:
9636 if (currItem == nullptr)
9637 //invoked from Marks Manager
9638 editMDialog = dynamic_cast<MarkInsert*>(new MarkVariableText(mrk, this));
9639 else
9640 //invoked from mark`s entry in text
9641 editMDialog = dynamic_cast<MarkInsert*>(new MarkVariableText(doc->marksList(), this));
9642 editMDialog->setValues(mrk->label, mrk->getString());
9643 break;
9644 case MARK2ItemType:
9645 editMDialog = (MarkInsert*) new Mark2Item(this);
9646 editMDialog->setValues(mrk->label, mrk->getItemPtr());
9647 break;
9648 case MARK2MarkType:
9649 {
9650 editMDialog = (MarkInsert*) new Mark2Mark(doc->marksList(), mrk, this);
9651 QString l;
9652 MarkType t;
9653 mrk->getMark(l,t);
9654 Mark* m = doc->getMark(l,t);
9655 editMDialog->setValues(mrk->label, m);
9656 }
9657 break;
9658 case MARKNoteMasterType:
9659 {
9660 //invoking editing note mark from master text
9661 //so we go to edit note
9662 TextNote* note = mrk->getNotePtr();
9663 if (note == nullptr)
9664 {
9665 qFatal("ScribusMainWindow::editMarkDlg - found note master mark with null pointer to note");
9666 return false;
9667 }
9668 Mark* noteMark = note->noteMark();
9669 doc->setCursor2MarkPos(noteMark);
9670 }
9671 break;
9672 case MARKNoteFrameType:
9673 {
9674 //invoking editing mark from note frame
9675 //so we go to master text
9676 TextNote* note = mrk->getNotePtr();
9677 if (note == nullptr)
9678 {
9679 qFatal("ScribusMainWindow::editMarkDlg - found note frame mark with null pointer to note");
9680 return false;
9681 }
9682 Mark* masterMark = note->masterMark();
9683 doc->setCursor2MarkPos(masterMark);
9684 }
9685 break;
9686 case MARKIndexType:
9687 return false;
9688 break;
9689 default:
9690 break;
9691 }
9692 if (editMDialog == nullptr)
9693 return false;
9694
9695 bool docWasChanged = false;
9696
9697 editMDialog->setWindowTitle(tr("Edit %1").arg(editMDialog->windowTitle()));
9698 if (editMDialog->exec())
9699 {
9700 Mark oldMark = *mrk;
9701 Mark* Mrk = nullptr;
9702 MarkData markdata;
9703 if (currItem != nullptr)
9704 markdata.itemName = currItem->itemName();
9705 QString label, text;
9706 QString oldStr = mrk->getString();
9707 bool newMark = false;
9708 bool replaceMark = false;
9709 switch (mrk->getType())
9710 {
9711 case MARKAnchorType:
9712 //only gets label for new mark
9713 editMDialog->values(label);
9714 if (label.isEmpty())
9715 label = tr("Anchor mark");
9716 if (mrk->label != label)
9717 {
9718 getUniqueName(label,doc->marksLabelsList(mrk->getType()), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9719 mrk->label = label;
9720 emit UpdateRequest(reqMarksUpdate);
9721 }
9722 break;
9723 case MARKVariableTextType:
9724 Mrk = editMDialog->values(label, text);
9725 if (text.isEmpty())
9726 return false; //FIX ME here user should be warned that editing of mark fails and why
9727 if (label.isEmpty())
9728 label = tr("Mark with <%1> variable text").arg(text);
9729 if (Mrk != nullptr)
9730 {
9731 if (Mrk != mrk)
9732 {
9733 currItem->itemText.replaceMark(currItem->itemText.cursorPosition(), Mrk);
9734 mrk = Mrk;
9735 oldMark = *mrk;
9736 replaceMark = true;
9737 }
9738 if (mrk->label != label)
9739 {
9740 getUniqueName(label,doc->marksLabelsList(mrk->getType()), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9741 mrk->label = label;
9742 emit UpdateRequest(reqMarksUpdate);
9743 }
9744 if (text != oldStr)
9745 {
9746 mrk->setString(text);
9747 docWasChanged = true;
9748 }
9749 }
9750 else
9751 {
9752 markdata.strtxt = text;
9753 mrk = doc->newMark();
9754 getUniqueName(label,doc->marksLabelsList(mrk->getType()), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9755 mrk->setValues(label, currItem->OwnPage, MARKVariableTextType, markdata);
9756 currItem->itemText.replaceMark(currItem->itemText.cursorPosition(), mrk);
9757 docWasChanged = true;
9758 newMark = true;
9759 }
9760 break;
9761 case MARK2ItemType:
9762 editMDialog->values(label, markdata.itemPtr);
9763 if (markdata.itemPtr == nullptr)
9764 return false; //FIX ME here user should be warned that inserting of mark fails and why
9765 if (label.isEmpty())
9766 label = tr("Mark to %1 item").arg(markdata.itemPtr->itemName());
9767 if (markdata.itemPtr != mrk->getItemPtr())
9768 {
9769 mrk->setItemPtr(markdata.itemPtr);
9770 mrk->setString(doc->getSectionPageNumberForPageIndex(markdata.itemPtr->OwnPage));
9771 docWasChanged = true;
9772 }
9773 if (mrk->label != label)
9774 {
9775 getUniqueName(label,doc->marksLabelsList(mrk->getType()), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9776 mrk->label = label;
9777 }
9778 break;
9779 case MARK2MarkType:
9780 {
9781 //gets pointer to referenced mark
9782 Mark* mrkPtr = nullptr;
9783 editMDialog->values(label, mrkPtr);
9784 if (mrkPtr == nullptr)
9785 return false; //FIX ME here user should be warned that inserting of mark fails and why
9786 if (label.isEmpty())
9787 label = tr("Mark to %1 mark").arg(mrkPtr->label);
9788 QString destLabel = mrkPtr->label;
9789 MarkType destType = mrkPtr->getType();
9790 if (markdata.destmarkName != destLabel || markdata.destmarkType != destType)
9791 {
9792 mrk->setMark(mrkPtr);
9793 mrk->setString(doc->getSectionPageNumberForPageIndex(mrkPtr->OwnPage));
9794 docWasChanged = true;
9795 }
9796 if (mrk->label != label)
9797 {
9798 getUniqueName(label,doc->marksLabelsList(mrk->getType()), "_"); //FIX ME here user should be warned that inserted mark`s label was changed
9799 mrk->label = label;
9800 }
9801 }
9802 break;
9803 case MARKNoteMasterType:
9804 break;
9805 case MARKIndexType:
9806 break;
9807 default:
9808 break;
9809 }
9810 if (UndoManager::undoEnabled())
9811 {
9812 ScItemsState* is = nullptr;
9813 if (newMark || replaceMark)
9814 is = new ScItemsState(UndoManager::InsertMark);
9815 else
9816 is = new ScItemsState(UndoManager::EditMark);
9817 is->set("ETEA", mrk->label);
9818 if (currItem != nullptr)
9819 {
9820 is->set("at", currItem->itemText.cursorPosition()-1);
9821 if (currItem->isNoteFrame())
9822 is->set("noteframeName", currItem->getUName());
9823 else
9824 is->insertItem("inItem", currItem);
9825 }
9826 is->set("label", mrk->label);
9827 is->set("type", (int) mrk->getType());
9828 is->set("strtxt", mrk->getString());
9829 if (newMark)
9830 {
9831 is->set("MARK", QString("new"));
9832 if (mrk->isType(MARK2MarkType))
9833 {
9834 QString dName;
9835 MarkType dType;
9836 mrk->getMark(dName, dType);
9837 is->set("dName", dName);
9838 is->set("dType", (int) dType);
9839 }
9840 if (mrk->isType(MARK2ItemType))
9841 is->insertItem("itemPtr", mrk->getItemPtr());
9842 if (mrk->isType(MARKNoteMasterType))
9843 is->set("nStyle", mrk->getNotePtr()->notesStyle()->name());
9844 doc->flag_updateMarksLabels = true;
9845 }
9846 else
9847 {
9848 if (replaceMark)
9849 is->set("MARK", QString("replace"));
9850 else
9851 is->set("MARK", QString("edit"));
9852 if (mrk->label != oldMark.label)
9853 {
9854 is->set("labelOLD", oldMark.label);
9855 is->set("labelNEW", mrk->label);
9856 doc->flag_updateMarksLabels = true;
9857 }
9858 if (mrk->getString() != oldMark.getString())
9859 {
9860 is->set("strtxtOLD", oldMark.getString());
9861 is->set("strtxtNEW", mrk->getString());
9862 }
9863 if (mrk->isType(MARK2MarkType))
9864 {
9865 QString dNameOLD;
9866 MarkType dTypeOLD;
9867 oldMark.getMark(dNameOLD, dTypeOLD);
9868 QString dName;
9869 MarkType dType;
9870 mrk->getMark(dName, dType);
9871 if (dName != dNameOLD || dType != dTypeOLD)
9872 {
9873 is->set("dNameOLD", dNameOLD);
9874 is->set("dTypeOLD", (int) dTypeOLD);
9875 is->set("dNameNEW", dName);
9876 is->set("dTypeNEW", (int) dType);
9877 }
9878 }
9879 if (mrk->isType(MARK2ItemType) && mrk->getItemPtr() != oldMark.getItemPtr())
9880 {
9881 is->insertItem("itemPtrOLD", oldMark.getItemPtr());
9882 is->insertItem("itemPtrNEW", mrk->getItemPtr());
9883 }
9884 }
9885 m_undoManager->action(doc, is);
9886 }
9887 }
9888 delete editMDialog;
9889 return docWasChanged;
9890 }
9891
setPreviewToolbar()9892 void ScribusMainWindow::setPreviewToolbar()
9893 {
9894 modeToolBar->setEnabled(!doc->drawAsPreview);
9895 editToolBar->setEnabled(!doc->drawAsPreview);
9896 pdfToolBar->setEnabled(!doc->drawAsPreview);
9897 symbolPalette->setEnabled(!doc->drawAsPreview);
9898 inlinePalette->setEnabled(!doc->drawAsPreview);
9899 undoPalette->setEnabled(!doc->drawAsPreview);
9900 outlinePalette->setEnabled(!(doc->drawAsPreview && !doc->editOnPreview));
9901 propertiesPalette->setEnabled(!(doc->drawAsPreview && !doc->editOnPreview));
9902 contentPalette->setEnabled(!(doc->drawAsPreview && !doc->editOnPreview));
9903 scrMenuMgr->setMenuEnabled("Edit", !doc->drawAsPreview);
9904 scrMenuMgr->setMenuEnabled("Item", !doc->drawAsPreview);
9905 scrMenuMgr->setMenuEnabled("Insert", !doc->drawAsPreview);
9906 scrMenuMgr->setMenuEnabled("Page", !doc->drawAsPreview);
9907 scrMenuMgr->setMenuEnabled("Extras", !doc->drawAsPreview);
9908 HaveNewSel();
9909 }
9910
9911 /*
9912 void ScribusMainWindow::testQT_slot1(QString s)
9913 {
9914 qDebug()<<"Signal data:"<<s;
9915 }
9916
9917 void ScribusMainWindow::testQT_slot2(double d)
9918 {
9919 qDebug()<<"Signal data:"<<d;
9920 }
9921
9922 void ScribusMainWindow::testQT_slot3(int i)
9923 {
9924 qDebug()<<"Signal data:"<<i;
9925 }
9926
9927 void ScribusMainWindow::testQT_slot4()
9928 {
9929 qDebug()<<"Signal data empty but received";
9930 QObject *rootObject = dynamic_cast<QObject*>(m_qqview->rootObject());
9931 QObject *q_xSpinBox = rootObject->findChild<QObject*>("xSpinBox");
9932 //if (q_xSpinBox==sender())
9933 {
9934 qDebug()<<"qov"<<q_xSpinBox->property("value").toDouble();
9935 }
9936 m_qqview->close();
9937 m_qqview->deleteLater();
9938 }*/
9939
changePreviewQuality(int index)9940 void ScribusMainWindow::changePreviewQuality(int index)
9941 {
9942 if (!HaveDoc)
9943 return;
9944 doc->allItems_ChangePreviewResolution(index);
9945 doc->view()->DrawNew();
9946 }
9947