Subversion Repositories Scribus

Rev

Rev 280 | Rev 283 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

/***************************************************************************
                          scribus.cpp  -  description
                             -------------------
    begin                : Fre Apr  6 21:09:31 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 <qaccel.h>
#include <qapplication.h>
#include <qeventloop.h>
#include <qcolordialog.h>
#include <qcolor.h>
#include <qiconset.h>
#include <qtextstream.h>
#include <qstylefactory.h>
#include <qregexp.h>
#include <qtextcodec.h>
#include <qcursor.h>
#include <qvbox.h>
#include <cstdio>
#include <cstdlib>
#include <dlfcn.h>
#include <unistd.h>
#include <iostream>
#include <signal.h>
#include <string>
#include "scribus.h"
#include "scribus.moc"
#include "newfile.h"
#include "page.h"
#include "query.h"
#include "mdup.h"
#include "docinfo.h"
#include "reformdoc.h"
#include "serializer.h"
#include "align.h"
#include "fmitem.h"
#include "fontprefs.h"
#include "libprefs/prefs.h"
#include "pdfopts.h"
#include "inspage.h"
#include "delpages.h"
#include "movepage.h"
#include "helpbrowser.h"
#include "scribusXml.h"
#include "libabout/about.h"
#include "druck.h"
#include "editformats.h"
#include "muster.h"
#include "applytemplate.h"
#include "picstatus.h"
#include "customfdialog.h"
#include "cmsprefs.h"
#include "annot.h"
#include "annota.h"
#include "javadocs.h"
#include "colorm.h"
#include "mpalette.h"

#ifndef _MSC_VER   // jjsa 21-03-2004 (lint complains)
#define _MSC_VER -1
#endif

#if (_MSC_VER >= 1200)
 #include "win-config.h"
#else
 #include "config.h"
#endif

#if (_MSC_VER == -1 )   // jjsa 21-03-2004 (lint complains)
#undef _MSC_VER
#endif

#include "fpoint.h"
#include "fpointarray.h"
#include "hysettings.h"
#include "guidemanager.h"
#include "mergedoc.h"
#include "lineformats.h"
#include "story.h"
#include "autoform.h"
#include "tabmanager.h"
#include "search.h"
#include "fontcombo.h"


extern QPixmap loadIcon(QString nam);
extern bool overwrite(QWidget *parent, QString filename);
extern void CopyPageItem(struct CLBuf *Buffer, PageItem *b);
extern void ReOrderText(ScribusDoc *doc, ScribusView *view);
extern int copyFile(QString source, QString target);
extern int moveFile(QString source, QString target);

using namespace std;

#ifdef HAVE_CMS
cmsHPROFILE CMSoutputProf;
cmsHPROFILE CMSprinterProf;
cmsHTRANSFORM stdTrans;
cmsHTRANSFORM stdProof;
cmsHTRANSFORM stdTransImg;
cmsHTRANSFORM stdProofImg;
bool SoftProofing;
bool Gamut;
bool CMSuse;
int IntentMonitor;
int IntentPrinter;
#endif
bool CMSavail;
ProfilesL InputProfiles;
int PolyC;
int PolyFd;
double PolyF;
bool PolyS;
double PolyR;
double UmReFaktor;
QString DocDir;
ScribusApp* ScApp;

ScribusApp::ScribusApp()
{} // ScribusApp::ScribusApp()

void ScribusApp::initGui()
{
        splash = new SplashScreen();
        splash->setStatus(QObject::tr("Initializing..."));
        initScribus();
        splash->close();
        delete splash;
}

void ScribusApp::initScribus()
{
        ScApp = this;
        setCaption( tr("Scribus " VERSION));
        setKeyCompression(false);
        setIcon(loadIcon("AppIcon.png"));
        MenuItemsFile.clear();
        initMenuBar();
        initStatusBar();
        WerkTools2 = new QToolBar( tr("File"), this);
        DatNeu = new QToolButton(loadIcon("DateiNeu.xpm"), tr("Create a new Document"), QString::null, this, SLOT(slotFileNew()), WerkTools2);
        DatOpe = new QToolButton(loadIcon("DateiOpen.xpm"), tr("Open a Document"), QString::null, this, SLOT(slotDocOpen()), WerkTools2);
        DatSav = new QToolButton(loadIcon("DateiSave.xpm"), tr("Save the current Document"), QString::null, this, SLOT(slotFileSave()), WerkTools2);
        DatClo = new QToolButton(loadIcon("DateiClos.xpm"), tr("Close the current Document"), QString::null, this, SLOT(slotFileClose()), WerkTools2);
        DatPri = new QToolButton(loadIcon("DateiPrint.xpm"), tr("Print the current Document"), QString::null, this, SLOT(slotFilePrint()), WerkTools2);
        DatPDF = new QToolButton(loadIcon("acrobat.png"), tr("Save the current Document as PDF"), QString::null, this, SLOT(SaveAsPDF()), WerkTools2);
        DatSav->setEnabled(false);
        DatClo->setEnabled(false);
        DatPri->setEnabled(false);
        DatPDF->setEnabled(false);
        DatOpe->setPopup(recentMenu);
        WerkTools = new WerkToolB(this);
        setDockEnabled(WerkTools, DockLeft, false);
        setDockEnabled(WerkTools, DockRight, false);
        WerkTools->Sichtbar = true;
        WerkTools->setEnabled(false);
        WerkToolsP = new WerkToolBP(this);
        setDockEnabled(WerkToolsP, DockLeft, false);
        setDockEnabled(WerkToolsP, DockRight, false);
        WerkToolsP->setEnabled(false);
        WerkToolsP->Sichtbar = true;
        QString Pff = QDir::convertSeparators(QDir::homeDirPath()+"/.scribus");
        QFileInfo Pffi = QFileInfo(Pff);
        if (Pffi.exists())
        {
                if (Pffi.isDir())
                        PrefsPfad = Pff;
                else
                        PrefsPfad = QDir::homeDirPath();
        }
        else
        {
                QDir di = QDir();
                di.mkdir(Pff);
                PrefsPfad = Pff;
                QString OldPR = QDir::convertSeparators(QDir::homeDirPath()+"/.scribus.rc");
                QFileInfo OldPi = QFileInfo(OldPR);
                if (OldPi.exists())
                        moveFile(OldPR, Pff+"/scribus.rc");
                QString OldPR2 = QDir::convertSeparators(QDir::homeDirPath()+"/.scribusfont.rc");
                QFileInfo OldPi2 = QFileInfo(OldPR2);
                if (OldPi2.exists())
                        moveFile(OldPR2, Pff+"/scribusfont.rc");
                QString OldPR3 = QDir::convertSeparators(QDir::homeDirPath()+"/.scribusscrap.scs");
                QFileInfo OldPi3 = QFileInfo(OldPR3);
                if (OldPi3.exists())
                        moveFile(OldPR3, Pff+"/scrap.scs");
        }
        /** Erstelle Fontliste */
        NoFonts = false;
        BuFromApp = false;
        splash->setStatus( tr("Searching for Fonts"));
        GetAllFonts();
        if (NoFonts)
        {
                QString mess = tr("There are no Postscript-Fonts on your System");
                mess += "\n" + tr("Exiting now");
                QMessageBox::critical(this, tr("Fatal Error"), mess, 1, 0, 0);
        }
        else
        {
                HaveDoc = 0;
                singleClose = false;
                ScriptRunning = false;
                DLLReturn = "";
                DLLinput = "";
                view = NULL;
                doc = NULL;
                Buffer2 = "";
                UniCinp = false;
                UniCinC = 0;
                UniCinS = "";
                BuildFontMenu();
                SCFontsIterator it(Prefs.AvailFonts);
                Prefs.DefFont = it.currentKey();
                Prefs.DefSize = 120;
                Prefs.AppFontSize = qApp->font().pointSize();
                /** Default Farbenliste */
                Prefs.DColors.clear();
                QString pfadC = PREL;
                QString pfadC2 = pfadC + "/lib/scribus/rgbscribus.txt";
                QFile fiC(pfadC2);
                if (!fiC.exists())
                {
                        Prefs.DColors.insert("White", CMYKColor(0, 0, 0, 0));
                        Prefs.DColors.insert("Black", CMYKColor(0, 0, 0, 255));
                        Prefs.DColors.insert("Blue", CMYKColor(255, 255, 0, 0));
                        Prefs.DColors.insert("Cyan", CMYKColor(255, 0, 0, 0));
                        Prefs.DColors.insert("Green", CMYKColor(255, 0, 255, 0));
                        Prefs.DColors.insert("Red", CMYKColor(0, 255, 255, 0));
                        Prefs.DColors.insert("Yellow", CMYKColor(0, 0, 255, 0));
                        Prefs.DColors.insert("Magenta", CMYKColor(0, 255, 0, 0));
                        Prefs.DColorSet = "Scribus-Small";
                }
                else
                {
                        if (fiC.open(IO_ReadOnly))
                        {
                                QString ColorEn, Cname;
                                int Rval, Gval, Bval;
                                QTextStream tsC(&fiC);
                                ColorEn = tsC.readLine();
                                while (!tsC.atEnd())
                                {
                                        ColorEn = tsC.readLine();
                                        QTextStream CoE(&ColorEn, IO_ReadOnly);
                                        CoE >> Rval;
                                        CoE >> Gval;
                                        CoE >> Bval;
                                        CoE >> Cname;
                                        CMYKColor tmp;
                                        tmp.setColorRGB(Rval, Gval, Bval);
                                        Prefs.DColors.insert(Cname, tmp);
                                }
                                fiC.close();
                        }
                        Prefs.DColorSet = "X11 RGB-Set";
                }
                DispX = 10;
                DispY = 10;
                Prefs.Wheelval = 40;
                Prefs.GrabRad = 4;
                Prefs.GuideRad = 10;
                Prefs.DminGrid = 20;
                Prefs.DmajGrid = 100;
                DocNr = 1;
                Prefs.DminColor = QColor(green);
                Prefs.DmajColor = QColor(green);
                Prefs.DpapColor = QColor(white);
                Prefs.DmargColor = QColor(blue);
                Prefs.guideColor = QColor(darkBlue);
                Prefs.DVHoch = 33;
                Prefs.DVHochSc = 100;
                Prefs.DVTief = 33;
                Prefs.DVTiefSc = 100;
                Prefs.DVKapit = 75;
                Prefs.GUI = "Default";
                Prefs.Dpen = "Black";
                Prefs.Dbrush = "Black";
                Prefs.Dshade = 100;
                Prefs.Dshade2 = 100;
                Prefs.DLineArt = SolidLine;
                Prefs.Dwidth = 1;
                Prefs.DpenLine = "Black";
                Prefs.DpenText = "Black";
                Prefs.DCols = 1;
                Prefs.DGap = 0.0;
                Prefs.DshadeLine = 100;
                Prefs.DLstyleLine = SolidLine;
                Prefs.DwidthLine = 1;
                Prefs.MagMin = 10;
                Prefs.MagMax = 800;
                Prefs.MagStep = 25;
                Prefs.DbrushPict = "White";
                Prefs.ShadePict = 100;
                Prefs.ScaleX = 1;
                Prefs.ScaleY = 1;
                Prefs.Before = true;
                Prefs.Einheit = 0;
                UmReFaktor = 1.0;
                PolyC = 4;
                PolyF = 0.5;
                PolyS = false;
                PolyFd = 0;
                PolyR = 0;
                Prefs.PolyC = PolyC;
                Prefs.PolyF = PolyF;
                Prefs.PolyFd = PolyFd;
                Prefs.PolyS = PolyS;
                Prefs.PolyR = PolyR;
                Prefs.Werkv = true;
                Prefs.WerkvP = true;
                Prefs.Mpalv = false;
                Prefs.Tpalv = false;
                Prefs.SCpalv = false;
                Prefs.Lpalv = false;
                Prefs.Bopalv = false;
                Prefs.Mpalx = 0;
                Prefs.Mpaly = 0;
                Prefs.Tpalx = 0;
                Prefs.Tpaly = 0;
                Prefs.SCpalx = 0;
                Prefs.SCpaly = 0;
                Prefs.SCpalw = 100;
                Prefs.SCpalh = 200;
                Prefs.Sepalx = 0;
                Prefs.Sepaly = 0;
                Prefs.Bopalx = 0;
                Prefs.Bopaly = 0;
                Prefs.Lpalx = 0;
                Prefs.Lpaly = 0;
                Prefs.PSize = 40;
                Prefs.SaveAtQ = true;
                Prefs.FramesShown = true;
                Prefs.GridShown = false;
                Prefs.MarginsShown = true;
                Prefs.GuidesShown = true;
                Prefs.BaseShown = true;
                Prefs.ClipMargin = true;
                Prefs.PagesSbS = true;
                Prefs.RecentDocs.clear();
                Prefs.RecentDCount = 5;
                Prefs.RandFarbig = false;
                Prefs.AutoLine = 20;
                Prefs.PageFormat = 4;
                Prefs.Ausrichtung = 0;
                Prefs.PageBreite = 595;
                Prefs.PageHoehe = 842;
                Prefs.RandOben = 9;
                Prefs.RandUnten = 40;
                Prefs.RandLinks = 9;
                Prefs.RandRechts = 9;
                Prefs.DoppelSeiten = false;
                Prefs.ErsteLinks = false;
                Prefs.ScaleType = true;
                Prefs.AspectRatio = true;
                Prefs.MinWordLen = 3;
                Prefs.HyCount = 2;
                Prefs.Language = "";
                Prefs.Automatic = true;
                Prefs.AutoCheck = false;
                Prefs.PDFTransparency = false;
                Prefs.AutoSave = false;
                Prefs.AutoSaveTime = 600000;
                Prefs.DisScale = 1.0;
                Prefs.DocDir = QDir::homeDirPath();
                Prefs.ProfileDir = "";
                Prefs.ScriptDir = "";
                Prefs.CustomColorSets.clear();
                Prefs.PrPr_Mode = false;
                Prefs.PrPr_AlphaText = false;
                Prefs.PrPr_AlphaGraphics = false;
                Prefs.PrPr_Transparency = false;
                Prefs.PrPr_C = true;
                Prefs.PrPr_M = true;
                Prefs.PrPr_Y = true;
                Prefs.PrPr_K = true;
                Prefs.gimp_exe = "gimp";
                Prefs.gs_antiGraph = true;
                Prefs.gs_antiText = true;
                Prefs.gs_exe = "gs";
                Prefs.BaseGrid = 14.4;
                Prefs.BaseOffs = 0.0;
                PDef.Pname = "";
                PDef.Dname = "";
                PDef.Command = "";
                PrinterUsed = false;
                resize(610, 600);
                QVBox* vb = new QVBox( this );
                vb->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
                wsp = new QWorkspace( vb );
                setCentralWidget( vb );
                connect(wsp, SIGNAL(windowActivated(QWidget *)), this, SLOT(newActWin(QWidget *)));
                Tpal = new Tree(this, 0);
                Mpal = new Mpalette(this, &Prefs);
                Mpal->Cpal->SetColors(Prefs.DColors);
                Npal = new NodePalette(this);
                Lpal = new LayerPalette(this);
                ScBook = new Biblio(this, &Prefs);
                Sepal = new SeitenPal(this);
                BookPal = new BookPalette(this);
                CMSavail = false;
                keyrep = false;
                Prefs.DCMSset.DefaultMonitorProfile = "";
                Prefs.DCMSset.DefaultPrinterProfile = "";
                Prefs.DCMSset.DefaultInputProfile = "";
                Prefs.DCMSset.DefaultInputProfile2 = "";
                Prefs.DCMSset.CMSinUse = false;
                Prefs.DCMSset.SoftProofOn = false;
                Prefs.DCMSset.GamutCheck = false;
                Prefs.DCMSset.BlackPoint = true;
                Prefs.DCMSset.DefaultIntentMonitor = 1;
                Prefs.DCMSset.DefaultIntentMonitor2 = 1;
                Prefs.DCMSset.DefaultIntentPrinter = 0;
                Prefs.GFontSub.clear();
                SetKeyEntry(56, tr("Smart Hyphen"), 0, CTRL+Key_Minus);
                SetKeyEntry(57, tr("Align Left"), 0, CTRL+Key_L);
                SetKeyEntry(58, tr("Align Right"), 0, CTRL+Key_R);
                SetKeyEntry(59, tr("Align Center"), 0, CTRL+Key_E);
                SetKeyEntry(60, tr("Insert Page Number"), 0, CTRL+Key_NumberSign);
                SetKeyEntry(61, tr("Attach Text to Path"), PfadT, 0);
                SetKeyEntry(62, tr("Show Layers"), viewLpal, 0);
                SetKeyEntry(63, tr("Javascripts..."), jman, 0);
                SetKeyEntry(64, tr("Undo"), edUndo, CTRL+Key_Z);
                SetKeyEntry(65, tr("Show Page Palette"), viewSepal, 0);
                SetKeyEntry(66, tr("Lock/Unlock"), LockOb, CTRL+Key_H);
                SetKeyEntry(67, tr("Non Breaking Space"), 0, CTRL+Key_Space);
                splash->setStatus( tr("Reading Preferences"));
                ReadPrefs();
                if (Prefs.DefFont == "")
                        Prefs.DefFont = it.currentKey();
                splash->setStatus( tr("Getting ICC-Profiles"));
                GetCMSProfiles();
                splash->setStatus( tr("Init Hyphenator"));
                InitHyphenator();
                Mpal->Cpal->UseTrans(Prefs.PDFTransparency);
                Mpal->Fonts->RebuildList(&Prefs);
                Mpal->fillLangCombo(Sprachen);
                DocDir = Prefs.DocDir;
                splash->setStatus( tr(""));
                splash->setStatus( tr("Setting up Shortcuts"));
                SetShortCut();
                if (CMSavail)
                {
                        hymen->insertItem( tr("Color Management..."), this , SLOT(SetCMSPrefs()));
                        ProfilesL::Iterator ip;
                        if ((Prefs.DCMSset.DefaultInputProfile == "") || (!InputProfiles.contains(Prefs.DCMSset.DefaultInputProfile)))
                        {
                                ip = InputProfiles.begin();
                                Prefs.DCMSset.DefaultInputProfile = ip.key();
                        }
                        if ((Prefs.DCMSset.DefaultInputProfile2 == "") || (!InputProfiles.contains(Prefs.DCMSset.DefaultInputProfile2)))
                        {
                                ip = InputProfiles.begin();
                                Prefs.DCMSset.DefaultInputProfile2 = ip.key();
                        }
                        if ((Prefs.DCMSset.DefaultMonitorProfile == "") || (!MonitorProfiles.contains(Prefs.DCMSset.DefaultMonitorProfile)))
                        {
                                ip = MonitorProfiles.begin();
                                Prefs.DCMSset.DefaultMonitorProfile = ip.key();
                        }
                        if ((Prefs.DCMSset.DefaultPrinterProfile == "") || (!PrinterProfiles.contains(Prefs.DCMSset.DefaultPrinterProfile)))
                        {
                                ip = PrinterProfiles.begin();
                                Prefs.DCMSset.DefaultPrinterProfile = ip.key();
                        }
#ifdef HAVE_CMS
                        SoftProofing = Prefs.DCMSset.SoftProofOn;
                        CMSuse = false;
                        IntentPrinter = Prefs.DCMSset.DefaultIntentPrinter;
                        IntentMonitor = Prefs.DCMSset.DefaultIntentMonitor;
#endif

                }
                splash->setStatus( tr("Reading Scrapbook"));
                QString SCf = PrefsPfad+"/scrap.scs";
                QFileInfo SCfi = QFileInfo(SCf);
                if (SCfi.exists())
                        ScBook->BibWin->ReadContents(SCf);
                ScBook->ScFilename = SCf;
                ScBook->AdjustMenu();
                HaveGS = system(Prefs.gs_exe+" -h > /dev/null 2>&1");
                HavePngAlpha = system(Prefs.gs_exe+" -sDEVICE=pngalpha -c quit > /dev/null 2>&1");
                splash->setStatus( tr("Initializing Plugins"));
                InitPlugs(splash);
                ClipB = QApplication::clipboard();
                PalettesStat[0] = false;
                GuidesStat[0] = false;
                connect(WerkTools, SIGNAL(NewMode(int)), this, SLOT(ModeFromTB(int)));
                connect(WerkTools, SIGNAL(Schliessen()), this, SLOT(ToggleTools()));
                connect(WerkToolsP, SIGNAL(NewMode(int)), this, SLOT(ModeFromTB(int)));
                connect(WerkToolsP, SIGNAL(Schliessen()), this, SLOT(TogglePDFTools()));
                connect(Mpal, SIGNAL(DocChanged()), this, SLOT(slotDocCh()));
                connect(Mpal, SIGNAL(NewAbStyle(int)), this, SLOT(setNewAbStyle(int)));
                connect(Mpal, SIGNAL(BackHome()), this, SLOT(Aktiv()));
                connect(Mpal, SIGNAL(Stellung(int)), this, SLOT(setItemHoch(int)));
                connect(Mpal, SIGNAL(Schliessen()), this, SLOT(ToggleMpal()));
                connect(Mpal, SIGNAL(EditCL()), this, SLOT(ToggleFrameEdit()));
                connect(Mpal, SIGNAL(NewTF(QString)), this, SLOT(SetNewFont(QString)));
                connect(Mpal, SIGNAL(UpdtGui(int)), this, SLOT(HaveNewSel(int)));
                connect(Mpal->Cpal, SIGNAL(NewPen(QString)), this, SLOT(setPenFarbe(QString)));
                connect(Mpal->Cpal, SIGNAL(NewBrush(QString)), this, SLOT(setBrushFarbe(QString)));
                connect(Mpal->Cpal, SIGNAL(NewPenShade(int)), this, SLOT(setPenShade(int)));
                connect(Mpal->Cpal, SIGNAL(NewBrushShade(int)), this, SLOT(setBrushShade(int)));
                connect(Mpal->Cpal, SIGNAL(NewTrans(double)), this, SLOT(SetTranspar(double)));
                connect(Mpal->Cpal, SIGNAL(NewTransS(double)), this, SLOT(SetTransparS(double)));
                connect(Mpal->Cpal, SIGNAL(NewGradient(int, QString, int, QString, int)), this, SLOT(setGradFill(int, QString, int, QString, int)));
                connect(Mpal->Cpal, SIGNAL(QueryItem()), this, SLOT(GetBrushPen()));
                connect(Tpal, SIGNAL(Schliessen()), this, SLOT(ToggleTpal()));
                connect(Tpal, SIGNAL(SelectElement(int, int)), this, SLOT(SelectFromOutl(int, int)));
                connect(Tpal, SIGNAL(SelectSeite(int)), this, SLOT(SelectFromOutlS(int)));
                connect(Mpal->Spal, SIGNAL(NewStyle(int)), this, SLOT(setNewAbStyle(int)));
                connect(Mpal, SIGNAL(EditLSt()), this, SLOT(slotEditLineStyles()));
                connect(Npal, SIGNAL(Schliessen()), this, SLOT(NoFrameEdit()));
                connect(Lpal, SIGNAL(LayerActivated(int)), this, SLOT(changeLayer(int)));
                connect(Lpal, SIGNAL(LayerRemoved(int, bool)), this, SLOT(LayerRemove(int, bool)));
                connect(Lpal, SIGNAL(LayerChanged()), this, SLOT(showLayer()));
                connect(Lpal, SIGNAL(Schliessen()), this, SLOT(ToggleLpal()));
                connect(Sepal, SIGNAL(Schliessen()), this, SLOT(ToggleSepal()));
                connect(ScBook, SIGNAL(Schliessen()), this, SLOT(ToggleBpal()));
                connect(Sepal, SIGNAL(EditTemp(QString)), this, SLOT(ManageTemp(QString)));
                connect(Sepal->PageView, SIGNAL(UseTemp(QString, int)), this, SLOT(Apply_Temp(QString, int)));
                connect(Sepal->PageView, SIGNAL(NewPage(int, QString)), this, SLOT(slotNewPageP(int, QString)));
                connect(Sepal->Trash, SIGNAL(DelPage(int)), this, SLOT(DeletePage2(int)));
                connect(Sepal, SIGNAL(GotoSeite(int)), this, SLOT(SelectFromOutlS(int)));
                connect(BookPal->BView, SIGNAL(MarkMoved()), this, SLOT(StoreBookmarks()));
                connect(BookPal->BView, SIGNAL(ChangeBMNr(int, int, int)), this, SLOT(ChBookmarks(int, int, int)));
                connect(BookPal, SIGNAL(Schliessen()), this, SLOT(ToggleBookpal()));
                connect(recentMenu, SIGNAL(activated(int)), this, SLOT(LoadRecent(int)));
                connect(ColorMenC, SIGNAL(activated(int)), this, SLOT(setItemFarbe(int)));
                connect(ShadeMenu, SIGNAL(activated(int)), this, SLOT(setItemShade(int)));
                connect(FontMenu, SIGNAL(activated(int)), this, SLOT(setItemFont(int)));
                connect(SizeTMenu, SIGNAL(activated(int)), this, SLOT(setItemFSize(int)));
                connect(TypeStyleMenu, SIGNAL(activated(int)), this, SLOT(setItemTypeStyle(int)));
                connect(AliMenu, SIGNAL(activated(int)), this, SLOT(setItemTextAli(int)));
                connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
                connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
                connect(this, SIGNAL(TextISize(int)), Mpal, SLOT(setSize(int)));
                connect(this, SIGNAL(TextUSval(double)), Mpal, SLOT(setExtra(double)));
                connect(this, SIGNAL(TextStil(int)), Mpal, SLOT(setStil(int)));
                connect(this, SIGNAL(TextScale(int)), Mpal, SLOT(setTScale(int)));
                connect(this, SIGNAL(TextFarben(QString, QString, int, int)), Mpal, SLOT(setActFarben(QString, QString, int, int)));
                connect(ClipB, SIGNAL(dataChanged()), this, SLOT(ClipChange()));
                typedef void (*HandlerType)(int);
                HandlerType handler     = 0;
                handler = ScribusApp::defaultCrashHandler;
                if (!handler)
                        handler = SIG_DFL;
                sigset_t mask;
                sigemptyset(&mask);
#ifdef SIGSEGV
                signal (SIGSEGV, handler);
                sigaddset(&mask, SIGSEGV);
#endif
#ifdef SIGFPE
                signal (SIGFPE, handler);
                sigaddset(&mask, SIGFPE);
#endif
#ifdef SIGILL
                signal (SIGILL, handler);
                sigaddset(&mask, SIGILL);
#endif
#ifdef SIGABRT
                signal (SIGABRT, handler);
                sigaddset(&mask, SIGABRT);
#endif
                sigprocmask(SIG_UNBLOCK, &mask, 0);
        }
}

void ScribusApp::initMenuBar()
{
        int MenID;
        QFont tmp;
        recentMenu = new QPopupMenu();
        RecentDocs.clear();
        fileMenu=new QPopupMenu();
        fid12 = fileMenu->insertItem(loadIcon("DateiNeu16.png"), tr("New"), this, SLOT(slotFileNew()), CTRL+Key_N);
        fid13 = fileMenu->insertItem(loadIcon("DateiOpen16.png"), tr("Open..."), this, SLOT(slotDocOpen()), CTRL+Key_O);
        fid14 = fileMenu->insertItem( tr("Recent Documents"), recentMenu);
        SetKeyEntry(0, tr("New"), fid12, CTRL+Key_N);
        SetKeyEntry(1, tr("Open..."), fid13, CTRL+Key_O);
        fileMenu->insertSeparator();
        fid1 = fileMenu->insertItem(loadIcon("DateiClos16.png"), tr("Close"), this, SLOT(slotFileClose()), CTRL+Key_W);
        SetKeyEntry(2, tr("Close"), fid1, CTRL+Key_W);
        fileMenu->setItemEnabled(fid1, 0);
        MenuItemsFile.append(fid1);
        fid4 = fileMenu->insertItem(loadIcon("DateiSave16.png"), tr("Save"), this, SLOT(slotFileSave()), CTRL+Key_S);
        SetKeyEntry(3, tr("Save"), fid4, CTRL+Key_S);
        fileMenu->setItemEnabled(fid4, 0);
        fid5 = fileMenu->insertItem( tr("Save as..."), this, SLOT(slotFileSaveAs()));
        SetKeyEntry(4, tr("Save as..."), fid5, 0);
        fileMenu->setItemEnabled(fid5, 0);
        fid52 = fileMenu->insertItem( tr("Revert to Saved"), this, SLOT(slotFileRevert()));
        fileMenu->setItemEnabled(fid52, 0);
        fid51 = fileMenu->insertItem( tr("Collect for Output..."), this, SLOT(Collect()));
        fileMenu->setItemEnabled(fid51, 0);
        MenuItemsFile.append(fid51);
        fileMenu->insertSeparator();
        importMenu = new QPopupMenu();
        fid2 = importMenu->insertItem( tr("Get Text/Picture..."), this, SLOT(slotFileOpen()));
        importMenu->setItemEnabled(fid2, 0);
        fid2aa = importMenu->insertItem( tr("Append Text..."), this, SLOT(slotFileAppend()));
        importMenu->setItemEnabled(fid2aa, 0);
        fid2a = importMenu->insertItem( tr("Insert Page..."), this, SLOT(slotDocMerge()));
        importMenu->setItemEnabled(fid2a, 0);
        fileMenu->insertItem( tr("Import..."), importMenu);
        exportMenu = new QPopupMenu();
        fid3 = exportMenu->insertItem( tr("Save Text..."), this, SLOT(SaveText()));
        exportMenu->setItemEnabled(fid3, 0);
        fid8 = exportMenu->insertItem( tr("Save Page as EPS..."), this, SLOT(SaveAsEps()));
        exportMenu->setItemEnabled(fid8, 0);
        fid10 = exportMenu->insertItem( tr("Save as PDF..."), this, SLOT(SaveAsPDF()));
        exportMenu->setItemEnabled(fid10, 0);
        fid11 = fileMenu->insertItem( tr("Export..."), exportMenu);
        fileMenu->setItemEnabled(fid11, 0);
        fileMenu->insertSeparator();
        fid6 = fileMenu->insertItem( tr("Document Info..."), this, SLOT(InfoDoc()), CTRL+Key_I);
        fileMenu->setItemEnabled(fid6, 0);
        MenuItemsFile.append(fid6);
        SetKeyEntry(5, tr("Document Info..."), fid6, CTRL+Key_I);
        fid7 = fileMenu->insertItem( tr("Document Setup..."), this, SLOT(SetupDoc()));
        fileMenu->setItemEnabled(fid7, 0);
        MenuItemsFile.append(fid7);
        SetKeyEntry(6, tr("Document Setup..."), fid7, 0);
        fid9 = fileMenu->insertItem(loadIcon("DateiPrint16.png"), tr("Print..."), this, SLOT(slotFilePrint()), CTRL+Key_P);
        fileMenu->setItemEnabled(fid9, 0);
        MenuItemsFile.append(fid9);
        SetKeyEntry(7, tr("Print..."), fid9, CTRL+Key_P);
        fileMenu->insertSeparator();
        MenID = fileMenu->insertItem(loadIcon("exit.png"), tr("Quit"), this, SLOT(slotFileQuit()), CTRL+Key_Q);
        SetKeyEntry(8, tr("Quit"), MenID, CTRL+Key_Q);
        editMenu = new QPopupMenu();
        edUndo = editMenu->insertItem( tr("Undo"), this, SLOT(UnDoAction()), CTRL+Key_Z);
        editMenu->insertSeparator();
        edid1 = editMenu->insertItem(loadIcon("editcut.png"), tr("Cut"), this , SLOT(slotEditCut()), CTRL+Key_X);
        edid2 = editMenu->insertItem(loadIcon("editcopy.png"), tr("Copy"), this , SLOT(slotEditCopy()), CTRL+Key_C);
        edid3 = editMenu->insertItem(loadIcon("editpaste.png"), tr("Paste"), this , SLOT(slotEditPaste()), CTRL+Key_V);
        edid4 = editMenu->insertItem(loadIcon("editdelete.png"), tr("Clear"), this, SLOT(DeleteText()));
        edid5 = editMenu->insertItem( tr("Select all"), this, SLOT(SelectAll()), CTRL+Key_A);
        SetKeyEntry(9, tr("Cut"), edid1, CTRL+Key_X);
        SetKeyEntry(10, tr("Copy"), edid2, CTRL+Key_C);
        SetKeyEntry(11, tr("Paste"), edid3, CTRL+Key_V);
        SetKeyEntry(12, tr("Clear"), edid4, 0);
        SetKeyEntry(13, tr("Select all"), edid5, CTRL+Key_A);
        editMenu->insertSeparator();
        Sear = editMenu->insertItem( tr("Search/Replace..."), this, SLOT(SearchText()));
        editMenu->insertSeparator();
        MenID = editMenu->insertItem( tr("Colors..."), this , SLOT(slotEditColors()));
        SetKeyEntry(14, tr("Colors..."), MenID, 0);
        edid6 = editMenu->insertItem( tr("Paragraph Styles..."), this , SLOT(slotEditStyles()));
        edid6a = editMenu->insertItem( tr("Line Styles..."), this , SLOT(slotEditLineStyles()));
        SetKeyEntry(15, tr("Styles..."), edid6, 0);
        tman = editMenu->insertItem( tr("Templates..."), this, SLOT(ManageTemp()));
        SetKeyEntry(16, tr("Templates..."), tman, 0);
        jman = editMenu->insertItem( tr("Javascripts..."), this, SLOT(ManageJava()));
        hymen = new QPopupMenu();
        MenID = hymen->insertItem( tr("General..."), this , SLOT(slotPrefsOrg()));
        SetKeyEntry(18, tr("Preferences..."), MenID, 0);
        MenID = hymen->insertItem( tr("Fonts..."), this , SLOT(slotFontOrg()));
        SetKeyEntry(17, tr("Fonts..."), MenID, 0);
        hymen->insertItem( tr("Hyphenator..."), this, SLOT(configHyphenator()));
        editMenu->insertItem( tr("Preferences"), hymen);
        editMenu->setItemEnabled(edUndo, 0);
        editMenu->setItemEnabled(edid1, 0);
        editMenu->setItemEnabled(edid2, 0);
        editMenu->setItemEnabled(edid3, 0);
        editMenu->setItemEnabled(edid4, 0);
        editMenu->setItemEnabled(edid5, 0);
        editMenu->setItemEnabled(edid6, 0);
        editMenu->setItemEnabled(edid6a, 0);
        editMenu->setItemEnabled(Sear, 0);
        editMenu->setItemEnabled(tman, 0);
        editMenu->setItemEnabled(jman, 0);
        StilMenu = new QPopupMenu();
        ObjMenu = new QPopupMenu();
        SetKeyEntry(19, tr("Select New Font"), 0, 0);
        ODup = ObjMenu->insertItem( tr("Duplicate"), this, SLOT(ObjektDup()), CTRL+Key_D);
        SetKeyEntry(20, tr("Duplicate"), ODup, CTRL+Key_D);
        OMDup = ObjMenu->insertItem( tr("Multiple Duplicate"), this, SLOT(ObjektDupM()));
        SetKeyEntry(21, tr("Multiple Duplicate"), OMDup, 0);
        Loesch = ObjMenu->insertItem( tr("Delete"), this, SLOT(DeleteObjekt()), CTRL+Key_K);
        SetKeyEntry(22, tr("Delete"), Loesch, CTRL+Key_K);
        ObjMenu->insertSeparator();
        Gr = ObjMenu->insertItem( tr("Group"), this, SLOT(GroupObj()), CTRL+Key_G);
        SetKeyEntry(23, tr("Group"), Gr, CTRL+Key_G);
        UnGr = ObjMenu->insertItem( tr("Un-group"), this, SLOT(UnGroupObj()),CTRL+Key_U);
        SetKeyEntry(24, tr("Un-group"), UnGr, CTRL+Key_U);
        LockOb = ObjMenu->insertItem( tr("Lock"), this, SLOT(ToggleObjLock()), CTRL+Key_H);
        ObjMenu->insertSeparator();
        OBack = ObjMenu->insertItem( tr("Send to Back"), this, SLOT(Objekt2Back()));
        SetKeyEntry(25, tr("Send to Back"), OBack, 0);
        OFront = ObjMenu->insertItem( tr("Bring to Front"), this, SLOT(Objekt2Front()));
        SetKeyEntry(26, tr("Bring to Front"), OFront, 0);
        OLower = ObjMenu->insertItem( tr("Lower"), this, SLOT(ObjektLower()));
        SetKeyEntry(27, tr("Lower"), OLower, 0);
        ORaise = ObjMenu->insertItem( tr("Raise"), this, SLOT(ObjektRaise()));
        SetKeyEntry(28, tr("Raise"), ORaise, 0);
        DistM = ObjMenu->insertItem( tr("Distribute/Align..."), this, SLOT(ObjektAlign()));
        SetKeyEntry(29, tr("Distribute/Align..."), DistM, 0);
        ObjMenu->insertSeparator();
        ShapeMenu = new QPopupMenu();
        SCustom = new Autoforms(0);
        ShapeMenu->insertItem(SCustom);
        connect(SCustom, SIGNAL(FormSel(int, int, double *)), this, SLOT(MakeFrame(int, int, double *)));
        ShapeEdit = ShapeMenu->insertItem( tr("Edit Frame"), this, SLOT(ToggleFrameEdit()));
        ShapeM = ObjMenu->insertItem( tr("Shape"), ShapeMenu);
        PfadT = ObjMenu->insertItem( tr("Attach Text to Path"), this, SLOT(Pfadtext()));
        PfadDT = ObjMenu->insertItem( tr("Detach Text from Path"), this, SLOT(noPfadtext()));
        PfadV = ObjMenu->insertItem( tr("Combine Polygons"), this, SLOT(UniteOb()));
        PfadS = ObjMenu->insertItem( tr("Split Polygons"), this, SLOT(SplitUniteOb()));
        PfadTP = ObjMenu->insertItem( tr("Convert to Outlines"), this, SLOT(TraceText()));
        ObjMenu->setItemEnabled(ShapeM, 0);
        ObjMenu->setItemEnabled(DistM, 0);
        ObjMenu->setItemEnabled(Gr, 0);
        ObjMenu->setItemEnabled(UnGr, 0);
        ObjMenu->setItemEnabled(PfadT, 0);
        ObjMenu->setItemEnabled(PfadDT, 0);
        ObjMenu->setItemEnabled(PfadV, 0);
        ObjMenu->setItemEnabled(PfadS, 0);
        ObjMenu->setItemEnabled(LockOb, 0);
        ObjMenu->setItemEnabled(PfadTP, 0);
        pageMenu = new QPopupMenu();
        MenID = pageMenu->insertItem( tr("Insert..."), this, SLOT(slotNewPageM()));
        SetKeyEntry(30, tr("Insert..."), MenID, 0);
        pgmd = pageMenu->insertItem( tr("Delete..."), this, SLOT(DeletePage()));
        SetKeyEntry(31, tr("Delete..."), pgmd, 0);
        MenID = pageMenu->insertItem( tr("Copy")+"...", this, SLOT(CopyPage()));
        SetKeyEntry(61, tr("Copy")+"...", MenID, 0);
        pgmv = pageMenu->insertItem( tr("Move..."), this, SLOT(MovePage()));
        SetKeyEntry(32, tr("Move..."), pgmv, 0);
        MenID = pageMenu->insertItem( tr("Apply Template..."), this, SLOT(ApplyTemp()));
        SetKeyEntry(33, tr("Apply Template..."), MenID, 0);
        MenID = pageMenu->insertItem( tr("Manage Guides..."), this, SLOT(ManageGuides()));
        SetKeyEntry(49, tr("Manage Guides..."), MenID, 0);
        pageMenu->setItemEnabled(pgmd, 0);
        pageMenu->setItemEnabled(pgmv, 0);
        viewMenu=new QPopupMenu();
        MenID = viewMenu->insertItem( tr("Fit in Window"), this, SLOT(slotZoomFit()), CTRL+Key_0);
        SetKeyEntry(34, tr("Fit in Window"), MenID, CTRL+Key_0);
        MenID = viewMenu->insertItem("50%", this, SLOT(slotZoom50()));
        SetKeyEntry(35, tr("50%"), MenID, 0);
        MenID = viewMenu->insertItem("75%", this, SLOT(slotZoom75()));
        SetKeyEntry(36, tr("75%"), MenID, 0);
        MenID = viewMenu->insertItem( tr("Actual Size"), this, SLOT(slotZoom100()), CTRL+Key_1);
        SetKeyEntry(37, tr("Actual Size"), MenID, CTRL+Key_1);
        MenID = viewMenu->insertItem("200%", this, SLOT(slotZoom200()));
        SetKeyEntry(38, tr("200%"), MenID, 0);
        MenID = viewMenu->insertItem( tr("Thumbnails"), this, SLOT(slotZoom20()));
        SetKeyEntry(39, tr("Thumbnails"), MenID, 0);
        viewMenu->insertSeparator();
        Markers = viewMenu->insertItem( tr("Hide Margins"), this, SLOT(ToggleMarks()));
        SetKeyEntry(40, tr("Hide Margins"), Markers, 0);
        FrameDr = viewMenu->insertItem( tr("Hide Frames"), this, SLOT(ToggleFrames()));
        SetKeyEntry(41, tr("Hide Frames"), FrameDr, 0);
        Bilder = viewMenu->insertItem( tr("Hide Images"), this, SLOT(TogglePics()));
        SetKeyEntry(42, tr("Hide Images"), Bilder, 0);
        Ras = viewMenu->insertItem( tr("Show Grid"), this, SLOT(ToggleRaster()));
        SetKeyEntry(43, tr("Show Grid"), Ras, 0);
        uRas = viewMenu->insertItem( tr("Snap to Grid"), this, SLOT(ToggleURaster()));
        SetKeyEntry(44, tr("Snap to Grid"), uRas, 0);
        Guide = viewMenu->insertItem( tr("Hide Guides"), this, SLOT(ToggleGuides()));
        uGuide = viewMenu->insertItem( tr("Snap to Guides"), this, SLOT(ToggleUGuides()));
        Base = viewMenu->insertItem( tr("Show Baseline Grid"), this, SLOT(ToggleBase()));
        toolMenu=new QPopupMenu();
        toolbarMenu = new QPopupMenu();
        toolbarMenuTools = toolbarMenu->insertItem( tr("Tools"), this, SLOT(ToggleTools()));
        SetKeyEntry(45, tr("Tools"), toolbarMenuTools, 0);
        toolbarMenuPDFTools = toolbarMenu->insertItem( tr("PDF-Tools"), this, SLOT(TogglePDFTools()));
        viewToolbars = toolMenu->insertItem ( tr("Tool&bars"), toolbarMenu);
        viewMpal = toolMenu->insertItem( tr("Properties"), this, SLOT(ToggleMpal()));
        SetKeyEntry(46, tr("Properties"), viewMpal, 0);
        viewTpal = toolMenu->insertItem( tr("Outline"), this, SLOT(ToggleTpal()));
        SetKeyEntry(47, tr("Outline"), viewTpal, 0);
        viewBpal = toolMenu->insertItem( tr("Scrapbook"), this, SLOT(ToggleBpal()));
        SetKeyEntry(48, tr("Scrapbook"), viewBpal, 0);
        viewLpal = toolMenu->insertItem( tr("Layers"), this, SLOT(ToggleLpal()));
        viewSepal = toolMenu->insertItem( tr("Page Palette"), this, SLOT(ToggleSepal()));
        viewBopal = toolMenu->insertItem( tr("Bookmarks"), this, SLOT(ToggleBookpal()));
        extraMenu=new QPopupMenu();
        MenID = extraMenu->insertItem( tr("Manage Pictures"), this, SLOT(StatusPic()));
        SetKeyEntry(51, tr("Manage Pictures"), MenID, 0);
        hyph = extraMenu->insertItem( tr("Hyphenate Text"), this, SLOT(doHyphenate()));
        extraMenu->setItemEnabled(hyph, 0);
        SetKeyEntry(50, tr("Hyphenate Text"), hyph, 0);
        windowsMenu = new QPopupMenu();
        windowsMenu->setCheckable( true );
        connect(windowsMenu, SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
        helpMenu=new QPopupMenu();
        MenID = helpMenu->insertItem( tr("About Scribus"), this, SLOT(slotHelpAbout()));
        SetKeyEntry(52, tr("About Scribus"), MenID, 0);
        MenID = helpMenu->insertItem( tr("About Qt"), this, SLOT(slotHelpAboutQt()));
        SetKeyEntry(53, tr("About Qt"), MenID, 0);
        helpMenu->insertSeparator();
        MenID = helpMenu->insertItem( tr("Online-Help..."), this, SLOT(slotOnlineHelp()));
        SetKeyEntry(54, tr("Online-Help..."), MenID, 0);
        tip = helpMenu->insertItem( tr("Tool-Tips"), this, SLOT(ToggleTips()));
        SetKeyEntry(55, tr("Tool-Tips"), tip, 0);
        tipsOn = true;
        helpMenu->setItemChecked(tip, tipsOn);
        //      editMenu->insertItem( tr("Test"), this, SLOT(slotTest()));
        //      helpMenu->insertItem( tr("Test2"), this, SLOT(slotTest2()));
        menuBar()->insertItem( tr("&File"), fileMenu);
        menuBar()->insertItem( tr("&Edit"), editMenu);
        Stm = menuBar()->insertItem( tr("&Style"), StilMenu);
        Obm = menuBar()->insertItem( tr("&Item"), ObjMenu);
        pgmm = menuBar()->insertItem( tr("&Page"), pageMenu);
        menuBar()->setItemEnabled(Stm, 0);
        menuBar()->setItemEnabled(Obm, 0);
        menuBar()->setItemEnabled(pgmm, 0);
        ViMen = menuBar()->insertItem( tr("&View"), viewMenu);
        menuBar()->setItemEnabled(ViMen, 0);
        menuBar()->insertItem( tr("&Tools"), toolMenu);
        exmn = menuBar()->insertItem( tr("E&xtras"), extraMenu);
        menuBar()->setItemEnabled(exmn, 0);
        WinMen = menuBar()->insertItem( tr("&Windows"), windowsMenu );
        menuBar()->setItemEnabled(WinMen, 0);
        menuBar()->insertSeparator();
        menuBar()->insertItem( tr("&Help"), helpMenu);
        AliMenu = new QPopupMenu();
        AliMenu->insertItem( tr("Left"));
        AliMenu->insertItem( tr("Center"));
        AliMenu->insertItem( tr("Right"));
        AliMenu->insertItem( tr("Block"));
        AliMenu->insertItem( tr("Forced"));
        ColorMenu = new QPopupMenu();
        ColorMenC = new QComboBox(false);
        ColorMenC->setEditable(false);
        ColorMenu->insertItem(ColorMenC);
        SizeTMenu = new QPopupMenu();
        SizeTMenu->insertItem( tr("Other..."));
        char *ar_sizes[] = {" 7", " 9", "10", "12", "14", "18", "24", "36", "48", "60", "72"};
        size_t f_size = sizeof(ar_sizes) / sizeof(*ar_sizes);
        for (uint s = 0; s < f_size; ++s)
                SizeTMenu->insertItem(ar_sizes[s] + tr(" pt"));
        ShadeMenu = new QPopupMenu();
        ShadeMenu->insertItem( tr("Other..."));
        ShadeMenu->insertItem("0 %");
        ShadeMenu->insertItem("10 %");
        ShadeMenu->insertItem("20 %");
        ShadeMenu->insertItem("30 %");
        ShadeMenu->insertItem("40 %");
        ShadeMenu->insertItem("50 %");
        ShadeMenu->insertItem("60 %");
        ShadeMenu->insertItem("70 %");
        ShadeMenu->insertItem("80 %");
        ShadeMenu->insertItem("90 %");
        ShadeMenu->insertItem("100 %");
        FontMenu = new QPopupMenu();
        TypeStyleMenu = new QPopupMenu();
        TypeStyleMenu->insertItem( tr("Normal"));
        tmp = qApp->font();
        tmp = qApp->font();
        tmp.setUnderline(true);
        TypeStyleMenu->insertItem(new FmItem( tr("Underline"), tmp));
        tmp = qApp->font();
        tmp.setStrikeOut(true);
        TypeStyleMenu->insertItem(new FmItem( tr("Strikethru"), tmp));
        TypeStyleMenu->insertItem( tr("Small Caps"));
        TypeStyleMenu->insertItem( tr("Superscript"));
        TypeStyleMenu->insertItem( tr("Subscript"));
        TypeStyleMenu->insertItem( tr("Outlined"));
}

void ScribusApp::initStatusBar()
{
        FMess = new QLabel(statusBar(), "ft");
        FMess->setText("           ");
        statusBar()->addWidget(FMess, 3, true);
        FProg = new QProgressBar(statusBar(), "p");
        FProg->setCenterIndicator(true);
        FProg->setFixedWidth( 100 );
        statusBar()->addWidget(FProg, 0, true);
        FProg->reset();
        XMess = new QLabel(statusBar(), "xt");
        XMess->setText( tr("X-Pos:"));
        statusBar()->addWidget(XMess, 0, true);
        XDat = new QLabel(statusBar(), "dt");
        statusBar()->addWidget(XDat, 1, true);
        XDat->setText("         ");
        YMess = new QLabel(statusBar(), "yt");
        YMess->setText( tr("Y-Pos:"));
        statusBar()->addWidget(YMess, 0, true);
        YDat = new QLabel(statusBar(), "ydt");
        statusBar()->addWidget(YDat, 1, true);
        YDat->setText("         ");
}

void ScribusApp::ReportMP(double xp, double yp)
{
        QString tmp, tmp2;
        int multiplier, precision;
        double divisor;
        switch (doc->Einheit)
        {
        case 0:
                tmp2 = tr(" pt");
                multiplier = 100;
                divisor = 100.0;
                precision = 2;
                break;
        case 1:
                tmp2 = tr(" mm");
                multiplier = 1000;
                divisor = 1000.0;
                precision = 3;
                break;
        case 2:
                tmp2 = tr(" in");
                multiplier = 10000;
                divisor = 10000.0;
                precision = 4;
                break;
        case 3:
                tmp2 = tr(" p");
                multiplier = 100;
                divisor = 100.0;
                precision = 2;
                break;
        default:  // jjsa 21-03-2004 added default (complains for lint)
                tmp2 = tr(" pt");
                multiplier = 100;
                divisor = 100.0;
                precision = 2;
                break;
        }
        XDat->setText(tmp.setNum(qRound(xp*UmReFaktor * multiplier) / divisor, 'f', precision)+tmp2);
        YDat->setText(tmp.setNum(qRound(yp*UmReFaktor * multiplier) / divisor, 'f', precision)+tmp2);
}

void ScribusApp::SetKeyEntry(int Nr, QString text, int Men, int KeyC)
{
        Keys ke;
        ke.Name = text;
        ke.MenuID = Men;
        ke.KeyID = KeyC;
        Prefs.KeyActions.insert(Nr, ke);
}

void ScribusApp::DeleteSel(PageItem *b)
{
        Pti *it;
        int FirstSel = 0;
        bool first = false;
        for (it = b->Ptext.first(); it != 0; it = b->Ptext.next())
        {
                if (it->cselect)
                {
                        first = true;
                        b->Ptext.remove();
                        it = b->Ptext.prev();
                        if (it == 0)
                                it = b->Ptext.first();
                }
                if (!first)
                        FirstSel++;
        }
        if (b->Ptext.count() != 0)
        {
                if (b->Ptext.first()->cselect)
                {
                        b->Ptext.remove();
                        b->CPos = 0;
                }
                else
                        b->CPos = FirstSel;
        }
        else
                b->CPos = 0;
        b->HasSel = false;
        DisableTxEdit();
}

void ScribusApp::setTBvals(PageItem *b)
{
        if (b->Ptext.count() != 0)
        {
                int ChPos = QMIN(b->CPos, static_cast<int>(b->Ptext.count()-1));
                doc->CurrentStyle = b->Ptext.at(ChPos)->cstyle & 127;
                doc->CurrentABStil = b->Ptext.at(ChPos)->cab;
                setAbsValue(doc->CurrentABStil);
                Mpal->setAli(doc->CurrentABStil);
                doc->CurrFont = b->Ptext.at(ChPos)->cfont;
                doc->CurrFontSize = b->Ptext.at(ChPos)->csize;
                doc->CurrTextFill = b->Ptext.at(ChPos)->ccolor;
                doc->CurrTextFillSh = b->Ptext.at(ChPos)->cshade;
                doc->CurrTextStroke = b->Ptext.at(ChPos)->cstroke;
                doc->CurrTextStrokeSh = b->Ptext.at(ChPos)->cshade2;
                doc->CurrTextScale = b->Ptext.at(ChPos)->cscale;
                emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
                emit TextIFont(doc->CurrFont);
                emit TextISize(doc->CurrFontSize);
                emit TextUSval(b->Ptext.at(ChPos)->cextra);
                emit TextStil(doc->CurrentStyle);
                emit TextScale(doc->CurrTextScale);
        }
}

void ScribusApp::wheelEvent(QWheelEvent *w)
{
        if (HaveDoc)
        {
                if ((w->orientation() != Qt::Vertical) || ( w->state() & ShiftButton ))
                {
                        if (w->delta() < 0)
                                view->scrollBy(Prefs.Wheelval, 0);
                        else
                                view->scrollBy(-Prefs.Wheelval, 0);
                }
                else
                {
                        if (w->delta() < 0)
                                view->scrollBy(0, Prefs.Wheelval);
                        else
                                view->scrollBy(0, -Prefs.Wheelval);
                }
                w->accept();
        }
}

void ScribusApp::keyPressEvent(QKeyEvent *k)
{
        QWidgetList windows;
        QWidget* w = NULL;
        struct Pti *hg;
        int kk = k->key();
        int as = k->ascii();
        double altx, alty;
        QString uc = k->text();
        QString cr, Tcha, Twort;
        uint Tcoun;
        int len, pos, c;
        if (keyrep)
                return;
        keyrep = true;
        switch (k->state())
        {
        case ShiftButton:
                KeyMod = 0x00200000;
                break;
        case AltButton:
                KeyMod = 0x00800000;
                break;
        case ControlButton:
                KeyMod = 0x00400000;
                break;
        default:
                KeyMod = 0;
                break;
        }
        if (kk == Key_F10)
        {
                keyrep = false;
                ToggleAllPalettes();
                return;
        }
        if ((kk == Key_F11) && (HaveDoc))
        {
                keyrep = false;
                ToggleAllGuides();
                return;
        }
        ButtonState buttonState = k->state();
        if ((HaveDoc) && (!view->LE->hasFocus()) && (!view->PGS->PageCombo->hasFocus()))
        {
                if (doc->AppMode != 7)
                {
                        switch (kk)
                        {
                        case Key_Space:
                                keyrep = false;
                                if (doc->AppMode == 23)
                                        setAppMode(1);
                                else
                                {
                                        setAppMode(23);
                                        qApp->setOverrideCursor(QCursor(loadIcon("HandC.xpm")), true);
                                }
                                return;
                                break;
                        case Key_Prior:
                                view->scrollBy(0, -Prefs.Wheelval);
                                keyrep = false;
                                return;
                                break;
                        case Key_Next:
                                view->scrollBy(0, Prefs.Wheelval);
                                keyrep = false;
                                return;
                                break;
                        case Key_Tab:
                                keyrep = false;
                                windows = wsp->windowList();
                                if (windows.count() > 1)
                                {
                                        for (int i = 0; i < static_cast<int>(windows.count()); ++i)
                                        {
                                                if (wsp->activeWindow() == windows.at(i))
                                                {
                                                        if (i == static_cast<int>(windows.count()-1))
                                                                w = windows.at(0);
                                                        else
                                                                w = windows.at(i+1);
                                                        break;
                                                }
                                        }
                                        doc->OpenNodes = Tpal->buildReopenVals();
                                        if ( w )
                                                w->showNormal();
                                        newActWin(w);
                                }
                                return;
                                break;
                        }
                }
                if (doc->ActPage->SelItem.count() != 0)
                {
                        PageItem *b = doc->ActPage->SelItem.at(0);
                        switch (doc->AppMode)
                        {
                        case 1:
                                switch (kk)
                                {
                                case Key_Delete:
                                        if (!doc->EditClip)
                                        {
                                                if ((!b->Locked) && (!((b->isTableItem) && (b->isSingleSel))))
                                                        doc->ActPage->DeleteItem();
                                        }
                                        break;
                                case Key_Left:
                                        if (!k->isAutoRepeat())
                                        {
                                                doc->ActPage->storeUndoInf(b);
                                                doc->UnData.UnCode = 1;
                                                doc->UnDoValid = true;
                                                CanUndo();
                                        }
                                        if (!b->Locked)
                                        {
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->moveGroup(-10, 0);
                                                else if ( buttonState & ControlButton )
                                                        doc->ActPage->moveGroup(-0.1, 0);
                                                else
                                                        doc->ActPage->moveGroup(-1, 0);
                                        }
                                        break;
                                case Key_Right:
                                        if (!k->isAutoRepeat())
                                        {
                                                doc->ActPage->storeUndoInf(b);
                                                doc->UnData.UnCode = 1;
                                                doc->UnDoValid = true;
                                                CanUndo();
                                        }
                                        if (!b->Locked)
                                        {
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->moveGroup(10, 0);
                                                else if ( buttonState & ControlButton )
                                                        doc->ActPage->moveGroup(0.1, 0);
                                                else
                                                        doc->ActPage->moveGroup(1, 0);
                                        }
                                        break;
                                case Key_Up:
                                        if (!k->isAutoRepeat())
                                        {
                                                doc->ActPage->storeUndoInf(b);
                                                doc->UnData.UnCode = 1;
                                                doc->UnDoValid = true;
                                                CanUndo();
                                        }
                                        if (!b->Locked)
                                        {
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->moveGroup(0, -10);
                                                else if ( buttonState & ControlButton )
                                                        doc->ActPage->moveGroup(0, -0.1);
                                                else
                                                        doc->ActPage->moveGroup(0, -1);
                                        }
                                        break;
                                case Key_Down:
                                        if (!k->isAutoRepeat())
                                        {
                                                doc->ActPage->storeUndoInf(b);
                                                doc->UnData.UnCode = 1;
                                                doc->UnDoValid = true;
                                                CanUndo();
                                        }
                                        if (!b->Locked)
                                        {
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->moveGroup(0, 10);
                                                else if ( buttonState & ControlButton )
                                                        doc->ActPage->moveGroup(0, 0.1);
                                                else
                                                        doc->ActPage->moveGroup(0, 1);
                                        }
                                        break;
                                default:
                                        if (b->PType == 4)
                                        {
                                                if ((kk + KeyMod) == Prefs.KeyActions[59].KeyID)
                                                {
                                                        setNewAbStyle(1);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b);
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[58].KeyID)
                                                {
                                                        setNewAbStyle(2);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b);
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[57].KeyID)
                                                {
                                                        setNewAbStyle(0);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b);
                                                }
                                        }
                                        break;
                                }
                                slotDocCh();
                                break;
                        case 7:
                                int oldPos = b->CPos; // 15-mar-2004 jjsa for cursor movement with Shift + Arrow key
                                doc->ActPage->oldCp = b->CPos;
                                if (b->PType == 4)
                                {
                                        doc->ActPage->slotDoCurs(false);
                                        switch (kk)
                                        {
                                        case Key_Prior:
                                        case Key_Next:
                                        case Key_End:
                                        case Key_Home:
                                        case Key_Right:
                                        case Key_Left:
                                        case Key_Up:
                                        case Key_Down:
                                                if ( (buttonState & ShiftButton) == 0 )
                                                        doc->ActPage->deselectAll(b);
                                        }
                                        if (UniCinp)
                                        {
                                                int conv = 0;
                                                bool ok = false;
                                                UniCinS += uc;
                                                conv = UniCinS.toInt(&ok, 16);
                                                if (!ok)
                                                {
                                                        UniCinp = false;
                                                        UniCinC = 0;
                                                        UniCinS = "";
                                                        keyrep = false;
                                                        return;
                                                }
                                                UniCinC++;
                                                if (UniCinC == 4)
                                                {
                                                        UniCinp = false;
                                                        UniCinC = 0;
                                                        UniCinS = "";
                                                        if (ok)
                                                        {
                                                                if (b->HasSel)
                                                                        DeleteSel(b);
                                                                if (conv < 31)
                                                                        conv = 32;
                                                                hg = new Pti;
                                                                hg->ch = QString(QChar(conv));
                                                                hg->cfont = doc->CurrFont;
                                                                hg->csize = doc->CurrFontSize;
                                                                hg->ccolor = doc->CurrTextFill;
                                                                hg->cshade = doc->CurrTextFillSh;
                                                                hg->cstroke = doc->CurrTextStroke;
                                                                hg->cshade2 = doc->CurrTextStrokeSh;
                                                                hg->cscale = doc->CurrTextScale;
                                                                hg->cselect = false;
                                                                hg->cstyle = doc->CurrentStyle;
                                                                hg->cab = doc->CurrentABStil;
                                                                if (doc->Vorlagen[doc->CurrentABStil].Font != "")
                                                                {
                                                                        hg->cfont = doc->Vorlagen[doc->CurrentABStil].Font;
                                                                        hg->csize = doc->Vorlagen[doc->CurrentABStil].FontSize;
                                                                }
                                                                hg->cextra = 0;
                                                                hg->xp = 0;
                                                                hg->yp = 0;
                                                                hg->PRot = 0;
                                                                hg->PtransX = 0;
                                                                hg->PtransY = 0;
                                                                b->Ptext.insert(b->CPos, hg);
                                                                b->CPos += 1;
                                                                b->Dirty = true;
                                                                b->Tinput = true;
                                                                setTBvals(b);
                                                                doc->ActPage->RefreshItem(b, true);
                                                                keyrep = false;
                                                                return;
                                                        }
                                                }
                                                else
                                                {
                                                        keyrep = false;
                                                        return;
                                                }
                                        }
                                        switch (kk)
                                        {
                                        case Key_F12:
                                                UniCinp = true;
                                                UniCinC = 0;
                                                UniCinS = "";
                                                keyrep = false;
                                                return;
                                                break;
                                        case Key_Prior:
                                                // go to begin of line
                                                if ( (pos = b->CPos) == 0 )
                                                        break; // at begin of frame
                                                len = static_cast<int>(b->Ptext.count());
                                                if ( pos == len )
                                                        pos--;
                                                if ( (buttonState & ControlButton) == 0 )
                                                {
                                                        alty =  b->Ptext.at(pos)->yp;
                                                        c = b->Ptext.at(pos)->ch.at(0).latin1();
                                                        if ( c == 13 ) // new line, position is wrong
                                                                if ( --pos > 0 )
                                                                        alty =  b->Ptext.at(pos)->yp;
                                                        // check for yp at actual position
                                                        if ( pos < len )
                                                        {
                                                                altx =  b->Ptext.at(pos)->yp;
                                                                if ( altx > alty )
                                                                {
                                                                        // we was at begin of line
                                                                        break;
                                                                }
                                                        }
                                                        while (  pos > 0 && b->Ptext.at(pos-1)->yp == alty )
                                                                pos--;
                                                        if ( b->Ptext.at(pos)->ch.at(0).latin1() == 13 )
                                                                pos++;
                                                }
                                                else
                                                {
                                                        // paragraph begin
                                                        if ( pos < len &&
                                                                b->Ptext.at(pos)->ch.at(0).latin1() == 13 )
                                                                pos--;
                                                        while(pos > 0 )
                                                                if ( b->Ptext.at(pos)->ch.at(0).latin1() == 13 )
                                                                {
                                                                        pos++;
                                                                        break;
                                                                }
                                                                else
                                                                        pos--;
                                                }
                                                b->CPos = pos;
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->ExpandSel(b, -1, oldPos);
                                                break;
                                        case Key_Next:
                                                // go to end of line
                                                len = static_cast<int>(b->Ptext.count());
                                                if ( b->CPos >= len )
                                                        break; // at end of frame
                                                if ( (buttonState & ControlButton) == 0 )
                                                {
                                                        if ( b->CPos < len && b->Ptext.at(b->CPos)->ch.at(0).latin1() == 13 )
                                                        {
                                                                // at end of paragraph and therefore line
                                                                break;
                                                        }
                                                        alty =  b->Ptext.at(b->CPos)->yp;
                                                        while (  b->CPos < len-1 &&  b->Ptext.at(b->CPos+1)->yp == alty )
                                                                b->CPos++;

                                                        if ( b->CPos < len -1 )
                                                                c = b->Ptext.at(b->CPos+1)->ch.at(0).latin1();
                                                        else if ( b->CPos == len - 1 )
                                                                c = 13;
                                                        else
                                                                c = 0;
                                                        if ( c == 13 )
                                                                b->CPos++;
                                                }
                                                else
                                                {
                                                        // go to end of paragraph
                                                        if ( b->Ptext.at(b->CPos)->ch.at(0).latin1() == 13 )
                                                        {
                                                                break;
                                                        }
                                                        pos = b->CPos;
                                                        while ( pos < len )
                                                        {
                                                                if ( b->Ptext.at(pos)->ch.at(0).latin1() == 13 )
                                                                        break;
                                                                else
                                                                        pos++;
                                                        }
                                                        b->CPos = pos;
                                                }
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->ExpandSel(b, 1, oldPos);
                                                break;
                                        case Key_Down:
                                                if (b->CPos != static_cast<int>(b->Ptext.count()))
                                                {
                                                        alty = b->Ptext.at(b->CPos)->yp;
                                                        altx = b->Ptext.at(b->CPos)->xp;
                                                        do
                                                        {
                                                                b->CPos += 1;
                                                                if (b->CPos == static_cast<int>(b->Ptext.count()))
                                                                        break;
                                                                if (b->Ptext.at(b->CPos)->yp > alty)
                                                                {
                                                                        if (b->Ptext.at(b->CPos)->xp >= altx)
                                                                                break;
                                                                }
                                                        }
                                                        while (b->CPos < static_cast<int>(b->Ptext.count()));
                                                        if ( buttonState & ShiftButton )
                                                        {
                                                                if ( buttonState & AltButton )
                                                                        b->CPos = b->Ptext.count();
                                                                doc->ActPage->ExpandSel(b, 1, oldPos);
                                                        }
                                                        else
                                                                if (b->CPos == static_cast<int>(b->Ptext.count()))
                                                                        if (b->NextBox != 0)
                                                                        {
                                                                                if (b->NextBox->Ptext.count() != 0)
                                                                                {
                                                                                        b->OwnPage->Deselect(true);
                                                                                        b->NextBox->CPos = 0;
                                                                                        doc->ActPage = b->NextBox->OwnPage;
                                                                                        b->NextBox->OwnPage->SelectItemNr(b->NextBox->ItemNr);
                                                                                        b = b->NextBox;
                                                                                }
                                                                        }
                                                }
                                                else
                                                {
                                                        if (b->NextBox != 0)
                                                        {
                                                                if (b->NextBox->Ptext.count() != 0)
                                                                {
                                                                        b->OwnPage->Deselect(true);
                                                                        b->NextBox->CPos = 0;
                                                                        doc->ActPage = b->NextBox->OwnPage;
                                                                        b->NextBox->OwnPage->SelectItemNr(b->NextBox->ItemNr);
                                                                        b = b->NextBox;
                                                                }
                                                        }
                                                }
                                                if ( b->HasSel )
                                                        doc->ActPage->RefreshItem(b, true);
                                                setTBvals(b);
                                                break;
                                        case Key_Up:
                                                if (b->CPos > 0)
                                                {
                                                        if (b->CPos == static_cast<int>(b->Ptext.count()))
                                                                b->CPos -= 1;
                                                        alty = b->Ptext.at(b->CPos)->yp;
                                                        altx = b->Ptext.at(b->CPos)->xp;
                                                        if (b->CPos > 0)
                                                        {
                                                                do
                                                                {
                                                                        b->CPos -= 1;
                                                                        if (b->CPos == 0)
                                                                                break;
                                                                        if (b->Ptext.at(b->CPos)->yp < alty)
                                                                        {
                                                                                if (b->Ptext.at(b->CPos)->xp <= altx)
                                                                                        break;
                                                                        }
                                                                }
                                                                while (b->CPos > 0);
                                                        }
                                                        if ( buttonState & ShiftButton )
                                                        {
                                                                if ( buttonState & AltButton )
                                                                        b->CPos = 0;
                                                                doc->ActPage->ExpandSel(b, -1, oldPos);
                                                        }
                                                        else
                                                                if (b->CPos == 0)
                                                                {
                                                                        if (b->BackBox != 0)
                                                                        {
                                                                                b->OwnPage->Deselect(true);
                                                                                b->BackBox->CPos = b->BackBox->Ptext.count();
                                                                                doc->ActPage = b->BackBox->OwnPage;
                                                                                b->BackBox->OwnPage->SelectItemNr(b->BackBox->ItemNr);
                                                                                b = b->BackBox;
                                                                        }
                                                                }
                                                }
                                                else
                                                {
                                                        b->CPos = 0;
                                                        if (b->BackBox != 0)
                                                        {
                                                                b->OwnPage->Deselect(true);
                                                                b->BackBox->CPos = b->BackBox->Ptext.count();
                                                                doc->ActPage = b->BackBox->OwnPage;
                                                                b->BackBox->OwnPage->SelectItemNr(b->BackBox->ItemNr);
                                                                b = b->BackBox;
                                                        }
                                                }
                                                if ( b->HasSel )
                                                        doc->ActPage->RefreshItem(b);
                                                setTBvals(b);
                                                break;
                                        case Key_Home:
                                                b->CPos = 0;
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->ExpandSel(b, -1, oldPos);
                                                setTBvals(b);
                                                break;
                                        case Key_End:
                                                b->CPos = static_cast<int>(b->Ptext.count());
                                                if ( buttonState & ShiftButton )
                                                        doc->ActPage->ExpandSel(b, 1, oldPos);
                                                setTBvals(b);
                                                break;
                                        case Key_Left:
                                                if ( buttonState & ControlButton )
                                                {
                                                        doc->ActPage->setNewPos(b, oldPos, b->Ptext.count(),-1);
                                                        if ( buttonState & ShiftButton )
                                                                doc->ActPage->ExpandSel(b, -1, oldPos);
                                                }
                                                else if ( buttonState & ShiftButton )
                                                {
                                                        b->CPos--;
                                                        if ( b->CPos < 0 )
                                                                b->CPos = 0;
                                                        else
                                                                doc->ActPage->ExpandSel(b, -1, oldPos);
                                                }
                                                else
                                                {
                                                        b->CPos -= 1;
                                                        if (b->CPos < 0)
                                                        {
                                                                b->CPos = 0;
                                                                if (b->BackBox != 0)
                                                                {
                                                                        b->OwnPage->Deselect(true);
                                                                        b->BackBox->CPos = b->BackBox->Ptext.count();
                                                                        doc->ActPage = b->BackBox->OwnPage;
                                                                        b->BackBox->OwnPage->SelectItemNr(b->BackBox->ItemNr);
                                                                        b = b->BackBox;
                                                                }
                                                        }
                                                }
                                                while (b->Ptext.at(b->CPos)->cstyle & 256)
                                                {
                                                        b->CPos--;
                                                        if (b->CPos == 0)
                                                                break;
                                                }
                                                if ( b->HasSel )
                                                        doc->ActPage->RefreshItem(b, true);
                                                setTBvals(b);
                                                break;
                                        case Key_Right:
                                                if ( buttonState & ControlButton )
                                                {
                                                        doc->ActPage->setNewPos(b, oldPos, b->Ptext.count(),1);
                                                        if ( buttonState & ShiftButton )
                                                                doc->ActPage->ExpandSel(b, 1, oldPos);
                                                }
                                                else if ( buttonState & ShiftButton )
                                                {
                                                        b->CPos++;
                                                        if ( b->CPos > static_cast<int>(b->Ptext.count()) )
                                                                b->CPos--;
                                                        else
                                                                doc->ActPage->ExpandSel(b, 1, oldPos);
                                                }
                                                else
                                                {
                                                        b->CPos += 1; // new position within text ?
                                                        if (b->CPos > static_cast<int>(b->Ptext.count()))
                                                        {
                                                                b->CPos -= 1;
                                                                if (b->NextBox != 0)
                                                                {
                                                                        if (b->NextBox->Ptext.count() != 0)
                                                                        {
                                                                                b->OwnPage->Deselect(true);
                                                                                b->NextBox->CPos = 0;
                                                                                doc->ActPage = b->NextBox->OwnPage;
                                                                                b->NextBox->OwnPage->SelectItemNr(b->NextBox->ItemNr);
                                                                                b = b->NextBox;
                                                                        }
                                                                }
                                                        }
                                                }
                                                if ( b->HasSel )
                                                        doc->ActPage->RefreshItem(b, true);
                                                setTBvals(b);
                                                break;
                                        case Key_Delete:
                                                if (b->CPos == static_cast<int>(b->Ptext.count()))
                                                {
                                                        if (b->HasSel)
                                                        {
                                                                DeleteSel(b);
                                                                setTBvals(b);
                                                                b->Dirty = true;
                                                                doc->ActPage->RefreshItem(b, true);
                                                        }
                                                        keyrep = false;
                                                        return;
                                                }
                                                if (b->Ptext.count() == 0)
                                                {
                                                        keyrep = false;
                                                        return;
                                                }
                                                cr = b->Ptext.at(b->CPos)->ch;
                                                if (b->HasSel)
                                                        DeleteSel(b);
                                                else
                                                        b->Ptext.remove(b->CPos);
                                                b->Tinput = false;
                                                if ((cr == QChar(13)) && (b->Ptext.count() != 0))
                                                {
                                                        doc->ActPage->chAbStyle(b, b->Ptext.at(QMAX(b->CPos-1,0))->cab);
                                                        b->Tinput = false;
                                                }
                                                setTBvals(b);
                                                b->Dirty = true;
                                                doc->ActPage->RefreshItem(b, true);
                                                break;
                                        case Key_Backspace:
                                                if (b->CPos == 0)
                                                {
                                                        if (b->HasSel)
                                                        {
                                                                DeleteSel(b);
                                                                setTBvals(b);
                                                                b->Dirty = true;
                                                                doc->ActPage->RefreshItem(b, true);
                                                        }
                                                        keyrep = false;
                                                        return;
                                                }
                                                if (b->Ptext.count() == 0)
                                                {
                                                        keyrep = false;
                                                        return;
                                                }
                                                cr = b->Ptext.at(QMAX(b->CPos-1,0))->ch;
                                                if (b->HasSel)
                                                        DeleteSel(b);
                                                else
                                                        b->CPos -= 1;
                                                b->Ptext.remove(b->CPos);
                                                b->Tinput = false;
                                                if ((cr == QChar(13)) && (b->Ptext.count() != 0))
                                                {
                                                        doc->ActPage->chAbStyle(b, b->Ptext.at(QMAX(b->CPos-1,0))->cab);
                                                        b->Tinput = false;
                                                }
                                                setTBvals(b);
                                                b->Dirty = true;
                                                doc->ActPage->RefreshItem(b, true);
                                                break;
                                        default:
                                                if ((b->HasSel) && (kk < 0x1000))
                                                {
                                                        DeleteSel(b);
                                                        b->Dirty = true;
//                                                      doc->ActPage->RefreshItem(b, true);
                                                }
                                                if ((kk == Key_Tab)
                                                        || ((kk == Key_Return) && (buttonState & ShiftButton))
                                                        || ((kk + KeyMod) == Prefs.KeyActions[60].KeyID)
                                                        || ((kk + KeyMod) == Prefs.KeyActions[67].KeyID))
                                                {
                                                        hg = new Pti;
                                                        if ((kk + KeyMod) == Prefs.KeyActions[60].KeyID)
                                                                hg->ch = QString(QChar(30));
                                                        else if (kk == Key_Return)
                                                                hg->ch = QString(QChar(28));
                                                        else if (kk == Key_Tab)
                                                                hg->ch = QString(QChar(9));
                                                        else
                                                                hg->ch = QString(QChar(29));
                                                        hg->cfont = doc->CurrFont;
                                                        hg->csize = doc->CurrFontSize;
                                                        hg->ccolor = doc->CurrTextFill;
                                                        hg->cshade = doc->CurrTextFillSh;
                                                        hg->cstroke = doc->CurrTextStroke;
                                                        hg->cshade2 = doc->CurrTextStrokeSh;
                                                        hg->cscale = doc->CurrTextScale;
                                                        hg->cselect = false;
                                                        hg->cstyle = doc->CurrentStyle;
                                                        hg->cab = doc->CurrentABStil;
                                                        if (doc->Vorlagen[doc->CurrentABStil].Font != "")
                                                        {
                                                                hg->cfont = doc->Vorlagen[doc->CurrentABStil].Font;
                                                                hg->csize = doc->Vorlagen[doc->CurrentABStil].FontSize;
                                                        }
                                                        hg->cextra = 0;
                                                        hg->xp = 0;
                                                        hg->yp = 0;
                                                        hg->PRot = 0;
                                                        hg->PtransX = 0;
                                                        hg->PtransY = 0;
                                                        b->Ptext.insert(b->CPos, hg);
                                                        b->CPos += 1;
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                        break;
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[56].KeyID)
                                                {
                                                        b->Ptext.at(QMAX(b->CPos-1,0))->cstyle ^= 128;
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                        break;
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[59].KeyID)
                                                {
                                                        setNewAbStyle(1);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                        break;
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[57].KeyID)
                                                {
                                                        setNewAbStyle(0);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                        break;
                                                }
                                                if ((kk + KeyMod) == Prefs.KeyActions[58].KeyID)
                                                {
                                                        setNewAbStyle(2);
                                                        b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                        break;
                                                }
                                                if (((uc[0] > QChar(31)) || (as == 13) || (as == 30)) && ((*doc->AllFonts)[doc->CurrFont]->CharWidth.contains(uc[0].unicode())))
                                                {
                                                        hg = new Pti;
                                                        hg->ch = uc;
                                                        hg->cfont = doc->CurrFont;
                                                        hg->ccolor = doc->CurrTextFill;
                                                        hg->cshade = doc->CurrTextFillSh;
                                                        hg->cstroke = doc->CurrTextStroke;
                                                        hg->cshade2 = doc->CurrTextStrokeSh;
                                                        hg->cscale = doc->CurrTextScale;
                                                        hg->csize = doc->CurrFontSize;
                                                        hg->cextra = 0;
                                                        hg->cselect = false;
                                                        hg->cstyle = doc->CurrentStyle;
                                                        hg->cab = doc->CurrentABStil;
                                                        if (doc->Vorlagen[doc->CurrentABStil].Font != "")
                                                        {
                                                                hg->cfont = doc->Vorlagen[doc->CurrentABStil].Font;
                                                                hg->csize = doc->Vorlagen[doc->CurrentABStil].FontSize;
                                                        }
                                                        hg->xp = 0;
                                                        hg->yp = 0;
                                                        hg->PRot = 0;
                                                        hg->PtransX = 0;
                                                        hg->PtransY = 0;
                                                        b->Ptext.insert(b->CPos, hg);
                                                        b->CPos += 1;
                                                        if ((doc->Trenner->AutoCheck) && (b->CPos > 1))
                                                        {
                                                                Twort = "";
                                                                Tcoun = 0;
                                                                for (int hych = b->CPos-1; hych > -1; hych--)
                                                                {
                                                                        Tcha = b->Ptext.at(hych)->ch;
                                                                        if (Tcha == " ")
                                                                        {
                                                                                Tcoun = hych+1;
                                                                                break;
                                                                        }
                                                                        Twort.prepend(Tcha);
                                                                }
                                                                if (Twort != "")
                                                                {
                                                                        if (doc->Trenner->Language != b->Language)
                                                                                doc->Trenner->slotNewDict(b->Language);
                                                                        doc->Trenner->slotHyphenateWord(b, Twort, Tcoun);
                                                                        b->Dirty = true;
                                                                }
                                                        }
                                                        if ((b->CPos < static_cast<int>(b->Ptext.count())) || (as == 30))
                                                                b->Dirty = true;
                                                        b->Tinput = true;
                                                        doc->ActPage->RefreshItem(b, true);
                                                }
                                                break;
                                        }
                                        if (b->Ptext.count() != 0)
                                                if (b->Ptext.at(QMAX(b->CPos-1, 0))->yp != 0)
                                                        doc->ActPage->slotDoCurs(true);
                                        if ((kk == Key_Left) || (kk == Key_Right) || (kk == Key_Up) || (kk == Key_Down))
                                        {
                                                keyrep = false;
                                                return;
                                        }
                                }
                                slotDocCh(false);
                                break;
                        }
                }
        }
        keyrep = false;
}

void ScribusApp::closeEvent(QCloseEvent *ce)
{
        QWidgetList windows = wsp->windowList();
        ScribusWin* tw;
        if (!windows.isEmpty())
        {
                singleClose = true;
                for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
                {
                        newActWin(windows.at(i));
                        tw = ActWin;
                        ActWin->close();
                        if (tw == ActWin)
                        {
                                ce->ignore();
                                singleClose = false;
                                return;
                        }
                }
                SavePrefs();
                if ((Prefs.SaveAtQ) && (ScBook->Changed == true))
                {
                        if (ScBook->ScFilename.isEmpty())
                                ScBook->ScFilename = PrefsPfad+"/scrap.scs";
                        ScBook->Save();
                }
                if (ScBook->BibWin->Objekte.count() == 0)
                        unlink(PrefsPfad+"/scrap.scs");
                Prefs.AvailFonts.~SCFonts();
                FinalizePlugs();
                exit(0);
        }
        else
        {
                SavePrefs();
                if ((Prefs.SaveAtQ) && (ScBook->Changed == true))
                {
                        if (ScBook->ScFilename.isEmpty())
                                ScBook->ScFilename = PrefsPfad+"/scrap.scs";
                        ScBook->Save();
                }
                if (ScBook->BibWin->Objekte.count() == 0)
                        unlink(PrefsPfad+"/scrap.scs");
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                Prefs.AvailFonts.~SCFonts();
                FinalizePlugs();
                exit(0);
        }
}

/////////////////////////////////////////////////////////////////////
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
double ScribusApp::mm2pts(int mm)
{
        return mm / 25.4 * 72;
}

double ScribusApp::pts2mm(double pts)
{
        return pts / 72 * 25.4;
}

bool ScribusApp::slotFileNew()
{
        double b, h, tpr, lr, rr, br, sp, ab;
        bool fp, atf, ret;
        NewDoc* dia = new NewDoc(this, &Prefs);
        if (dia->exec())
        {
                tpr = dia->Top;
                lr = dia->Left;
                rr = dia->Right;
                br = dia->Bottom;
                ab = dia->Dist;
                b = dia->Pagebr;
                h = dia->Pageho;
                sp = dia->SpinBox10->value();
                atf = dia->AutoFrame->isChecked();
                fp = dia->Doppelseiten->isChecked();
                if (dia->ComboBox3->currentItem() == 1)
                {
                        b = mm2pts(qRound(pts2mm(dia->Pagebr)));
                        h = mm2pts(qRound(pts2mm(dia->Pageho)));
                }
                ret = doFileNew(b, h, tpr, lr, rr, br, ab, sp, atf, fp, dia->ComboBox3->currentItem(),
                                dia->ErsteSeite->isChecked(), dia->Orient, dia->PgNr->value());
                FMess->setText( tr("Ready"));
        }
        else
                ret = false;
        delete dia;
        return ret;
}

bool ScribusApp::doFileNew(double b, double h, double tpr, double lr, double rr, double br, double ab, double sp,
                           bool atf, bool fp, int einh, bool firstleft, int Ori, int SNr)
{
        QString cc;
        if (HaveDoc)
                doc->OpenNodes = Tpal->buildReopenVals();
        doc = new ScribusDoc();
        doc->Einheit = einh;
        if (fp)
                doc->FirstPageLeft = firstleft;
        doc->PageOri = Ori;
        doc->FirstPnum = SNr;
        doc->AllFonts = &Prefs.AvailFonts;
        doc->AddFont(Prefs.DefFont, Prefs.AvailFonts[Prefs.DefFont]->Font);
        doc->Dfont = Prefs.DefFont;
        doc->Dsize = Prefs.DefSize;
        doc->GrabRad = Prefs.GrabRad;
        doc->GuideRad = Prefs.GuideRad;
        doc->minorGrid = Prefs.DminGrid;
        doc->majorGrid = Prefs.DmajGrid;
        doc->minorColor = Prefs.DminColor;
        doc->majorColor = Prefs.DmajColor;
        doc->papColor = Prefs.DpapColor;
        doc->margColor = Prefs.DmargColor;
        doc->guideColor = Prefs.guideColor;
        doc->VHoch = Prefs.DVHoch;
        doc->VHochSc = Prefs.DVHochSc;
        doc->VTief = Prefs.DVTief;
        doc->VTiefSc = Prefs.DVTiefSc;
        doc->VKapit = Prefs.DVKapit;
        doc->Dpen = Prefs.Dpen;
        doc->DpenText = Prefs.DpenText;
        doc->Dbrush = Prefs.Dbrush;
        doc->Dshade = Prefs.Dshade;
        doc->Dshade2 = Prefs.Dshade2;
        doc->DCols = Prefs.DCols;
        doc->DGap = Prefs.DGap;
        doc->DLineArt = PenStyle(Prefs.DLineArt);
        doc->Dwidth = Prefs.Dwidth;
        doc->DpenLine = Prefs.DpenLine;
        doc->DshadeLine = Prefs.DshadeLine;
        doc->DLstyleLine = PenStyle(Prefs.DLstyleLine);
        doc->DwidthLine = Prefs.DwidthLine;
        doc->MagMin = Prefs.MagMin;
        doc->MagMax = Prefs.MagMax;
        doc->MagStep = Prefs.MagStep;
        doc->DbrushPict = Prefs.DbrushPict;
        doc->ShadePict = Prefs.ShadePict;
        doc->ScaleX = Prefs.ScaleX;
        doc->ScaleY = Prefs.ScaleY;
        doc->ScaleType = Prefs.ScaleType;
        doc->AspectRatio = Prefs.AspectRatio;
        doc->Before = Prefs.Before;
        doc->PagesSbS = Prefs.PagesSbS;
        doc->RandFarbig = Prefs.RandFarbig;
        doc->AutoLine = Prefs.AutoLine;
        doc->DocName = doc->DocName+cc.setNum(DocNr);
        doc->HasCMS = true;
        doc->CMSSettings.DefaultInputProfile = Prefs.DCMSset.DefaultInputProfile;
        doc->CMSSettings.DefaultInputProfile2 = Prefs.DCMSset.DefaultInputProfile2;
        doc->CMSSettings.DefaultMonitorProfile = Prefs.DCMSset.DefaultMonitorProfile;
        doc->CMSSettings.DefaultPrinterProfile = Prefs.DCMSset.DefaultPrinterProfile;
        doc->CMSSettings.DefaultIntentPrinter = Prefs.DCMSset.DefaultIntentPrinter;
        doc->CMSSettings.DefaultIntentMonitor = Prefs.DCMSset.DefaultIntentMonitor;
        doc->CMSSettings.DefaultIntentMonitor2 = Prefs.DCMSset.DefaultIntentMonitor2;
        doc->CMSSettings.SoftProofOn = Prefs.DCMSset.SoftProofOn;
        doc->CMSSettings.GamutCheck = Prefs.DCMSset.GamutCheck;
        doc->CMSSettings.BlackPoint = Prefs.DCMSset.BlackPoint;
        doc->CMSSettings.CMSinUse = Prefs.DCMSset.CMSinUse;
        doc->PDF_Optionen.SolidProf = doc->CMSSettings.DefaultInputProfile2;
        doc->PDF_Optionen.ImageProf = doc->CMSSettings.DefaultInputProfile;
        doc->PDF_Optionen.PrintProf = doc->CMSSettings.DefaultPrinterProfile;
        doc->PDF_Optionen.Intent = doc->CMSSettings.DefaultIntentMonitor;
        doc->PDF_Optionen.Intent2 = doc->CMSSettings.DefaultIntentMonitor2;
        doc->ActiveLayer = 0;
        HaveDoc++;
        DocNr++;
        doc->Scale = 1.0*Prefs.DisScale;
        doc->AppMode = 1;
        doc->Language = Prefs.Language;
        doc->MinWordLen = Prefs.MinWordLen;
        doc->HyCount = Prefs.HyCount;
        doc->Automatic = Prefs.Automatic;
        doc->AutoCheck = Prefs.AutoCheck;
        doc->PageColors = Prefs.DColors;
        doc->BaseGrid = Prefs.BaseGrid;
        doc->BaseOffs = Prefs.BaseOffs;
        doc->loading = true;
        ScribusWin* w = new ScribusWin(wsp, doc);
        view = new ScribusView(w, doc, &Prefs);
        w->setView(view);
        ActWin = w;
        doc->WinHan = w;
        w->setCentralWidget(view);
        connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
        //      connect(w, SIGNAL(SaveAndClose()), this, SLOT(DoSaveClose()));
        if (CMSavail)
        {
#ifdef HAVE_CMS
                w->SoftProofing = Prefs.DCMSset.SoftProofOn;
                w->Gamut = Prefs.DCMSset.GamutCheck;
                CMSuse = Prefs.DCMSset.CMSinUse;
                w->IntentPrinter = Prefs.DCMSset.DefaultIntentPrinter;
                w->IntentMonitor = Prefs.DCMSset.DefaultIntentMonitor;
                SoftProofing = Prefs.DCMSset.SoftProofOn;
                Gamut = Prefs.DCMSset.GamutCheck;
                IntentPrinter = Prefs.DCMSset.DefaultIntentPrinter;
                IntentMonitor = Prefs.DCMSset.DefaultIntentMonitor;
                w->OpenCMSProfiles(InputProfiles, MonitorProfiles, PrinterProfiles);
                stdProof = w->stdProof;
                stdTrans = w->stdTrans;
                stdProofImg = w->stdProofImg;
                stdTransImg = w->stdTransImg;
                CMSoutputProf = doc->DocOutputProf;
                CMSprinterProf = doc->DocPrinterProf;
                if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigRgbData)
                        doc->CMSSettings.ComponentsInput2 = 3;
                if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigCmykData)
                        doc->CMSSettings.ComponentsInput2 = 4;
                if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigCmyData)
                        doc->CMSSettings.ComponentsInput2 = 3;
                if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigRgbData)
                        doc->CMSSettings.ComponentsPrinter = 3;
                if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigCmykData)
                        doc->CMSSettings.ComponentsPrinter = 4;
                if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigCmyData)
                        doc->CMSSettings.ComponentsPrinter = 3;
                doc->PDF_Optionen.SComp = doc->CMSSettings.ComponentsInput2;
#endif
                if (Prefs.DCMSset.CMSinUse)
                        RecalcColors();
        }
        doc->setPage(b, h, tpr, lr, rr, br, sp, ab, atf, fp);
        doc->loading = false;
        slotNewPage(0);
        doc->loading = true;
        HaveNewDoc();
        view->Pages.at(0)->parentWidget()->hide();
        view->DocPages = view->Pages;
        view->Pages = view->MasterPages;
        doc->PageC = view->MasterPages.count();
        bool atfb = doc->PageAT;
        doc->PageAT = false;
        slotNewPage(0);
        doc->PageAT = atfb;
        view->MasterNames["Normal"] = 0;
        view->Pages.at(0)->PageNam = "Normal";
        view->Pages.at(0)->parentWidget()->hide();
        view->MasterPages = view->Pages;
        doc->PageC = view->DocPages.count();
        view->Pages = view->DocPages;
        doc->MasterP = false;
        view->Pages.at(0)->MPageNam = "Normal";
        view->Pages.at(0)->parentWidget()->show();
        doc->setUnModified();
        doc->loading = false;
        doc->ActPage = view->Pages.at(0);
        doc->OpenNodes.clear();
        Tpal->BuildTree(view);
        Sepal->Rebuild();
        BookPal->BView->clear();
        if ( wsp->windowList().isEmpty() )
                w->showMaximized();
        else
                w->show();
        view->show();
        connect(doc->ASaveTimer, SIGNAL(timeout()), w, SLOT(slotAutoSave()));
        connect(w, SIGNAL(AutoSaved()), this, SLOT(slotAutoSaved()));
        doc->AutoSave = Prefs.AutoSave;
        if (doc->AutoSave)
                doc->ASaveTimer->start(Prefs.AutoSaveTime);
        DatSav->setEnabled(false);
        fileMenu->setItemEnabled(fid4, 0);
        return true;
}

bool ScribusApp::DoSaveClose()
{
        return slotFileSave();
}

void ScribusApp::windowsMenuAboutToShow()
{
        windowsMenu->clear();
        int cascadeId = windowsMenu->insertItem( tr("Cascade"), wsp, SLOT(cascade() ) );
        int tileId = windowsMenu->insertItem( tr("Tile"), wsp, SLOT(tile() ) );
        if ( wsp->windowList().isEmpty() )
        {
                windowsMenu->setItemEnabled( cascadeId, false );
                windowsMenu->setItemEnabled( tileId, false );
        }
        windowsMenu->insertSeparator();
        QWidgetList windows = wsp->windowList();
        for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
        {
                int id = windowsMenu->insertItem(windows.at(i)->caption(), this, SLOT(windowsMenuActivated(int)));
                windowsMenu->setItemParameter( id, i );
                windowsMenu->setItemChecked( id, wsp->activeWindow() == windows.at(i) );
        }
}

void ScribusApp::newActWin(QWidget *w)
{
        ScribusWin* swin;
        if (w == NULL)
        {
                ActWin = NULL;
                return;
        }
        ActWin = (ScribusWin*)w;
        if (doc != NULL)
        {
                if ((HaveDoc) && (doc != ActWin->doc))
                        doc->OpenNodes = Tpal->buildReopenVals();
        }
        doc = ActWin->doc;
        view = ActWin->view;
        Sepal->SetView(view);
        if (!doc->loading)
        {
                SwitchWin();
                QWidgetList windows = wsp->windowList();
                for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
                {
                        swin = (ScribusWin*)windows.at(i);
                        if (swin->muster != NULL)
                                swin->muster->hide();
                }
                if (doc->TemplateMode)
                        ActWin->muster->show();
                setAppMode(doc->AppMode);
        }
        w->setFocus();
        if (w->isMaximized())
                wsp->setScrollBarsEnabled(false);
        else
                wsp->setScrollBarsEnabled(true);
        if (!doc->TemplateMode)
                Sepal->Rebuild();
        Tpal->BuildTree(view);
        Tpal->reopenTree(doc->OpenNodes);
        BookPal->BView->NrItems = ActWin->NrItems;
        BookPal->BView->First = ActWin->First;
        BookPal->BView->Last = ActWin->Last;
        RestoreBookMarks();
        if (!doc->loading)
        {
                if (doc->ActPage->SelItem.count() != 0)
                        HaveNewSel(doc->ActPage->SelItem.at(0)->PType);
                else
                        HaveNewSel(-1);
        }
}

void ScribusApp::windowsMenuActivated( int id )
{
        if (HaveDoc)
                doc->OpenNodes = Tpal->buildReopenVals();
        QWidget* w = wsp->windowList().at( id );
        if ( w )
                w->showNormal();
        newActWin(w);
}

bool ScribusApp::SetupDoc()
{
        double tpr = doc->PageM.Top;
        double lr = doc->PageM.Left;
        double rr = doc->PageM.Right;
        double br = doc->PageM.Bottom;
        bool fp = doc->PageFP;
        bool fpe = doc->FirstPageLeft;
        double tpr2, lr2, rr2, br2;
        bool ret = false;
        ReformDoc* dia = new ReformDoc(this, tpr, lr, rr, br, doc->PageB, doc->PageH, fp, fpe, doc->Einheit);
        if (dia->exec())
        {
                tpr2 = dia->TopR->value() / UmReFaktor;
                lr2 = dia->LeftR->value() / UmReFaktor;
                rr2 = dia->RightR->value() / UmReFaktor;
                br2 = dia->BottomR->value() / UmReFaktor;
                fp = dia->Doppelseiten->isChecked();
                if (fp)
                        doc->FirstPageLeft = dia->ErsteSeite->isChecked();
                doc->resetPage(tpr2, lr2, rr2, br2, fp);
                view->reformPages();
                view->GotoPage(doc->ActPage->PageNr);
                view->DrawNew();
                Sepal->RebuildPage();
                slotDocCh();
                ret = true;
                doc->PDF_Optionen.BleedBottom = doc->PageM.Bottom;
                doc->PDF_Optionen.BleedTop = doc->PageM.Top;
                doc->PDF_Optionen.BleedLeft = doc->PageM.Left;
                doc->PDF_Optionen.BleedRight = doc->PageM.Right;

        }
        delete dia;
        return ret;
}

void ScribusApp::SwitchWin()
{
        int a;
        CListe::Iterator it;
        QPixmap pm = QPixmap(15, 15);
        a = 0;
        ColorMenC->clear();
        ColorMenC->insertItem( tr("None"));
        for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
        {
                pm.fill(doc->PageColors[it.key()].getRGBColor());
                ColorMenC->insertItem(pm, it.key());
                if (it.key() == doc->Dbrush)
                        ColorMenC->setCurrentItem(a);
                a++;
        }
        BuildFontMenu();
#ifdef HAVE_CMS
        SoftProofing = ActWin->SoftProofing;
        Gamut = ActWin->Gamut;
        IntentPrinter = ActWin->IntentPrinter;
        IntentMonitor = ActWin->IntentMonitor;
        stdProof = ActWin->stdProof;
        stdTrans = ActWin->stdTrans;
        stdProofImg = ActWin->stdProofImg;
        stdTransImg = ActWin->stdTransImg;
        CMSoutputProf = doc->DocOutputProf;
        CMSprinterProf = doc->DocPrinterProf;
#endif
        Mpal->Cpal->SetColors(doc->PageColors);
        Mpal->Cpal->ChooseGrad(0);
        ActWin->setCaption(doc->DocName);
        ShadeMenu->setItemChecked(ShadeMenu->idAt(11), true);
        Mpal->SetDoc(doc);
        Mpal->updateCList();
        Sepal->SetView(view);
        Mpal->Spal->SetFormats(doc);
        Mpal->SetLineFormats(doc);
        Lpal->setLayers(&doc->Layers, &doc->ActiveLayer);
        view->LaMenu();
        view->setLayMenTxt(doc->ActiveLayer);
        doc->CurrentABStil = 0;
        slotChangeUnit(doc->Einheit, false);
        if (doc->EditClip)
        {
                doc->EditClip = !doc->EditClip;
                ToggleFrameEdit();
        }
        DatClo->setEnabled(true);
        if (doc->TemplateMode)
        {
                for (uint a=0; a<5; ++a)
                {
                        pageMenu->setItemEnabled(pageMenu->idAt(a), 0);
                }
                editMenu->setItemEnabled(tman, 0);
                DatNeu->setEnabled(false);
                DatSav->setEnabled(false);
                DatOpe->setEnabled(false);
                DatClo->setEnabled(false);
                fileMenu->setItemEnabled(fid1, 0);
                fileMenu->setItemEnabled(fid4, 0);
                fileMenu->setItemEnabled(fid5, 0);
                fileMenu->setItemEnabled(fid51, 0);
                fileMenu->setItemEnabled(fid52, 0);
                fileMenu->setItemEnabled(fid12, 0);
                fileMenu->setItemEnabled(fid13, 0);
                fileMenu->setItemEnabled(fid14, 0);
                Sepal->DisablePal();
        }
        else
        {
                menuBar()->setItemEnabled(pgmm, 1);
                editMenu->setItemEnabled(tman, 1);
                DatNeu->setEnabled(true);
                DatOpe->setEnabled(true);
                DatClo->setEnabled(true);
                DatSav->setEnabled(doc->isModified());
                fileMenu->setItemEnabled(fid1, 1);
                fileMenu->setItemEnabled(fid4, ActWin->MenuStat[2]);
                fileMenu->setItemEnabled(fid5, ActWin->MenuStat[3]);
                fileMenu->setItemEnabled(fid51, ActWin->MenuStat[3]);
                fileMenu->setItemEnabled(fid52, 0);
                fileMenu->setItemEnabled(fid12, 1);
                fileMenu->setItemEnabled(fid13, 1);
                fileMenu->setItemEnabled(fid14, 1);
                if (view->Pages.count() > 1)
                {
                        pageMenu->setItemEnabled(pgmd, 1);
                        pageMenu->setItemEnabled(pgmv, 1);
                }
                else
                {
                        pageMenu->setItemEnabled(pgmd, 0);
                        pageMenu->setItemEnabled(pgmv, 0);
                }
                if (doc->isModified())
                        slotDocCh(false);
                fileMenu->setItemEnabled(fid5, 1);
                fileMenu->setItemEnabled(fid51, 1);
                Sepal->EnablePal();
        }
}

void ScribusApp::HaveNewDoc()
{
        int a;
        DatPri->setEnabled(true);
        DatPDF->setEnabled(true);
        DatSav->setEnabled(false);
        QValueList<int>::iterator itm;
        for (itm = MenuItemsFile.begin(); itm != MenuItemsFile.end(); ++itm )
        {
                fileMenu->setItemEnabled((*itm), 1);
        }
        fileMenu->setItemEnabled(fid5, 1);
        fileMenu->setItemEnabled(fid11, 1);
        fileMenu->setItemEnabled(fid4, 0);
        fileMenu->setItemEnabled(fid52, 0);
        exportMenu->setItemEnabled(fid8, 1);
        importMenu->setItemEnabled(fid2a, 1);
        exportMenu->setItemEnabled(fid10, 1);
        editMenu->setItemEnabled(edid1, 0);
        editMenu->setItemEnabled(edid2, 0);
        if (Buffer2 != "")
                editMenu->setItemEnabled(edid3, 1);
        else
                editMenu->setItemEnabled(edid3, 0);
        editMenu->setItemEnabled(edid6, 1);
        editMenu->setItemEnabled(edid6a, 1);
        menuBar()->setItemEnabled(ViMen, 1);
        menuBar()->setItemEnabled(WinMen, 1);
        viewMenu->setItemChecked(uGuide, doc->SnapGuides);
        viewMenu->setItemChecked(uRas, doc->useRaster);
        menuBar()->setItemEnabled(pgmm, 1);
        menuBar()->setItemEnabled(exmn, 1);
        WerkTools->setEnabled(true);
        WerkToolsP->setEnabled(true);
        int setter = 0;
        if (view->Pages.count() > 1)
                setter = 1;
        pageMenu->setItemEnabled(pgmd, setter);
        pageMenu->setItemEnabled(pgmv, setter);
        editMenu->setItemEnabled(tman, 1);
        editMenu->setItemEnabled(jman, 1);
        CListe::Iterator it;
        QPixmap pm = QPixmap(15, 15);
        a = 0;
        ColorMenC->clear();
        ColorMenC->insertItem( tr("None"));
        for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
        {
                pm.fill(doc->PageColors[it.key()].getRGBColor());
                ColorMenC->insertItem(pm, it.key());
                if (it.key() == doc->Dbrush)
                        ColorMenC->setCurrentItem(a);
                a++;
        }
        Mpal->Cpal->SetColors(doc->PageColors);
        Mpal->Cpal->ChooseGrad(0);
        ActWin->setCaption(doc->DocName);
        ShadeMenu->setItemChecked(ShadeMenu->idAt(11), true);
        Mpal->SetDoc(doc);
        Mpal->updateCList();
        Sepal->SetView(view);
        Mpal->Spal->SetFormats(doc);
        Mpal->SetLineFormats(doc);
        Lpal->setLayers(&doc->Layers, &doc->ActiveLayer);
        view->LaMenu();
        view->setLayMenTxt(doc->ActiveLayer);
        doc->CurrentABStil = 0;
        slotChangeUnit(doc->Einheit);
        doc->Trenner = new Hyphenator(this, doc, this);
        BuildFontMenu();
        connect(view, SIGNAL(changeUN(int)), this, SLOT(slotChangeUnit(int)));
        connect(view, SIGNAL(changeLA(int)), Lpal, SLOT(MarkActiveLayer(int)));
        doc->PDF_Optionen.BleedBottom = doc->PageM.Bottom;
        doc->PDF_Optionen.BleedTop = doc->PageM.Top;
        doc->PDF_Optionen.BleedLeft = doc->PageM.Left;
        doc->PDF_Optionen.BleedRight = doc->PageM.Right;
        doc->CurTimer = 0;
}

void ScribusApp::HaveNewSel(int Nr)
{
        PageItem *b = NULL;
        if (Nr != -1)
                b = doc->ActPage->SelItem.at(0);
        ObjMenu->setItemEnabled(PfadDT, 0);
        view->HR->ItemPosValid = false;
        view->HR->repX = false;
        view->HR->repaint();
        switch (Nr)
        {
        case -1:
                importMenu->changeItem(fid2, tr("Get Text/Picture..."));
                importMenu->setItemEnabled(fid2, 0);
                importMenu->setItemEnabled(fid2aa, 0);
                exportMenu->setItemEnabled(fid3, 0);
                menuBar()->setItemEnabled(Stm, 0);
                menuBar()->setItemEnabled(Obm, 0);
                ObjMenu->setItemEnabled(ShapeM, 0);
                ObjMenu->setItemEnabled(PfadTP, 0);
                ObjMenu->setItemEnabled(LockOb, 0);
                editMenu->setItemEnabled(edid1, 0);
                editMenu->setItemEnabled(edid2, 0);
                editMenu->setItemEnabled(edid4, 0);
                editMenu->setItemEnabled(edid5, 0);
                editMenu->setItemEnabled(Sear, 0);
                extraMenu->setItemEnabled(hyph, 0);
                StilMenu->clear();
                WerkTools->KetteAus->setEnabled(false);
                WerkTools->KetteEin->setEnabled(false);
                WerkTools->Textedit->setEnabled(false);
                WerkTools->Textedit2->setEnabled(false);
                WerkTools->Rotiere->setEnabled(false);
                Mpal->Cpal->GradCombo->setCurrentItem(0);
                Tpal->slotShowSelect(doc->ActPage->PageNr, -1);
                break;
        case 2:
                importMenu->changeItem(fid2, tr("Get Picture..."));
                importMenu->setItemEnabled(fid2aa, 0);
                importMenu->setItemEnabled(fid2, 1);
                editMenu->setItemEnabled(edid1, 1);
                editMenu->setItemEnabled(edid2, 1);
                editMenu->setItemEnabled(edid4, 0);
                editMenu->setItemEnabled(edid5, 0);
                editMenu->setItemEnabled(Sear, 0);
                extraMenu->setItemEnabled(hyph, 0);
                menuBar()->setItemEnabled(Stm, 1);
                menuBar()->setItemEnabled(Obm, 1);
                if ((b->isTableItem) && (b->isSingleSel))
                        ObjMenu->setItemEnabled(ShapeM, 0);
                else
                        ObjMenu->setItemEnabled(ShapeM, 1);
                ObjMenu->setItemEnabled(PfadTP, 0);
                StilMenu->clear();
                StilMenu->insertItem( tr("Color"), ColorMenu);
                if (b->isRaster)
                        StilMenu->insertItem( tr("Invert"), this, SLOT(InvertPict()));
                WerkTools->KetteAus->setEnabled(false);
                WerkTools->KetteEin->setEnabled(false);
                WerkTools->Textedit->setEnabled(b->ScaleType);
                WerkTools->Textedit2->setEnabled(false);
                WerkTools->Rotiere->setEnabled(true);
                break;
        case 4:
                importMenu->changeItem(fid2, tr("Get Text..."));
                importMenu->setItemEnabled(fid2, 1);
                importMenu->setItemEnabled(fid2aa, 1);
                exportMenu->setItemEnabled(fid3, 1);
                editMenu->setItemEnabled(edid1, 1);
                editMenu->setItemEnabled(edid2, 1);
                editMenu->setItemEnabled(edid4, 0);
                editMenu->setItemEnabled(edid5, 0);
                editMenu->setItemEnabled(Sear, 1);
                extraMenu->setItemEnabled(hyph, 1);
                menuBar()->setItemEnabled(Stm, 1);
                menuBar()->setItemEnabled(Obm, 1);
                if ((b->isTableItem) && (b->isSingleSel))
                        ObjMenu->setItemEnabled(ShapeM, 0);
                else
                        ObjMenu->setItemEnabled(ShapeM, 1);
                ObjMenu->setItemEnabled(PfadTP, 1);
                StilMenu->clear();
                StilMenu->insertItem( tr("Font"), FontMenu);
                StilMenu->insertItem( tr("Size"), SizeTMenu);
                StilMenu->insertItem( tr("Effects"), TypeStyleMenu);
                StilMenu->insertItem( tr("Alignment"), AliMenu);
                StilMenu->insertItem( tr("Color"), ColorMenu);
                StilMenu->insertItem( tr("Shade"), ShadeMenu);
                StilMenu->insertItem( tr("Tabulators..."), this, SLOT(EditTabs()));
                WerkTools->Rotiere->setEnabled(true);
                WerkTools->Textedit2->setEnabled(true);
                if ((b->NextBox != 0) || (b->BackBox != 0))
                {
                        WerkTools->KetteAus->setEnabled(true);
                        if ((b->BackBox != 0) && (b->Ptext.count() == 0))
                                WerkTools->Textedit->setEnabled(false);
                        else
                                WerkTools->Textedit->setEnabled(true);
                }
                else
                        WerkTools->Textedit->setEnabled(true);
                if (b->NextBox == 0)
                        WerkTools->KetteEin->setEnabled(true);
                if (doc->MasterP)
                        WerkTools->KetteEin->setEnabled(false);
                if (doc->AppMode == 7)
                {
                        setTBvals(b);
                        editMenu->setItemEnabled(edid5, 1);
                        view->HR->ItemPos = b->Xpos;
                        view->HR->ItemEndPos = b->Xpos+b->Width;
                        if (b->Pcolor2 != "None")
                                view->HR->lineCorr = b->Pwidth / 2.0;
                        else
                                view->HR->lineCorr = 0;
                        view->HR->ColGap = b->ColGap;
                        view->HR->Cols = b->Cols;
                        view->HR->Extra = b->Extra;
                        view->HR->RExtra = b->RExtra;
                        view->HR->First = doc->Vorlagen[doc->CurrentABStil].First;
                        view->HR->Indent = doc->Vorlagen[doc->CurrentABStil].Indent;
                        if ((b->flippedH % 2 != 0) || (b->Reverse))
                                view->HR->Revers = true;
                        else
                                view->HR->Revers = false;
                        view->HR->ItemPosValid = true;
                        view->HR->repX = false;
                        if (doc->CurrentABStil < 5)
                                view->HR->TabValues = b->TabValues;
                        else
                                view->HR->TabValues = doc->Vorlagen[doc->CurrentABStil].TabValues;
                        view->HR->repaint();
                }
                else
                {
                        doc->CurrFont = b->IFont;
                        doc->CurrFontSize = b->ISize;
                        doc->CurrTextFill = b->TxtFill;
                        doc->CurrTextStroke = b->TxtStroke;
                        doc->CurrTextStrokeSh = b->ShTxtStroke;
                        doc->CurrTextFillSh = b->ShTxtFill;
                        doc->CurrTextScale = b->TxtScale;
                        emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
                        doc->CurrentStyle = b->TxTStyle;
                        emit TextStil(doc->CurrentStyle);
                        emit TextScale(doc->CurrTextScale);
                        setStilvalue(doc->CurrentStyle);
                }
                doc->Vorlagen[0].LineSpa = b->LineSp;
                doc->Vorlagen[0].Ausri = b->Ausrich;
                break;
        case 8:
                importMenu->changeItem(fid2, tr("Get Text..."));
                importMenu->setItemEnabled(fid2, 1);
                importMenu->setItemEnabled(fid2aa, 1);
                exportMenu->setItemEnabled(fid3, 1);
                editMenu->setItemEnabled(edid1, 1);
                editMenu->setItemEnabled(edid2, 1);
                editMenu->setItemEnabled(edid4, 0);
                editMenu->setItemEnabled(edid5, 0);
                editMenu->setItemEnabled(Sear, 0);
                extraMenu->setItemEnabled(hyph, 0);
                menuBar()->setItemEnabled(Stm, 1);
                menuBar()->setItemEnabled(Obm, 1);
                ObjMenu->setItemEnabled(ShapeM, 0);
                ObjMenu->setItemEnabled(PfadDT, 1);
                ObjMenu->setItemEnabled(PfadTP, 0);
                StilMenu->clear();
                StilMenu->insertItem( tr("Font"), FontMenu);
                StilMenu->insertItem( tr("Size"), SizeTMenu);
                StilMenu->insertItem( tr("Style"), TypeStyleMenu);
                StilMenu->insertItem( tr("Color"), ColorMenu);
                StilMenu->insertItem( tr("Shade"), ShadeMenu);
                WerkTools->Rotiere->setEnabled(true);
                WerkTools->Textedit->setEnabled(false);
                WerkTools->Textedit2->setEnabled(true);
                WerkTools->KetteEin->setEnabled(false);
                WerkTools->KetteAus->setEnabled(false);
                if (doc->AppMode == 7)
                        setTBvals(b);
                else
                {
                        doc->CurrFont = b->IFont;
                        doc->CurrFontSize = b->ISize;
                        doc->CurrTextFill = b->TxtFill;
                        doc->CurrTextStroke = b->TxtStroke;
                        doc->CurrTextStrokeSh = b->ShTxtStroke;
                        doc->CurrTextFillSh = b->ShTxtFill;
                        doc->CurrTextScale = b->TxtScale;
                        emit TextFarben(doc->CurrTextStroke, doc->CurrTextFill, doc->CurrTextStrokeSh, doc->CurrTextFillSh);
                        doc->CurrentStyle = b->TxTStyle;
                        emit TextStil(doc->CurrentStyle);
                        emit TextScale(doc->CurrTextScale);
                        setStilvalue(doc->CurrentStyle);
                }
                break;
        default:
                importMenu->changeItem(fid2, tr("Get Text/Picture..."));
                importMenu->setItemEnabled(fid2, 0);
                importMenu->setItemEnabled(fid2aa, 0);
                exportMenu->setItemEnabled(fid3, 0);
                editMenu->setItemEnabled(edid1, 1);
                editMenu->setItemEnabled(edid2, 1);
                editMenu->setItemEnabled(edid4, 0);
                editMenu->setItemEnabled(edid5, 0);
                editMenu->setItemEnabled(Sear, 0);
                extraMenu->setItemEnabled(hyph, 0);
                menuBar()->setItemEnabled(Stm, 1);
                menuBar()->setItemEnabled(Obm, 1);
                StilMenu->clear();
                StilMenu->insertItem( tr("Color"), ColorMenu);
                StilMenu->insertItem( tr("Shade"), ShadeMenu);
                if (Nr == 6)
                        ObjMenu->setItemEnabled(ShapeM, 1);
                WerkTools->KetteAus->setEnabled(false);
                WerkTools->KetteEin->setEnabled(false);
                if (Nr != 5)
                        WerkTools->Rotiere->setEnabled(true);
                else
                        WerkTools->Rotiere->setEnabled(false);
                break;
        }
        doc->CurrentSel = Nr;
        Mpal->RotationGroup->setButton(doc->RotMode);
        if (doc->ActPage->SelItem.count() > 1)
        {
                ObjMenu->setItemEnabled(DistM, 1);
                ObjMenu->setItemEnabled(PfadTP, 0);
                bool hPoly = true;
                bool isGroup = true;
                int firstElem = -1;
                if (b->Groups.count() != 0)
                        firstElem = b->Groups.top();
                for (uint bx=0; bx<doc->ActPage->SelItem.count(); ++bx)
                {
                        if (doc->ActPage->SelItem.at(bx)->PType != 6)
                                hPoly = false;
                        if (doc->ActPage->SelItem.at(bx)->Groups.count() != 0)
                        {
                                if (doc->ActPage->SelItem.at(bx)->Groups.top() != firstElem)
                                        isGroup = false;
                        }
                        else
                                isGroup = false;
                }
                ObjMenu->setItemEnabled(Gr, !isGroup);
                ObjMenu->setItemEnabled(PfadV, hPoly);
                if (doc->ActPage->SelItem.count() == 2)
                {
                        if (((b->PType == 4) || (doc->ActPage->SelItem.at(1)->PType == 4)) && ((b->PType == 7) || (doc->ActPage->SelItem.at(1)->PType == 7)))
                        {
                                PageItem* bx = doc->ActPage->SelItem.at(1);
                                if ((b->NextBox == 0) && (b->BackBox == 0) && (bx->NextBox == 0) && (bx->BackBox == 0))
                                        ObjMenu->setItemEnabled(PfadT, 1);
                        }
                }
        }
        else
        {
                ObjMenu->setItemEnabled(DistM, 0);
                ObjMenu->setItemEnabled(Gr, 0);
                ObjMenu->setItemEnabled(PfadT, 0);
                ObjMenu->setItemEnabled(PfadV, 0);
        }
        if (doc->ActPage->SelItem.count() != 0)
        {
                Mpal->Textflow->setChecked(b->Textflow);
                ObjMenu->setItemEnabled(LockOb, 1);
                if (b->Groups.count() != 0)
                        ObjMenu->setItemEnabled(UnGr, 1);
                else
                {
                        ObjMenu->setItemEnabled(UnGr, 0);
                        if ((b->PType == 6) && (b->Segments.count() != 0))
                                ObjMenu->setItemEnabled(PfadS, 1);
                        else
                                ObjMenu->setItemEnabled(PfadS, 0);
                }
                if (b->Locked)
                {
                        ObjMenu->setItemEnabled(DistM, 0);
                        ObjMenu->setItemEnabled(ShapeM, 0);
                        ObjMenu->setItemEnabled(PfadTP, 0);
                        ObjMenu->setItemEnabled(PfadS, 0);
                        ObjMenu->setItemEnabled(PfadT, 0);
                        ObjMenu->setItemEnabled(PfadDT, 0);
                        ObjMenu->setItemEnabled(PfadV, 0);
                        ObjMenu->setItemEnabled(Loesch, 0);
                        ObjMenu->setItemEnabled(OBack, 0);
                        ObjMenu->setItemEnabled(OFront, 0);
                        ObjMenu->setItemEnabled(ORaise, 0);
                        ObjMenu->setItemEnabled(OLower, 0);
                        editMenu->setItemEnabled(edid1, 0);
                        editMenu->setItemEnabled(edid4, 0);
                        WerkTools->Rotiere->setEnabled(false);
                        ObjMenu->changeItem(LockOb, tr("Unlock"));
                }
                else
                {
                        ObjMenu->changeItem(LockOb, tr("Lock"));
                        if ((b->isTableItem) && (b->isSingleSel))
                        {
                                ObjMenu->setItemEnabled(PfadTP, 0);
                                ObjMenu->setItemEnabled(ODup, 0);
                                ObjMenu->setItemEnabled(OMDup, 0);
                                ObjMenu->setItemEnabled(Loesch, 0);
                                ObjMenu->setItemEnabled(OBack, 0);
                                ObjMenu->setItemEnabled(OFront, 0);
                                ObjMenu->setItemEnabled(ORaise, 0);
                                ObjMenu->setItemEnabled(OLower, 0);
                        }
                        else
                        {
                                ObjMenu->setItemEnabled(ODup, 1);
                                ObjMenu->setItemEnabled(OMDup, 1);
                                ObjMenu->setItemEnabled(Loesch, 1);
                                ObjMenu->setItemEnabled(OBack, 1);
                                ObjMenu->setItemEnabled(OFront, 1);
                                ObjMenu->setItemEnabled(ORaise, 1);
                                ObjMenu->setItemEnabled(OLower, 1);
                        }
                }
        }
        Mpal->NewSel(Nr);
        if (Nr != -1)
        {
                Mpal->SetCurItem(b);
                Tpal->slotShowSelect(b->OwnPage->PageNr, b->ItemNr);
                if (b->FrameType == 0)
                        SCustom->setPixmap(SCustom->getIconPixmap(0));
                if (b->FrameType == 1)
                        SCustom->setPixmap(SCustom->getIconPixmap(1));
                if (b->FrameType > 3)
                        SCustom->setPixmap(SCustom->getIconPixmap(b->FrameType-2));
        }
}

void ScribusApp::slotDocCh(bool reb)
{
        if ((reb) && (!doc->TemplateMode) && (doc->ActPage->SelItem.count() != 0))
                Tpal->slotUpdateElement(doc->ActPage->PageNr, doc->ActPage->SelItem.at(0)->ItemNr);
        if (!doc->isModified())
                doc->setModified();
        ActWin->setCaption( doc->DocName + "*");
        if (!doc->TemplateMode)
        {
                fileMenu->setItemEnabled(fid4, 1);
                DatSav->setEnabled(true);
                DatClo->setEnabled(true);
                fileMenu->setItemEnabled(fid5, 1);
                fileMenu->setItemEnabled(fid51, 1);
                if (doc->hasName)
                        fileMenu->setItemEnabled(fid52, 1);
        }
        ActWin->MenuStat[0] = DatSav->isEnabled();
        ActWin->MenuStat[1] = fileMenu->isItemEnabled(fid1);
        ActWin->MenuStat[2] = fileMenu->isItemEnabled(fid4);
        ActWin->MenuStat[3] = fileMenu->isItemEnabled(fid5);
        if (doc->ActPage->SelItem.count() != 0)
        {
                PageItem* b = doc->ActPage->SelItem.at(0);
                if (b->Locked)
                        ObjMenu->changeItem(LockOb, tr("Unlock"));
                else
                        ObjMenu->changeItem(LockOb, tr("Lock"));
        }
}

void ScribusApp::UpdateRecent(QString fn)
{
        recentMenu->clear();
        if (RecentDocs.findIndex(fn) == -1)
                RecentDocs.prepend(fn);
        else
        {
                RecentDocs.remove(fn);
                RecentDocs.prepend(fn);
        }
        uint max = QMIN(Prefs.RecentDCount, RecentDocs.count());
        for (uint m = 0; m < max; ++m)
        {
                recentMenu->insertItem(RecentDocs[m]);
        }
}

void ScribusApp::LoadRecent(int id)
{
        QString fn = recentMenu->text(id);
        QFileInfo fd(fn);
        if (!fd.exists())
        {
                RecentDocs.remove(fn);
                recentMenu->clear();
                uint max = QMIN(Prefs.RecentDCount, RecentDocs.count());
                for (uint m = 0; m < max; ++m)
                {
                        recentMenu->insertItem(RecentDocs[m]);
                }
                return;
        }
        qApp->setOverrideCursor(QCursor(waitCursor), true);
        LadeDoc(recentMenu->text(id));
        qApp->setOverrideCursor(QCursor(arrowCursor), true);
}

bool ScribusApp::slotDocOpen()
{
        bool ret = false;
#ifdef HAVE_LIBZ
        QString fileName = CFileDialog( tr("Open"), tr("Documents (*.sla *.sla.gz *.scd *.scd.gz);;All Files (*)"));
#else
        QString fileName = CFileDialog( tr("Open"), tr("Documents (*.sla *.scd);;All Files (*)"));
#endif
        qApp->setOverrideCursor(QCursor(waitCursor), true);
        ret = LadeDoc(fileName);
        qApp->setOverrideCursor(QCursor(arrowCursor), true);
        return ret;
}

bool ScribusApp::slotDocMerge()
{
        bool ret = false;
        MergeDoc *dia = new MergeDoc(this, false);
        if (dia->exec())
        {
                qApp->setOverrideCursor(QCursor(waitCursor), true);
                ret = LadeSeite(dia->Filename->text(), dia->PageNr->value()-1, false);
                qApp->setOverrideCursor(QCursor(arrowCursor), true);
                ret = true;
        }
        delete dia;
        return ret;
}

bool ScribusApp::LadeSeite(QString fileName, int Nr, bool Mpa)
{
        bool ret = false;
        if (!fileName.isEmpty())
        {
                if (!Mpa)
                        doc->OpenNodes = Tpal->buildReopenVals();
                doc->loading = true;
                ScriXmlDoc *ss = new ScriXmlDoc();
                if(!ss->ReadPage(fileName, Prefs.AvailFonts, doc, view, Nr, Mpa))
                {
                        delete ss;
                        doc->loading = false;
                        return false;
                }
                delete ss;
                if (CMSavail)
                {
                        if (doc->CMSSettings.CMSinUse)
                        {
                                RecalcColors();
                                view->RecalcPictures(&InputProfiles);
                        }
                }
                for (uint azz = 0; azz < doc->ActPage->Items.count(); ++azz)
                {
                        PageItem *ite = doc->ActPage->Items.at(azz);
                        if ((ite->PType == 4) && (ite->isBookmark))
                                BookPal->BView->AddPageItem(ite);
                }
                Mpal->Cpal->SetColors(doc->PageColors);
                Mpal->updateCList();
                Mpal->Spal->SetFormats(doc);
                Mpal->SetLineFormats(doc);
                if (!Mpa)
                {
                        Tpal->BuildTree(view);
                        Tpal->reopenTree(doc->OpenNodes);
                }
                slotDocCh();
                doc->loading = false;
                ret = true;
        }
        Sepal->Rebuild();
        doc->ActPage->update();
        return ret;
}

bool ScribusApp::LadeDoc(QString fileName)
{
        if (HaveDoc)
                doc->OpenNodes = Tpal->buildReopenVals();
        bool ret = false;
        QWidgetList windows = wsp->windowList();
        bool found = false;
        int id = 0;
        for ( int i = 0; i < static_cast<int>(windows.count()); ++i )
        {
                if (windows.at(i)->caption() == fileName)
                {
                        found = true;
                        id = i;
                        break;
                }
        }
        if (found)
        {
                windowsMenuActivated(id);
                return true;
        }
        if (!fileName.isEmpty())
        {
                QFileInfo fi(fileName);
                QString FName = fi.absFilePath();
                QDir::setCurrent(fi.dirPath(true));
                doc=new ScribusDoc();
                doc->AllFonts = &Prefs.AvailFonts;
                doc->AddFont(Prefs.DefFont, Prefs.AvailFonts[Prefs.DefFont]->Font);
                doc->Dfont = Prefs.DefFont;
                doc->Dsize = Prefs.DefSize;
                doc->GrabRad = Prefs.GrabRad;
                doc->GuideRad = Prefs.GuideRad;
                doc->minorGrid = Prefs.DminGrid;
                doc->majorGrid = Prefs.DmajGrid;
                doc->minorColor = Prefs.DminColor;
                doc->majorColor = Prefs.DmajColor;
                doc->papColor = Prefs.DpapColor;
                doc->margColor = Prefs.DmargColor;
                doc->guideColor = Prefs.guideColor;
                doc->Dpen = Prefs.Dpen;
                doc->DpenText = Prefs.DpenText;
                doc->Dbrush = Prefs.Dbrush;
                doc->Dshade = Prefs.Dshade;
                doc->Dshade2 = Prefs.Dshade2;
                doc->DCols = Prefs.DCols;
                doc->DGap = Prefs.DGap;
                doc->DLineArt = PenStyle(Prefs.DLineArt);
                doc->Dwidth = Prefs.Dwidth;
                doc->DpenLine = Prefs.DpenLine;
                doc->DshadeLine = Prefs.DshadeLine;
                doc->DLstyleLine = PenStyle(Prefs.DLstyleLine);
                doc->DwidthLine = Prefs.DwidthLine;
                doc->MagMin = Prefs.MagMin;
                doc->MagMax = Prefs.MagMax;
                doc->MagStep = Prefs.MagStep;
                doc->DbrushPict = Prefs.DbrushPict;
                doc->ShadePict = Prefs.ShadePict;
                doc->ScaleX = Prefs.ScaleX;
                doc->ScaleY = Prefs.ScaleY;
                doc->ScaleType = Prefs.ScaleType;
                doc->AspectRatio = Prefs.AspectRatio;
                doc->Before = Prefs.Before;
                doc->Einheit = Prefs.Einheit;
                doc->PagesSbS = Prefs.PagesSbS;
                doc->RandFarbig = Prefs.RandFarbig;
                doc->AutoLine = Prefs.AutoLine;
                doc->Scale = 1.0*Prefs.DisScale;
                doc->AppMode = 1;
                doc->HasCMS = false;
                doc->ActiveLayer = 0;
                doc->Language = Prefs.Language;
                doc->MinWordLen = Prefs.MinWordLen;
                doc->HyCount = Prefs.HyCount;
                doc->Automatic = Prefs.Automatic;
                doc->AutoCheck = Prefs.AutoCheck;
                doc->BaseGrid = Prefs.BaseGrid;
                doc->BaseOffs = Prefs.BaseOffs;
                doc->OpenNodes.clear();
                doc->loading = true;
                FMess->setText( tr("Loading..."));
                FProg->reset();
                ScribusWin* w = new ScribusWin(wsp, doc);
                view = new ScribusView(w, doc, &Prefs);
                w->setView(view);
                ActWin = w;
                doc->WinHan = w;
                w->setCentralWidget(view);
                ScriXmlDoc *ss = new ScriXmlDoc();
                connect(ss, SIGNAL(NewPage(int)), this, SLOT(slotNewPage(int)));
#ifdef HAVE_CMS
                w->SoftProofing = false;
                w->Gamut = false;
                bool cmsu = CMSuse;
                CMSuse = false;
#endif
                if(!ss->ReadDoc(fi.fileName(), Prefs.AvailFonts, doc, view, FProg))
                {
                        view->close();
                        disconnect(ss, SIGNAL(NewPage(int)), this, SLOT(slotNewPage(int)));
                        delete ss;
                        delete view;
                        delete doc;
                        delete w;
                        FMess->setText("");
                        FProg->reset();
                        ActWin = NULL;
                        return false;
                }
                delete ss;
                FMess->setText("");
                FProg->reset();
#ifdef HAVE_CMS
                CMSuse = cmsu;
#endif
                HaveDoc++;
                connect(w, SIGNAL(Schliessen()), this, SLOT(DoFileClose()));
                if (!doc->HasCMS)
                {
                        doc->CMSSettings.DefaultInputProfile = Prefs.DCMSset.DefaultInputProfile;
                        doc->CMSSettings.DefaultInputProfile2 = Prefs.DCMSset.DefaultInputProfile2;
                        doc->CMSSettings.DefaultMonitorProfile = Prefs.DCMSset.DefaultMonitorProfile;
                        doc->CMSSettings.DefaultPrinterProfile = Prefs.DCMSset.DefaultPrinterProfile;
                        doc->CMSSettings.DefaultIntentPrinter = Prefs.DCMSset.DefaultIntentPrinter;
                        doc->CMSSettings.DefaultIntentMonitor = Prefs.DCMSset.DefaultIntentMonitor;
                        doc->CMSSettings.DefaultIntentMonitor2 = Prefs.DCMSset.DefaultIntentMonitor2;
                        doc->CMSSettings.SoftProofOn = Prefs.DCMSset.SoftProofOn;
                        doc->CMSSettings.GamutCheck = Prefs.DCMSset.GamutCheck;
                        doc->CMSSettings.BlackPoint = Prefs.DCMSset.BlackPoint;
                        doc->CMSSettings.CMSinUse = false;
                }
                if (CMSavail)
                {
                        if (!InputProfiles.contains(doc->CMSSettings.DefaultInputProfile))
                                doc->CMSSettings.DefaultInputProfile = Prefs.DCMSset.DefaultInputProfile;
                        if (!InputProfiles.contains(doc->CMSSettings.DefaultInputProfile2))
                                doc->CMSSettings.DefaultInputProfile2 = Prefs.DCMSset.DefaultInputProfile2;
                        if (!MonitorProfiles.contains(doc->CMSSettings.DefaultMonitorProfile))
                                doc->CMSSettings.DefaultMonitorProfile = Prefs.DCMSset.DefaultMonitorProfile;
                        if (!PrinterProfiles.contains(doc->CMSSettings.DefaultPrinterProfile))
                                doc->CMSSettings.DefaultPrinterProfile = Prefs.DCMSset.DefaultPrinterProfile;
                        if (!PrinterProfiles.contains(doc->PDF_Optionen.PrintProf))
                                doc->PDF_Optionen.PrintProf = doc->CMSSettings.DefaultPrinterProfile;
                        if (!InputProfiles.contains(doc->PDF_Optionen.ImageProf))
                                doc->PDF_Optionen.ImageProf = doc->CMSSettings.DefaultInputProfile;
                        if (!InputProfiles.contains(doc->PDF_Optionen.SolidProf))
                                doc->PDF_Optionen.SolidProf = doc->CMSSettings.DefaultInputProfile2;
#ifdef HAVE_CMS
                        w->SoftProofing = doc->CMSSettings.SoftProofOn;
                        w->Gamut = doc->CMSSettings.GamutCheck;
                        CMSuse = doc->CMSSettings.CMSinUse;
                        w->IntentPrinter = doc->CMSSettings.DefaultIntentPrinter;
                        w->IntentMonitor = doc->CMSSettings.DefaultIntentMonitor;
                        SoftProofing = doc->CMSSettings.SoftProofOn;
                        Gamut = doc->CMSSettings.GamutCheck;
                        IntentPrinter = doc->CMSSettings.DefaultIntentPrinter;
                        IntentMonitor = doc->CMSSettings.DefaultIntentMonitor;
                        w->OpenCMSProfiles(InputProfiles, MonitorProfiles, PrinterProfiles);
                        CMSuse = doc->CMSSettings.CMSinUse;
                        stdProof = w->stdProof;
                        stdTrans = w->stdTrans;
                        stdProofImg = w->stdProofImg;
                        stdTransImg = w->stdTransImg;
                        CMSoutputProf = doc->DocOutputProf;
                        CMSprinterProf = doc->DocPrinterProf;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigRgbData)
                                doc->CMSSettings.ComponentsInput2 = 3;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigCmykData)
                                doc->CMSSettings.ComponentsInput2 = 4;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocInputProf)) == icSigCmyData)
                                doc->CMSSettings.ComponentsInput2 = 3;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigRgbData)
                                doc->CMSSettings.ComponentsPrinter = 3;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigCmykData)
                                doc->CMSSettings.ComponentsPrinter = 4;
                        if (static_cast<int>(cmsGetColorSpace(doc->DocPrinterProf)) == icSigCmyData)
                                doc->CMSSettings.ComponentsPrinter = 3;
                        doc->PDF_Optionen.SComp = doc->CMSSettings.ComponentsInput2;
#endif
                        if (doc->CMSSettings.CMSinUse)
                        {
                                RecalcColors();
                                view->RecalcPictures(&InputProfiles);
                        }
                }
                Mpal->Cpal->SetColors(doc->PageColors);
                Mpal->Cpal->ChooseGrad(0);
                doc->DocName = FName;
                doc->MasterP = false;
                HaveNewDoc();
                Mpal->updateCList();
                doc->hasName = true;
                if (view->MasterPages.count() == 0)
                {
                        for (uint ax=0; ax<view->Pages.count(); ++ax)
                        {
                                view->Pages.at(ax)->parentWidget()->hide();
                        }
                        view->DocPages = view->Pages;
                        view->Pages = view->MasterPages;
                        doc->PageC = view->MasterPages.count();
                        bool atf = doc->PageAT;
                        doc->PageAT = false;
                        slotNewPage(0);
                        doc->PageAT = atf;
                        view->MasterNames["Normal"] = 0;
                        view->Pages.at(0)->PageNam = "Normal";
                        view->Pages.at(0)->parentWidget()->hide();
                        view->MasterPages = view->Pages;
                        doc->PageC = view->DocPages.count();
                        view->Pages = view->DocPages;
                        doc->MasterP = false;
                        for (uint ay=0; ay<view->Pages.count(); ++ay)
                        {
                                view->Pages.at(ay)->parentWidget()->show();
                        }
                }
                doc->setUnModified();
                doc->loading = false;
                view->GotoPage(0);
                doc->RePos = true;
                QPixmap pgPix(10, 10);
                QRect rd = QRect(0,0,9,9);
                ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
                for (uint az=0; az<view->MasterPages.count(); az++)
                {
                        for (uint azz=0; azz<view->MasterPages.at(az)->Items.count(