Rev 19689 |
Rev 19754 |
Go to most recent revision |
Blame |
Compare with Previous |
Last modification |
View Log
| RSS feed
/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/
/***************************************************************************
scribusdoc.cpp - description
-------------------
begin : Fre Apr 6 21:47:55 CEST 2001
copyright : (C) 2001 by Franz Schmid
email : Franz.Schmid@altmuehlnet.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include <memory>
#include <utility>
#include <sstream>
#include <QByteArray>
#include <QDebug>
#include <QDialog>
#include <QEventLoop>
#include <QFile>
#include <QList>
#include <QMessageBox>
#include <QPainter>
#include <QPixmap>
#include <QPointer>
#include <QProgressBar>
#include <QtAlgorithms>
#include <QTime>
//#include <qtconcurrentmap.h>
#include "actionmanager.h"
#include "appmodes.h"
#include "canvas.h"
#include "ui/masterpagepalette.h"
#include "colorblind.h"
#include "commonstrings.h"
#include "desaxe/digester.h"
#include "fileloader.h"
#include "filewatcher.h"
#include "fpoint.h"
#include "ui/guidemanager.h"
#include "ui/outlinepalette.h"
#include "hyphenator.h"
#include "ui/inserttablecolumnsdialog.h"
#include "ui/inserttablerowsdialog.h"
#include "notesstyles.h"
#include "numeration.h"
#include "ui/notesstyleseditor.h"
#include "pageitem.h"
#include "pageitem_imageframe.h"
#include "pageitem_latexframe.h"
#include "pageitem_line.h"
#include "pageitem_noteframe.h"
#include "pageitem_pathtext.h"
#include "pageitem_polygon.h"
#include "pageitem_polyline.h"
#include "pageitem_table.h"
#include "pageitem_textframe.h"
#ifdef HAVE_OSG
#include "pageitem_osgframe.h"
#endif
#include "colormgmt/sccolormgmtenginefactory.h"
#include "pageitem_arc.h"
#include "pageitem_group.h"
#include "pageitem_regularpolygon.h"
#include "pageitem_spiral.h"
#include "pageitem_symbol.h"
#include "pagesize.h"
#include "pagestructs.h"
#include "prefsfile.h"
#include "prefsmanager.h"
#include "resourcecollection.h"
#include "scclocale.h"
#include "sccolorengine.h"
#include "sclimits.h"
#include "scpage.h"
#include "scpainter.h"
#include "scraction.h"
#include "scribusXml.h"
#include "scribuscore.h"
#include "scribusdoc.h"
#include "scribusview.h"
#include "scribuswin.h"
#include "selection.h"
#include "serializer.h"
#include "tableborder.h"
#include "ui/hruler.h"
#include "ui/layers.h"
#include "ui/mark2item.h"
#include "ui/mark2mark.h"
#include "ui/markanchor.h"
#include "ui/markinsert.h"
#include "ui/marksmanager.h"
#include "ui/markvariabletext.h"
#include "ui/pagepalette.h"
#include "ui/storyeditor.h"
#include "ui/tablecolumnwidthsdialog.h"
#include "ui/tablerowheightsdialog.h"
#include "undomanager.h"
#include "units.h"
#include "util.h"
#include "util_icon.h"
#include "util_math.h"
// static const bool FRAMESELECTION_EDITS_DEFAULTSTYLE = false;
/**
This class forwards change events for pages and pageitems to
the region occupied by this page or pageitem.
*/
class DocUpdater : public Observer<ScPage*>, public Observer<PageItem*>
{
ScribusDoc* doc;
int m_updateEnabled;
bool m_docChangeNeeded;
public:
DocUpdater(ScribusDoc* d) : doc(d), m_updateEnabled(0), m_docChangeNeeded(false) {}
bool inUpdateSession() const
{
return m_updateEnabled > 0;
}
void beginUpdate(void)
{
if (m_updateEnabled == 0)
m_docChangeNeeded = false;
++m_updateEnabled;
}
void endUpdate(void)
{
--m_updateEnabled;
if (m_updateEnabled <= 0)
{
if (m_docChangeNeeded)
{
doc->changed();
m_docChangeNeeded = false;
}
}
}
void changed(ScPage* pg, bool /*doLayout*/)
{
QRectF pagebox(pg->xOffset(), pg->yOffset(), pg->width(), pg->height());
doc->invalidateRegion(pagebox);
doc->regionsChanged()->update(pagebox);
if (m_updateEnabled <= 0)
{
doc->changed();
return;
}
m_docChangeNeeded = true;
}
void changed(PageItem* it, bool doLayout)
{
it->invalidateLayout();
if (doLayout)
it->layout();
double x, y, w, h;
QTransform t = it->getCombinedTransform();
w = it->visualWidth();
h = it->visualHeight();
x = -it->visualLineWidth() / 2.0;
y = -it->visualLineWidth() / 2.0;
QRectF upRect = t.mapRect(QRectF(x, y, w, h));
doc->regionsChanged()->update(upRect);
if (m_updateEnabled <= 0)
{
doc->changed();
return;
}
m_docChangeNeeded = true;
}
void setDocChangeNeeded(bool changeNeeded = true)
{
m_docChangeNeeded = changeNeeded;
}
};
ScribusDoc::ScribusDoc() : UndoObject( tr("Document")), Observable<ScribusDoc>(NULL),
m_hasGUI(false),
docFilePermissions(QFileDevice::ReadOwner|QFileDevice::WriteOwner),
appPrefsData(PrefsManager::instance()->appPrefs),
docPrefsData(PrefsManager::instance()->appPrefs),
undoManager(UndoManager::instance()),
loading(false),
modified(false),
ActiveLayer(0),
rotMode(0),
automaticTextFrames(0),
m_masterPageMode(false),
m_symbolEditMode(false),
m_inlineEditMode(false),
m_ScMW(0),
m_View(0),
m_guardedObject(this),
m_serializer(NULL),
m_tserializer(NULL),
is12doc(false),
NrItems(0),
First(1), Last(0),
viewCount(0), viewID(0),
SnapGrid(false),
SnapGuides(true),
SnapElement(false), GuideLock(false),
minCanvasCoordinate(FPoint(0, 0)),
rulerXoffset(0.0), rulerYoffset(0.0),
Pages(0), MasterPages(), DocPages(),
MasterNames(),
Items(0), MasterItems(), DocItems(), FrameItems(),
m_Selection(new Selection(this, true)),
PageSp(1), PageSpa(0),
FirstPnum(1),
PageColors(this, true),
appMode(modeNormal),
SubMode(-1),
ShapeValues(0),
ValCount(0),
DocName( tr("Document")+"-"),
UsedFonts(),
AllFonts(&appPrefsData.fontPrefs.AvailFonts),
AObjects(),
CurrentSel(-1),
nodeEdit(),
LastAuto(0), FirstAuto(0),
DraggedElem(0),
ElemToLink(0),
DragElements(),
docParagraphStyles(),
docCharStyles(),
docTableStyles(),
docCellStyles(),
Layers(),
GroupCounter(1),
colorEngine(ScCore->defaultEngine),
JavaScripts(),
TotalItems(0),
RePos(false),
BookMarks(),
OldBM(false),
hasName(false),
isConverted(false),
autoSaveTimer(new QTimer(this)),
MLineStyles(),
WinHan(0),
DoDrawing(true),
OpenNodes(),
CurTimer(0),
pageErrors(),
docLayerErrors(),
docItemErrors(),
masterItemErrors(),
symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
docHyphenator(0),
m_itemCreationTransaction(NULL),
m_alignTransaction(NULL),
m_currentPage(NULL),
m_updateManager(),
m_docUpdater(NULL),
flag_notesChanged(false),
flag_restartMarksRenumbering(false),
flag_updateMarksLabels(false),
flag_updateEndNotes(false),
flag_layoutNotesFrames(true),
flag_Renumber(false),
flag_NumUpdateRequest(false)
{
docUnitRatio=unitGetRatioFromIndex(docPrefsData.docSetupPrefs.docUnitIndex);
docPrefsData.docSetupPrefs.pageHeight=0;
docPrefsData.docSetupPrefs.pageWidth=0;
docPrefsData.docSetupPrefs.pagePositioning=0;
maxCanvasCoordinate=(FPoint(docPrefsData.displayPrefs.scratch.Left + docPrefsData.displayPrefs.scratch.Right, docPrefsData.displayPrefs.scratch.Top + docPrefsData.displayPrefs.scratch.Bottom)),
init();
docPrefsData.pdfPrefs.bleeds = docPrefsData.docSetupPrefs.bleeds;
docPrefsData.pdfPrefs.useDocBleeds = true;
Print_Options.firstUse = true;
drawAsPreview = false;
viewAsPreview = false;
editOnPreview = false;
previewVisual = 0;
dontResize = false;
//create default numeration
NumStruct * numS = new NumStruct;
numS->m_name = "default";
Numeration newNum;
numS->m_nums.insert(0, newNum);
numS->m_counters.insert(0, 0);
numS->m_lastlevel = -1;
numerations.insert("default", numS);
currentEditedTextframe = NULL;
}
ScribusDoc::ScribusDoc(const QString& docName, int unitindex, const PageSize& pagesize, const MarginStruct& margins, const DocPagesSetup& pagesSetup) : UndoObject( tr("Document")),
m_hasGUI(false),
docFilePermissions(QFileDevice::ReadOwner|QFileDevice::WriteOwner),
appPrefsData(PrefsManager::instance()->appPrefs),
docPrefsData(PrefsManager::instance()->appPrefs),
undoManager(UndoManager::instance()),
loading(false),
modified(false),
ActiveLayer(0),
docUnitRatio(unitGetRatioFromIndex(appPrefsData.docSetupPrefs.docUnitIndex)),
rotMode(0),
automaticTextFrames(pagesSetup.autoTextFrames),
m_masterPageMode(false),
m_symbolEditMode(false),
m_inlineEditMode(false),
m_ScMW(0),
m_View(0),
m_guardedObject(this),
m_serializer(NULL),
m_tserializer(NULL),
is12doc(false),
NrItems(0),
First(1), Last(0),
viewCount(0), viewID(0),
SnapGrid(false),
SnapGuides(true),
SnapElement(false),
GuideLock(false),
minCanvasCoordinate(FPoint(0, 0)),
rulerXoffset(0.0), rulerYoffset(0.0),
Pages(0), MasterPages(), DocPages(),
MasterNames(),
Items(0), MasterItems(), DocItems(), FrameItems(),
m_Selection(new Selection(this, true)),
PageSp(pagesSetup.columnCount), PageSpa(pagesSetup.columnDistance),
FirstPnum(pagesSetup.firstPageNumber),
PageColors(this, true),
appMode(modeNormal),
SubMode(-1),
ShapeValues(0),
ValCount(0),
DocName(docName),
UsedFonts(),
AllFonts(&appPrefsData.fontPrefs.AvailFonts),
AObjects(),
CurrentSel(-1),
nodeEdit(),
LastAuto(0), FirstAuto(0),
DraggedElem(0),
ElemToLink(0),
DragElements(),
docParagraphStyles(),
docCharStyles(),
docTableStyles(),
docCellStyles(),
Layers(),
GroupCounter(1),
colorEngine(ScCore->defaultEngine),
JavaScripts(),
TotalItems(0),
RePos(false),
BookMarks(),
OldBM(false),
hasName(false),
isConverted(false),
autoSaveTimer(new QTimer(this)),
MLineStyles(),
WinHan(0),
DoDrawing(true),
OpenNodes(),
CurTimer(0),
pageErrors(),
docLayerErrors(),
docItemErrors(),
masterItemErrors(),
symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
docHyphenator(0),
m_itemCreationTransaction(NULL),
m_alignTransaction(NULL),
m_currentPage(NULL),
m_updateManager(),
m_docUpdater(NULL),
flag_notesChanged(false),
flag_restartMarksRenumbering(false),
flag_updateMarksLabels(false),
flag_updateEndNotes(false),
flag_layoutNotesFrames(true),
flag_Renumber(false),
flag_NumUpdateRequest(false)
{
docPrefsData.docSetupPrefs.docUnitIndex=unitindex;
docPrefsData.docSetupPrefs.pageHeight=pagesize.height();
docPrefsData.docSetupPrefs.pageWidth=pagesize.width();
docPrefsData.docSetupPrefs.pageSize=pagesize.name();
docPrefsData.docSetupPrefs.margins=margins;
maxCanvasCoordinate=(FPoint(docPrefsData.displayPrefs.scratch.Left + docPrefsData.displayPrefs.scratch.Right, docPrefsData.displayPrefs.scratch.Top + docPrefsData.displayPrefs.scratch.Bottom)),
setPageSetFirstPage(pagesSetup.pageArrangement, pagesSetup.firstPageLocation);
init();
docPrefsData.pdfPrefs.bleeds = docPrefsData.docSetupPrefs.bleeds;
docPrefsData.pdfPrefs.useDocBleeds = true;
docPrefsData.docSetupPrefs.pageOrientation=pagesSetup.orientation;
docPrefsData.docSetupPrefs.pagePositioning=pagesSetup.pageArrangement;
Print_Options.firstUse = true;
drawAsPreview = false;
viewAsPreview = false;
editOnPreview = false;
previewVisual = 0;
dontResize = false;
currentEditedTextframe = NULL;
}
void ScribusDoc::init()
{
Q_CHECK_PTR(m_Selection);
Q_CHECK_PTR(autoSaveTimer);
HasCMS = false;
docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
colorEngine = ScCore->defaultEngine;
SetDefaultCMSParams();
// init update change management
setUpdateManager(&m_updateManager);
m_itemsChanged.setUpdateManager(&m_updateManager);
m_pagesChanged.setUpdateManager(&m_updateManager);
m_regionsChanged.setUpdateManager(&m_updateManager);
nodeEdit.setUpdateManager(&m_updateManager);
// setup update() event chains
m_docUpdater = new DocUpdater(this);
m_itemsChanged.connectObserver(m_docUpdater);
m_pagesChanged.connectObserver(m_docUpdater);
PrefsManager *prefsManager = PrefsManager::instance();
docPrefsData.colorPrefs.DCMSset = prefsManager->appPrefs.colorPrefs.DCMSset;
docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
docPrefsData.pdfPrefs.Intent = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
AddFont(appPrefsData.itemToolPrefs.textFont);//, prefsData.AvailFonts[prefsData.itemToolPrefs.textFont]->Font);
//FIXME: aren't we doing this now anyway with prefs struct copy?
docPrefsData.itemToolPrefs.textFont = appPrefsData.itemToolPrefs.textFont;
docPrefsData.itemToolPrefs.textSize = appPrefsData.itemToolPrefs.textSize;
docPrefsData.itemToolPrefs.textTabFillChar = appPrefsData.itemToolPrefs.textTabFillChar;
docPrefsData.opToolPrefs.dispX = appPrefsData.opToolPrefs.dispX;
docPrefsData.opToolPrefs.dispY = appPrefsData.opToolPrefs.dispY;
docPrefsData.opToolPrefs.constrain = appPrefsData.opToolPrefs.constrain;
PageColors.ensureDefaultColors();
if (appPrefsData.itemToolPrefs.shapeLineColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.shapeLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeLineColor]);
docPrefsData.itemToolPrefs.shapeLineColor = appPrefsData.itemToolPrefs.shapeLineColor;
if (appPrefsData.itemToolPrefs.lineColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.lineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.lineColor]);
docPrefsData.itemToolPrefs.lineColor = appPrefsData.itemToolPrefs.lineColor;
if (appPrefsData.itemToolPrefs.textColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.textColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textColor]);
docPrefsData.itemToolPrefs.textColor = appPrefsData.itemToolPrefs.textColor;
if (appPrefsData.itemToolPrefs.textStrokeColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.textStrokeColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textStrokeColor]);
docPrefsData.itemToolPrefs.textStrokeColor = appPrefsData.itemToolPrefs.textStrokeColor;
if (appPrefsData.itemToolPrefs.shapeFillColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.shapeFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeFillColor]);
docPrefsData.itemToolPrefs.shapeFillColor = appPrefsData.itemToolPrefs.shapeFillColor;
if (appPrefsData.itemToolPrefs.imageFillColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.imageFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.imageFillColor]);
docPrefsData.itemToolPrefs.imageFillColor = appPrefsData.itemToolPrefs.imageFillColor;
if (appPrefsData.itemToolPrefs.imageStrokeColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.imageStrokeColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.imageStrokeColor]);
docPrefsData.itemToolPrefs.imageStrokeColor = appPrefsData.itemToolPrefs.imageStrokeColor;
if (appPrefsData.itemToolPrefs.textFillColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.textFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textFillColor]);
docPrefsData.itemToolPrefs.textFillColor = appPrefsData.itemToolPrefs.textFillColor;
if (appPrefsData.itemToolPrefs.textLineColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.textLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textLineColor]);
if (appPrefsData.itemToolPrefs.calligraphicPenFillColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.calligraphicPenFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligraphicPenFillColor]);
if (appPrefsData.itemToolPrefs.calligraphicPenLineColor != CommonStrings::None)
PageColors.insert(appPrefsData.itemToolPrefs.calligraphicPenLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligraphicPenLineColor]);
ParagraphStyle pstyle;
pstyle.setDefaultStyle(true);
pstyle.setName(CommonStrings::DefaultParagraphStyle);
pstyle.setLineSpacingMode(ParagraphStyle::FixedLineSpacing);
pstyle.setLineSpacing(15);
pstyle.setAlignment(ParagraphStyle::Leftaligned);
pstyle.setLeftMargin(0);
pstyle.setFirstIndent(0);
pstyle.setRightMargin(0);
pstyle.setGapBefore(0);
pstyle.setGapAfter(0);
pstyle.setHasDropCap(false);
pstyle.setHasBullet(false);
pstyle.setHasNum(false);
pstyle.setDropCapLines(2);
pstyle.setParEffectOffset(0);
pstyle.charStyle().setParent("");
CharStyle cstyle;
cstyle.setDefaultStyle(true);
cstyle.setName(CommonStrings::DefaultCharacterStyle);
cstyle.setFont(appPrefsData.fontPrefs.AvailFonts[docPrefsData.itemToolPrefs.textFont]);
cstyle.setFontSize(docPrefsData.itemToolPrefs.textSize);
cstyle.setFeatures(QStringList(CharStyle::INHERIT));
cstyle.setFillColor(docPrefsData.itemToolPrefs.textColor);
cstyle.setFillShade(docPrefsData.itemToolPrefs.textShade);
cstyle.setStrokeColor(docPrefsData.itemToolPrefs.textStrokeColor);
cstyle.setStrokeShade(docPrefsData.itemToolPrefs.textStrokeShade);
cstyle.setBaselineOffset(0);
cstyle.setShadowXOffset(50);
cstyle.setShadowYOffset(-50);
cstyle.setOutlineWidth(10);
cstyle.setUnderlineOffset(docPrefsData.typoPrefs.valueUnderlinePos);
cstyle.setUnderlineWidth(docPrefsData.typoPrefs.valueUnderlineWidth);
cstyle.setStrikethruOffset(docPrefsData.typoPrefs.valueStrikeThruPos);
cstyle.setStrikethruWidth(docPrefsData.typoPrefs.valueStrikeThruPos);
cstyle.setScaleH(1000);
cstyle.setScaleV(1000);
cstyle.setTracking(0);
cstyle.setLanguage(PrefsManager::instance()->appPrefs.hyphPrefs.Language);
docParagraphStyles.create(pstyle);
docParagraphStyles.makeDefault( &(docParagraphStyles[0]) );
docCharStyles.create(cstyle);
docCharStyles.makeDefault( &(docCharStyles[0]) );
docParagraphStyles[0].breakImplicitCharStyleInheritance();
docParagraphStyles[0].charStyle().setContext( & docCharStyles );
// docParagraphStyles[0].charStyle().setName( "cdocdefault" ); // DONT TRANSLATE
currentStyle = pstyle;
// Create default table style.
// TODO: We should have preferences for the default values.
TableStyle defaultTableStyle;
defaultTableStyle.setDefaultStyle(true);
defaultTableStyle.setName(CommonStrings::DefaultTableStyle);
defaultTableStyle.setFillColor(CommonStrings::None);
defaultTableStyle.setFillShade(100);
defaultTableStyle.setLeftBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultTableStyle.setRightBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultTableStyle.setTopBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultTableStyle.setBottomBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
docTableStyles.create(defaultTableStyle);
docTableStyles.makeDefault(&(docTableStyles[0]));
// Create default table cell style.
// TODO: We should have preferences for the default values.
CellStyle defaultCellStyle;
defaultCellStyle.setDefaultStyle(true);
defaultCellStyle.setName(CommonStrings::DefaultCellStyle);
defaultCellStyle.setFillColor(CommonStrings::None);
defaultCellStyle.setFillShade(100);
defaultCellStyle.setLeftBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultCellStyle.setRightBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultCellStyle.setTopBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultCellStyle.setBottomBorder(TableBorder(1.0, Qt::SolidLine, "Black", 100));
defaultCellStyle.setLeftPadding(1.0);
defaultCellStyle.setRightPadding(1.0);
defaultCellStyle.setTopPadding(1.0);
defaultCellStyle.setBottomPadding(1.0);
docCellStyles.create(defaultCellStyle);
docCellStyles.makeDefault(&(docCellStyles[0]));
Layers.addLayer( tr("Background") );
// FIXME: Check PDF version input
//TODO: Check if this is needed now we ue appPrefsData --> docPrefsData
pdfOptions().Version = (PDFOptions::PDFVersion)appPrefsData.pdfPrefs.Version;
pdfOptions().firstUse = true;
docPatterns.clear();
docGradients.clear();
if (autoSave() && ScCore->usingGUI())
autoSaveTimer->start(autoSaveTime());
//Do this after all the collections have been created and cleared!
m_masterPageMode=true; // quick hack to force the change of pointers in setMasterPageMode();
setMasterPageMode(false);
addSymbols();
//for loading old documents where default notes style is not saved
if (m_docNotesStylesList.isEmpty())
m_docNotesStylesList.append(new NotesStyle());
}
ScribusDoc::~ScribusDoc()
{
m_guardedObject.nullify();
CloseCMSProfiles();
ScCore->fileWatcher->stop();
ScCore->fileWatcher->removeFile(DocName);
QList<PageItem*> allItems;
for (int a = 0; a < DocItems.count(); ++a)
{
PageItem *currItem = DocItems.at(a);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->PictureIsAvailable)
ScCore->fileWatcher->removeFile(currItem->Pfile);
if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
{
QFileInfo fi(currItem->Pfile);
ScCore->fileWatcher->removeDir(fi.absolutePath());
}
}
allItems.clear();
}
for (int a = 0; a < MasterItems.count(); ++a)
{
PageItem *currItem = MasterItems.at(a);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->PictureIsAvailable)
ScCore->fileWatcher->removeFile(currItem->Pfile);
if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
{
QFileInfo fi(currItem->Pfile);
ScCore->fileWatcher->removeDir(fi.absolutePath());
}
}
allItems.clear();
}
for (QHash<int, PageItem*>::iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
{
PageItem *currItem = itf.value();
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->PictureIsAvailable)
ScCore->fileWatcher->removeFile(currItem->Pfile);
if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
{
QFileInfo fi(currItem->Pfile);
ScCore->fileWatcher->removeDir(fi.absolutePath());
}
}
allItems.clear();
}
QStringList patterns = docPatterns.keys();
for (int c = 0; c < patterns.count(); ++c)
{
ScPattern pa = docPatterns[patterns[c]];
for (int o = 0; o < pa.items.count(); o++)
{
PageItem *currItem = pa.items.at(o);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->itemType() == PageItem::ImageFrame)
{
if ((currItem->PictureIsAvailable) && (!currItem->Pfile.isEmpty()))
{
ScCore->fileWatcher->removeFile(currItem->Pfile);
QFileInfo fi(currItem->Pfile);
ScCore->fileWatcher->removeDir(fi.absolutePath());
}
}
}
allItems.clear();
}
while (!pa.items.isEmpty())
{
delete pa.items.takeFirst();
}
}
//deleting resources alocated for marks and notes
while (! m_docNotesList.isEmpty())
delete m_docNotesList.takeFirst();
while (!m_docMarksList.isEmpty())
delete m_docMarksList.takeFirst();
while (! m_docNotesStylesList.isEmpty())
delete m_docNotesStylesList.takeFirst();
docPatterns.clear();
docGradients.clear();
foreach (NumStruct* ns, numerations.values())
delete ns;
numerations.clear();
while (!DocItems.isEmpty())
{
delete DocItems.takeFirst();
}
QList<PageItem*> tmList = FrameItems.values();
while (!tmList.isEmpty())
{
delete tmList.takeFirst();
}
FrameItems.clear();
while (!MasterPages.isEmpty())
{
delete MasterPages.takeFirst();
}
while (!DocPages.isEmpty())
{
delete DocPages.takeFirst();
}
while (!MasterItems.isEmpty())
{
delete MasterItems.takeFirst();
}
QMap<QString,int>::Iterator it3;
for (it3 = UsedFonts.begin(); it3 != UsedFonts.end(); ++it3)
{
if (!(*AllFonts)[it3.key()].localForDocument().isEmpty())
(*AllFonts).removeFont(it3.key());
else
(*AllFonts)[it3.key()].decreaseUsage();
}
if (docHyphenator)
delete docHyphenator;
if (m_serializer)
delete m_serializer;
if (m_tserializer)
delete m_tserializer;
ScCore->fileWatcher->start();
}
bool ScribusDoc::inAnEditMode() const
{
bool inEditMode = (appMode == modeEdit ||
appMode == modeEditTable ||
appMode == modeEditSpiral ||
appMode == modeEditGradientVectors ||
appMode == modeEditClip ||
appMode == modeEditMeshGradient ||
appMode == modeEditArc ||
appMode == modeEditMeshPatch ||
appMode == modeEditWeldPoint ||
appMode == modeEditPolygon ||
appMode == modeDrawBezierLine
) ? true : false;
return inEditMode;
}
QList<PageItem*> ScribusDoc::getAllItems(QList<PageItem*> &items)
{
QList<PageItem*> ret;
for (int em = 0; em < items.count(); ++em)
{
PageItem* embedded = items.at(em);
ret.append(embedded);
if (embedded->isGroup())
ret += embedded->asGroupFrame()->getItemList();
}
return ret;
}
QList<PageItem*> *ScribusDoc::parentGroup(PageItem* item, QList<PageItem*> *list)
{
QList<PageItem*> *retList = NULL;
if (list->contains(item))
retList = list;
else
{
for (int a = 0; a < list->count(); ++a)
{
PageItem* embedded = list->at(a);
if (embedded->isGroup())
{
retList = parentGroup(item, &embedded->asGroupFrame()->groupItemList);
if (retList != NULL)
break;
}
}
}
return retList;
}
void ScribusDoc::setup(const int unitIndex, const int fp, const int firstLeft, const int orientation, const int firstPageNumber, const QString& defaultPageSize, const QString& documentName)
{
docPrefsData.docSetupPrefs.docUnitIndex=unitIndex;
setPageSetFirstPage(fp, firstLeft);
docPrefsData.docSetupPrefs.pageOrientation = orientation;
docPrefsData.docSetupPrefs.pageSize = defaultPageSize;
FirstPnum = firstPageNumber;
docPrefsData.docSetupPrefs.pagePositioning = fp;
setName(documentName);
HasCMS = false;
if (!pdfOptions().UseLPI)
{
pdfOptions().LPISettings.clear();
struct LPIData lpo;
lpo.Frequency = 133;
lpo.SpotFunc = 3;
lpo.Angle = 105;
pdfOptions().LPISettings.insert("Cyan", lpo);
lpo.Angle = 75;
pdfOptions().LPISettings.insert("Magenta", lpo);
lpo.Angle = 90;
pdfOptions().LPISettings.insert("Yellow", lpo);
lpo.Angle = 45;
pdfOptions().LPISettings.insert("Black", lpo);
ActiveLayer = 0;
}
appMode = modeNormal;
PrefsManager *prefsManager=PrefsManager::instance();
docPrefsData.colorPrefs.DCMSset = prefsManager->appPrefs.colorPrefs.DCMSset;
docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
docPrefsData.pdfPrefs.Intent = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
BlackPoint = docPrefsData.colorPrefs.DCMSset.BlackPoint;
SoftProofing = docPrefsData.colorPrefs.DCMSset.SoftProofOn;
Gamut = docPrefsData.colorPrefs.DCMSset.GamutCheck;
IntentColors = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
IntentImages = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
if (ScCore->haveCMS() && docPrefsData.colorPrefs.DCMSset.CMSinUse)
{
if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles))
{
HasCMS = true;
pdfOptions().SComp = docPrefsData.colorPrefs.DCMSset.ComponentsInput2;
}
else
{
SetDefaultCMSParams();
HasCMS = false;
}
}
}
void ScribusDoc::setGUI(bool hasgui, ScribusMainWindow* mw, ScribusView* view)
{
m_hasGUI = hasgui;
m_ScMW = mw;
//FIXME: stop using m_View
m_View = view;
if (m_hasGUI)
{
docHyphenator = new Hyphenator(m_ScMW, this);
Q_CHECK_PTR(docHyphenator);
}
else
docHyphenator = NULL;
}
void ScribusDoc::setLoading(const bool docLoading)
{
loading = docLoading;
}
bool ScribusDoc::isLoading() const
{
return loading;
}
//AV: eeks. That should not be used
ScribusView* ScribusDoc::view() const
{
// return (WinHan ? (((ScribusWin*) WinHan)->view()) : 0);
return m_View;
}
const ScGuardedPtr<ScribusDoc>& ScribusDoc::guardedPtr() const
{
return m_guardedObject;
}
void ScribusDoc::CloseCMSProfiles()
{
HasCMS = false;
SetDefaultCMSParams();
}
void ScribusDoc::SetDefaultCMSParams()
{
BlackPoint = true;
SoftProofing = false;
Gamut = false;
IntentColors = Intent_Relative_Colorimetric;
IntentImages = Intent_Relative_Colorimetric;
DocInputRGBProf = ScCore->defaultRGBProfile;
DocInputCMYKProf = ScCore->defaultCMYKProfile;
DocInputImageRGBProf = ScCore->defaultRGBProfile;
DocInputImageCMYKProf = ScCore->defaultCMYKProfile;
DocDisplayProf = ScCore->defaultRGBProfile;
DocPrinterProf = ScCore->defaultCMYKProfile;
stdTransRGBMon = ScCore->defaultRGBToScreenSolidTrans;
stdTransCMYKMon = ScCore->defaultCMYKToRGBTrans;
stdTransRGB = ScCore->defaultCMYKToRGBTrans;
stdTransCMYK = ScCore->defaultRGBToCMYKTrans;
stdProof = ScCore->defaultRGBToScreenSolidTrans;
stdProofGC = ScCore->defaultRGBToScreenSolidTrans;
stdProofCMYK = ScCore->defaultCMYKToRGBTrans;
stdProofCMYKGC = ScCore->defaultCMYKToRGBTrans;
stdTransImg = ScCore->defaultRGBToScreenImageTrans;
stdProofImg = ScCore->defaultRGBToScreenImageTrans;
stdProofImgCMYK = ScCore->defaultCMYKToScreenImageTrans;
}
bool ScribusDoc::OpenCMSProfiles(ProfilesL InPo, ProfilesL InPoCMYK, ProfilesL MoPo, ProfilesL PrPo)
{
HasCMS = false;
ScColorProfile inputProf;
colorEngine = colorMgmtEngineFactory.createDefaultEngine();
ScColorMgmtStrategy colorStrategy;
colorStrategy.useBlackPointCompensation = docPrefsData.colorPrefs.DCMSset.BlackPoint;
colorStrategy.useBlackPreservation = false;
colorEngine.setStrategy(colorStrategy);
DocDisplayProf = ScCore->monitorProfile;
DocInputRGBProf = colorEngine.openProfileFromFile( InPo[docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile] );
DocInputCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[docPrefsData.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile] );
DocPrinterProf = colorEngine.openProfileFromFile( PrPo[docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile] );
DocInputImageRGBProf = colorEngine.openProfileFromFile( InPo[docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile] );
DocInputImageCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[docPrefsData.colorPrefs.DCMSset.DefaultImageCMYKProfile] );
if ((!DocDisplayProf) || (!DocInputRGBProf) || (!DocInputCMYKProf) || (!DocPrinterProf) || (!DocInputImageCMYKProf) || (!DocInputImageRGBProf))
{
docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
return false;
}
int dcmsFlags = 0;
int dcmsFlagsGC = 0;
if (docPrefsData.colorPrefs.DCMSset.GamutCheck)
dcmsFlagsGC |= Ctf_GamutCheck;
if (docPrefsData.colorPrefs.DCMSset.BlackPoint)
{
dcmsFlags |= Ctf_BlackPointCompensation;
dcmsFlagsGC |= Ctf_BlackPointCompensation;
}
stdTransRGBMon = colorEngine.createTransform(DocInputRGBProf, Format_RGB_16,
DocDisplayProf, Format_RGB_16,
IntentColors, dcmsFlags);
stdTransCMYKMon = colorEngine.createTransform(DocInputCMYKProf, Format_CMYK_16,
DocDisplayProf, Format_RGB_16,
IntentColors, dcmsFlags);
// TODO : check input profiles used for images
stdProofImg = colorEngine.createProofingTransform(DocInputImageRGBProf, Format_BGRA_8,
DocDisplayProf, Format_BGRA_8, DocPrinterProf,
IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
stdProofImgCMYK = colorEngine.createProofingTransform(DocInputImageCMYKProf, Format_CMYK_8,
DocDisplayProf, Format_BGRA_8, DocPrinterProf,
IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
stdTransImg = colorEngine.createTransform(DocInputRGBProf, Format_BGRA_8,
DocDisplayProf, Format_BGRA_8,
IntentImages, dcmsFlags);
stdTransRGB = colorEngine.createTransform(DocInputCMYKProf, Format_CMYK_16,
DocInputRGBProf, Format_RGB_16,
IntentColors, dcmsFlags);
stdTransCMYK = colorEngine.createTransform(DocInputRGBProf, Format_RGB_16,
DocInputCMYKProf, Format_CMYK_16,
IntentColors, dcmsFlags);
ScColorProfile inputProfRGB;
ScColorProfile inputProfCMYK;
if (DocPrinterProf.colorSpace() == ColorSpace_Cmyk)
{
inputProf = (docPrefsData.colorPrefs.DCMSset.SoftProofOn && docPrefsData.colorPrefs.DCMSset.SoftProofFullOn) ? DocInputCMYKProf : DocPrinterProf;
inputProfRGB = DocInputRGBProf;
inputProfCMYK = inputProf;
}
else
{
inputProf = (docPrefsData.colorPrefs.DCMSset.SoftProofOn && docPrefsData.colorPrefs.DCMSset.SoftProofFullOn) ? DocInputRGBProf : DocPrinterProf;
inputProfRGB = inputProf;
inputProfCMYK = DocInputCMYKProf;
}
stdProof = colorEngine.createProofingTransform(inputProfRGB, Format_RGB_16,
DocDisplayProf, Format_RGB_16,
DocPrinterProf,
IntentColors,
Intent_Relative_Colorimetric, dcmsFlags);
stdProofGC = colorEngine.createProofingTransform(inputProfRGB, Format_RGB_16,
DocDisplayProf, Format_RGB_16,
DocPrinterProf, IntentColors,
Intent_Relative_Colorimetric, dcmsFlags| Ctf_GamutCheck);
stdProofCMYK = colorEngine.createProofingTransform(inputProfCMYK, Format_CMYK_16,
DocDisplayProf, Format_RGB_16,
DocPrinterProf, IntentColors,
Intent_Relative_Colorimetric, dcmsFlags);
stdProofCMYKGC = colorEngine.createProofingTransform(inputProfCMYK, Format_CMYK_16,
DocDisplayProf, Format_RGB_16,
DocPrinterProf,
IntentColors,
Intent_Relative_Colorimetric, dcmsFlags | Ctf_GamutCheck);
if (DocInputRGBProf.colorSpace() == ColorSpace_Rgb)
docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 3;
if (DocInputRGBProf.colorSpace() == ColorSpace_Cmyk)
docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 4;
if (DocInputRGBProf.colorSpace() == ColorSpace_Cmy)
docPrefsData.colorPrefs.DCMSset.ComponentsInput2 = 3;
bool success = (stdTransRGBMon && stdTransCMYKMon && stdProofImg && stdProofImgCMYK &&
stdTransImg && stdTransRGB && stdTransCMYK && stdProof &&
stdProofGC && stdProofCMYK && stdProofCMYKGC);
if (!success)
{
CloseCMSProfiles();
docPrefsData.colorPrefs.DCMSset.CMSinUse = false;
QString message = tr("An error occurred while opening ICC profiles, color management is not enabled." );
ScMessageBox::warning(m_ScMW, CommonStrings::trWarning, message);
}
return true;
}
void ScribusDoc::enableCMS(bool enable)
{
m_ScMW->setStatusBarInfoText( tr("Adjusting Colors"));
m_ScMW->mainWindowProgressBar->reset();
int cc = PageColors.count() + MasterItems.count() + DocItems.count() + FrameItems.count();
m_ScMW->mainWindowProgressBar->setMaximum(cc);
qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
bool oldCM = docPrefsData.colorPrefs.DCMSset.CMSinUse;
bool newCM = enable;
CloseCMSProfiles();
docPrefsData.colorPrefs.DCMSset.CMSinUse = newCM;
HasCMS = docPrefsData.colorPrefs.DCMSset.CMSinUse;
BlackPoint = docPrefsData.colorPrefs.DCMSset.BlackPoint;
SoftProofing = docPrefsData.colorPrefs.DCMSset.SoftProofOn;
Gamut = docPrefsData.colorPrefs.DCMSset.GamutCheck;
IntentColors = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
IntentImages = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
if (!docPrefsData.colorPrefs.DCMSset.CMSinUse)
{
HasCMS = false;
if (oldCM)
{
m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
}
}
else if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles) )
{
HasCMS = true;
docPrefsData.pdfPrefs.SComp = docPrefsData.colorPrefs.DCMSset.ComponentsInput2;
docPrefsData.pdfPrefs.SolidProf = docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile;
docPrefsData.pdfPrefs.ImageProf = docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile;
docPrefsData.pdfPrefs.PrintProf = docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile;
docPrefsData.pdfPrefs.Intent = docPrefsData.colorPrefs.DCMSset.DefaultIntentColors;
docPrefsData.pdfPrefs.Intent2 = docPrefsData.colorPrefs.DCMSset.DefaultIntentImages;
m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
}
else
{
SetDefaultCMSParams();
HasCMS = false;
}
m_ScMW->mainWindowProgressBar->setValue(cc);
qApp->restoreOverrideCursor();
m_ScMW->setStatusBarInfoText("");
m_ScMW->mainWindowProgressBar->reset();
}
void ScribusDoc::getNamedResources(ResourceCollection& lists) const
{
lists.availableFonts = AllFonts;
lists.availableColors = const_cast<ColorList*>(& PageColors);
const QList<PageItem*> * itemlist = & MasterItems;
while (itemlist != NULL)
{
for (int i=0; i < itemlist->count(); ++i)
{
const PageItem * currItem = const_cast<QList<PageItem*>*>(itemlist)->at(i);
if (currItem)
currItem->getNamedResources(lists);
}
if (itemlist == &MasterItems)
itemlist = &DocItems;
else
itemlist = NULL;
}
for (QHash<int, PageItem*>::const_iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
{
PageItem *currItem = itf.value();
if (currItem)
currItem->getNamedResources(lists);
}
for (int i = 0; i < docParagraphStyles.count(); ++i)
docParagraphStyles[i].getNamedResources(lists);
for (int i = 0; i < docCharStyles.count(); ++i)
docCharStyles[i].getNamedResources(lists);
for (int i = 0; i < docTableStyles.count(); ++i)
docTableStyles[i].getNamedResources(lists);
for (int i = 0; i < docCellStyles.count(); ++i)
docCellStyles[i].getNamedResources(lists);
// for (uint i = 0; i < docLineStyles.count(); ++i)
// docLineStyles[i].getNamedResources(lists);
QHash<QString,ScPattern>::ConstIterator it;
for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
{
ScPattern pa = *it;
for (int o = 0; o < pa.items.count(); o++)
{
pa.items.at(o)->getNamedResources(lists);
}
}
QHash<QString,VGradient>::ConstIterator itg;
for (itg = docGradients.begin(); itg != docGradients.end(); ++itg)
{
QList<VColorStop*> cstops = itg.value().colorStops();
for (uint cst = 0; cst < itg.value().Stops(); ++cst)
{
lists.collectColor(cstops.at(cst)->name);
}
}
}
bool ScribusDoc::styleExists(QString styleName)
{
for (int i = 0; i < paragraphStyles().count(); ++i)
{
if (paragraphStyles()[i].name() == styleName)
return true;
}
return false;
}
QList<int> ScribusDoc::getSortedStyleList()
{
QList<int> retList;
for (int i = 0; i < docParagraphStyles.count(); ++i)
{
if (docParagraphStyles[i].parent().isEmpty())
{
if (!retList.contains(i))
retList.append(i);
continue;
}
QList<int> retList2;
QString name = docParagraphStyles[i].name();
QString par = docParagraphStyles[i].parent();
retList2.prepend(i);
while ((!par.isEmpty()) && (par != name))
{
int pp = docParagraphStyles.find(par);
if ((pp >= 0) && (!retList2.contains(pp)))
retList2.prepend(pp);
par = (pp >= 0) ? docParagraphStyles[pp].parent() : QString();
}
for (int r = 0; r < retList2.count(); ++r)
{
if (!retList.contains(retList2[r]))
retList.append(retList2[r]);
}
}
return retList;
}
QList<int> ScribusDoc::getSortedCharStyleList()
{
QList<int> retList;
for (int i = 0; i < docCharStyles.count(); ++i)
{
if (docCharStyles[i].parent().isEmpty())
{
if (!retList.contains(i))
retList.append(i);
continue;
}
QList<int> retList2;
QString name = docCharStyles[i].name();
QString par = docCharStyles[i].parent();
retList2.prepend(i);
while ((!par.isEmpty()) && (par != name))
{
int pp = docCharStyles.find(par);
if ((pp >= 0) && (!retList2.contains(pp)))
retList2.prepend(pp);
par = (pp >= 0) ? docCharStyles[pp].parent() : QString();
}
for (int r = 0; r < retList2.count(); ++r)
{
if (!retList.contains(retList2[r]))
retList.append(retList2[r]);
}
}
return retList;
}
QList<int> ScribusDoc::getSortedTableStyleList()
{
QList<int> retList;
for (int i = 0; i < docTableStyles.count(); ++i)
{
if (docTableStyles[i].parent().isEmpty())
{
if (!retList.contains(i))
retList.append(i);
continue;
}
QList<int> retList2;
QString name = docTableStyles[i].name();
QString par = docTableStyles[i].parent();
retList2.prepend(i);
while ((!par.isEmpty()) && (par != name))
{
int pp = docTableStyles.find(par);
if ((pp >= 0) && (!retList2.contains(pp)))
retList2.prepend(pp);
par = (pp >= 0) ? docTableStyles[pp].parent() : QString();
}
for (int r = 0; r < retList2.count(); ++r)
{
if (!retList.contains(retList2[r]))
retList.append(retList2[r]);
}
}
return retList;
}
QList<int> ScribusDoc::getSortedCellStyleList()
{
QList<int> retList;
for (int i = 0; i < docCellStyles.count(); ++i)
{
if (docCellStyles[i].parent().isEmpty())
{
if (!retList.contains(i))
retList.append(i);
continue;
}
QList<int> retList2;
QString name = docCellStyles[i].name();
QString par = docCellStyles[i].parent();
retList2.prepend(i);
while ((!par.isEmpty()) && (par != name))
{
int pp = docCellStyles.find(par);
if ((pp >= 0) && (!retList2.contains(pp)))
retList2.prepend(pp);
par = (pp >= 0) ? docCellStyles[pp].parent() : QString();
}
for (int r = 0; r < retList2.count(); ++r)
{
if (!retList.contains(retList2[r]))
retList.append(retList2[r]);
}
}
return retList;
}
void ScribusDoc::replaceStyles(const QMap<QString,QString>& newNameForOld)
{
ResourceCollection newNames;
newNames.mapStyles(newNameForOld);
replaceNamedResources(newNames);
}
void ScribusDoc::replaceNamedResources(ResourceCollection& newNames)
{
// replace names in items
//#ifndef QT_NO_CONCURRENT
// QtConcurrent::blockingMap(DocItems, ResMapped(newNames));
// QtConcurrent::blockingMap(MasterItems, ResMapped(newNames));
//#else
QList<PageItem*> * itemlist = & MasterItems;
while (itemlist != NULL)
{
for (int i=0; i < itemlist->count(); ++i)
{
PageItem * currItem = itemlist->at(i);
if (currItem)
currItem->replaceNamedResources(newNames);
}
if (itemlist == &MasterItems)
itemlist = &DocItems;
else
itemlist = NULL;
}
//#endif
foreach (NotesStyle* nStyle, m_docNotesStylesList)
{ //update styles names in notes styles
if (nStyle == NULL)
continue;
if (newNames.styles().contains(nStyle->notesParStyle()))
nStyle->setNotesParStyle(newNames.styles().value(nStyle->notesParStyle()));
if (newNames.charStyles().contains(nStyle->marksChStyle()))
nStyle->setMarksCharStyle(newNames.charStyles().value(nStyle->marksChStyle()));
}
for (QHash<int, PageItem*>::iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
{
PageItem *currItem = itf.value();
if (currItem)
currItem->replaceNamedResources(newNames);
}
// replace names in styles...
for (int i=docParagraphStyles.count()-1; i >= 0; --i)
{
if (newNames.styles().contains(docParagraphStyles[i].name()))
docParagraphStyles.remove(i);
else
docParagraphStyles[i].replaceNamedResources(newNames);
}
for (int i=docCharStyles.count()-1; i >= 0; --i)
{
if (newNames.charStyles().contains(docCharStyles[i].name()))
docCharStyles.remove(i);
else
docCharStyles[i].replaceNamedResources(newNames);
}
for (int i = docTableStyles.count() - 1; i >= 0; --i)
{
if (newNames.tableStyles().contains(docTableStyles[i].name()))
docTableStyles.remove(i);
else
docTableStyles[i].replaceNamedResources(newNames);
}
for (int i = docCellStyles.count() - 1; i >= 0; --i)
{
if (newNames.cellStyles().contains(docCellStyles[i].name()))
docCellStyles.remove(i);
else
docCellStyles[i].replaceNamedResources(newNames);
}
QHash<QString,ScPattern>::Iterator it;
for (it = docPatterns.begin(); it != docPatterns.end(); ++it)
{
if (newNames.patterns().contains(it.key()))
docPatterns.erase(it);
else
{
ScPattern pa = *it;
for (int o = 0; o < pa.items.count(); o++)
{
pa.items.at(o)->replaceNamedResources(newNames);
}
}
}
QHash<QString,VGradient>::Iterator itg;
for (itg = docGradients.begin(); itg != docGradients.end(); ++itg)
{
if (newNames.gradients().contains(itg.key()))
docGradients.erase(itg);
else
{
QMap<QString,QString>::ConstIterator itc;
QList<VColorStop*> cstops = itg.value().colorStops();
for (uint cst = 0; cst < itg.value().Stops(); ++cst)
{
itc = newNames.colors().find(cstops.at(cst)->name);
if (itc != newNames.colors().end())
{
if (*itc != CommonStrings::None)
cstops.at(cst)->name = *itc;
}
}
}
}
if (newNames.colors().count() > 0 || newNames.fonts().count() > 0)
{
docCharStyles.invalidate();
docParagraphStyles.invalidate();
docTableStyles.invalidate();
docCellStyles.invalidate();
}
else
{
if (newNames.charStyles().count() > 0)
docCharStyles.invalidate();
if (newNames.styles().count() > 0)
docParagraphStyles.invalidate();
if (newNames.tableStyles().count() > 0)
docTableStyles.invalidate();
if (newNames.cellStyles().count() > 0)
docCellStyles.invalidate();
}
if (!isLoading() && !(newNames.colors().isEmpty() && newNames.fonts().isEmpty() && newNames.patterns().isEmpty()
&& newNames.styles().isEmpty() && newNames.charStyles().isEmpty() && newNames.lineStyles().isEmpty()
&& newNames.tableStyles().isEmpty() && newNames.cellStyles().isEmpty()))
changed();
}
void ScribusDoc::replaceCharStyles(const QMap<QString,QString>& newNameForOld)
{
ResourceCollection newNames;
newNames.mapCharStyles(newNameForOld);
replaceNamedResources(newNames);
/*
// replace style in items
QPtrList<PageItem> * itemlist = & MasterItems;
while (itemlist != NULL)
{
for (uint i=0; i < itemlist->count(); ++i)
{
PageItem_TextFrame * currItem = itemlist->at(i)->asTextFrame();
if (currItem)
currItem->itemText.replaceCharStyles(newNameForOld);
}
if (itemlist == &MasterItems)
itemlist = &DocItems;
else if (itemlist == &DocItems)
itemlist = &FrameItems;
else
itemlist = NULL;
}
// replace names in styles
for (uint i=0; i < docParagraphStyles.count(); ++i)
{
// ...parent of parstyle's charstyle
const QString& parent(docParagraphStyles[i].charStyle().parent());
if (newNameForOld.contains(parent))
docParagraphStyles[i].charStyle().setParent(newNameForOld[parent]);
}
for (int i=docCharStyles.count()-1; i >= 0; --i)
{
// ...parent of charstyle
const QString& parent(docCharStyles[i].parent());
if (newNameForOld.contains(parent))
docCharStyles[i].setParent(newNameForOld[parent]);
// ... as name
if (newNameForOld.contains(docCharStyles[i].name()))
docCharStyles.remove(i);
}
*/
}
void ScribusDoc::replaceTableStyles(const QMap<QString, QString>& newNameForOld)
{
ResourceCollection newNames;
newNames.mapTableStyles(newNameForOld);
replaceNamedResources(newNames);
}
void ScribusDoc::replaceCellStyles(const QMap<QString, QString>& newNameForOld)
{
ResourceCollection newNames;
newNames.mapCellStyles(newNameForOld);
replaceNamedResources(newNames);
}
void ScribusDoc::redefineStyles(const StyleSet<ParagraphStyle>& newStyles, bool removeUnused)
{
docParagraphStyles.redefine(newStyles, false);
if (removeUnused)
{
QMap<QString, QString> deletion;
QString deflt("");
for (int i=0; i < docParagraphStyles.count(); ++i)
{
const QString& nam(docParagraphStyles[i].name());
if (newStyles.find(nam) < 0)
deletion[nam] = deflt;
}
if (deletion.count() > 0)
replaceStyles(deletion);
}
// repair charstyle context:
for (int i=0; i < docParagraphStyles.count(); ++i)
{
ParagraphStyle& sty(docParagraphStyles[i]);
if (docParagraphStyles.isDefault(sty))
{
sty.breakImplicitCharStyleInheritance(true);
sty.charStyle().setContext( & docCharStyles );
// sty.charStyle().setName( "cdocdefault" ); // DONT TRANSLATE
}
else {
sty.breakImplicitCharStyleInheritance(false);
}
}
docParagraphStyles.invalidate();
if (!isLoading())
{
flag_Renumber = true;
flag_NumUpdateRequest = true;
}
}
void ScribusDoc::redefineCharStyles(const StyleSet<CharStyle>& newStyles, bool removeUnused)
{
docCharStyles.redefine(newStyles, false);
if (removeUnused)
{
QMap<QString, QString> deletion;
QString deflt("");
for (int i=0; i < docCharStyles.count(); ++i)
{
const QString& nam(docCharStyles[i].name());
if (newStyles.find(nam) < 0)
{
deletion[nam] = deflt;
}
}
if (deletion.count() > 0)
replaceCharStyles(deletion);
}
docCharStyles.invalidate();
}
void ScribusDoc::redefineTableStyles(const StyleSet<TableStyle>& newStyles, bool removeUnused)
{
docTableStyles.redefine(newStyles, false);
if (removeUnused)
{
QMap<QString, QString> deletion;
QString deflt("");
for (int i = 0; i < docTableStyles.count(); ++i)
{
const QString& nam(docTableStyles[i].name());
if (newStyles.find(nam) < 0)
{
deletion[nam] = deflt;
}
}
if (deletion.count() > 0)
replaceTableStyles(deletion);
}
docTableStyles.invalidate();
}
void ScribusDoc::redefineCellStyles(const StyleSet<CellStyle>& newStyles, bool removeUnused)
{
docCellStyles.redefine(newStyles, false);
if (removeUnused)
{
QMap<QString, QString> deletion;
QString deflt("");
for (int i = 0; i < docCellStyles.count(); ++i)
{
const QString& nam(docCellStyles[i].name());
if (newStyles.find(nam) < 0)
{
deletion[nam] = deflt;
}
}
if (deletion.count() > 0)
replaceCellStyles(deletion);
}
docCellStyles.invalidate();
}
/*
* Split out from loadStyles in editFormats.cpp so it's callable from anywhere,
* including plugins.
* - 2004-09-14 Craig Ringer
*/
// dont like this here. could as well be a static method for reading this stuff into temp., then always use redefineXY() - av
void ScribusDoc::loadStylesFromFile(QString fileName)
{
StyleSet<ParagraphStyle> *wrkStyles = &docParagraphStyles;
StyleSet<CharStyle> *wrkCharStyles = &docCharStyles;
QHash<QString, multiLine> *wrkLineStyles = &MLineStyles;
int oldStyles = wrkStyles->count();
int oldCharStyles = wrkCharStyles->count();
int oldLineStyles = wrkLineStyles->count();
if (!fileName.isEmpty())
{
FileLoader fl(fileName);
if (fl.testFile() == -1)
//TODO put in nice user warning
return;
if (!fl.readStyles(this, *wrkStyles))
{
//TODO put in nice user warning
}
if (!fl.readCharStyles(this, *wrkCharStyles))
{
//TODO put in nice user warning
}
if (!fl.readLineStyles(wrkLineStyles))
{
//TODO put in nice user warning
}
if ( !isLoading() && ((wrkStyles->count() > oldStyles)
|| (wrkCharStyles->count() > oldCharStyles)
|| (wrkLineStyles->count() > oldLineStyles) ) )
changed();
}
}
void ScribusDoc::loadStylesFromFile(QString fileName, StyleSet<ParagraphStyle> *tempStyles,
StyleSet<CharStyle> *tempCharStyles,
QHash<QString, multiLine> *tempLineStyles)
{
StyleSet<ParagraphStyle> *wrkStyles = tempStyles;
StyleSet<CharStyle> *wrkCharStyles = tempCharStyles;
QHash<QString, multiLine> *wrkLineStyles = tempLineStyles;
if (!fileName.isEmpty())
{
FileLoader fl(fileName);
if (fl.testFile() == -1)
//TODO put in nice user warning
return;
if (!fl.readStyles(this, *wrkStyles))
{
//TODO put in nice user warning
}
if (!fl.readCharStyles(this, *wrkCharStyles))
{
//TODO put in nice user warning
}
if (!fl.readLineStyles(wrkLineStyles))
{
//TODO put in nice user warning
}
// Which are the default styles
// Sadly StyleSet is not updated at import
// and it might break something to do so.
// We need to loop then - pm
// ParagraphStyle* parDefault(wrkStyles->getDefault());
// CharStyle* charDefault(wrkCharStyles->getDefault());
QFileInfo fi(fileName);
QString importPrefix(tr("Imported ","Prefix of imported default style"));
QString importSuffix(" (" + fi.baseName() + ")");
for (int j(0) ; j < wrkStyles->count() ; ++j)
{
if ((*wrkStyles)[j].isDefaultStyle())
{
ParagraphStyle& parDefault((*wrkStyles)[j]);
parDefault.setDefaultStyle(false);
QMap<QString, QString> namesMap;
namesMap[parDefault.name()] = importPrefix + parDefault.name() + importSuffix;
for (int i(0) ; i < wrkStyles->count() ; ++i)
{
if ((*wrkStyles)[i] != parDefault)
namesMap[(*wrkStyles)[i].name()] = (*wrkStyles)[i].name();
}
wrkStyles->rename(namesMap);
}
}
for (int j(0) ; j < wrkCharStyles->count() ; ++j)
{
if ((*wrkCharStyles)[j].isDefaultStyle())
{
CharStyle& charDefault((*wrkCharStyles)[j]);
charDefault.setDefaultStyle(false);
QMap<QString, QString> namesMap;
namesMap[charDefault.name()] = importPrefix + charDefault.name() + importSuffix;
for (int i(0) ; i < wrkCharStyles->count() ; ++i)
{
if ((*wrkCharStyles)[i] != charDefault)
namesMap[(*wrkCharStyles)[i].name()] = (*wrkCharStyles)[i].name();
}
wrkCharStyles->rename(namesMap);
}
}
}
}
void ScribusDoc::lockGuides(bool isLocked)
{
if (GuideLock == isLocked)
return;
GuideLock = isLocked;
if (UndoManager::undoEnabled())
{
QString name;
if (isLocked)
name = Um::LockGuides;
else
name = Um::UnlockGuides;
SimpleState *ss = new SimpleState(name, "", Um::ILockGuides);
ss->set("GUIDE_LOCK", isLocked);
undoManager->action(this, ss);
}
}
void ScribusDoc::undoRedoBegin()
{
m_docUpdater->beginUpdate();
m_Selection->delaySignalsOn();
}
void ScribusDoc::undoRedoDone()
{
m_Selection->delaySignalsOff();
m_docUpdater->endUpdate();
}
void ScribusDoc::restore(UndoState* state, bool isUndo)
{
SimpleState *ss = dynamic_cast<SimpleState*>(state);
if (ss)
{
bool layersUndo=false;
if (ss->contains("GROUP"))
restoreGrouping(ss, isUndo);
else if (ss->contains("UNGROUP"))
restoreGrouping(ss, !isUndo);
else if (ss->contains("GUIDE_LOCK"))
{
if (isUndo)
GuideLock = !ss->getBool("GUIDE_LOCK");
else
GuideLock = ss->getBool("GUIDE_LOCK");
}
else if (ss->contains("UP_LAYER"))
{
if (isUndo)
lowerLayer(ss->getInt("ACTIVE"));
else
raiseLayer(ss->getInt("ACTIVE"));
layersUndo=true;
}
else if (ss->contains("DOWN_LAYER"))
{
if (isUndo)
raiseLayer(ss->getInt("ACTIVE"));
else
lowerLayer(ss->getInt("ACTIVE"));
layersUndo=true;
}
else if (ss->contains("PRINT_LAYER"))
{
bool print = ss->getBool("PRINT");
setLayerPrintable(ss->getInt("ACTIVE"), isUndo ? !print : print);
layersUndo=true;
}
else if (ss->contains("LAYER_FLOW"))
{
bool flow = ss->getBool("FLOW");
setLayerFlow(ss->getInt("ACTIVE"), isUndo ? !flow : flow);
layersUndo=true;
}
else if (ss->contains("LAYER_LOCK"))
{
bool lock = ss->getBool("LOCK");
setLayerLocked(ss->getInt("ACTIVE"), isUndo ? !lock : lock);
layersUndo=true;
}
else if (ss->contains("LAYER_TRANSPARENCY"))
{
double old_trans = ss->getDouble("OLD_TRANS");
double new_trans = ss->getDouble("NEW_TRANS");
setLayerTransparency(ss->getInt("ACTIVE"), isUndo ? old_trans : new_trans);
layersUndo=true;
}
else if (ss->contains("LAYER_BLENDMODE"))
{
int old_blend = ss->getInt("OLD_BLENDMODE");
int new_blend = ss->getInt("NEW_BLENDMODE");
setLayerBlendMode(ss->getInt("ACTIVE"), isUndo ? old_blend : new_blend);
layersUndo=true;
}
else if (ss->contains("ADD_LAYER"))
{
if (isUndo)
deleteLayer(ss->getInt("LAYER_NR"), false);
else
{
int layerID=addLayer( ss->get("NAME"), false );
int newLayerID=ss->getInt("LAYER_NR");
bool renumberedOk=renumberLayer(layerID, newLayerID);
Q_ASSERT(renumberedOk);
}
layersUndo=true;
}
else if (ss->contains("REMOVE_LAYER"))
{
if (isUndo)
{
int layerID=addLayer( ss->get("NAME"), false );
int newLayerID=ss->getInt("LAYER_NR");
bool renumberedOk=renumberLayer(layerID, newLayerID);
Q_ASSERT(renumberedOk);
layerID=newLayerID;
//Layer is at the top now, lower it until it reaches the old level
int level = ss->getInt("LEVEL");
while (layerLevelFromID(layerID)!=level)
lowerLayer(layerID);
}
else
deleteLayer(ss->getInt("LAYER_NR"), ss->getBool("DELETE"));
layersUndo=true;
}
else if (ss->contains("CHANGE_NAME"))
{
QString name = ss->get("OLD_NAME");
if (!isUndo)
name = ss->get("NEW_NAME");
changeLayerName(ss->getInt("ACTIVE"), name);
layersUndo=true;
}
else if (ss->contains("MASTERPAGE_ADD"))
restoreAddMasterPage(ss, isUndo);
else if (ss->contains("MASTERPAGE_RENAME"))
restoreMasterPageRenaming(ss, isUndo);
else if (ss->contains("OLD_MASTERPAGE"))
restoreMasterPageApplying(ss, isUndo);
else if (ss->contains("PAGE_COPY"))
restoreCopyPage(ss, isUndo);
else if (ss->contains("PAGE_MOVE"))
restoreMovePage(ss, isUndo);
else if (ss->contains("LEVEL_DOWN"))
restoreLevelDown(ss,isUndo);
else if (ss->contains("LEVEL_UP"))
restoreLevelDown(ss,!isUndo);
else if (ss->contains("LEVEL_BOTTOM"))
restoreLevelBottom(ss,isUndo);
else if (ss->contains("LEVEL_TOP"))
restoreLevelBottom(ss,!isUndo);
else if (ss->contains("PAGE_CHANGEPROPS"))
{
if (isUndo)
{
changePageMargins(ss->getDouble("OLD_PAGE_INITIALTOP"), ss->getDouble("OLD_PAGE_INITIALBOTTOM"),
ss->getDouble("OLD_PAGE_INITIALLEFT"), ss->getDouble("OLD_PAGE_INITIALRIGHT"),
ss->getDouble("OLD_PAGE_INITIALHEIGHT"), ss->getDouble("OLD_PAGE_INITIALWIDTH"),
ss->getDouble("OLD_PAGE_HEIGHT"), ss->getDouble("OLD_PAGE_WIDTH"), ss->getInt("OLD_PAGE_ORIENTATION"),
ss->get("OLD_PAGE_SIZE"), ss->getInt("OLD_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("OLD_PAGE_TYPE"));
}
else
{
changePageMargins(ss->getDouble("NEW_PAGE_INITIALTOP"), ss->getDouble("NEW_PAGE_INITIALBOTTOM"),
ss->getDouble("NEW_PAGE_INITIALLEFT"), ss->getDouble("NEW_PAGE_INITIALRIGHT"),
ss->getDouble("NEW_PAGE_INITIALHEIGHT"), ss->getDouble("NEW_PAGE_INITIALWIDTH"),
ss->getDouble("NEW_PAGE_HEIGHT"), ss->getDouble("NEW_PAGE_WIDTH"), ss->getInt("NEW_PAGE_ORIENTATION"),
ss->get("NEW_PAGE_SIZE"), ss->getInt("NEW_PAGE_MARGINPRESET"), ss->getBool("OLD_PAGE_MOVEOBJECTS"), ss->getInt("PAGE_NUM"), ss->getInt("NEW_PAGE_TYPE"));
}
}
else if (ss->contains("DELETE_FRAMETEXT"))
{
PageItem * nF = getItemFromName(ss->get("noteframeName"));
Q_ASSERT(nF != NULL);
nF->asNoteFrame()->restoreDeleteNoteText(ss, isUndo);
}
else if (ss->contains("INSERT_FRAMETEXT"))
{
PageItem * nF = getItemFromName(ss->get("noteframeName"));
Q_ASSERT(nF != NULL);
nF->asNoteFrame()->restoreInsertNoteText(ss,isUndo);
}
else if (ss->contains("NSTYLE"))
{
NotesStyle* NS = NULL;
if ((ss->get("NSTYLE") == "new" && isUndo) || (ss->get("NSTYLE") == "delete" && !isUndo))
deleteNotesStyle(ss->get("name"));
else if ((ss->get("NSTYLE") == "new" && !isUndo) || (ss->get("NSTYLE") == "delete" && isUndo))
{
NS = new NotesStyle();
NS->setName(ss->get("name"));
NS->setStart(ss->getInt("start"));
NS->setEndNotes(ss->getBool("endNotes"));
NS->setType((NumFormat) ss->getInt("numFormat"));
NS->setRange((NumerationRange) ss->getInt("range"));
NS->setPrefix(ss->get("prefix"));
NS->setSuffix(ss->get("suffix"));
NS->setAutoNotesHeight(ss->getBool("autoH"));
NS->setAutoNotesWidth(ss->getBool("autoW"));
NS->setAutoWeldNotesFrames(ss->getBool("autoWeld"));
NS->setAutoRemoveEmptyNotesFrames(ss->getBool("autoRemove"));
NS->setSuperscriptInMaster(ss->getBool("superMaster"));
NS->setSuperscriptInNote(ss->getBool("superNote"));
NS->setMarksCharStyle(ss->get("marksChStyle"));
NS->setNotesParStyle(ss->get("notesParStyle"));
m_docNotesStylesList.append(NS);
scMW()->emitUpdateRequest(reqMarksUpdate);
}
else if (ss->get("NSTYLE") == "edit")
{
if (isUndo)
NS = getNotesStyle(ss->get("NEWname"));
else
NS = getNotesStyle(ss->get("name"));
Q_ASSERT(NS != NULL);
//check if Notes Style change form footnotes to endnotes or range of numeration was changed
//if use delete all notes frames with current style
bool delNF = false;
if (ss->getBool("NEWendNotes") != ss->getBool("endNotes")
|| ((isUndo && (ss->getBool("endNotes") && (NumerationRange) ss->getInt("range") != (NumerationRange) ss->getInt("NEWrange")))
|| (!isUndo && (ss->getBool("NEWendNotes") && ((NumerationRange) ss->getInt("NEWrange") != (NumerationRange) ss->getInt("range"))))))
delNF = true;
if (delNF)
{
foreach (PageItem_NoteFrame* nF, listNotesFrames(NS))
delNoteFrame(nF, false);
flag_updateEndNotes = NS->isEndNotes();
}
if (isUndo)
{
NS->setName(ss->get("name"));
NS->setStart(ss->getInt("start"));
NS->setRange((NumerationRange) ss->getInt("range"));
NS->setEndNotes(ss->getBool("endNotes"));
NS->setType((NumFormat) ss->getInt("numFormat"));
NS->setPrefix(ss->get("prefix"));
NS->setSuffix(ss->get("suffix"));
NS->setAutoNotesHeight(ss->getBool("autoH"));
NS->setAutoNotesWidth(ss->getBool("autoW"));
NS->setAutoWeldNotesFrames(ss->getBool("autoWeld"));
NS->setAutoRemoveEmptyNotesFrames(ss->getBool("autoRemove"));
NS->setSuperscriptInMaster(ss->getBool("superMaster"));
NS->setSuperscriptInNote(ss->getBool("superNote"));
NS->setMarksCharStyle(ss->get("marksChStyle"));
NS->setNotesParStyle(ss->get("notesParStyle"));
}
else
{
NS->setName(ss->get("NEWname"));
NS->setStart(ss->getInt("NEWstart"));
NS->setRange((NumerationRange) ss->getInt("NEWrange"));
NS->setEndNotes(ss->getBool("NEWendNotes"));
NS->setType((NumFormat) ss->getInt("NEWnumFormat"));
NS->setPrefix(ss->get("NEWprefix"));
NS->setSuffix(ss->get("NEWsuffix"));
NS->setAutoNotesHeight(ss->getBool("NEWautoH"));
NS->setAutoNotesWidth(ss->getBool("NEWautoW"));
NS->setAutoWeldNotesFrames(ss->getBool("NEWautoWeld"));
NS->setAutoRemoveEmptyNotesFrames(ss->getBool("NEWautoRemove"));
NS->setSuperscriptInMaster(ss->getBool("NEWsuperMaster"));
NS->setSuperscriptInNote(ss->getBool("NEWsuperNote"));
NS->setMarksCharStyle(ss->get("NEWmarksChStyle"));
NS->setNotesParStyle(ss->get("NEWnotesParStyle"));
}
setNotesChanged(true);
if ((ss->get("marksChStyle") != ss->get("NEWmarksChStyle"))
|| (ss->getBool("superMaster") != ss->getBool("NEWsuperMaster")))
invalidateMasterFrames(NS);
updateNotesNums(NS);
updateNotesFramesSettings(NS);
if (flag_updateEndNotes)
updateEndnotesFrames(NS, true);
updateNotesFramesStyles(NS);
if (notesChanged())
{
flag_updateMarksLabels = true;
changed();
regionsChanged()->update(QRectF());
}
}
if (NS != NULL)
scMW()->nsEditor->setNotesStyle(NS);
else
scMW()->nsEditor->updateNSList();
}
else if (ss->contains("DELETE_NOTE"))
{
ScItemsState *is = dynamic_cast<ScItemsState*>(state);
if (is)
{
NotesStyle* nStyle = getNotesStyle(is->get("nStyle"));
PageItem* master = NULL;
if (is->contains("noteframeName"))
master = getItemFromName(is->get("noteframeName"));
else
master = (PageItem*) is->getItem("inItem");
if (isUndo)
{
TextNote* note = newNote(nStyle);
Mark* mrk = newMark();
mrk->setType(MARKNoteMasterType);
mrk->setNotePtr(note);
note->setMasterMark(mrk);
note->setSaxedText(is->get("noteTXT"));
master->itemText.insertMark(mrk, is->getInt("at"));
master->invalid = true;
if (!nStyle->isAutoRemoveEmptyNotesFrames())
{
PageItem_NoteFrame* nF = (PageItem_NoteFrame*) is->getItem("noteframe");
Q_ASSERT(nF != NULL);
master->asTextFrame()->setNoteFrame(nF);
}
setNotesChanged(true);
if (note->isEndNote())
flag_updateEndNotes = true;
}
else
{
TextNote* note = master->itemText.mark(is->getInt("at"))->getNotePtr();
if (note->isEndNote())
flag_updateEndNotes = true;
deleteNote(note);
}
master->invalidateLayout();
master->updateLayout();
}
}
else if (ss->contains("MARK"))
{
ScItemsState *is = dynamic_cast<ScItemsState*>(state);
if (is)
{
Mark* mrk = getMarkDefinied(is->get("label"), (MarkType) is->getInt("type"));
if (mrk == NULL && is->contains("labelOLD"))
mrk = getMarkDefinied(is->get("labelOLD"), (MarkType) is->getInt("type"));
int pos = is->getInt("at");
bool isAutoNoteFrame = false;
PageItem* currItem = NULL;
if (is->contains("noteframeName"))
{
currItem = getItemFromName(is->get("noteframeName"));
if (currItem != NULL)
isAutoNoteFrame = currItem->asNoteFrame()->isAutoFrame();
}
else
currItem = (PageItem*) is->getItem("inItem");
if (isUndo)
{
if (is->get("MARK") == "new")
{
Q_ASSERT(mrk != NULL);
if (mrk->isNoteType())
{
TextNote* note = mrk->getNotePtr();
NotesStyle* nStyle = note->notesStyle();
if (note->isEndNote())
flag_updateEndNotes = true;
deleteNote(note);
updateNotesNums(nStyle);
}
else
eraseMark(mrk, true, currItem, true);
}
else if (is->get("MARK") == "replace")
{
Q_ASSERT(pos >= 0);
Q_ASSERT(currItem != NULL);
Q_ASSERT(mrk != NULL);
Mark* mrk = getMarkDefinied(is->get("label"), (MarkType) is->getInt("type"));
currItem->itemText.replaceMark(pos, mrk);
if (is->contains("strtxtOLD"))
{
mrk->setString(is->get("strtxtOLD"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("labelOLD"))
mrk->label = is->get("labelOLD");
}
else if (is->get("MARK") == "edit")
{
Q_ASSERT(mrk != NULL);
if (is->contains("labelOLD"))
mrk->label = is->get("labelOLD");
if (is->contains("strtxtOLD"))
{
mrk->setString(is->get("strtxtOLD"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("dNameOLD"))
mrk->setMark(is->get("dNameOLD"), (MarkType) is->getInt("dTypeOLD"));
if (is->getItem("itemPtrOLD") != NULL)
mrk->setItemPtr((PageItem*) is->getItem("itemPtrOLD"));
}
else if (is->get("MARK") == "insert_existing")
{
Q_ASSERT(pos >= 0);
Q_ASSERT(currItem != NULL);
Q_ASSERT(mrk != NULL);
currItem->itemText.removeChars(pos,1);
if (is->contains("strOLD"))
{
mrk->setString(is->get("strOLD"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("labelOLD"))
mrk->label = is->get("labelOLD");
}
else if (is->get("MARK") == "delete")
{
mrk = newMark();
mrk->label = is->get("label");
mrk->setType((MarkType) is->getInt("type"));
Q_ASSERT(pos >= 0);
Q_ASSERT(currItem != NULL);
currItem->itemText.insertMark(mrk, pos);
if (is->contains("strtxt"))
{
mrk->setString(is->get("strtxt"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("dName"))
mrk->setMark(is->get("dName"), (MarkType) is->getInt("dType"));
if (is->getItem("itemPtr") != NULL)
mrk->setItemPtr((PageItem*) is->getItem("itemPtrOLD"));
}
else if (is->get("MARK") == "eraseFromText") ////for non-unique marks
{
Q_ASSERT(pos >= 0);
Q_ASSERT(mrk != NULL);
Q_ASSERT(currItem != NULL);
currItem->itemText.insertMark(mrk, pos);
if (is->contains("strNew"))
{
mrk->setString(is->get("strNEW"));
invalidateVariableTextFrames(mrk, false);
}
}
else if (is->get("MARK") == "delNonUnique")
{
//used if deleting non-unique marks by MarksManager
mrk = newMark();
mrk->label = is->get("label");
mrk->setType((MarkType) is->getInt("type"));
mrk->setString(is->get("strtxt"));
for (int i=0; i < is->insertItemPos.count(); ++i)
{
PageItem* item = (PageItem*) is->insertItemPos[i].first;
item->itemText.insertMark(mrk, is->insertItemPos[i].second);
item->invalid = true;
}
}
else
{
Q_ASSERT(false);
qDebug() << "MARK undo - unhandled " << is->get("MARK");
}
}
else //REDO
{
if (is->get("MARK") == "new")
{
if (currItem == NULL)
{
qDebug() << "Wrong inItem in undo step for mark";
return;
}
mrk = newMark();
mrk->label = is->get("label");
mrk->setType((MarkType) is->getInt("type"));
Q_ASSERT(currItem != NULL);
Q_ASSERT(pos >= 0);
currItem->itemText.insertMark(mrk, pos);
if (is->contains("strtxt"))
mrk->setString(is->get("strtxt"));
if (is->contains("dName"))
mrk->setMark(is->get("dName"), (MarkType) is->getInt("dType"));
if (is->getItem("itemPtr") != NULL)
mrk->setItemPtr((PageItem*) is->getItem("itemPtrOLD"));
if (mrk->isType(MARKNoteMasterType))
{
NotesStyle* nStyle = getNotesStyle(is->get("nStyle"));;
TextNote* note = newNote(nStyle);
mrk->setNotePtr(note);
note->setMasterMark(mrk);
if (nStyle->isEndNotes())
flag_updateEndNotes = true;
updateNotesNums(nStyle);
}
}
else if (is->get("MARK") == "replace")
{
Q_ASSERT(currItem != NULL);
Q_ASSERT(pos >= 0);
currItem->itemText.replaceMark(pos, getMarkDefinied(is->get("label"), (MarkType) is->getInt("type")));
if (is->contains("strtxtNEW"))
{
mrk->setString(is->get("strtxtNEW"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("labelNEW"))
mrk->label = is->get("labelNEW");
}
else if (is->get("MARK") == "edit")
{
if (is->contains("labelNEW"))
mrk->label = is->get("labelNEW");
if (is->contains("strtxtNEW"))
{
mrk->setString(is->get("strtxtNEW"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("dNameNEW"))
mrk->setMark(is->get("dNameNEW"), (MarkType) is->getInt("dTypeNEW"));
if (is->getItem("itemPtrNEW") != NULL)
mrk->setItemPtr((PageItem*) is->getItem("itemPtrNEW"));
}
else if (is->get("MARK") == "insert_existing")
{
Q_ASSERT(currItem != NULL);
Q_ASSERT(pos >= 0);
currItem->itemText.insertMark(mrk, pos);
if (is->contains("strNew"))
{
mrk->setString(is->get("strNEW"));
invalidateVariableTextFrames(mrk, false);
}
if (is->contains("labelNEW"))
mrk->label = is->get("labelNEW");
}
else if (is->get("MARK") == "eraseFromText") //for non-unique marks
{
Q_ASSERT(currItem != NULL);
Q_ASSERT(pos >= 0);
currItem->itemText.removeChars(pos,1);
}
else if (is->get("MARK") == "delete")
{
if (!mrk->isUnique())
{
Q_ASSERT(currItem != NULL);
Q_ASSERT(pos >= 0);
currItem->itemText.removeChars(pos,1);
}
else
{
if (mrk->isType(MARKNoteMasterType))
{
TextNote* note = mrk->getNotePtr();
NotesStyle* nStyle = note->notesStyle();
if (note->isEndNote())
flag_updateEndNotes = true;
deleteNote(note);
updateNotesNums(nStyle);
}
else
eraseMark(mrk, true);
}
}
else if (is->get("MARK") == "delNonUnique")
{
//used if deleting non-unique marks by MarksManager
eraseMark(mrk, true, NULL, true);
}
else
{
qDebug() << "MARK redo - unhandled " << is->get("MARK");
}
}
scMW()->emitUpdateRequest(reqMarksUpdate);
if (currItem != NULL && !isAutoNoteFrame)
{
currItem->invalidateLayout();
currItem->updateLayout();
}
}
}
if (layersUndo)
{
if (ScCore->usingGUI())
{
if (ss->contains("ACTIVE"))
scMW()->layerPalette->setActiveLayer(layerLevelFromID(ss->getInt("ACTIVE")),0);
m_ScMW->changeLayer(ss->getInt("ACTIVE"));
m_ScMW->layerPalette->rebuildList();
if (m_ScMW->outlinePalette->isVisible())
m_ScMW->outlinePalette->BuildTree();
}
}
}
}
void ScribusDoc::restoreLevelDown(SimpleState *ss, bool isUndo)
{
ScItemState<QList<QPointer<PageItem> > > *is = dynamic_cast<ScItemState<QList<QPointer<PageItem> > > *>(ss);
QList<QPointer<PageItem> > listItem = is->getItem();
m_Selection->clear();
for (int i = 0; i<listItem.size();i++)
m_Selection->addItem(listItem.at(i));
if (isUndo)
itemSelection_RaiseItem();
else
itemSelection_LowerItem();
}
void ScribusDoc::restoreLevelBottom(SimpleState *ss, bool isUndo)
{
ScItemState<QList<QPointer<PageItem> > > *is = dynamic_cast<ScItemState<QList<QPointer<PageItem> > > *>(ss);
QList<QPointer<PageItem> > listItem = is->getItem();
m_Selection->clear();
for (int i = 0; i<listItem.size();i++)
m_Selection->addItem(listItem.at(i));
if (isUndo)
bringItemSelectionToFront();
else
sendItemSelectionToBack();
}
void ScribusDoc::restoreAddMasterPage(SimpleState *ss, bool isUndo)
{
QString pageName = ss->get("MASTERPAGE_NAME");
int pageNr = ss->getInt("MASTERPAGE_NBR");
bool oldMPMode = masterPageMode();
ScPage* oldPage = currentPage();
setMasterPageMode(true);
if (isUndo)
{
DummyUndoObject *duo = new DummyUndoObject();
uint did = static_cast<uint>(duo->getUId());
undoManager->replaceObject(Pages->at(MasterNames[pageName])->getUId(), duo);
ss->set("DUMMY_ID", did);
scMW()->deletePage2(MasterNames[pageName]);
rebuildMasterNames();
}
else
{
ScPage* Mpage = addMasterPage(pageNr, pageName);
setCurrentPage(Mpage);
UndoObject *tmp = undoManager->replaceObject(
ss->getUInt("DUMMY_ID"), Pages->at(MasterNames[pageName]));
delete tmp;
}
setMasterPageMode(oldMPMode);
if (!oldMPMode)
setCurrentPage(oldPage);
scMW()->pagePalette->updateMasterPageList();
m_View->reformPages();
}
void ScribusDoc::restoreGrouping(SimpleState *state, bool isUndo)
{
double x, y, w, h;
ScItemState<QList<QPointer<PageItem> > > *is = dynamic_cast<ScItemState<QList<QPointer<PageItem> > >*>(state);
QList<QPointer<PageItem> > select = is->getItem();
m_Selection->delaySignalsOn();
for (int i = 0; i < select.count(); ++i)
m_Selection->removeItem(select.at(i));
Selection tempSelect(this, false);
if (isUndo)
{
tempSelect.addItem(select.last());
tempSelect.setGroupRect();
tempSelect.getGroupRect(&x, &y, &w, &h);
itemSelection_UnGroupObjects(&tempSelect);
}
else
{
for (int i = 0; i < select.size()-1; ++i)
tempSelect.addItem(select.at(i));
tempSelect.setGroupRect();
tempSelect.getGroupRect(&x, &y, &w, &h);
select.removeLast();
select.append(itemSelection_GroupObjects(false, false,&tempSelect));
is->setItem(select);
}
QRectF rect(x, y , w, h);
regionsChanged()->update(rect.adjusted(-10, -10, 20, 20));
m_Selection->delaySignalsOff();
}
void ScribusDoc::setName(const QString& name)
{
DocName = name;
}
void ScribusDoc::setModified(const bool isModified)
{
if (modified != isModified)
{
modified = isModified;
update();
}
}
bool ScribusDoc::isModified() const
{
return modified;
}
/** sets page properties */
void ScribusDoc::setPage(double w, double h, double t, double l, double r, double b, double sp, double ab, bool atf, int fp)
{
docPrefsData.docSetupPrefs.pageWidth = w;
docPrefsData.docSetupPrefs.pageHeight = h;
docPrefsData.docSetupPrefs.margins.set(t, l, b ,r);
PageSp = sp;
PageSpa = ab;
docPrefsData.docSetupPrefs.pagePositioning = fp;
automaticTextFrames = atf;
//CB Moved from scribus.cpp. Overrides the defaults...
// PDF_Options.BleedTop = pageMargins.Top;
// PDF_Options.BleedLeft = pageMargins.Left;
// PDF_Options.BleedRight = pageMargins.Right;
// PDF_Options.BleedBottom = pageMargins.Bottom;
}
void ScribusDoc::resetPage(int fp, MarginStruct* newMargins)
{
if (newMargins!=0)
docPrefsData.docSetupPrefs.margins = *newMargins;
docPrefsData.docSetupPrefs.pagePositioning = fp;
}
bool ScribusDoc::AddFont(QString name, int fsize)
{
bool ret = false;
// FT_Face face;
if (UsedFonts.contains(name))
return true;
if (! AllFonts->contains(name) || name == "" )
return false;
// face = (*AllFonts)[name]->ftFace();
// if ( !face )
// return false;
/* if ((*AllFonts)[name].ReadMetrics()) FIXME: needed?
{
// (*AllFonts)[name]->CharWidth[13] = 0;
// (*AllFonts)[name]->CharWidth[28] = 0;
// (*AllFonts)[name]->CharWidth[26] = 0;
// (*AllFonts)[name]->CharWidth[9] = 1;
QString afnm = (*AllFonts)[name].fontFilePath().left((*AllFonts)[name].fontFilePath().length()-3);
QFile afm(afnm+"afm");
if (!(afm.exists()))
{
afm.setName(afnm+"pfm");
}
if (!(afm.exists())) {
afm.setName(afnm+"AFM");
}
if (!(afm.exists()))
{
afm.setName(afnm+"PFM");
}
if (!(afm.exists()))
{
afm.setName(afnm+"Afm");
}
if (!(afm.exists()))
{
afm.setName(afnm+"Pfm");
}
if (afm.exists())
FT_Attach_File(face, afm.name());
}
*/
UsedFonts[name] = fsize;
(*AllFonts)[name].increaseUsage();
ret = true;
return ret;
}
QStringList ScribusDoc::getItemAttributeNames()
{
QStringList nameList;
for (ObjAttrVector::Iterator it = itemAttributes().begin(); it!= itemAttributes().end(); ++it)
nameList.append((*it).name);
return nameList;
}
void ScribusDoc::addSymbols()
{
symReturn.resize(0);
symReturn.addQuadPoint(1.98438, 9.14062, 1.98438, 9.14062, 1.98438, 4.03125, 1.98438, 4.03125);
symReturn.addQuadPoint(1.98438, 4.03125, 1.98438, 4.03125, 0.546875, 3.45312, 1.09375, 4);
symReturn.addQuadPoint(0.546875, 3.45312, 0.546875, 3.45312, 0, 2.0625, 0, 2.92188);
symReturn.addQuadPoint(0, 2.0625, 0, 2.0625, 0.65625, 0.5, 0, 1.04688);
symReturn.addQuadPoint(0.65625, 0.5, 0.65625, 0.5, 2.3125, 0, 1.28125, 0);
symReturn.addQuadPoint(2.3125, 0, 2.3125, 0, 5.40625, 0, 5.40625, 0);
symReturn.addQuadPoint(5.40625, 0, 5.40625, 0, 5.40625, 0.84375, 5.40625, 0.84375);
symReturn.addQuadPoint(5.40625, 0.84375, 5.40625, 0.84375, 4.70312, 0.84375, 4.70312, 0.84375);
symReturn.addQuadPoint(4.70312, 0.84375, 4.70312, 0.84375, 4.70312, 9.14062, 4.70312, 9.14062);
symReturn.addQuadPoint(4.70312, 9.14062, 4.70312, 9.14062, 3.875, 9.14062, 3.875, 9.14062);
symReturn.addQuadPoint(3.875, 9.14062, 3.875, 9.14062, 3.875, 0.84375, 3.875, 0.84375);
symReturn.addQuadPoint(3.875, 0.84375, 3.875, 0.84375, 2.78125, 0.84375, 2.78125, 0.84375);
symReturn.addQuadPoint(2.78125, 0.84375, 2.78125, 0.84375, 2.78125, 9.14062, 2.78125, 9.14062);
symReturn.addQuadPoint(2.78125, 9.14062, 2.78125, 9.14062, 1.98438, 9.14062, 1.98438, 9.14062);
symNewLine.resize(0);
symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 0.90625, 2.64062, 0.90625, 2.64062);
symNewLine.addQuadPoint(0.90625, 2.64062, 0.90625, 2.64062, 1.4375, 1.92188, 1.26562, 2.1875);
symNewLine.addQuadPoint(1.4375, 1.92188, 1.4375, 1.92188, 1.76562, 1.14062, 1.75, 1.42188);
symNewLine.addQuadPoint(1.76562, 1.14062, 1.76562, 1.14062, 1.60938, 1.03125, 1.60938, 1.03125);
symNewLine.addQuadPoint(1.60938, 1.03125, 1.60938, 1.03125, 0.90625, 1.92188, 0.90625, 1.92188);
symNewLine.addQuadPoint(0.90625, 1.92188, 0.90625, 1.92188, 0, 2.90625, 0.578125, 2.23438);
symNewLine.addQuadPoint(0, 2.90625, 0, 2.90625, 0.75, 3.875, 0.75, 3.875);
symNewLine.addQuadPoint(0.75, 3.875, 0.75, 3.875, 1.57812, 4.78125, 1.1875, 4.40625);
symNewLine.addQuadPoint(1.57812, 4.78125, 1.57812, 4.78125, 1.65625, 4.79688, 1.65625, 4.79688);
symNewLine.addQuadPoint(1.65625, 4.79688, 1.65625, 4.79688, 1.76562, 4.65625, 1.76562, 4.65625);
symNewLine.addQuadPoint(1.76562, 4.65625, 1.76562, 4.65625, 0.90625, 3.17188, 1.73438, 4.34375);
symNewLine.addQuadPoint(0.90625, 3.17188, 0.90625, 3.17188, 0.96875, 3.125, 0.96875, 3.125);
symNewLine.addQuadPoint(0.96875, 3.125, 0.96875, 3.125, 6.75, 3.125, 6.75, 3.125);
symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.51562, 2.625, 6.51562, 2.625);
symNewLine.addQuadPoint(6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625, 6.51562, 2.625);
symNewLine.setMarker();
symNewLine.addQuadPoint(6.875, 0, 6.875, 0, 6.51562, 0, 6.51562, 0);
symNewLine.addQuadPoint(6.51562, 0, 6.51562, 0, 6.51562, 2.84375, 6.51562, 2.84375);
symNewLine.addQuadPoint(6.51562, 2.84375, 6.51562, 2.84375, 6.75, 3.125, 6.51562, 3.125);
symNewLine.addQuadPoint(6.75, 3.125, 6.75, 3.125, 6.85938, 3.0625, 6.85938, 3.0625);
symNewLine.addQuadPoint(6.85938, 3.0625, 6.85938, 3.0625, 6.875, 0, 6.875, 0);
symTab.resize(0);
symTab.addQuadPoint(4.82812, 3.96875, 4.82812, 3.96875, 4.5625, 3.73438, 4.5625, 3.96875);
symTab.addQuadPoint(4.5625, 3.73438, 4.5625, 3.73438, 5.07812, 3.10938, 4.5625, 3.57812);
symTab.addQuadPoint(5.07812, 3.10938, 5.07812, 3.10938, 0, 3.10938, 0, 3.10938);
symTab.addQuadPoint(0, 3.10938, 0, 3.10938, 0, 2.625, 0, 2.625);
symTab.addQuadPoint(0, 2.625, 0, 2.625, 5.53125, 2.625, 5.53125, 2.625);
symTab.addQuadPoint(5.53125, 2.625, 5.53125, 2.625, 6.3125, 1.8125, 6.3125, 1.8125);
symTab.addQuadPoint(6.3125, 1.8125, 6.3125, 1.8125, 5.64062, 1.29688, 5.64062, 1.29688);
symTab.addQuadPoint(5.64062, 1.29688, 5.64062, 1.29688, 0, 1.29688, 0, 1.29688);
symTab.addQuadPoint(0, 1.29688, 0, 1.29688, 0, 0.8125, 0, 0.8125);
symTab.addQuadPoint(0, 0.8125, 0, 0.8125, 5.01562, 0.8125, 5.01562, 0.8125);
symTab.addQuadPoint(5.01562, 0.8125, 5.01562, 0.8125, 4.45312, 0.265625, 4.45312, 0.453125);
symTab.addQuadPoint(4.45312, 0.265625, 4.45312, 0.265625, 4.6875, 0, 4.45312, 0);
symTab.addQuadPoint(4.6875, 0, 4.6875, 0, 5.90625, 0.828125, 4.875, 0);
symTab.addQuadPoint(5.90625, 0.828125, 5.90625, 0.828125, 6.9375, 1.79688, 6.9375, 1.64062);
symTab.addQuadPoint(6.9375, 1.79688, 6.9375, 1.79688, 5.95312, 2.96875, 6.9375, 1.95312);
symTab.addQuadPoint(5.95312, 2.96875, 5.95312, 2.96875, 4.82812, 3.96875, 4.98438, 3.96875);
symNonBreak.resize(0);
symNonBreak.addQuadPoint(1.32812, 2.59375, 1.32812, 2.59375, 0.390625, 2.21875, 0.796875, 2.59375);
symNonBreak.addQuadPoint(0.390625, 2.21875, 0.390625, 2.21875, 0, 1.3125, 0, 1.84375);
symNonBreak.addQuadPoint(0, 1.3125, 0, 1.3125, 0.390625, 0.390625, 0, 0.765625);
symNonBreak.addQuadPoint(0.390625, 0.390625, 0.390625, 0.390625, 1.32812, 0, 0.796875, 0);
symNonBreak.addQuadPoint(1.32812, 0, 1.32812, 0, 2.23438, 0.390625, 1.85938, 0);
symNonBreak.addQuadPoint(2.23438, 0.390625, 2.23438, 0.390625, 2.60938, 1.29688, 2.60938, 0.765625);
symNonBreak.addQuadPoint(2.60938, 1.29688, 2.60938, 1.29688, 2.23438, 2.21875, 2.60938, 1.84375);
symNonBreak.addQuadPoint(2.23438, 2.21875, 2.23438, 2.21875, 1.32812, 2.59375, 1.875, 2.59375);
symNewCol.resize(0);
symNewCol.addQuadPoint(1.73438, 0, 1.73438, 0, 2.67188, 0.109375, 2.03125, 0);
symNewCol.addQuadPoint(2.67188, 0.109375, 2.67188, 0.109375, 3.59375, 0.203125, 3.26562, 0.21875);
symNewCol.addQuadPoint(3.59375, 0.203125, 3.59375, 0.203125, 3.79688, 0.1875, 3.64062, 0.203125);
symNewCol.addQuadPoint(3.79688, 0.1875, 3.79688, 0.1875, 4, 0.171875, 3.92188, 0.171875);
symNewCol.addQuadPoint(4, 0.171875, 4, 0.171875, 4.20312, 0.1875, 4.20312, 0.1875);
symNewCol.addQuadPoint(4.20312, 0.1875, 4.20312, 0.1875, 4.3125, 1.39062, 4.20312, 0.5625);
symNewCol.addQuadPoint(4.3125, 1.39062, 4.3125, 1.39062, 4.42188, 2.64062, 4.42188, 2.21875);
symNewCol.addQuadPoint(4.42188, 2.64062, 4.42188, 2.64062, 4.28125, 2.73438, 4.28125, 2.73438);
symNewCol.addQuadPoint(4.28125, 2.73438, 4.28125, 2.73438, 3.75, 1.03125, 4.01562, 2.64062);
symNewCol.addQuadPoint(3.75, 1.03125, 3.75, 1.03125, 3.67188, 1.03125, 3.67188, 1.03125);
symNewCol.addQuadPoint(3.67188, 1.03125, 3.67188, 1.03125, 0.28125, 6.20312, 0.28125, 6.20312);
symNewCol.addQuadPoint(0.28125, 6.20312, 0.28125, 6.20312, 0, 5.95312, 0.03125, 6.17188);
symNewCol.addQuadPoint(0, 5.95312, 0, 5.95312, 3.35938, 0.71875, 3.35938, 0.71875);
symNewCol.addQuadPoint(3.35938, 0.71875, 3.35938, 0.71875, 3.375, 0.640625, 3.375, 0.640625);
symNewCol.addQuadPoint(3.375, 0.640625, 3.375, 0.640625, 2.4375, 0.484375, 2.79688, 0.5625);
symNewCol.addQuadPoint(2.4375, 0.484375, 2.4375, 0.484375, 1.67188, 0.140625, 1.71875, 0.328125);
symNewCol.addQuadPoint(1.67188, 0.140625, 1.67188, 0.140625, 1.73438, 0, 1.73438, 0);
symNewFrame.resize(0);
symNewFrame.addQuadPoint(1.75, 6.20312, 1.75, 6.20312, 2.67188, 6.09375, 2.0625, 6.20312);
symNewFrame.addQuadPoint(2.67188, 6.09375, 2.67188, 6.09375, 3.60938, 5.98438, 3.28125, 5.98438);
symNewFrame.addQuadPoint(3.60938, 5.98438, 3.60938, 5.98438, 3.84375, 6.01562, 3.6875, 5.98438);
symNewFrame.addQuadPoint(3.84375, 6.01562, 3.84375, 6.01562, 4.07812, 6.03125, 4, 6.03125);
symNewFrame.addQuadPoint(4.07812, 6.03125, 4.07812, 6.03125, 4.20312, 6.01562, 4.20312, 6.01562);
symNewFrame.addQuadPoint(4.20312, 6.01562, 4.20312, 6.01562, 4.32812, 4.79688, 4.21875, 5.625);
symNewFrame.addQuadPoint( 4.32812, 4.79688, 4.32812, 4.79688, 4.42188, 3.5625, 4.42188, 3.98438);
symNewFrame.addQuadPoint(4.42188, 3.5625, 4.42188, 3.5625, 4.29688, 3.45312, 4.29688, 3.45312);
symNewFrame.addQuadPoint(4.29688, 3.45312, 4.29688, 3.45312, 3.75, 5.17188, 4.03125, 3.54688);
symNewFrame.addQuadPoint(3.75, 5.17188, 3.75, 5.17188, 3.67188, 5.17188, 3.67188, 5.17188);
symNewFrame.addQuadPoint(3.67188, 5.17188, 3.67188, 5.17188, 0.28125, 0, 0.28125, 0);
symNewFrame.addQuadPoint(0.28125, 0, 0.28125, 0, 0, 0.25, 0.03125, 0.015625);
symNewFrame.addQuadPoint(0, 0.25, 0, 0.25, 3.375, 5.46875, 3.375, 5.46875);
symNewFrame.addQuadPoint(3.375, 5.46875, 3.375, 5.46875, 3.39062, 5.54688, 3.39062, 5.54688);
symNewFrame.addQuadPoint(3.39062, 5.54688, 3.39062, 5.54688, 2.4375, 5.70312, 2.8125, 5.625);
symNewFrame.addQuadPoint(2.4375, 5.70312, 2.4375, 5.70312, 1.67188, 6.0625, 1.71875, 5.875);
symNewFrame.addQuadPoint(1.67188, 6.0625, 1.67188, 6.0625, 1.75, 6.20312, 1.75, 6.20312);
}
ScPage* ScribusDoc::addPage(const int pageIndex, const QString& masterPageName, const bool addAutoFrame)
{
assert(masterPageMode()==false);
ScPage* addedPage = new ScPage(docPrefsData.displayPrefs.scratch.Left, DocPages.count()*(docPrefsData.docSetupPrefs.pageHeight+docPrefsData.displayPrefs.scratch.Bottom+docPrefsData.displayPrefs.scratch.Top)+docPrefsData.displayPrefs.scratch.Top, docPrefsData.docSetupPrefs.pageWidth, docPrefsData.docSetupPrefs.pageHeight);
assert(addedPage!=NULL);
addedPage->setDocument(this);
addedPage->Margins.Top = docPrefsData.docSetupPrefs.margins.Top;
addedPage->Margins.Bottom = docPrefsData.docSetupPrefs.margins.Bottom;
addedPage->initialMargins.Top = docPrefsData.docSetupPrefs.margins.Top;
addedPage->initialMargins.Bottom = docPrefsData.docSetupPrefs.margins.Bottom;
addedPage->initialMargins.Left = docPrefsData.docSetupPrefs.margins.Left;
addedPage->initialMargins.Right = docPrefsData.docSetupPrefs.margins.Right;
addedPage->setPageNr(pageIndex);
addedPage->m_pageSize = docPrefsData.docSetupPrefs.pageSize;
addedPage->setOrientation(docPrefsData.docSetupPrefs.pageOrientation);
addedPage->marginPreset = docPrefsData.docSetupPrefs.marginPreset;
DocPages.insert(pageIndex, addedPage);
assert(DocPages.at(pageIndex)!=NULL);
setCurrentPage(addedPage);
//if (!masterPageMode())
if (!masterPageName.isEmpty())
applyMasterPage(masterPageName, pageIndex);
setLocationBasedPageLRMargins(pageIndex);
if (addAutoFrame && automaticTextFrames)
addAutomaticTextFrame(pageIndex);
// if (!isLoading())
// changed();
return addedPage;
}
ScPage* ScribusDoc::addMasterPage(const int pageNumber, const QString& pageName)
{
//CB We dont create master pages (yet) with a pageCount based location
//Page* addedPage = new Page(ScratchLeft, MasterPages.count()*(pageHeight+ScratchBottom+ScratchTop)+ScratchTop, pageWidth, pageHeight);
ScPage* addedPage = new ScPage(docPrefsData.displayPrefs.scratch.Left, docPrefsData.displayPrefs.scratch.Top, docPrefsData.docSetupPrefs.pageWidth, docPrefsData.docSetupPrefs.pageHeight);
assert(addedPage!=NULL);
addedPage->setDocument(this);
addedPage->Margins = docPrefsData.docSetupPrefs.margins;
addedPage->initialMargins = docPrefsData.docSetupPrefs.margins;
addedPage->m_pageSize = docPrefsData.docSetupPrefs.pageSize;
addedPage->setOrientation(docPrefsData.docSetupPrefs.pageOrientation);
addedPage->marginPreset = docPrefsData.docSetupPrefs.marginPreset;
addedPage->MPageNam = "";
int pgN = pageNumber;
if (pageNumber > MasterPages.count())
pgN = MasterPages.count();
addedPage->setPageName(pageName);
addedPage->setPageNr(pgN);
MasterNames.insert(pageName, pgN);
MasterPages.insert(pgN, addedPage);
assert(MasterPages.at(pgN)!=NULL);
if (!isLoading())
changed();
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::NewMasterPage, "", Um::IDocument);
ss->set("MASTERPAGE_ADD", "masterpage_add");
ss->set("MASTERPAGE_NAME", pageName);
ss->set("MASTERPAGE_NBR", pgN);
undoManager->action(this, ss);
}
return addedPage;
}
bool ScribusDoc::renameMasterPage(const QString& oldPageName, const QString& newPageName)
{
Q_ASSERT(oldPageName!=CommonStrings::masterPageNormal && oldPageName!=CommonStrings::trMasterPageNormal);
if (!MasterNames.contains(oldPageName) || MasterNames.contains(newPageName))
return false;
//Rename our master page lists
int number = MasterNames[oldPageName];
MasterNames.insert(newPageName, number);
MasterNames.remove(oldPageName);
Q_ASSERT(MasterPages.at(number)->pageName()==oldPageName);
MasterPages.at(number)->setPageName(newPageName);
//Update any pages that were linking to our old name
ScPage* docPage=NULL;
for (int i=0; i < DocPages.count(); ++i )
{
docPage=DocPages[i];
if (docPage->MPageNam == oldPageName)
docPage->MPageNam = newPageName;
}
//Update any items that were linking to our old name
uint masterItemsCount=MasterItems.count();
for (uint i = 0; i < masterItemsCount; ++i)
{
if (MasterItems.at(i)->OnMasterPage == oldPageName)
MasterItems.at(i)->OnMasterPage = newPageName;
}
changed();
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::RenameMasterPage, "", Um::IDocument);
ss->set("MASTERPAGE_RENAME", "masterpage_rename");
ss->set("OLD_MASTERPAGE", oldPageName);
ss->set("NEW_MASTERPAGE", newPageName);
undoManager->action(this, ss);
}
return true;
}
void ScribusDoc::deleteMasterPage(const int pageNumber)
{
assert(masterPageMode());
assert( Pages->count() > 1 && Pages->count() > pageNumber );
setCurrentPage(Pages->at(0));
ScPage* page = Pages->takeAt(pageNumber);
QString oldPageName(page->pageName());
delete page;
// #10658 : renumber masterpages and masterpage objects
// in order to avoid crash after masterpage deletion
for (int i = 0; i < MasterPages.count(); ++i)
MasterPages.at(i)->setPageNr(i);
for (int i = 0; i < MasterItems.count(); ++i)
{
if (MasterItems.at(i)->OwnPage > pageNumber)
MasterItems.at(i)->OwnPage--;
}
// remove the master page from the master page name list
//MasterNames.remove(page->PageNam);
/*CB TODO moved back to muster.cpp for now as this must happen after reformPages
MasterNames.clear();
for (uint a = 0; a < Pages->count(); ++a)
MasterNames[Pages->at(a)->PageNam] = Pages->at(a)->pageNr();
// and fix up any pages that refer to the deleted master page
for (Page* docPage = DocPages.first(); docPage; docPage = DocPages.next() )
{
if (docPage->MPageNam == oldPageName)
docPage->MPageNam = CommonStrings::masterPageNormal;
}
*/
//QPtrList docs: The item after the removed item becomes the new current list item if the removed item is not the last item in the list. If the last item is removed, the new last item becomes the current item.
changed();
}
void ScribusDoc::rebuildMasterNames(void)
{
MasterNames.clear();
for (int i = 0; i < MasterPages.count(); ++i)
MasterNames[MasterPages.at(i)->pageName()] = i;
}
void ScribusDoc::replaceMasterPage(const QString& oldMasterPage)
{
uint pageIndex = 0;
QMap<QString,int>::Iterator it = MasterNames.begin();
QListIterator<ScPage *> dpIt(DocPages);
ScPage* docPage=NULL;
while(dpIt.hasNext())
//for (Page* docPage = currentDoc->DocPages.first(); docPage; docPage = currentDoc->DocPages.next() )
{
docPage=dpIt.next();
if (docPage->MPageNam == oldMasterPage)
{
PageLocation pageLoc = locationOfPage(pageIndex);
if (pageLoc == LeftPage)
{
if (MasterNames.contains( CommonStrings::trMasterPageNormalLeft))
docPage->MPageNam = CommonStrings::trMasterPageNormalLeft;
else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
docPage->MPageNam = CommonStrings::trMasterPageNormal;
else
docPage->MPageNam = it.key();
}
else if (pageLoc == RightPage)
{
if (MasterNames.contains( CommonStrings::trMasterPageNormalRight))
docPage->MPageNam = CommonStrings::trMasterPageNormalRight;
else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
docPage->MPageNam = CommonStrings::trMasterPageNormal;
else
docPage->MPageNam = it.key();
}
else
{
if (MasterNames.contains( CommonStrings::trMasterPageNormalMiddle))
docPage->MPageNam = CommonStrings::trMasterPageNormalMiddle;
else if (MasterNames.contains( CommonStrings::trMasterPageNormal))
docPage->MPageNam = CommonStrings::trMasterPageNormal;
else
docPage->MPageNam = it.key();
}
}
pageIndex++;
}
}
void ScribusDoc::deletePage(const int pageNumber)
{
assert( Pages->count() > 1 && Pages->count() > pageNumber );
//#5561: If we are going to delete the first page, do not set the current page to it
setCurrentPage(Pages->at(pageNumber!=0?0:1));
ScPage* page = Pages->takeAt(pageNumber);
delete page;
reformPages();
changed();
}
void ScribusDoc::movePage(const int fromPage, const int toPage, const int dest, const int position)
{
QList<ScPage*> pageList;
int numPages = dest;
pageList.clear();
for (int i = fromPage; i < toPage; ++i)
{
pageList.append(Pages->takeAt(fromPage));
if (i <= numPages)
--numPages;
}
int pageListCount=pageList.count();
switch (position)
{
case 0: //Before Page
for (int j = 0; j < pageListCount; ++j)
Pages->insert(numPages++, pageList.at(j));
break;
case 1: //After Page
for (int j = 0; j < pageListCount; ++j)
Pages->insert(++numPages, pageList.at(j));
break;
case 2: //To End
for (int j = 0; j < pageListCount; ++j)
Pages->append(pageList.at(j));
break;
}
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::MovePage, "", Um::IDocument);
ss->set("PAGE_MOVE", "page_move");
ss->set("PAGE_MOVE_FROM", fromPage);
ss->set("PAGE_MOVE_TO", toPage);
ss->set("PAGE_MOVE_DEST", dest);
ss->set("PAGE_MOVE_NEWPOS", position);
undoManager->action(this, ss, DocName, Um::IDocument);
}
reformPages();
if (m_View && m_ScMW)
{
m_View->reformPagesView();
m_ScMW->updateGUIAfterPagesChanged();
}
updateEndnotesFrames();
changed();
}
void ScribusDoc::restoreMovePage(SimpleState *state, bool isUndo)
{
int fromPage = state->getInt("PAGE_MOVE_FROM");
int toPage = state->getInt("PAGE_MOVE_TO");
int position = state->getInt("PAGE_MOVE_NEWPOS");
int dest = state->getInt("PAGE_MOVE_DEST");
if (isUndo)
{
int newPageDest = fromPage;
int newPageFrom = 0;
int newPageTo = 0;
int newPosition = 0;
int pagesMoved = toPage - fromPage;
switch (position)
{
case 0: //Before Page
newPageDest = (toPage <= dest) ? fromPage : toPage;
newPageFrom = (toPage <= dest) ? (dest - pagesMoved) : dest;
break;
case 1: //After Page
newPageDest = (toPage <= dest) ? fromPage : toPage;
newPageFrom = (toPage <= dest) ? (dest-pagesMoved + 1) : (dest + 1);
break;
case 2: //To End
newPageFrom = Pages->count() - pagesMoved;
break;
}
newPageTo = newPageFrom + pagesMoved;
movePage(newPageFrom, newPageTo, newPageDest, newPosition);
}
else
movePage(fromPage, toPage, dest, position);
}
int ScribusDoc::addAutomaticTextFrame(const int pageNumber)
{
if (!automaticTextFrames)
return -1;
ScPage *addToPage=DocPages.at(pageNumber);
if ((!masterPageMode()) && (usesAutomaticTextFrames()))// && (!isLoading()))
{
int z = itemAdd(PageItem::TextFrame, PageItem::Unspecified,
addToPage->Margins.Left+addToPage->xOffset(),
addToPage->Margins.Top+addToPage->yOffset(), docPrefsData.docSetupPrefs.pageWidth-addToPage->Margins.Right-addToPage->Margins.Left,
docPrefsData.docSetupPrefs.pageHeight-addToPage->Margins.Bottom-addToPage->Margins.Top,
1, CommonStrings::None, docPrefsData.itemToolPrefs.shapeLineColor, true);
Items->at(z)->isAutoText = true;
Items->at(z)->Cols = qRound(PageSp);
Items->at(z)->ColGap = PageSpa;
if (LastAuto != 0)
LastAuto->link(Items->at(z));
else
FirstAuto = Items->at(z);
LastAuto = Items->at(z);
Items->at(z)->setRedrawBounding();
updateEndnotesFrames();
return z;
}
return -1;
}
int ScribusDoc::addLayer(const QString& layerName, const bool activate)
{
int lId = Layers.addLayer(layerName);
if (lId==-1)
return -1;
if (activate)
setActiveLayer(lId);
const ScLayer* ll = Layers.layerByID(lId);
if (!ll)
qWarning() << "Layer added without undo, could not get layer back for undo action creation";
else
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::AddLayer, "", Um::ICreate);
ss->set("ADD_LAYER", "add_layer");
ss->set("ACTIVE", ActiveLayer);
ss->set("NAME", ll->Name);
ss->set("LAYER_NR", ll->ID);
undoManager->action(this, ss, DocName, Um::ILayer);
}
changed();
return lId;
}
void ScribusDoc::copyLayer(int layerIDToCopy, int whereToInsert)
{
if (!setActiveLayer(whereToInsert))
return;
Selection sourceSelection(this);
for (int ite = 0; ite < Items->count(); ++ite)
{
PageItem *itemToCopy = Items->at(ite);
if (itemToCopy->LayerID == layerIDToCopy)
{
sourceSelection.addItem(itemToCopy);
}
}
if (sourceSelection.count() != 0)
{
ScriXmlDoc ss;
QString dataS = ss.WriteElem(this, &sourceSelection);
ss.ReadElemToLayer(dataS, appPrefsData.fontPrefs.AvailFonts, this, Pages->at(0)->xOffset(), Pages->at(0)->yOffset(), false, true, appPrefsData.fontPrefs.GFontSub, whereToInsert);
}
sourceSelection.clear();
changed();
}
bool ScribusDoc::deleteLayer(const int layerID, const bool deleteItems)
{
if (Layers.count() < 2)
return false;
const ScLayer* lToRemove = Layers.layerByID(layerID);
if (!lToRemove)
return false;
int layerLevel = lToRemove->Level;
QString name = lToRemove->Name;
UndoTransaction activeTransaction;
if (UndoManager::undoEnabled())
activeTransaction = undoManager->beginTransaction(Um::Layer, Um::IDocument, Um::DeleteLayer, "", Um::IDelete);
rebuildItemLists();
if (ScCore->usingGUI())
removeLayer(layerID, deleteItems);
//Now delete the layer
Layers.removeLayerByID(layerID);
if (activeTransaction)
{
SimpleState *ss = new SimpleState(Um::DeleteLayer, "", Um::IDelete);
ss->set("REMOVE_LAYER", "remove_layer");
ss->set("ACTIVE", layerID);
ss->set("LEVEL", layerLevel);
ss->set("NAME", name);
ss->set("LAYER_NR", layerID);
ss->set("DELETE", deleteItems);
undoManager->action(this, ss, DocName, Um::ILayer);
activeTransaction.commit();
}
changed();
return true;
}
int ScribusDoc::activeLayer()
{
return ActiveLayer;
}
const QString& ScribusDoc::activeLayerName()
{
const ScLayer* ll = Layers.layerByID(ActiveLayer);
Q_ASSERT(ll);
return ll->Name;
}
bool ScribusDoc::setActiveLayer(const int layerToActivate)
{
const ScLayer* ll = Layers.layerByID(layerToActivate);
Q_ASSERT(ll);
if (ll)
ActiveLayer=layerToActivate;
return (ll != NULL);
}
bool ScribusDoc::setActiveLayer(const QString& layerNameToActivate)
{
const ScLayer* ll = Layers.layerByName(layerNameToActivate);
Q_ASSERT(ll);
if (ll)
ActiveLayer=ll->ID;
return (ll != NULL);
}
bool ScribusDoc::setLayerPrintable(const int layerID, const bool isPrintable)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
if (it->isPrintable!=isPrintable && UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(isPrintable ? Um::PrintLayer : Um::DoNotPrintLayer, "", Um::IPrint);
ss->set("PRINT_LAYER", "print_layer");
ss->set("ACTIVE", it->ID);
ss->set("PRINT", isPrintable);
undoManager->action(this, ss, it->Name, Um::ILayer);
}
it->isPrintable = isPrintable;
found=true;
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerPrintable(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->isPrintable;
}
return false;
}
bool ScribusDoc::setLayerVisible(const int layerID, const bool isViewable)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
it->isViewable = isViewable;
found=true;
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerVisible(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->isViewable;
}
return false;
}
bool ScribusDoc::setLayerSelectable(const int layerID, const bool isSelectable)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
it->isSelectable = isSelectable;
found=true;
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerSelectable(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->isSelectable;
}
return false;
}
bool ScribusDoc::setLayerLocked(const int layerID, const bool isLocked)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
// == because isEditable vs isLocked...
if (it->isEditable==isLocked && UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(isLocked ? Um::SetLayerLocked : Um::SetLayerUnlocked, "", Um::ILayer);
ss->set("LAYER_LOCK", "layer_lock");
ss->set("ACTIVE", it->ID);
ss->set("LOCK", isLocked);
undoManager->action(this, ss, it->Name, Um::ILayer);
}
it->isEditable = !isLocked;
found=true;
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerLocked(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return !it->isEditable;
}
return false;
}
bool ScribusDoc::setLayerFlow(const int layerID, const bool flow)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
if (it->flowControl!=flow && UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(flow ? Um::FlowLayer : Um::DisableFlowLayer, "", Um::ITextFrame);
ss->set("LAYER_FLOW", "layer_flow");
ss->set("ACTIVE", it->ID);
ss->set("FLOW", flow);
undoManager->action(this, ss, it->Name, Um::ILayer);
}
it->flowControl = flow;
found=true;
break;
}
}
if (found)
{
// #9188 : invalidate layout of items below layer
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
break;
invalidateLayer(it->ID);
}
changed();
}
return found;
}
bool ScribusDoc::layerFlow(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->flowControl;
}
return false;
}
bool ScribusDoc::setLayerTransparency(const int layerID, double trans)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
if (it->transparency!=trans && UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::SetLayerTransparency, "", Um::ILayer);
ss->set("LAYER_TRANSPARENCY", "layer_transparency");
ss->set("ACTIVE", it->ID);
ss->set("OLD_TRANS", it->transparency);
ss->set("NEW_TRANS", trans);
undoManager->action(this, ss, it->Name, Um::ILayer);
}
it->transparency = trans;
found=true;
break;
}
}
if (found)
changed();
return found;
}
double ScribusDoc::layerTransparency(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->transparency;
}
return 1.0;
}
bool ScribusDoc::setLayerBlendMode(const int layerID, int blend)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
if (it->blendMode!=blend && UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::SetLayerBlendMode, "", Um::ILayer);
ss->set("LAYER_BLENDMODE", "layer_blendmode");
ss->set("ACTIVE", it->ID);
ss->set("OLD_BLENDMODE", it->blendMode);
ss->set("NEW_BLENDMODE", blend);
undoManager->action(this, ss, it->Name, Um::ILayer);
}
it->blendMode = blend;
found=true;
break;
}
}
if (found)
changed();
return found;
}
int ScribusDoc::layerBlendMode(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->blendMode;
}
return 0;
}
bool ScribusDoc::setLayerOutline(const int layerID, const bool outline)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
it->outlineMode = outline;
found=true;
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerOutline(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->outlineMode;
}
return false;
}
bool ScribusDoc::setLayerMarker(const int layerID, QColor color)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
bool found=false;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
{
it->markerColor = color;
found=true;
break;
}
}
if (found)
changed();
return found;
}
QColor ScribusDoc::layerMarker(const int layerID)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->ID == layerID)
return it->markerColor;
}
return QColor(0, 0, 0);
}
int ScribusDoc::layerLevelFromID(const int layerID)
{
uint layerCount=Layers.count();
for (uint i=0; i < layerCount; ++i)
{
if (Layers[i].ID == layerID)
return Layers[i].Level;
}
return -1;
}
int ScribusDoc::layerCount() const
{
return Layers.count();
}
int ScribusDoc::layerIDFromLevel(const int layerLevel)
{
uint layerCount=Layers.count();
for (uint i=0; i < layerCount; ++i)
{
if (Layers[i].Level == layerLevel)
return Layers[i].ID;
}
return -1;
}
int ScribusDoc::layerIDFromName(QString name)
{
ScLayers::iterator itend=Layers.end();
ScLayers::iterator it;
for (it = Layers.begin(); it != itend; ++it)
{
if (it->Name == name)
return it->ID;
}
return -1;
}
bool ScribusDoc::lowerLayer(const int layerID)
{
return lowerLayerByLevel(layerLevelFromID(layerID));
}
bool ScribusDoc::lowerLayerByLevel(const int layerLevel)
{
if (Layers.count() < 2)
return false;
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::LowerLayer, "", Um::IDown);
ss->set("DOWN_LAYER", "down_layer");
ss->set("ACTIVE", layerIDFromLevel(layerLevel));
undoManager->action(this, ss, DocName, Um::ILayer);
}
ScLayers::iterator it;
ScLayers::iterator itend=Layers.end();
for (it = Layers.begin(); it != itend; ++it)
{
if (it->Level == layerLevel-1)
break;
}
ScLayers::iterator it2;
ScLayers::iterator it2end=Layers.end();
for (it2 = Layers.begin(); it2 != it2end; ++it2)
{
if (it2->Level == layerLevel)
break;
}
it2->Level -= 1;
it->Level += 1;
// #9188 : invalidate layout of items in below layers
int maxLevel = qMax(it->Level, it2->Level);
for (it = Layers.begin(); it != itend; ++it)
{
if (it->flowControl)
invalidateLayer(it->ID);
if (it->Level == maxLevel)
break;
}
return true;
}
bool ScribusDoc::raiseLayer(const int layerID)
{
return raiseLayerByLevel(layerLevelFromID(layerID));
}
bool ScribusDoc::raiseLayerByLevel(const int layerLevel)
{
if (Layers.count() < 2)
return false;
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::RaiseLayer, "", Um::IUp);
ss->set("UP_LAYER", "up_layer");
ss->set("ACTIVE", layerIDFromLevel(layerLevel));
undoManager->action(this, ss, DocName, Um::ILayer);
}
ScLayers::iterator it;
ScLayers::iterator itend=Layers.end();
for (it = Layers.begin(); it != itend; ++it)
{
if (it->Level == layerLevel+1)
break;
}
ScLayers::iterator it2;
ScLayers::iterator it2end=Layers.end();
for (it2 = Layers.begin(); it2 != it2end; ++it2)
{
if (it2->Level == layerLevel)
break;
}
it2->Level += 1;
it->Level -= 1;
// #9188 : invalidate layout of items in below layers
int maxLevel = qMax(it->Level, it2->Level);
for (it = Layers.begin(); it != itend; ++it)
{
if (it->flowControl)
invalidateLayer(it->ID);
if (it->Level == maxLevel)
break;
}
return true;
}
QString ScribusDoc::layerName(const int layerID) const
{
uint layerCount=Layers.count();
for (uint i=0; i < layerCount; ++i)
{
if (Layers[i].ID == layerID)
return Layers[i].Name;
}
return QString::null;
}
bool ScribusDoc::changeLayerName(const int layerID, const QString& newName)
{
uint layerCount=Layers.count();
bool found=false;
for (uint i=0; i < layerCount; ++i)
{
if (Layers[i].ID == layerID)
{
if (Layers[i].Name != newName)
{
if (UndoManager::undoEnabled())
{
SimpleState *ss = new SimpleState(Um::SetLayerName,
QString(Um::FromTo).arg(Layers[i].Name).arg(newName),
Um::IDown);
ss->set("CHANGE_NAME", "change_name");
ss->set("ACTIVE", ActiveLayer);
ss->set("NEW_NAME", newName);
ss->set("OLD_NAME", Layers[i].Name);
undoManager->action(this, ss, DocName, Um::ILayer);
}
Layers[i].Name = newName;
found=true;
}
break;
}
}
if (found)
changed();
return found;
}
bool ScribusDoc::layerContainsItems(const int layerID)
{
QList<PageItem*> allItems;
uint masterItemsCount=MasterItems.count();
for (uint i = 0; i < masterItemsCount; ++i)
{
PageItem* currItem = MasterItems.at(i);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->LayerID == layerID)
return true;
}
allItems.clear();
}
uint docItemsCount=DocItems.count();
for (uint i = 0; i < docItemsCount; ++i)
{
PageItem* currItem = DocItems.at(i);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if (currItem->LayerID == layerID)
return true;
}
allItems.clear();
}
return false;
}
void ScribusDoc::orderedLayerList(QStringList* list)
{
Q_ASSERT(list!=NULL);
uint layerCount=Layers.count();
if (layerCount != 0)
{
for (uint i=0; i < layerCount; ++i)
{
ScLayers::iterator itend=Layers.end();
for (ScLayers::iterator it = Layers.begin(); it != itend; ++it)
{
if (layerCount-(*it).Level-1 == i)
list->append((*it).Name);
}
}
}
}
int ScribusDoc::firstLayerID()
{
QStringList newNames;
orderedLayerList(&newNames);
return layerIDFromName(newNames.first());
}
bool ScribusDoc::renumberLayer(const int layerID, const int newLayerID)
{
uint layerCount=Layers.count();
uint foundIndex = 0;
bool found=false;
//Find layer to renumber, if found the new number, return as it exists already.
for (uint i=0; i < layerCount; ++i)
{
if (Layers[i].ID == layerID)
{
foundIndex=i;
found=true;
}
else
if (Layers[i].ID == newLayerID)
return false;
}
if (!found)
return false;
Layers[foundIndex].ID=newLayerID;
return true;
}
//Make the doc delete the items, not the view. TODO: Currently does nada, zilch, zero
bool ScribusDoc::deleteTaggedItems()
{
QString tooltip = Um::ItemsInvolved + "\n";
//Master Items
for (int b = 0; b < MasterItems.count(); ++b)
{
if (MasterItems.at(b)->isTagged())
{
}
}
//Doc Items
for (int b = 0; b < DocItems.count(); ++b)
{
if (DocItems.at(b)->isTagged())
{
}
}
return true;
}
void ScribusDoc::replaceLineStyleColors(const QMap<QString, QString>& colorMap)
{
multiLine::iterator its;
QMap<QString, QString>::const_iterator it;
QHash<QString,multiLine>::iterator itl;
for (itl = MLineStyles.begin(); itl != MLineStyles.end(); ++itl)
{
multiLine& mline = itl.value();
for (its = mline.begin(); its != mline.end(); ++its)
{
struct SingleLine& sline = *its;
it = colorMap.find(sline.Color);
if (it != colorMap.end())
sline.Color = it.value();
}
}
}
void ScribusDoc::getUsedColors(ColorList &colorsToUse, bool spot)
{
bool found;
colorsToUse.clear();
colorsToUse.setDocument(this);
ColorList::Iterator it;
ResourceCollection resources;
this->getNamedResources(resources);
const QMap<QString, QString>& resColors = resources.colors();
for (it = PageColors.begin(); it != PageColors.end(); ++it)
{
found = false;
// Tool preferences colors
if ((it.key() == docPrefsData.itemToolPrefs.shapeFillColor) || (it.key() == docPrefsData.itemToolPrefs.shapeLineColor) || (it.key() == docPrefsData.itemToolPrefs.imageFillColor)
|| (it.key() == docPrefsData.itemToolPrefs.imageStrokeColor) || (it.key() == docPrefsData.itemToolPrefs.lineColor) || (it.key() == docPrefsData.itemToolPrefs.textColor))
{
if (spot)
{
if (it.value().isSpotColor())
colorsToUse.insert(it.key(), it.value());
}
else
colorsToUse.insert(it.key(), it.value());
continue;
}
// Current paragraph style colors
if ((it.key() == currentStyle.charStyle().fillColor()) || (it.key() == currentStyle.charStyle().strokeColor()))
found = true;
// Resources colors
if (!found)
found = resColors.contains(it.key());
// Line styles colors
if (!found)
found = lineStylesUseColor(it.key());
if (found)
{
if (spot)
{
if (it.value().isSpotColor())
colorsToUse.insert(it.key(), it.value());
}
else
colorsToUse.insert(it.key(), it.value());
continue;
}
}
}
bool ScribusDoc::lineStylesUseColor(const QString& colorName)
{
bool found = false;
QHash<QString,multiLine>::const_iterator itm, itmend;
multiLine::const_iterator its, itsend;
itmend = MLineStyles.constEnd();
for (itm = MLineStyles.constBegin(); itm != itmend && !found; ++itm)
{
const multiLine& ml = itm.value();
itsend = ml.constEnd();
for (its = ml.constBegin(); its != itsend; ++its)
{
if ( its->Color == colorName )
{
found = true;
break;
}
}
}
return found;
}
void ScribusDoc::getUsedGradients(QHash<QString, VGradient> &gradients)
{
ResourceCollection resources;
this->getNamedResources(resources);
const QMap<QString, QString>& resGradients = resources.gradients();
QHash<QString, VGradient>::iterator it;
for (it = docGradients.begin(); it != docGradients.end(); ++it)
{
if (resGradients.contains(it.key()))
gradients.insert(it.key(), docGradients[it.key()]);
}
}
bool ScribusDoc::addGradient(QString &name, VGradient &gradient)
{
for (QHash<QString, VGradient>::Iterator it = docGradients.begin(); it != docGradients.end(); ++it)
{
if (it.value() == gradient)
{
name = it.key();
return false;
}
}
QString tmp;
if (docGradients.contains(name))
name += "("+tmp.setNum(docGradients.count())+")";
docGradients.insert(name, gradient);
return true;
}
void ScribusDoc::setGradients(QHash<QString, VGradient> &gradients)
{
docGradients.clear();
docGradients = gradients;
}
bool ScribusDoc::addPattern(QString &name, ScPattern& pattern)
{
QString tmp;
if (docPatterns.contains(name))
name += "("+tmp.setNum(docPatterns.count())+")";
// name = tr("Copy_of_")+name;
docPatterns.insert(name, pattern);
QList<PageItem*> allItems = getAllItems(pattern.items);
for (int i = 0; i < allItems.count(); i++)
{
PageItem* currItem = allItems.at(i);
currItem->setLayer(0);
}
return true;
}
ScPattern* ScribusDoc::checkedPattern(QString &name)
{
if (name.isEmpty() || !docPatterns.contains(name))
return 0;
ScPattern* pattern = &docPatterns[name];
if (pattern->width <= 0 || pattern->height <= 0)
return 0;
if (pattern->getPattern()->isNull())
return 0;
return pattern;
}
void ScribusDoc::setPatterns(QHash<QString, ScPattern> &patterns)
{
docPatterns.clear();
docPatterns = patterns;
}
QStringList ScribusDoc::getUsedPatterns()
{
QList<PageItem*> allItems;
QStringList results;
for (int c = 0; c < MasterItems.count(); ++c)
{
PageItem* currItem = MasterItems.at(c);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if ((!results.contains(currItem->pattern())) && ((currItem->GrType == 8) || (currItem->itemType() == PageItem::Symbol)))
results.append(currItem->pattern());
if (!currItem->strokePattern().isEmpty())
{
if (!results.contains(currItem->strokePattern()))
results.append(currItem->strokePattern());
}
if (!currItem->patternMask().isEmpty())
{
if (!results.contains(currItem->patternMask()))
results.append(currItem->patternMask());
}
}
allItems.clear();
}
for (int c = 0; c < DocItems.count(); ++c)
{
PageItem* currItem = DocItems.at(c);
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if ((!results.contains(currItem->pattern())) && ((currItem->GrType == 8) || (currItem->itemType() == PageItem::Symbol)))
results.append(currItem->pattern());
if (!currItem->strokePattern().isEmpty())
{
if (!results.contains(currItem->strokePattern()))
results.append(currItem->strokePattern());
}
if (!currItem->patternMask().isEmpty())
{
if (!results.contains(currItem->patternMask()))
results.append(currItem->patternMask());
}
}
allItems.clear();
}
for (QHash<int, PageItem*>::iterator itf = FrameItems.begin(); itf != FrameItems.end(); ++itf)
{
PageItem *currItem = itf.value();
if (currItem->isGroup())
allItems = currItem->asGroupFrame()->getItemList();
else
allItems.append(currItem);
for (int ii = 0; ii < allItems.count(); ii++)
{
currItem = allItems.at(ii);
if ((!results.contains(currItem->pattern())) && ((currItem->GrType == 8) || (currItem->itemType() == PageItem::Symbol)))
results.append(currItem->pattern());
if (!currItem->strokePattern().isEmpty())
{
if (!results.contains(currItem->strokePattern()))
results.append(currItem->strokePattern());
}
if (!currItem->patternMask().isEmpty())
{
if (!results.contains(currItem->patternMask()))
results.append(currItem->patternMask());
}
}
allItems.clear();
}
for (QHash<QString, ScPattern>::Iterator it = docPatterns.begin(); it != docPatterns.end(); ++it)
{
for