Subversion Repositories Scribus

Rev

Rev 14881 | Rev 14924 | 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 <utility>

#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 "fileloader.h"
#include "filewatcher.h"
#include "ui/guidemanager.h"
#include "ui/hruler.h"
#include "hyphenator.h"
#include "ui/layers.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 "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 "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/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),
        docUnitIndex(appPrefsData.docSetupPrefs.docUnitIndex),
        docUnitRatio(unitGetRatioFromIndex(docUnitIndex)),
        rotMode(0),
        automaticTextFrames(0),
        m_masterPageMode(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),
        scratch(appPrefsData.displayPrefs.scratch),
        GapHorizontal(appPrefsData.displayPrefs.pageGapHorizontal),
        GapVertical(appPrefsData.displayPrefs.pageGapVertical),
//      ScratchLeft(prefsData.ScratchLeft),
//      ScratchRight(prefsData.ScratchRight),
//      ScratchTop(prefsData.ScratchTop),
//      ScratchBottom(prefsData.ScratchBottom),
        minCanvasCoordinate(FPoint(0, 0)),
        maxCanvasCoordinate(FPoint(scratch.Left + scratch.Right, scratch.Top + scratch.Bottom)),
        rulerXoffset(0.0), rulerYoffset(0.0),
        Pages(0), MasterPages(), DocPages(),
        MasterNames(),
        Items(0), MasterItems(), DocItems(), FrameItems(),
        m_Selection(new Selection(this, true)),
        pageWidth(0), pageHeight(0),
        pageSets(appPrefsData.pageSets),
        PageSp(1), PageSpa(0),
        currentPageLayout(0),
        PageOri(0), m_pageSize(),
        FirstPnum(1),
        useRaster(false),
        PageColors(this, true),
        appMode(modeNormal),
        SubMode(-1),
        ShapeValues(0),
        ValCount(0),
        DocName( tr("Document")+"-"),
        UsedFonts(),
        AllFonts(&appPrefsData.fontPrefs.AvailFonts),
        AObjects(),
        papColor(appPrefsData.displayPrefs.paperColor),
        CurrentSel(-1),
        nodeEdit(),
        typographicSettings(appPrefsData.typoPrefs),
        guidesSettings(appPrefsData.guidesPrefs),
        itemToolPrefs(appPrefsData.itemToolPrefs),
        opToolPrefs(appPrefsData.opToolPrefs),
        checkerProfiles(appPrefsData.verifierPrefs.checkerPrefsList),
        curCheckProfile(appPrefsData.verifierPrefs.curCheckProfile),
        LastAuto(0), FirstAuto(0),
        DraggedElem(0),
        ElemToLink(0),
        DragElements(),
        docParagraphStyles(),
        docCharStyles(),
        Layers(),
        marginColored(appPrefsData.displayPrefs.marginColored),
        GroupCounter(1),
        colorEngine(ScCore->defaultEngine),
        JavaScripts(),
        TotalItems(0),
        MinWordLen(appPrefsData.hyphPrefs.MinWordLen),
        HyCount(appPrefsData.hyphPrefs.HyCount),
        Language(appPrefsData.hyphPrefs.Language),
        Automatic(appPrefsData.hyphPrefs.Automatic),
        AutoCheck(appPrefsData.hyphPrefs.AutoCheck),
        PDF_Options(appPrefsData.pdfPrefs),
        RePos(false),
        BookMarks(),
        OldBM(false),
        hasName(false),
        AutoSave(appPrefsData.docSetupPrefs.AutoSave),
        AutoSaveTime(appPrefsData.docSetupPrefs.AutoSaveTime),
        autoSaveTimer(new QTimer(this)),
        MLineStyles(),
        arrowStyles(appPrefsData.arrowStyles),
        WinHan(0),
        DoDrawing(true),
        OpenNodes(),
        CurTimer(0),
        docLayerErrors(),
        docItemErrors(),
        masterItemErrors(),
        docItemAttributes(appPrefsData.itemAttrPrefs.defaultItemAttributes),
        docToCSetups(appPrefsData.tocPrefs.defaultToCSetups),
        // sections
        symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
        docHyphenator(0),
        m_itemCreationTransaction(NULL),
        m_alignTransaction(NULL),
        m_currentPage(NULL),
        m_updateManager(),
        m_docUpdater(NULL)
{
        init();
        bleeds = appPrefsData.docSetupPrefs.bleeds;
        PDF_Options.bleeds = bleeds;
        PDF_Options.useDocBleeds = true;
        Print_Options.firstUse = true;
}


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),
        docUnitIndex(unitindex),
        docUnitRatio(unitGetRatioFromIndex(docUnitIndex)),
        rotMode(0),
        automaticTextFrames(pagesSetup.autoTextFrames),
        m_masterPageMode(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),
        scratch(appPrefsData.displayPrefs.scratch),
        GapHorizontal(appPrefsData.displayPrefs.pageGapHorizontal),
        GapVertical(appPrefsData.displayPrefs.pageGapVertical),
//      ScratchLeft(prefsData.ScratchLeft),
//      ScratchRight(prefsData.ScratchRight),
//      ScratchTop(prefsData.ScratchTop),
//      ScratchBottom(prefsData.ScratchBottom),
        minCanvasCoordinate(FPoint(0, 0)),
        maxCanvasCoordinate(FPoint(scratch.Left + scratch.Right, scratch.Top + scratch.Bottom)),
        rulerXoffset(0.0), rulerYoffset(0.0),
        Pages(0), MasterPages(), DocPages(),
        MasterNames(),
        Items(0), MasterItems(), DocItems(), FrameItems(),
        m_Selection(new Selection(this, true)),
        pageWidth(pagesize.width()), pageHeight(pagesize.height()),
        pageMargins(margins),
        marginPreset(appPrefsData.docSetupPrefs.marginPreset),
        pageSets(appPrefsData.pageSets),
        PageSp(pagesSetup.columnCount), PageSpa(pagesSetup.columnDistance),
        currentPageLayout(pagesSetup.pageArrangement),
        PageOri(pagesSetup.orientation), m_pageSize(pagesize.name()),
        FirstPnum(pagesSetup.firstPageNumber),
        useRaster(false),
        PageColors(this, true),
        appMode(modeNormal),
        SubMode(-1),
        ShapeValues(0),
        ValCount(0),
        DocName(docName),
        UsedFonts(),
        AllFonts(&appPrefsData.fontPrefs.AvailFonts),
        AObjects(),
        papColor(appPrefsData.displayPrefs.paperColor),
        CurrentSel(-1),
        nodeEdit(),
        typographicSettings(appPrefsData.typoPrefs),
        guidesSettings(appPrefsData.guidesPrefs),
        itemToolPrefs(appPrefsData.itemToolPrefs),
        opToolPrefs(appPrefsData.opToolPrefs),
        checkerProfiles(appPrefsData.verifierPrefs.checkerPrefsList),
        curCheckProfile(appPrefsData.verifierPrefs.curCheckProfile),
        LastAuto(0), FirstAuto(0),
        DraggedElem(0),
        ElemToLink(0),
        DragElements(),
        docParagraphStyles(),
        docCharStyles(),
        Layers(),
        marginColored(appPrefsData.displayPrefs.marginColored),
        GroupCounter(1),
        colorEngine(ScCore->defaultEngine),
        JavaScripts(),
        TotalItems(0),
        MinWordLen(appPrefsData.hyphPrefs.MinWordLen),
        HyCount(appPrefsData.hyphPrefs.HyCount),
        Language(appPrefsData.hyphPrefs.Language),
        Automatic(appPrefsData.hyphPrefs.Automatic),
        AutoCheck(appPrefsData.hyphPrefs.AutoCheck),
        PDF_Options(appPrefsData.pdfPrefs),
        RePos(false),
        BookMarks(),
        OldBM(false),
        hasName(false),
        AutoSave(appPrefsData.docSetupPrefs.AutoSave),
        AutoSaveTime(appPrefsData.docSetupPrefs.AutoSaveTime),
        autoSaveTimer(new QTimer(this)),
        MLineStyles(),
        arrowStyles(appPrefsData.arrowStyles),
        WinHan(0),
        DoDrawing(true),
        OpenNodes(),
        CurTimer(0),
        docLayerErrors(),
        docItemErrors(),
        masterItemErrors(),
        docItemAttributes(appPrefsData.itemAttrPrefs.defaultItemAttributes),
        docToCSetups(appPrefsData.tocPrefs.defaultToCSetups),
        // sections
        symReturn(), symNewLine(), symTab(), symNonBreak(), symNewCol(), symNewFrame(),
        docHyphenator(0),
        m_itemCreationTransaction(NULL),
        m_alignTransaction(NULL),
        m_currentPage(NULL),
        m_updateManager(),
        m_docUpdater(NULL)
{
        pageSets[pagesSetup.pageArrangement].FirstPage = pagesSetup.firstPageLocation;
        init();
        bleeds = appPrefsData.docSetupPrefs.bleeds;
        PDF_Options.bleeds = bleeds;
        PDF_Options.useDocBleeds = true;
        Print_Options.firstUse = true;
}


void ScribusDoc::init()
{
        Q_CHECK_PTR(m_Selection);
        Q_CHECK_PTR(autoSaveTimer);

        HasCMS = false;
        CMSSettings.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();
        CMSSettings = prefsManager->appPrefs.colorPrefs.DCMSset;
        PDF_Options.SolidProf = CMSSettings.DefaultSolidColorRGBProfile;
        PDF_Options.ImageProf = CMSSettings.DefaultImageRGBProfile;
        PDF_Options.PrintProf = CMSSettings.DefaultPrinterProfile;
        PDF_Options.Intent = CMSSettings.DefaultIntentColors;
        PDF_Options.Intent2 = CMSSettings.DefaultIntentImages;

        AddFont(appPrefsData.itemToolPrefs.textFont);//, prefsData.AvailFonts[prefsData.itemToolPrefs.textFont]->Font);
        itemToolPrefs.textFont = appPrefsData.itemToolPrefs.textFont;
        itemToolPrefs.textSize = appPrefsData.itemToolPrefs.textSize;
        itemToolPrefs.textTabFillChar = appPrefsData.itemToolPrefs.textTabFillChar;
        opToolPrefs.dispX = appPrefsData.opToolPrefs.dispX;
        opToolPrefs.dispY = appPrefsData.opToolPrefs.dispY;
        opToolPrefs.constrain = appPrefsData.opToolPrefs.constrain;

        PageColors.ensureBlackAndWhite();
        if (appPrefsData.itemToolPrefs.shapeLineColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.shapeLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeLineColor]);
        itemToolPrefs.shapeLineColor = appPrefsData.itemToolPrefs.shapeLineColor;
        if (appPrefsData.itemToolPrefs.lineColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.lineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.lineColor]);
        itemToolPrefs.lineColor = appPrefsData.itemToolPrefs.lineColor;
        if (appPrefsData.itemToolPrefs.textColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.textColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textColor]);
        itemToolPrefs.textColor = appPrefsData.itemToolPrefs.textColor;
        if (appPrefsData.itemToolPrefs.textStrokeColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.textStrokeColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textStrokeColor]);
        itemToolPrefs.textStrokeColor = appPrefsData.itemToolPrefs.textStrokeColor;
        if (appPrefsData.itemToolPrefs.shapeFillColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.shapeFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.shapeFillColor]);
        itemToolPrefs.shapeFillColor = appPrefsData.itemToolPrefs.shapeFillColor;
        if (appPrefsData.itemToolPrefs.imageFillColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.imageFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.imageFillColor]);
        itemToolPrefs.imageFillColor = appPrefsData.itemToolPrefs.imageFillColor;
        if (appPrefsData.itemToolPrefs.textFillColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.textFillColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textFillColor]);
        itemToolPrefs.textFillColor = appPrefsData.itemToolPrefs.textFillColor;
        if (appPrefsData.itemToolPrefs.textLineColor != CommonStrings::None)
                PageColors.insert(appPrefsData.itemToolPrefs.textLineColor, appPrefsData.colorPrefs.DColors[appPrefsData.itemToolPrefs.textLineColor]);

       
        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[itemToolPrefs.textFont]);
        cstyle.setFontSize(itemToolPrefs.textSize);
        cstyle.setFeatures(QStringList(CharStyle::INHERIT));
        cstyle.setFillColor(itemToolPrefs.textColor);
        cstyle.setFillShade(itemToolPrefs.textShade);
        cstyle.setStrokeColor(itemToolPrefs.textStrokeColor);
        cstyle.setStrokeShade(itemToolPrefs.textStrokeShade);
        cstyle.setBaselineOffset(0);
        cstyle.setShadowXOffset(50);
        cstyle.setShadowYOffset(-50);
        cstyle.setOutlineWidth(10);
        cstyle.setUnderlineOffset(typographicSettings.valueUnderlinePos);
        cstyle.setUnderlineWidth(typographicSettings.valueUnderlineWidth);
        cstyle.setStrikethruOffset(typographicSettings.valueStrikeThruPos);
        cstyle.setStrikethruWidth(typographicSettings.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
        PDF_Options.Version = (PDFOptions::PDFVersion)appPrefsData.pdfPrefs.Version;

        PDF_Options.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);
        for (int a = 0; a < DocItems.count(); ++a)
        {
                PageItem *currItem = DocItems.at(a);
                if (currItem->PictureIsAvailable)
                        ScCore->fileWatcher->removeFile(currItem->Pfile);
                if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
                {
                        QFileInfo fi(currItem->Pfile);
                        ScCore->fileWatcher->removeDir(fi.absolutePath());
                }
        }
        for (int a = 0; a < MasterItems.count(); ++a)
        {
                PageItem *currItem = MasterItems.at(a);
                if (currItem->PictureIsAvailable)
                        ScCore->fileWatcher->removeFile(currItem->Pfile);
                if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
                {
                        QFileInfo fi(currItem->Pfile);
                        ScCore->fileWatcher->removeDir(fi.absolutePath());
                }
        }
        for (int a = 0; a < FrameItems.count(); ++a)
        {
                PageItem *currItem = FrameItems.at(a);
                if (currItem->PictureIsAvailable)
                        ScCore->fileWatcher->removeFile(currItem->Pfile);
                if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
                {
                        QFileInfo fi(currItem->Pfile);
                        ScCore->fileWatcher->removeDir(fi.absolutePath());
                }
        }
        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->PictureIsAvailable)
                                ScCore->fileWatcher->removeFile(currItem->Pfile);
                        if ((currItem->asImageFrame()) && (!currItem->Pfile.isEmpty()))
                        {
                                QFileInfo fi(currItem->Pfile);
                                ScCore->fileWatcher->removeDir(fi.absolutePath());
                        }
                }
        }
        while (!DocItems.isEmpty())
        {
                delete DocItems.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();
}


void ScribusDoc::setup(const int unitIndex, const int fp, const int firstLeft, const int orientation, const int firstPageNumber, const QString& defaultPageSize, const QString& documentName)
{
        docUnitIndex=unitIndex;
        pageSets[fp].FirstPage = firstLeft;
        PageOri = orientation;
        m_pageSize = defaultPageSize;
        FirstPnum = firstPageNumber;
        currentPageLayout = fp;
        setName(documentName);
        HasCMS = false;
        if (!PDF_Options.UseLPI)
        {
                PDF_Options.LPISettings.clear();
                struct LPIData lpo;
                lpo.Frequency = 133;
                lpo.SpotFunc = 3;
                lpo.Angle = 105;
                PDF_Options.LPISettings.insert("Cyan", lpo);
                lpo.Angle = 75;
                PDF_Options.LPISettings.insert("Magenta", lpo);
                lpo.Angle = 90;
                PDF_Options.LPISettings.insert("Yellow", lpo);
                lpo.Angle = 45;
                PDF_Options.LPISettings.insert("Black", lpo);
                ActiveLayer = 0;
        }

        appMode = modeNormal;
        PrefsManager *prefsManager=PrefsManager::instance();

        docGradients = prefsManager->appPrefs.defaultGradients;

        PageColors = prefsManager->colorSet();
        PageColors.ensureBlackAndWhite();
        PageColors.setDocument(this);

        CMSSettings = prefsManager->appPrefs.colorPrefs.DCMSset;
        PDF_Options.SolidProf = CMSSettings.DefaultSolidColorRGBProfile;
        PDF_Options.ImageProf = CMSSettings.DefaultImageRGBProfile;
        PDF_Options.PrintProf = CMSSettings.DefaultPrinterProfile;
        PDF_Options.Intent = CMSSettings.DefaultIntentColors;
        PDF_Options.Intent2 = CMSSettings.DefaultIntentImages;
        BlackPoint   = CMSSettings.BlackPoint;
        SoftProofing = CMSSettings.SoftProofOn;
        Gamut        = CMSSettings.GamutCheck;
        IntentColors = CMSSettings.DefaultIntentColors;
        IntentImages = CMSSettings.DefaultIntentImages;
        if (ScCore->haveCMS() && CMSSettings.CMSinUse)
        {
                if (OpenCMSProfiles(ScCore->InputProfiles, ScCore->InputProfilesCMYK, ScCore->MonitorProfiles, ScCore->PrinterProfiles))
                {
                        HasCMS = true;
                        PDF_Options.SComp = CMSSettings.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 = CMSSettings.BlackPoint;
        colorStrategy.useBlackPreservation      = false;
        colorEngine.setStrategy(colorStrategy);

        DocDisplayProf   = ScCore->monitorProfile;
        DocInputRGBProf  = colorEngine.openProfileFromFile( InPo[CMSSettings.DefaultSolidColorRGBProfile] );
        DocInputCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[CMSSettings.DefaultSolidColorCMYKProfile] );
        DocPrinterProf   = colorEngine.openProfileFromFile( PrPo[CMSSettings.DefaultPrinterProfile] );
        DocInputImageRGBProf  = colorEngine.openProfileFromFile( InPo[CMSSettings.DefaultImageRGBProfile] );
        DocInputImageCMYKProf = colorEngine.openProfileFromFile( InPoCMYK[CMSSettings.DefaultImageCMYKProfile] );
        if ((!DocDisplayProf) || (!DocInputRGBProf) || (!DocInputCMYKProf) || (!DocPrinterProf) || (!DocInputImageCMYKProf) || (!DocInputImageRGBProf))
        {
                CMSSettings.CMSinUse = false;
                return false;
        }

        int dcmsFlags   = 0;
        int dcmsFlagsGC = 0;
        if (CMSSettings.GamutCheck)
                dcmsFlagsGC |= Ctf_GamutCheck;
        if (CMSSettings.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_RGBA_8,
                          DocDisplayProf, Format_RGBA_8, DocPrinterProf,
                          IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
        stdProofImgCMYK = colorEngine.createProofingTransform(DocInputImageCMYKProf, Format_CMYK_8,
                          DocDisplayProf, Format_RGBA_8, DocPrinterProf,
                          IntentImages, Intent_Relative_Colorimetric, dcmsFlagsGC);
        stdTransImg = colorEngine.createTransform(DocInputRGBProf, Format_RGBA_8,
                          DocDisplayProf, Format_RGBA_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 = (CMSSettings.SoftProofOn && CMSSettings.SoftProofFullOn) ? DocInputCMYKProf : DocPrinterProf;
                inputProfRGB  = DocInputRGBProf;
                inputProfCMYK = inputProf;
        }
        else
        {
                inputProf = (CMSSettings.SoftProofOn && CMSSettings.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)
                        CMSSettings.ComponentsInput2 = 3;
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmyk)
                        CMSSettings.ComponentsInput2 = 4;
        if (DocInputRGBProf.colorSpace() == ColorSpace_Cmy)
                        CMSSettings.ComponentsInput2 = 3;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Rgb)
                        CMSSettings.ComponentsInput3 = 3;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Cmyk)
                        CMSSettings.ComponentsInput3 = 4;
        if (DocInputCMYKProf.colorSpace() == ColorSpace_Cmy)
                        CMSSettings.ComponentsInput3 = 3;
        if (DocPrinterProf.colorSpace() == ColorSpace_Rgb)
                        CMSSettings.ComponentsPrinter = 3;
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmyk)
                        CMSSettings.ComponentsPrinter = 4;
        if (DocPrinterProf.colorSpace() == ColorSpace_Cmy)
                        CMSSettings.ComponentsPrinter = 3;

        bool success  = (stdTransRGBMon && stdTransCMYKMon && stdProofImg  && stdProofImgCMYK &&
                             stdTransImg    && stdTransRGB     && stdTransCMYK && stdProof       &&
                         stdProofGC     && stdProofCMYK    && stdProofCMYKGC);
        if (!success)
        {
                CloseCMSProfiles();
                CMSSettings.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 = CMSSettings.CMSinUse;
        bool newCM = enable;
        CloseCMSProfiles();
        CMSSettings.CMSinUse = newCM;
        HasCMS       = CMSSettings.CMSinUse;
        BlackPoint   = CMSSettings.BlackPoint;
        SoftProofing = CMSSettings.SoftProofOn;
        Gamut        = CMSSettings.GamutCheck;
        IntentColors = CMSSettings.DefaultIntentColors;
        IntentImages = CMSSettings.DefaultIntentImages;
        if (!CMSSettings.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;
                PDF_Options.SComp = CMSSettings.ComponentsInput2;
                PDF_Options.SolidProf = CMSSettings.DefaultSolidColorRGBProfile;
                PDF_Options.ImageProf = CMSSettings.DefaultImageRGBProfile;
                PDF_Options.PrintProf = CMSSettings.DefaultPrinterProfile;
                PDF_Options.Intent = CMSSettings.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);
                }
        }
}


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

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("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)
        {
                uint docSelectionCount=tmpSelection.count();
                PageItem *currItem;
                uint lowestItem = 999999;
                for (uint a=0; a<docSelectionCount; ++a)
                {
                        currItem = tmpSelection.itemAt(a);
                        lowestItem = qMin(lowestItem, currItem->ItemNr);
                }
                if ((lowestItem > 0) && (Items->at(lowestItem-1)->Groups.count() != 0))
                {
                        if (Items->at(lowestItem-1)->Groups.top() == tmpSelection.itemAt(0)->Groups.top())
                        {
                                tmpSelection.addItem(Items->at(lowestItem-1), true);
                        }
                }
                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
        {
                uint docSelectionCount=tmpSelection.count();
                PageItem *currItem;
                uint lowestItem = 999999;
                for (uint a=0; a<docSelectionCount; ++a)
                {
                        currItem = tmpSelection.itemAt(a);
                        lowestItem = qMin(lowestItem, currItem->ItemNr);
                }
                if ((lowestItem > 0) && (Items->at(lowestItem-1)->Groups.count() != 0))
                {
                        if (Items->at(lowestItem-1)->Groups.top() == tmpSelection.itemAt(0)->Groups.top())
                        {
                                tmpSelection.addItem(Items->at(lowestItem-1));
                        }
                }
                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 b, double h, double t, double l, double r, double bo, double sp, double ab, bool atf, int fp)
{
        pageWidth = b;
        pageHeight = h;
        pageMargins.Top = t;
        pageMargins.Left = l;
        pageMargins.Right = r;
        pageMargins.Bottom = bo;
        PageSp = sp;
        PageSpa = ab;
        currentPageLayout = 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(MarginStruct& newMargins, int fp)
{
        pageMargins = newMargins;
        currentPageLayout = 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 = docItemAttributes.begin(); it!= docItemAttributes.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(scratch.Left, DocPages.count()*(pageHeight+scratch.Bottom+scratch.Top)+scratch.Top, pageWidth, pageHeight);
        assert(addedPage!=NULL);
        addedPage->setDocument(this);
        addedPage->Margins.Top = pageMargins.Top;
        addedPage->Margins.Bottom = pageMargins.Bottom;
        addedPage->initialMargins.Top = pageMargins.Top;
        addedPage->initialMargins.Bottom = pageMargins.Bottom;
        addedPage->initialMargins.Left = pageMargins.Left;
        addedPage->initialMargins.Right = pageMargins.Right;
        addedPage->setPageNr(pageIndex);
        addedPage->m_pageSize = m_pageSize;
        addedPage->setOrientation(PageOri);
        addedPage->marginPreset = 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(scratch.Left, scratch.Top, pageWidth, pageHeight);
        assert(addedPage!=NULL);
        addedPage->setDocument(this);
        addedPage->Margins.Top = pageMargins.Top;
        addedPage->Margins.Bottom = pageMargins.Bottom;
        addedPage->Margins.Left = pageMargins.Left;//todo fix for layouts
        addedPage->Margins.Right = pageMargins.Right;
        addedPage->initialMargins.Top = pageMargins.Top;
        addedPage->initialMargins.Bottom = pageMargins.Bottom;
        addedPage->initialMargins.Left = pageMargins.Left;
        addedPage->initialMargins.Right = pageMargins.Right;
        addedPage->m_pageSize = m_pageSize;
        addedPage->setOrientation(PageOri);
        addedPage->marginPreset = 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(), pageWidth-addToPage->Margins.Right-addToPage->Margins.Left,
                                     pageHeight-addToPage->Margins.Bottom-addToPage->Margins.Top,
                                                         1, CommonStrings::None, 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);
                }
        }
        Selection targetSelection(Serializer(*this).cloneObjects(sourceSelection));
        for(int si(0); si < targetSelection.count(); ++si)
        {
                targetSelection.itemAt(si)->setLayer(whereToInsert);
        }
}


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, DocName, 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)
                {
                        (*it).flowControl = flow;
                        found=true;
                        break;
                }
        }
        if (found)
                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;
        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;
        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)
{
        uint masterItemsCount=MasterItems.count();
        for (uint i = 0; i < masterItemsCount; ++i)
        {
                if (MasterItems.at(i)->LayerID == layerID)
                        return true;
        }
        uint docItemsCount=DocItems.count();
        for (uint i = 0; i < docItemsCount; ++i)
        {
                if (DocItems.at(i)->LayerID == layerID)
                        return true;
        }
        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() == itemToolPrefs.shapeFillColor) || (it.key() == itemToolPrefs.shapeLineColor) || (it.key() == itemToolPrefs.imageFillColor)
                                || (it.key() == itemToolPrefs.lineColor) || (it.key() == 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;
}

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;
//      for (QMap<QString, ScPattern>::Iterator it = patterns.begin(); it != patterns.end(); ++it)
//      {
//              docPatterns.insert(it.key(), it.data());
//      }
/*      for (int c=0; c<DocItems.count(); ++c)
        {
                PageItem *ite = DocItems.at(c);
                if ((!docPatterns.contains(ite->pattern())) && (ite->GrType == 8))
                {
                        ite->setPattern("");
                        ite->GrType = 0;
                }
        }
        for (int c=0; c<MasterItems.count(); ++c)
        {
                PageItem *ite = MasterItems.at(c);
                if ((!docPatterns.contains(ite->pattern())) && (ite->GrType == 8))
                {
                        ite->setPattern("");
                        ite->GrType = 0;
                }
        }
        for (int c=0; c<FrameItems.count(); ++c)
        {
                PageItem *ite = FrameItems.at(c);
                if ((!docPatterns.contains(ite->pattern())) && (ite->GrType == 8))
                {
                        ite->setPattern("");
                        ite->GrType = 0;
                }
        } */

}


QStringList ScribusDoc::getUsedPatterns()
{
        QStringList results;
        for (int c = 0; c < MasterItems.count(); ++c)
        {
                if ((!results.contains(MasterItems.at(c)->pattern())) && (MasterItems.at(c)->GrType == 8))
                        results.append(MasterItems.at(c)->pattern());
                if (!MasterItems.at(c)->strokePattern().isEmpty())
                {
                        if (!results.contains(MasterItems.at(c)->strokePattern()))
                                results.append(MasterItems.at(c)->strokePattern());
                }
                if (!MasterItems.at(c)->patternMask().isEmpty())
                {
                        if (!results.contains(MasterItems.at(c)->patternMask()))
                                results.append(MasterItems.at(c)->patternMask());
                }
        }
        for (int c = 0; c < DocItems.count(); ++c)
        {
                if ((!results.contains(DocItems.at(c)->pattern())) && (DocItems.at(c)->GrType == 8))
                        results.append(DocItems.at(c)->pattern());
                if (!DocItems.at(c)->strokePattern().isEmpty())
                {
                        if (!results.contains(DocItems.at(c)->strokePattern()))
                                results.append(DocItems.at(c)->strokePattern());
                }
                if (!DocItems.at(c)->patternMask().isEmpty())
                {
                        if (!results.contains(DocItems.at(c)->patternMask()))
                                results.append(DocItems.at(c)->patternMask());
                }
        }
        for (int c = 0; c < FrameItems.count(); ++c)
        {
                if ((!results.contains(FrameItems.at(c)->pattern())) && (FrameItems.at(c)->GrType == 8))
                        results.append(FrameItems.at(c)->pattern());
                if (!FrameItems.at(c)->strokePattern().isEmpty())
                {
                        if (!results.contains(FrameItems.at(c)->strokePattern()))
                                results.append(FrameItems.at(c)->strokePattern());
                }
                if (!FrameItems.at(c)->patternMask().isEmpty())
                {
                        if (!results.contains(FrameItems.at(c)->patternMask()))
                                results.append(FrameItems.at(c)->patternMask());
                }
        }
        for (int c = 0; c < results.count(); ++c)
        {
                QStringList pats = getUsedPatternsHelper(results[c], results);
                if (!pats.isEmpty())
                        results += pats;
        }
        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)
                        {
                                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());
                }
                for (int c = 0; c < results.count(); ++c)
                {
                        QStringList pats = getUsedPatternsHelper(results[c], results);
                        if (!pats.isEmpty())
                                results += pats;
                }
                return results;
        }
        else
                return QStringList();
}


QStringList ScribusDoc::getUsedPatternsHelper(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)->GrType == 8)
                {
                        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))
                        results.append(pat->items.at(c)->strokePattern());
                const QString& pat3 = pat->items.at(c)->patternMask();
                if (!pat3.isEmpty() && !results.contains(pat3))
                        results.append(pat->items.at(c)->patternMask());
        }
        if (!pats.isEmpty())
        {
                for (int c = 0; c < pats.count(); ++c)
                {
                        getUsedPatternsHelper(pats[c], results);
                }
        }
        return pats;
}

QMap<QString,int> ScribusDoc::reorganiseFonts()
{
//      QTime t;
//      t.start();
        QMap<QString,int> Really;
        //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->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]);
                                }
                        }
                }
        }
        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(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)
{
        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;
                        }
                        checkItemForFonts(it, Really, lc);
                }
        }
        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++)
                {
                        checkItemForFonts(pa.items.at(o), Really, 3);
                }
        }
}


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)
                                {
                                        //If not on a master page just get the page number for the page and the text
                                        if (lc!=0)
                                                pageNumberText=getSectionPageNumberForPageIndex(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);
                                                                for (int nti=0;nti<newText.length();++nti)
                                                                        if (pageNumberText.indexOf(newText[nti])==-1)
                                                                                pageNumberText+=newText[nti];
                                                        }
                                                }
                                        }
                                }
                                else
                                {
                                        if (lc!=0)
                                        {
                                                QString out("%1");
                                                int key = getSectionKeyForPageIndex(it->OwnPage);
                                                if (key == -1)
                                                        pageNumberText = "";
                                                else
                                                        pageNumberText = out.arg(getStringFromSequence(sections[key].type, sections[key].toindex - sections[key].fromindex + 1));
                                        }
                                        else
                                        {
                                                QString newText;
                                                uint docPageCount=DocPages.count();
                                                for (uint a = 0; a < docPageCount; ++a)
                                                {
                                                        if (DocPages.at(a)->MPageNam == it->OnMasterPage)
                                                        {
                                                                QString out("%1");
                                                                int key = getSectionKeyForPageIndex(a);
                                                                if (key == -1)
                                                                        newText = "";
                                                                else
                                                                        newText = out.arg(getStringFromSequence(sections[key].type, sections[key].toindex - sections[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_SmartHyphenVisible)
                        {
                                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();

        profileNames.append(CMSSettings.DefaultSolidColorRGBProfile);
        profileNames.append(CMSSettings.DefaultSolidColorCMYKProfile);
        if( profileNames.indexOf(CMSSettings.DefaultImageRGBProfile) < 0 )
                profileNames.append(CMSSettings.DefaultImageRGBProfile);
        if( profileNames.indexOf(CMSSettings.DefaultImageCMYKProfile) < 0 )
                profileNames.append(CMSSettings.DefaultImageCMYKProfile);
        if( profileNames.indexOf(CMSSettings.DefaultMonitorProfile) < 0 )
                profileNames.append(CMSSettings.DefaultMonitorProfile);
        if( profileNames.indexOf(CMSSettings.DefaultPrinterProfile) < 0 )
                profileNames.append(CMSSettings.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->IProfile.isEmpty() || profileNames.contains(it->IProfile))
                                continue;
                        profileNames.append(it->IProfile);
                }
        }

        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)
{
        docUnitIndex=newIndex;
        docUnitRatio = unitGetRatioFromIndex( docUnitIndex );
}


int ScribusDoc::unitIndex() const
{
        return 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[currentPageLayout].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 ((view()) && (view()->m_canvas->usePreviewVisual()))
                        {
                                VisionDefectColor defect;
                                tmp = defect.convertDefect(tmp, view()->m_canvas->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 (currentPageLayout != 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();
                                                QString dataS = ss->WriteElem(this, &tempSelection);
                                                setCurrentPage(targetPage);
                                                ss->ReadElemToLayer(dataS, appPrefsData.fontPrefs.AvailFonts, this, targetPage->xOffset(), targetPage->yOffset(), false, true, appPrefsData.fontPrefs.GFontSub, it->ID);
                                                delete ss;
                                                setMasterPageMode(false);
                                        }
                                        tempSelection.clear();
                                }
                                setActiveLayer(currActiveLayer);
                        }
                }
        }
        //Copy the items from our current *document* page
        if (Layers.count()!= 0)
        {
                int currActiveLayer = activeLayer();
                for (ScLayers::iterator it = Layers.begin(); it != Layers.end(); ++it)
                {
                        setActiveLayer(it->ID);
                        for (uint ite = 0; ite < end; ++ite)
                        {
                                PageItem *itemToCopy = DocItems.at(ite);
                                if ((itemToCopy->OwnPage == static_cast<int>(sourcePage->pageNr())) && (it->ID == itemToCopy->LayerID))
                                        tempSelection.addItem(itemToCopy, true);
                        }
                        if (tempSelection.count() != 0)
                        {
                                ScriXmlDoc *ss = new ScriXmlDoc();
                                QString dataS = ss->WriteElem(this, &tempSelection);
                                setMasterPageMode(true);
                                setCurrentPage(targetPage);
                                ss->ReadElemToLayer(dataS, appPrefsData.fontPrefs.AvailFonts, this, targetPage->xOffset(), targetPage->yOffset(), false, true, appPrefsData.fontPrefs.GFontSub, it->ID);
                                delete ss;
                                setMasterPageMode(false);
                        }
                        tempSelection.clear();
                }
                setActiveLayer(currActiveLayer);
        }
        //Make sure our copied items have the master page name and own page set.
        uint end3 = MasterItems.count();
        for (uint a = end2; a < end3; ++a)
        {
                PageItem *newItem = MasterItems.at(a);
                newItem->OnMasterPage = masterPageName;
                newItem->OwnPage = MasterNames[masterPageName];
        }
        targetPage->MPageNam = "";
        setLoading(false);
        GroupCounter = GrMax + 1;
        //Reset the current page..
        setMasterPageMode(false);
        setCurrentPage(oldCurrentPage);
        changed();
        return true;
}

void ScribusDoc::PasteItem(struct CopyPasteBuffer *Buffer, bool drag, bool resize)
{
        QColor tmp;
        double x = Buffer->Xpos;
        double y = Buffer->Ypos;
        double w = Buffer->Width;
        double h = Buffer->Height;
        double pw = Buffer->Pwidth;
        int z = 0;
        switch (Buffer->PType)
        {
        // OBSOLETE CR 2005-02-06
        case PageItem::ItemType1:
                z = itemAdd(PageItem::Polygon, PageItem::Ellipse, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2, true);
                break;
        //
        case PageItem::ImageFrame:
                z = itemAdd(PageItem::ImageFrame, PageItem::Unspecified, x, y, w, h, 1, itemToolPrefs.imageFillColor, CommonStrings::None, true);
                undoManager->setUndoEnabled(false);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
                Items->at(z)->setImageRotation(Buffer->LocalRot);
                Items->at(z)->Pfile = Buffer->Pfile;
                Items->at(z)->IProfile = Buffer->IProfile;
                Items->at(z)->EmProfile = Buffer->EmProfile;
                Items->at(z)->IRender = Buffer->IRender;
                Items->at(z)->UseEmbedded = Buffer->UseEmbedded;
                if (!Items->at(z)->Pfile.isEmpty())
                        LoadPict(Items->at(z)->Pfile, z);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageShown(Buffer->PicArt);
                Items->at(z)->ScaleType = Buffer->ScaleType;
                Items->at(z)->AspectRatio = Buffer->AspectRatio;
                Items->at(z)->setLineWidth(Buffer->Pwidth);
                undoManager->setUndoEnabled(true);
                break;
        // OBSOLETE CR 2005-02-06
        case PageItem::ItemType3:
                z = itemAdd(PageItem::Polygon, PageItem::Rectangle, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2, true);
                break;
        //
        case PageItem::PathText:
        case PageItem::TextFrame:
#ifndef NLS_PROTO
                if (Buffer->PType == PageItem::PathText)
                        z = itemAdd(PageItem::PathText, PageItem::Unspecified, x, y, w, h, pw, CommonStrings::None, Buffer->Pcolor, true);
                else
                        z = itemAdd(PageItem::TextFrame, PageItem::Unspecified, x, y, w, h, pw, CommonStrings::None, Buffer->Pcolor, true);
                undoManager->setUndoEnabled(false);
                if ((Buffer->m_isAnnotation) && (Buffer->m_annotation.UseIcons()))
                {
                        Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                        Items->at(z)->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
                        Items->at(z)->setImageRotation(Buffer->LocalRot);
                        Items->at(z)->Pfile = Buffer->Pfile;
                        Items->at(z)->Pfile2 = Buffer->Pfile2;
                        Items->at(z)->Pfile3 = Buffer->Pfile3;
                        Items->at(z)->IProfile = Buffer->IProfile;
                        Items->at(z)->EmProfile = Buffer->EmProfile;
                        Items->at(z)->IRender = Buffer->IRender;
                        Items->at(z)->UseEmbedded = Buffer->UseEmbedded;
                        LoadPict(Items->at(z)->Pfile, z);
                        Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                        Items->at(z)->setImageShown(Buffer->PicArt);
                }
                if (!Buffer->itemText.isEmpty())
                {
                        QTextStream t(&Buffer->itemText, QIODevice::ReadOnly);
                        QString cc;
                        while (!t.atEnd())
                        {
                                cc = t.readLine();
                                if (cc.isEmpty())
                                        continue;
                                QStringList wt;
                                QStringList::Iterator it;
                                wt = cc.split("\t", QString::SkipEmptyParts);
                                it = wt.begin();
                                CharStyle nstyle;
                                QString ch = (*it);
                                if (ch == QChar(5))
                                        ch = SpecialChars::PARSEP;
                                if (ch == QChar(4))
                                        ch = SpecialChars::TAB;
                                it++;
                                nstyle.setFont((*AllFonts)[*it]);
                                it++;
                                nstyle.setFontSize(qRound(ScCLocale::toDoubleC((*it)) * 10));
                                it++;
                                nstyle.setFillColor(*it);
                                it++;
                                nstyle.setTracking((*it).toInt());
                                it++;
                                nstyle.setFillShade((*it).toInt());
                                it++;
                                nstyle.setFeatures(static_cast<StyleFlag>(it == wt.end() ? 0 : (*it).toInt()).featureList());
                                it++;
                                int cab = it == wt.end() ? 0 : (*it).toInt();
                                it++;
                                nstyle.setStrokeColor(it == wt.end() ? CommonStrings::None : *it);
                                it++;
                                nstyle.setStrokeShade(it == wt.end() ? 100 : (*it).toInt());
                                it++;
                                if (it == wt.end())
                                        nstyle.setScaleH(1000);
                                else
                                        nstyle.setScaleH(qMin(qMax((*it).toInt(), 100), 4000));
                                it++;
                                if (it == wt.end())
                                        nstyle.setScaleV(1000);
                                else
                                        nstyle.setScaleV(qMin(qMax((*it).toInt(), 100), 4000));
                                it++;
                                nstyle.setBaselineOffset(it == wt.end() ? 0 : (*it).toInt());
                                it++;
                                nstyle.setShadowXOffset(it == wt.end() ? 50 : (*it).toInt());
                                it++;
                                nstyle.setShadowYOffset(it == wt.end() ? -50 : (*it).toInt());
                                it++;
                                nstyle.setOutlineWidth(it == wt.end() ? 10 : (*it).toInt());
                                it++;
                                nstyle.setUnderlineOffset(it == wt.end() ? -1 : (*it).toInt());
                                it++;
                                nstyle.setUnderlineWidth(it == wt.end() ? -1 : (*it).toInt());
                                it++;
                                nstyle.setStrikethruOffset(it == wt.end() ? -1 : (*it).toInt());
                                it++;
                                nstyle.setStrikethruWidth(it == wt.end() ? -1 : (*it).toInt());
                                uint pos = Items->at(z)->itemText.length();
                                Items->at(z)->itemText.insertChars(pos, ch);
                                if (ch == SpecialChars::PARSEP && cab > 0) {
                                        ParagraphStyle pstyle;
                                        pstyle.setParent(paragraphStyles()[cab].name());
                                        Items->at(z)->itemText.applyStyle(pos, pstyle);
                                }
                                else {
                                        Items->at(z)->itemText.applyCharStyle(pos, 1, nstyle);
                                }
                        }
                }
                {
                        ParagraphStyle pstyle;
                        pstyle.setAlignment(static_cast<ParagraphStyle::AlignmentType>(Buffer->textAlignment));
                        pstyle.setLineSpacing(Buffer->LineSp);
                        pstyle.setLineSpacingMode(static_cast<ParagraphStyle::LineSpacingMode>(Buffer->LineSpMode));
                        if (AllFonts->contains(Buffer->IFont))
                                pstyle.charStyle().setFont((*AllFonts)[Buffer->IFont]);
                        else
                                pstyle.charStyle().setFont((*AllFonts)[itemToolPrefs.textFont]);
                        pstyle.charStyle().setFontSize(Buffer->ISize);
                        pstyle.charStyle().setFillColor(Buffer->TxtFill);
                        pstyle.charStyle().setStrokeColor(Buffer->TxtStroke);
                        pstyle.charStyle().setFillShade(Buffer->ShTxtFill);
                        pstyle.charStyle().setStrokeShade(Buffer->ShTxtStroke);
                        pstyle.charStyle().setScaleH(Buffer->TxtScale);
                        pstyle.charStyle().setScaleV(Buffer->TxtScaleV);
                        pstyle.charStyle().setBaselineOffset(Buffer->TxTBase);
                        pstyle.charStyle().setFeatures(StyleFlag(Buffer->TxTStyle).featureList());
                        pstyle.charStyle().setShadowXOffset(Buffer->TxtShadowX);
                        pstyle.charStyle().setShadowYOffset(Buffer->TxtShadowY);
                        pstyle.charStyle().setOutlineWidth(Buffer->TxtOutline);
                        pstyle.charStyle().setUnderlineOffset(Buffer->TxtUnderPos);
                        pstyle.charStyle().setUnderlineWidth(Buffer->TxtUnderWidth);
                        pstyle.charStyle().setStrikethruOffset(Buffer->TxtStrikePos);
                        pstyle.charStyle().setStrikethruWidth(Buffer->TxtStrikeWidth);
                        Items->at(z)->itemText.setDefaultStyle(pstyle);
                }
                undoManager->setUndoEnabled(true);
#endif
                break;
        case PageItem::Line:
                z = itemAdd(PageItem::Line, PageItem::Unspecified, x, y, w ,0, pw, CommonStrings::None, Buffer->Pcolor2, true);
                break;
        case PageItem::Polygon:
                z = itemAdd(PageItem::Polygon, PageItem::Unspecified, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2, true);
                break;
        case PageItem::PolyLine:
                z = itemAdd(PageItem::PolyLine, PageItem::Unspecified, x, y, w, h, pw, Buffer->Pcolor, Buffer->Pcolor2, true);
                break;
        case PageItem::Multiple:
                Q_ASSERT(false);
                break;
        case PageItem::LatexFrame:
                {
                z = itemAdd(PageItem::LatexFrame, PageItem::Unspecified, x, y, w, h, 1, itemToolPrefs.imageFillColor, CommonStrings::None, true);
                undoManager->setUndoEnabled(false);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
                Items->at(z)->setImageRotation(Buffer->LocalRot);
                Items->at(z)->Pfile = Buffer->Pfile;
                Items->at(z)->IProfile = Buffer->IProfile;
                Items->at(z)->EmProfile = Buffer->EmProfile;
                Items->at(z)->IRender = Buffer->IRender;
                Items->at(z)->UseEmbedded = Buffer->UseEmbedded;
                if (!Items->at(z)->Pfile.isEmpty())
                        LoadPict(Items->at(z)->Pfile, z);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageShown(Buffer->PicArt);
                Items->at(z)->ScaleType = Buffer->ScaleType;
                Items->at(z)->AspectRatio = Buffer->AspectRatio;
                Items->at(z)->setLineWidth(Buffer->Pwidth);
                PageItem_LatexFrame *latexframe = Items->at(z)->asLatexFrame();
                latexframe->setFormula(Buffer->itemText); //itemText seems to be a good choice...
                undoManager->setUndoEnabled(true);
                break;
                }
        case PageItem::OSGFrame:
#ifdef HAVE_OSG
                z = itemAdd(PageItem::OSGFrame, PageItem::Unspecified, x, y, w, h, 1, itemToolPrefs.imageFillColor, CommonStrings::None, true);
                undoManager->setUndoEnabled(false);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageXYOffset(Buffer->LocalX, Buffer->LocalY);
                Items->at(z)->setImageRotation(Buffer->LocalRot);
                Items->at(z)->Pfile = Buffer->Pfile;
                Items->at(z)->IProfile = Buffer->IProfile;
                Items->at(z)->EmProfile = Buffer->EmProfile;
                Items->at(z)->IRender = Buffer->IRender;
                Items->at(z)->UseEmbedded = Buffer->UseEmbedded;
                if (!Items->at(z)->Pfile.isEmpty())
                        LoadPict(Items->at(z)->Pfile, z);
                Items->at(z)->setImageXYScale(Buffer->LocalScX, Buffer->LocalScY);
                Items->at(z)->setImageShown(Buffer->PicArt);
                Items->at(z)->ScaleType = Buffer->ScaleType;
                Items->at(z)->AspectRatio = Buffer->AspectRatio;
                Items->at(z)->setLineWidth(Buffer->Pwidth);
                undoManager->setUndoEnabled(true);
#endif
                break;
        }
        PageItem *currItem = Items->at(z);
        undoManager->setUndoEnabled(false);
/*FIXME
        currItem->setLineSpacingMode(Buffer->LineSpMode);
        if (currItem->lineSpacingMode() == 3)
        {
                currItem->setLineSpacing(Doc->typographicSettings.valueBaseGrid-1);
        }
        */

        currItem->setImageFlippedH(Buffer->flippedH);
        currItem->setImageFlippedV(Buffer->flippedV);
        currItem->setCornerRadius(Buffer->RadRect);
        currItem->FrameType = Buffer->FrameType;
        currItem->ClipEdited = Buffer->ClipEdited;
        currItem->setFillColor(Buffer->Pcolor);
        currItem->setLineColor(Buffer->Pcolor2);
        currItem->setFillShade(Buffer->Shade);
        currItem->setLineShade(Buffer->Shade2);
        currItem->fillRule = Buffer->FillRule;
        currItem->setRotation(Buffer->Rot);
        currItem->setTextToFrameDist(Buffer->Extra, Buffer->RExtra, Buffer->TExtra, Buffer->BExtra);
        currItem->PLineArt = Qt::PenStyle(Buffer->PLineArt);
        currItem->PLineEnd = Qt::PenCapStyle(Buffer->PLineEnd);
        currItem->PLineJoin = Qt::PenJoinStyle(Buffer->PLineJoin);
        currItem->setPrintEnabled(Buffer->isPrintable);
        currItem->isBookmark = Buffer->isBookmark;
        currItem->Groups = Buffer->Groups;
        currItem->setIsAnnotation(Buffer->m_isAnnotation);
        currItem->setAnnotation(Buffer->m_annotation);
        if (!Buffer->AnName.isEmpty())
        {
                if (!drag)
                {
                        if (currItem->itemName() == Buffer->AnName)
                                currItem->AutoName = true;
                        else
                        {
                                currItem->setItemName(Buffer->AnName);
                                currItem->AutoName = false;
                        }
                }
                else
                {
                        currItem->setItemName(Buffer->AnName);
                        currItem->AutoName = false;
                }
        }
        else
        {
                if (currItem->isGroupControl)
                        currItem->setItemName( tr("Group%1").arg(currItem->Groups.top()));
        }

        currItem->TopLine = Buffer->TopLine;
        currItem->RightLine = Buffer->RightLine;
        currItem->LeftLine = Buffer->LeftLine;
        currItem->BottomLine = Buffer->BottomLine;
        currItem->isTableItem = Buffer->isTableItem;
        currItem->TopLinkID = Buffer->TopLinkID;
        currItem->LeftLinkID = Buffer->LeftLinkID;
        currItem->RightLinkID = Buffer->RightLinkID;
        currItem->BottomLinkID = Buffer->BottomLinkID;
        currItem->Clip = Buffer->Clip; //irrelevant, overwritten below
        currItem->PoShow = Buffer->PoShow;
        currItem->BaseOffs = Buffer->BaseOffs;
        currItem->textPathFlipped = Buffer->textPathFlipped;
        currItem->textPathType = Buffer->textPathType;
        currItem->setTextFlowMode((PageItem::TextFlowMode) Buffer->TextflowMode);
        currItem->DashValues = Buffer->DashValues;
        currItem->DashOffset = Buffer->DashOffset;
        currItem->setLocked(Buffer->Locked);
        currItem->setSizeLocked(Buffer->LockRes);
        currItem->setFillTransparency(Buffer->Transparency);
        currItem->setLineTransparency(Buffer->TranspStroke);
        currItem->setFillBlendmode(Buffer->TransBlend);
        currItem->setLineBlendmode(Buffer->TransBlendS);
        currItem->setStartArrowIndex(Buffer->startArrowIndex);
        currItem->setEndArrowIndex(Buffer->endArrowIndex);
        currItem->setReversed(Buffer->Reverse);
        currItem->NamedLStyle = Buffer->NamedLStyle;
        currItem->Cols = Buffer->Cols;
        currItem->ColGap = Buffer->ColGap;
        currItem->setFirstLineOffset(Buffer->firstLineOffsetP);
        if (Buffer->LayerID != -1)
                currItem->LayerID = Buffer->LayerID;
        currItem->PoLine = Buffer->PoLine.copy();
        currItem->setTextFlowMode((PageItem::TextFlowMode) Buffer->TextflowMode);
        if (Buffer->ContourLine.size() == 0)
                currItem->ContourLine = currItem->PoLine.copy();
        else
                currItem->ContourLine = Buffer->ContourLine.copy();
        if (!currItem->asLine())
        {
                // OBSOLETE CR 2005-02-06
                if ((currItem->PoLine.size() == 0) && (currItem->itemType() != PageItem::ItemType1))
                        currItem->convertClip();
                else