Subversion Repositories Scribus

Rev

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

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/

/***************************************************************************
                          scribusview.cpp  -  description
                             -------------------
    begin                : Fre Apr  6 21:47:55 CEST 2001
    copyright            : (C) 2001 by Franz Schmid
    email                : Franz.Schmid@altmuehlnet.de
 ***************************************************************************/


/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/


#include "scribusview.h"
#include "scribusview.moc"

#include "scconfig.h"

#include <qcolor.h>
#include <qfont.h>
#include <qfontmetrics.h>
#include <qpixmap.h>
#include <qpointarray.h>
#include <qstringlist.h>
#include <qdragobject.h>
#include <qimage.h>
#include <qcstring.h>
#include <qfileinfo.h>
#include <qfile.h>
#include <qptrstack.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <qurl.h>
#include <qdir.h>
#include <qevent.h>
#include <qsizegrip.h>
#if QT_VERSION  > 0x030102
        #define SPLITVC SplitHCursor
        #define SPLITHC SplitVCursor
#else
        #define SPLITVC SplitVCursor
        #define SPLITHC SplitHCursor
#endif
#include "scribus.h"
#include "tree.h"
#include "mpalette.h"
#include "scribusXml.h"
#include "selection.h"
#include "serializer.h"
#include "insertTable.h"
#include "hruler.h"
#include "vruler.h"
#include "filewatcher.h"
#include "undomanager.h"
#include "units.h"
#include "extimageprops.h"
#include "page.h"
#include "pageitemattributes.h"
#include "pageitem_imageframe.h"
#include "pageitem_line.h"
#include "pageitem_pathtext.h"
#include "pageitem_polygon.h"
#include "pageitem_polyline.h"
#include "pageitem_textframe.h"
#include "pageselector.h"
#include "scpaths.h"
#include "actionmanager.h"
#include <tiffio.h>
#include CMS_INC

#include "scmessagebox.h"
#include "util.h"
#include "story.h"
#include "prefsmanager.h"
#include "prefscontext.h"
#include "prefsfile.h"
#include "rulermover.h"
#include "hyphenator.h"
#include "commonstrings.h"
#include "guidemanager.h"
#include "oneclick.h"
#include "text/nlsconfig.h"
#include "scrap.h"
#include "stencilreader.h"
#ifdef HAVE_CAIRO
#include <cairo.h>
#endif

using namespace std;



ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
        QScrollView(win, "s", WRepaintNoErase | WNorthWestGravity),
        Doc(doc),
        Prefs(&(PrefsManager::instance()->appPrefs)),
        undoManager(UndoManager::instance()),
        OldScale(0),
        dragX(0), dragY(0), dragW(0), dragH(0),
        oldW(-1), oldCp(-1),
        Mxp(-1), Myp(-1), Dxp(-1), Dyp(-1),
        frameResizeHandle(-1),
        SeRx(-1), SeRy(-1), GyM(-1), GxM(-1),
        ClRe(-1), ClRe2(-1),
        SegP1(-1), SegP2(-1),
        RotMode(0),
        DrHY(-1), DrVX(-1),
        EdPoints(true),
        m_MouseButtonPressed(false),   
        operItemMoving(false),
        MoveGY(false), MoveGX(false),
        HaveSelRect(false),
        operItemResizing(false),
        EditContour(false),
        //GroupSel(false),
        DraggedGroup(false),
        DraggedGroupFirst(false),
        operItemResizeInEditMode(false),
        MidButt(false),
        updateOn(true),
        FirstPoly(true),
        Magnify(false),
        MoveSym(false),
        previewMode(false),
        RCenter(-1,-1),
        RecordP(),
        Ready(false),
        oldX(0), oldY(0),
        _groupTransactionStarted(false),
        _isGlobalMode(true),
        evSpon(false),
        forceRedraw(false),
        Scale(Prefs->DisScale),
        oldClip(0),
        m_vhRulerHW(17),
        m_cursorVisible(false),
        m_ScMW(mw)
{
        setHScrollBarMode(QScrollView::AlwaysOn);
        setVScrollBarMode(QScrollView::AlwaysOn);
        setMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
        setResizePolicy(Manual);
        viewport()->setBackgroundMode(PaletteBackground);
        QFont fo = QFont(font());
        int posi = fo.pointSize()-2;
        fo.setPointSize(posi);
        unitSwitcher = new QComboBox( false, this, "unitSwitcher" );
        unitSwitcher->setFocusPolicy(QWidget::NoFocus);
        unitSwitcher->setFont(fo);
        for (int i=0;i<=unitGetMaxIndex();++i)
                unitSwitcher->insertItem(unitGetStrFromIndex(i));
        zoomSpinBox = new MSpinBox( 10, 3200, this, 2 );
        zoomSpinBox->setTabAdvance(false);
        zoomSpinBox->setFont(fo);
        zoomSpinBox->setValue( 100 );
        zoomSpinBox->setLineStep(10);
        zoomSpinBox->setFocusPolicy(QWidget::ClickFocus);
        zoomSpinBox->setSuffix( tr( " %" ) );
#if OPTION_USE_QTOOLBUTTON
        zoomOutToolbarButton = new QToolButton(this);
        zoomDefaultToolbarButton = new QToolButton(this);
        zoomInToolbarButton = new QToolButton(this);
        cmsToolbarButton = new QToolButton(this);
        previewToolbarButton = new QToolButton(this);
        zoomDefaultToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        zoomOutToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        zoomInToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        cmsToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        cmsToolbarButton->setToggleButton(true);
        QIconSet ic2;
        ic2.setPixmap(loadIcon("cmsOff.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::Off);
        ic2.setPixmap(loadIcon("cmsOn.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::On);
        cmsToolbarButton->setIconSet(ic2);
        previewToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        previewToolbarButton->setToggleButton(true);
        QIconSet ic;
        ic.setPixmap(loadIcon("previewOff.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::Off);
        ic.setPixmap(loadIcon("previewOn.png"), QIconSet::Automatic, QIconSet::Normal, QIconSet::On);
        previewToolbarButton->setIconSet(ic);
#else
        zoomDefaultToolbarButton = new QPushButton(this);
        zoomDefaultToolbarButton->setFocusPolicy(QWidget::NoFocus);
        zoomDefaultToolbarButton->setDefault( false );
        zoomDefaultToolbarButton->setAutoDefault( false );
        zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        zoomOutToolbarButton = new QPushButton(this);
        zoomOutToolbarButton->setFocusPolicy(QWidget::NoFocus);
        zoomOutToolbarButton->setDefault( false );
        zoomOutToolbarButton->setAutoDefault( false );
        zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        zoomInToolbarButton = new QPushButton(this);
        zoomInToolbarButton->setFocusPolicy(QWidget::NoFocus);
        zoomInToolbarButton->setDefault( false );
        zoomInToolbarButton->setAutoDefault( false );
        zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        previewToolbarButton = new QPushButton(this);
        cmsToolbarButton->setFocusPolicy(QWidget::NoFocus);
        cmsToolbarButton->setDefault( false );
        cmsToolbarButton->setAutoDefault( false );
        cmsToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        cmsToolbarButton->setPixmap(loadIcon("cmsOn.png"));
        previewToolbarButton = new QPushButton(this);
        previewToolbarButton->setFocusPolicy(QWidget::NoFocus);
        previewToolbarButton->setDefault( false );
        previewToolbarButton->setAutoDefault( false );
        previewToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        previewToolbarButton->setPixmap(loadIcon("previewOn.png"));
#endif
        //zoomDefaultToolbarButton->setText("1:1");
        zoomDefaultToolbarButton->setPixmap(loadIcon("16/zoom-original.png"));
        zoomOutToolbarButton->setPixmap(loadIcon("16/zoom-out.png"));
        zoomInToolbarButton->setPixmap(loadIcon("16/zoom-in.png"));
        pageSelector = new PageSelector(this, Doc->Pages->count());
        pageSelector->setFont(fo);
        pageSelector->setFocusPolicy(QWidget::ClickFocus);
        layerMenu = new QComboBox( true, this, "LY" );
        layerMenu->setEditable(false);
        layerMenu->setFont(fo);
        layerMenu->setFocusPolicy(QWidget::NoFocus);
        visualMenu = new QComboBox( false, this, "visualMenu" );
        visualMenu->setFocusPolicy(QWidget::NoFocus);
        visualMenu->setFont(fo);
        visualMenu->setEnabled(false);
        horizRuler = new Hruler(this, Doc);
        vertRuler = new Vruler(this, Doc);
        rulerMover = new RulerMover(this);
        rulerMover->setFocusPolicy(QWidget::NoFocus);
        Ready = true;
        viewport()->setMouseTracking(true);
        setAcceptDrops(true);
        viewport()->setAcceptDrops(true);
        setDragAutoScroll(false);
        Doc->DragP = false;
        Doc->leaveDrag = false;
        Doc->SubMode = -1;
        storedFramesShown = Doc->guidesSettings.framesShown;
        storedShowControls = Doc->guidesSettings.showControls;
        viewAsPreview = false;
        previewVisual = 0;
        shiftSelItems = false;
        inItemCreation = false;
#ifdef HAVE_CAIRO
        m_ScMW->scrActions["viewFitPreview"]->setOn(viewAsPreview);
#endif
        m_SnapCounter = 0;
        connect(zoomOutToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
        connect(zoomInToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
        connect(zoomDefaultToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoom100()));
        connect(zoomSpinBox, SIGNAL(valueChanged(int)), this, SLOT(setZoom()));
        connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
        connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
        connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
        connect(previewToolbarButton, SIGNAL(clicked()), this, SLOT(togglePreview()));
        connect(cmsToolbarButton, SIGNAL(clicked()), this, SLOT(toggleCMS()));
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
        connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
        connect(this, SIGNAL(HaveSel(int)), this, SLOT(selectionChanged()));
        languageChange();
}

void ScribusView::languageChange()
{
        QToolTip::remove(cmsToolbarButton);
        QToolTip::remove(previewToolbarButton);
        QToolTip::remove(visualMenu);
        QToolTip::add(cmsToolbarButton, tr("Switches Color Management on or off"));
        QToolTip::add(previewToolbarButton, tr("Enables the Preview Mode"));
        QToolTip::add(visualMenu, tr("Here you can select the visual appearance of the display\nYou can choose between normal and several color blindness forms"));
        disconnect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
        visualMenu->clear();
        visualMenu->insertItem(CommonStrings::trVisionNormal);
        visualMenu->insertItem(CommonStrings::trVisionProtanopia);
        visualMenu->insertItem(CommonStrings::trVisionDeuteranopia);
        visualMenu->insertItem(CommonStrings::trVisionTritanopia);
        visualMenu->insertItem(CommonStrings::trVisionFullColorBlind);
        visualMenu->setCurrentItem(previewVisual);
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
}

void ScribusView::toggleCMS()
{
        Doc->enableCMS(!Doc->HasCMS);
        updateContents();
}

void ScribusView::switchPreviewVisual(int vis)
{
        previewVisual = vis;
        Doc->recalculateColors();
        Doc->recalcPicturesRes();
        updateContents();
}

void ScribusView::togglePreview()
{
        viewAsPreview = !viewAsPreview;
        if (viewAsPreview)
        {
                storedFramesShown = Doc->guidesSettings.framesShown;
                Doc->guidesSettings.framesShown = false;
                storedShowControls = Doc->guidesSettings.showControls;
                Doc->guidesSettings.showControls = false;
                // warning popping up in case colour management and out-of-gamut-display are active
                // as from #4346: Add a preview for daltonian - PV
                if (Doc->HasCMS && Doc->Gamut)
                        QMessageBox::information(m_ScMW, tr("Preview Mode"),
                                                "<qt>" + tr("CMS is active. Therefore the color display may not match the perception by visually impaired") + "</qt>",
                                                QMessageBox::Ok);
        }
        else
        {
                Doc->guidesSettings.framesShown = storedFramesShown;
                Doc->guidesSettings.showControls = storedShowControls;
        }
        m_ScMW->scrActions["viewFitPreview"]->setOn(viewAsPreview);
        m_ScMW->scrActions["viewShowMargins"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowFrames"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowGrid"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowGuides"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowBaseline"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowTextChain"]->setEnabled(!viewAsPreview);
        m_ScMW->scrActions["viewShowTextControls"]->setEnabled(!viewAsPreview);
#if OPTION_USE_QTOOLBUTTON
        previewToolbarButton->setOn(viewAsPreview);
#endif
        visualMenu->setEnabled(viewAsPreview);
        Doc->recalculateColors();
        Doc->recalcPicturesRes();
        updateContents();
}

void ScribusView::viewportPaintEvent ( QPaintEvent * p )
{
        #ifndef _WIN32
        if (p->spontaneous())
                evSpon = true;
        #endif
        QScrollView::viewportPaintEvent(p);
}

void ScribusView::drawContents(QPainter *psx, int clipx, int clipy, int clipw, int cliph)
{
        if (Doc->isLoading())
                return;
        if (!updateOn)
                return;
//      QTime tim;
//      tim.start();
        if ((clipw > 0) && (cliph > 0))
        {
                QPoint vr = contentsToViewport(QPoint(clipx, clipy));
                ScPainter *painter=0;
#ifdef HAVE_CAIRO
//              struct Layer la;
//              la.LNr = 0;
//              int Lnr = 0;
//              Level2Layer(Doc, &la, Lnr);
                QImage img = QImage(clipw, cliph, 32);
                painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
                painter->clear(paletteBackgroundColor());
#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 2, 6)
                painter->newPath();
                painter->moveTo(0, 0);
                painter->lineTo(clipw, 0);
                painter->lineTo(clipw, cliph);
                painter->lineTo(0, cliph);
                painter->closePath();
                painter->setClipPath();
#endif
                painter->translate(-clipx, -clipy);
                painter->setZoomFactor(Scale);
                painter->translate(-Doc->minCanvasCoordinate.x(), -Doc->minCanvasCoordinate.y());
                painter->setLineWidth(1);
                painter->setFillMode(ScPainter::Solid);
#else
                painter = new ScPainter(viewport(), clipw, cliph, vr.x(), vr.y());
                painter->clear(paletteBackgroundColor());
                painter->translate(-Doc->minCanvasCoordinate.x()*Scale, -Doc->minCanvasCoordinate.y()*Scale);
                painter->translate(-clipx, -clipy);
                painter->setLineWidth(1);
                painter->setFillMode(ScPainter::Solid);
                painter->setZoomFactor(1.0);
#endif
/* Draw Page Outlines */
                if (!Doc->masterPageMode())
                {
                        uint docPagesCount=Doc->Pages->count();
                        if (!viewAsPreview)
                        {
                                painter->setBrush(QColor(128,128,128));
#ifdef HAVE_CAIRO
                                painter->setAntialiasing(false);
                                painter->beginLayer(1.0, 0);
                                painter->setPen(black, 1.0 / Scale, SolidLine, FlatCap, MiterJoin);
#else
                                painter->setPen(black, 0.5 / Scale, SolidLine, FlatCap, MiterJoin);
#endif
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
                                {
                                        double bleedRight = 0.0;
                                        double bleedLeft = 0.0;
                                        double bleedBottom = 0.0;
                                        double bleedTop = 0.0;
                                        Doc->getBleeds(Doc->Pages->at(a), &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
                                        int blx = qRound((Doc->Pages->at(a)->xOffset() - bleedLeft) * Scale);
                                        int bly = qRound((Doc->Pages->at(a)->yOffset() - bleedTop) * Scale);
                                        int blw = qRound((Doc->Pages->at(a)->width() + bleedLeft + bleedRight) * Scale);
                                        int blh = qRound((Doc->Pages->at(a)->height() + bleedBottom + bleedTop) * Scale);
       
                                        QRect drawRect = QRect(blx-1, bly-1, blw+6, blh+6);
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
                                        {
                                                painter->setFillMode(ScPainter::Solid);
                                                int blx2, bly2, blw2, blh2;
                                                if (Doc->guidesSettings.showBleed)
                                                {
                                                        blx2 = qRound(Doc->Pages->at(a)->xOffset() - bleedLeft);
                                                        bly2 = qRound(Doc->Pages->at(a)->yOffset() - bleedTop);
                                                        blw2 = qRound(Doc->Pages->at(a)->width() + bleedLeft + bleedRight);
                                                        blh2 = qRound(Doc->Pages->at(a)->height() + bleedBottom + bleedTop);
                                                }
                                                else
                                                {
                                                        blx2 = qRound(Doc->Pages->at(a)->xOffset());
                                                        bly2 = qRound(Doc->Pages->at(a)->yOffset());
                                                        blw2 = qRound(Doc->Pages->at(a)->width());
                                                        blh2 = qRound(Doc->Pages->at(a)->height());
                                                }
#ifdef HAVE_CAIRO
                                                painter->drawRect(blx2 + 5 / Scale, bly2 + 5 / Scale, blw2, blh2);
#else
                                                blx2 = qRound(blx2 * Scale);
                                                bly2 = qRound(bly2 * Scale);
                                                blw2 = qRound(blw2 * Scale);
                                                blh2 = qRound(blh2 * Scale);
                                                painter->drawRect(blx2 + 5, bly2 + 5, blw2, blh2);
#endif
                                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
                                                {
                                                        painter->setFillMode(ScPainter::None);
#ifdef HAVE_CAIRO
                                                        painter->setPen(black, 1.0 / Scale, SolidLine, FlatCap, MiterJoin);
                                                        painter->drawRect(blx2, bly2 - 1 / Scale, blw2 + 1 / Scale, blh2 + 2 / Scale);
#else
                                                        painter->setPen(black, 0.5 / Scale, SolidLine, FlatCap, MiterJoin);
                                                        painter->drawRect(blx2, bly2 - 1, blw2 + 1, blh2 + 2);
#endif
                                                }
                                        }
                                }
#ifdef HAVE_CAIRO
                                painter->endLayer();
                                painter->setAntialiasing(true);
#endif
                        }
                        painter->setFillMode(ScPainter::Solid);
                        for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
                        {
#ifdef HAVE_CAIRO
                                int x = qRound(Doc->Pages->at(a)->xOffset());
                                int y = qRound(Doc->Pages->at(a)->yOffset());
                                int w = qRound(Doc->Pages->at(a)->width());
                                int h = qRound(Doc->Pages->at(a)->height());
#else
                                int x = qRound(Doc->Pages->at(a)->xOffset() * Scale);
                                int y = qRound(Doc->Pages->at(a)->yOffset() * Scale);
                                int w = qRound(Doc->Pages->at(a)->width() * Scale);
                                int h = qRound(Doc->Pages->at(a)->height() * Scale);
#endif
                                double bleedRight = 0.0;
                                double bleedLeft = 0.0;
                                double bleedBottom = 0.0;
                                double bleedTop = 0.0;
                                bool drawBleed = false;
                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
                                {
                                        drawBleed = true;
                                        Doc->getBleeds(a, &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
                                }
                                int blx = qRound((Doc->Pages->at(a)->xOffset() - bleedLeft) * Scale);
                                int bly = qRound((Doc->Pages->at(a)->yOffset() - bleedTop) * Scale);
                                int blw = qRound((Doc->Pages->at(a)->width() + bleedLeft + bleedRight) * Scale);
                                int blh = qRound((Doc->Pages->at(a)->height() + bleedBottom + bleedTop) * Scale);

                                QRect drawRect = QRect(blx, bly, blw+5, blh+5);
                                drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
                                if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
                                {
                                        painter->setFillMode(ScPainter::Solid);
                                        painter->setPen(black, 0, SolidLine, FlatCap, MiterJoin);
#ifdef HAVE_CAIRO
                                        painter->setAntialiasing(false);
                                        painter->beginLayer(1.0, 0);
#endif
                                        painter->setLineWidth(0.0);
                                        painter->setBrush(Doc->papColor);
                                        if (!viewAsPreview)
                                        {
#ifdef HAVE_CAIRO
                                                int blx2 = qRound(Doc->Pages->at(a)->xOffset() - bleedLeft);
                                                int bly2 = qRound(Doc->Pages->at(a)->yOffset() - bleedTop);
                                                int blw2 = qRound(Doc->Pages->at(a)->width() + bleedLeft + bleedRight);
                                                int blh2 = qRound(Doc->Pages->at(a)->height() + bleedBottom + bleedTop);
                                                painter->drawRect(blx2, bly2, blw2, blh2);
#else
                                                painter->drawRect(blx, bly, blw, blh);
#endif
                                                if (drawBleed)
                                                        painter->drawRect(x, y, w, h);
                                        }
                                        else
                                                painter->drawRect(x, y, w, h);
#ifdef HAVE_CAIRO
                                        painter->endLayer();
                                        painter->setAntialiasing(true);
#endif
                                }
                        }
#ifdef HAVE_CAIRO
                        if (viewAsPreview)
                        {
                                FPointArray PoLine;
                                bool first = true;
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
                                {
                                        if (!first)
                                                PoLine.setMarker();
                                        first = false;
                                        double x = Doc->Pages->at(a)->xOffset();
                                        double y = Doc->Pages->at(a)->yOffset();
                                        double w = Doc->Pages->at(a)->width();
                                        double h = Doc->Pages->at(a)->height();
                                        static double rect[] = {0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0,
                                                                                                        1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0,
                                                                                                        0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0};
                                        for (int a = 0; a < 29; a += 4)
                                        {
                                                PoLine.addPoint(x + w * rect[a], y + h * rect[a+1]);
                                                PoLine.addPoint(x + w * rect[a+2], y + h * rect[a+3]);
                                        }
                                }
                                painter->beginLayer(1.0, 0, &PoLine);
                        }
                        else
                                painter->beginLayer(1.0, 0);
#endif
                        if ((Doc->guidesSettings.before) && (!viewAsPreview))
                        {
                                for (uint a = 0; a < docPagesCount; ++a)
                                {
                                        int x = qRound(Doc->Pages->at(a)->xOffset() * Scale);
                                        int y = qRound(Doc->Pages->at(a)->yOffset() * Scale);
                                        int w = qRound(Doc->Pages->at(a)->width() * Scale);
                                        int h = qRound(Doc->Pages->at(a)->height() * Scale);
                                        QRect drawRect = QRect(x, y, w+5, h+5);
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
                                }
                        }
                        for (uint a = 0; a < docPagesCount; ++a)
                        {
                                DrawMasterItems(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
                        }
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
#ifdef HAVE_CAIRO
                        painter->endLayer();
#endif
                        if ((!Doc->guidesSettings.before) && (!viewAsPreview))
                        {
                                for (uint a = 0; a < docPagesCount; ++a)
                                {
                                        int x = qRound(Doc->Pages->at(a)->xOffset() * Scale);
                                        int y = qRound(Doc->Pages->at(a)->yOffset() * Scale);
                                        int w = qRound(Doc->Pages->at(a)->width() * Scale);
                                        int h = qRound(Doc->Pages->at(a)->height() * Scale);
                                        QRect drawRect = QRect(x, y, w+5, h+5);
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
                                }
                        }
                }
                else
                {
                        int x = qRound(Doc->scratch.Left * Scale);
                        int y = qRound(Doc->scratch.Top * Scale);
                        int w = qRound(Doc->currentPage()->width() * Scale);
                        int h = qRound(Doc->currentPage()->height() * Scale);
                        QRect drawRect = QRect(x, y, w+5, h+5);
                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
                        {
                                painter->setFillMode(ScPainter::Solid);
                                painter->setBrush(QColor(128,128,128));
                                double bleedRight = 0.0;
                                double bleedLeft = 0.0;
                                double bleedBottom = 0.0;
                                double bleedTop = 0.0;
                                Doc->getBleeds(Doc->currentPage(), &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
#ifdef HAVE_CAIRO
                                painter->beginLayer(1.0, 0);
                                painter->setAntialiasing(false);
                                painter->setPen(black, 1 / Scale, SolidLine, FlatCap, MiterJoin);
                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
                                {
                                        painter->drawRect(Doc->scratch.Left - bleedLeft+5 / Scale, Doc->scratch.Top - bleedTop+5 / Scale, Doc->currentPage()->width() + bleedLeft + bleedRight, Doc->currentPage()->height() + bleedBottom + bleedTop);
                                        painter->setBrush(Doc->papColor);
                                        painter->drawRect(Doc->scratch.Left - bleedLeft, Doc->scratch.Top - bleedTop, Doc->currentPage()->width() + bleedLeft + bleedRight, Doc->currentPage()->height() + bleedBottom + bleedTop);
                                }
                                else
                                {
                                        painter->drawRect(Doc->scratch.Left+5 / Scale, Doc->scratch.Top+5 / Scale, Doc->currentPage()->width(), Doc->currentPage()->height());
                                        painter->setBrush(Doc->papColor);
                                        painter->drawRect(Doc->scratch.Left, Doc->scratch.Top, Doc->currentPage()->width(), Doc->currentPage()->height());
                                }
                                painter->setAntialiasing(true);
#else
                                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
                                {
                                        x = qRound((Doc->scratch.Left - bleedLeft) * Scale);
                                        y = qRound((Doc->scratch.Top - bleedTop) * Scale);
                                        w = qRound((Doc->currentPage()->width() + bleedLeft + bleedRight) * Scale);
                                        h = qRound((Doc->currentPage()->height() + bleedBottom + bleedTop) * Scale);
                                }
                                painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
                                painter->drawRect(x+5, y+5, w, h);
                                painter->setBrush(Doc->papColor);
                                painter->drawRect(x, y, w, h);
#endif
                                if (Doc->guidesSettings.before)
                                        DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
#ifdef HAVE_CAIRO
                                painter->endLayer();
#endif
                        }
#ifdef HAVE_CAIRO
                        painter->beginLayer(1.0, 0);
#endif
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
#ifdef HAVE_CAIRO
                        painter->endLayer();
#endif
                        if ((!Doc->guidesSettings.before) && (drawRect.intersects(QRect(clipx, clipy, clipw, cliph))))
                                DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
                }
                if (((Doc->m_Selection->count() != 0) || (linkedFramesToShow.count() != 0))  && (!viewAsPreview))
                {
#ifndef HAVE_CAIRO
                        double z = painter->zoomFactor();
                        painter->setZoomFactor(Scale);
#endif
                        painter->save();
                        PageItem *currItem;
                        if ((Doc->guidesSettings.linkShown) && (linkedFramesToShow.count() != 0))
                                currItem = linkedFramesToShow.at(0);
                        else
                        {
                                if (linkedFramesToShow.count() != 0)
                                        currItem = linkedFramesToShow.at(0);
                                else
                                        currItem = Doc->m_Selection->itemAt(0);
                        }
                        //Draw the frame links
                        if ((((Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
                                   && (currItem->itemType() == PageItem::TextFrame)) || (Doc->guidesSettings.linkShown))
                        {
                                PageItem *nextItem = currItem;
                                if (Doc->guidesSettings.linkShown)
                                {
                                        for (uint lks = 0; lks < linkedFramesToShow.count(); ++lks)
                                        {
                                                nextItem = linkedFramesToShow.at(lks);
                                                while (nextItem != 0)
                                                {
                                                        //Calculate the link points of the frames
                                                        double x11 = nextItem->xPos();
                                                        double y11 = nextItem->yPos();
                                                        double x12 = x11+nextItem->width();
                                                        double y12 = y11+nextItem->height();
                                                        double x1mid = x11+(x12-x11)/2;
                                                        double y1mid = y11+(y12-y11)/2;

                                                        if (nextItem->rotation()!=0.000)
                                                        {
                                                                FPoint tempPoint(0,0, x11, y11, nextItem->rotation(), 1, 1);
                                                                x11=tempPoint.x();
                                                                y11=tempPoint.y();
                                                                FPoint tempPoint2(0,0, x12, y12, nextItem->rotation(), 1, 1);
                                                                x12=tempPoint2.x();
                                                                y12=tempPoint2.y();
                                                                FPoint tempPoint3(0,0, x1mid, y1mid, nextItem->rotation(), 1, 1);
                                                                x1mid=tempPoint3.x();
                                                                y1mid=tempPoint3.y();
                                                        }


                                                        double a1, b1, a2, b2;
                                                        a1 = a2 = b1 = b2 = 0;
                                                        if (nextItem->nextInChain() != NULL)
                                                        {
                                                                double x21 = nextItem->nextInChain()->xPos();
                                                                double y21 = nextItem->nextInChain()->yPos();
                                                                double x22 = x21+nextItem->nextInChain()->width();
                                                                double y22 = y21+nextItem->nextInChain()->height();
                                                                double x2mid = x21 + nextItem->nextInChain()->width()/2;
                                                                double y2mid = y21 + nextItem->nextInChain()->height()/2;
                                                                //x2mid = x21+(x22-x21)/2;
                                                                //y2mid = y21+(y22-y21)/2;

                                                                if (nextItem->nextInChain()->rotation()!=0.000)
                                                                {
                                                                        FPoint tempPoint(0,0, x21, y21, nextItem->nextInChain()->rotation(), 1, 1);
                                                                        x21=tempPoint.x();
                                                                        y21=tempPoint.y();
                                                                        FPoint tempPoint2(0,0, x22, y22, nextItem->nextInChain()->rotation(), 1, 1);
                                                                        x22=tempPoint2.x();
                                                                        y22=tempPoint2.y();
                                                                        FPoint tempPoint3(0,0, x2mid, y2mid, nextItem->nextInChain()->rotation(), 1, 1);
                                                                        x2mid=tempPoint3.x();
                                                                        y2mid=tempPoint3.y();
                                                                }

                                                                if (x22<x11) { a1 = x11; a2 = x22; }
                                                                if (x21>x12) { a1 = x12; a2 = x21; }
                                                                if (y22<y11) { b1 = y11; b2 = y22; }
                                                                if (y21>y12) { b1 = y12; b2 = y21; }

                                                                if (x21<x12 && x21>x11) { a1 = x1mid; a2 = x2mid; }
                                                                if (x21<x11 && x22>x11) { a1 = x1mid; a2 = x2mid; }

                                                                if (y21<y12 && y21>y11) { b1 = y1mid; b2 = y2mid; }
                                                                if (y21<y11 && y22>y11) { b1 = y1mid; b2 = y2mid; }

                                                        }
                                                        //Draw the link frame lines
                                                        FPoint Start(a1-nextItem->xPos(), b1-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
                                                        //FPoint Start = transformPoint(FPoint(nextItem->Width/2, nextItem->Height), nextItem->xPos(), nextItem->yPos(), nextItem->Rot, 1, 1);
                                                        nextItem = nextItem->nextInChain();
                                                        if (nextItem != NULL)
                                                        {
                                                                FPoint End(a2-nextItem->xPos(), b2-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
                                                                drawLinkFrameLine(painter, Start, End);
                                                        }
                                                }
                                        }
                                }
                                else
                                {
                                        while (nextItem != 0)
                                        {
                                                if (nextItem->prevInChain() != 0)
                                                        nextItem = nextItem->prevInChain();
                                                else
                                                        break;
                                        }
                                        while (nextItem != 0)
                                        {
                                                FPoint Start(nextItem->width()/2, nextItem->height(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
                                                nextItem = nextItem->nextInChain();
                                                //Draw the link frame indicator for a new link
                                                //CB unsure if we need to do this
                                                if (nextItem != 0)
                                                {
                                                        FPoint End(nextItem->width()/2, 0, nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
                                                        drawLinkFrameLine(painter, Start, End);
                                                }
                                        }
                                }
                        }
                        painter->setLineWidth(1);
                        painter->setPenOpacity(1.0);
                        painter->restore();
#ifndef HAVE_CAIRO
                        painter->setZoomFactor(z);
#endif
                }
                painter->end();
#ifdef HAVE_CAIRO
                psx->drawImage(clipx, clipy, img);
#endif
                delete painter;
                painter=NULL;
        }
        if (Doc->m_Selection->count() != 0)
        {
                PageItem *currItem = Doc->m_Selection->itemAt(0);
                currItem->paintObj();
                if ((Doc->EditClip) && (currItem->isSelected()))
                {
                if (EditContour)
                        MarkClip(currItem, currItem->ContourLine, true);
                else
                        MarkClip(currItem, currItem->PoLine, true);
                }
                if (Doc->m_Selection->isMultipleSelection())
                {
                        Doc->m_Selection->setGroupRect();
                        paintGroupRect();
                }
        }
        if (Doc->appMode == modeEdit)
                slotDoCurs(true);
        if (Doc->appMode == modeEditGradientVectors)
        {
                PageItem *currItem = Doc->m_Selection->itemAt(0);
                QPainter p;
                p.begin(viewport());
                ToView(&p);
                Transform(currItem, &p);
                p.setPen(QPen(blue, 1, SolidLine, FlatCap, MiterJoin));
                p.setBrush(NoBrush);
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
                p.setPen(QPen(magenta, 8, SolidLine, RoundCap, MiterJoin));
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)));
                p.drawLine(QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
                p.end();
        }
        evSpon = false;
        forceRedraw = false;
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
}

void ScribusView::DrawMasterItems(ScPainter *painter, Page *page, QRect clip)
{
        QRect oldR;
        QPtrStack<PageItem> groupStack;
        QPtrStack<PageItem> groupStack2;
#ifndef HAVE_CAIRO
        double z = painter->zoomFactor();
#endif
        if (!page->MPageNam.isEmpty())
        {
                Page* Mp = Doc->MasterPages.at(Doc->MasterNames[page->MPageNam]);
                if (page->FromMaster.count() != 0)
                {
                        int Lnr;
                        struct Layer ll;
                        PageItem *currItem;
                        ll.isViewable = false;
                        ll.LNr = 0;
                        Lnr = 0;
                        uint layerCount=Doc->layerCount();
                        for (uint la = 0; la < layerCount; ++la)
                        {
                                Level2Layer(Doc, &ll, Lnr);
                                bool pr = true;
                                if ((previewMode) && (!ll.isPrintable))
                                        pr = false;
                                if ((viewAsPreview) && (!ll.isPrintable))
                                        pr = false;
                                if ((ll.isViewable) && (pr))
                                {
#ifdef HAVE_CAIRO
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
                                                painter->beginLayer(ll.transparency, ll.blendMode);
#endif
                                        uint pageFromMasterCount=page->FromMaster.count();
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
                                        {
                                                currItem = page->FromMaster.at(a);
                                                if (currItem->LayerNr != ll.LNr)
                                                        continue;
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
                                                        continue;
                                                if ((previewMode) && (!currItem->printEnabled()))
                                                        continue;
                                                if ((viewAsPreview) && (!currItem->printEnabled()))
                                                        continue;
                                                double OldX = currItem->xPos();
                                                double OldY = currItem->yPos();
                                                double OldBX = currItem->BoundingX;
                                                double OldBY = currItem->BoundingY;
                                                if (!currItem->ChangedMasterItem)
                                                {
                                                        //Hack to not check for undo changes, indicate drawing only
                                                        currItem->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
                                                }
                                                oldR = currItem->getRedrawBounding(Scale);
                                                if (currItem->isGroupControl)
                                                {
                                                        painter->save();
                                                        currItem->savedOwnPage = currItem->OwnPage;
                                                        currItem->OwnPage = page->pageNr();
                                                        if ((clip.intersects(oldR)) && (Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1))
                                                                currItem->DrawObj(painter, clip);
#ifdef HAVE_CAIRO
                                                        FPointArray cl = currItem->PoLine.copy();
                                                        QWMatrix mm;
                                                        mm.translate(currItem->xPos(), currItem->yPos());
                                                        mm.rotate(currItem->rotation());
                                                        cl.map( mm );
                                                        painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode(), &cl);
#endif
                                                        groupStack.push(currItem->groupsLastItem);
                                                        groupStack2.push(currItem);
                                                        currItem->OwnPage = currItem->savedOwnPage;
                                                        if (!currItem->ChangedMasterItem)
                                                        {
                                                                //Hack to not check for undo changes, indicate drawing only
                                                                currItem->setXYPos(OldX, OldY, true);
                                                                currItem->BoundingX = OldBX;
                                                                currItem->BoundingY = OldBY;
                                                        }
                                                        continue;
                                                }
                                                currItem->savedOwnPage = currItem->OwnPage;
                                                currItem->OwnPage = page->pageNr();
                                                if (!evSpon || forceRedraw)
                                                        currItem->invalid = true;
                                                if (clip.intersects(oldR))
                                                        currItem->DrawObj(painter, clip);
                                                currItem->OwnPage = currItem->savedOwnPage;
                                                if (!currItem->ChangedMasterItem)
                                                {
                                                        //Hack to not check for undo changes, indicate drawing only
                                                        currItem->setXYPos(OldX, OldY, true);
                                                        currItem->BoundingX = OldBX;
                                                        currItem->BoundingY = OldBY;
                                                }
                                                if (groupStack.count() != 0)
                                                {
                                                        while (currItem == groupStack.top())
                                                        {
#ifdef HAVE_CAIRO
                                                                painter->endLayer();
#endif
                                                                painter->restore();
                                                                PageItem *cite = groupStack2.pop();
                                                                double OldX = cite->xPos();
                                                                double OldY = cite->yPos();
                                                                double OldBX = cite->BoundingX;
                                                                double OldBY = cite->BoundingY;
                                                                if (!cite->ChangedMasterItem)
                                                                {
                                                                        //Hack to not check for undo changes, indicate drawing only
                                                                        cite->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
                                                                        cite->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
                                                                        cite->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
                                                                }
                                                                oldR = cite->getRedrawBounding(Scale);
                                                                if ((clip.intersects(oldR)) && (Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1))
                                                                        cite->DrawObj(painter, clip);
                                                                cite->OwnPage = cite->savedOwnPage;
                                                                if (!currItem->ChangedMasterItem)
                                                                {
                                                                        //Hack to not check for undo changes, indicate drawing only
                                                                        cite->setXYPos(OldX, OldY, true);
                                                                        cite->BoundingX = OldBX;
                                                                        cite->BoundingY = OldBY;
                                                                }
                                                                groupStack.pop();
                                                        }
                                                }
                                        }
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
                                        {
                                                currItem = page->FromMaster.at(a);
                                                if (currItem->LayerNr != ll.LNr)
                                                        continue;
                                                if (!currItem->isTableItem)
                                                        continue;
                                                if ((previewMode) && (!currItem->printEnabled()))
                                                        continue;
                                                if ((viewAsPreview) && (!currItem->printEnabled()))
                                                        continue;
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
                                                        continue;
                                                if (currItem->isGroupControl)
                                                        continue;
                                                double OldX = currItem->xPos();
                                                double OldY = currItem->yPos();
                                                double OldBX = currItem->BoundingX;
                                                double OldBY = currItem->BoundingY;
                                                if (!currItem->ChangedMasterItem)
                                                {
                                                        //Hack to not check for undo changes, indicate drawing only
                                                        currItem->setXYPos(OldX - Mp->xOffset() + page->xOffset(), OldY - Mp->yOffset() + page->yOffset(), true);
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
                                                }
                                                oldR = currItem->getRedrawBounding(Scale);
                                                if (clip.intersects(oldR))
                                                {
#ifdef HAVE_CAIRO
                                                        painter->save();
                                                        painter->translate(currItem->xPos(), currItem->yPos());
#else
                                                        painter->setZoomFactor(Scale);
                                                        painter->save();
                                                        painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
#endif
                                                        painter->rotate(currItem->rotation());
                                                        if ((currItem->lineColor() != CommonStrings::None) && (currItem->lineWidth() != 0.0))
                                                        {
                                                                QColor tmp;
                                                                currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
                                                                if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
                                                                {
                                                                        painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
                                                                        if (currItem->TopLine)
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
                                                                        if (currItem->RightLine)
                                                                                painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
                                                                        if (currItem->BottomLine)
                                                                                painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
                                                                        if (currItem->LeftLine)
                                                                                painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
                                                                }
                                                        }
                                                        painter->restore();
                                                }
                                                if (!currItem->ChangedMasterItem)
                                                {
                                                        //Hack to not check for undo changes, indicate drawing only
                                                        currItem->setXYPos(OldX, OldY, true);
                                                        currItem->BoundingX = OldBX;
                                                        currItem->BoundingY = OldBY;
                                                }
                                        }
#ifdef HAVE_CAIRO
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
                                                painter->endLayer();
#endif
                                }
                                Lnr++;
                        }
                }
        }
#ifndef HAVE_CAIRO
        painter->setZoomFactor(z);
#endif
}

void ScribusView::DrawPageItems(ScPainter *painter, QRect clip)
{
        linkedFramesToShow.clear();
#ifndef HAVE_CAIRO
        double z = painter->zoomFactor();
#endif
        QRect oldR;
        QPtrStack<PageItem> groupStack;
        QPtrStack<PageItem> groupStack2;
        if (Doc->Items->count() != 0)
        {
                int Lnr=0;
                struct Layer ll;
                PageItem *currItem;
                ll.isViewable = false;
                ll.LNr = 0;
                uint layerCount=Doc->layerCount();
                int docCurrPageNo=static_cast<int>(Doc->currentPageNumber());
                for (uint la2 = 0; la2 < layerCount; ++la2)
                {
                        Level2Layer(Doc, &ll, Lnr);
                        bool pr = true;
                        if ((previewMode) && (!ll.isPrintable))
                                pr = false;
                        if ((viewAsPreview) && (!ll.isPrintable))
                                pr = false;
                        if ((ll.isViewable) && (pr))
                        {
#ifdef HAVE_CAIRO
                                if ((layerCount > 1) || (ll.transparency != 1.0))
                                        painter->beginLayer(ll.transparency, ll.blendMode);
#endif
                                QPtrListIterator<PageItem> docItem(*Doc->Items);
                                while ( (currItem = docItem.current()) != 0)
                                {
                                        ++docItem;
                                        if (currItem->LayerNr != ll.LNr)
                                                continue;
                                        if ((previewMode) && (!currItem->printEnabled()))
                                                continue;
                                        if ((viewAsPreview) && (!currItem->printEnabled()))
                                                continue;
                                        if ((Doc->masterPageMode()) && ((currItem->OwnPage != -1) && (currItem->OwnPage != docCurrPageNo)))
                                                continue;
                                        if (!Doc->masterPageMode() && !currItem->OnMasterPage.isEmpty())
                                        {
                                                if (currItem->OnMasterPage != Doc->currentPage()->pageName())
                                                        continue;
                                        }
                                        oldR = currItem->getRedrawBounding(Scale);
                                        if (currItem->isGroupControl)
                                        {
                                                painter->save();
#ifdef HAVE_CAIRO
                                                FPointArray cl = currItem->PoLine.copy();
                                                QWMatrix mm;
                                                mm.translate(currItem->xPos(), currItem->yPos());
                                                mm.rotate(currItem->rotation());
                                                cl.map( mm );
                                                painter->beginLayer(1.0 - currItem->fillTransparency(), currItem->fillBlendmode(), &cl);
#endif
                                                groupStack.push(currItem->groupsLastItem);
                                                groupStack2.push(currItem);
                                                continue;
                                        }
                                        if (clip.intersects(oldR))
                                        {
                                                if (!evSpon || forceRedraw)
                                                        currItem->invalid = true;
//                                              if ((!m_MouseButtonPressed) || (Doc->EditClip))
                                                currItem->DrawObj(painter, clip);
//                                              currItem->Redrawn = true;
                                                if ((currItem->asTextFrame()) && ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0)))
                                                {
                                                        PageItem *nextItem = currItem;
                                                        while (nextItem != 0)
                                                        {
                                                                if (nextItem->prevInChain() != 0)
                                                                        nextItem = nextItem->prevInChain();
                                                                else
                                                                        break;
                                                        }
                                                        if (linkedFramesToShow.find(nextItem) == -1)
                                                                linkedFramesToShow.append(nextItem);
                                                }
                                                if ((Doc->appMode == modeEdit) && (currItem->isSelected()) && (currItem->itemType() == PageItem::TextFrame))
                                                {
                                                        //CB 230305 Stop redrawing the horizontal ruler if it hasnt changed when typing text!!!
                                                        if ((qRound(horizRuler->ItemPos*10000) != qRound((currItem->xPos())*10000)) || (qRound(horizRuler->ItemEndPos*10000) != qRound(((currItem->xPos()+currItem->width()) )*10000)))
                                                        {
                                                                horizRuler->setItem(currItem);
                                                                if (currItem->lineColor() != CommonStrings::None)
                                                                        horizRuler->lineCorr = currItem->lineWidth() / 2.0;
                                                                else
                                                                        horizRuler->lineCorr = 0;
                                                                horizRuler->ColGap = currItem->ColGap;
                                                                horizRuler->Cols = currItem->Cols;
                                                                horizRuler->Extra = currItem->textToFrameDistLeft();
                                                                horizRuler->RExtra = currItem->textToFrameDistRight();
                                                                horizRuler->First = currItem->currentStyle().firstIndent();
                                                                horizRuler->Indent = currItem->currentStyle().leftMargin();
                                                                double columnWidth = (currItem->width() - (currItem->columnGap() * (currItem->columns() - 1))
                                                                        - currItem->textToFrameDistLeft() - currItem->textToFrameDistLeft()
                                                                        - 2*horizRuler->lineCorr) / currItem->columns();
                                                                horizRuler->RMargin = columnWidth - currItem->currentStyle().rightMargin();
                                                                if (currItem->imageFlippedH() || (currItem->reversed()))
                                                                        horizRuler->Revers = true;
                                                                else
                                                                        horizRuler->Revers = false;
                                                                horizRuler->ItemPosValid = true;
                                                                horizRuler->TabValues = currItem->currentStyle().tabValues();
                                                                horizRuler->repaint();
                                                        }
                                                }
                                        }
                                        if (groupStack.count() != 0)
                                        {
                                                while (currItem == groupStack.top())
                                                {
#ifdef HAVE_CAIRO
                                                        painter->endLayer();
#endif
                                                        painter->restore();
                                                        PageItem *cite = groupStack2.pop();
                                                        oldR = cite->getRedrawBounding(Scale);
                                                        if ((clip.intersects(oldR)) && (Doc->guidesSettings.layerMarkersShown) && (Doc->layerCount() > 1))
                                                                cite->DrawObj(painter, clip);
                                                        groupStack.pop();
                                                }
                                        }
                                }
                                QPtrListIterator<PageItem> docItem2(*Doc->Items);
                                while ( (currItem = docItem2.current()) != 0 )
                                {
                                        ++docItem2;
                                        if (currItem->LayerNr != ll.LNr)
                                                continue;
                                        if (!currItem->isTableItem)
                                                continue;
                                        if ((previewMode) && (!currItem->printEnabled()))
                                                continue;
                                        if ((viewAsPreview) && (!currItem->printEnabled()))
                                                continue;
                                        oldR = currItem->getRedrawBounding(Scale);
                                        if (clip.intersects(oldR))
                                        {
#ifdef HAVE_CAIRO
                                                painter->save();
                                                painter->translate(currItem->xPos(), currItem->yPos());
#else
                                                painter->setZoomFactor(Scale);
                                                painter->save();
                                                painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
#endif
                                                painter->rotate(currItem->rotation());
                                                if ((currItem->lineColor() != CommonStrings::None) && (currItem->lineWidth() != 0.0))
                                                {
                                                        QColor tmp;
                                                        currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
                                                        if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
                                                        {
                                                                painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
                                                                if (currItem->TopLine)
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
                                                                if (currItem->RightLine)
                                                                        painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
                                                                if (currItem->BottomLine)
                                                                        painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
                                                                if (currItem->LeftLine)
                                                                        painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
                                                        }
                                                }
                                                painter->restore();
                                        }
                                }
#ifdef HAVE_CAIRO
                                if ((layerCount > 1) || (ll.transparency != 1.0))
                                        painter->endLayer();
#endif
                        }
                        Lnr++;
                }
        }
#ifndef HAVE_CAIRO
        painter->setZoomFactor(z);
#endif
}

void ScribusView::DrawPageMarks(ScPainter *p, Page *page, QRect clip)
{
        p->save();
#ifdef HAVE_CAIRO
        p->setAntialiasing(false);
        p->translate(page->xOffset(), page->yOffset());
        double lineWidth = 1.0 / Scale;
#else
        double z = p->zoomFactor();
        p->setZoomFactor(Scale);
        p->translate(page->xOffset() * Scale, page->yOffset() * Scale);
        double lineWidth = 0.5 / Scale;
#endif
        double pageHeight=page->height();
        double pageWidth=page->width();
        p->setFillMode(ScPainter::None);
        p->setPen(black, lineWidth, SolidLine, FlatCap, MiterJoin);
        p->drawRect(0, 0, pageWidth, pageHeight);
        //Draw the margins
        if (Doc->guidesSettings.marginsShown)
        {
                p->setPen(Doc->guidesSettings.margColor);
                if (Doc->marginColored)
                {
                        p->setBrush(Doc->guidesSettings.margColor);
                        p->drawRect(0, 0, pageWidth, page->Margins.Top);
                        p->drawRect(0, page->Margins.Top, page->Margins.Left, pageHeight - page->Margins.Top);
                        p->drawRect(page->Margins.Left, pageHeight - page->Margins.Bottom, pageWidth - page->Margins.Right - page->Margins.Left, page->Margins.Bottom);
                        p->drawRect(pageWidth - page->Margins.Right, page->Margins.Top, page->Margins.Right, pageHeight-page->Margins.Top);
                }
//              p->setPen(Doc->guidesSettings.margColor);
                p->setFillMode(ScPainter::None);
                p->drawRect(page->Margins.Left, page->Margins.Top, pageWidth - page->Margins.Left - page->Margins.Right, pageHeight - page->Margins.Top - page->Margins.Bottom);
//              p->drawLine(FPoint(0, page->Margins.Top), FPoint(pageWidth, page->Margins.Top));
//              p->drawLine(FPoint(0, pageHeight - page->Margins.Bottom), FPoint(pageWidth, pageHeight - page->Margins.Bottom));
//              p->drawLine(FPoint(page->Margins.Left, 0), FPoint(page->Margins.Left, pageHeight));
//              p->drawLine(FPoint(pageWidth - page->Margins.Right, 0), FPoint(pageWidth - page->Margins.Right, pageHeight));
        }
        //Draw the baseline grid
        if (Doc->guidesSettings.baseShown)
        {
                p->setPen(Doc->guidesSettings.baseColor, lineWidth, SolidLine, FlatCap, MiterJoin);
                for (double yg = Doc->typographicSettings.offsetBaseGrid; yg < pageHeight; yg += Doc->typographicSettings.valueBaseGrid)
                        p->drawLine(FPoint(0, yg), FPoint(pageWidth, yg));
        }
        //Draw the grid lines
        if (Doc->guidesSettings.gridShown)
        {
                double lowerBx = QMAX(clip.x() / Scale + Doc->minCanvasCoordinate.x() - page->xOffset(), 0);
                double lowerBy = QMAX(clip.y() / Scale + Doc->minCanvasCoordinate.y() - page->yOffset(), 0);
                double highBx = QMIN(lowerBx + clip.width() / Scale, pageWidth);
                double highBy = QMIN(lowerBy + clip.height() / Scale, pageHeight);
                if (Scale > 0.49)
                {
                        double i,start;
                        i = Doc->guidesSettings.majorGrid;
                        p->setPen(Doc->guidesSettings.majorColor, lineWidth, SolidLine, FlatCap, MiterJoin);
                        start=floor(lowerBy/i);
                        start*=i;
                        for (double b = start; b <= highBy; b+=i)
                        {
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
                        }
                        start=floor(lowerBx/i);
                        start*=i;
                        for (double b = start; b <= highBx; b+=i)
                        {
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
                        }
                        i = Doc->guidesSettings.minorGrid;
                        p->setPen(Doc->guidesSettings.minorColor, lineWidth, DotLine, FlatCap, MiterJoin);
                        start=floor(lowerBy/i);
                        start*=i;
                        for (double b = start; b <= highBy; b+=i)
                        {
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
                        }
                        start=floor(lowerBx/i);
                        start*=i;
                        for (double b = start; b <= highBx; b+=i)
                        {
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
                        }
                }
        }
        //Draw the guides
        if (Doc->guidesSettings.guidesShown)
                page->guides.drawPage(p, Doc, lineWidth);
        if (Doc->currentPage() == page)
        {
#ifdef HAVE_CAIRO
                p->setPen(Prefs->DPageBorderColor, 2 / Scale, SolidLine, FlatCap, MiterJoin);
#else
                p->setPen(Prefs->DPageBorderColor, 2, SolidLine, FlatCap, MiterJoin);
#endif
                p->drawRect(0, 0, pageWidth, pageHeight);
        }

#ifdef HAVE_CAIRO
        p->setAntialiasing(true);
#endif

        p->restore();
#ifndef HAVE_CAIRO
        p->setZoomFactor(z);
#endif
}

void ScribusView::enterEvent(QEvent *)
{
        if (!m_MouseButtonPressed)
        {
                switch (Doc->appMode)
                {
                        case modeDrawShapes:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawFrame.xpm")), true);
                                break;
                        case modeDrawPicture:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawImageFrame.xpm")), true);
                                break;
                        case modeDrawText:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawTextFrame.xpm")), true);
                                break;
                        case modeDrawTable:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawTable.xpm")), true);
                                break;
                        case modeDrawRegularPolygon:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawPolylineFrame.xpm")), true);
                                break;
                        case modeDrawLine:
                        case modeDrawBezierLine:
                                qApp->setOverrideCursor(QCursor(crossCursor), true);
                                break;
                        case modeDrawFreehandLine:
                                qApp->setOverrideCursor(QCursor(loadIcon("DrawFreeLine.png"), 0, 32), true);
                                break;
                        case modeMagnifier:
                                if (Magnify)
                                        qApp->setOverrideCursor(QCursor(loadIcon("LupeZ.xpm")), true);
                                else
                                        qApp->setOverrideCursor(QCursor(loadIcon("LupeZm.xpm")), true);
                                break;
                        case modePanning:
                                qApp->setOverrideCursor(QCursor(loadIcon("HandC.xpm")), true);
                                break;
                        case modeMeasurementTool:
                        case modeEditGradientVectors:
                                qApp->setOverrideCursor(QCursor(CrossCursor), true);
                                break;
                        default:
                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        break;
                }
        }
}

void ScribusView::leaveEvent(QEvent *)
{
/*      if (BlockLeave)
                return; */

        if (!m_MouseButtonPressed)
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
/*      else
        {
                if ((SelItem.count() != 0) && (m_MouseButtonPressed) && (!doku->DragP) && (doku->appMode == 1))
                {
                        PageItem *currItem = SelItem.at(0);
                        if ((b->Locked) || (b->Sizing))
                                return;
                        doku->DragP = true;
                        doku->leaveDrag = true;
                        doku->DraggedElem = b;
                        doku->DragElements.clear();
                        for (uint dre=0; dre<SelItem.count(); ++dre)
                                doku->DragElements.append(SelItem.at(dre)->ItemNr);
                        ScriXmlDoc *ss = new ScriXmlDoc();
                        QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
                        dr->setPixmap(loadIcon("DragPix.xpm"));
                        dr->drag();
                        delete ss;
                        ss=NULL;
                        doku->DragP = false;
                        doku->leaveDrag = false;
                        m_MouseButtonPressed = false;
                        doku->DraggedElem = 0;
                        doku->DragElements.clear();
                }
        } */

}

void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
{
        QString text;
        e->accept(QTextDrag::canDecode(e));
        if (QTextDrag::decode(e, text))
        {
                double gx, gy, gw, gh;
                /*<< #3524
                setActiveWindow();
                raise();
                m_ScMW->newActWin(Doc->WinHan);
                updateContents();
                >>*/

//              SeleItemPos(e->pos());
                QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                ScriXmlDoc *ss = new ScriXmlDoc();
                if (fi.exists())
                        text = ur.path();
                if(ss->ReadElemHeader(text,fi.exists(), &gx, &gy, &gw, &gh))
                {
                        dragX = e->pos().x() / Scale;
                        dragY = e->pos().y() / Scale;
                        dragW = gw;
                        dragH = gh;
                        DraggedGroup = true;
                        DraggedGroupFirst = true;
                        //GroupSel = false;
                        QPainter p;
                        p.begin(viewport());
                        PaintSizeRect(&p, QRect());
                        emit ItemGeom(gw, gh);
//                      QPoint pv = QPoint(qRound(gx), qRound(gy));
//                      PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
                        p.end();
                }
                delete ss;
                ss=NULL;
        }
}

void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
{
        QString text;
//      PageItem *currItem;
//      bool img;
        e->accept(QTextDrag::canDecode(e));
        if (QTextDrag::decode(e, text))
        {
                if (DraggedGroup)
                {
                        double gx, gy, gw, gh;
                        dragX = e->pos().x() / Scale;
                        dragY = e->pos().y() / Scale;
                        getDragRectScreen(&gx, &gy, &gw, &gh);
                        QPainter p;
                        p.begin(viewport());
                        gx += Doc->minCanvasCoordinate.x();
                        gy += Doc->minCanvasCoordinate.y();
                        QPoint pv = QPoint(qRound(gx), qRound(gy));
                        if (!DraggedGroupFirst)
                                PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
                        DraggedGroupFirst = false;
                        p.end();
                        emit MousePos(dragX+Doc->minCanvasCoordinate.x(), dragY+Doc->minCanvasCoordinate.y());
                        horizRuler->Draw(e->pos().x());
                        vertRuler->Draw(e->pos().y());
                        return;
                }
/*              QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                QString ext = fi.extension(false).upper();
                QStrList imfo = QImageIO::inputFormats();
                if (ext == "JPG")
                        ext = "JPEG";
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
                if (!SeleItemPos(e->pos()))
                {
                        if (SelItem.count() != 0)
                                Deselect(true);
                }
                else
                {
                        b = SelItem.at(0);
                        if (img)
                        {
                                if (b->PType != 2)
                                        Deselect(true);
                        }
                        else
                        {
                                if (b->PType != 4)
                                        Deselect(true);
                        }
                } */

        }
}

void ScribusView::contentsDragLeaveEvent(QDragLeaveEvent *)
{
        if (DraggedGroup)
        {
                updateContents();
                DraggedGroup = false;
                DraggedGroupFirst = false;
        }
}

void ScribusView::contentsDropEvent(QDropEvent *e)
{
        QString text;
        PageItem *currItem;
        bool img = false;
//      struct ScText *hg;
//      uint a;
        int re = 0;
        e->accept(QTextDrag::canDecode(e));
        DraggedGroupFirst = false;
        int ex = qRound(e->pos().x()/Scale + Doc->minCanvasCoordinate.x());
        int ey = qRound(e->pos().y()/Scale + Doc->minCanvasCoordinate.y());
        if (QTextDrag::decode(e, text))
        {
                //<<#3524
                setActiveWindow();
                raise();
                m_ScMW->newActWin(Doc->WinHan);
                updateContents();
                //>>
                QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                QString ext = fi.extension(false).upper();
                QStrList imfo = QImageIO::inputFormats();
                if (ext == "JPG")
                        ext = "JPEG";
                //CB Need to handle this ugly file extension list elsewhere... some capabilities class perhaps
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="PDF")||(ext=="TIF")||(ext=="TIFF")||(ext=="PSD"));
                bool selectedItemByDrag=false;
                int pscx=qRound(e->pos().x()/Scale), pscy=qRound(e->pos().y()/Scale);
                //Loop through all items and see which one(s) were under the drop point on the current layer
                //Should make a nice function for this.
                for (uint i=0; i<Doc->Items->count(); ++i)
                {
                        if (Doc->Items->at(i)->LayerNr==Doc->activeLayer())
                        {
                                if (Doc->Items->at(i)->pointWithinItem(pscx, pscy))
                                {
                                        Deselect(false);
                                        SelectItem(Doc->Items->at(i));
                                        selectedItemByDrag=true;
                                        break;
                                }
                        }
                }
                //CB When we drag an image to a page from outside
                //SeleItemPos is from 1.2.x. Needs reenabling for dragging *TO* a frame
                if ((fi.exists()) && (img) && !selectedItemByDrag)// && (!SeleItemPos(e->pos())))
                {
                        int z = Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, ex, ey, 1, 1, 1, Doc->toolSettings.dBrushPict, CommonStrings::None, true);
                        PageItem *b = Doc->Items->at(z);
                        Doc->LoadPict(ur.path(), b->ItemNr);
                        b->setWidth(static_cast<double>(b->OrigW * 72.0 / b->pixm.imgInfo.xres));
                        b->setHeight(static_cast<double>(b->OrigH * 72.0 / b->pixm.imgInfo.yres));
                        b->OldB2 = b->width();
                        b->OldH2 = b->height();
                        b->updateClip();
                        emit DocChanged();
                        update();
                        return;
                }
                //if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
                if (Doc->m_Selection->count()>0 && Doc->m_Selection->itemAt(0)->pointWithinItem(pscx, pscy) && (!text.startsWith("<SCRIBUSELEM")))
                {
                        PageItem *b = Doc->m_Selection->itemAt(0);
                        if (b->itemType() == PageItem::ImageFrame)
                        {
                                if ((fi.exists()) && (img))
                                {
                                        Doc->LoadPict(ur.path(), b->ItemNr);
                                        update();
                                }
                        }
                        /* CB leaving this out for now...
                        if (b->PType == 4)
                        {
                                if ((b->BackBox != 0) && (b->itemText.count() == 0))
                                        return;
                                if ((fi.exists()) && (!img) && (fi.size() < 500000))
                                {
                                        Serializer *ss = new Serializer(ur.path());
                                        if (ss->Read())
                                        {
                                                int st = doku->currentParaStyle;
                                                ss->GetText(b, st, doku->docParagraphStyles[st].Font, doku->docParagraphStyles[st].FontSize, true);
                                                emit DocChanged();
                                        }
                                        delete ss;
                                        ss=NULL;
                                        update();
                                }
                                else
                                {
                                        slotDoCurs(false);
                                        slotSetCurs(e->pos().x(), e->pos().y());
                                        if (text.startsWith("<SCRIBUSELEM"))
                                                return;
                                        for (a=0; a<text.length(); ++a)
                                        {
                                                hg = new ScText;
                                                hg->ch = text.at(a);
                                                if (hg->ch == QChar(10))
                                                        hg->ch = QChar(13);
                                                if (hg->ch == QChar(4))
                                                        hg->ch = QChar(9);
                                                if (hg->ch == QChar(5))
                                                        hg->ch = QChar(13);
                                                hg->cfont = b->IFont;
                                                hg->csize = b->ISize;
                                                hg->ccolor = b->TxtFill;
                                                hg->cshade = b->ShTxtFill;
                                                hg->cstroke = b->TxtStroke;
                                                hg->cshade2 = b->ShTxtStroke;
                                                hg->cselect = false;
                                                hg->cscale = b->TxtScale;
                                                hg->cextra = 0;
                                                hg->cstyle = 0;
                                                hg->cab = 0;
                                                hg->xp = 0;
                                                hg->yp = 0;
                                                hg->PRot = 0;
                                                hg->PtransX = 0;
                                                hg->PtransY = 0;
                                                b->itemText.insert(b->CPos, hg);
                                                b->CPos += 1;
                                        }
                                        emit DocChanged();
                                        update();
                                }
                        }*/

                }
                else
                {
                        for (uint as = 0; as < Doc->Items->count(); ++as)
                        {
                                Doc->Items->at(as)->setSelected(false);
                        }
                        uint oldDocItemCount = Doc->Items->count();
                        if ((!img) && (Doc->DraggedElem == 0))
                        {
                                undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Create,"",Um::ICreate);
                                if ((fi.exists()) && (!img))
                                {
                                        QString data;
                                        if (fi.extension(true).lower() == "sml")
                                        {
                                                QString f = "";
                                                loadText(ur.path(), &f);
                                                StencilReader *pre = new StencilReader();
                                                data = pre->createObjects(f);
                                                delete pre;
                                                emit LoadElem(data, ex, ey, false, false, Doc, this);
                                        }
/*                                      else if (fi.extension(true).lower() == "shape")
                                        {
                                                QString f = "";
                                                loadText(ur.path(), &f);
                                                StencilReader *pre = new StencilReader();
                                                data = pre->createShape(f);
                                                delete pre;
                                                emit LoadElem(data, ex, ey, false, false, Doc, this);
                                        } */

                                        else
                                                emit LoadElem(ur.path(), ex, ey, true, false, Doc, this);
                                }
                                else
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
                                Doc->m_Selection->clear();
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                {
                                        currItem = Doc->Items->at(as);
                                        Doc->setRedrawBounding(currItem);
                                        Doc->m_Selection->addItem(currItem, true);
                                        if (currItem->isBookmark)
                                                emit AddBM(currItem);
                                }
                                undoManager->commit();
                        }
                        else
                        {
                                if (Doc->DraggedElem != 0)
                                {
                                        if (!Doc->leaveDrag)
                                        {
                                                QPopupMenu *pmen = new QPopupMenu();
                                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                                                pmen->insertItem( tr("Copy Here"));
                                                int mov = pmen->insertItem( tr("Move Here"));
                                                pmen->insertItem( tr("Cancel"));
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        if (Doc->Items->at(Doc->DragElements[dre])->locked())
                                                        {
                                                                pmen->setItemEnabled(mov, false);
                                                                break;
                                                        }
                                                }
                                                re = pmen->indexOf(pmen->exec(QCursor::pos()));
                                                delete pmen;
                                                pmen=NULL;
                                        }
                                        else
                                                re = 1;
                                        if ((re == 2) || (re == -1))
                                        {
                                                updateContents();
                                                return;
                                        }
                                        if ((re == 1) || (Doc->leaveDrag))
                                        {
                                                QPtrList<PageItem> pasted;
                                                emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
                                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                                {
                                                        pasted.append(Doc->Items->at(as));
                                                }
                                                Doc->m_Selection->clear();
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        Doc->m_Selection->addItem(Doc->Items->at(Doc->DragElements[dre]), true);
                                                }
                                                PageItem* bb;
                                                int fin;
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        bb = pasted.at(dre);
                                                        currItem = Doc->m_Selection->itemAt(dre);
                                                        if ((currItem->asTextFrame()) && ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0)))
                                                        {
                                                                PageItem* before = currItem->prevInChain();
                                                                PageItem* after = currItem->nextInChain();
                                                                currItem->unlink();
                                                                if (before != 0)
                                                                {
                                                                        fin = Doc->m_Selection->findItem(before);
                                                                        if (fin != -1)
                                                                                before = pasted.at(fin);
                                                                        before->unlink();
                                                                        before->link(bb);
                                                                }
                                                                if (after != 0)
                                                                {
                                                                        fin = Doc->m_Selection->findItem(after);
                                                                        if (fin != -1)
                                                                                after = pasted.at(fin);                                                                
                                                                        bb->link(after);
                                                                }
                                                        }
                                                }
/*                                              for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        currItem = Doc->m_Selection->itemAt(dre);
                                                        currItem->NextBox = 0;
                                                        currItem->BackBox = 0;
                                                }
*/

                                                pasted.clear();
                                                Doc->itemSelection_DeleteItem();
                                        }
                                }
                                if ((!img) && ((re == 0)))
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
                                Doc->DraggedElem = 0;
                                Doc->DragElements.clear();
                                Doc->m_Selection->clear();
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                {
                                        currItem = Doc->Items->at(as);
                                        Doc->setRedrawBounding(currItem);
                                        Doc->m_Selection->addItem(currItem, true);
                                        if (currItem->isBookmark)
                                                emit AddBM(currItem);
                                }
                        }
                        if (Doc->m_Selection->count() > 1)
                        {
                                Doc->m_Selection->connectItemToGUI();
                                Doc->m_Selection->setGroupRect();
                                double gx, gy, gh, gw;
                                Doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
                                double nx = gx;
                                double ny = gy;
                                if (!Doc->ApplyGuides(&nx, &ny))
                                {
                                        FPoint npx;
                                        npx = Doc->ApplyGridF(FPoint(nx, ny));
                                        nx = npx.x();
                                        ny = npx.y();
                                }
                                moveGroup(nx-gx, ny-gy, false);
                                Doc->m_Selection->setGroupRect();
                                Doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
                                nx = gx+gw;
                                ny = gy+gh;
                                Doc->ApplyGuides(&nx, &ny);
                                moveGroup(nx-(gx+gw), ny-(gy+gh), false);
                                Doc->m_Selection->setGroupRect();
                                Doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
                                for (uint a = 0; a < Doc->m_Selection->count(); ++a)
                                {
                                        PageItem *currItem = Doc->m_Selection->itemAt(a);
                                        currItem->gXpos = currItem->xPos() - gx;
                                        currItem->gYpos = currItem->yPos() - gy;
                                        currItem->gWidth = gw;
                                        currItem->gHeight = gh;
                                }
                                emit ItemPos(gx, gy);
                                emit ItemGeom(gw, gh);
                        }
                        else
                        {
                                Doc->m_Selection->connectItemToGUI();
                                currItem = Doc->m_Selection->itemAt(0);
                                if (Doc->useRaster)
                                {
                                        double nx = currItem->xPos();
                                        double ny = currItem->yPos();
                                        if (!Doc->ApplyGuides(&nx, &ny))
                                        {
                                                FPoint npx;
                                                npx = Doc->ApplyGridF(FPoint(nx, ny));
                                                nx = npx.x();
                                                ny = npx.y();
                                        }
                                        Doc->MoveItem(nx-currItem->xPos(), ny-currItem->yPos(), currItem);
                                }
                        }
                        updateContents();
                }
                if (!Doc->masterPageMode())
                {
                        uint docPagesCount=Doc->Pages->count();
                        uint docCurrPageNo=Doc->currentPageNumber();
                        for (uint i = 0; i < docPagesCount; ++i)
                        {
                                int x = static_cast<int>(Doc->Pages->at(i)->xOffset());
                                int y = static_cast<int>(Doc->Pages->at(i)->yOffset());
                                int w = static_cast<int>(Doc->Pages->at(i)->width());
                                int h = static_cast<int>(Doc->Pages->at(i)->height());
                                if (QRect(x, y, w, h).contains(ex, ey))
                                {
                                        if (docCurrPageNo != i)
                                        {
                                                Doc->setCurrentPage(Doc->Pages->at(i));
                                                setMenTxt(i);
                                                DrawNew();
                                        }
                                        break;
                                }
                        }
                        setRulerPos(contentsX(), contentsY());
                }
        }
}

void ScribusView::contentsMouseDoubleClickEvent(QMouseEvent *m)
{
        m->accept();
        m_MouseButtonPressed = false;
        PageItem *currItem = 0;
        if (Doc->EditClip)
        {
                emit EndNodeEdit();
                return;
        }
        if ((Doc->m_Selection->isMultipleSelection()) || (Doc->appMode != modeNormal))
        {
                if ((Doc->m_Selection->isMultipleSelection()) && (Doc->appMode == modeNormal))
                {
                        if (GetItem(&currItem))
                        {
                                if (currItem->isTableItem)
                                {
                                        Deselect(false);
                                        Doc->m_Selection->addItem(currItem);
                                        currItem->isSingleSel = true;
                                        //CB FIXME dont call this if the added item is item 0
                                        if (!Doc->m_Selection->primarySelectionIs(currItem))
                                                currItem->emitAllToGUI();
                                        currItem->paintObj();
                                }
                        }
                        return;
                }
                else
                {
                        if (!(GetItem(&currItem) && (Doc->appMode == modeEdit) && currItem->asTextFrame()))
                        {
                                contentsMousePressEvent(m);
                                return;
                        }
                }
        }
        if (GetItem(&currItem))
        {
                if ((currItem->itemType() == PageItem::Polygon) || (currItem->itemType() == PageItem::PolyLine) || (currItem->itemType() == PageItem::ImageFrame) || (currItem->itemType() == PageItem::PathText))
                {
                        if ((currItem->locked()) || (!currItem->ScaleType))
                        {
                                contentsMousePressEvent(m);
                                return;
                        }
                        //If we double click on an image frame and theres no image assigned, open the
                        //load picture dialog, else put it into edit mode if the frame is set to show the image
                        if (currItem->itemType() == PageItem::ImageFrame)
                        {
                                if (currItem->Pfile.isEmpty())
                                        emit LoadPic();
                                else if (currItem->imageShown())
                                        emit Amode(modeEdit);
                        }
                        else
                                emit Amode(modeEdit);
                }
                else
                        if (currItem->itemType() == PageItem::TextFrame)
                        {
                                //CB old code
                                //emit currItem->isAnnotation() ? AnnotProps() : Amode(modeEdit);
                                //contentsMousePressEvent(m);
                                //CB if annotation, open the annotation dialog
                                if (currItem->isAnnotation())
                                {
                                        emit AnnotProps();
                                        contentsMousePressEvent(m);
                                }
                                //else if not in mode edit, set mode edit
                                else if (Doc->appMode != modeEdit)
                                {
                                        emit Amode(modeEdit);
                                        //CB ignore the double click and go with a single one
                                        //if we werent in mode edit before.
                                        //unsure if this is correct, but its ok given we had no
                                        //double click select until now.
                                        contentsMousePressEvent(m);
                                }
                                //otherwise, select between the whitespace
                                else
                                {       //Double click in a frame to select a word
                                        PageItem_TextFrame *cItem=currItem->asTextFrame();
                                        bool inText = slotSetCurs(m->x(), m->y());
                                        if (!inText)
                                        {
                                                Deselect(true);
                                                slotDoCurs(true);
                                                emit Amode(modeNormal);
                                                return;
                                        }
                                        int a=cItem->CPos;
                                        while(a>0)
                                        {
                                                if (cItem->itemText.text(a-1).isLetterOrNumber())
                                                        --a;
                                                else
                                                        break;
                                        }
                                        int b=cItem->CPos;
                                        while(b<cItem->itemText.length())
                                        {
                                                if (cItem->itemText.text(b).isLetterOrNumber())
                                                        ++b;
                                                else
                                                        break;
                                        }
                                        oldCp = a;
                                        cItem->CPos=b;
                                        cItem->ExpandSel(1, oldCp);
                                        slotDoCurs(true);
                                }
                        }
        }
}

void ScribusView::normalizeSelectionRect()
{
        if(Mxp > SeRx)
        {
                int tmp = SeRx;
                SeRx = Mxp;
                Mxp = tmp;
        }
        if(Myp > SeRy)
        {
                int tmp = SeRy;
                SeRy = Myp;
                Myp = tmp;
        }
}

void ScribusView::contentsMouseReleaseEvent(QMouseEvent *m)
{
        PageItem *currItem;
        m_MouseButtonPressed = false;
        if (Doc->appMode == modeNormal && Doc->guidesSettings.guidesShown)
        {
                bool foundGuide = false;
                double nx = translateToDoc(m->x(), m->y()).x();
                double ny = translateToDoc(m->x(), m->y()).y();
                double grabRadScale=Doc->guidesSettings.grabRad / Scale;
                if (Doc->currentPage()->guides.isMouseOnHorizontal(ny + grabRadScale, ny - grabRadScale, GuideManagerCore::Standard)
                        || Doc->currentPage()->guides.isMouseOnVertical(nx + grabRadScale, nx - grabRadScale, GuideManagerCore::Standard))
                        foundGuide = true;
                if ((foundGuide) && (m->button() == RightButton) && (!GetItem(&currItem)))
                {
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        MoveGY = false;
                        MoveGX = false;
                        return;
                }
                if (MoveGY)
                {
                        SetYGuide(m, GyM);
                        MoveGY = false;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        updateContents();
                        GyM = -1;
                        return;
                }
                if (MoveGX)
                {
                        SetXGuide(m, GxM);
                        MoveGX = false;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        updateContents();
                        GxM = -1;
                        return;
                }
        }
        if (Doc->appMode == modeEditGradientVectors)
                return;
        if (Doc->appMode == modeCopyProperties)
                return;
        if (Doc->appMode == modeMeasurementTool)
        {
                QPainter p;
                p.begin(viewport());
                QPoint out = contentsToViewport(QPoint(0, 0));
                p.translate(out.x(), out.y());
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                p.drawLine(Dxp, Dyp, Mxp, Myp);
                p.end();
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                //emit PaintingDone();
                return;
        }
        if (Doc->appMode == modePanning)
        {
                if ((m->state() & Qt::RightButton) && (m->state() & Qt::ControlButton))
                {
                        m_ScMW->setAppMode(modeNormal);
                }
                return;
        }
        if (Doc->appMode == modeDrawTable)
        {
                if ((Doc->m_Selection->count() == 0) && (HaveSelRect) && (!MidButt))
                {
                        QRect AreaR = QRect(static_cast<int>(Mxp), static_cast<int>(Myp), static_cast<int>(SeRx-Mxp), static_cast<int>(SeRy-Myp));
                        QPainter p;
                        p.begin(viewport());
                        ToView(&p);
                        p.scale(Scale, Scale);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        normalizeSelectionRect();
                        HaveSelRect = false;
                        double Tx, Ty, Tw, Th;
                        FPoint np2 = Doc->ApplyGrid(QPoint(Mxp, Myp));
                        Tx = np2.x();
                        Ty = np2.y();
                        Doc->ApplyGuides(&Tx, &Ty);
                        Mxp = qRound(Tx);
                        Myp = qRound(Ty);
                        np2 = Doc->ApplyGrid(QPoint(SeRx, SeRy));
                        Tw = np2.x();
                        Th = np2.y();
                        Doc->ApplyGuides(&Tw, &Th);
                        SeRx = qRound(Tw);
                        SeRy = qRound(Th);
                        Tw = Tw - Tx;
                        Th = Th - Ty;
                        int z;
                        int Cols, Rows;
                        double deltaX, deltaY, offX, offY;
                        if ((Th < 6) || (Tw < 6))
                        {
                                p.drawRect(AreaR);
                                p.end();
                                Doc->appMode = modeNormal;
                                emit PaintingDone();
                                return;
                        }
                        InsertTable *dia = new InsertTable(this, static_cast<int>(Th / 6), static_cast<int>(Tw / 6));
                        if (!dia->exec())
                        {
                                p.drawRect(AreaR);
                                p.end();
                                Doc->appMode = modeNormal;
                                emit PaintingDone();
                                delete dia;
                                dia=NULL;
                                return;
                        }
                        p.end();
                        Cols = dia->Cols->value();
                        Rows = dia->Rows->value();
                        delete dia;
                        dia=NULL;
                        deltaX = Tw / Cols;
                        deltaY = Th / Rows;
                        offX = 0.0;
                        offY = 0.0;
                        Doc->m_Selection->clear();
                        if (UndoManager::undoEnabled())
                                undoManager->beginTransaction(Doc->currentPage()->getUName(),
                                                                                          Um::ITable, Um::CreateTable,
                                                                                          QString(Um::RowsCols).arg(Rows).arg(Cols),
                                                                                          Um::ICreate);
                        for (int rc = 0; rc < Rows; ++rc)
                        {
                                for (int cc = 0; cc < Cols; ++cc)
                                {
                                        //z = PaintText(Tx + offX, Ty + offY, deltaX, deltaY, Doc->toolSettings.dWidth, Doc->toolSettings.dPenText);
                                        z = Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, Tx + offX, Ty + offY, deltaX, deltaY, Doc->toolSettings.dWidth, CommonStrings::None, Doc->toolSettings.dPenText, !m_MouseButtonPressed);
                                        currItem = Doc->Items->at(z);
                                        currItem->isTableItem = true;
                                        //currItem->setTextFlowsAroundFrame(true);
                                        //currItem->setTextFlowUsesBoundingBox(true);
                                        currItem->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
                                        Doc->m_Selection->addItem(currItem);
                                        offX += deltaX;
                                }
                                offY += deltaY;
                                offX = 0.0;
                        }
                        for (int rc = 0; rc < Rows; ++rc)
                        {
                                for (int cc = 0; cc < Cols; ++cc)
                                {
                                        currItem = Doc->m_Selection->itemAt((rc * Cols) + cc);
                                        if (rc == 0)
                                                currItem->TopLink = 0;
                                        else
                                                currItem->TopLink = Doc->m_Selection->itemAt(((rc-1)*Cols)+cc);
                                        if (rc == Rows-1)
                                                currItem->BottomLink = 0;
                                        else
                                                currItem->BottomLink = Doc->m_Selection->itemAt(((rc+1)*Cols)+cc);
                                        if (cc == 0)
                                                currItem->LeftLink = 0;
                                        else
                                                currItem->LeftLink = Doc->m_Selection->itemAt((rc*Cols)+cc-1);
                                        if (cc == Cols-1)
                                                currItem->RightLink = 0;
                                        else
                                                currItem->RightLink = Doc->m_Selection->itemAt((rc*Cols)+cc+1);
                                }
                        }
                        emit DoGroup();
                        if (UndoManager::undoEnabled())
                                undoManager->commit();
                }
                if (!Prefs->stickyTools)
                {
                        Doc->appMode = modeNormal;
                        emit PaintingDone();
                }
                else
                        emit Amode(Doc->appMode);
                emit DocChanged();
                updateContents();
                return;
        }
        if (Doc->appMode == modeDrawFreehandLine)
        {
                if (RecordP.size() > 1)
                {
                        uint z = Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, Mxp, Myp, 1, 1, Doc->toolSettings.dWidth, CommonStrings::None, Doc->toolSettings.dPenLine, !m_MouseButtonPressed);
                        currItem = Doc->Items->at(z);
                        currItem->PoLine.resize(0);
                        currItem->PoLine.addPoint(RecordP.point(0));
                        currItem->PoLine.addPoint(RecordP.point(0));
                        for (uint px = 1; px < RecordP.size()-1; ++px)
                        {
                                currItem->PoLine.addPoint(RecordP.point(px));
                                currItem->PoLine.addPoint(RecordP.point(px));
                                currItem->PoLine.addPoint(RecordP.point(px));
                                currItem->PoLine.addPoint(RecordP.point(px));
                        }
                        currItem->PoLine.addPoint(RecordP.point(RecordP.size()-1));
                        currItem->PoLine.addPoint(RecordP.point(RecordP.size()-1));
                        FPoint tp2(getMinClipF(&currItem->PoLine));
                        currItem->setXYPos(tp2.x(), tp2.y(), true);
                        currItem->PoLine.translate(-tp2.x(), -tp2.y());
                        FPoint tp(getMaxClipF(&currItem->PoLine));
                        Doc->SizeItem(tp.x(), tp.y(), currItem->ItemNr, false, false, false);
//                      currItem->Clip = FlattenPath(currItem->PoLine, currItem->Segments);
                        Doc->AdjustItemSize(currItem);
                        Doc->m_Selection->clear();
                        Doc->m_Selection->addItem(currItem);
                        currItem->ClipEdited = true;
                        currItem->FrameType = 3;
                        currItem->OwnPage = Doc->OnPage(currItem);
                }
                if (!Prefs->stickyTools)
                {
                        Doc->appMode = modeNormal;
                        emit PaintingDone();
                }
                else
                        emit Amode(Doc->appMode);
                emit DocChanged();
                updateContents();
                return;
        }
        if ((Doc->EditClip) && (ClRe == -1) && (HaveSelRect))
        {
                double sc = Scale;
                QPainter p;
                p.begin(viewport());
                ToView(&p);
                p.scale(Scale, Scale);
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                p.drawRect(Mxp, Myp, SeRx-Mxp, SeRy-Myp);
                p.end();
                normalizeSelectionRect();
                currItem = Doc->m_Selection->itemAt(0);
                SelNode.clear();
                QRect Sele = QRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>((SeRx-Mxp)*sc), static_cast<int>((SeRy-Myp)*sc));
                FPointArray Clip;
                if (EditContour)
                        Clip = currItem->ContourLine;
                else
                        Clip = currItem->PoLine;
                for (uint a = 0; a < Clip.size(); ++a)
                {
                        if (Clip.point(a).x() > 900000)
                                continue;
                        p.begin(viewport());
                        Transform(currItem, &p);
                        QPoint npf = p.xForm(Clip.pointQ(a));
                        p.end();
                        if ((Sele.contains(npf)) && ((a == 0) || (((a-2) % 4) == 0)))
                        {
                                ClRe = a;
                                SelNode.append(a);
                                emit ClipPo(Clip.point(a).x(), Clip.point(a).y());
                        }
                }
                HaveSelRect = false;
                if (EditContour)
                        MarkClip(currItem, currItem->ContourLine, true);
                else
                        MarkClip(currItem, currItem->PoLine, true);

                if (oldClip) // is there the old clip stored for the undo action
                {
                        FPointArray newClip(isContourLine ? currItem->ContourLine : currItem->PoLine);
                        if (*oldClip != newClip)
                        {
                                QString name = isContourLine ? Um::EditContour : Um::EditShape;
                                ItemState<QPair<FPointArray, FPointArray> > *state =
                                                new ItemState<QPair<FPointArray, FPointArray> >(name);
                                state->set("EDIT_SHAPE_OR_CONTOUR", "edit_shape_or_contour");
                                state->set("IS_CONTOUR", isContourLine);
                                state->setItem(QPair<FPointArray, FPointArray>(*oldClip, newClip));
                                state->set("OLD_X", oldItemX);
                                state->set("OLD_Y", oldItemY);
                                state->set("NEW_X", currItem->xPos());
                                state->set("NEW_Y", currItem->yPos());
                                undoManager->action(currItem, state);
                                undoManager->commit();
                        }
                        else
                                undoManager->cancelTransaction();

                        delete oldClip;
                        oldClip = 0;
                }
                m_SnapCounter = 0;
                return;
        }
/*      if (moveTimerElapsed() && (Doc->EditClip) && (SegP1 == -1) && (SegP2 == -1))
        {
                currItem = Doc->m_Selection->itemAt(0);
                if (operItemMoving)
                {
                        currItem->OldB2 = currItem->width();
                        currItem->OldH2 = currItem->height();
                        double nx = m->x()/Scale + Doc->minCanvasCoordinate.x();
                        double ny = m->y()/Scale + Doc->minCanvasCoordinate.y();
                        if (!Doc->ApplyGuides(&nx, &ny))
                        {
                                FPoint npg(ApplyGridF(FPoint(nx, ny)));
                                nx = npg.x();
                                ny = npg.y();
                        }
                        FPoint np(nx, ny, currItem->xPos(), currItem->yPos(), currItem->rotation(), 1, 1, true);
                        MoveClipPoint(currItem, np);
                }
                Doc->AdjustItemSize(currItem);
                emit DocChanged();
                updateContents();
                operItemMoving = false;
                return;
        }
        if (moveTimerElapsed() && (Doc->EditClip) && (SegP1 != -1) && (SegP2 != -1)) */

        if (moveTimerElapsed() && (Doc->EditClip))
        {
                SegP1 = -1;
                SegP2 = -1;
                currItem = Doc->m_Selection->itemAt(0);
                operItemMoving = false;

                ItemState<QPair<FPointArray, FPointArray> > *state = NULL;
                if (oldClip) // is there the old clip stored for the undo action
                {
                        FPointArray newClip(isContourLine ? currItem->ContourLine : currItem->PoLine);
                        if (*oldClip != newClip)
                        {
                                QString name = isContourLine ? Um::EditContour : Um::EditShape;
                                state = new ItemState<QPair<FPointArray, FPointArray> >(name);
                                state->set("EDIT_SHAPE_OR_CONTOUR", "edit_shape_or_contour");
                                state->set("IS_CONTOUR", isContourLine);
                                state->setItem(QPair<FPointArray, FPointArray>(*oldClip, newClip));
                                undoManager->setUndoEnabled(false);
                        }
                        else
                        {
                                delete oldClip;
                                oldClip = 0;
                                undoManager->cancelTransaction();
                        }
                }
                if (ClRe != -1)
                {
                        double newX = m->x();
                        double newY = m->y();
                        FPoint np(newX-Mxp, newY-Myp, 0, 0, currItem->rotation(), 1, 1, true);
                        currItem->OldB2 = currItem->width();
                        currItem->OldH2 = currItem->height();
                        FPointArray Clip;
                        if (EditContour)
                                Clip = currItem->ContourLine;
                        else
                                Clip = currItem->PoLine;
                        FPoint npf = FPoint(Clip.point(ClRe).x() + np.x() / Scale, Clip.point(ClRe).y() + np.y() / Scale);
                        double nx = npf.x();
                        double ny = npf.y();
                        nx += currItem->xPos();
                        ny += currItem->yPos();
                        if (!Doc->ApplyGuides(&nx, &ny))
                                npf = Doc->ApplyGridF(FPoint(nx, ny));
                        else
                                npf = FPoint(nx, ny);
                        npf = FPoint(npf.x() - currItem->xPos(), npf.y() - currItem->yPos());
                        MoveClipPoint(currItem, npf);
                }

                Doc->AdjustItemSize(currItem);
                emit DocChanged();
                updateContents();
                if (oldClip)
                {
                        state->set("OLD_X", oldItemX);
                        state->set("OLD_Y", oldItemY);
                        state->set("NEW_X", currItem->xPos());
                        state->set("NEW_Y", currItem->yPos());
                        undoManager->setUndoEnabled(true);
                        undoManager->action(currItem, state);
                        undoManager->commit();
                        delete oldClip;
                        oldClip = 0;
                }
                m_SnapCounter = 0;
                return;
        }
        if ((!GetItem(&currItem)) && (m->button() == RightButton) && (!Doc->DragP) && (Doc->appMode == modeNormal))
        {
                QPopupMenu *pmen = new QPopupMenu();
                if ((m_ScMW->Buffer2.startsWith("<SCRIBUSELEM")) || (m_ScMW->scrapbookPalette->tempBView->objectMap.count() > 0))
                {
                        Mxp = m->x();
                        Myp = m->y();
                        if (m_ScMW->Buffer2.startsWith("<SCRIBUSELEM"))
                                pmen->insertItem( tr("&Paste") , this, SLOT(PasteToPage()));
                        if (m_ScMW->scrapbookPalette->tempBView->objectMap.count() > 0)
                        {
                                pmen3 = new QPopupMenu();
                                QMap<QString,BibView::Elem>::Iterator it;
                                it = m_ScMW->scrapbookPalette->tempBView->objectMap.end();
                                it--;
                                for (uint m = 0; m < m_ScMW->scrapbookPalette->tempBView->objectMap.count(); ++m)
                                {
                                        QString strippedName = it.key();
                                        QPixmap pm = it.data().Preview;
                                        pmen3->insertItem(pm, strippedName);
                                        it--;
                                }
                                connect(pmen3, SIGNAL(activated(int)), this, SLOT(PasteRecentToPage(int)));
                                pmen->insertItem( tr("Paste Recent"), pmen3);
                        }
                        pmen->insertSeparator();
                }
                setObjectUndoMode();
                m_ScMW->scrActions["editUndoAction"]->addTo(pmen);
                m_ScMW->scrActions["editRedoAction"]->addTo(pmen);
                pmen->insertSeparator();
                m_ScMW->scrActions["viewShowMargins"]->addTo(pmen);
                m_ScMW->scrActions["viewShowFrames"]->addTo(pmen);
                m_ScMW->scrActions["viewShowLayerMarkers"]->addTo(pmen);
                m_ScMW->scrActions["viewShowImages"]->addTo(pmen);
                m_ScMW->scrActions["viewShowGrid"]->addTo(pmen);
                m_ScMW->scrActions["viewShowGuides"]->addTo(pmen);
                m_ScMW->scrActions["viewShowBaseline"]->addTo(pmen);
                m_ScMW->scrActions["viewShowTextChain"]->addTo(pmen);
                m_ScMW->scrActions["viewRulerMode"]->addTo(pmen);
                pmen->insertSeparator();
                m_ScMW->scrActions["viewSnapToGrid"]->addTo(pmen);
                m_ScMW->scrActions["viewSnapToGuides"]->addTo(pmen);
                int pgNum = -1;
                int docPageCount = static_cast<int>(Doc->Pages->count() - 1);
                double bleedRight = 0.0;
                double bleedLeft = 0.0;
                double bleedBottom = 0.0;
                double bleedTop = 0.0;
                bool drawBleed = false;
                int x2 = static_cast<int>(translateToDoc(m->x(), m->y()).x());
                int y2 = static_cast<int>(translateToDoc(m->x(), m->y()).y());
                if (((Doc->bleeds.Bottom != 0.0) || (Doc->bleeds.Top != 0.0) || (Doc->bleeds.Left != 0.0) || (Doc->bleeds.Right != 0.0)) && (Doc->guidesSettings.showBleed))
                        drawBleed = true;
                for (int a = docPageCount; a > -1; a--)
                {
                        if (drawBleed)
                                Doc->getBleeds(a, &bleedTop, &bleedBottom, &bleedLeft, &bleedRight);
                        int x = static_cast<int>(Doc->Pages->at(a)->xOffset() - bleedLeft);
                        int y = static_cast<int>(Doc->Pages->at(a)->yOffset() - bleedTop);
                        int w = static_cast<int>(Doc->Pages->at(a)->width() + bleedLeft + bleedRight);
                        int h = static_cast<int>(Doc->Pages->at(a)->height() + bleedBottom + bleedTop);
                        if (QRect(x, y, w, h).contains(x2, y2))
                        {
                                pgNum = static_cast<int>(a);
                                if (drawBleed)  // check again if its really on the correct page
                                {
                                        for (int a2 = docPageCount; a2 > -1; a2--)
                                        {
                                                int xn = static_cast<int>(Doc->Pages->at(a2)->xOffset());
                                                int yn = static_cast<int>(Doc->Pages->at(a2)->yOffset());
                                                int wn = static_cast<int>(Doc->Pages->at(a2)->width());
                                                int hn = static_cast<int>(Doc->Pages->at(a2)->height());
                                                if (QRect(xn, yn, wn, hn).contains(x2, y2))
                                                {
                                                        pgNum = static_cast<int>(a2);
                                                        break;
                                                }
                                        }
                                }
                                break;
                        }
                }
                if (pgNum != -1)
                {
                        pmen->insertSeparator();
                        m_ScMW->scrActions["pageApplyMasterPage"]->addTo(pmen);
                        m_ScMW->scrActions["pageManageGuides"]->addTo(pmen);
                        m_ScMW->scrActions["pageManageMargins"]->addTo(pmen);
                        pmen->insertSeparator();
                        m_ScMW->scrActions["pageDelete"]->addTo(pmen);
                }
                pmen->exec(QCursor::pos());
                setGlobalUndoMode();
                delete pmen;
                pmen=NULL;
                if (m_ScMW->scrapbookPalette->tempBView->objectMap.count() > 0)
                {
                        delete pmen3;
                        pmen3=NULL;
                }
                return;
        }
        if ((Doc->appMode != modeMagnifier) && (!Doc->EditClip) && (Doc->appMode != modeDrawBezierLine))
        {
                if ((GetItem(&currItem)) && (m->button() == RightButton) && (!Doc->DragP))
                {
                        QPopupMenu *pmen = new QPopupMenu();
                        QPopupMenu *pmen2 = new QPopupMenu();
                        pmen3 = new QPopupMenu();
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        QPopupMenu *pmen4 = new QPopupMenu();
                        QPopupMenu *pmenEditContents = new QPopupMenu();
                        QPopupMenu *pmenLevel = new QPopupMenu();
                        QPopupMenu *pmenPDF = new QPopupMenu();
                        pmenResolution = new QPopupMenu();
                        setObjectUndoMode();
                        if ((currItem->itemType() == PageItem::TextFrame) || (currItem->itemType() == PageItem::ImageFrame) || (currItem->itemType() == PageItem::PathText))
                        {
                                QButtonGroup *InfoGroup = new QButtonGroup( this, "InfoGroup" );
                                InfoGroup->setFrameShape( QButtonGroup::NoFrame );
                                InfoGroup->setFrameShadow( QButtonGroup::Plain );
                                InfoGroup->setTitle("");
                                InfoGroup->setExclusive( true );
                                InfoGroup->setColumnLayout(0, Qt::Vertical );
                                InfoGroup->layout()->setSpacing( 0 );
                                InfoGroup->layout()->setMargin( 0 );
                                QGridLayout *InfoGroupLayout = new QGridLayout( InfoGroup->layout() );
                                InfoGroupLayout->setAlignment( Qt::AlignTop );
                                InfoGroupLayout->setSpacing( 2 );
                                InfoGroupLayout->setMargin( 0 );
                                QString txtC, txtC2;
                                QLabel *InfoT = new QLabel(InfoGroup, "ct");
                                QLabel *LinCT = new QLabel(InfoGroup, "lt");
                                QLabel *LinC = new QLabel(InfoGroup, "lc");
                                QLabel *ParCT = new QLabel(InfoGroup, "pt");
                                QLabel *ParC = new QLabel(InfoGroup, "pc");
                                QLabel *WordCT = new QLabel(InfoGroup, "wt");
                                QLabel *WordC = new QLabel(InfoGroup, "wc");
                                QLabel *CharCT = new QLabel(InfoGroup, "ct");
                                QLabel *CharC = new QLabel(InfoGroup, "cc");
                                QLabel *ColCT = new QLabel(InfoGroup, "ct");
                                QLabel *ColC = new QLabel(InfoGroup, "cc");
                                QLabel *PrintCT = new QLabel(InfoGroup, "nt"); // <a.l.e>
                                QLabel *PrintC = new QLabel(InfoGroup, "nc"); // </a.l.e>
                                if (currItem->itemType() == PageItem::ImageFrame)
                                {
                                        LinC->hide();
                                        LinCT->hide();
                                        if (currItem->PicAvail)
                                        {
                                                QFileInfo fi = QFileInfo(currItem->Pfile);
                                                InfoT->setText( tr("Picture"));
                                                InfoGroupLayout->addMultiCellWidget( InfoT, 0, 0, 0, 1, Qt::AlignHCenter );
                                                ParCT->setText( tr("File: "));
                                                InfoGroupLayout->addWidget( ParCT, 1, 0, Qt::AlignRight );
                                                ParC->setText(fi.fileName());
                                                InfoGroupLayout->addWidget( ParC, 1, 1 );
                                                WordCT->setText( tr("Original PPI: "));
                                                InfoGroupLayout->addWidget( WordCT, 2, 0, Qt::AlignRight );
                                                WordC->setText(txtC.setNum(qRound(currItem->pixm.imgInfo.xres))+" x "+txtC2.setNum(qRound(currItem->pixm.imgInfo.yres)));
                                                InfoGroupLayout->addWidget( WordC, 2, 1 );
                                                CharCT->setText( tr("Actual PPI: "));
                                                InfoGroupLayout->addWidget( CharCT, 3, 0, Qt::AlignRight );
                                                CharC->setText(txtC.setNum(qRound(72.0 / currItem->imageXScale()))+" x "+ txtC2.setNum(qRound(72.0 / currItem->imageYScale())));
                                                InfoGroupLayout->addWidget( CharC, 3, 1 );
                                                ColCT->setText( tr("Colorspace: "));
                                                InfoGroupLayout->addWidget( ColCT, 4, 0, Qt::AlignRight );
                                                QString cSpace;
                                                QString ext = fi.extension(false).lower();
                                                if (((ext == "pdf") || (ext == "eps") || (ext == "epsi") || (ext == "ps")) && (currItem->pixm.imgInfo.type != 7))
                                                        cSpace = tr("Unknown");
                                                else
                                                {
                                                        switch (currItem->pixm.imgInfo.colorspace)
                                                        {
                                                                case 0:
                                                                        cSpace = tr("RGB");
                                                                        break;
                                                                case 1:
                                                                        cSpace = tr("CMYK");
                                                                        break;
                                                                case 2:
                                                                        cSpace = tr("Grayscale");
                                                                        break;
                                                                case 3:
                                                                        cSpace = tr("Duotone");
                                                                        break;
                                                        }
                                                }
                                                ColC->setText(cSpace);
                                                InfoGroupLayout->addWidget( ColC, 4, 1 );
                                        }
                                        else
                                        {
                                                InfoT->setText( tr("Picture"));
                                                InfoGroupLayout->addMultiCellWidget( InfoT, 0, 0, 0, 1, Qt::AlignHCenter );
                                                ParCT->setText( tr("No Image Loaded"));
                                                InfoGroupLayout->addMultiCellWidget( ParCT, 1, 1, 0, 1, Qt::AlignHCenter );
                                                ParC->hide();
                                                WordCT->hide();
                                                WordC->hide();
                                                CharCT->hide();
                                                CharC->hide();
                                                ColCT->hide();
                                                ColC->hide();
                                        }
                                }
                                if ((currItem->itemType() == PageItem::TextFrame) || (currItem->itemType() == PageItem::PathText))
                                {
                                        int Parag = 0;
                                        int Words = 0;
                                        int Chara = 0;
                                        int ParagN = 0;
                                        int WordsN = 0;
                                        int CharaN = 0;
                                        ColC->hide();
                                        ColCT->hide();
                                        if (currItem->itemType() == PageItem::TextFrame)
                                        {
                                                if ((currItem->nextInChain() != 0) || (currItem->prevInChain() != 0))
                                                        InfoT->setText( tr("Linked Text"));
                                                else
                                                        InfoT->setText( tr("Text Frame"));
                                        }
                                        else
                                                InfoT->setText( tr("Text on a Path"));
                                        InfoGroupLayout->addMultiCellWidget( InfoT, 0, 0, 0, 1, Qt::AlignCenter );
                                        WordAndPara(currItem, &Words, &Parag, &Chara, &WordsN, &ParagN, &CharaN);
                                        ParCT->setText( tr("Paragraphs: "));
                                        InfoGroupLayout->addWidget( ParCT, 1, 0, Qt::AlignRight );
                                        if (ParagN != 0)
                                                ParC->setText(txtC.setNum(Parag+ParagN)+" ("+txtC2.setNum(ParagN)+")");
                                        else
                                                ParC->setText(txtC.setNum(Parag));
                                        InfoGroupLayout->addWidget( ParC, 1, 1 );
                                        LinCT->setText( tr("Lines: "));
                                        InfoGroupLayout->addWidget( LinCT, 2, 0, Qt::AlignRight );
                                        LinC->setText(txtC.setNum(currItem->itemText.lines()));
                                        InfoGroupLayout->addWidget( LinC, 2, 1 );
                                        WordCT->setText( tr("Words: "));
                                        InfoGroupLayout->addWidget( WordCT, 3, 0, Qt::AlignRight );
                                        if (WordsN != 0)
                                                WordC->setText(txtC.setNum(Words+WordsN)+" ("+txtC2.setNum(WordsN)+")");
                                        else
                                                WordC->setText(txtC.setNum(Words));
                                        InfoGroupLayout->addWidget( WordC, 3, 1 );
                                        CharCT->setText( tr("Chars: "));
                                        InfoGroupLayout->addWidget( CharCT, 4, 0, Qt::AlignRight );
                                        if (CharaN != 0)
                                                CharC->setText(txtC.setNum(Chara+CharaN)+" ("+txtC2.setNum(CharaN)+")");
                                        else
                                                CharC->setText(txtC.setNum(Chara));
                                        InfoGroupLayout->addWidget( CharC, 4, 1 );
                                }

                                int row = InfoGroupLayout->numRows(); // <a.l.e>

                                PrintCT->setText( tr("Print: "));
                                InfoGroupLayout->addWidget( PrintCT, row, 0, Qt::AlignRight );
                                if (currItem->printEnabled())
                                        PrintC->setText( tr("Enabled"));
                                else
                                        PrintC->setText( tr("Disabled"));
                                InfoGroupLayout->addWidget( PrintC, row, 1 ); // </a.l.e>

                                pmen4->insertItem(InfoGroup);
                                if ((currItem->itemType() == PageItem::ImageFrame) && (currItem->pixm.imgInfo.exifDataValid))
                                        m_ScMW->scrActions["itemImageInfo"]->addTo(pmen4);
                                pmen->insertItem( tr("In&fo"), pmen4);
                        }
                        pmen->insertSeparator();
                        m_ScMW->scrActions["editUndoAction"]->addTo(pmen);
                        m_ScMW->scrActions["editRedoAction"]->addTo(pmen);
                        if (currItem->itemType() == PageItem::ImageFrame ||
                                currItem->itemType() == PageItem::TextFrame ||
                                currItem->itemType() == PageItem::PathText)
                        {
                                pmen->insertSeparator();
                                if (currItem->itemType() == PageItem::ImageFrame)
                                {
                                        m_ScMW->scrActions["fileImportImage"]->addTo(pmen);
                                        if (currItem->PicAvail)
                                        {
                                                if (!currItem->isTableItem)
                                                        m_ScMW->scrActions["itemAdjustFrameToImage"]->addTo(pmen);
                                                if (currItem->pixm.imgInfo.valid)
                                                        m_ScMW->scrActions["itemExtendedImageProperties"]->addTo(pmen);
                                                m_ScMW->scrActions["itemUpdateImage"]->addTo(pmen);
                                        }
                                        pmen->insertItem( tr("Preview Settings"), pmenResolution);
                                        m_ScMW->scrActions["itemImageIsVisible"]->addTo(pmenResolution);
                                        pmenResolution->insertSeparator();
                                        m_ScMW->scrActions["itemPreviewLow"]->addTo(pmenResolution);
                                        m_ScMW->scrActions["itemPreviewNormal"]->addTo(pmenResolution);
                                        m_ScMW->scrActions["itemPreviewFull"]->addTo(pmenResolution);
                                        if (currItem->PicAvail && currItem->isRaster)
                                        {
                                                m_ScMW->scrActions["styleImageEffects"]->addTo(pmen);
                                                m_ScMW->scrActions["editEditWithImageEditor"]->addTo(pmen);
                                        }
                                }
                                if (currItem->itemType() == PageItem::TextFrame)
                                {
                                        m_ScMW->scrActions["fileImportText"]->addTo(pmen);
                                        m_ScMW->scrActions["fileImportAppendText"]->addTo(pmen);
                                        m_ScMW->scrActions["toolsEditWithStoryEditor"]->addTo(pmen);
                                        m_ScMW->scrActions["insertSampleText"]->addTo(pmen);
                                }
                                if (currItem->itemType() == PageItem::PathText)
                                        m_ScMW->scrActions["toolsEditWithStoryEditor"]->addTo(pmen);
                        }
                        if (Doc->m_Selection->count() == 1)
                        {
                                pmen->insertSeparator();
                                m_ScMW->scrActions["itemAttributes"]->addTo(pmen);
                        }      
                        if (currItem->itemType() == PageItem::TextFrame)
                        {
                                if (Doc->currentPage()->pageName().isEmpty())
                                {
                                        m_ScMW->scrActions["itemPDFIsAnnotation"]->addTo(pmenPDF);
                                        m_ScMW->scrActions["itemPDFIsBookmark"]->addTo(pmenPDF);
                                        if (currItem->isAnnotation())
                                        {
                                                if ((currItem->annotation().Type() == 0) || (currItem->annotation().Type() == 1) || (currItem->annotation().Type() > 9))
                                                        m_ScMW->scrActions["itemPDFAnnotationProps"]->addTo(pmenPDF);
                                                else
                                                        m_ScMW->scrActions["itemPDFFieldProps"]->addTo(pmenPDF);
                                        }
                                }
                                pmen->insertItem( tr("&PDF Options"), pmenPDF);
                        }
                        pmen->insertSeparator();
                        m_ScMW->scrActions["itemLock"]->addTo(pmen);
                        m_ScMW->scrActions["itemLockSize"]->addTo(pmen);
                        if (!currItem->isSingleSel)
                        {
                                m_ScMW->scrActions["itemSendToScrapbook"]->addTo(pmen);
                                m_ScMW->scrActions["itemSendToPattern"]->addTo(pmen);
                                if (Doc->layerCount() > 1)
                                {
                                        QMap<int,int> layerMap;
                                        for (QValueList<Layer>::iterator it = Doc->Layers.begin(); it != Doc->Layers.end(); ++it)
                                                layerMap.insert((*it).Level, (*it).LNr);
                                        int i=layerMap.count()-1;
                                        while (i>=0)
                                        {
                                                if (Doc->layerLocked(layerMap[i]))
                                                        m_ScMW->scrLayersActions[QString::number(layerMap[i])]->setEnabled(false);
                                                else
                                                        m_ScMW->scrLayersActions[QString::number(layerMap[i])]->setEnabled(true);
                                                m_ScMW->scrLayersActions[QString::number(layerMap[i--])]->addTo(pmen3);
                                        }

                                        pmen->insertItem( tr("Send to La&yer"), pmen3);
                                }
                        }
                        if (Doc->m_Selection->count() > 1)
                        {
                                bool isGroup = true;
                                int firstElem = -1;
                                if (currItem->Groups.count() != 0)
                                        firstElem = currItem->Groups.top();
                                for (uint bx = 0; bx < Doc->m_Selection->count(); ++bx)
                                {
                                        if (Doc->m_Selection->itemAt(bx)->Groups.count() != 0)
                                        {
                                                if (Doc->m_Selection->itemAt(bx)->Groups.top() != firstElem)
                                                        isGroup = false;
                                        }
                                        else
                                                isGroup = false;
                                }
                                if (!isGroup)
                                        m_ScMW->scrActions["itemGroup"]->addTo(pmen);
                        }
                        if (currItem->Groups.count() != 0)
                                m_ScMW->scrActions["itemUngroup"]->addTo(pmen);
                        if (!currItem->locked())
                        {
                                if ((!currItem->isTableItem) && (!currItem->isSingleSel))
                                {
                                        pmen->insertItem( tr("Le&vel"), pmenLevel);
                                        m_ScMW->scrActions["itemRaiseToTop"]->addTo(pmenLevel);
                                        m_ScMW->scrActions["itemRaise"]->addTo(pmenLevel);
                                        m_ScMW->scrActions["itemLower"]->addTo(pmenLevel);
                                        m_ScMW->scrActions["itemLowerToBottom"]->addTo(pmenLevel);
                                }
                        }
                        if (Doc->appMode != modeEdit && Doc->m_Selection->itemsAreSameType()) //Create convertTo Menu
                        {
                                bool insertConvertToMenu=false;
                                if ((currItem->itemType() == PageItem::TextFrame) || (currItem->itemType() == PageItem::PathText))
                                {
                                        insertConvertToMenu=true;
                                        if (currItem->itemType() == PageItem::PathText)
                                                m_ScMW->scrActions["itemConvertToOutlines"]->addTo(pmen2);
                                        else
                                        {
                                                if (currItem->isTableItem)
                                                        m_ScMW->scrActions["itemConvertToImageFrame"]->addTo(pmen2);
                                                if (!currItem->isTableItem)
                                                {
                                                        if ((currItem->prevInChain() == 0) && (currItem->nextInChain() == 0))
                                                                m_ScMW->scrActions["itemConvertToImageFrame"]->addTo(pmen2);
                                                        m_ScMW->scrActions["itemConvertToOutlines"]->addTo(pmen2);
                                                        if ((currItem->prevInChain() == 0) && (currItem->nextInChain() == 0))
                                                                m_ScMW->scrActions["itemConvertToPolygon"]->addTo(pmen2);
                                                }
                                        }
                                }
                                if (currItem->itemType() == PageItem::ImageFrame)
                                {
                                        insertConvertToMenu=true;
                                        m_ScMW->scrActions["itemConvertToTextFrame"]->addTo(pmen2);
                                        if (!currItem->isTableItem)
                                                m_ScMW->scrActions["itemConvertToPolygon"]->addTo(pmen2);
                                }
                                if (currItem->itemType() == PageItem::Polygon)
                                {
                                        insertConvertToMenu=true;
                                        m_ScMW->scrActions["itemConvertToBezierCurve"]->addTo(pmen2);
                                        m_ScMW->scrActions["itemConvertToImageFrame"]->addTo(pmen2);
                                        m_ScMW->scrActions["itemConvertToTextFrame"]->addTo(pmen2);
                                }
                                bool insertedMenusEnabled = false;
                                for (uint pc = 0; pc < pmen2->count(); pc++)
                                {
                                        if (pmen2->isItemEnabled(pmen2->idAt(pc)))
                                                insertedMenusEnabled = true;
                                }
                                if ((insertConvertToMenu) && (insertedMenusEnabled))
                                        pmen->insertItem( tr("Conve&rt to"), pmen2);
                        }
                        pmen->insertSeparator();
                        if (!currItem->locked() && !(currItem->isSingleSel))
                                m_ScMW->scrActions["editCut"]->addTo(pmen);
                        if (!(currItem->isSingleSel))
                                m_ScMW->scrActions["editCopy"]->addTo(pmen);
                        if ((Doc->appMode == modeEdit) && (m_ScMW->Buffer2.startsWith("<SCRIBUSTEXT")) && (currItem->itemType() == PageItem::TextFrame))
                                m_ScMW->scrActions["editPaste"]->addTo(pmen);
                        if (!currItem->locked() && (Doc->appMode != modeEdit) && (!(currItem->isSingleSel)))
                                pmen->insertItem( tr("&Delete"), Doc, SLOT(itemSelection_DeleteItem()));
                        if ((currItem->itemType() == PageItem::ImageFrame) || (currItem->itemType() == PageItem::TextFrame))
                        {
                                if (currItem->itemType() == PageItem::ImageFrame)
                                {
                                        if (currItem->PicAvail)
                                                m_ScMW->scrActions["editCopyContents"]->addTo(pmenEditContents);
                                        if (m_ScMW->contentsBuffer.sourceType==PageItem::ImageFrame)
                                        {
                                                m_ScMW->scrActions["editPasteContents"]->addTo(pmenEditContents);
                                                m_ScMW->scrActions["editPasteContentsAbs"]->addTo(pmenEditContents);
                                        }
                                        if (currItem->PicAvail)
                                                m_ScMW->scrActions["editClearContents"]->addTo(pmenEditContents);
                                        if ((currItem->PicAvail) || (m_ScMW->contentsBuffer.sourceType==PageItem::ImageFrame))
                                                pmen->insertItem( tr("Contents"), pmenEditContents);
                                }
                                else
                                {
                                        if (currItem->itemText.lines() != 0)
                                        {
                                                m_ScMW->scrActions["editClearContents"]->addTo(pmenEditContents);
                                                pmen->insertItem( tr("Contents"), pmenEditContents);
                                        }
                                }
                        }
                        pmen->insertSeparator();
                        m_ScMW->scrActions["toolsProperties"]->addTo(pmen);

                        pmen->exec(QCursor::pos());
                        setGlobalUndoMode();
                        delete pmen;
                        delete pmen2;
                        delete pmen3;
                        delete pmen4;
                        delete pmenEditContents;
                        delete pmenLevel;
                        delete pmenPDF;
                        delete pmenResolution;
                        pmen=NULL;
                        pmen2=NULL;
                        pmen3=NULL;
                        pmen4=NULL;
                        pmenEditContents=NULL;
                        pmenLevel=NULL;
                        pmenPDF=NULL;
                        pmenResolution=NULL;
                }
                if ((Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
                {
                        updateContents();
                        if (Doc->ElemToLink != 0)
                                return;
                        else
                        {
                                Doc->appMode = modeNormal;
                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                                emit PaintingDone();
                                return;
                        }
                }
                if (inItemCreation)
                {
                        currItem = Doc->m_Selection->itemAt(0);
                        double itemX = 0.0;
                        double itemY = 0.0;
                        if (Doc->appMode == modeDrawLine)
                        {
                                QPainter p;
                                p.begin(viewport());
                                Transform(currItem, &p);
                                QPoint np = p.xFormDev(m->pos());
                                p.end();
                                np += QPoint(qRound(Doc->minCanvasCoordinate.x()), qRound(Doc->minCanvasCoordinate.y()));
                                np = Doc->ApplyGrid(np);
                                itemX = sqrt(pow(np.x(),2.0)+pow(np.y(),2.0));
                                itemY = 1.0;
                        }
                        else if (Doc->appMode == modeDrawRegularPolygon)
                        {
                                FPoint np1(translateToDoc(m->x(), m->y()));
                                np1 = Doc->ApplyGridF(np1);
                                itemX = fabs(np1.x() - currItem->xPos());
                                itemY = fabs(np1.y() - currItem->yPos());
                        }
                        else
                        {
                                itemX = fabs(currItem->width());
                                itemY = fabs(currItem->height());
                        }
                        if ((!moveTimerElapsed()) || ((itemX < 2.0) && (itemY < 2.0)) || ((Doc->appMode == modeDrawLine) && (itemX < 2.0)))
                        {
                                int lmode = 0;
                                if (Doc->appMode == modeDrawLine)
                                        lmode = 1;
                                PrefsContext* sizes = PrefsManager::instance()->prefsFile->getContext("ObjectSize");
                                double xSize, ySize;
                                int originPoint;
                                if (lmode == 0)
                                {
                                        xSize = sizes->getDouble("defWidth", 100.0);
                                        ySize = sizes->getDouble("defHeight", 100.0);
                                        originPoint = sizes->getInt("Origin", 0);
                                }
                                else
                                {
                                        xSize = sizes->getDouble("defLength", 100.0);
                                        ySize = sizes->getDouble("defAngle", 0.0);
                                        originPoint = sizes->getInt("OriginL", 0);
                                }
                                bool doRemember = sizes->getBool("Remember", true);
                                bool doCreate = false;