Subversion Repositories Scribus

Rev

Rev 10869 | Rev 10876 | 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 "scconfig.h"

#include <QColor>
#include <QDrag>
#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QDragMoveEvent>
#include <QDropEvent>
#include <QEvent>
#include <QFile>
#include <QFileInfo>
#include <QFont>
#include <QFontMetrics>
#include <QImage>
#include <QImageReader>
#include <QLabel>
#include <QList>
#include <QMenu>
#include <QMimeData>
#include <QMouseEvent>
#include <QPaintEvent>
#include <QPixmap>
#include <QPolygon>
#include <QStack>
#include <QStringList>
#include <QWheelEvent>
#include <QWidgetAction>

#include <cmath>
#include <cstdio>
#include <cstdlib>

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

#include <QUrl>
#include <QDir>
#include <QEvent>
#include <QSizeGrip>
#if QT_VERSION  > 0x030102
        #define SPLITVC Qt::SplitHCursor
        #define SPLITHC Qt::SplitVCursor
#else
        #define SPLITVC Qt::SplitVCursor
        #define SPLITHC Qt::SplitHCursor
#endif
#include "scribus.h"

#include "canvas.h"
#include "canvasgesture.h"
#include "canvasmode.h"
#include "actionmanager.h"
#include "commonstrings.h"
#include "extimageprops.h"
#include "filewatcher.h"
#include "guidemanager.h"
#include "hruler.h"
#include "hyphenator.h"
#include "insertTable.h"
#include "oneclick.h"
#include "page.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 "pageitem_latexframe.h"
#include "pageitemattributes.h"
#include "pageselector.h"
#include "prefscontext.h"
#include "prefsfile.h"
#include "prefsmanager.h"
#include "propertiespalette.h"
#include "rulermover.h"
#include "scmessagebox.h"
#include "scpainter.h"
#include "scpaths.h"
#include "scrapbookpalette.h"
#include "scribusXml.h"
#include "selection.h"
#include "serializer.h"
#include "stencilreader.h"
#include "story.h"
#include "text/nlsconfig.h"
#include "undomanager.h"
#include "units.h"
#include "util.h"
#include "util_color.h"
#include "util_formats.h"
#include "util_icon.h"
#include "util_math.h"
#include "vruler.h"
#include <tiffio.h>
#include CMS_INC


using namespace std;



ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
        QScrollArea(win),
        Doc(doc),
        m_canvas(new Canvas(doc, this)),
        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)
{
        setObjectName("s");
        setAttribute(Qt::WA_StaticContents);
        setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
        setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
        setViewportMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
        setWidgetResizable(false);
        m_canvasMode = CanvasMode::createForAppMode(this, Doc->appMode);
        setWidget(m_canvas);
        //already done by QScrollArea: widget()->installEventFilter(this);
        installEventFilter(this); // FIXME:av
//      viewport()->setBackgroundMode(Qt::PaletteBackground);
        QFont fo = QFont(font());
        int posi = fo.pointSize()-2;
        fo.setPointSize(posi);
        unitSwitcher = new QComboBox( this );
        unitSwitcher->setFocusPolicy(Qt::NoFocus);
        unitSwitcher->setFont(fo);
        int maxUindex = unitGetMaxIndex() - 2;
        for (int i = 0; i <= maxUindex; ++i)
                unitSwitcher->addItem(unitGetStrFromIndex(i));
        zoomSpinBox = new ScrSpinBox( 10, 3200, this, 6 );
        zoomSpinBox->setTabAdvance(false);
        zoomSpinBox->setFont(fo);
        zoomSpinBox->setValue( 100 );
        zoomSpinBox->setSingleStep(10);
        zoomSpinBox->setFocusPolicy(Qt::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->setCheckable(true);
        QIcon ic2;
        ic2.addPixmap(loadIcon("cmsOff.png"), QIcon::Normal, QIcon::Off);
        ic2.addPixmap(loadIcon("cmsOn.png"), QIcon::Normal, QIcon::On);
        cmsToolbarButton->setIcon(ic2);
        previewToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
        previewToolbarButton->setCheckable(true);
        QIcon ic;
        ic.addPixmap(loadIcon("previewOff.png"), QIcon::Normal, QIcon::Off);
        ic.addPixmap(loadIcon("previewOn.png"), QIcon::Normal, QIcon::On);
        previewToolbarButton->setIcon(ic);
#else
        zoomDefaultToolbarButton = new QPushButton(this);
        zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomDefaultToolbarButton->setDefault( false );
        zoomDefaultToolbarButton->setAutoDefault( false );
        zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        zoomOutToolbarButton = new QPushButton(this);
        zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomOutToolbarButton->setDefault( false );
        zoomOutToolbarButton->setAutoDefault( false );
        zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        zoomInToolbarButton = new QPushButton(this);
        zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
        zoomInToolbarButton->setDefault( false );
        zoomInToolbarButton->setAutoDefault( false );
        zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        previewToolbarButton = new QPushButton(this);
        cmsToolbarButton->setFocusPolicy(Qt::NoFocus);
        cmsToolbarButton->setDefault( false );
        cmsToolbarButton->setAutoDefault( false );
        cmsToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        cmsToolbarButton->setPixmap(loadIcon("cmsOn.png"));
        previewToolbarButton = new QPushButton(this);
        previewToolbarButton->setFocusPolicy(Qt::NoFocus);
        previewToolbarButton->setDefault( false );
        previewToolbarButton->setAutoDefault( false );
        previewToolbarButton->setFlat(OPTION_FLAT_BUTTON);
        previewToolbarButton->setPixmap(loadIcon("previewOn.png"));
#endif
        //zoomDefaultToolbarButton->setText("1:1");
        zoomDefaultToolbarButton->setIcon(QIcon(loadIcon("16/zoom-original.png")));
        zoomOutToolbarButton->setIcon(QIcon(loadIcon("16/zoom-out.png")));
        zoomInToolbarButton->setIcon(QIcon(loadIcon("16/zoom-in.png")));
        pageSelector = new PageSelector(this, Doc->Pages->count());
        pageSelector->setFont(fo);
        pageSelector->setFocusPolicy(Qt::ClickFocus);
        layerMenu = new QComboBox( this );
        layerMenu->setEditable(false);
        layerMenu->setFont(fo);
        layerMenu->setFocusPolicy(Qt::NoFocus);
        visualMenu = new QComboBox( this );
        visualMenu->setFocusPolicy(Qt::NoFocus);
        visualMenu->setFont(fo);
        visualMenu->setEnabled(false);
        horizRuler = new Hruler(this, Doc);
        vertRuler = new Vruler(this, Doc);
        horizRuler->installEventFilter(this);
        vertRuler->installEventFilter(this);
        rulerMover = new RulerMover(this);
        rulerMover->setFocusPolicy(Qt::NoFocus);
        horizRuler->setGeometry(m_vhRulerHW, 1, width()-m_vhRulerHW-1, m_vhRulerHW);
        vertRuler->setGeometry(1, m_vhRulerHW, m_vhRulerHW, height()-m_vhRulerHW-1);
        rulerMover->setGeometry(1, 1, m_vhRulerHW, m_vhRulerHW);
        Ready = true;
        m_canvas->setMouseTracking(true);
        setAcceptDrops(true);
        m_canvas->setAcceptDrops(true);
        // FIXME setDragAutoScroll(false);
        Doc->DragP = false;
        Doc->leaveDrag = false;
        Doc->SubMode = -1;
        storedFramesShown = Doc->guidesSettings.framesShown;
        storedShowControls = Doc->guidesSettings.showControls;
        m_canvas->m_viewMode.viewAsPreview = false;
        m_canvas->setPreviewVisual(-1);
//      shiftSelItems = false;
//      inItemCreation = false;
        m_previousMode = -1;
        redrawMode = 0;
        redrawCount = 0;
        redrawMarker = new QRubberBand(QRubberBand::Rectangle);
        redrawMarker->hide();
        m_canvas->newRedrawPolygon();
        m_canvas->resetRenderMode();
        m_ScMW->scrActions["viewFitPreview"]->setChecked(m_canvas->m_viewMode.viewAsPreview);
//      m_SnapCounter = 0;
       
        Doc->regionsChanged()->connectObserver(this);
        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(double)), 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();
        dragTimer = new QTimer(this);
        connect(dragTimer, SIGNAL(timeout()), this, SLOT(dragTimerTimeOut()));
        dragTimer->stop();
        dragTimerFired = false;
}

void ScribusView::changeEvent(QEvent *e)
{
        if (e->type() == QEvent::LanguageChange)
        {
                languageChange();
        }
}

void ScribusView::languageChange()
{
        cmsToolbarButton->setToolTip("");
        previewToolbarButton->setToolTip("");
        visualMenu->setToolTip("");
        cmsToolbarButton->setToolTip( tr("Switches Color Management on or off"));
        previewToolbarButton->setToolTip( tr("Enables the Preview Mode"));
        visualMenu->setToolTip( 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->addItem(CommonStrings::trVisionNormal);
        visualMenu->addItem(CommonStrings::trVisionProtanopia);
        visualMenu->addItem(CommonStrings::trVisionDeuteranopia);
        visualMenu->addItem(CommonStrings::trVisionTritanopia);
        visualMenu->addItem(CommonStrings::trVisionFullColorBlind);
        visualMenu->setCurrentIndex(m_canvas->previewVisual());
        connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
}

void ScribusView::toggleCMS()
{
        Doc->enableCMS(!Doc->HasCMS);
//      repaintContents(QRect());
        DrawNew();
}

void ScribusView::switchPreviewVisual(int vis)
{
        m_canvas->setPreviewVisual(vis);
        Doc->recalculateColors();
        Doc->recalcPicturesRes();
//      repaintContents(QRect());
        DrawNew();
}

void ScribusView::togglePreview()
{
        m_canvas->m_viewMode.viewAsPreview = !m_canvas->m_viewMode.viewAsPreview;
        if (m_canvas->m_viewMode.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"]->setChecked(m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowMargins"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowFrames"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowGrid"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowGuides"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowBaseline"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowTextChain"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
        m_ScMW->scrActions["viewShowTextControls"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
#if OPTION_USE_QTOOLBUTTON
        previewToolbarButton->setChecked(m_canvas->m_viewMode.viewAsPreview);
#endif
        visualMenu->setEnabled(m_canvas->m_viewMode.viewAsPreview);
        Doc->recalculateColors();
        Doc->recalcPicturesRes();
//      repaintContents(QRect());
        DrawNew();
}

void ScribusView::changed(QRectF re)
{
//      qDebug() << "ScribusView-changed(): changed region:" << re;
        if (re.isValid())
                updateCanvas(re);
        else
                DrawNew();
//              m_canvas->repaint();
}




void ScribusView::startGesture(CanvasGesture* gesture)
{
        qDebug() << "start gesture" << typeid(*m_canvasMode).name() << "---->" << typeid(*gesture).name();
        m_canvasMode->deactivate(true);
        gesture->setDelegate(m_canvasMode);
        m_canvasMode = gesture;
        m_canvasMode->activate(false);
        m_canvas->repaint();   
}


void ScribusView::stopGesture()
{
        qDebug() << "stop gesture" << typeid(*m_canvasMode).name() << (m_canvasMode->delegate() != 0);
        if (m_canvasMode->delegate())
        {
                m_canvasMode->deactivate(false);
                m_canvasMode = m_canvasMode->delegate();
                m_canvasMode->activate(true);
                m_canvas->repaint();
        }
}

/**
switches between appmodes:
 - for submodes, activate the appropiate dialog or palette
 - set a new CanvasMode if necessary
 - call ScribusMainWindow::setAppMode(), which de/activates actions
 TODO:av make this simpler
 */

void ScribusView::requestMode(int appMode)
{
        bool updateNecessary = false;
        qDebug() << "request mode:" << appMode;
        switch(appMode) // filter submodes
        {
                case submodePaintingDone:   // return to normal mode
                        appMode = m_previousMode < 0 ? modeNormal : m_previousMode;
                        m_previousMode = -1;
                        updateNecessary = true;
                        break;                 
                case submodeEndNodeEdit:     // return from node/shape editing
                        appMode = m_previousMode < 0 ? modeNormal : m_previousMode;
                        m_previousMode = -1;
                        updateNecessary = true;
                        break;
                        /*
                         case submodeToggleNodeEdit:
                                 if (Doc->appMode == modeEditClip)
                                 {
                                         m_ScMW->setAppMode(m_previousMode < 0 ? modeNormal : m_previousMode);
                                         m_previousMode = -1;
                                 }
                                 else
                                 {
                                         m_previousMode = Doc->appMode;
                                         m_ScMW->setAppMode(modeEditClip);
                                 }
                                 return;
                                 */

                case submodeLoadPic:         // open GetImage dialog
                        appMode = Doc->appMode;
                        m_previousMode = appMode;
                        m_ScMW->slotGetContent();
                        break;
                case submodeStatusPic:       // open ManageImages dialog
                        appMode = Doc->appMode;
                        m_previousMode = appMode;
                        m_ScMW->StatusPic();
                        break;
                case submodeEditExternal:    // open external image editor
                        appMode = Doc->appMode;
                        m_previousMode = appMode;
                        m_ScMW->callImageEditor();
                        break;
                case submodeAnnotProps:
                        appMode = Doc->appMode;
                        m_previousMode = appMode;
                        m_ScMW->ModifyAnnot();
                        break;
                default:
                        if (appMode < 0 || appMode > submodeFirstSubmode)
                        {
                                qDebug() << "request mode: UNKNOWN" << appMode;
                                appMode = modeNormal;
                        }
                        m_previousMode = appMode;                      
                        break;
        }

        qDebug() << "request mode" << Doc->appMode << "-->" << appMode;
        if (Doc->appMode != appMode)
        {
                m_ScMW->setAppMode(appMode);
                CanvasMode* newCanvasMode = modeInstances.value(appMode);
                if (!newCanvasMode)
                {
                        newCanvasMode = CanvasMode::createForAppMode(this, appMode);
                        modeInstances[appMode] = newCanvasMode;
                }
                if (newCanvasMode)
                {
                        qDebug() << "request canvas mode" << typeid(*newCanvasMode).name();
                        m_canvasMode->deactivate(false);
                        m_canvasMode = newCanvasMode;
                        m_canvasMode->activate(false);
                }
                updateNecessary = true;
        }
        else
                m_ScMW->setAppMode(appMode);
        if (updateNecessary)
                updateCanvas();
}



/*
void ScribusView::paintEvent ( QPaintEvent * p )
{
        #ifndef _WIN32
        if (p->spontaneous())
                evSpon = true;
        #endif
        QScrollArea::paintEvent(p);
//      QPainter qp(viewport());
//      drawContents(&qp, p->rect().x(), p->rect().y(), p->rect().width(), p->rect().height());
}
*/


void ScribusView::enterEvent(QEvent * e)
{
        m_canvasMode->enterEvent(e);
        return;
        /*
        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
        {
                switch (Doc->appMode)
                {
                        case modeDrawShapes:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawFrame.xpm")));
                                break;
                        case modeDrawPicture:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawImageFrame.xpm")));
                                break;
                        case modeDrawLatex:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawLatexFrame.xpm")));
                                break;
                        case modeDrawText:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawTextFrame.xpm")));
                                break;
                        case modeDrawTable:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawTable.xpm")));
                                break;
                        case modeDrawRegularPolygon:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawPolylineFrame.xpm")));
                                break;
                        case modeDrawLine:
                        case modeDrawBezierLine:
                                qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
                                break;
                        case modeDrawFreehandLine:
                                qApp->changeOverrideCursor(QCursor(loadIcon("DrawFreeLine.png"), 0, 32));
                                break;
                        case modeMagnifier:
                                if (Magnify)
                                        qApp->changeOverrideCursor(QCursor(loadIcon("LupeZ.xpm")));
                                else
                                        qApp->changeOverrideCursor(QCursor(loadIcon("LupeZm.xpm")));
                                break;
                        case modePanning:
                                qApp->changeOverrideCursor(QCursor(loadIcon("HandC.xpm")));
                                break;
                        case modeMeasurementTool:
                        case modeEditGradientVectors:
                        case modeInsertPDFButton:
                        case modeInsertPDFTextfield:
                        case modeInsertPDFCheckbox:
                        case modeInsertPDFCombobox:
                        case modeInsertPDFListbox:
                        case modeInsertPDFTextAnnotation:
                        case modeInsertPDFLinkAnnotation:
                                qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
                                break;
                        default:
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
                        break;
                }
        }*/

}

void ScribusView::leaveEvent(QEvent *e)
{
        m_canvasMode->leaveEvent(e);
        return;
       
/*      if (BlockLeave)
                return; */

        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
/*      else
        {
                if ((SelItem.count() != 0) && (m_canvas->m_viewMode.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_canvas->m_viewMode.m_MouseButtonPressed = false;
                        doku->DraggedElem = 0;
                        doku->DragElements.clear();
                }
        } */

}

void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
{
        QString text;
//      e->accept(Q3TextDrag::canDecode(e));
        e->accept();
        if (e->mimeData()->hasText())
        {
                e->acceptProposedAction();
                text = e->mimeData()->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() / m_canvas->scale();
                        dragY = e->pos().y() / m_canvas->scale();
                        dragW = gw;
                        dragH = gh;
                        DraggedGroup = true;
                        DraggedGroupFirst = true;
                        getDragRectScreen(&gx, &gy, &gw, &gh);
//                      gx += Doc->minCanvasCoordinate.x();
//                      gy += Doc->minCanvasCoordinate.y();
                        QPoint evP = viewport()->mapToGlobal(e->pos());
                        evP -= QPoint(contentsX(), contentsY());
                        redrawMarker->setGeometry(QRect(evP.x() + 1, evP.y() + 1, qRound(gw), qRound(gh)).normalized());
                        if (!redrawMarker->isVisible())
                                redrawMarker->show();
                        emit ItemGeom(gw, gh);
                }
                delete ss;
                ss=NULL;
        }
}

void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
{
        QString text;
//      PageItem *currItem;
//      bool img;
//      e->accept(Q3TextDrag::canDecode(e));
        e->accept();
        if (e->mimeData()->hasText())
        {
                e->acceptProposedAction();
                text = e->mimeData()->text();
                if (DraggedGroup)
                {
                        double gx, gy, gw, gh;
                        dragX = e->pos().x() / m_canvas->scale();
                        dragY = e->pos().y() / m_canvas->scale();
                        getDragRectScreen(&gx, &gy, &gw, &gh);
//                      gx += Doc->minCanvasCoordinate.x();
//                      gy += Doc->minCanvasCoordinate.y();
                        QPoint evP = viewport()->mapToGlobal(e->pos());
                        evP -= QPoint(contentsX(), contentsY());
                        redrawMarker->setGeometry(QRect(evP.x() + 2, evP.y() + 2, qRound(gw - 2), qRound(gh - 2)).normalized());
                        if (!redrawMarker->isVisible())
                                redrawMarker->show();
                        DraggedGroupFirst = false;
                        emit MousePos(dragX, dragY); //+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).toUpper();
                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)
        {
                DraggedGroup = false;
                DraggedGroupFirst = false;
                m_canvas->resetRenderMode();
                redrawMarker->hide();
                updateContents();
        }
}

void ScribusView::contentsDropEvent(QDropEvent *e)
{
        QString text;
        PageItem *currItem;
        bool img = false;
        m_canvas->resetRenderMode();
        redrawMode = 0;
        redrawMarker->hide();
//      struct ScText *hg;
//      uint a;
        int re = 0;
//      e->accept(Q3TextDrag::canDecode(e));
        e->accept();
        DraggedGroupFirst = false;
        int ex = qRound(e->pos().x()/m_canvas->scale());// + Doc->minCanvasCoordinate.x());
                int ey = qRound(e->pos().y()/m_canvas->scale());// + Doc->minCanvasCoordinate.y());
        if (e->mimeData()->hasText())
        {
                e->acceptProposedAction();
                text = e->mimeData()->text();
                //<<#3524
                activateWindow();
                raise();
                m_ScMW->newActWin(Doc->WinHan);
                updateContents();
                //>>
                QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                QString ext = fi.suffix().toUpper();
                QStringList imfo;
                QList<QByteArray> imgs = QImageReader::supportedImageFormats();
                for (int i = 0; i < imgs.count(); ++i )
                {
                        imfo.append(QString(imgs.at(i)));
                }
                if (ext == "JPG")
                        ext = "JPEG";
                //CB Need to handle this ugly file extension list elsewhere... some capabilities class perhaps
                img = ((imfo.contains(ext)) || extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext) || extensionIndicatesTIFF(ext) || extensionIndicatesPSD(ext));
                bool selectedItemByDrag=false;
                int pscx=qRound(e->pos().x()/m_canvas->scale()), pscy=qRound(e->pos().y()/m_canvas->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 (int 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);
                                        updateContents();
                                }
                        }
                        /* 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);
//                      }
                        Deselect(true);
                        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.suffix().toLower() == "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.suffix().toLower() == "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);
                                Selection tmpSelection(this, false);
                                tmpSelection.copy(*Doc->m_Selection, false, true);
                                for (int as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                {
                                        currItem = Doc->Items->at(as);
                                        Doc->setRedrawBounding(currItem);
                                        tmpSelection.addItem(currItem, true);
                                        if (currItem->isBookmark)
                                                emit AddBM(currItem);
                                }
                                Doc->m_Selection->copy(tmpSelection, false, false);
                                undoManager->commit();
                        }
                        else
                        {
                                if (Doc->DraggedElem != 0)
                                {
                                        if (!Doc->leaveDrag)
                                        {
                                                QMenu *pmen = new QMenu();
                                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
                                                pmen->addAction( tr("Copy Here"));
                                                QAction* mov = pmen->addAction( tr("Move Here"));
                                                pmen->addAction( tr("Cancel"));
                                                for (int dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        if (Doc->Items->at(Doc->DragElements[dre])->locked())
                                                        {
                                                                mov->setEnabled(false);
                                                                break;
                                                        }
                                                }
                                                re = pmen->actions().indexOf(pmen->exec(QCursor::pos()));
                                                delete pmen;
                                                pmen=NULL;
                                        }
                                        else
                                                re = 1;
                                        if ((re == 2) || (re == -1))
                                        {
                                                updateContents();
                                                return;
                                        }
                                        if ((re == 1) || (Doc->leaveDrag))
                                        {
                                                QList<PageItem*> pasted;
                                                emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
                                                for (int as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                                {
                                                        pasted.append(Doc->Items->at(as));
                                                }
                                                Selection tmpSelection(this, false);
                                                tmpSelection.copy(*Doc->m_Selection, false, true);
                                                for (int dre=0; dre<Doc->DragElements.count(); ++dre)
                                                {
                                                        tmpSelection.addItem(Doc->Items->at(Doc->DragElements[dre]), true);
                                                }
                                                Doc->m_Selection->copy(tmpSelection, false, false);
                                                PageItem* bb;
                                                int fin;
                                                for (int 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();
                                Selection tmpSelection(this, false);
                                tmpSelection.copy(*Doc->m_Selection, false, true);
                                for (int as = oldDocItemCount; as < Doc->Items->count(); ++as)
                                {
                                        currItem = Doc->Items->at(as);
                                        Doc->setRedrawBounding(currItem);
                                        tmpSelection.addItem(currItem, true);
                                        if (currItem->isBookmark)
                                                emit AddBM(currItem);
                                }
                                Doc->m_Selection->copy(tmpSelection, false, false);
                        }
                        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 (int 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::normalizeSelectionRect() // unsused
{
        if(Mxp > SeRx)
        {
                int tmp = SeRx;
                SeRx = Mxp;
                Mxp = tmp;
        }
        if(Myp > SeRy)
        {
                int tmp = SeRy;
                SeRy = Myp;
                Myp = tmp;
        }
}
*/



void ScribusView::getDragRectScreen(double *x, double *y, double *w, double *h)
{
        QPoint in(qRound(dragX*m_canvas->scale()), qRound(dragY*m_canvas->scale()));
//      in -= QPoint(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(Doc->minCanvasCoordinate.y() * m_canvas->scale()));
        QPoint out = contentsToViewport(in);
        *x = static_cast<double>(out.x());
        *y = static_cast<double>(out.y());
        *w = dragW*m_canvas->scale();
        *h = dragH*m_canvas->scale();
}

void ScribusView::getGroupRectScreen(double *x, double *y, double *w, double *h)
{
        double gx, gy, gh, gw;
        Doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
        QPoint in(qRound(gx*m_canvas->scale()), qRound(gy*m_canvas->scale()));
//      in -= QPoint(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(Doc->minCanvasCoordinate.y() * m_canvas->scale()));
        QPoint out = contentsToViewport(in);
        *x = static_cast<double>(out.x());
        *y = static_cast<double>(out.y());
        *w = gw*m_canvas->scale();
        *h = gh*m_canvas->scale();
}


#if 0
void ScribusView::ToView(QPainter *p)
{
        QPoint out(contentsToViewport(QPoint(0, 0)));
//      p->translate(qRound(-Doc->minCanvasCoordinate.x()*m_canvas->scale()), qRound(-Doc->minCanvasCoordinate.y()*m_canvas->scale()));
        p->translate(out.x(), out.y());
}

void ScribusView::ToView(QMatrix& m)
{
        QPoint out(contentsToViewport(QPoint(0, 0)));
//      m.translate(qRound(-Doc->minCanvasCoordinate.x()*m_canvas->scale()), qRound(-Doc->minCanvasCoordinate.y()*m_canvas->scale()));
        m.translate(out.x(), out.y());
}

void ScribusView::RefreshItem(PageItem *currItem)
{
        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
}
#endif


void ScribusView::RefreshGradient(PageItem *currItem, double dx, double dy)
{
        QMatrix matrix;
        QRect rect = currItem->getRedrawBounding(m_canvas->scale());
        m_canvas->Transform(currItem, matrix);
        FPointArray fpNew;
        fpNew.setPoints(2, currItem->GrStartX, currItem->GrStartY, currItem->GrEndX, currItem->GrEndY);
        fpNew.map(matrix);
        if (dx < 8.0) dx = 8.0;
        if (dy < 8.0) dy = 8.0;
        int grl = (int) floor( qMin(fpNew.point(0).x(), fpNew.point(1).x()) - dx );
        int grr = (int) ceil ( qMax(fpNew.point(0).x(), fpNew.point(1).x()) + dx );
        int grb = (int) ceil ( qMax(fpNew.point(0).y(), fpNew.point(1).y()) + dy );
        int grt = (int) floor( qMin(fpNew.point(0).y(), fpNew.point(1).y()) - dy );
        rect |= QRect(grl, grt, grr-grl, grb-grt);
        updateContents(rect);
}


//CB-->elsewhere, util, however, only used in the view for now
bool ScribusView::PointOnLine(QPoint Start, QPoint End, QRect MArea)
{
        QPoint an, en;
        if (Start.x() == End.x())
        {
                an = Start.y() > End.y() ? End : Start;
                en = an == End ? Start : End;
                for (int a=an.y(); a<en.y(); ++a)
                {
                        if (MArea.contains(an.x(), a))
                                return true;
                }
        }
        if (Start.y() == End.y())
        {
                an = Start.x() > End.x() ? End : Start;
                en = an == End ? Start : End;
                for (int a=an.x(); a<en.x(); ++a)
                {
                        if (MArea.contains(a, an.y()))
                                return true;
                }
        }
        if (abs(Start.x() - End.x()) > abs(Start.y() - End.y()))
        {
                an = Start.x() > End.x() ? End : Start;
                en = an == End ? Start : End;
                double stg = (en.y() - an.y()) / static_cast<double>((en.x() - an.x()));
                for (int a = an.x(); a < en.x(); ++a)
                {
                        if (MArea.contains(a, an.y()+qRound((a-an.x())*stg)))
                                return true;
                }
        }
        else
        {
                an = Start.y() > End.y() ? End : Start;
                en = an == End ? Start : End;
                double stg = (en.x() - an.x()) / static_cast<double>((en.y() - an.y()));
                for (int a = an.y(); a < en.y(); ++a)
                {
                        if (MArea.contains(an.x()+qRound((a-an.y())*stg), a))
                                return true;
                }
        }
        return false;
}

//CB-->Doc??
void ScribusView::TransformPoly(int mode, int rot, double scaling)
{
        PageItem *currItem = Doc->m_Selection->itemAt(0);
        currItem->ClipEdited = true;
        QMatrix ma;
        if (Doc->nodeEdit.isContourLine)
        {
                FPoint tp2(getMinClipF(&currItem->ContourLine));
                FPoint tp(getMaxClipF(&currItem->ContourLine));
                currItem->ContourLine.translate(-qRound((tp.x() + tp2.x()) / 2.0), -qRound((tp.y() + tp2.y()) / 2.0));
                switch (mode)
                {
                case 0:
                        ma.rotate(-rot);
                        break;
                case 1:
                        ma.rotate(rot);
                        break;
                case 2:
                        ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                        break;
                case 3:
                        ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                        break;
                case 4:
                        ma.shear(0.017455, 0);
                        break;
                case 5:
                        ma.shear(-0.017455, 0);
                        break;
                case 6:
                        ma.shear(0, -0.017455);
                        break;
                case 7:
                        ma.shear(0, 0.017455);
                        break;
                case 8:
                        ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                        break;
                case 9:
                        ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                        break;
                //10-13 are for scaling the contour line in shape edit mode
                case 10:
                        {
                                double s=1.0 - (scaling/(tp2.x() - tp.x()));
                                ma.scale(s, 1);
                                ma.translate(-scaling/s/2,0);
                        }
                        break;
                case 11:
                        {
                                double s=1.0 - (scaling/(tp2.x() - tp.x()));
                                ma.scale(s, 1);
                                ma.translate(scaling/s/2,0);
                        }
                        break;
                case 12:
                        {
                                double s=1.0 - (scaling/(tp2.y() - tp.y()));
                                ma.scale(1, s);
                                ma.translate(0,-scaling/s/2);
                        }
                        break;
                case 13:
                        {
                                double s=1.0 - (scaling/(tp2.y() - tp.y()));
                                ma.scale(1, s);
                                ma.translate(0,scaling/s/2);
                        }
                        break;
                }
                currItem->ContourLine.map(ma);
                currItem->ContourLine.translate(qRound((tp.x() + tp2.x()) / 2.0), qRound((tp.y() + tp2.y()) / 2.0));
                updateContents();
                currItem->FrameOnly = true;
                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                if (UndoManager::undoEnabled())
                {
                        undoManager->setUndoEnabled(false);
                        currItem->checkChanges(true);
                        undoManager->setUndoEnabled(true);
                        SimpleState *ss = new SimpleState(Um::EditContourLine, "", Um::IBorder);
                        ss->set("EDIT_CONTOUR", "edit_contour");
                        ss->set("MODE", mode);
                        ss->set("ROT", rot);
                        ss->set("SCALING", scaling);
                        undoManager->action(currItem, ss);
                }
                emit DocChanged();
                return;
        }
        FPoint oldPos(currItem->xyPos());
        double offsX = currItem->width() / 2.0;
        double offsY = currItem->height() / 2.0;
        ma.translate(-offsX, -offsY);
        switch (mode)
        {
        case 0:
                ma.rotate(-rot);
                break;
        case 1:
                ma.rotate(rot);
                break;
        case 2:
                ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                break;
        case 3:
                ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                break;
        case 4:
                ma.shear(0.017455, 0);
                break;
        case 5:
                ma.shear(-0.017455, 0);
                break;
        case 6:
                ma.shear(0, -0.017455);
                break;
        case 7:
                ma.shear(0, 0.017455);
                break;
        case 8:
                ma.scale(1.0 - (scaling / currItem->width()),1.0 - (scaling / currItem->height()));
                break;
        case 9:
                ma.scale(1.0 + (scaling / currItem->width()),1.0 + (scaling / currItem->height()));
                break;
        }
        currItem->PoLine.map(ma);
        currItem->PoLine.translate(offsX, offsY);
        Doc->AdjustItemSize(currItem);
        QMatrix ma2;
        ma2.translate(oldPos.x(), oldPos.y());
        ma2.scale(1, 1);
        ma2.translate(offsX, offsY);
        FPoint n(-offsX, -offsY);
        switch (mode)
        {
        case 0:
                ma2.rotate(-rot);
                break;
        case 1:
                ma2.rotate(rot);
                break;
        case 2:
                ma2.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                break;
        case 3:
                ma2.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                break;
        case 4:
                ma2.shear(0.017455, 0);
                break;
        case 5:
                ma2.shear(-0.017455, 0);
                break;
        case 6:
                ma2.shear(0, -0.017455);
                break;
        case 7:
                ma2.shear(0, 0.017455);
                break;
        case 8:
                ma2.scale(1.0 - (scaling / currItem->width()),1.0 - (scaling / currItem->height()));
                break;
        case 9:
                ma2.scale(1.0 + (scaling / currItem->width()),1.0 + (scaling / currItem->height()));
                break;
        }
        double x = ma2.m11() * n.x() + ma2.m21() * n.y() + ma2.dx();
        double y = ma2.m22() * n.y() + ma2.m12() * n.x() + ma2.dy();
        Doc->MoveItem(x-oldPos.x(), y-oldPos.y(), currItem);
        if (currItem->asPathText())
                currItem->updatePolyClip();
        Doc->setRedrawBounding(currItem);
        currItem->update();
//      MarkClip(currItem, currItem->PoLine, true);
        currItem->FrameType = 3;
        if (UndoManager::undoEnabled())
        {
                undoManager->setUndoEnabled(false);
                currItem->checkChanges(true);
                undoManager->setUndoEnabled(true);
                SimpleState *ss = new SimpleState(Um::EditShape, "", Um::IBorder);
                ss->set("EDIT_SHAPE", "edit_shape");
                ss->set("MODE", mode);
                ss->set("ROT", rot);
                ss->set("SCALING", scaling);
                undoManager->action(currItem, ss);
        }
        emit DocChanged();
}

/*
void ScribusView::Reset1Control()
{
        Doc->nodeEdit.reset1Control(Doc->m_Selection->itemAt(0));
}

void ScribusView::ResetControl()
{
        PageItem *currItem = Doc->m_Selection->itemAt(0);
        Doc->nodeEdit.resetControl(currItem);
}
*/



//CB-->Doc
void ScribusView::moveGroup(double x, double y, bool fromMP, Selection* customSelection)
{
        Selection* itemSelection = (customSelection!=0) ? customSelection : Doc->m_Selection;
        Q_ASSERT(itemSelection!=0);
        uint selectedItemCount=itemSelection->count();
        if (selectedItemCount == 0)
                return;
       
        if (!_groupTransactionStarted && selectedItemCount > 1)
        {
                QString tooltip = Um::ItemsInvolved + "\n";
                for (uint i = 0; i < selectedItemCount; ++i)
                        tooltip += "\t" + itemSelection->itemAt(i)->getUName() + "\n";
                undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup,
                                                                          Um::Move, tooltip, Um::IMove);
                _groupTransactionStarted = true;
        }

        Doc->moveGroup(x, y, fromMP, itemSelection);
}

//CB-->Doc
void ScribusView::RotateGroup(double win)
{
        if (!_groupTransactionStarted && Doc->m_Selection->count() > 1)
        {
                QString tooltip = Um::ItemsInvolved + "\n";
                for (int i = 0; i < Doc->m_Selection->count(); ++i)
                        tooltip += "\t" + Doc->m_Selection->itemAt(i)->getUName() + "\n";
                undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup,
                                                                          Um::Rotate, tooltip, Um::IRotate);
                _groupTransactionStarted = true;
        }
       
        Doc->rotateGroup(win, RCenter);
}



void ScribusView::scaleGroup(double scx, double scy, bool scaleText, Selection* customSelection)
{
        Selection* itemSelection = (customSelection!=0) ? customSelection : Doc->m_Selection;
        Q_ASSERT(itemSelection!=0);
        uint selectedItemCount=itemSelection->count();
        if (selectedItemCount == 0)
                return;
       
        if (!_groupTransactionStarted && selectedItemCount > 1)
        {
                QString tooltip = Um::ItemsInvolved + "\n";
                for (uint i = 0; i < selectedItemCount; ++i)
                        tooltip += "\t" + itemSelection->itemAt(i)->getUName() + "\n";
                undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup,
                                                                          Um::Resize, tooltip, Um::IResize);
                _groupTransactionStarted = true;
        }

        Doc->scaleGroup(scx, scy, scaleText, itemSelection);
        emit DocChanged();
}

bool ScribusView::slotSetCurs(int x, int y)
{
        PageItem *currItemGeneric;
        if (GetItem(&currItemGeneric))
        {
                if (!((currItemGeneric->asTextFrame()) || (currItemGeneric->asImageFrame())))
                        return false;
                // unsed by gcc warning - PV
                //int xP = qRound(x/m_canvas->scale() + Doc->minCanvasCoordinate.x());
                //int yP = qRound(y/m_canvas->scale() + Doc->minCanvasCoordinate.y());
                QMatrix p;
//              p.begin(this);
                m_canvas->Transform(currItemGeneric, p);
//              p.translate(qRound(-Doc->minCanvasCoordinate.x()), qRound(-Doc->minCanvasCoordinate.y()));
                if (currItemGeneric->asImageFrame())
                        return true;
                PageItem_TextFrame *currItem=currItemGeneric->asTextFrame();
                if (currItem==0)
                        return false;
                QRect mpo(x - Doc->guidesSettings.grabRad, y - Doc->guidesSettings.grabRad, Doc->guidesSettings.grabRad*2, Doc->guidesSettings.grabRad*2);
                if ((QRegion(p.map(QPolygon(QRect(0, 0, static_cast<int>(currItem->width()), static_cast<int>(currItem->height()))))).contains(mpo)) ||
                        (QRegion(p.map(currItem->Clip)).contains(mpo)))
                {
        //              m_cursorVisible = true;
#if 0
//#ifndef NLS_PROTO
                        //Work out which column we are in
                        double colWidth=currItem->columnWidth();
                        double colGap=currItem->ColGap;
                        int currCol=0;
                        int cp=static_cast<int>(currItem->xPos()+currItem->textToFrameDistLeft()+qRound(colGap)+qRound(colWidth));
                        while (xP>cp)
                        {
                                ++currCol;
                                cp+=qRound(colGap);
                                cp+=qRound(colWidth);
                        };
                        int a, xp=0, yp=0, h;
                        bool breakAndReturn=false;
                        int currItemTextCount=currItem->itemText.length();
                        for (a = currItem->firstInFrame(); a <= currItem->lastInFrame(); ++a)
                        {
                                xp = static_cast<int>(currItem->itemText.item(a)->glyph.xoffset);
                                //If x pos of curr char is less than left position of current column, continue
                                if (xp+currItem->xPos()<cp-colWidth-colGap)
                                        continue;
                                yp = static_cast<int>(currItem->itemText.item(a)->glyph.yoffset);
                                h = static_cast<int>(currItem->itemText.paragraphStyle(a).lineSpacing());

                                if (a<currItemTextCount-1)
                                {
                                        if ((xp+currItem->xPos()+1>=xP) && (yp+currItem->yPos()>=yP))
                                        {
                                                //beginning of new paragraph or not
                                                if (((currItem->itemText.text(a) == m_canvas->setRenderModeFillBufferChars::PARSEP) || (currItem->itemText.text(a) == SpecialChars::LINEBREAK)))
                                                        currItem->CPos = a+1;
                                                else
                                                        currItem->CPos = a;
                                                p.end();
                                                breakAndReturn=true;
                                                break;
                                        }
                                        if (yp-h+currItem->yPos()<=yP && yp+currItem->yPos()>=yP)
                                        {
                                                //click where next char is on next line in same or next column
                                                if (static_cast<int>(currItem->itemText.item(a+1)->glyph.yoffset)!=yp)
                                                {
                                                        if (((currItem->itemText.text(a+1) == SpecialChars::PARSEP) || (currItem->itemText.text(a+1) == SpecialChars::LINEBREAK)))
                                                                currItem->CPos = a+1;
                                                        else
                                                                currItem->CPos = a;
                                                        p.end();
                                                        breakAndReturn=true;
                                                        break;
                                                }
                                        }
                                }

                                /* CB old, rather complicated code...
                                chx = currItem->itemText.at(a)->ch;
                                if (chx == QChar(30))
                                        chx = currItem->ExpandToken(a);
                                if (chx == QChar(29))
                                        chx = " ";
                                chs = currItem->itemText.at(a)->csize;
                                currItem->SetZeichAttr(currItem->itemText.charStyle(a), &chs, &chx);
                                if ((chx == QChar(13)) || (chx == QChar(9)) || (chx == QChar(27)))
                                        w = 1;
                                else
                                        w = qRound(Cwidth(Doc, currItem->itemText.at(a)->cfont, chx, chs)*(currItem->itemText.at(a)->cscale / 1000.0));
                                h = static_cast<int>(Doc->docParagraphStyles[currItem->itemText.at(a)->cab].LineSpa);
                                //If we click within text
                                if (QRegion(p.xForm(QRect(xp-1, yp-h, w+1, h))).contains(QPoint(x, y)))
                                {
                                        currItem->CPos = a;
                                        p.end();
                                        breakAndReturn=true;
                                        break;
                                }
                                //If we are not at the end of the text and the next characters y position > current one
                                //IE, we are at the end of the line
                                else if ((a<currItemTextCount-1) && (static_cast<int>(currItem->itemText.at(a+1)->yp)>yp))
                                {
                                        //If one column only and we are within the width of the frame
                                        //Yes, some people want selection outside the frame to work too, this works ok for now
                                        if ((currItem->Cols==1) && (QRegion(p.xForm(QRect(xp-1, yp-h, static_cast<int>(currItem->width()-xp-1), h))).contains(QPoint(x, y))))
                                        {
                                                currItem->CPos = a;
                                                p.end();
                                                breakAndReturn=true;
                                                break;
                                        }
                                        //If columns>1, then work out what column we are in and place our cursor
                                        //TODO: Move this column placement code into PageItem_TextFrame.
                                        else if (currItem->Cols>1)
                                        {
                                                double colWidth=currItem->columnWidth();
                                                int currCol=0;
                                                int cp=static_cast<int>(currItem->xPos()+currItem->textToFrameDistLeft());
                                                do
                                                {
                                                        ++currCol;
                                                        cp+=qRound(currItem->ColGap);
                                                        if (currCol>1)
                                                                cp+=qRound(colWidth);
                                                } while (xp>cp);
                                                if (QRegion(p.xForm(QRect(xp-1, yp-h, static_cast<int>(cp-xp-1), h))).contains(QPoint(x, y)))
                                                {
                                                        currItem->CPos = a;
                                                        p.end();
                                                        breakAndReturn=true;
                                                        break;
                                                }
                                        }
                                }*/

                        }
                        if (breakAndReturn)
                        {
                                Doc->currentStyle.charStyle() = currItem->itemText.charStyle(a);
                                emit ItemTextStrike(currItem->itemText.charStyle(a).strikethruOffset(), currItem->itemText.charStyle(a).strikethruWidth());
                                emit ItemTextUnderline(currItem->itemText.charStyle(a).underlineOffset(), currItem->itemText.charStyle(a).underlineWidth());
                                emit ItemTextOutline(currItem->itemText.charStyle(a).outlineWidth());
                                emit ItemTextShadow(currItem->itemText.charStyle(a).shadowXOffset(), currItem->itemText.charStyle(a).shadowYOffset());
                                emit ItemTextBase(currItem->itemText.charStyle(a).baselineOffset());
                                emit ItemTextSca(currItem->itemText.charStyle(a).scaleH());
                                emit ItemTextScaV(currItem->itemText.charStyle(a).scaleV());
                                emit ItemTextFont(currItem->itemText.charStyle(a).font().scName());
                                emit ItemTextSize(currItem->itemText.charStyle(a).fontSize());
                                emit ItemTextUSval(currItem->itemText.charStyle(a).tracking());
                                emit ItemTextStil(currItem->itemText.charStyle(a).effects());
                                emit ItemTextAbs(currItem->itemText.paragraphStyle(a).alignment());
                                emit ItemTextFarben(currItem->itemText.charStyle(a).strokeColor(), currItem->itemText.charStyle(a).fillColor(), currItem->itemText.charStyle(a).strokeShade(), currItem->itemText.charStyle(a).fillShade());
                                return true;
                        }

                        /*currItemTextCount=currItem->itemText.count();
                        qDebug(QString("%1").arg(2));
                        for (a=0; a<currItemTextCount; ++a)
                        {
                                xp = static_cast<int>(currItem->itemText.at(a)->xp);
                                yp = static_cast<int>(currItem->itemText.at(a)->yp);
                                QPoint np = p.xForm(QPoint(xp, yp - static_cast<int>(Doc->docParagraphStyles[currItem->itemText.at(a)->cab].LineSpa)));
                                if (yP < np.y())
                                {
                                        currItem->CPos = a;
                                        p.end();
                                        uint i=a;
                                        if (a > 0)
                                                i--;
                                        Doc->CurrFont = currItem->itemText.at(i)->cfont->scName();
                                        Doc->CurrFontSize = currItem->itemText.at(i)->csize;
                                        Doc->CurrTextFill = currItem->itemText.at(i)->ccolor;
                                        Doc->CurrTextFillSh = currItem->itemText.at(i)->cshade;
                                        Doc->CurrTextStroke = currItem->itemText.at(i)->cstroke;
                                        Doc->CurrTextStrokeSh = currItem->itemText.at(i)->cshade2;
                                        Doc->CurrTextScale = currItem->itemText.at(i)->cscale;
                                        Doc->CurrTextScaleV = currItem->itemText.at(i)->cscalev;
                                        Doc->CurrTextBase = currItem->itemText.at(i)->cbase;
                                        Doc->CurrTextShadowX = currItem->itemText.at(i)->cshadowx;
                                        Doc->CurrTextShadowY = currItem->itemText.at(i)->cshadowy;
                                        Doc->CurrTextOutline = currItem->itemText.at(i)->coutline;
                                        Doc->CurrTextUnderPos = currItem->itemText.at(i)->cunderpos;
                                        Doc->CurrTextUnderWidth = currItem->itemText.at(i)->cunderwidth;
                                        Doc->CurrTextStrikePos = currItem->itemText.at(i)->cstrikepos;
                                        Doc->CurrTextStrikeWidth = currItem->itemText.at(i)->cstrikewidth;
                                        emit ItemTextStrike(currItem->itemText.at(i)->cstrikepos, currItem->itemText.at(i)->cstrikewidth);
                                        emit ItemTextUnderline(currItem->itemText.at(i)->cunderpos, currItem->itemText.at(i)->cunderwidth);
                                        emit ItemTextOutline(currItem->itemText.at(i)->coutline);
                                        emit ItemTextShadow(currItem->itemText.at(i)->cshadowx, currItem->itemText.at(i)->cshadowy);
                                        emit ItemTextSca(currItem->itemText.at(i)->cscale);
                                        emit ItemTextScaV(currItem->itemText.at(i)->cscalev);
                                        emit ItemTextFarben(currItem->itemText.at(i)->cstroke, currItem->itemText.at(i)->ccolor, currItem->itemText.at(i)->cshade2, currItem->itemText.at(i)->cshade);
                                        emit ItemTextFont(currItem->itemText.at(i)->cfont->scName());
                                        emit ItemTextSize(currItem->itemText.at(i)->csize);
                                        emit ItemTextUSval(currItem->itemText.at(i)->cextra);
                                        emit ItemTextStil(currItem->itemText.at(i)->cstyle);
                                        emit ItemTextAbs(currItem->itemText.at(i)->cab);
                                        emit ItemTextBase(currItem->itemText.at(i)->cbase);
                                        return true;
                                }
                        }
                        */

                        //End of text in frame
                        if (currItem->itemText.length() != 0)
                        {
                                a=currItem->lastInFrame();
                                int w = qRound(currItem->itemText.charStyle(a).font().charWidth(currItem->itemText.text(a), currItem->itemText.charStyle(a).fontSize())*(currItem->itemText.charStyle(a).scaleH() / 1000.0));
                                if (xp+currItem->xPos()+w<xP || yp+currItem->yPos()<yP)
                                        currItem->CPos = a+1;
                                else
                                        currItem->CPos = a;
                        }
                        else
                                currItem->CPos = 0;
                        p.end();

#else
                        FPoint point((x + 0*Doc->minCanvasCoordinate.x()) / m_canvas->scale() - currItem->xPos(),
                                                 (y + 0*Doc->minCanvasCoordinate.x()) / m_canvas->scale() - currItem->yPos());
                        currItem->CPos = currItem->itemText.length() == 0 ? 0 :
                                currItem->itemText.screenToPosition(point);                    
#endif
                       
                        if (currItem->itemText.length() > 0)
                        {
                                int b=currItem->CPos-1;
                                if (b<0)
                                        b=0;
                                Doc->currentStyle.charStyle() = currItem->itemText.charStyle(b);
                                emit ItemTextStrike(Doc->currentStyle.charStyle().strikethruOffset(), Doc->currentStyle.charStyle().strikethruWidth());
                                emit ItemTextUnderline(Doc->currentStyle.charStyle().underlineOffset(), Doc->currentStyle.charStyle().underlineWidth());
                                emit ItemTextOutline(Doc->currentStyle.charStyle().outlineWidth());
                                emit ItemTextShadow(Doc->currentStyle.charStyle().shadowXOffset(), Doc->currentStyle.charStyle().shadowYOffset());
                                emit ItemTextSca(Doc->currentStyle.charStyle().scaleH());
                                emit ItemTextScaV(Doc->currentStyle.charStyle().scaleV());
                                emit ItemTextFarben(Doc->currentStyle.charStyle().strokeColor(), Doc->currentStyle.charStyle().fillColor(), Doc->currentStyle.charStyle().strokeShade(), Doc->currentStyle.charStyle().fillShade());
                                emit ItemTextFont(Doc->currentStyle.charStyle().font().scName());
                                emit ItemTextSize(Doc->currentStyle.charStyle().fontSize());
                                emit ItemTextUSval(Doc->currentStyle.charStyle().tracking());
                                emit ItemTextStil(Doc->currentStyle.charStyle().effects());
                                emit ItemTextAbs(currItem->itemText.paragraphStyle(b).alignment());
                                emit ItemTextBase(Doc->currentStyle.charStyle().baselineOffset());
                                return true;
                        }
                        else
                        {
                                Doc->currentStyle.charStyle() = currItem->itemText.defaultStyle().charStyle();
                                emit ItemTextStrike(currItem->itemText.defaultStyle().charStyle().strikethruOffset(), currItem->itemText.defaultStyle().charStyle().strikethruWidth());
                                emit ItemTextUnderline(currItem->itemText.defaultStyle().charStyle().underlineOffset(), currItem->itemText.defaultStyle().charStyle().underlineWidth());
                                emit ItemTextOutline(currItem->itemText.defaultStyle().charStyle().outlineWidth());
                                emit ItemTextShadow(currItem->itemText.defaultStyle().charStyle().shadowXOffset(), currItem->itemText.defaultStyle().charStyle().shadowYOffset());
                                emit ItemTextSca(currItem->itemText.defaultStyle().charStyle().scaleH());
                                emit ItemTextScaV(currItem->itemText.defaultStyle().charStyle().scaleV());
                                emit ItemTextFarben(currItem->itemText.defaultStyle().charStyle().strokeColor(), currItem->itemText.defaultStyle().charStyle().fillColor(), currItem->itemText.defaultStyle().charStyle().strokeShade(), currItem->itemText.defaultStyle().charStyle().fillShade());
                                emit ItemTextFont(currItem->itemText.defaultStyle().charStyle().font().scName());
                                emit ItemTextSize(currItem->itemText.defaultStyle().charStyle().fontSize());
                                emit ItemTextUSval(currItem->itemText.defaultStyle().charStyle().tracking());
                                emit ItemTextStil(currItem->itemText.defaultStyle().charStyle().effects());
                                emit ItemTextAbs( 0 );
                                emit ItemTextBase(currItem->itemText.defaultStyle().charStyle().baselineOffset());
                                return true;
                        }
                }
        }
        return false;
}

void ScribusView::slotDoCurs(bool draw)
{
//      disabling that function for now
        return;

        PageItem *currItem;
        if (GetItem(&currItem))
        {
                PageItem_TextFrame * textframe = currItem->asTextFrame();
                if ( !textframe )
                        return;
               
                // don't mess around with itemText when layout() is about to happen
                if (currItem->invalid)
                        return;
               
                //              textframe->lastTextItem = qMin(textframe->lastTextItem,
                //                                             signed(textframe->itemText.nrOfItems()) - 1);
               
                if (textframe->firstInFrame() >= 0
                        && ((textframe->lastInFrame() >= textframe->firstInFrame()
                                 && textframe->CPos >= textframe->itemText.startOfItem(textframe->firstInFrame())
                                 && textframe->CPos <= textframe->itemText.endOfItem(textframe->lastInFrame())
                                 )
                                ||
                                textframe->CPos >= textframe->itemText.length()
                                )
                        )
                {
//                      QPainter p;
//                      p.begin(viewport());
//                      ToView(&p);
//                      m_canvas->Transform(textframe, &p);
//                      m_canvas->TransformM(textframe, &p);
                       
                        if (Doc->CurTimer != 0)
                                Doc->CurTimer->stop();
                       
                        int x, y, y1;
#ifdef NLS_PROTO
                        if (textframe->CPos == textframe->itemText.endOfItem(textframe->lastInFrame()))
                        {
                                ScScriptItem * last = textframe->itemText.item(textframe->lastInFrame());
                                x = static_cast<int>(last->x + last->naturalWidth);
                                y = static_cast<int>(last->y);
                                y1 = static_cast<int>(last->y - 12);
                                qDebug(QString("cursor at end (%1,%2)").arg(x).arg(y));
                        }
                        else
                        {
                                glyph_metrics_t bbox = textframe->itemText.boundingBox(textframe->CPos);
                                x = static_cast<int>(bbox.x);
                                y = static_cast<int>(bbox.y);
                                y1 = static_cast<int>(bbox.y - bbox.height);
//                              qDebug(QString("cursor at (%1,%2) + %3").arg(bbox.x).arg(bbox.y).arg(bbox.height));
                        }
#else
                        if (textframe->CPos > textframe->itemText.length())
                        {
                                textframe->CPos = textframe->itemText.length();
                        }
                        if (textframe->lastInFrame() >= signed(textframe->itemText.nrOfItems())
                                || textframe->itemText.length() == 0)
                        {
                                x = 0;
                                y = 0;
                                y1 = static_cast<int>(textframe->itemText.defaultStyle().charStyle().fontSize() / 10);
                        }
                        else if ( textframe->CPos > textframe->itemText.endOfItem(textframe->lastInFrame())
                                          || (textframe->CPos >= textframe->itemText.length() && textframe->itemText.text(textframe->itemText.length()-1) != SpecialChars::PARSEP) )
                        {
                                FRect bbox = textframe->itemText.boundingBox(qMax(0,qMin(textframe->lastInFrame(), textframe->itemText.length()-1)));
                                x = static_cast<int>(bbox.x() + textframe->itemText.item(qMax(0,qMin(textframe->lastInFrame(), textframe->itemText.length()-1)))->glyph.wide());
                                y = static_cast<int>(bbox.y());
                                if (bbox.height() <= 2)
                                        y1 = static_cast<int>(bbox.y() + textframe->itemText.defaultStyle().charStyle().fontSize() / 30);
                                else
                                        y1 = static_cast<int>(bbox.y() + bbox.height());
                        }
                        else
                        {
                                FRect bbox = textframe->itemText.boundingBox(qMax(0,qMin(textframe->CPos, textframe->itemText.length())));
                                x = static_cast<int>(bbox.x());
                                y = static_cast<int>(bbox.y());
                                if (bbox.height() <= 2)
                                        y1 = static_cast<int>(bbox.y() + textframe->itemText.charStyle(textframe->CPos).fontSize() / 30);
                                else
                                        y1 = static_cast<int>(bbox.y() + bbox.height());
                        }
#endif
                        // avoid displaying the cursor on the frameborder
                        if (x < 1)
                                x = 1;
/*
 p.setPen(QPen(Qt::white, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
                        p.setCompositionMode(QPainter::CompositionMode_Xor);
                        if (draw)
                        {
                                p.drawLine(x, qMin(qMax(y,0),static_cast<int>(currItem->height())),
                                                   x, qMin(qMax(y1,0),static_cast<int>(currItem->height())));
                                m_cursorVisible = !m_cursorVisible;
                        if (Doc->CurTimer != 0)
                                {
                                        if (!Doc->CurTimer->isActive())
                                                Doc->CurTimer->start(500);
                                }
                        }
                        else
                        {
                                if (Doc->CurTimer != 0)
                                        Doc->CurTimer->stop();
                                if (m_cursorVisible)
                                        p.drawLine(x, qMin(qMax(y,0),static_cast<int>(currItem->height())),
                                                           x, qMin(qMax(y1,0),static_cast<int>(currItem->height())));
                                m_cursorVisible = false;
                        }
                        p.end();
 */

                }
        }
}

void ScribusView::blinkCursor()
{
//      disabling that function for now
        return;
        slotDoCurs(true);
}

void ScribusView::dragTimerTimeOut()
{
        dragTimerFired = true;
        qApp->changeOverrideCursor(QCursor(loadIcon("DragPix.xpm")));
}

void ScribusView::HandleCurs(PageItem *currItem, QRect mpo)
{
        QPoint tx, tx2;
        QMatrix ma;
//      ma.translate(-Doc->minCanvasCoordinate.x()*m_canvas->scale(), -Doc->minCanvasCoordinate.y()*m_canvas->scale());
        m_canvas->Transform(currItem, ma);
        tx = ma.map(QPoint(static_cast<int>(currItem->width()), 0));
        tx2 = ma.map(QPoint(0, static_cast<int>(currItem->height())));
        if (mpo.contains(tx) || mpo.contains(tx2))
        {
                if (Doc->appMode == modeRotation)
                        qApp->changeOverrideCursor(QCursor(loadIcon("Rotieren2.png")));
                else
                {
                        double rr = fabs(currItem->rotation());
                        if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >=315.0) && (rr <= 360.0)))
                                qApp->changeOverrideCursor(QCursor(Qt::SizeBDiagCursor));
                        if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
                                qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
                }
        }
        tx = ma.map(QPoint(static_cast<int>(currItem->width()), static_cast<int>(currItem->height())/2));
        tx2 = ma.map(QPoint(0, static_cast<int>(currItem->height())/2));
        if (mpo.contains(tx) || mpo.contains(tx2))
        {
                double rr = fabs(currItem->rotation());
                if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >= 315.0) && (rr <= 360.0)))
                        qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
                if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
                        qApp->changeOverrideCursor(QCursor(Qt::SizeVerCursor));
        }
        tx = ma.map(QPoint(static_cast<int>(currItem->width())/2, 0));
        tx2 = ma.map(QPoint(static_cast<int>(currItem->width())/2, static_cast<int>(currItem->height())));
        if (mpo.contains(tx) || mpo.contains(tx2))
        {
                double rr = fabs(currItem->rotation());
                if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >= 315.0) && (rr <= 360.0)))
                        qApp->changeOverrideCursor(QCursor(Qt::SizeVerCursor));
                if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
                        qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
        }
        tx = ma.map(QPoint(static_cast<int>(currItem->width()), static_cast<int>(currItem->height())));
        tx2 = ma.map(QPoint(0, 0));
        if (mpo.contains(tx) || mpo.contains(tx2))
        {
                if (Doc->appMode == modeRotation)
                        qApp->changeOverrideCursor(QCursor(loadIcon("Rotieren2.png")));
                else
                {
                        double rr = fabs(currItem->rotation());
                        if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) ||
                                ((rr >= 315.0) && (rr <= 360.0)))
                                qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
                        if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
                                qApp->changeOverrideCursor(QCursor(Qt::SizeBDiagCursor));
                }
        }
        if (Doc->appMode == modeEditClip)
                qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
}

void ScribusView::SelectItemNr(uint nr, bool draw, bool single)
{
        if (nr < static_cast<uint>(Doc->Items->count()))
                SelectItem(Doc->Items->at(nr), draw, single);
}

//CB-->Doc/Fix
void ScribusView::SelectItem(PageItem *currItem, bool draw, bool single)
{
        if (!currItem->isSelected())
        {
                if (single)
                {
                        Doc->m_Selection->addItem(currItem);
                        currItem->isSingleSel = true;
                        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                }
                else
                {
                        if (currItem->Groups.count() != 0)
                        {
                                if (Doc->m_Selection->count() != 0)
                                {
                                        if (Doc->m_Selection->findItem(currItem) == -1)
                                                Doc->m_Selection->addItem(currItem);
                                }
                                else
                                        Doc->m_Selection->addItem(currItem);
                               
                                for (int ga=0; ga<Doc->Items->count(); ++ga)
                                {
                                        if (Doc->Items->at(ga)->Groups.count() != 0)
                                        {
                                                if (Doc->Items->at(ga)->Groups.top() == currItem->Groups.top())
                                                {
                                                        if (Doc->Items->at(ga)->ItemNr != currItem->ItemNr)
                                                        {
                                                                if (Doc->m_Selection->findItem(Doc->Items->at(ga)) == -1)
                                                                        Doc->m_Selection->addItem(Doc->Items->at(ga));
                                                        }
                                                        if (draw)
                                                        {
                                                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                        }
                                                }
                                        }
                                }
                        }
                        else
                        {
                                Doc->m_Selection->addItem(currItem);
                                if (draw)
                                {
                                        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                }
                        }
                        //CB FIXME/TODO We are surely prepending here and we have turned off
                        //emitting in prepend below so do it here.
                        //Doc->m_Selection->itemAt(0)->emitAllToGUI();
                }
        }
        else
        {
        //CB Prepend used to occur to enable level changes to work properly, however with
        //current selection code we dont seem to need that anymore
        /*
                if (Doc->m_Selection->count() > 1)
                {
                        PageItem *bb = Doc->m_Selection->itemAt(0);
                        Doc->m_Selection->removeItem(currItem);
                        Doc->m_Selection->prependItem(currItem, false);
                        currItem->paintObj();
                        bb->paintObj();
                }*/

        }
        if (draw)
        {
                if (Doc->m_Selection->count() > 1)
                {
                        Doc->m_Selection->setGroupRect();
                        double x, y, w, h;
                        Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
                        emit ItemPos(x, y);
                        emit ItemGeom(w, h);
                        getGroupRectScreen(&x, &y, &w, &h);
                        updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
                        //CB move in here as the emitAllToGUI will do it otherwise
                        emit HaveSel(currItem->itemType());
                }
                //CB done by addItem for single selection or the frame data is already there
                //else
                        //EmitValues(currItem);
                        //currItem->emitAllToGUI();
        }
}

void ScribusView::selectionChanged()
{
        if (m_ScMW->isObjectSpecificUndo())
        {
                uint docSelectionCount=Doc->m_Selection->count();
                if (docSelectionCount == 1)
                        undoManager->showObject(Doc->m_Selection->itemAt(0)->getUId());
                else if (docSelectionCount == 0)
                        undoManager->showObject(Doc->currentPage()->getUId());
                else
                        undoManager->showObject(Um::NO_UNDO_STACK);
        }
}

#if 0
void ScribusView::selectPage(QMouseEvent *m)
{
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
        Mxp = static_cast<int>(m->x()/m_canvas->scale());
        Myp = static_cast<int>(m->y()/m_canvas->scale());
        QRect mpo(m->x()-Doc->guidesSettings.grabRad, m->y()-Doc->guidesSettings.grabRad, Doc->guidesSettings.grabRad*2, Doc->guidesSettings.grabRad*2);
//      mpo.moveBy(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(Doc->minCanvasCoordinate.y() * m_canvas->scale()));
        Doc->nodeEdit.deselect();
        Deselect(false);
        if (!Doc->masterPageMode())
        {
                int i = Doc->OnPage(Mxp + 0*Doc->minCanvasCoordinate.x(), Myp + 0*Doc->minCanvasCoordinate.y());
                if (i!=-1)
                {
                        uint docCurrPageNo=Doc->currentPageNumber();
                        uint j=static_cast<uint>(i);
                        if (docCurrPageNo != j)
                        {
                                Doc->setCurrentPage(Doc->Pages->at(j));
                                setMenTxt(j);
                                DrawNew();
                        }
                }
/*              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() * m_canvas->scale());
                        int y = static_cast<int>(Doc->Pages->at(i)->yOffset() * m_canvas->scale());
                        int w = static_cast<int>(Doc->Pages->at(i)->width() * m_canvas->scale());
                        int h = static_cast<int>(Doc->Pages->at(i)->height() * m_canvas->scale());
                        if (QRect(x, y, w, h).intersects(mpo))
                        {
                                if (docCurrPageNo != i)
                                {
                                        Doc->setCurrentPage(Doc->Pages->at(i));
                                        setMenTxt(i);
                                        DrawNew();
                                }
                                break;
                        }
                } */

                setRulerPos(contentsX(), contentsY());
        }
}


//CB-->Doc/Fix
bool ScribusView::SeleItem(QMouseEvent *m)
{
        QMatrix p;
        QRectF tx, mpo;
        PageItem *currItem;
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
        Mxp = static_cast<int>(m->x()/m_canvas->scale());
        Myp = static_cast<int>(m->y()/m_canvas->scale());
        int MxpS = static_cast<int>(m->x()/m_canvas->scale() + 0*Doc->minCanvasCoordinate.x());
        int MypS = static_cast<int>(m->y()/m_canvas->scale() + 0*Doc->minCanvasCoordinate.y());
        mpo = QRectF(m->x()-Doc->guidesSettings.grabRad, m->y()-Doc->guidesSettings.grabRad, Doc->guidesSettings.grabRad*2, Doc->guidesSettings.grabRad*2);
//      mpo.translate(Doc->minCanvasCoordinate.x() * m_canvas->scale(), Doc->minCanvasCoordinate.y() * m_canvas->scale());
        Doc->nodeEdit.deselect();
        int a;
        if (!Doc->masterPageMode())
        {
                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;
                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(MxpS, MypS))
                        {
                                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(MxpS, MypS))
                                                {
                                                        pgNum = static_cast<int>(a2);
                                                        break;
                                                }
                                        }
                                }
                                break;
                        }
                }
                if (pgNum!=-1)
                {
                        uint docCurrPageNo=Doc->currentPageNumber();
                        uint j=static_cast<uint>(pgNum);
                        if (docCurrPageNo != j)
                        {
                                Doc->setCurrentPage(Doc->Pages->at(j));
                                setMenTxt(j);
                                DrawNew();
                        }
                }
                setRulerPos(contentsX(), contentsY());
        }
        if (m->modifiers() == (Qt::ControlModifier | Qt::AltModifier))
                Deselect(false);

        if ((m->modifiers() == (Qt::ShiftModifier | Qt::AltModifier)) && (!Doc->masterPageMode()) && (Doc->currentPage()->FromMaster.count() != 0))
        {
                Page* Mp = Doc->MasterPages.at(Doc->MasterNames[Doc->currentPage()->MPageNam]);
                currItem = Doc->currentPage()->FromMaster.at(Doc->currentPage()->FromMaster.count()-1);
                int currNr = Doc->currentPage()->FromMaster.count()-1;
                for (a = 0; a < Doc->currentPage()->FromMaster.count(); ++a)
                {
                        p = QMatrix();
                        if ((currItem->LayerNr == Doc->activeLayer()) && (!Doc->layerLocked(currItem->LayerNr)))
                        {
                                double OldX = currItem->xPos();
                                double OldY = currItem->yPos();
                                if (!currItem->ChangedMasterItem)
                                {
                                        currItem->moveBy(-Mp->xOffset() + Doc->currentPage()->xOffset(), -Mp->yOffset() + Doc->currentPage()->yOffset());
                                }
                                m_canvas->Transform(currItem, p);
                                if ((QRegion(p.map(QPolygon(QRect(0, 0, static_cast<int>(currItem->width()), static_cast<int>(currItem->height()))))).contains(mpo.toRect())) ||
                                                (QRegion(currItem->Clip * p).contains(mpo.toRect())))
                                {
                                        Doc->m_Selection->setIsGUISelection(false);
                                        if (!currItem->isSelected())
                                        {
                                                if ((m->modifiers() != Qt::ShiftModifier) || (Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
                                                        Deselect(false);
                                                if (currItem->Groups.count() != 0)
                                                {
                                                        if (Doc->m_Selection->count() != 0)
                                                        {
                                                                if (Doc->m_Selection->findItem(currItem) == -1)
                                                                        Doc->m_Selection->addItem(currItem, true);
                                                        }
                                                        else
                                                                Doc->m_Selection->addItem(currItem, true);
                                                        if (m->modifiers() != (Qt::ControlModifier | Qt::AltModifier))
                                                        {
                                                                for (int ga=0; ga<Doc->Items->count(); ++ga)
                                                                {
                                                                        if (Doc->Items->at(ga)->Groups.count() != 0)
                                                                        {
                                                                                if (Doc->Items->at(ga)->Groups.top() == currItem->Groups.top())
                                                                                {
                                                                                        if (Doc->Items->at(ga)->ItemNr != currItem->ItemNr)
                                                                                        {
                                                                                                if (Doc->m_Selection->findItem(Doc->Items->at(ga)) == -1)
                                                                                                {
                                                                                                        Doc->m_Selection->addItem(Doc->Items->at(ga), true);
                                                                                                }

                                                                                        }
                                                                                        Doc->Items->at(ga)->isSingleSel = false;
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                        else
                                                        {
                                                                currItem->isSingleSel = true;
                                                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                        }
                                                }
                                                else
                                                {
                                                        Doc->m_Selection->addItem(currItem, true);
                                                        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                }
                                        }
                                        else
                                        {
                                                if (Doc->m_Selection->count() > 1)
                                                {
                                                        PageItem *bb = Doc->m_Selection->itemAt(0);
                                                        Doc->m_Selection->removeItem(currItem);
                                                        Doc->m_Selection->prependItem(currItem);
                                                        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                        updateContents(bb->getRedrawBounding(m_canvas->scale()));
                                                }
                                        }
                                        Doc->m_Selection->setIsGUISelection(true);
                                        Doc->m_Selection->connectItemToGUI();
                                        if (Doc->m_Selection->count() > 1)
                                        {
                                                for (int aa = 0; aa < Doc->m_Selection->count(); ++aa)
                                                {
                                                        PageItem *bb = Doc->m_Selection->itemAt(aa);
                                                        updateContents(bb->getRedrawBounding(m_canvas->scale()));
                                                }
                                                Doc->m_Selection->setGroupRect();
                                                double x, y, w, h;
                                                Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
                                                emit ItemPos(x, y);
                                                emit ItemGeom(w, h);
                                                getGroupRectScreen(&x, &y, &w, &h);
                                                updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
                                                emit HaveSel(currItem->itemType());
                                        }
                                        else
                                        {
                                                currItem->emitAllToGUI();
                                        }
                                        if (!currItem->ChangedMasterItem)
                                        {
                                                currItem->setXYPos(OldX, OldY);
                                        }
                                        return true;
                                }
                                Doc->m_Selection->setIsGUISelection(true);
                                Doc->m_Selection->connectItemToGUI();
                                if (!currItem->ChangedMasterItem)
                                {
                                        currItem->setXYPos(OldX, OldY);
                                }
                        }
                        currNr--;
                        currItem = Doc->currentPage()->FromMaster.at(currNr);
                }
        }
        if (Doc->Items->count() != 0)
        {
                if ((Doc->m_Selection->count() != 0) && (m->modifiers() == Qt::ControlModifier))
                        currItem = Doc->m_Selection->itemAt(0);
                else
                        currItem = Doc->Items->at(Doc->Items->count()-1);
                if ((m->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) && (Doc->m_Selection->count() != 0))
                {
                        int currNr = Doc->Items->count();
                        for (a = 0; a < Doc->Items->count(); ++a)
                        {
                                if (currItem->isSelected())
                                {
                                        if (currItem->ItemNr == 0)
                                        {
                                                currItem = Doc->Items->at(Doc->Items->count()-1);
                                                break;
                                        }
                                        currNr--;
                                        currItem = Doc->Items->at(currNr);
                                        break;
                                }
                                currNr--;
                                currItem = Doc->Items->at(currNr);
                        }
                }
                Doc->m_Selection->setIsGUISelection(false);
                if (currItem == NULL)
                {
                        Doc->m_Selection->setIsGUISelection(true);
                        Doc->m_Selection->connectItemToGUI();
                        Deselect(true);
                }
                else
                {
                        //Where all basic selection occurs having found the click location and the current page
                        int currNr = Doc->Items->indexOf(currItem);
                        for (a = currNr; a > -1; a--)
                        {
                                currItem = Doc->Items->at(a);
                                if ((Doc->masterPageMode())  && (!((currItem->OwnPage == -1) || (currItem->OwnPage == static_cast<int>(Doc->currentPage()->pageNr())))))
                                        continue;
                                if ((currItem->LayerNr == Doc->activeLayer()) && (!Doc->layerLocked(currItem->LayerNr)))
                                {
                                        p = QMatrix();
                                        m_canvas->Transform(currItem, p);
                                        if ((QRegion(p.map(QPolygon(QRect(0, 0, static_cast<int>(currItem->width()), static_cast<int>(currItem->height()))))).contains(mpo.toRect())) ||
                                                        (QRegion(currItem->Clip * p).contains(mpo.toRect())))
                                        {
                                                //If the clicked on item is not tagged as selected
                                                if (!currItem->isSelected())
                                                {
                                                        if ((m->modifiers() != Qt::ShiftModifier) || (Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
                                                                Deselect(false);
                                                        //If we are selecting an item that is part of a group...
                                                        if (currItem->Groups.count() != 0)
                                                        {
                                                                if (Doc->m_Selection->count() != 0)
                                                                {
                                                                        if (Doc->m_Selection->findItem(currItem) == -1)
                                                                                Doc->m_Selection->addItem(currItem, true);
                                                                }
                                                                else
                                                                        Doc->m_Selection->addItem(currItem, true);
                                                                //CB This is where we add the items of an unselected group
                                                                if (m->modifiers() != (Qt::ControlModifier | Qt::AltModifier))
                                                                {
                                                                        for (int ga=0; ga<Doc->Items->count(); ++ga)
                                                                        {
                                                                                if (Doc->Items->at(ga)->Groups.count() != 0)
                                                                                {
                                                                                        if (Doc->Items->at(ga)->Groups.top() == currItem->Groups.top())
                                                                                        {
                                                                                                if (Doc->Items->at(ga)->ItemNr != currItem->ItemNr)
                                                                                                {
                                                                                                        if (Doc->m_Selection->findItem(Doc->Items->at(ga)) == -1)
                                                                                                                Doc->m_Selection->addItem(Doc->Items->at(ga), true);
                                                                                                }
                                                                                                Doc->Items->at(ga)->isSingleSel = false;
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                                else
                                                                {
                                                                        currItem->isSingleSel = true;
                                                                        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                                }
                                                        }
                                                        else
                                                        //If we are just selecting one item
                                                        {
                                                                //CB 301206 We shouldnt be ignoring the GUI here...
                                                                //Doc->m_Selection->addItem(currItem, true);
                                                                Doc->m_Selection->addItem(currItem);
                                                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                        }
                                                }
                                                else //If the clicked on item is tagged as selected
                                                {
                                                        if (Doc->m_Selection->count() > 1)
                                                        {
                                                                PageItem *bb = Doc->m_Selection->itemAt(0);
                                                                Doc->m_Selection->removeItem(currItem);
                                                                Doc->m_Selection->prependItem(currItem);
                                                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                                                                //CB dont think we need to paint here when we paint below
                                                                //CB With the change of 301206, perhaps we need to?
                                                                updateContents(bb->getRedrawBounding(m_canvas->scale()));
                                                        }
                                                }
                                                Doc->m_Selection->setIsGUISelection(true);
                                                Doc->m_Selection->connectItemToGUI();
                                                if (Doc->m_Selection->count() > 1)
                                                {
                                                        for (int aa = 0; aa < Doc->m_Selection->count(); ++aa)
                                                        {
                                                                PageItem *bb = Doc->m_Selection->itemAt(aa);
                                                                updateContents(bb->getRedrawBounding(m_canvas->scale()));
                                                        }
                                                        Doc->m_Selection->setGroupRect();
                                                        double x, y, w, h;
                                                        Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
                                                        emit ItemPos(x, y);
                                                        emit ItemGeom(w, h);
                                                        getGroupRectScreen(&x, &y, &w, &h);
                                                        updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
                                                        emit HaveSel(currItem->itemType());
                                                }
                //CB 301206 Unsure why we need this if the above is no longer ignoring the GUI
                //                              else
                //                              {
                //                                      Doc->m_Selection->connectItemToGUI();
                //                                      //CB Dont need this as creating the 0th selection does this
                //                                      currItem->paintObj();
                //                              }
                                                if (Doc->m_Selection->count() == 1)
                                                {
                                                        HandleSizer(currItem, mpo.toRect(), m);
                                                        if ((frameResizeHandle == 0) && (!currItem->locked()))
                                                                qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
                                                }
                                                else
                                                {
                                                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
                                                        m_canvas->m_viewMode.operItemResizing = false;
                                                }
                                                return true;
                                        }
                                }
                        }
                }
        }
        if ((Doc->guidesSettings.guidesShown) && (Doc->appMode == modeNormal) && (!Doc->GuideLock) && (Doc->OnPage(MxpS, MypS) != -1) && (Doc->m_Selection->count() == 0))
        {
                GxM = -1;
                GyM = -1;
                QMap<double, uint> tmpGuidesSel;
                Guides tmpGuides = Doc->currentPage()->guides.horizontals(GuideManagerCore::Standard);
                Guides::iterator it;
                uint yg = 0;
                uint xg = 0;
                double lowX = ((m->x() - Doc->guidesSettings.grabRad) / m_canvas->scale()) + 0*Doc->minCanvasCoordinate.x();
                double highX = ((m->x() + Doc->guidesSettings.grabRad) / m_canvas->scale()) + 0*Doc->minCanvasCoordinate.x();
                double lowY = ((m->y() - Doc->guidesSettings.grabRad) / m_canvas->scale()) + 0*Doc->minCanvasCoordinate.y();
                double highY = ((m->y() + Doc->guidesSettings.grabRad) / m_canvas->scale()) + 0*Doc->minCanvasCoordinate.y();
                for (it = tmpGuides.begin(); it != tmpGuides.end(); ++it, ++yg)
                {
                        if (((*it) + Doc->currentPage()->yOffset() < highY) && ((*it)+Doc->currentPage()->yOffset() > lowY))
                                tmpGuidesSel.insert(fabs(((*it)+Doc->currentPage()->yOffset()) - MypS), yg);
                }
                if (tmpGuidesSel.count() != 0)
                {
                        GyM = tmpGuidesSel.begin().value();
                        QPoint py = viewport()->mapFromGlobal(m->globalPos());
                        DrHY = py.y();
                }
                tmpGuidesSel.clear();
                tmpGuides = Doc->currentPage()->guides.verticals(GuideManagerCore::Standard);
                for (it = tmpGuides.begin(); it != tmpGuides.end(); ++it, ++xg)
                {
                        if (((*it) + Doc->currentPage()->xOffset() < highX) && ((*it)+Doc->currentPage()->xOffset() > lowX))
                                tmpGuidesSel.insert(fabs(((*it)+Doc->currentPage()->xOffset()) - MypS), xg);
                }
                if (tmpGuidesSel.count() != 0)
                {
                        GxM = tmpGuidesSel.begin().value();
                        QPoint py = viewport()->mapFromGlobal(m->globalPos());
                        DrVX = py.x();
                }
                if (GxM!=-1 || GyM!=-1)
                {
                        if (GxM==-1)
                        {
                                // Horizontal Guide
                                MoveGY = true;
                                emit signalGuideInformation(0, qRound(Doc->currentPage()->guides.horizontal(GyM, GuideManagerCore::Standard) * 10000.0) / 10000.0);
                        }
                        else
                        {
                                // Vertical Guide
                                MoveGX = true;
                                emit signalGuideInformation(1, qRound(Doc->currentPage()->guides.vertical(GxM, GuideManagerCore::Standard) * 10000.0) / 10000.0);
                        }
                }
        }
        Doc->m_Selection->setIsGUISelection(true);
        Doc->m_Selection->connectItemToGUI();
        if ((m->modifiers() != Qt::ShiftModifier) || (Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
                Deselect(true);
        return false;
}


#endif


bool ScribusView::GetItem(PageItem **currItem, int nr)
{
        int n=nr;
        if (n == -1)
                n=0;
        *(currItem) = Doc->m_Selection->itemAt(n);
        return (*(currItem)!=NULL);
}

//CB Remove bookmark interaction here, item/doc should do it
void ScribusView::Deselect(bool prop)
{
        if (!Doc->m_Selection->isEmpty())
        {
                PageItem* currItem=NULL;
                for (int a = 0; a < Doc->m_Selection->count(); ++a)
                {
                        currItem = Doc->m_Selection->itemAt(a);
                        if ((currItem->asTextFrame()) && (currItem->isBookmark))
                                emit ChBMText(currItem);
                }
                if (Doc->m_Selection->isMultipleSelection())
                {
                        double x, y, w, h;
                        Doc->m_Selection->getGroupRect(&x, &y, &w, &h);
                        Doc->m_Selection->clear();
//                      x -= Doc->minCanvasCoordinate.x();
//                      y -= Doc->minCanvasCoordinate.y();
                        updateContents(static_cast<int>(x*m_canvas->scale()-5), static_cast<int>(y*m_canvas->scale()-5), static_cast<int>(w*m_canvas->scale()+10), static_cast<int>(h*m_canvas->scale()+10));
                }
                else
                {
                        currItem=Doc->m_Selection->itemAt(0);
                        Doc->m_Selection->clear();
                        if (currItem!=NULL)
                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
                }
        }
        if (prop)
                emit HaveSel(-1);
}

#if 0
void ScribusView::SetupDraw(int nr)
{
        PageItem* currItem = Doc->Items->at(nr);
//      currItem->setFont(Doc->toolSettings.defFont);
//      currItem->setFontSize(Doc->toolSettings.defSize);
        m_canvas->m_viewMode.operItemResizing = true;
        frameResizeHandle = 1;
        qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
        Doc->m_Selection->setIsGUISelection(true);
        Doc->m_Selection->clear();
        Doc->m_Selection->addItem(currItem);
        Doc->m_Selection->connectItemToGUI();
        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
        m_canvas->m_viewMode.operItemMoving = true;
        Doc->appMode = modeNormal;
        emit DocChanged();
        currItem->Sizing =  currItem->asLine() ? false : true;
        inItemCreation = true;
        m_canvas->setRenderModeFillBuffer();
//      moveTimer = moveTimer.addSecs(1500);
}

void ScribusView::SetupDrawNoResize(int nr)
{
        PageItem* currItem = Doc->Items->at(nr);
//      currItem->setFont(Doc->toolSettings.defFont);
//      currItem->setFontSize(Doc->toolSettings.defSize);
        Doc->m_Selection->setIsGUISelection(true);
        Doc->m_Selection->clear();
        Doc->m_Selection->addItem(currItem);
        Doc->m_Selection->connectItemToGUI();
        updateContents(currItem->getRedrawBounding(m_canvas->scale()));
        if (!Prefs->stickyTools)
                Doc->appMode = modeNormal;
        emit DocChanged();
        currItem->Sizing =  currItem->asLine() ? false : true;
        inItemCreation = false;
        moveTimer = moveTimer.addSecs(1500);
}

#endif

//CB-->Doc/Fix
void ScribusView::ToggleBookmark()
{
        uint docSelectionCount=Doc->m_Selection->count();
        if (docSelectionCount != 0)
        {
                for (uint a = 0; a < docSelectionCount; ++a)
                {
                        PageItem* currItem = Doc->m_Selection->itemAt(a);
                        if (currItem->asTextFrame())
                        {
                                if (currItem->OwnPage != -1)
                                {
                                        bool old = currItem->isBookmark;
                                        currItem->isBookmark = !currItem->isBookmark;
                                        if (currItem->isBookmark)
                                        {
                                                currItem->setIsAnnotation(false);
                                                emit AddBM(currItem);
                                        }
                                        else
                                        {
                                                if (old)
                                                        emit DelBM(currItem);
                                        }
                                }
                        }
                }
                m_ScMW->actionManager->setPDFActions(this);
                emit DocChanged();
        }
}

//CB-->Doc/Fix
void ScribusView::ToggleAnnotation()
{
        if (Doc->m_Selection->count() != 0)
        {
                for (int a = 0; a < Doc->m_Selection->count(); ++a)
                {
                        PageItem* currItem = Doc->m_Selection->itemAt(a);
                        if (currItem->asTextFrame())
                        {
                                bool old = currItem->isBookmark;
                                currItem->setIsAnnotation(!currItem->isAnnotation());
                                if (currItem->isAnnotation())
                                {
                                        currItem->AutoName = false;
                                        if (old)
                                                emit DelBM(currItem);
                                        currItem->isBookmark = false;
                                }
                        }
                }
                m_ScMW->actionManager->setPDFActions(this);
                emit DocChanged();
        }
}

//CB Unused
// void ScribusView::sentToScrap()
// {
//      ScriXmlDoc *ss = new ScriXmlDoc();
//      emit ToScrap(ss->WriteElem(Doc, this, Doc->m_Selection));
//      delete ss;
//      ss=NULL;
// }

//CB-->Doc/Fix
void ScribusView::ToBack()
{
        if (Doc->sendItemSelectionToBack())
        {
//              m_ScMW->outlinePalette->BuildTree();
                emit LevelChanged(0);
                emit DocChanged();
                forceRedraw = true;
                updateContents();
        }
}

//CB-->Doc/Fix
void ScribusView::ToFront()
{
        if (Doc->bringItemSelectionToFront())
        {
//              m_ScMW->outlinePalette->BuildTree();
                emit LevelChanged(Doc->m_Selection->itemAt(0)->ItemNr);
                emit DocChanged();
                forceRedraw = true;
                updateContents();
        }
}

//CB-->Doc/Fix
void ScribusView::LowerItem()
{
        uint low = Doc->Items->count();
        uint high = 0;
        int d;
        QMap<int, uint> ObjOrder;
        PageItem *currItem;
        PageItem *b2;
        uint docSelectionCount=Doc->m_Selection->count();
        if ((Doc->Items->count() > 1) && (docSelectionCount != 0))
        {
                for (uint c = 0; c < docSelectionCount; ++c)
                {
                        currItem = Doc->m_Selection->itemAt(c);
                        if (currItem->isTableItem && currItem->isSingleSel)
                                return;
                        low = qMin(currItem->ItemNr, low);
                        high = qMax(currItem->ItemNr, high);
                }
                if (low == 0)
                        return;
                bool wasGUISelection=Doc->m_Selection->isGUISelection();
                if (wasGUISelection)
                {
                        Doc->m_Selection->setIsGUISelection(false);
                        Doc->m_Selection->disconnectAllItemsFromGUI();
                }
                Selection tempSelection(*Doc->m_Selection);
                b2 = Doc->Items->at(high);
                Doc->m_Selection->clear();
                SelectItemNr(low-1, false);
                for (int c = 0; c < Doc->m_Selection->count(); ++c)
                {
                        currItem = Doc->m_Selection->itemAt(c);
                        ObjOrder.insert(currItem->ItemNr, c);
                        d = Doc->Items->indexOf(currItem);
                        Doc->Items->takeAt(d);
                }
                d = Doc->Items->indexOf(b2);
                QList<uint> Oindex = ObjOrder.values();
                for (int c = static_cast<int>(Oindex.count()-1); c > -1; c--)
                {
                        Doc->Items->insert(d+1, Doc->m_Selection->itemAt(Oindex[c]));
                }
                Doc->m_Selection->clear();
                Doc->renumberItemsInListOrder();
//              m_ScMW->outlinePalette->BuildTree();
                if (wasGUISelection)
                        tempSelection.setIsGUISelection(true);
                *Doc->m_Selection=tempSelection;
                emit LevelChanged(Doc->m_Selection->itemAt(0)->ItemNr);
                emit DocChanged();
                forceRedraw = true;
                updateContents();
        }
}

//CB-->Doc/Fix
void ScribusView::RaiseItem()
{
        uint low = Doc->Items->count();
        uint high = 0;
        int d;
        QMap<int, uint> ObjOrder;
        PageItem *currItem;
        PageItem *b2;
        uint docSelectionCount=Doc->m_Selection->count();
        if ((Doc->Items->count() > 1) && (docSelectionCount != 0))
        {
                for (uint c = 0; c < docSelectionCount; ++c)
                {
                        currItem = Doc->m_Selection->itemAt(c);
                        if (currItem->isTableItem && currItem->isSingleSel)
                                return;
                        low = qMin(currItem->ItemNr, low);
                        high = qMax(currItem->ItemNr, high);
                }
                if (high == static_cast<uint>(Doc->Items->count()-1))
                        return;
                bool wasGUISelection=Doc->m_Selection->isGUISelection();
                if (wasGUISelection)
                {
                        Doc->m_Selection->setIsGUISelection(false);
                        Doc->m_Selection->disconnectAllItemsFromGUI();
                }
                Selection tempSelection(*Doc->m_Selection);
                b2 = Doc->Items->at(low);
                Doc->m_Selection->clear();
                SelectItemNr(high+1, false);
                for (int c = 0; c < Doc->m_Selection->count(); ++c)
                {
                        currItem = Doc->m_Selection->itemAt(c);
                        ObjOrder.insert(currItem->ItemNr, c);
                        d = Doc->Items->indexOf(currItem);
                        Doc->Items->takeAt(d);
                }
                QList<uint> Oindex = ObjOrder.values();
                for (int c = 0; c <static_cast<int>(Oindex.count()); ++c)
                {
                        d = Doc->Items->indexOf(b2);
                        if (d==-1)
                                d=0;
                        Doc->Items->insert(d, Doc->m_Selection->itemAt(Oindex[c]));
                }
                Doc->m_Selection->clear();
                Doc->renumberItemsInListOrder();
//              m_ScMW->outlinePalette->BuildTree();
                if (wasGUISelection)
                        tempSelection.setIsGUISelection(true);
                *Doc->m_Selection=tempSelection;
                emit LevelChanged(Doc->m_Selection->itemAt(0)->ItemNr);
                emit DocChanged();
                forceRedraw = true;
                updateContents();
        }
}

#if 0 // FIXME:av -> CanvasMode_legacy / Doc
//CB Remove emit/start pasting objects
void ScribusView::PasteToPage()
{
        int ac = Doc->Items->count();
        if (UndoManager::undoEnabled())
                undoManager->beginTransaction(Doc->currentPage()->getUName(), 0, Um::Paste, "", Um::IPaste);
        if (m_ScMW->Buffer2.contains("<SCRIBUSFRAGMENT"))
        {
                bool savedAlignGrid = Doc->useRaster;
                bool savedAlignGuides = Doc->SnapGuides;
                Selection pastedObjects = Serializer(*Doc).deserializeObjects(m_ScMW->Buffer2.toUtf8());
                Doc->useRaster = savedAlignGrid;
                Doc->SnapGuides = savedAlignGuides;
                pastedObjects.setGroupRect();
                double gx, gy, gh, gw;
                pastedObjects.getGroupRect(&gx, &gy, &gw, &gh);
                moveGroup(Mxp / m_canvas->scale() - gx, Myp / m_canvas->scale() - gy, false, &pastedObjects);
                Doc->m_Selection->clear();
        }
        else
                emit LoadElem(m_ScMW->Buffer2, Mxp / m_canvas->scale(), Myp / m_canvas->scale(), false, false, Doc, this);
        Doc->DraggedElem = 0;
        Doc->DragElements.clear();
        updateContents();
        Selection newObjects(this, false);
        for (int as = ac; as < Doc->Items->count(); ++as)
        {
                PageItem* currItem = Doc->Items->at(as);
                if (currItem->isBookmark)
                        emit AddBM(currItem);
                newObjects.addItem(currItem);
        }
        if (newObjects.count() > 1)
        {
                newObjects.setGroupRect();
                double gx, gy, gh, gw;
                newObjects.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, &newObjects);
                newObjects.setGroupRect();
                newObjects.getGroupRect(&gx, &gy, &gw, &gh);
                nx = gx+gw;
                ny = gy+gh;
                Doc->ApplyGuides(&nx, &ny);
                moveGroup(nx-(gx+gw), ny-(gy+gh), false, &newObjects);
                newObjects.setGroupRect();
                newObjects.getGroupRect(&gx, &gy, &gw, &gh);
                emit ItemPos(gx, gy);
                emit ItemGeom(gw, gh);
                emit HaveSel(newObjects.itemAt(0)->itemType());
        }
        else
        {
                Q_ASSERT(newObjects.count()==1);
                PageItem *currItem = newObjects.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);
                }
                currItem->emitAllToGUI();
        }
        newObjects.clear();
        if (UndoManager::undoEnabled())
                undoManager->commit();
}

void ScribusView::PasteRecentToPage(int id)
{
        if (UndoManager::undoEnabled())
                undoManager->beginTransaction(Doc->currentPage()->getUName(), 0, Um::Paste, "", Um::IPaste);
        QString nam = pmen3->text(id);
        QString data = m_ScMW->scrapbookPalette->tempBView->objectMap[nam].Data;
        QFileInfo fi(data);
        if (fi.extension(true).toLower() == "sml")
        {
                QString f = "";
                loadText(data, &f);
                StencilReader *pre = new StencilReader();
                data = pre->createObjects(f);
                delete pre;
        }
        else if (fi.extension(true).toLower() == "shape")
        {
                QString f = "";
                loadText(data, &f);
                StencilReader *pre = new StencilReader();
                data = pre->createShape(f);
                delete pre;
        }
        else if (fi.extension(true).toLower() == "sce")
        {
                QString f = "";
                loadText(data, &f);
                data = f;
        }
        int ac = Doc->Items->count();
        emit LoadElem(data, Mxp / m_canvas->scale(), Myp / m_canvas->scale(), false, false, Doc, this);
        Doc->DraggedElem = 0;
        Doc->DragElements.clear();
        updateContents();
        for (int as = ac; as < Doc->Items->count(); ++as)
        {
                PageItem* currItem = Doc->Items->at(as);
                if (currItem->isBookmark)
                        emit AddBM(currItem);
                Doc->m_Selection->addItem(currItem);
        }
        if (Doc->m_Selection->count() > 1)
        {
                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);
                emit ItemPos(gx, gy);
                emit ItemGeom(gw, gh);
                emit HaveSel(Doc->m_Selection->itemAt(0)->itemType());
        }
        else
        {
                PageItem *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);
                }
                currItem->emitAllToGUI();
        }
        if (UndoManager::undoEnabled())
                undoManager->commit();
}
#endif

void ScribusView::resizeEvent ( QResizeEvent * event )
{
        QScrollArea::resizeEvent(event);
        horizRuler->setGeometry(m_vhRulerHW, 1, width()-m_vhRulerHW-1, m_vhRulerHW);
        vertRuler->setGeometry(1, m_vhRulerHW, m_vhRulerHW, height()-m_vhRulerHW-1);
        rulerMover->setGeometry(1, 1, m_vhRulerHW, m_vhRulerHW);       
}


/** Waagrechter Scrollbalken */
void ScribusView::setHBarGeometry(QScrollBar &bar, int x, int y, int w, int h)
{
        bar.setGeometry(x, y, w, h);
        if (Ready)
                horizRuler->setGeometry(m_vhRulerHW, 1, w-m_vhRulerHW-1, m_vhRulerHW);
}

/** Senkrechter Scrollbalken */
void ScribusView::setVBarGeometry(QScrollBar &bar, int x, int y, int w, int h)
{
        bar.setGeometry(x, y, w, h);
        if (Ready)
        {
                vertRuler->setGeometry(1, m_vhRulerHW, m_vhRulerHW, h-m_vhRulerHW-1);
                rulerMover->setGeometry(1, 1, m_vhRulerHW, m_vhRulerHW);
        }
}

bool ScribusView::mousePressed()
{
        return m_canvas->m_viewMode.m_MouseButtonPressed;
}

bool ScribusView::groupTransactionStarted()
{
        return _groupTransactionStarted;
}

void ScribusView::setGroupTransactionStarted(bool isOn)
{
        _groupTransactionStarted = isOn;
}

// jjsa 27-03-2004 add for better setting while zooming
//CB find a new name
void ScribusView::rememberOldZoomLocation(int mx, int my)
{
        oldX = mx;
        oldY = my;
}

void ScribusView::setRulerPos(int x, int y)
{
        if (m_ScMW->ScriptRunning)
                return;
        if (Doc->guidesSettings.rulerMode)
        {
                horizRuler->offs = x / m_canvas->scale() - Doc->currentPage()->xOffset();
                vertRuler->offs = y / m_canvas->scale() - Doc->currentPage()->yOffset();
        }
        else
        {
                horizRuler->offs = x / m_canvas->scale();
                vertRuler->offs = y / m_canvas->scale();
        }
//      horizRuler->offs += qRound(Doc->minCanvasCoordinate.x() - 1 - Doc->rulerXoffset);
//      vertRuler->offs += qRound(Doc->minCanvasCoordinate.y() - 1 - Doc->rulerYoffset);
        horizRuler->offs += 0*Doc->minCanvasCoordinate.x()  - Doc->rulerXoffset;
        vertRuler->offs += 0*Doc->minCanvasCoordinate.y()  - Doc->rulerYoffset;
        horizRuler->repaint();
        vertRuler->repaint();
//      evSpon = true;
        QString newStatusBarText(" ");
        if ((verticalScrollBar()->isSliderDown()) || (horizontalScrollBar()->isSliderDown()))
        {
                QList<int> pag;
                pag.clear();
                uint docPageCount=Doc->Pages->count();
                for (uint a = 0; a < docPageCount; ++a)
                {
                        int xs = static_cast<int>(Doc->Pages->at(a)->xOffset() * m_canvas->scale());
                        int ys = static_cast<int>(Doc->Pages->at(a)->yOffset() * m_canvas->scale());
                        int ws = static_cast<int>(Doc->Pages->at(a)->width() * m_canvas->scale());
                        int hs = static_cast<int>(Doc->Pages->at(a)->height() * m_canvas->scale());
                        QRect drawRect = QRect(x, y, visibleWidth(), visibleHeight());
//                      drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(-Doc->minCanvasCoordinate.y() * m_canvas->scale()));
                        if (drawRect.intersects(QRect(xs, ys, ws, hs)))
                                pag.append(a+1);
                }
                if (!pag.isEmpty())
                        newStatusBarText=( tr("Page %1 to %2").arg(pag.first()).arg(pag.last()));
        }
        m_ScMW->setStatusBarInfoText(newStatusBarText);
}


//CB This MUST now be called AFTER a call to doc->addPage or doc->addMasterPage as it
//does NOT create a page anymore.
Page* ScribusView::addPage(int nr, bool mov)
{
        Page* fe=Doc->Pages->at(nr);
        Q_ASSERT(fe!=0);
        if (fe==0)
                return 0;
        //Note this picks up the new page or master page depending on the mode.
        reformPages(mov);
        setMenTxt(nr);
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
        Doc->DragP = false;
        Doc->leaveDrag = false;
        m_canvas->m_viewMode.operItemMoving = false;
        MidButt = false;
        HaveSelRect = false;
        Magnify = false;
        FirstPoly = true;
        Doc->nodeEdit.EdPoints = true;
        //GroupSel = false;
        DraggedGroup = false;
//FIXME:av      MoveGY = false;
//FIXME:av      MoveGX = false;
        Doc->nodeEdit.isContourLine = false;
        return fe;
}

void ScribusView::reformPages(bool moveObjects)
{
        Doc->reformPages(moveObjects);
        if (!m_ScMW->ScriptRunning)
                setContentsPos(qRound((Doc->currentPage()->xOffset()-10 - 0*Doc->minCanvasCoordinate.x()) * m_canvas->scale()), qRound((Doc->currentPage()->yOffset()-10 - 0*Doc->minCanvasCoordinate.y()) * m_canvas->scale()));
        if (!Doc->isLoading())
        {
                setRulerPos(contentsX(), contentsY());
                setMenTxt(Doc->currentPage()->pageNr());
        }
}

void ScribusView::updatesOn(bool on)
{
        updateOn = on;
        setUpdatesEnabled(on);
        viewport()->setUpdatesEnabled(on);
}


/*!
  immediately paints the canvas inside the box given in canvas coordinates
 */

void ScribusView::updateCanvas(QRectF box)
{
        m_canvas->m_viewMode.firstSpecial = true;      
        if (box.isValid())
        {
                QPoint upperLeft = m_canvas->canvasToLocal(box.topLeft());
                QPoint lowerRight = m_canvas->canvasToLocal(box.bottomRight());
                upperLeft.setX(qMax(0, upperLeft.x()-10));
                upperLeft.setY(qMax(0, upperLeft.y()-10));
                lowerRight.setX(qMax(0, lowerRight.x()+10));
                lowerRight.setY(qMax(0, lowerRight.y()+10));
                m_canvas->update(upperLeft.x(), upperLeft.y(), lowerRight.x()-upperLeft.x(), lowerRight.y()-upperLeft.y());
/*              double scale = m_canvas->scale();
                double x = box.x() * scale;
                double y = box.y() * scale;
                double w = box.width() * scale;
                double h = box.height() * scale;
                double sbx = horizontalScrollBar()->value();
                double sby = verticalScrollBar()->value();
                if (x < sbx)
                {
                        w -= (sbx - x);
                        x = sbx;
                }
                else
                {
                        w += (x - static_cast<int>(x));  // since x will be rounded down below
                }
                if (y < sby)
                {
                        h -= (sby - y);
                        y = sby;
                }
                else
                {
                        h += (y - static_cast<int>(y));  // since y will be rounded down below
                }
                // enlarge the rectangle when rounding to int:
                m_canvas->update(static_cast<int>(x), static_cast<int>(y),
                                                 qMin(qRound(h + 0.5), viewport()->width()),
                                                 qMin(qRound(w + 0.5), viewport()->height()));
*/
      }
        else
        {
                m_canvas->update(horizontalScrollBar()->value(), verticalScrollBar()->value(), viewport()->width(), viewport()->height());
        }
}


/*!
  Scrolls the canvas so (x,y) becomes the origin
 */

void ScribusView::setCanvasOrigin(double x, double y)
{
        double scale = m_canvas->scale();
        horizontalScrollBar()->setValue(x * scale);
        verticalScrollBar()->setValue(y * scale);      
}


/*!
  Scrolls the canvas so (x,y) is in the center of the viewport
 */

void ScribusView::setCanvasCenter(double x, double y)
{
        double scale = m_canvas->scale();
        setCanvasOrigin(x - viewport()->width() / scale,
                                        y - viewport()->height() / scale);
}

/*!
  Scrolls canvas relatively
 */

void ScribusView::scrollCanvasBy(double deltaX, double deltaY)
{
        double scale = m_canvas->scale();
        horizontalScrollBar()->setValue(horizontalScrollBar()->value() + deltaX * scale);
        verticalScrollBar()->setValue(verticalScrollBar()->value() + deltaX * scale);
}


/*!
  returns the canvas's origin in canvas coordinates.
  Doc->minCanvasCoordinate <= result <= Doc->maxCanvasCoordinate
 */

FPoint ScribusView::canvasOrigin() const
{
        double scale = m_canvas->scale();
        return FPoint(horizontalScrollBar()->value() / scale,
                                  verticalScrollBar()->value() / scale);                                 
}


/*!
  returns the visible part of the canvas in canvas coordinates
 */

QRectF ScribusView::visibleCanvas() const
{
        double scale = m_canvas->scale();
        return QRectF(horizontalScrollBar()->value() / scale,
                                  verticalScrollBar()->value() / scale,
                                  viewport()->width() / scale,
                                  viewport()->height() / scale);
}


/*!
  Legacy.
  Now ignores the parameters and just adjusts the canvas widget according to min/maxCanvasCoordinate
 */

void ScribusView::adjustCanvas(double width, double height, double dX, double dY)
{
        QSize maxViewport = maximumViewportSize();
        double scale = m_canvas->scale();
        horizontalScrollBar()->setRange(qRound(Doc->minCanvasCoordinate.x() * scale),
                                                                        qRound(Doc->maxCanvasCoordinate.x() * scale) - maxViewport.width());
        verticalScrollBar()->setRange(qRound(Doc->minCanvasCoordinate.y() * scale),
                                                                  qRound(Doc->maxCanvasCoordinate.y() * scale) - maxViewport.height());
        qDebug() << "adjustCanvas" << width << height << dX << dY
                << "(" << Doc->minCanvasCoordinate.x() << Doc->minCanvasCoordinate.y() << ") - ("
                << Doc->maxCanvasCoordinate.x() << Doc->maxCanvasCoordinate.y() << ") @" << scale << maxViewport;
        widget()->resize(qRound((Doc->maxCanvasCoordinate.x()-Doc->minCanvasCoordinate.x())*scale),
                                   qRound((Doc->maxCanvasCoordinate.y()-Doc->minCanvasCoordinate.y())*scale));
       
        if (false && !m_canvas->m_viewMode.operItemMoving)
        {
                bool updback = updateOn;
                updatesOn(false);
                disconnect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
                int oldDX = contentsX();
                int oldDY = contentsY();
                int nw = qMax(qRound(width * scale), contentsWidth() + qRound(dX * scale) * 2);
                int nh = qMax(qRound(height * scale), contentsHeight() + qRound(dY * scale) * 2);
                resizeContents(qMax(nw, visibleWidth() + qRound(dX * scale) * 2), qMax(nh, visibleHeight() + qRound(dY * scale) * 2));
                setContentsPos(oldDX + qRound(dX * scale), oldDY + qRound(dY * scale));
//              setRulerPos(contentsX(), contentsY());
                connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
                updatesOn(updback);
        }
//      evSpon = false;
}

void ScribusView::setMenTxt(int Seite)
{
        if (m_ScMW->ScriptRunning)
                return;
        disconnect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
        pageSelector->setMaximum(Doc->masterPageMode() ? 1 : Doc->Pages->count());
        if ((!Doc->isLoading()) && (!Doc->masterPageMode()))
                pageSelector->GotoPg(Seite);
        connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
}

/** Fuehrt die Vergroesserung/Verkleinerung aus */
void ScribusView::slotDoZoom()
{
        undoManager->setUndoEnabled(false);
        if (m_canvas->scale() > 32*Prefs->DisScale)
        {
                setScale(32*Prefs->DisScale);
                return;
        }
        updatesOn(false);
        int nw = qMax(qRound((Doc->maxCanvasCoordinate.x() - Doc->minCanvasCoordinate.x()) * m_canvas->scale()), visibleWidth());
        int nh = qMax(qRound((Doc->maxCanvasCoordinate.y() - Doc->minCanvasCoordinate.y()) * m_canvas->scale()), visibleHeight());
        resizeContents(nw, nh);
        if (Doc->m_Selection->count() != 0)
        {
                PageItem *currItem = Doc->m_Selection->itemAt(0);
                SetCCPo(currItem->xPos() + currItem->width() / 2.0, currItem->yPos() + currItem->height() / 2.0);
        }
        else
                SetCCPo(oldX, oldY);
        updatesOn(true);
        DrawNew();
        undoManager->setUndoEnabled(true);
}

void ScribusView::setZoom()
{
        int x = qRound(qMax(contentsX() / m_canvas->scale(), 0.0));
        int y = qRound(qMax(contentsY() / m_canvas->scale(), 0.0));
        int w = qRound(qMin(visibleWidth() / m_canvas->scale(), Doc->currentPage()->width()));
        int h = qRound(qMin(visibleHeight() / m_canvas->scale(), Doc->currentPage()->height()));
        rememberOldZoomLocation(w / 2 + x,h / 2 + y);
        setScale(zoomSpinBox->value() / 100.0 * Prefs->DisScale);
        slotDoZoom();
        m_ScMW->setFocus();
}

void ScribusView::slotZoom100()
{
        int x = qRound(qMax(contentsX() / m_canvas->scale(), Doc->minCanvasCoordinate.x()));
        int y = qRound(qMax(contentsY() / m_canvas->scale(), Doc->minCanvasCoordinate.y()));
        int w = qRound(qMin(visibleWidth() / m_canvas->scale(), Doc->maxCanvasCoordinate.x() - Doc->minCanvasCoordinate.x()));
        int h = qRound(qMin(visibleHeight() / m_canvas->scale(), Doc->maxCanvasCoordinate.y() - Doc->minCanvasCoordinate.y()));
        rememberOldZoomLocation(w / 2 + x,h / 2 + y);
        setScale(Prefs->DisScale);
        slotDoZoom();
}

void ScribusView::slotZoomIn(int mx,int my)
{
        if ((mx == 0) && (my == 0))
        {
                int x = qRound(qMax(contentsX() / m_canvas->scale(), Doc->minCanvasCoordinate.x()));
                int y = qRound(qMax(contentsY() / m_canvas->scale(), Doc->minCanvasCoordinate.y()));
                int w = qRound(qMin(visibleWidth() / m_canvas->scale(), Doc->maxCanvasCoordinate.x() - Doc->minCanvasCoordinate.x()));
                int h = qRound(qMin(visibleHeight() / m_canvas->scale(), Doc->maxCanvasCoordinate.y() - Doc->minCanvasCoordinate.y()));
                rememberOldZoomLocation(w/2+x, h/2+y);
        }
        else
                rememberOldZoomLocation(mx,my);
        setScale(m_canvas->scale() * static_cast<double>(Doc->toolSettings.magStep)/100.0);
        slotDoZoom();
}

/** Verkleinert die Ansicht */
void ScribusView::slotZoomOut(int mx,int my)
{
        if ((mx == 0) && (my == 0))
        {
                int x = qRound(qMax(contentsX() / m_canvas->scale(), Doc->minCanvasCoordinate.x()));
                int y = qRound(qMax(contentsY() / m_canvas->scale(), Doc->minCanvasCoordinate.y()));
                int w = qRound(qMin(visibleWidth() / m_canvas->scale(), Doc->maxCanvasCoordinate.x() - Doc->minCanvasCoordinate.x()));
                int h = qRound(qMin(visibleHeight() / m_canvas->scale(), Doc->maxCanvasCoordinate.y() - Doc->minCanvasCoordinate.y()));
                rememberOldZoomLocation(w/2+x, h/2+y);
        }
        else
                rememberOldZoomLocation(mx,my);
        setScale(m_canvas->scale() / (static_cast<double>(Doc->toolSettings.magStep)/100.0));
        slotDoZoom();
}

#if 0
FPoint ScribusView::translateToView(double x, double y) // deprecated
{
        return FPoint((x - 0*Doc->minCanvasCoordinate.x()) * m_canvas->scale(), (y - 0*Doc->minCanvasCoordinate.y())* m_canvas->scale());
}

FPoint ScribusView::translateToView(FPoint in) // deprecated
{
        return translateToView(in.x(), in.y());
}

FPoint ScribusView::translateToDoc(double x, double y) // deprecated
{
        return FPoint(x / m_canvas->scale() + 0*Doc->minCanvasCoordinate.x(), y / m_canvas->scale() + 0*Doc->minCanvasCoordinate.y());
}

FPoint ScribusView::translateToDoc(FPoint in) // deprecated
{
        return translateToDoc(in.x(), in.y());
}

FPoint ScribusView::translateFromViewport(double x, double y) // deprecated
{
        return FPoint((x + contentsX()) / m_canvas->scale() + 0*Doc->minCanvasCoordinate.x(), (y + contentsY()) / m_canvas->scale() + 0*Doc->minCanvasCoordinate.y());
}

FPoint ScribusView::translateFromViewport(FPoint in) // deprecated
{
        return translateFromViewport(in.x(), in.y());
}

FPoint ScribusView::translateToViewport(double x, double y) // deprecated
{
        return FPoint((x - 0*Doc->minCanvasCoordinate.x()) * m_canvas->scale() - contentsX(), (y - 0*Doc->minCanvasCoordinate.y())* m_canvas->scale() - contentsY());
}

FPoint ScribusView::translateToViewport(FPoint in) // deprecated
{
        return translateToViewport(in.x(), in.y());
}
#endif


void ScribusView::DrawNew()
{
        if (m_ScMW->ScriptRunning)
                return;
//      evSpon = false;
        forceRedraw = true;
        updateContents();
        setRulerPos(contentsX(), contentsY());
        setMenTxt(Doc->currentPage()->pageNr());
        disconnect(zoomSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setZoom()));
        zoomSpinBox->setValue(m_canvas->scale()/Prefs->DisScale*100);
        connect(zoomSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setZoom()));
}

void Sc