Subversion Repositories Scribus

Rev

Rev 16396 | Rev 16497 | 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 <QEventLoop>
#include <QFile>
#include <QList>
#include <QTime>
#include <QPainter>
#include <QPixmap>
#include <QProgressBar>

#include "canvas.h"
#include "colorblind.h"
#include "commonstrings.h"
#include "desaxe/digester.h"
//#include "desaxe/saxXML.h"
#include "fileloader.h"
#include "filewatcher.h"
#include "ui/guidemanager.h"
#include "hyphenator.h"
#include "page.h"
#include "pageitem.h"
#include "pageitem_imageframe.h"
#include "pageitem_latexframe.h"
#include "pageitem_line.h"
#include "pageitem_pathtext.h"
#include "pageitem_polygon.h"
#include "pageitem_polyline.h"
#include "pageitem_textframe.h"
#ifdef HAVE_OSG
        #include "pageitem_osgframe.h"
#endif
#include "pageitem_symbol.h"
#include "pageitem_group.h"
#include "pageitem_regularpolygon.h"
#include "pageitem_arc.h"
#include "pageitem_spiral.h"
#include "ui/pagepalette.h"
#include "pagesize.h"
#include "pagestructs.h"
#include "prefsfile.h"
#include "prefsmanager.h"
#include "resourcecollection.h"
#include "sccolorengine.h"
#include "ui/scmessagebox.h"
#include "colormgmt/sccolormgmtenginefactory.h"
#include "scclocale.h"
#include "scpainter.h"
#include "sclimits.h"
#include "scraction.h"
#include "scribus.h"
#include "scribusXml.h"
#include "scribuscore.h"
#include "scribusdoc.h"
#include "scribusview.h"
#include "scribuswin.h"
#include "selection.h"
#include "serializer.h"
#include "ui/hruler.h"
#include "ui/layers.h"
#include "ui/storyeditor.h"
#include "text/nlsconfig.h"
#include "undomanager.h"
#include "undostate.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<Page*>, 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(Page* pg)
        {
                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)
        {
                it->invalidateLayout();
                doc->regionsChanged()->update(it->getVisualBoundingRect());
                if (m_updateEnabled <= 0)
                {
                        doc->changed();
                        return;
                }
                m_docChangeNeeded = true;
        }
};




ScribusDoc::ScribusDoc() : UndoObject( tr("Document")), Observable<ScribusDoc>(NULL),
        m_hasGUI(false),
        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_ScMW(0),
        m_View(0),
        m_guardedObject(this),
        m_serializer(NULL),
        is12doc(false),
        NrItems(0),
        First(1), Last(0),
        viewCount(0), viewID(0),
        SnapGuides(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),
        useRaster(false),
        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(),
        Layers(),
        GroupCounter(1),
        colorEngine(ScCore->defaultEngine),
        JavaScripts(),
        TotalItems(0),
        RePos(false),
        BookMarks(),
        OldBM(false),
        hasName(false),
        autoSaveTimer(new QTimer(this)),
        MLineStyles(),
        WinHan(0),
        DoDrawing(true),
        OpenNodes(),
        CurTimer(0),
        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)
{
        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;
        previewVisual = -1;
}


ScribusDoc::ScribusDoc(const QString& docName, int unitindex, const PageSize& pagesize, const MarginStruct& margins, const DocPagesSetup& pagesSetup) : UndoObject( tr("Document")),
        m_hasGUI(false),
        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_ScMW(0),
        m_View(0),
        m_guardedObject(this),
        m_serializer(NULL),
        is12doc(false),
        NrItems(0),
        First(1), Last(0),
        viewCount(0), viewID(0),
        SnapGuides(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),
        useRaster(false),
        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(),
        Layers(),
        GroupCounter(1),
        colorEngine(ScCore->defaultEngine),
        JavaScripts(),
        TotalItems(0),
        RePos(false),
        BookMarks(),
        OldBM(false),
        hasName(false),
        autoSaveTimer(new QTimer(this)),
        MLineStyles(),
        WinHan(0),
        DoDrawing(true),
        OpenNodes(),
        CurTimer(0),
        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)
{
        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;
        previewVisual = -1;
}


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.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.calligrapicPenFillColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.calligrapicPenFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligrapicPenFillColor]);
        if (appPrefsData.itemToolPrefs.calligrapicPenLineColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.calligrapicPenLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.calligrapicPenLineColor]);

       
        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.setDropCapLines(2);
        pstyle.setDropCapOffset(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;
       
        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();
}


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->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->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 < FrameItems.count(); ++a)
        {
                PageItem *currItem = FrameItems.at(a);
                if (currItem->isGroup())
                        allItems = currItem->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->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();
                }
        }
        docPatterns.clear();
        docGradients.clear();
        while (!DocItems.isEmpty())
        {
                delete DocItems.takeFirst();
        }
        while (!FrameItems.isEmpty())
        {
                delete FrameItems.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;
        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->getItemList();
        }
        return ret;
}

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();
        m_ScMW->mainWindowProgressBar->setMaximum(cc);
        qApp->changeOverrideCursor(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;
                m_ScMW->recalcColors(m_ScMW->mainWindowProgressBar);
                RecalcPictures(&ScCore->InputProfiles, &ScCore->InputProfilesCMYK, m_ScMW->mainWindowProgressBar);
        }
        else
        {
                SetDefaultCMSParams();
                HasCMS = false;
        }
        m_ScMW->mainWindowProgressBar->setValue(cc);
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
        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 if (itemlist == &DocItems)
                        itemlist = &FrameItems;
                else
                        itemlist = NULL;
        }
        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 (uint i = 0; i < docLineStyles.count(); ++i)
//              docLineStyles[i].getNamedResources(lists);
       
        QMap<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);
                }
        }
        QMap<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 < paragraphStyles().count(); ++ff)
        {
                if (paragraphStyles()[ff].parent().isEmpty())
                {
                        if (!retList.contains(ff))
                                retList.append(ff);
                }
                else
                {
                        QList<int> retList2;
                        QString par = paragraphStyles()[ff].parent();
                        retList2.prepend(ff);
                        while (!par.isEmpty())
                        {
                                for (int pp = 0; pp < paragraphStyles().count(); ++pp)
                                {
                                        if (paragraphStyles()[pp].name() == par)
                                        {
                                                if (!retList2.contains(pp))
                                                        retList2.prepend(pp);
                                                par = paragraphStyles()[pp].parent();
                                        }
                                }
                        }
                        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);
                }
                else
                {
                        QList<int> retList2;
                        QString par = docCharStyles[ff].parent();
                        retList2.prepend(ff);
                        while (!par.isEmpty())
                        {
                                for (int pp = 0; pp < docCharStyles.count(); ++pp)
                                {
                                        if (docCharStyles[pp].name() == par)
                                        {
                                                if (!retList2.contains(pp))
                                                        retList2.prepend(pp);
                                                par = docCharStyles[pp].parent();
                                        }
                                }
                        }
                        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
        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 if (itemlist == &DocItems)
                        itemlist = &FrameItems;
                else
                        itemlist = NULL;
        }
       
        // 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);
        }

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

        QMap<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();       
        }
        else
        {
                if (newNames.charStyles().count() > 0)
                        docCharStyles.invalidate();
                if (newNames.styles().count() > 0)
                        docParagraphStyles.invalidate();       
        }
        if (!isLoading() && !(newNames.colors().isEmpty() && newNames.fonts().isEmpty() && newNames.patterns().isEmpty()
                                                  && newNames.styles().isEmpty() && newNames.charStyles().isEmpty() && newNames.lineStyles().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::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();
}

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


/*
 * 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;
        QMap<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(fileName, this, *wrkStyles))
                {
                        //TODO put in nice user warning
                }

                if (!fl.ReadCharStyles(fileName, this, *wrkCharStyles))
                {
                        //TODO put in nice user warning
                }

                if (!fl.ReadLineStyles(fileName, 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,
                                                      QMap<QString, multiLine> *tempLineStyles)
{
        StyleSet<ParagraphStyle> *wrkStyles     = tempStyles;
        StyleSet<CharStyle> *wrkCharStyles      = tempCharStyles;
        QMap<QString, multiLine> *wrkLineStyles = tempLineStyles;
       
        if (!fileName.isEmpty())
        {
                FileLoader fl(fileName);
                if (fl.TestFile() == -1)
                //TODO put in nice user warning
                        return;

                if (!fl.ReadStyles(fileName, this, *wrkStyles))
                {
                        //TODO put in nice user warning
                }

                if (!fl.ReadCharStyles(fileName, this, *wrkCharStyles))
                {
                        //TODO put in nice user warning
                }

                if (!fl.ReadLineStyles(fileName, 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();
        // #9500 : Ensure PP is properly disabled when selection is empty
        // after undoing or redoing an action
        if (m_Selection->count() == 0)
                emit firstSelectedItemType(-1);
}

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"))
                        restoreUngrouping(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("FLOW_LAYER"))
                {
                        bool flow = ss->getBool("FLOW");
                        setLayerFlow(ss->getInt("ACTIVE"), isUndo ? !flow : flow);
                        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("OLD_MASTERPAGE"))
                        restoreMasterPageApplying(ss, isUndo);
                else if (ss->contains("COPY_PAGE"))
                        restorePageCopy(ss, isUndo);

                if (layersUndo)
                {
                        if (ScCore->usingGUI())
                        {
                                m_ScMW->changeLayer(ss->getInt("ACTIVE"));
                                m_ScMW->layerPalette->rebuildList();
                        }
                }
        }
}

void ScribusDoc::restoreGrouping(SimpleState *state, bool isUndo)
{
        double x, y, w, h;
        Selection tmpSelection(this, false);
        int itemCount = state->getInt("itemcount");
        m_Selection->setGroupRect();
        m_Selection->getGroupRect(&x, &y, &w, &h);
        m_Selection->delaySignalsOn();
        m_Selection->clear();
        for (int i = 0; i < itemCount; ++i)
        {
                int itemNr = getItemNrfromUniqueID(state->getUInt(QString("item%1").arg(i)));
                if (Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
                        tmpSelection.addItem(Items->at(itemNr));
        }
        if (isUndo)
                itemSelection_UnGroupObjects(&tmpSelection);
        else
                itemSelection_GroupObjects(false, false, &tmpSelection);
        QRectF rect(x, y , w, h);
        regionsChanged()->update(rect.adjusted(-10, -10, 20, 20));
        m_Selection->delaySignalsOff();
}

void ScribusDoc::restoreUngrouping(SimpleState *state, bool isUndo)
{
        double x, y, w, h;
        Selection tmpSelection(this, false);
        int itemCount = state->getInt("itemcount");
        m_Selection->setGroupRect();
        m_Selection->getGroupRect(&x, &y, &w, &h);
        m_Selection->delaySignalsOn();
        m_Selection->clear();
        for (int i = 0; i < itemCount; ++i)
        {
                int itemNr = getItemNrfromUniqueID(state->getUInt(QString("item%1").arg(i)));
                if (Items->at(itemNr)->uniqueNr == state->getUInt(QString("item%1").arg(i)))
                {
                        if (isUndo)
                                Items->at(itemNr)->isTableItem = static_cast<bool>(state->getInt(QString("tableitem%1").arg(i)));
                        tmpSelection.addItem(Items->at(itemNr));
                }
        }
        if (isUndo)
                itemSelection_GroupObjects(false, false, &tmpSelection);
        else
                itemSelection_UnGroupObjects(&tmpSelection);
        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.addQuadPoint(999999, 999999, 999999, 999999, 999999, 999999, 999999, 999999);
        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);
}


Page* ScribusDoc::addPage(const int pageIndex, const QString& masterPageName, const bool addAutoFrame)
{
        assert(masterPageMode()==false);
        Page* addedPage = new Page(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;
}


Page* 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);
        Page* addedPage = new Page(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 = "";
        addedPage->setPageName(pageName);
        addedPage->setPageNr(pageNumber);
        MasterNames.insert(pageName, pageNumber);
        MasterPages.insert(pageNumber, addedPage);
        assert(MasterPages.at(pageNumber)!=NULL);
        if  (!isLoading())
                changed();
        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))
        {
                //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
                Page* 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();
                return true;
        }
        return false;
}


void ScribusDoc::deleteMasterPage(const int pageNumber)
{
        assert(masterPageMode());
        assert( Pages->count() > 1 && Pages->count() > pageNumber );
        setCurrentPage(Pages->at(0));
        Page* page = Pages->takeAt(pageNumber);
        QString oldPageName(page->pageName());
        delete page;
        // 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()] = MasterPages.at(a)->pageNr();
}


void ScribusDoc::replaceMasterPage(const QString& oldMasterPage)
{
        uint pageIndex = 0;
        QMap<QString,int>::Iterator it = MasterNames.begin();
        QListIterator<Page *> dpIt(DocPages);
        Page* 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));
        Page* page = Pages->takeAt(pageNumber);
        delete page;
        changed();
}


void ScribusDoc::movePage(const int from, const int to, const int ziel, const int art)
{
        QList<Page*> Buf;
        int zz = ziel;
        Buf.clear();
        for (int a = from; a < to; ++a)
        {
                Buf.append(Pages->takeAt(from));
                if (a <= zz)
                        --zz;
        }
        int bufCount=Buf.count();
        switch (art)
        {
                case 0:
                        for (int b = 0; b < bufCount; ++b)
                                Pages->insert(zz++, Buf.at(b));
                        break;
                case 1:
                        for (int b = 0; b < bufCount; ++b)
                                Pages->insert(++zz, Buf.at(b));
                        break;
                case 2:
                        for (int b = 0; b < bufCount; ++b)
                                Pages->append(Buf.at(b));
                        break;
        }
        changed();
}


int ScribusDoc::addAutomaticTextFrame(const int pageNumber)
{
        if (!automaticTextFrames)
                return -1;
        Page *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();
                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 = new ScriXmlDoc();
                        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);
                        delete ss;
                }
                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("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)
                {
                        bool oldPrintable = (*it).isPrintable;
                        it->isPrintable = isPrintable;

                        if (oldPrintable!=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::IDocument);
                        }
                        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::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)
                {
                        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)
                {
                        bool oldFlow = it->flowControl;
                        it->flowControl = flow;

                        if (oldFlow!=flow && UndoManager::undoEnabled())
                        {
                                SimpleState *ss = new SimpleState(flow ? Um::FlowLayer : Um::DisableFlowLayer,"", Um::ITextFrame);
                                ss->set("FLOW_LAYER", "flow_layer");
                                ss->set("ACTIVE", (*it).ID);
                                ss->set("FLOW", flow);
                                undoManager->action(this, ss, it->Name, Um::IDocument);
                        }

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


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", layerLevel-1);
                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", layerLevel+1);
                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->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->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);
                        }
                }
        }
}


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;
        QMap<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.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;
        QMap<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(QMap<QString, VGradient> &gradients)
{
        ResourceCollection resources;
        this->getNamedResources(resources);
        const QMap<QString, QString>& resGradients = resources.gradients();
        QMap<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 (QMap<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(QMap<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);
        return true;
}

void ScribusDoc::setPatterns(QMap<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->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->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 < FrameItems.count(); ++c)
        {
                PageItem* currItem = FrameItems.at(c);
                if (currItem->isGroup())
                        allItems = currItem->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 (QMap<QString, ScPattern>::Iterator it = docPatterns.begin(); it != docPatterns.end(); ++it)
        {
                for (int c = 0; c < it.value().items.count(); ++c)
                {
                        PageItem* currItem = it.value().items.at(c);
                        if (currItem->isGroup())
                                allItems = currItem->getItemList();
                        else
                                allItems.append(currItem);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                currItem = allItems.at(ii);
                                if ((currItem->GrType == 8) || (currItem->itemType() == PageItem::Symbol))
                                {
                                        const QString& patName = currItem->pattern();
                                        if (!patName.isEmpty() && !results.contains(patName))
                                                results.append(patName);
                                }
                                const QString& pat2 = currItem->strokePattern();
                                if (!pat2.isEmpty() && !results.contains(pat2))
                                        results.append(pat2);
                                const QString& pat3 = currItem->patternMask();
                                if (!pat3.isEmpty() && !results.contains(pat3))
                                        results.append(pat3);
                        }
                        allItems.clear();
                }
        }
        return results;
}


QStringList ScribusDoc::getUsedPatternsSelection(Selection* customSelection)
{
        QStringList results;
        uint selectedItemCount = customSelection->count();
        if (selectedItemCount != 0)
        {
                for (uint a = 0; a < selectedItemCount; ++a)
                {
                        PageItem *currItem = customSelection->itemAt(a);
                        if ((currItem->GrType == 8) || (currItem->itemType() == PageItem::Symbol))
                        {
                                const QString& pat = currItem->pattern();
                                if (!pat.isEmpty() && !results.contains(pat))
                                        results.append(currItem->pattern());
                        }
                        const QString& pat2 = currItem->strokePattern();
                        if (!pat2.isEmpty() && !results.contains(pat2))
                                results.append(currItem->strokePattern());
                        const QString& pat3 = currItem->patternMask();
                        if (!pat3.isEmpty() && !results.contains(pat3))
                                results.append(currItem->patternMask());
                }
                QStringList results2 = results;
                for (int c = 0; c < results.count(); ++c)
                {
                        QStringList pats = getUsedPatternsHelper(results[c], results2);
                        if (!pats.isEmpty())
                        {
                                for (int cc = 0; cc < pats.count(); cc++)
                                {
                                        if (!results2.contains(pats[cc]))
                                                results2.append(pats[cc]);
                                }
                        }
                }
                return results2;
        }
        else
                return QStringList();
}

QStringList ScribusDoc::getUsedPatternsHelper(QString pattern, QStringList &results)
{
        if (!docPatterns.contains(pattern))
                return QStringList();
        ScPattern *pat = &docPatterns[pattern];
        QStringList pats;
        pats.clear();
        for (int c = 0; c < pat->items.count(); ++c)
        {
                if ((pat->items.at(c)->GrType == 8) || (pat->items.at(c)->itemType() == PageItem::Symbol))
                {
                        const QString& patName = pat->items.at(c)->pattern();
                        if (!patName.isEmpty() && !results.contains(patName))
                                pats.append(patName);
                }
                const QString& pat2 = pat->items.at(c)->strokePattern();
                if (!pat2.isEmpty() && !results.contains(pat2))
                        pats.append(pat->items.at(c)->strokePattern());
                const QString& pat3 = pat->items.at(c)->patternMask();
                if (!pat3.isEmpty() && !results.contains(pat3))
                        pats.append(pat->items.at(c)->patternMask());
        }
        if (!pats.isEmpty())
        {
                results += pats;
                for (int c = 0; c < pats.count(); ++c)
                {
                        QStringList pp = getUsedPatternsHelper(pats[c], results);
                        if (!pp.isEmpty())
                        {
                                for (int cc = 0; cc < pp.count(); cc++)
                                {
                                        if (!results.contains(pp[cc]))
                                                results.append(pp[cc]);
                                }
                        }
                }
        }
        return results;
}

QStringList ScribusDoc::getPatternDependencyList(QStringList used)
{
        QStringList results;
        QStringList pp;
        QStringList pats = used;
        QStack<QStringList> patternStack;
        patternStack.push(pats);
        while (!pats.isEmpty())
        {
                for (int c = 0; c < pats.count(); ++c)
                {
                        pp = getUsedPatternsHelper(pats[c], results);
                        if (!pp.isEmpty())
                                results += pp;
                }
                pats = results;
                results.clear();
                if (!pats.isEmpty())
                        patternStack.push(pats);
        }
        results.clear();
        while (patternStack.count() != 0)
        {
                pp = patternStack.pop();
                for (int c = 0; c < pp.count(); c++)
                {
                        if (!results.contains(pp[c]))
                                results.prepend(pp[c]);
                }
                if (patternStack.count() == 0)
                        break;
        }
        return results;
}

QStringList ScribusDoc::getUsedSymbols()
{
        QList<PageItem*> allItems;
        QStringList results;
        for (int c = 0; c < MasterItems.count(); ++c)
        {
                PageItem* currItem = MasterItems.at(c);
                if (currItem->isGroup())
                        allItems = currItem->getItemList();
                else
                        allItems.append(currItem);
                for (int ii = 0; ii < allItems.count(); ii++)
                {
                        currItem = allItems.at(ii);
                        if ((!results.contains(currItem->pattern())) && (currItem->itemType() == PageItem::Symbol) && (!currItem->pattern().isEmpty()))
                                results.append(currItem->pattern());
                        if ((!currItem->strokePattern().isEmpty()) && (currItem->patternStrokePath))
                        {
                                if (!results.contains(currItem->strokePattern()))
                                        results.append(currItem->strokePattern());
                        }
                        if ((!results.contains(currItem->strokePattern())) && ((!currItem->strokePattern().isEmpty()) && (currItem->patternStrokePath)))
                                results.append(currItem->pattern());
                }
                allItems.clear();
        }
        for (int c = 0; c < DocItems.count(); ++c)
        {
                PageItem* currItem = DocItems.at(c);
                if (currItem->isGroup())
                        allItems = currItem->getItemList();
                else
                        allItems.append(currItem);
                for (int ii = 0; ii < allItems.count(); ii++)
                {
                        currItem = allItems.at(ii);
                        if ((!results.contains(currItem->pattern())) && (currItem->itemType() == PageItem::Symbol) && (!currItem->pattern().isEmpty()))
                                results.append(currItem->pattern());
                        if ((!currItem->strokePattern().isEmpty()) && (currItem->patternStrokePath))
                        {
                                if (!results.contains(currItem->strokePattern()))
                                        results.append(currItem->strokePattern());
                        }
                }
                allItems.clear();
        }
        for (int c = 0; c < FrameItems.count(); ++c)
        {
                PageItem* currItem = FrameItems.at(c);
                if (currItem->isGroup())
                        allItems = currItem->getItemList();
                else
                        allItems.append(currItem);
                for (int ii = 0; ii < allItems.count(); ii++)
                {
                        currItem = allItems.at(ii);
                        if ((!results.contains(currItem->pattern())) && (currItem->itemType() == PageItem::Symbol) && (!currItem->pattern().isEmpty()))
                                results.append(currItem->pattern());
                        if ((!currItem->strokePattern().isEmpty()) && (currItem->patternStrokePath))
                        {
                                if (!results.contains(currItem->strokePattern()))
                                        results.append(currItem->strokePattern());
                        }
                }
                allItems.clear();
        }
        for (QMap<QString, ScPattern>::Iterator it = docPatterns.begin(); it != docPatterns.end(); ++it)
        {
                for (int c = 0; c < it.value().items.count(); ++c)
                {
                        PageItem* currItem = it.value().items.at(c);
                        if (currItem->isGroup())
                                allItems = currItem->getItemList();
                        else
                                allItems.append(currItem);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                currItem = allItems.at(ii);
                                if ((!results.contains(currItem->pattern())) && (currItem->itemType() == PageItem::Symbol) && (!currItem->pattern().isEmpty()))
                                        results.append(currItem->pattern());
                                if ((!currItem->strokePattern().isEmpty()) && (currItem->patternStrokePath))
                                {
                                        if (!results.contains(currItem->strokePattern()))
                                                results.append(currItem->strokePattern());
                                }
                        }
                        allItems.clear();
                }
        }
        return results;
}

QStringList ScribusDoc::getUsedSymbolsHelper(QString pattern, QStringList &results)
{
        ScPattern *pat = &docPatterns[pattern];
        QStringList pats;
        pats.clear();
        for (int c = 0; c < pat->items.count(); ++c)
        {
                if (pat->items.at(c)->itemType() == PageItem::Symbol)
                {
                        const QString& patName = pat->items.at(c)->pattern();
                        if (!patName.isEmpty() && !results.contains(patName))
                                pats.append(patName);
                }
        }
        if (!pats.isEmpty())
        {
                for (int c = 0; c < pats.count(); ++c)
                {
                        getUsedSymbolsHelper(pats[c], results);
                }
        }
        return pats;
}

QMap<QString,int> ScribusDoc::reorganiseFonts()
{
//      QTime t;
//      t.start();
        QMap<QString,int> Really;
        QList<PageItem*> allItems;
        //QMap<QString,QFont> DocF;
        //DocF = UsedFonts;
        uint counter = 0;
        for (uint lc = 0; lc < 3; ++lc)
        {
                switch (lc)
                {
                        case 0:
                                counter = MasterItems.count();
                                break;
                        case 1:
                                counter = DocItems.count();
                                break;
                        case 2:
                                counter = FrameItems.count();
                                break;
                }
                PageItem* it = NULL;
                for (uint d = 0; d < counter; ++d)
                {
                        switch (lc)
                        {
                                case 0:
                                        it = MasterItems.at(d);
                                        break;
                                case 1:
                                        it = DocItems.at(d);
                                        break;
                                case 2:
                                        it = FrameItems.at(d);
                                        break;
                        }
                        if (it->isGroup())
                                allItems = it->getItemList();
                        else
                                allItems.append(it);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                it = allItems.at(ii);
                                if ((it->itemType() == PageItem::TextFrame) || (it->itemType() == PageItem::PathText))
                                {
                                        QString fontName(it->itemText.defaultStyle().charStyle().font().replacementName());
                                        Really.insert(fontName, UsedFonts[fontName]);
                                        int start = it->firstInFrame();
                                        int stop = it->lastInFrame();
                                        for (int e = start; e <= stop; ++e)
                                        {
                                                QString rep = it->itemText.charStyle(e).font().replacementName();
                                                if (Really.contains(rep))
                                                        continue;
                                                Really.insert(rep, UsedFonts[rep]);
                                        }
                                }
                        }
                        allItems.clear();
                }
        }
        QMap<QString,int>::Iterator itfo, itnext;
        for (itfo = UsedFonts.begin(); itfo != UsedFonts.end(); itfo = itnext)
        {
                itnext = itfo;
                ++itnext;
                if (!Really.contains(itfo.key()))
                {
                        (*AllFonts)[itfo.key()].decreaseUsage();
                        UsedFonts.erase(itfo);
                }
        }
        PrefsManager* prefsManager=PrefsManager::instance();
        AddFont(prefsManager->appPrefs.itemToolPrefs.textFont);//, prefsManager->appPrefs.AvailFonts[prefsManager->appPrefs.itemToolPrefs.textFont]->Font);
        AddFont(docPrefsData.itemToolPrefs.textFont);//, prefsManager->appPrefs.AvailFonts[itemToolPrefs.textFont]->Font);
//      qDebug( "Time elapsed: %d ms", t.elapsed() );
        return Really;
}

void ScribusDoc::getUsedFonts(QMap<QString, QMap<uint, FPointArray> > & Really)
{
        QList<PageItem*> allItems;
        PageItem* it = NULL;
        uint counter = 0;
        for (uint lc = 0; lc < 3; ++lc)
        {
                switch (lc)
                {
                        case 0:
                                counter = MasterItems.count();
                                break;
                        case 1:
                                counter = DocItems.count();
                                break;
                        case 2:
                                counter = FrameItems.count();
                                break;
                }
                for (uint d = 0; d < counter; ++d)
                {
                        switch (lc)
                        {
                                case 0:
                                        it = MasterItems.at(d);
                                        break;
                                case 1:
                                        it = DocItems.at(d);
                                        break;
                                case 2:
                                        it = FrameItems.at(d);
                                        break;
                        }
                        if (it->isGroup())
                                allItems = it->getItemList();
                        else
                                allItems.append(it);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                it = allItems.at(ii);
                                checkItemForFonts(it, Really, lc);
                        }
                        allItems.clear();
                }
        }
        QStringList patterns = getUsedPatterns();
        for (int c = 0; c < patterns.count(); ++c)
        {
                ScPattern pa = docPatterns[patterns[c]];
                for (int o = 0; o < pa.items.count(); o++)
                {
                        it = pa.items.at(o);
                        if (it->isGroup())
                                allItems = it->getItemList();
                        else
                                allItems.append(it);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                it = allItems.at(ii);
                                checkItemForFonts(it, Really, 3);
                        }
                        allItems.clear();
                }
        }
}


void ScribusDoc::checkItemForFonts(PageItem *it, QMap<QString, QMap<uint, FPointArray> > & Really, uint lc)
{
        FPointArray gly;
        QChar chstr;
        if ((it->itemType() == PageItem::TextFrame) || (it->itemType() == PageItem::PathText))
        {
                for (int e = 0; e < it->itemText.length(); ++e)
                {
                        if (! Really.contains(it->itemText.charStyle(e).font().replacementName()) )
                        {
                                if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                        Really.insert(it->itemText.charStyle(e).font().replacementName(), QMap<uint, FPointArray>());
                        }
                        uint chr = it->itemText.text(e).unicode();
                        if ((chr == 13) || (chr == 32) || ((chr >= 26) && (chr <= 29)))
                                continue;
                        if (chr == 9)
                        {
                                for (int t1 = 0; t1 < it->itemText.paragraphStyle(e).tabValues().count(); t1++)
                                {
                                        if (it->itemText.paragraphStyle(e).tabValues()[t1].tabFillChar.isNull())
                                                continue;
                                        chstr = it->itemText.paragraphStyle(e).tabValues()[t1].tabFillChar;
                                        if ((it->itemText.charStyle(e).effects() & ScStyle_SmallCaps) || (it->itemText.charStyle(e).effects() & ScStyle_AllCaps))
                                        {
                                                if (chstr.toUpper() != chstr)
                                                        chstr = chstr.toUpper();
                                        }
                                        chr = chstr.unicode();
                                        uint gl = it->itemText.charStyle(e).font().char2CMap(chstr);
                                        gly = it->itemText.charStyle(e).font().glyphOutline(gl);
                                        if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                                Really[it->itemText.charStyle(e).font().replacementName()].insert(gl, gly);
                                }
                                for (int t1 = 0; t1 < it->itemText.defaultStyle().tabValues().count(); t1++)
                                {
                                        if (it->itemText.defaultStyle().tabValues()[t1].tabFillChar.isNull())
                                                continue;
                                        chstr = it->itemText.defaultStyle().tabValues()[t1].tabFillChar;
                                        if ((it->itemText.charStyle(e).effects() & ScStyle_SmallCaps) || (it->itemText.charStyle(e).effects() & ScStyle_AllCaps))
                                        {
                                                if (chstr.toUpper() != chstr)
                                                        chstr = chstr.toUpper();
                                        }
                                        chr = chstr.unicode();
                                        uint gl = it->itemText.charStyle(e).font().char2CMap(chstr);
                                        gly = it->itemText.charStyle(e).font().glyphOutline(gl);
                                        if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                                Really[it->itemText.charStyle(e).font().replacementName()].insert(gl, gly);
                                }
                                continue;
                        }
                        if ((chr == 30) || (chr == 23))
                        {
                                /* CB Removed forced loading of 0-9 for section based numbering
                                for (uint numco = 0x30; numco < 0x3A; ++numco)
                                {
                                        if (it->itemText.charStyle(e)->cfont->CharWidth.contains(numco))
                                        {
                                                gly = it->itemText.charStyle(e)->cfont->GlyphArray[numco].Outlines.copy();
                                                it->itemText.charStyle(e)->cfont->RealGlyphs.insert(numco, gly);
                                        }
                                }*/

                                //Our page number collection string
                                QString pageNumberText(QString::null);
                                if (chr == 30)
                                {//ch == SpecialChars::PAGENUMBER
                                        //If not on a master page just get the page number for the page and the text
                                        if (lc!=0)
                                        {
//                                              pageNumberText=getSectionPageNumberForPageIndex(it->OwnPage);
                                                pageNumberText = QString("%1").arg(getSectionPageNumberForPageIndex(it->OwnPage),
                                                                                getSectionPageNumberWidthForPageIndex(it->OwnPage),
                                                                                getSectionPageNumberFillCharForPageIndex(it->OwnPage));
                                        }
                                        else
                                        {
                                                //Else, for a page number in a text frame on a master page we must scan
                                                //all pages to see which ones use this page and get their page numbers.
                                                //We only add each character of the pages' page number text if its nothing
                                                //already in the pageNumberText variable. No need to add glyphs twice.
                                                QString newText;
                                                uint docPageCount=DocPages.count();
                                                for (uint a = 0; a < docPageCount; ++a)
                                                {
                                                        if (DocPages.at(a)->MPageNam == it->OnMasterPage)
                                                        {
//                                                              newText=getSectionPageNumberForPageIndex(a);
                                                                newText = QString("%1").arg(getSectionPageNumberForPageIndex(a),
                                                                                                getSectionPageNumberWidthForPageIndex(a),
                                                                                                getSectionPageNumberFillCharForPageIndex(a));
                                                                for (int nti=0;nti<newText.length();++nti)
                                                                        if (pageNumberText.indexOf(newText[nti])==-1)
                                                                                pageNumberText+=newText[nti];
                                                        }
                                                }
                                        }
                                }
                                else
                                {//ch == SpecialChars::PAGECOUNT
                                        if (lc!=0)
                                        {
                                                int key = getSectionKeyForPageIndex(it->OwnPage);
                                                if (key == -1)
                                                        pageNumberText = "";
                                                else
                                                        pageNumberText = QString("%1").arg(getStringFromSequence(docPrefsData.docSectionMap[key].type, docPrefsData.docSectionMap[key].toindex - docPrefsData.docSectionMap[key].fromindex + 1));
                                        }
                                        else
                                        {
                                                QString newText;
                                                uint docPageCount=DocPages.count();
                                                for (uint a = 0; a < docPageCount; ++a)
                                                {
                                                        if (DocPages.at(a)->MPageNam == it->OnMasterPage)
                                                        {
                                                                int key = getSectionKeyForPageIndex(a);
                                                                if (key == -1)
                                                                        newText = "";
                                                                else
                                                                        newText = QString("%1").arg(getStringFromSequence(docPrefsData.docSectionMap[key].type, docPrefsData.docSectionMap[key].toindex - docPrefsData.docSectionMap[key].fromindex + 1));
                                                                for (int nti=0;nti<newText.length();++nti)
                                                                        if (pageNumberText.indexOf(newText[nti])==-1)
                                                                                pageNumberText+=newText[nti];
                                                        }
                                                }
                                        }
                                }
                                //Now scan and add any glyphs used in page numbers
                                for (int pnti=0;pnti<pageNumberText.length(); ++pnti)
                                {
                                        uint chr = pageNumberText[pnti].unicode();
                                        if (it->itemText.charStyle(e).font().canRender(chr))
                                        {
                                                uint gl = it->itemText.charStyle(e).font().char2CMap(pageNumberText[pnti]);
                                                FPointArray gly(it->itemText.charStyle(e).font().glyphOutline(gl));
                                                if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                                        Really[it->itemText.charStyle(e).font().replacementName()].insert(gl, gly);
                                        }
                                }
                                continue;
                        }
                        if (it->itemText.charStyle(e).effects() & ScStyle_SoftHyphenVisible)
                        {
                                uint gl = it->itemText.charStyle(e).font().char2CMap(QChar('-'));
                                FPointArray gly(it->itemText.charStyle(e).font().glyphOutline(gl));
                                if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                        Really[it->itemText.charStyle(e).font().replacementName()].insert(gl, gly);
                        }
                        if ((it->itemText.charStyle(e).effects() & ScStyle_SmallCaps) || (it->itemText.charStyle(e).effects() & ScStyle_AllCaps))
                        {
                                chstr = it->itemText.text(e);
                                if (chstr.toUpper() != chstr)
                                        chstr = chstr.toUpper();
                                chr = chstr.unicode();
                        }
                        if (it->itemText.charStyle(e).font().canRender(chr))
                        {
                                uint gl = it->itemText.charStyle(e).font().char2CMap(chr);
                                gly = it->itemText.charStyle(e).font().glyphOutline(gl);
                                if (!it->itemText.charStyle(e).font().replacementName().isEmpty())
                                        Really[it->itemText.charStyle(e).font().replacementName()].insert(gl, gly);
                        }
                }
        }
}


void ScribusDoc::getUsedProfiles(ProfilesL& usedProfiles)
{
        PageItem* it = NULL;
        QString profileName;
        QStringList profileNames;
        uint counter = 0;
        usedProfiles.clear();

        QList<PageItem*> allItems;
        profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultSolidColorRGBProfile);
        profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultSolidColorCMYKProfile);
        if( profileNames.indexOf(docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile) < 0 )
                profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultImageRGBProfile);
        if( profileNames.indexOf(docPrefsData.colorPrefs.DCMSset.DefaultImageCMYKProfile) < 0 )
                profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultImageCMYKProfile);
        if( profileNames.indexOf(docPrefsData.colorPrefs.DCMSset.DefaultMonitorProfile) < 0 )
                profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultMonitorProfile);
        if( profileNames.indexOf(docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile) < 0 )
                profileNames.append(docPrefsData.colorPrefs.DCMSset.DefaultPrinterProfile);
       
        for (uint lc = 0; lc < 3; ++lc)
        {
                if (lc == 0)
                        counter = MasterItems.count();
                else if(lc == 1)
                        counter = DocItems.count();
                else if(lc == 2)
                        counter = FrameItems.count();
                for (uint d = 0; d < counter; ++d)
                {
                        if (lc == 0)
                                it = MasterItems.at(d);
                        else if(lc == 1)
                                it = DocItems.at(d);
                        else if(lc == 2)
                                it = FrameItems.at(d);
                        if (it->isGroup())
                                allItems = it->getItemList();
                        else
                                allItems.append(it);
                        for (int ii = 0; ii < allItems.count(); ii++)
                        {
                                it = allItems.at(ii);
                                if (it->IProfile.isEmpty() || profileNames.contains(it->IProfile))
                                        continue;
                                profileNames.append(it->IProfile);
                        }
                        allItems.clear();
                }
        }

        for( QStringList::Iterator pIter = profileNames.begin(); pIter != profileNames.end(); pIter++ )
        {
                if (ScCore->InputProfiles.contains(*pIter))
                        usedProfiles[*pIter] = ScCore->InputProfiles[*pIter];
                else if (ScCore->InputProfilesCMYK.contains(*pIter))
                        usedProfiles[*pIter] = ScCore->InputProfilesCMYK[*pIter];
                else if (ScCore->PrinterProfiles.contains(*pIter))
                        usedProfiles[*pIter] = ScCore->PrinterProfiles[*pIter];
        }
}


void ScribusDoc::setUnitIndex(const int newIndex)
{
        docPrefsData.docSetupPrefs.docUnitIndex=newIndex;
        docUnitRatio = unitGetRatioFromIndex( newIndex );
}


int ScribusDoc::unitIndex() const
{
        return docPrefsData.docSetupPrefs.docUnitIndex;
}


double ScribusDoc::unitRatio() const
{
        return docUnitRatio;
}


bool ScribusDoc::applyMasterPage(const QString& pageName, const int pageNumber)
{
        if (!MasterNames.contains(pageName))
                return false;

        if (UndoManager::undoEnabled())
        {
                if (DocPages.at(pageNumber)->MPageNam != pageName)
                {
                        SimpleState *ss = new SimpleState(Um::ApplyMasterPage, QString(Um::FromTo).arg(DocPages.at(pageNumber)->MPageNam).arg(pageName));
                        ss->set("PAGE_NUMBER", pageNumber);
                        ss->set("OLD_MASTERPAGE", DocPages.at(pageNumber)->MPageNam);
                        ss->set("NEW_MASTERPAGE", pageName);
                        undoManager->action(this, ss);
                }
        }

//      QString mna = pageName;
//      if (mna == CommonStrings::trMasterPageNormal)
//              mna = CommonStrings::masterPageNormal;
//      if (!MasterNames.contains(mna))
//              mna = CommonStrings::masterPageNormal;
        Page* Ap = DocPages.at(pageNumber);
        Ap->MPageNam = pageName;
        const int MpNr = MasterNames[pageName];
        Page* Mp = MasterPages.at(MpNr);
        PageItem *currItem;

//      for (currItem = Ap->FromMaster.first(); currItem; currItem = Ap->FromMaster.next())
//      {
//              if (currItem->ChangedMasterItem)
//              {
//                      Ap->FromMaster.remove(currItem);
//                      delete currItem;
//              }
//      }

        Ap->FromMaster.clear();
        for (int itn = 0; itn < MasterItems.count(); ++itn)
        {
                currItem = MasterItems.at(itn);
                if (currItem->OwnPage == MpNr)
                        Ap->FromMaster.append(currItem);
        }
        if (!isLoading())
        {
                // PV - apply auto guides from MP only if there are no auto guides
                // on original page
                if (Ap->guides.horizontalAutoCount() != 0 || Ap->guides.horizontalAutoCount() != 0)
                        Mp->guides.copy(&Ap->guides, GuideManagerCore::Standard);
                else
                        Mp->guides.copy(&Ap->guides);

                Ap->initialMargins.Top = Mp->Margins.Top;
                Ap->initialMargins.Bottom = Mp->Margins.Bottom;
                if (pageSets()[docPrefsData.docSetupPrefs.pagePositioning].Columns == 1)
                {
                        Ap->initialMargins.Left = Mp->Margins.Left;
                        Ap->initialMargins.Right = Mp->Margins.Right;
                }
                else
                {
                        PageLocation pageLoc=locationOfPage(pageNumber);
                        if (pageLoc==LeftPage) //Left hand page
                        {
                                if (Mp->LeftPg != 0)
                                {
                                        Ap->initialMargins.Right = Mp->initialMargins.Right;
                                        Ap->initialMargins.Left = Mp->initialMargins.Left;
                                }
                                else
                                {
                                        Ap->initialMargins.Left = Mp->initialMargins.Right;
                                        Ap->initialMargins.Right = Mp->initialMargins.Left;
                                }
                        }
                        else if (pageLoc==RightPage) // Right hand page
                        {
                                if (Mp->LeftPg != 0)
                                {
                                        Ap->initialMargins.Left = Mp->initialMargins.Right;
                                        Ap->initialMargins.Right = Mp->initialMargins.Left;
                                }
                                else
                                {
                                        Ap->initialMargins.Right = Mp->initialMargins.Right;
                                        Ap->initialMargins.Left = Mp->initialMargins.Left;
                                }
                        }
                        else //Middle pages
                        {
                                Ap->initialMargins.Left = Mp->initialMargins.Left;
                                Ap->initialMargins.Right = Mp->initialMargins.Right;
                        }
                }

                //#8212: Apply page settings
                Ap->setInitialHeight(Mp->initialHeight());
                Ap->setInitialWidth(Mp->initialWidth());
                Ap->setHeight(Mp->height());
                Ap->setWidth(Mp->width());
                Ap->setOrientation(Mp->orientation());
                Ap->m_pageSize = Mp->m_pageSize;
        }
        //TODO make a return false if not possible to apply the master page
        if (!isLoading())
                changed();
        return true;
}


void ScribusDoc::restoreMasterPageApplying(SimpleState *state, bool isUndo)
{
        int pageNumber = state->getInt("PAGE_NUMBER");
        QString oldName = state->get("OLD_MASTERPAGE");
        QString newName = state->get("NEW_MASTERPAGE");
        if (isUndo)
                applyMasterPage(oldName, pageNumber);
        else
                applyMasterPage(newName, pageNumber);
}


void ScribusDoc::restorePageCopy(SimpleState *state, bool isUndo)
{
        int pnum = state->getInt("PAGE_NUM");
        int extPage = state->getInt("EXISTING_PAGE");
        int whereTo = state->getInt("WHERE_TO");
        int copyCount = state->getInt("COPY_COUNT");

        if (isUndo)
        {
                int destLocation=extPage + 1;
                if (whereTo==0)
                        --destLocation;
                else if (whereTo==2)
                        destLocation=DocPages.count();
                for (int i = 0; i < copyCount; ++i)
                {
                        m_ScMW->DeletePage(destLocation, destLocation);
                        if (whereTo == 2)
                                --destLocation;
                }
        }
        else
                copyPage(pnum, extPage, whereTo, copyCount);

}


//TODO: Handle saving to versions of SLA, and other formats
bool ScribusDoc::save(const QString& fileName, QString* savedFile)
{
        QProgressBar* mainWindowProgressBar=NULL;
        if (ScCore->usingGUI())
        {
                mainWindowProgressBar=m_ScMW->mainWindowProgressBar;
                mainWindowProgressBar->reset();
        }
        FileLoader fl(fileName);
        bool ret = fl.SaveFile(fileName, this, savedFile);
        if (ret)
        {
                setName(fileName);
                setModified(false);
                hasName = true;
        }
        return ret;
}


bool ScribusDoc::changePageMargins(const double initialTop, const double initialBottom, const double initialLeft, const double initialRight, const double initialHeight, const double initialWidth, const double height, const double width, const int orientation, const QString& pageSize, const int pageNumber, const int pageType)
{
        bool retVal=true;
        if (pageNumber==-1)
        {
                //find page and set values
                return false;
        }
        else
        {
                if (currentPage()==NULL)
                        retVal=false;
                else
                {
                        //set the current page's values
                        currentPage()->initialMargins.Top = initialTop;
                        currentPage()->initialMargins.Bottom = initialBottom;
                        currentPage()->initialMargins.Left = initialLeft;
                        currentPage()->initialMargins.Right = initialRight;
                        currentPage()->setInitialHeight(initialHeight);
                        currentPage()->setInitialWidth(initialWidth);
                        currentPage()->setHeight(height);
                        currentPage()->setWidth(width);
                        currentPage()->setOrientation(orientation);
                        currentPage()->m_pageSize = pageSize;
                        currentPage()->LeftPg = pageType;
                        changed();
                }
        }
        return retVal;
}


void ScribusDoc::recalculateColors()
{
        //Adjust Items of the 3 types to the colors
        uint itemsCount=Items->count();
        updateAllItemQColors();
        QMap<QString, VGradient>::Iterator itGrad;
        for (itGrad = docGradients.begin(); itGrad != docGradients.end(); ++itGrad)
        {
                QList<VColorStop*> cstops = itGrad.value().colorStops();
                for (uint cst = 0; cst < itGrad.value().Stops(); ++cst)
                {
                        const ScColor& col = PageColors[cstops.at(cst)->name];
                        QColor tmp = ScColorEngine::getShadeColorProof(col, this, cstops.at(cst)->shade);
                        if (viewAsPreview)
                        {
                                VisionDefectColor defect;
                                tmp = defect.convertDefect(tmp, previewVisual);
                        }
                        cstops.at(cst)->color = tmp;
                }
        }
        for (uint c=0; c<itemsCount; ++c)
        {
                PageItem *ite = Items->at(c);
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->stroke_gradient.colorStops();
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->mask_gradient.colorStops();
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
        }
        uint masterItemsCount=MasterItems.count();
        for (uint c=0; c<masterItemsCount; ++c)
        {
                PageItem *ite = MasterItems.at(c);
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->stroke_gradient.colorStops();
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->mask_gradient.colorStops();
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
        }
        uint frameItemsCount=FrameItems.count();
        for (uint c=0; c<frameItemsCount; ++c)
        {
                PageItem *ite = FrameItems.at(c);
                QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
                for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->stroke_gradient.colorStops();
                for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                cstops = ite->mask_gradient.colorStops();
                for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
                        ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
        }
        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 *ite = pa.items.at(o);
                        QList<VColorStop*> cstops = ite->fill_gradient.colorStops();
                        for (uint cst = 0; cst < ite->fill_gradient.Stops(); ++cst)
                                ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                        cstops = ite->stroke_gradient.colorStops();
                        for (uint cst = 0; cst < ite->stroke_gradient.Stops(); ++cst)
                                ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                        cstops = ite->mask_gradient.colorStops();
                        for (uint cst = 0; cst < ite->mask_gradient.Stops(); ++cst)
                                ite->SetQColor(&cstops.at(cst)->color, cstops.at(cst)->name, cstops.at(cst)->shade);
                        if (ite->asImageFrame())
                                loadPict(ite->Pfile, ite, true, false);
                }
                PageItem *ite = pa.items.at(0);
                docPatterns[patterns[c]].pattern = ite->DrawObj_toImage(pa.items);
        }
}


void ScribusDoc::setScTextDefaultsFromDoc(ScText *sctextdata)
{
        if (sctextdata==NULL)
                return;
#ifndef NLS_PROTO
        reinterpret_cast<CharStyle&>(*sctextdata) = currentStyle.charStyle();
//      sctextdata->cab = 0;
#endif
}

bool ScribusDoc::copyPageToMasterPage(const int pageNumber, const int leftPage, const int maxLeftPage,  const QString& masterPageName, bool copyFromAppliedMaster)
{
        assert(!masterPageMode());
        if (masterPageMode())
                return false;
        int GrMax = GroupCounter;
        Page* sourcePage = Pages->at(pageNumber);
        int nr = MasterPages.count();
        Page* targetPage=addMasterPage(nr, masterPageName);
        assert(targetPage!=NULL);
        //Backup currentpage, and dont use sourcepage here as we might convert a non current page
        Page* oldCurrentPage = currentPage();
        //Must set current page for pasteitem to work properly
        setLoading(true);
        targetPage->copySizingProperties(sourcePage, sourcePage->Margins);
        //Grab the left page setting for the current document layout from the dialog, and increment, singlePage==1 remember.
        if (docPrefsData.docSetupPrefs.pagePositioning != singlePage)
        {
                int lp = leftPage;
                if (lp == 0)
                        lp = 1;
                else if (lp == maxLeftPage-1)
                        lp = 0;
                else
                        ++lp;
                targetPage->LeftPg = lp;
        }
        sourcePage->guides.copy(&targetPage->guides);
        uint end = DocItems.count();
        uint end2 = MasterItems.count();
        Selection tempSelection(this, false);
        m_Selection->clear();
        //Copy the items from our current document page's applied *master* page
        if (copyFromAppliedMaster)
        {
                if (!sourcePage->MPageNam.isEmpty() && MasterNames.contains(sourcePage->MPageNam))
                {
                        Page* pageMaster=NULL;
                        for (int i=0; i < MasterPages.count(); ++i )
                        {
                                pageMaster=MasterPages[i];
                                if (pageMaster->pageName() == sourcePage->MPageNam)
                                        break;
                        }
                        if (Layers.count()!= 0 && pageMaster!=NULL)
                        {
                                int currActiveLayer = activeLayer();
                                for (ScLayers::iterator it = Layers.begin(); it != Layers.end(); ++it)
                                {
                                        setActiveLayer(it->ID);
                                        for (uint ite = 0; ite < end2; ++ite)
                                        {
                                                PageItem *itemToCopy = MasterItems.at(ite);
                                                if ((itemToCopy->OnMasterPage == pageMaster->pageName()) && (it->ID == itemToCopy->LayerID))
                                                        tempSelection.addItem(itemToCopy, true);
                                        }
                                        if (tempSelection.count() != 0)
                                        {
                                                setMasterPageMode(true);
                                                ScriXmlDoc *ss = new ScriXmlDoc();
                                        &nbs