Subversion Repositories Scribus

Rev

Rev 19374 | Rev 19413 | 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 "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();
}

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;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Rgb)
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput3 = 3;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Cmyk)
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput3 = 4;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Cmy)
                        docPrefsData.colorPrefs.DCMSset.ComponentsInput3 = 3;
        if (DocPrinterProf.colorSpace() == ColorSpace_Rgb)
                        docPrefsData.colorPrefs.DCMSset.ComponentsPrinter = 3;
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmyk)
                        docPrefsData.colorPrefs.DCMSset.ComponentsPrinter = 4;
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmy)
                        docPrefsData.colorPrefs.DCMSset.ComponentsPrinter = 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." );
                if (ScCore->usingGUI())
                        QMessageBox::warning(m_ScMW, CommonStrings::trWarning, message, QMessageBox::Ok, 0, 0);
                else
                        qWarning( "%s", message.toLocal8Bit().data() );
        }
        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 ff = 0; ff < paragraphStyles().count(); ++ff)
        {
                if (paragraphStyles()[ff].name() == styleName)
                        return true;
        }
        return false;
}

QList<int> ScribusDoc::getSortedStyleList()
{
        QList<int> retList;
        for (int ff = 0; ff < docParagraphStyles.count(); ++ff)
        {
                if (docParagraphStyles[ff].parent().isEmpty())
                {
                        if (!retList.contains(ff))
                                retList.append(ff);
                        continue;
                }

                QList<int> retList2;
                QString name = docParagraphStyles[ff].name();
                QString par  = docParagraphStyles[ff].parent();
                retList2.prepend(ff);
                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 ff = 0; ff < docCharStyles.count(); ++ff)
        {
                if (docCharStyles[ff].parent().isEmpty())
                {
                        if (!retList.contains(ff))
                                retList.append(ff);
                        continue;
                }

                QList<int> retList2;
                QString name = docCharStyles[ff].name();
                QString par  = docCharStyles[ff].parent();
                retList2.prepend(ff);
                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 ff = 0; ff < docTableStyles.count(); ++ff)
        {
                if (docTableStyles[ff].parent().isEmpty())
                {
                        if (!retList.contains(ff))
                                retList.append(ff);
                        continue;
                }

                QList<int> retList2;
                QString name = docTableStyles[ff].name();
                QString par  = docTableStyles[ff].parent();
                retList2.prepend(ff);
                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 ff = 0; ff < docCellStyles.count(); ++ff)
        {
                if (docCellStyles[ff].parent().isEmpty())
                {
                        if (!retList.contains(ff))
                                retList.append(ff);
                        continue;
                }

                QList<int> retList2;
                QString name = docCellStyles[ff].name();
                QString par  = docCellStyles[ff].parent();
                retList2.prepend(ff);
                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();
                        }
                }
        }
}

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 a = 0; a < MasterPages.count(); ++a)
                MasterNames[MasterPages.at(a)->pageName()] = a;
}


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);
        }
        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();
}


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 = NULL;
        if (UndoManager::undoEnabled())
                activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::Layer, Um::IDocument, Um::DeleteLayer, "", Um::IDelete));

        rebuildItemLists();
        if (ScCore->usingGUI())
                removeLayer(layerID, deleteItems);

        /*
        //Layer found, do we want to delete its items too?
        if (masterPageMode)
                MasterPages = Pages;
        else
                DocPages = Pages;
        for (uint b = 0; b < MasterItems.count(); ++b)
        {
                if (MasterItems.at(b)->LayerID == layerID)
                {
                        if (deleteItems)
                        {
                                MasterItems.at(b)->setTagged(true);
                                MasterItems.at(b)->setLocked(false);
                        }
                        else
                                MasterItems.at(b)->setTagged(false);
                }
        }
//      if (view->SelItem.count() != 0)
//              view->DeleteItem();
//      view->SelItem.clear();
        for (uint b = 0; b < DocItems.count(); ++b)
        {
                if (DocItems.at(b)->LayerID == l)
                {
                        if (deleteItems)
                        {
                                DocItems.at(b)->setTagged(true);
                                DocItems.at(b)->setLocked(false);
                        }
                        else
                                DocItems.at(b)->setLayer(0);
                }
        }
//      if (view->SelItem.count() != 0)
//              view->DeleteItem();

        bool deletedOk=deleteTaggedItems();
        Q_ASSERT(deletedOk);

        */

        //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();
                delete activeTransaction;
                activeTransaction = NULL;
        }
//      setActiveLayer(layerIDFromLevel(0));
        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 ii = 0; ii < allItems.count(); ii++)
        {
                PageItem* currItem = allItems.at(ii);
                currItem->setLayer(0);
        }
        return true;
}

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();
        }
  &n