Subversion Repositories Scribus

Rev

Rev 122 | Blame | Compare with Previous | Last modification | View Log | RSS feed

/***************************************************************************
                          page.cpp  -  description
                             -------------------
    begin                : Sat Apr 7 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 "page.h"
#include "page.moc"
#include "pageitem.h"
#include "serializer.h"
#include "scribusXml.h"
#include "config.h"
#include <qapplication.h>
#include <qcolor.h>
#include <qrect.h>
#include <qpointarray.h>
#include <qregion.h>
#include <qcursor.h>
#include <qimage.h>
#include <qfileinfo.h>
#include <qfile.h>
#include <qtextstream.h>
#include <qcstring.h>
#include <qdragobject.h>
#include <qurl.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <qbitmap.h>
#include <qwmatrix.h>
#include <qpopupmenu.h>

#ifdef HAVE_TIFF
        #include <tiffio.h>
#endif
#ifdef HAVE_CMS
        #include CMS_INC
#endif
extern int PolyC;
extern int PolyFd;
extern double PolyF;
extern bool PolyS;
extern double PolyR;
extern ProfilesL InputProfiles;
extern QPixmap loadIcon(QString nam);
extern double Cwidth(ScribusDoc *doc, QString name, QString ch, int Siz, QString ch2 = " ");
#ifdef HAVE_CMS
QImage ProofPict(QImage *Im, QString Prof, int Rend, cmsHPROFILE emPr=0);
#else
QImage ProofPict(QImage *Im, QString Prof, int Rend);
#endif
extern FPointArray RegularPolygonF(double w, double h, uint c, bool star, double factor, double rota);
extern QPointArray FlattenPath(FPointArray ina, QValueList<uint> &Segs);
extern double xy2Deg(double x, double y);
extern void BezierPoints(QPointArray *ar, QPoint n1, QPoint n2, QPoint n3, QPoint n4);
extern void Level2Layer(ScribusDoc *doc, struct Layer *ll, int Level);
extern FPoint GetMaxClipF(FPointArray Clip);

Page::Page(QWidget *pa, int x, int y, int b, int h, ScribusDoc *doc, QScrollView *view)
                                 : QWidget(pa, "ps", WRepaintNoErase)
{
        resize(b, h);
        move(x, y);
        setEraseColor(doc->papColor);
        doku = doc;
        Anz = view;
        Items.clear();
        Items.setAutoDelete(true);
        Margins.Top = 9;
        Margins.Left = 9;
        Margins.Right = 9;
        Margins.Bottom = 40;
        SelItem.clear();
        ClRe = -1;
        ClRe2 = -1;
        setAcceptDrops(true);
        emit DocChanged();
        doku->DragP = false;
        Imoved = false;
        Mpressed = false;
        MidButt = false;
        HaveSelRect = false;
        PageNam = "";
        LeftPg = false;
        Magnify = false;
        FirstPoly = true;
        EdPoints = true;
        MoveSym = false;
        GroupSel = false;
        DraggedGroup = false;
        GroupX = 0;
        GroupY = 0;
        GroupW = 0;
        GroupH = 0;
        DrHY = -1;
        DrVX = -1;
        XGuides.clear();
        YGuides.clear();
        GyM = 0;
        MoveGY = false;
        GxM = 0;
        MoveGX = false;
}

void Page::dragLeaveEvent(QDragLeaveEvent *e)
{
        if (DraggedGroup)
                {
                double gx, gy, gw, gh;
                getGroupRectScreen(&gx, &gy, &gw, &gh);
                repaint(static_cast<int>(gx), static_cast<int>(gy), static_cast<int>(gw), static_cast<int>(gh));
                DraggedGroup = false;
                }
}

void Page::dragEnterEvent(QDragEnterEvent *e)
{
        QString text;
        e->accept(QTextDrag::canDecode(e));
        if (QTextDrag::decode(e, text))
                {
                double gx, gy, gw, gh;
                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))
                        {
                        GroupX = e->pos().x() / doku->Scale;
                        GroupY = e->pos().y() / doku->Scale;
                        GroupW = gw;
                        GroupH = gh;
                        DraggedGroup = true;
                        GroupSel = false;
                        }
                delete ss;
                setActiveWindow();
                raise();
                SeleItemPos(e->pos());
                }
}

void Page::dragMoveEvent(QDragMoveEvent *e)
{
        QString text;
        PageItem *b;
        bool img;
        e->accept(QTextDrag::canDecode(e));
        if (QTextDrag::decode(e, text))
                {
                if (DraggedGroup)
                        {
                        double gx, gy, gw, gh;
                        getGroupRectScreen(&gx, &gy, &gw, &gh);
                        repaint(static_cast<int>(gx), static_cast<int>(gy), static_cast<int>(gw), static_cast<int>(gh));
                        GroupX = e->pos().x() / doku->Scale;
                        GroupY = e->pos().y() / doku->Scale;
                        paintGroupRect(false);
                        emit MousePos(GroupX, GroupY);
                        emit Hrule(e->pos().x()+Anz->childX(parentWidget()));
                        emit Vrule(e->pos().y()+Anz->childY(parentWidget()));
                        return;
                        }
                QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                QString ext = fi.extension(false).upper();
                QStrList imfo = QImageIO::inputFormats();
                if (ext == "JPG")
                        ext = "JPEG";
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
                if (!SeleItemPos(e->pos()))
                        {
                        if (SelItem.count() != 0)
                                Deselect(true);
                        }
                else
                        {
                        b = SelItem.at(0);
                        if (img)
                                {
                                if (b->PType != 2)
                                        Deselect(true);
                                }
                        else
                                {
                                if (b->PType != 4)
                                        Deselect(true);
                                }
                        }
                }
}

void Page::dropEvent(QDropEvent *e)
{
        QString text;
        PageItem *b;
        bool img = false;
        struct Pti *hg;
        uint a;
        int re;
        if (QTextDrag::decode(e, text))
                {
                QUrl ur(text);
                QFileInfo fi = QFileInfo(ur.path());
                QString ext = fi.extension(false).upper();
                QStrList imfo = QImageIO::inputFormats();
                if (ext == "JPG")
                        ext = "JPEG";
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="PDF")||(ext=="TIF"));
                if ((fi.exists()) && (img) && (!SeleItemPos(e->pos())))
                        {
                        int z = PaintPict(qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), 1, 1);
                        b = Items.at(z);
        LoadPict(ur.path(), b->ItemNr);
                        b->Width = static_cast<double>(b->pixm.width());
                        b->Height = static_cast<double>(b->pixm.height());
                        b->OldB2 = b->Width;
                        b->OldH2 = b->Height;
                        UpdateClip(b);
                        emit DocChanged();
                        update();
                        return;
                        }
                if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
                        {
                        b = SelItem.at(0);
                        if (b->PType == 2)
                                {
                                if ((fi.exists()) && (img))
                                        {
                        LoadPict(ur.path(), b->ItemNr);
                        update();
                                        }
                                }
                        if (b->PType == 4)
                                {
                                if ((b->BackBox != 0) && (b->Ptext.count() == 0))
                                        return;
                                if ((fi.exists()) && (!img) && (fi.size() < 500000))
                                        {
                                Serializer *ss = new Serializer(ur.path());
                                if (ss->Read())
                                        {
                                                int st = doku->CurrentABStil;
                                        ss->GetText(b, st, doku->Vorlagen[st].Font, doku->Vorlagen[st].FontSize);
                                                emit DocChanged();
                                        }
                                delete ss;
                        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 Pti;
                                                hg->ch = text.at(a);
                                                if (hg->ch == QChar(10))
                                                  hg->ch = QChar(13);
                                                if (hg->ch == QChar(9))
                                                  hg->ch = " ";
                                                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->Ptext.insert(b->CPos, hg);
                                                b->CPos += 1;
                                                }
                                        b->Dirty = true;
                                        emit DocChanged();
                                        update();
                                        }
                                }
                        }
                else
                        {
                        if ((fi.exists()) && (!img))
                                {
                                emit LoadElem(QString(ur.path()), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), true, false, doku);
                                }
                        else
                                {
                                if (doku->DraggedElem != 0)
                                        {
                                        QPopupMenu *pmen = new QPopupMenu();
                                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                                        pmen->insertItem( tr("Copy Here"));
                                        pmen->insertItem( tr("Move Here"));
                                        pmen->insertItem( tr("Cancel"));
                                        re = pmen->indexOf(pmen->exec(QCursor::pos()));
                                        delete pmen;
                                        if (re == 1)
                                                {
                                                doku->DraggedElem->OwnPage->SelItem.clear();
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
                                                        {
                                                        doku->DraggedElem->OwnPage->SelItem.append(doku->DraggedElem->OwnPage->Items.at(doku->DragElements[dre]));
                                                        }
                                                doku->DraggedElem->OwnPage->DeleteItem();
                                                }
                                        }
                                else
                                        re = 1;
                                if ((!img) && ((re == 0) || (re == 1)))
                                        emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
//                              Deselect(true);
                                doku->DraggedElem = 0;
                                doku->DragElements.clear();
                                }
                        }
                }
}

/** No descriptions */
void Page::paintEvent(QPaintEvent *e)
{
        QRect vr = ViewReg().boundingRect().intersect(e->rect());
        if ((vr.width() < 1) || (vr.height() < 1))
                return;
        QPixmap pgPix(vr.width(), vr.height());
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
        painter->translate(0.5, 0.5);
        if (doku->Before)
                DrawPageMarks(painter, vr);
//      QTime tim;
//      tim.start();
        DrawPageItems(painter, vr);
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
        if (!doku->Before)
                DrawPageMarks(painter, vr);
        painter->end();
        bitBlt( this, vr.x(), vr.y(), &pgPix, 0, 0, pgPix.width(), pgPix.height() );
        QPainter p;
        p.begin(this);
        p.setPen(QColor(0, 0, 0));
        p.setBrush(NoBrush);
        p.drawRect(0, 0, width(), height());
        p.end();
  if (SelItem.count() != 0)
        {
                PageItem *b = SelItem.at(0);
                b->paintObj(e->rect());
                if ((doku->EditClip) && (b->Select))
                        MarkClip(b);
                if (GroupSel)
                        {
                        setGroupRect();
                        paintGroupRect();
                        }
                }
        delete painter;
}

void Page::DrawPageMarks(ScPainter *p, QRect rd)
{
        double b;
        if ((rd.width() == 0) || (rd.height() == 0))
                return;
        double lw = 1.0 / doku->Scale;
        p->setZoomFactor(doku->Scale);
        QWMatrix ma = p->worldMatrix();
        QWMatrix ma2 = p->worldMatrix();
        ma.translate(-rd.x(), -rd.y());
        p->setWorldMatrix(ma);
        p->setLineWidth(lw);
        if (doku->Marks)
                {
                p->setPen(doku->margColor);
                if (doku->RandFarbig)
                        {
                        p->setBrush(doku->margColor);
                        p->drawRect(0, 0, width()/doku->Scale, Margins.Top);
                        p->drawRect(0, Margins.Top, Margins.Left, height()/doku->Scale-Margins.Top);
                        p->drawRect(Margins.Left, height()/doku->Scale-Margins.Bottom, width()/doku->Scale-Margins.Right-Margins.Left, Margins.Bottom);
                        p->drawRect(width()/doku->Scale-Margins.Right, Margins.Top, Margins.Right, height()/doku->Scale);
                        }
                p->setPen(doku->margColor);
                p->drawLine(FPoint(0, Margins.Top), FPoint(width()/doku->Scale, Margins.Top));
                p->drawLine(FPoint(0, height()/doku->Scale-Margins.Bottom), FPoint(width()/doku->Scale, height()/doku->Scale-Margins.Bottom));
                p->drawLine(FPoint(Margins.Left, 0), FPoint(Margins.Left, height()/doku->Scale));
                p->drawLine(FPoint(width()/doku->Scale-Margins.Right, 0), FPoint(width()/doku->Scale-Margins.Right, height()/doku->Scale));
                }
        if (doku->Raster)
                {
                double stx = rd.x()/doku->Scale;
                double endx = rd.x()/doku->Scale+rd.width()/doku->Scale;
                double sty = rd.y()/doku->Scale;
                double endy = rd.y()/doku->Scale+rd.height()/doku->Scale;
                if (doku->Scale > 0.49)
                        {
                        double i,start;
                        i=doku->majorGrid*doku->Scale;
                        p->setPen(doku->majorColor, lw, SolidLine, FlatCap, MiterJoin);
                        start=floor(sty/i);
                        start*=i;
                        for (b = start; b < endy; b+=i)
                                        p->drawLine(FPoint(0, b), FPoint(width()/doku->Scale, b));
                        start=floor(stx/i);
                        start*=i;
                        for (b = start; b <= endx; b+=i)
                                        p->drawLine(FPoint(b, 0), FPoint(b, height()/doku->Scale));
                        i=doku->minorGrid*doku->Scale;
                        p->setPen(doku->minorColor, lw, DotLine, FlatCap, MiterJoin);
                        start=floor(sty/i);
                        start*=i;
                        for (b = start; b < endy; b+=i)
                                        p->drawLine(FPoint(0, b), FPoint(width()/doku->Scale, b));
                        start=floor(stx/i);
                        start*=i;
                        for (b = start; b <= endx; b+=i)
                                        p->drawLine(FPoint(b, 0), FPoint(b, height()/doku->Scale));
                        }
                }
        if (doku->Guides)
                {
                if (XGuides.count() != 0)
                        {
                        p->setPen(doku->guideColor, lw, SolidLine, FlatCap, MiterJoin);
                        for (uint xg = 0; xg < XGuides.count(); ++xg)
                                {
                                p->drawLine(FPoint(XGuides[xg], 0), FPoint(XGuides[xg], doku->PageH));
                                }
                        }
                if (YGuides.count() != 0)
                        {
                        p->setPen(doku->guideColor, lw, SolidLine, FlatCap, MiterJoin);
                        for (uint yg = 0; yg < YGuides.count(); ++yg)
                                {
                                p->drawLine(FPoint(0, YGuides[yg]), FPoint(doku->PageB, YGuides[yg]));
                                }
                        }
                }
        p->setWorldMatrix(ma2);
}

void Page::DrawPageItems(ScPainter *painter, QRect rd)
{
        QPainter p;
        uint a;
        int Lnr;
        struct Layer ll;
        PageItem* b;
        ll.Sichtbar = false;
        ll.LNr = 0;
        ScribusView* vi = (ScribusView*)Anz;
        if ((rd.width() == 0) || (rd.height() == 0))
                return;
        if (MPageNam != "")
                {
                Page* Mp = vi->MasterPages.at(vi->MasterNames[MPageNam]);
                QWidget* Opa;
                Page* Opa2;
                if (Mp->Items.count() != 0)
                        {
                        Lnr = 0;
                        for (uint la = 0; la < doku->Layers.count(); ++la)
                                {
                                Level2Layer(doku, &ll, Lnr);
                                if (ll.Sichtbar)
                                        {
                                        for (a = 0; a < Mp->Items.count(); ++a)
                                                {
                                                b = Mp->Items.at(a);
                                                if (b->LayerNr != ll.LNr)
                                                        continue;
                                                Opa = b->Parent;
                                                Opa2 = b->OwnPage;
                                                b->Parent = this;
                                                b->OwnPage = this;
                                                b->DrawObj(painter, rd);
                                                b->Parent = Opa;
                                                b->OwnPage = Opa2;
                                                }
                                        }
                                Lnr++;
                                }
                        }
                }
        if (Items.count() != 0)
                {
                Lnr = 0;
                for (uint la2 = 0; la2 < doku->Layers.count(); ++la2)
                        {
                        Level2Layer(doku, &ll, Lnr);
                        if (ll.Sichtbar)
                                {
                                for (a = 0; a < Items.count(); ++a)
                                        {
                                        b = Items.at(a);
                                        if (b->LayerNr != ll.LNr)
                                                continue;
                                        QPainter p;
                                        p.begin(this);
                                        Transform(b, &p);
                                        QRegion apr = QRegion(p.xForm(b->Clip));
                                        QRegion apr2 = QRegion(p.xForm(QRect(-1, -1, static_cast<int>(b->Width), static_cast<int>(b->Height))));
                                        p.end();
                                        if ((rd.intersects(apr.boundingRect())) || (rd.intersects(apr2.boundingRect())))
                                                {
                                                b->DrawObj(painter, rd);
                                                b->Redrawn = true;
                                                if ((doku->AppMode == 7) && (b->Select))
                                                        slotDoCurs(true);
                                                }
                                        }
                                }
                        Lnr++;
                        }
                }
}

void Page::setGroupRect()
{
        PageItem* b;
        double minx = 99999.9;
        double miny = 99999.9;
        double maxx = -99999.9;
        double maxy = -99999.9;
        for (uint gc = 0; gc < SelItem.count(); ++gc)
                {
                b = SelItem.at(gc);
                if (b->Rot != 0)
                        {
                        QPainter p;
                        p.begin(this);
                        p.translate(static_cast<int>(b->Xpos), static_cast<int>(b->Ypos));
                        p.rotate(b->Rot);
                        QRect apr = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(QMAX(b->Height, 1))))).boundingRect();
                        p.end();
                        minx = QMIN(minx, apr.x());
                        miny = QMIN(miny, apr.y());
                        maxx = QMAX(maxx, apr.x() + apr.width());
                        maxy = QMAX(maxy, apr.y() + apr.height());
                        }
                else
                        {
                        minx = QMIN(minx, b->Xpos);
                        miny = QMIN(miny, b->Ypos);
                        maxx = QMAX(maxx, b->Xpos + b->Width);
                        maxy = QMAX(maxy, b->Ypos + b->Height);
                        }
                }
        GroupX = minx;
        GroupY = miny;
        GroupW = maxx - minx;
        GroupH = maxy - miny;
        GroupSel = true;
}

void Page::moveGroup(double x, double y, bool fromMP)
{
        PageItem* b;
        double gx, gy, gw, gh;
        if (GroupSel)
                getGroupRectScreen(&gx, &gy, &gw, &gh);
        for (uint a = 0; a < SelItem.count(); ++a)
                {
                b = SelItem.at(a);
                MoveItem(x, y, b, fromMP);
                }
        if (GroupSel)
                repaint(QRect(static_cast<int>(gx-5), static_cast<int>(gy-5), static_cast<int>(gw+10), static_cast<int>(gh+10)));
}

void Page::getGroupRect(double *x, double *y, double *w, double *h)
{
        *x = GroupX;
        *y = GroupY;
        *w = GroupW;
        *h = GroupH;
}

void Page::getGroupRectScreen(double *x, double *y, double *w, double *h)
{
        double sc = doku->Scale;
        *x = GroupX*sc;
        *y = GroupY*sc;
        *w = GroupW*sc;
        *h = GroupH*sc;
}

void Page::paintGroupRect(bool norm)
{
        double x, y, w, h;
        getGroupRectScreen(&x, &y, &w, &h);
        QPainter pgc;
        pgc.begin(this);
        if (norm)
                pgc.setPen(QPen(red, 1, DotLine, FlatCap, MiterJoin));
        else
                pgc.setPen(QPen(black, 1, DotLine, FlatCap, MiterJoin));
        pgc.setBrush(NoBrush);
        pgc.drawRect(static_cast<int>(x), static_cast<int>(y), static_cast<int>(w), static_cast<int>(h));
        pgc.setBrush(red);
        if (norm)
                {
                pgc.setPen(QPen(red, 1, SolidLine, FlatCap, MiterJoin));
                pgc.drawRect(static_cast<int>(x+w-6), static_cast<int>(y+h-6), 6, 6);
                }
//      pgc.drawRect(int(x), int(y), 6, 6);
/*      pgc.drawRect(int(x+w-6), int(y), 6, 6);
        pgc.drawRect(int(x), int(y+h-6), 6, 6);
        if (w > 6)
                {
                pgc.drawRect(int(x+w/2 - 3), int(y+h-6), 6, 6);
                pgc.drawRect(int(x+w/2 - 3), int(y), 6, 6);
                }
        if (h > 6)
                {
                pgc.drawRect(int(x+w-6), int(y+h/2 - 3), 6, 6);
                pgc.drawRect(int(x), int(y+h/2 - 3), 6, 6);
                }         */

        pgc.end();
}

void Page::storeUndoInf(PageItem* b)
{
        if ((doku->UnData.UnCode == 0) && (doku->UnDoValid))
                delete doku->UnData.Item;
        doku->UnDoValid = false;
        doku->UnData.Xpos = b->Xpos;
        doku->UnData.Ypos = b->Ypos;
        doku->UnData.Width = b->Width;
        doku->UnData.Height = b->Height;
        doku->UnData.Rot = b->Rot;
        doku->UnData.Item = b;
        doku->UnData.PageNr = PageNr;
        doku->UnData.ItemNr = b->ItemNr;
}

QRegion Page::ViewReg()
{
        int cx = Anz->contentsX() - Anz->childX(parentWidget());
        int cy = Anz->contentsY() - Anz->childY(parentWidget());
        int cw = Anz->visibleWidth();
        int ch = Anz->visibleHeight();
        return QRegion(QRect(cx, cy, cw, ch));
}

void Page::Transform(PageItem *b, QPainter *p)
{
        p->translate(static_cast<int>(b->Xpos*doku->Scale),
    static_cast<int>(b->Ypos*doku->Scale));
        p->scale(doku->Scale, doku->Scale);
        p->rotate(b->Rot);
}

bool Page::GetItem(PageItem **b, int nr)
{
        if (SelItem.count() != 0)
                {
                if (nr == -1)
                        *(b) = SelItem.at(0);
                else
                *(b) = SelItem.at(nr);
                return true;
                }
        else
                {
                *(b) = 0;
                return false;
                }
}

void Page::TransformM(PageItem *b, QPainter *p)
{
        if (b->flippedH % 2 != 0)
                {
                p->translate(b->Width, 0);
                p->scale(-1, 1);
                }
        if (b->flippedV % 2 != 0)
                {
                p->translate(0, b->Height);
                p->scale(1, -1);
                }
}

void Page::PaintSizeRect(QPainter *p, QRect alt, QRect neu)
{
        p->setRasterOp(XorROP);
        p->setBrush(NoBrush);
        p->setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
        p->drawRect(alt);
        p->drawRect(neu);
}

QPoint Page::ApplyGrid(QPoint in)
{
        QPoint np;
        if (doku->useRaster)
                {
                np.setX(static_cast<int>(qRound(in.x() / doku->minorGrid) * doku->minorGrid));
                np.setY(static_cast<int>(qRound(in.y() / doku->minorGrid) * doku->minorGrid));
                }
        else
                np = in;
        return np;
}

void Page::ApplyGuides(double *x, double *y)
{
        if (doku->SnapGuides)
                {
                if (YGuides.count() != 0)
                        {
                        for (uint yg = 0; yg < YGuides.count(); ++yg)
                                {
                                if ((YGuides[yg] < (*y+doku->GuideRad)) && (YGuides[yg] > (*y-doku->GuideRad)))
                                        {
                                        *y= YGuides[yg];
                                        break;
                                        }
                                }
                        }
                if (XGuides.count() != 0)
                        {
                        for (uint xg = 0; xg < XGuides.count(); ++xg)
                                {
                                if ((XGuides[xg] < (*x+doku->GuideRad)) && (XGuides[xg] > (*x-doku->GuideRad)))
                                        {
                                        *x = XGuides[xg];
                                        break;
                                        }
                                }
                        }
                }
}

FPoint Page::ApplyGridF(FPoint in)
{
        FPoint np;
        if (doku->useRaster)
                {
                np.setX(qRound(in.x() / doku->minorGrid) * doku->minorGrid);
                np.setY(qRound(in.y() / doku->minorGrid) * doku->minorGrid);
                }
        else
                np = in;
        return np;
}

void Page::RefreshItem(PageItem *b, bool single)
{
        QPainter p;
        p.begin(this);
        Transform(b, &p);
        if (single)
                RepaintTextRegion(b, QRegion(p.xForm(QRect(static_cast<int>(-b->Pwidth / 2.0), static_cast<int>(-b->Pwidth / 2.0), static_cast<int>(b->Width+(b->Pwidth / 2.0)), static_cast<int>(b->Height+(b->Pwidth / 2.0))))), true);
        else
                update(QRegion(p.xForm(QRect(static_cast<int>(-b->Pwidth / 2.0), static_cast<int>(-b->Pwidth / 2.0), static_cast<int>(b->Width+(b->Pwidth / 2.0)), static_cast<int>(b->Height+(b->Pwidth / 2.0))))).intersect(ViewReg()).boundingRect());
        p.end();
}

void Page::RepaintTextRegion(PageItem *b, QRegion alt, bool single)
{
        QPainter p;
        QRegion neu;
        if (!isUpdatesEnabled())
                return;
        p.begin(this);
        Transform(b, &p);
        neu = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width+1), static_cast<int>(b->Height+1)))).unite(alt);
        p.end();
        b->Dirty = true;
        QRect g = neu.boundingRect();
        g.setX(g.x()-static_cast<int>(b->Pwidth / 2.0));
        g.setY(g.y()-static_cast<int>(b->Pwidth / 2.0));
        g.setWidth(g.width()+static_cast<int>(b->Pwidth / 2.0));
        g.setHeight(g.height()+static_cast<int>(b->Pwidth / 2.0));
        if (single)
                {
                QRect rd = ViewReg().boundingRect().intersect(g);
                if ((rd.width() < 1) || (rd.height() < 1))
                        return;
                QPixmap pgPix(rd.width(), rd.height());
                ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
                painter->translate(0.5, 0.5);
                if (doku->Before)
                        DrawPageMarks(painter, rd);
                b->DrawObj(painter, rd);
                if (!doku->Before)
                        DrawPageMarks(painter, rd);
                painter->end();
                bitBlt( this, rd.x(), rd.y(), &pgPix, 0, 0, pgPix.width(), pgPix.height() );
                QPainter px;
                px.begin(this);
                px.setPen(QColor(0, 0, 0));
                px.setBrush(NoBrush);
                px.drawRect(0, 0, width(), height());
                px.end();
                b->paintObj(rd);
                if ((doku->EditClip) && (b->Select))
                        MarkClip(b);
                if (GroupSel)
                        {
                        setGroupRect();
                        paintGroupRect();
                        }
                delete painter;
                }
        else
                {
                neu = QRegion(g);
                update(neu.intersect(ViewReg()).boundingRect());
                }
}

void Page::AdjustPreview(PageItem *b)
{
        int neww, newh, fho, fvo;
        bool savF;
        if ((b->LocalViewX < 1.0) || (b->LocalViewY < 1.0))
                {
                if ((b->Pfile != "") && (b->PicAvail))
                        {
                        if (!b->Sizing)
                                {
                                fho = b->flippedH;
                                fvo = b->flippedV;
                                savF = b->PicArt;
                                LoadPict(b->Pfile, b->ItemNr);
                                b->flippedH = fho;
                                b->flippedV = fvo;
                                b->PicArt = savF;
                                }
                        neww = qRound(b->pixm.width() * b->LocalViewX);
                        newh = qRound(b->pixm.height() * b->LocalViewY);
                        b->pixm = b->pixm.smoothScale(neww, newh);
                        b->LocalViewX = 1;
                        b->LocalViewY = 1;
                        }
                }
}

void Page::AdjustPictScale(PageItem *b)
{
        int fho, fvo;
        bool savF;
        if (b->ScaleType)
                return;
        b->LocalX = 0;
        b->LocalY = 0;
        if ((b->OrigW == 0) || (b->OrigH == 0))
                return;
        double xs = b->Width / static_cast<double>(b->OrigW);
        double ys = b->Height / static_cast<double>(b->OrigH);
        if (!b->Sizing)
                {
                fho = b->flippedH;
                fvo = b->flippedV;
                savF = b->PicArt;
                LoadPict(b->Pfile, b->ItemNr);
                b->flippedH = fho;
                b->flippedV = fvo;
                b->PicArt = savF;
                }
        if (b->AspectRatio)
                {
                b->LocalScX = QMIN(xs, ys);
                b->LocalScY = QMIN(xs, ys);
                b->LocalViewX = QMIN(xs, ys);
                b->LocalViewY = QMIN(xs, ys);
                }
        else
                {
                b->LocalScX = xs;
                b->LocalScY = ys;
                b->LocalViewX = xs;
                b->LocalViewY = ys;
                }
        emit SetLocalValues(b->LocalScX, b->LocalScY, b->LocalX, b->LocalY );
}

bool Page::MoveSizeItem(FPoint newX, FPoint newY, int ite)
{
        QRegion alt;
        QPainter p;
        PageItem *b = Items.at(ite);
        p.begin(this);
        Transform(b, &p);
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
        p.end();
        if (b->PType == 5)
                {
                QWMatrix ma;
                ma.translate(b->Xpos, b->Ypos);
                ma.rotate(b->Rot);
                double mx = ma.m11() * b->Width + ma.m21() * b->Height + ma.dx();
                double my = ma.m22() * b->Height + ma.m12() * b->Width + ma.dy();
                MoveItem(newX.x(), newX.y(), b);
                b->Rot = xy2Deg(mx - b->Xpos, my - b->Ypos);
                b->Width = sqrt(pow(mx - b->Xpos,2)+pow(my - b->Ypos,2));
                b->Height = 0;
                UpdateClip(b);
                RepaintTextRegion(b, alt);
                emit ItemPos(b->Xpos, b->Ypos);
                emit ItemGeom(b->Width, b->Height);
                emit SetAngle(b->Rot);
                }
        else
                {
                if (b->Rot != 0)
                        {
                        FPoint npv = FPoint(newX.x(), newX.y());
                        QWMatrix ma3;
                        ma3.translate(b->Xpos, b->Ypos);
                        ma3.rotate(b->Rot);
                        double mxc3 = b->Xpos - (ma3.m11() * npv.x() + ma3.m21() * npv.y() + ma3.dx());
                        double myc3 = b->Ypos - (ma3.m22() * npv.y() + ma3.m12() * npv.x() + ma3.dy());
                        SizeItem(b->Width - newY.x(), b->Height - newY.y(), ite);
                        MoveItem(-mxc3, -myc3, b);
                        }
                else
                        {
                        SizeItem(b->Width - newY.x(), b->Height - newY.y(), ite);
                        MoveItem(newX.x(), newX.y(), b);
                        }
                }
        return true;
}

void Page::UpdateClip(PageItem* b)
{
        int ph = static_cast<int>(QMAX(1.0, b->Pwidth / 2.0));
        switch (b->PType)
                {
                case 5:
                        b->Clip.setPoints(4, -ph,-ph, static_cast<int>(b->Width+ph),-ph, static_cast<int>(b->Width+ph),static_cast<int>(b->Height+ph), -ph,static_cast<int>(b->Height+ph));
                        break;
                default:
                        if (!b->ClipEdited)
                                {
                                switch (b->FrameType)
                                        {
                                        case 0:
                                                SetRectFrame(b);
                                                break;
                                        case 1:
                                                SetOvalFrame(b);
                                                break;
                                        case 2:
                                                SetFrameRound(b);
                                                break;
                                        }
                                b->OldB2 = b->Width;
                                b->OldH2 = b->Height;
                                }
                        else
                                {
                                if (doku->SubMode != -1)
                                        {
                                        switch (doku->SubMode)
                                                {
                                                case 0:
                                                        SetRectFrame(b);
                                                        break;
                                                case 1:
                                                        SetOvalFrame(b);
                                                        break;
                                                default:
                                                        SetFrameShape(b, doku->ValCount, doku->ShapeValues);
                                                        break;
                                                }
                                        b->OldB2 = b->Width;
                                        b->OldH2 = b->Height;
                                        }
                                if ((b->OldB2 == 0) || (b->OldH2 == 0))
                                        return;
                                double scx = b->Width / b->OldB2;
                                double scy = b->Height / b->OldH2;
                                QWMatrix ma;
                                ma.scale(scx, scy);
                                b->PoLine.map(ma);
                                if (b->PType == 8)
                                        UpdatePolyClip(b);
                                else
                                        b->Clip = FlattenPath(b->PoLine, b->Segments);
                                b->OldB2 = b->Width;
                                b->OldH2 = b->Height;
                                }
                        break;
                }
}

bool Page::SizeItem(double newX, double newY, int ite, bool fromMP, bool DoUpdateClip)
{
        QRegion alt, neu;
        QPainter p;
        PageItem *b = Items.at(ite);
        if (b->Locked)
                return false;
        if (b->PType != 5)
                {
                newX = QMAX(newX, 1);
                newY = QMAX(newY, 1);
                }
        int ph = static_cast<int>(QMAX(1.0, b->Pwidth / 2.0));
        p.begin(this);
        Transform(b, &p);
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
        p.end();
        b->Width = newX;
        b->Height = newY;
  b->RadRect = QMIN(b->RadRect, QMIN(b->Width,b->Height)/2);
        if ((b->PType == 2) && (!b->Sizing) && (!doku->EditClip))
                {
                AdjustPictScale(b);
                AdjustPreview(b);
                }
        if (b->PType == 5)
                {
                if (!fromMP)
                        {
                        b->Rot = atan2(b->Height,b->Width)*(180.0/3.1415927);
                        b->Width = sqrt(pow(b->Width,2)+pow(b->Height,2));
                        b->Height = 0;
                        emit SetAngle(b->Rot);
                        }
                b->Clip.setPoints(4, -ph,-ph, static_cast<int>(b->Width+ph),-ph, static_cast<int>(b->Width+ph),static_cast<int>(b->Height+ph), -ph,static_cast<int>(b->Height+ph));
                }
        if (b->Sizing)
                {
                b->FrameOnly = true;
                b->Tinput = true;
                if ((HowTo == 1) && (b->PType != 5))
                        b->paintObj();
                emit ItemGeom(b->Width, b->Height);
                emit ItemRadius(b->RadRect);
                return true;
                }
        if (DoUpdateClip)
                {
                if (fromMP)
                        {
                        if (b->flippedH % 2 != 0)
                                MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                        if (b->flippedV % 2 != 0)
                                MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                        }
                else
                        {
                        if (b->flippedH % 2 == 0)
                                MoveItemI((b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                        if (b->flippedV % 2 == 0)
                                MoveItemI(0, (b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                        }
                UpdateClip(b);
                }
        RepaintTextRegion(b, alt);
        if (!fromMP)
                {
                if (GroupSel)
                        {
                        double gx, gy, gh, gw;
                        setGroupRect();
                        getGroupRect(&gx, &gy, &gw, &gh);
                        emit ItemGeom(gw, gh);
                        }
                else
                        emit ItemGeom(b->Width, b->Height);
                }
        emit ItemRadius(b->RadRect);
        return true;
}

void Page::MoveItemI(double newX, double newY, int ite)
{
        QPainter p;
        PageItem *b = Items.at(ite);
        if (b->Locked)
                return;
        if (!b->ScaleType)
                return;
        p.begin(this);
        Transform(b, &p);
        TransformM(b, &p);
        QRegion alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
        p.end();
        if (b->flippedH % 2 != 0)
                b->LocalX -= newX;
        else
                b->LocalX += newX;
        if (b->flippedV % 2 != 0)
                b->LocalY -= newY;
        else
                b->LocalY += newY;
        repaint(alt);
        emit SetLocalValues(b->LocalScX, b->LocalScY, b->LocalX, b->LocalY);
}

bool Page::MoveItem(double newX, double newY, PageItem* b, bool fromMP)
{
        QRegion alt;
        bool retw = false;
        if (b->Locked)
                return false;
        double oldx = b->Xpos;
        double oldy = b->Ypos;
        if (!Imoved)
                {
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
                p.end();
                }
        b->Xpos += newX;
        b->Ypos += newY;
        if ((doku->useRaster) && (!Imoved))
                {
                b->Xpos = qRound(b->Xpos / doku->minorGrid) * doku->minorGrid;
                b->Ypos = qRound(b->Ypos / doku->minorGrid) * doku->minorGrid;
                }
        if ((doku->SnapGuides) && (!Imoved) && (doku->AppMode == 1) && (!doku->EditClip))
                SnapToGuides(b);
        if ((b->Xpos != oldx) || (b->Ypos != oldy))
                retw = true;
        if ((!Imoved) && (!b->Sizing))
                RepaintTextRegion(b, alt);
        if (!fromMP)
                {
                if (GroupSel)
                        {
                        double gx, gy, gh, gw;
                        setGroupRect();
                        getGroupRect(&gx, &gy, &gw, &gh);
                        emit ItemPos(gx, gy);
                        }
                else
                        emit ItemPos(b->Xpos, b->Ypos);
                }
        if (!doku->loading)
                emit UpdtObj(PageNr, b->ItemNr);
        return retw;
}

void Page::RotateItem(double win, int ite)
{
        QRegion alt, neu;
        QPainter p;
        PageItem *b;
        FPoint n;
        b = Items.at(ite);
        if (b->Locked)
                return;
        p.begin(this);
        Transform(b, &p);
        alt = QRegion(p.xForm(QRect(0, 0, static_cast<int>(b->Width), static_cast<int>(b->Height))));
        p.end();
        if ((doku->RotMode != 0) && (b->PType != 5))
                {
                QWMatrix ma;
                ma.translate(b->Xpos, b->Ypos);
                ma.scale(1, 1);
                ma.rotate(b->Rot);
                double ro = win-b->Rot;
                b->Rot = win;
                switch (doku->RotMode)
                        {
                        case 2:
                                ma.translate(b->Width/2, b->Height/2);
                                n = FPoint(-b->Width/2, -b->Height/2);
                                break;
                        case 4:
                                ma.translate(b->Width, b->Height);
                                n = FPoint(-b->Width, -b->Height);
                                break;
                        case 3:
                                ma.translate(0, b->Height);
                                n = FPoint(0, -b->Height);
                                break;
                        case 1:
                                ma.translate(b->Width, 0);
                                n = FPoint(-b->Width, 0);
                                break;
                        }
                ma.rotate(ro);
                double x = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
                double y = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
                MoveItem(x-b->Xpos, y-b->Ypos, b);
                }
        else
                b->Rot = win;
        RepaintTextRegion(b, alt);
        emit SetAngle(b->Rot);
}

void Page::SnapToGuides(PageItem* b)
{
        if (YGuides.count() != 0)
                {
                for (uint yg = 0; yg < YGuides.count(); ++yg)
                        {
                        if ((YGuides[yg] < (b->Ypos+doku->GuideRad)) && (YGuides[yg] > (b->Ypos-doku->GuideRad)))
                                {
                                b->Ypos = YGuides[yg];
                                break;
                                }
                        if (b->PType == 5)
                                {
                                QWMatrix ma;
                                ma.translate(b->Xpos, b->Ypos);
                                ma.rotate(b->Rot);
                                double my = ma.m22() * b->Height + ma.m12() * b->Width + ma.dy();
                                if ((YGuides[yg] < (my+doku->GuideRad)) && (YGuides[yg] > (my-doku->GuideRad)))
                                        {
                                        b->Ypos = b->Ypos + YGuides[yg] - my;
                                        break;
                                        }
                                }
                        else
                                {
                                if ((YGuides[yg] < (b->Ypos+b->Height+doku->GuideRad)) && (YGuides[yg] > ((b->Ypos+b->Height)-doku->GuideRad)))
                                        {
                                        b->Ypos = YGuides[yg]-b->Height;
                                        break;
                                        }
                                }
                        }
                }
        if (XGuides.count() != 0)
                {
                for (uint xg = 0; xg < XGuides.count(); ++xg)
                        {
                        if ((XGuides[xg] < (b->Xpos+doku->GuideRad)) && (XGuides[xg] > (b->Xpos-doku->GuideRad)))
                                {
                                b->Xpos = XGuides[xg];
                                break;
                                }
                        if (b->PType == 5)
                                {
                                QWMatrix ma;
                                ma.translate(b->Xpos, b->Ypos);
                                ma.rotate(b->Rot);
                                double mx = ma.m11() * b->Width + ma.m21() * b->Height + ma.dx();
                                if ((XGuides[xg] < (mx+doku->GuideRad)) && (XGuides[xg] > (mx-doku->GuideRad)))
                                        {
                                        b->Xpos = b->Xpos + XGuides[xg] - mx;
                                        break;
                                        }
                                }
                        else
                                {
                                if ((XGuides[xg] < (b->Xpos+b->Width+doku->GuideRad)) && (XGuides[xg] > ((b->Xpos+b->Width)-doku->GuideRad)))
                                        {
                                        b->Xpos = XGuides[xg]-b->Width;
                                        break;
                                        }
                                }
                        }
                }
}

void Page::sentToScrap()
{
        ScriXmlDoc *ss = new ScriXmlDoc();
        emit ToScrap(ss->WriteElem(&SelItem, doku));
        delete ss;
}

void Page::sentToLayer(int id)
{
        int d = pmen3->indexOf(id);
        PageItem *b = SelItem.at(0);
        b->LayerNr = d;
        Deselect(true);
  update();
}

bool Page::PointOnLine(QPoint Start, QPoint Ende, QRect MArea)
{
        QPoint an, en;
        if (Start.x() == Ende.x())
                {
                if (Start.y() > Ende.y())
                        {
                        an = Ende;
                        en = Start;
                        }
                else
                        {
                        en = Ende;
                        an = Start;
                        }
                for (int a=an.y(); a<en.y(); ++a)
                        {
                        if (MArea.contains(QPoint(an.x(), a)))
                                return true;
                        }
                }
        if (Start.y() == Ende.y())
                {
                if (Start.x() > Ende.x())
                        {
                        an = Ende;
                        en = Start;
                        }
                else
                        {
                        en = Ende;
                        an = Start;
                        }
                for (int a=an.x(); a<en.x(); ++a)
                        {
                        if (MArea.contains(QPoint(a, an.y())))
                                return true;
                        }
                }
        if (Start.x() > Ende.x())
                {
                an = Ende;
                en = Start;
                }
        else
                {
                en = Ende;
                an = Start;
                }
        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(QPoint(a, an.y()+qRound((a-an.x())*stg))))
                        return true;
                }
        return false;
}

void Page::MoveRotated(PageItem *b, FPoint npv)
{
        QWMatrix ma;
        ma.translate(b->Xpos, b->Ypos);
        ma.rotate(b->Rot);
        double mxc = b->Xpos - (ma.m11() * npv.x() + ma.m21() * npv.y() + ma.dx());
        double myc = b->Ypos - (ma.m22() * npv.y() + ma.m12() * npv.x() + ma.dy());
        MoveItem(-mxc, -myc, b);
}

void Page::AdjustItemSize(PageItem *b)
{
        FPointArray Clip;
        Clip = b->PoLine;
        FPoint tp2 = GetMinClipF(Clip);
        SizeItem(b->Width - tp2.x(), b->Height - tp2.y(), b->ItemNr, false, false);
        Clip.translate(-tp2.x(), -tp2.y());
        if (b->Rot != 0)
                {
                FPoint npv = FPoint(tp2.x(), tp2.y());
                MoveRotated(b, npv);
                }
        else
                MoveItem(tp2.x(), tp2.y(), b);
        if (b->flippedH % 2 == 0)
                MoveItemI(-tp2.x()/b->LocalScX, 0, b->ItemNr);
        if (b->flippedV % 2 == 0)
                MoveItemI(0, -tp2.y()/b->LocalScY, b->ItemNr);
        FPoint tp = GetMaxClipF(Clip);
        if (b->flippedH % 2 != 0)
                MoveItemI((b->Width - tp.x())/b->LocalScX, 0, b->ItemNr);
        if (b->flippedV % 2 != 0)
                MoveItemI(0, (b->Height - tp.y())/b->LocalScY, b->ItemNr);
        SizeItem(tp.x(), tp.y(), b->ItemNr, false, false);
        b->ClipEdited = true;
        b->PoLine = Clip.copy();
        if (b->PType == 7)
                SetPolyClip(b, qRound(QMAX(b->Pwidth / 2, 1)), qRound(QMAX(b->Pwidth / 2, 1)));
        else
                b->Clip = FlattenPath(b->PoLine, b->Segments);
}

void Page::MirrorPolyH()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.scale(-1, 1);
        b->PoLine.map(ma);
        b->PoLine.translate(b->Width, 0);
        if (b->PType == 8)
                UpdatePolyClip(b);
        else
                b->Clip = FlattenPath(b->PoLine, b->Segments);
        RefreshItem(b);
        MarkClip(b);
}

void Page::MirrorPolyV()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.scale(1, -1);
        b->PoLine.map(ma);
        b->PoLine.translate(0, b->Height);
        if (b->PType == 8)
                UpdatePolyClip(b);
        else
                b->Clip = FlattenPath(b->PoLine, b->Segments);
        RefreshItem(b);
        MarkClip(b);
}

void Page::ShearPolyHR()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.shear(-0.017455, 0);
        b->PoLine.map(ma);
        AdjustItemSize(b);
        if (b->PType == 8)
                UpdatePolyClip(b);
        RefreshItem(b);
        MarkClip(b);
        b->FrameType = 3;
}

void Page::ShearPolyHL()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.shear(0.017455, 0);
        b->PoLine.map(ma);
        AdjustItemSize(b);
        if (b->PType == 8)
                UpdatePolyClip(b);
        RefreshItem(b);
        MarkClip(b);
        b->FrameType = 3;
}

void Page::ShearPolyVU()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.shear(0, -0.017455);
        b->PoLine.map(ma);
        AdjustItemSize(b);
        if (b->PType == 8)
                UpdatePolyClip(b);
        RefreshItem(b);
        MarkClip(b);
        b->FrameType = 3;
}

void Page::ShearPolyVD()
{
        PageItem *b = SelItem.at(0);
        QWMatrix ma;
        ma.shear(0, 0.017455);
        b->PoLine.map(ma);
        AdjustItemSize(b);
        if (b->PType == 8)
                UpdatePolyClip(b);
        RefreshItem(b);
        MarkClip(b);
        b->FrameType = 3;
}

void Page::Reset1Control()
{
        PageItem *b = SelItem.at(0);
        FPoint np = b->PoLine.point(ClRe-1);
        b->OldB2 = b->Width;
        b->OldH2 = b->Height;
        b->PoLine.setPoint(ClRe, np);
        AdjustItemSize(b);
        MarkClip(b);
}

void Page::ResetControl()
{
        PageItem *b = SelItem.at(0);
        FPoint np = b->PoLine.point(ClRe);
        b->OldB2 = b->Width;
        b->OldH2 = b->Height;
        if ((ClRe == 0) || (ClRe == static_cast<int>(b->PoLine.size()-2)))
                b->PoLine.setPoint(ClRe+1, np);
        else
                {
                b->PoLine.setPoint(ClRe+1, np);
                if (ClRe % 4 != 0)
                        b->PoLine.setPoint(ClRe+3, np);
                else
                        b->PoLine.setPoint(ClRe-1, np);
                }
        AdjustItemSize(b);
        MarkClip(b);
}

void Page::MoveClipPoint(PageItem *b, FPoint ip)
{
        FPointArray Clip;
        Clip = b->PoLine;
        b->FrameType = 3;
        if ((EdPoints) && (ClRe % 2 != 0))
                return;
        if ((!EdPoints) && (ClRe % 2 == 0))
                return;
        uint EndInd = Clip.size();
        uint StartInd = 0;
        for (uint n = ClRe; n < Clip.size(); n++)
                {
                if (Clip.point(n).x() > 900000)
                        {
                        EndInd = n;
                        break;
                        }
                }
        if (ClRe > 0)
                {
                for (uint n2 = ClRe; n2 > 0; n2--)
                        {
                        if (n2 == 0)
                                break;
                        if (Clip.point(n2).x() > 900000)
                                {
                                StartInd = n2 + 1;
                                break;
                                }
                        }
                }
//      FPoint np = ApplyGridF(ip);
        FPoint np = ip;
        if (ClRe != -1)
                {
                if (np.x() < 0)
                        {
                        SizeItem(b->Width - np.x(), b->Height, b->ItemNr, false, false);
                        if (b->Rot != 0)
                                {
                                FPoint npv = FPoint(np.x(), 0);
                                MoveRotated(b, npv);
                                }
                        else
                                MoveItem(np.x(), 0, b);
                        Clip.translate(-np.x(), 0);
                        if (b->flippedH % 2 == 0)
                                MoveItemI(-np.x()/b->LocalScX, 0, b->ItemNr);
                        np.setX(0);
                        }
                if (np.y() < 0)
                        {
                        SizeItem(b->Width, b->Height - np.y(), b->ItemNr, false, false);
                        if (b->Rot != 0)
                                {
                                FPoint npv = FPoint(0, np.y());
                                MoveRotated(b, npv);
                                }
                        else
                                MoveItem(0, np.y(), b);
                        Clip.translate(0, -np.y());
                        if (b->flippedV % 2 == 0)
                                MoveItemI(0, -np.y()/b->LocalScY, b->ItemNr);
                        np.setY(0);
                        }
                emit ClipPo(np.x(), np.y());
                if ((ClRe+1 < static_cast<int>(EndInd)) && (ClRe % 2 == 0))
                        {
                        FPoint ap = Clip.point(ClRe);
                        FPoint ap2 = Clip.point(ClRe+1);
                        ap2.setX(ap2.x() - (ap.x() - np.x()));
                        ap2.setY(ap2.y() - (ap.y() - np.y()));
                        Clip.setPoint(ClRe+1, ap2);
                        }
                Clip.setPoint(ClRe, np);
                if (((ClRe % 4 != 0) && (ClRe % 2 == 0)) && (ClRe+3 < static_cast<int>(EndInd)) && (ClRe != static_cast<int>(StartInd)))
                        {
                        FPoint ap = Clip.point(ClRe+2);
                        FPoint ap2 = Clip.point(ClRe+3);
                        ap2.setX(ap2.x() - (ap.x() - np.x()));
                        ap2.setY(ap2.y() - (ap.y() - np.y()));
                        Clip.setPoint(ClRe+3, ap2);
                        Clip.setPoint(ClRe+2, np);
                        }
                if ((ClRe % 4 == 0) && (ClRe+3 < static_cast<int>(EndInd)) && (ClRe != static_cast<int>(StartInd)))
                        {
                        FPoint ap = Clip.point(ClRe-2);
                        FPoint ap2 = Clip.point(ClRe-1);
                        ap2.setX(ap2.x() - (ap.x() - np.x()));
                        ap2.setY(ap2.y() - (ap.y() - np.y()));
                        Clip.setPoint(ClRe-1, ap2);
                        Clip.setPoint(ClRe-2, np);
                        }
                if (((ClRe == static_cast<int>(StartInd)) || (ClRe == static_cast<int>(EndInd-2))) && ((b->PType == 6) || (b->PType == 4) || (b->PType == 2)))
                        {
                        if (ClRe == static_cast<int>(StartInd))
                                {
                                FPoint ap = Clip.point(EndInd-2);
                                FPoint ap2 = Clip.point(EndInd-1);
                                ap2.setX(ap2.x() - (ap.x() - np.x()));
                                ap2.setY(ap2.y() - (ap.y() - np.y()));
                                Clip.setPoint(EndInd-2, Clip.point(StartInd));
                                Clip.setPoint(EndInd-1, ap2);
                                }
                        else
                                {
                                FPoint ap = Clip.point(StartInd);
                                FPoint ap2 = Clip.point(StartInd + 1);
                                ap2.setX(ap2.x() - (ap.x() - np.x()));
                                ap2.setY(ap2.y() - (ap.y() - np.y()));
                                Clip.setPoint(StartInd, Clip.point(EndInd-2));
                                Clip.setPoint(StartInd + 1, ap2);
                                }
                        }
                if (((ClRe == static_cast<int>(StartInd+1)) || (ClRe == static_cast<int>(EndInd-1))) && ((b->PType == 6) || (b->PType == 4) || (b->PType == 2)) && (MoveSym))
                        {
                        uint kon = 0;
                        if (ClRe == static_cast<int>(StartInd+1))
                                kon = EndInd-1;
                        else
                                kon = StartInd + 1;
                        FPoint lxy = Clip.point(ClRe-1);
                        FPoint lk = Clip.point(ClRe);
                        double dx = lxy.x() - lk.x();
                        double dy = lxy.y() - lk.y();
                        lk.setX(lk.x() + dx*2);
                        lk.setY(lk.y() + dy*2);
                        Clip.setPoint(kon, lk);
                        }
                if ((ClRe % 2 != 0) && (MoveSym) && (ClRe != static_cast<int>(StartInd + 1)) && (ClRe != static_cast<int>(EndInd-1)))
                        {
                        uint kon = 0;
                        if ((ClRe+1) % 4 == 0)
                                kon = ClRe + 2;
                        else
                                kon = ClRe - 2;
                        FPoint lxy = Clip.point(ClRe-1);
                        FPoint lk = Clip.point(ClRe);
                        double dx = lxy.x() - lk.x();
                        double dy = lxy.y() - lk.y();
                        lk.setX(lk.x() + dx*2);
                        lk.setY(lk.y() + dy*2);
                        Clip.setPoint(kon, lk);
                        }
                b->PoLine = Clip.copy();
                b->Clip = FlattenPath(b->PoLine, b->Segments);
                AdjustItemSize(b);
//                                      emit DocChanged();
                }
}
void Page::ConvertClip(PageItem *b)
{
        if (b->Clip.count() != 0)
                {
                FPoint np = FPoint(b->Clip.point(0));
                b->PoLine.resize(2);
                b->PoLine.setPoint(0, np);
                b->PoLine.setPoint(1, np);
                for (uint a = 1; a < b->Clip.size(); ++a)
                        {
                        np = FPoint(b->Clip.point(a));
                        b->PoLine.putPoints(b->PoLine.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
                        }
                np = FPoint(b->Clip.point(0));
                b->PoLine.putPoints(b->PoLine.size(), 2, np.x(), np.y(), np.x(), np.y());
                b->Clip = FlattenPath(b->PoLine, b->Segments);
                }
        else
                SetRectFrame(b);
}

void Page::mouseDoubleClickEvent(QMouseEvent *m)
{
        m->accept();
        Mpressed = false;
        if ((GroupSel) || (doku->AppMode != 1) || (doku->EditClip))
                {
                mousePressEvent(m);
                return;
                }
        PageItem *b = 0;
        if (GetItem(&b))
                {
                if ((b->PType == 6) || (b->PType == 7) || (b->PType == 2) || (b->PType == 8))
                        {
                        if ((b->Locked) || (!b->ScaleType))
                                {
                                mousePressEvent(m);
                                return;
                                }
                        emit Amode(7);
                        }
                else
                        {
                        if (b->PType == 4)
                                {
                                if (b->isAnnotation)
                                        emit AnnotProps();
                                else
                                        emit Amode(7);
                                }
                        }
                }
}

FPoint Page::transformPointI(FPoint in, double dx, double dy, double rot, double sx, double sy)
{
        QWMatrix ma;
        ma.translate(dx, dy);
        ma.scale(sx, sy);
        ma.rotate(rot);
        ma = ma.invert();
        double x = ma.m11() * in.x() + ma.m21() * in.y() + ma.dx();
        double y = ma.m22() * in.y() + ma.m12() * in.x() + ma.dy();
        return FPoint(x, y);
}

FPoint Page::transformPoint(FPoint in, double dx, double dy, double rot, double sx, double sy)
{
        QWMatrix ma;
        ma.translate(dx, dy);
        ma.scale(sx, sy);
        ma.rotate(rot);
        double x = ma.m11() * in.x() + ma.m21() * in.y() + ma.dx();
        double y = ma.m22() * in.y() + ma.m12() * in.x() + ma.dy();
        return FPoint(x, y);
}

void Page::scaleGroup(double scx, double scy)
{
        PageItem *bb;
        double gx, gy, gh, gw;
        uint aa;
        getGroupRect(&gx, &gy, &gw, &gh);
        for (uint a = 0; a < SelItem.count(); ++a)
                {
                bb = SelItem.at(a);
                bb->OldB = bb->Width;
                bb->OldH = bb->Height;
                bb->OldB2 = bb->Width;
                bb->OldH2 = bb->Height;
                bb->Sizing = false;
                FPoint b, b1, t, t1, h, h1, g, tes, tes2;
                double oldRot;
                switch (HowTo)
                        {
                        case 1:
                                oldRot = bb->Rot;
                                g = FPoint(gx, gy);
                                b = transformPoint(FPoint(0, 0), bb->Xpos, bb->Ypos, bb->Rot, 1, 1);
                                b -= g;
                                b1 = transformPoint(b, 0, 0, 0, scx, scy);
                                t = transformPoint(FPoint(bb->Width, 0), bb->Xpos, bb->Ypos, bb->Rot, 1, 1);
                                t -= g;
                                t1 = transformPoint(t, 0, 0, 0, scx, scy);
                                h = transformPoint(FPoint(0, bb->Height), bb->Xpos, bb->Ypos, bb->Rot, 1, 1);
                                h -= g;
                                h1 = transformPoint(h, 0, 0, 0, scx, scy);
                                bb->Pwidth = QMAX(bb->Pwidth*((scx+scy)/2), 0.01);
                                MoveItem(b1.x()-b.x(), b1.y()-b.y(), bb);
                                SizeItem(sqrt(pow(t1.x()-b1.x(),2)+pow(t1.y()-b1.y(),2)), sqrt(pow(h1.x()-b1.x(),2)+pow(h1.y()-b1.y(),2)), bb->ItemNr, true);
                                if (bb->Rot != 0)
                                        bb->Rot = atan2(t1.y()-b1.y(),t1.x()-b1.x())*(180.0/M_PI);
                                bb->ISize = QMAX(qRound(bb->ISize*((scx+scy)/2)), 1);
                                if (bb->Ptext.count() != 0)
                                        {
                                        bb->LineSp = ((bb->ISize / 10.0) * static_cast<double>(doku->AutoLine) / 100) + (bb->ISize / 10.0);
                                        for (aa = 0; aa < bb->Ptext.count(); ++aa)
                                                {
                                                bb->Ptext.at(aa)->csize = QMAX(qRound(bb->Ptext.at(aa)->csize*((scx+scy)/2)), 1);
                                                }
                                        if (bb->PType == 8)
                                                {
                                                UpdatePolyClip(bb);
                                                }
                                        }
                                break;
                        }
                }
        setGroupRect();
        update();
        emit DocChanged();
}

void Page::mouseReleaseEvent(QMouseEvent *m)
{
        PageItem *b;
        Mpressed = false;
        if (doku->Guides)
                {
                bool fg = false;
                double nx = m->x()/doku->Scale;
                double ny = m->y()/doku->Scale;
                if (YGuides.count() != 0)
                        {
                        for (uint yg = 0; yg < YGuides.count(); ++yg)
                                {
                                if ((YGuides[yg] < (ny+doku->GrabRad)) && (YGuides[yg] > (ny-doku->GrabRad)))
                                        {
                                        fg = true;
                                        break;
                                        }
                                }
                        }
                if (XGuides.count() != 0)
                        {
                        for (uint xg = 0; xg < XGuides.count(); ++xg)
                                {
                                if ((XGuides[xg] < (nx+doku->GrabRad)) && (XGuides[xg] > (nx-doku->GrabRad)))
                                        {
                                        fg = true;
                                        break;
                                        }
                                }
                        }
                if ((fg) && (m->button() == RightButton))
                        {
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        MoveGY = false;
                        MoveGX = false;
                        emit EditGuides();
                        return;
                        }
                if (MoveGY)
                        {
                        YGuides.remove(YGuides[GyM]);
                        SetYGuide(m);
                        MoveGY = false;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        update();
                        return;
                        }
                if (MoveGX)
                        {
                        XGuides.remove(XGuides[GxM]);
                        SetXGuide(m);
                        MoveGX = false;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        update();
                        return;
                        }
                }
        if ((doku->EditClip) && (ClRe == -1) && (HaveSelRect))
                {
                double sc = doku->Scale;
                QPainter p;
                p.begin(this);
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                p.drawRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                p.end();
        if((Mxp*sc) > SeRx)
                {
        double tmp=SeRx;
        SeRx=static_cast<int>(Mxp*sc);
        Mxp=static_cast<int>(tmp/sc);
                }
        if((Myp*sc) > SeRy)
                {
        double tmp=SeRy;
        SeRy=static_cast<int>(Myp*sc);
        Myp=static_cast<int>(tmp/sc);
                }
                b = SelItem.at(0);
                SelNode.clear();
                QRect Sele = QRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                for (uint a = 0; a < b->PoLine.count(); ++a)
                        {
                        if (b->PoLine.point(a).x() > 900000)
                                continue;
                        p.begin(this);
                        Transform(b, &p);
                        QPoint npf = p.xForm(b->PoLine.pointQ(a));
                        p.end();
                        if ((Sele.contains(npf)) && ((a == 0) || (((a-2) % 4) == 0)))
                                {
                                ClRe = a;
                                SelNode.append(a);
                                emit ClipPo(b->PoLine.point(a).x(), b->PoLine.point(a).y());
                                }
                        }
                HaveSelRect = false;
                MarkClip(b);
                return;
                }
        if ((doku->EditClip) && (SegP1 == -1) && (SegP2 == -1))
                {
                if (Imoved)
                        {
                        b = SelItem.at(0);
                        b->OldB2 = b->Width;
                        b->OldH2 = b->Height;
                        double nx = m->x()/doku->Scale;
                        double ny = m->y()/doku->Scale;
                        FPoint npg = ApplyGridF(FPoint(nx, ny));
                        nx = npg.x();
                        ny = npg.y();
                        ApplyGuides(&nx, &ny);
                        FPoint np = transformPointI(FPoint(nx, ny), b->Xpos, b->Ypos, b->Rot, 1, 1);
                        MoveClipPoint(b, np);
                        }
                Imoved = false;
                return;
                }
        if ((doku->EditClip) && (SegP1 != -1) && (SegP2 != -1))
                {
                SegP1 = -1;
                SegP2 = -1;
                b = SelItem.at(0);
                Imoved = false;
                b->paintObj();
                MarkClip(b);
                return;
                }
        if ((doku->AppMode != 6) /* && (doku->AppMode != 7) */ && (!doku->EditClip) && (doku->AppMode != 13))
                {
                if ((GetItem(&b)) && (m->button() == RightButton) && (!doku->DragP))
                        {
                        QPopupMenu *pmen = new QPopupMenu();
                        QPopupMenu *pmen2 = new QPopupMenu();
                        pmen3 = new QPopupMenu();
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        if (b->PType == 2)
                                {
                                pmen->insertItem( tr("Get Picture..."), this, SIGNAL(LoadPic()));
                                int px = pmen->insertItem( tr("Image Visible"), this, SLOT(TogglePic()));
                                pmen->setItemChecked(px, b->PicArt);
                                }
                        if (b->PType == 4)
                                {
                                pmen->insertItem( tr("Get Text..."), this, SIGNAL(LoadPic()));
                                pmen->insertItem( tr("Edit Text..."), this, SIGNAL(EditText()));
                                if (PageNam == "")
                                        {
                                        int pxb = pmen->insertItem( tr("Is PDF-Bookmark"), this, SLOT(ToggleBookmark()));
                                        pmen->setItemChecked(pxb, b->isBookmark);
                                        pxb = pmen->insertItem( tr("Is PDF-Annotation"), this, SLOT(ToggleAnnotation()));
                                        pmen->setItemChecked(pxb, b->isAnnotation);
                                        if (b->isAnnotation)
                                                {
                                                if ((b->AnType == 0) || (b->AnType == 1) || (b->AnType > 9))
                                                        pmen->insertItem( tr("Annotation Properties"), this, SIGNAL(AnnotProps()));
                                                else
                                                        pmen->insertItem( tr("Field Properties"), this, SIGNAL(AnnotProps()));
                                                }
                                        }
                                }
                        if (b->PType == 8)
                                pmen->insertItem( tr("Edit Text..."), this, SIGNAL(EditText()));
                        if (!b->Locked)
                                {
                                if (SelItem.count() > 1)
                                        pmen->insertItem( tr("Group"), this, SIGNAL(DoGroup()));
                                if (b->Groups.count() != 0)
                                        pmen->insertItem( tr("Un-group"), this, SIGNAL(DoUnGroup()));
                                pmen->insertItem( tr("Lock"), this, SLOT(ToggleLock()));
                                pmen->insertItem( tr("Send to Back"), this, SLOT(ToBack()));
                                pmen->insertItem( tr("Bring to Front"), this, SLOT(ToFront()));
                                pmen->insertItem( tr("Lower"), this, SLOT(LowerItem()));
                                pmen->insertItem( tr("Raise"), this, SLOT(RaiseItem()));
                                }
                        else
                                pmen->insertItem( tr("Unlock"), this, SLOT(ToggleLock()));
                        pmen->insertItem( tr("Send to Scrapbook"), this, SLOT(sentToScrap()));
                        if (doku->Layers.count() > 1)
                                {
                                for (uint lam=0; lam < doku->Layers.count(); ++lam)
                                        {
                                        int lai = pmen3->insertItem(doku->Layers[lam].Name);
                                        if (static_cast<int>(lam) == doku->ActiveLayer)
                                                pmen3->setItemEnabled(lai, 0);
                                        }
                                pmen->insertItem( tr("Send to Layer"), pmen3);
                                }
                        connect(pmen3, SIGNAL(activated(int)), this, SLOT(sentToLayer(int)));
                        if ((b->PType == 4) || (b->PType == 2) || (b->PType == 6))
                                {
                                if (b->PType == 4)
                                        {
                                        pmen2->insertItem( tr("Picture Frame"), this, SLOT(ToPicFrame()));
                                        pmen2->insertItem( tr("Polygon"), this, SLOT(ToPolyFrame()));
                                        pmen2->insertItem( tr("Outlines"), this, SLOT(TextToPath()));
                                        }
                                if (b->PType == 2)
                                        {
                                        pmen2->insertItem( tr("Text Frame"), this, SLOT(ToTextFrame()));
                                        pmen2->insertItem( tr("Polygon"), this, SLOT(ToPolyFrame()));
                                        }
                                if (b->PType == 6)
                                        {
                                        pmen2->insertItem( tr("Text Frame"), this, SLOT(ToTextFrame()));
                                        pmen2->insertItem( tr("Picture Frame"), this, SLOT(ToPicFrame()));
                                        pmen2->insertItem( tr("Bezier Curve"), this, SLOT(ToBezierFrame()));
                                        }
                                pmen->insertItem( tr("Convert to"), pmen2);
                                }
                        pmen->insertSeparator();
                        if (!b->Locked)
                                pmen->insertItem( tr("Cut"), this, SIGNAL(CutItem()));
                        pmen->insertItem( tr("Copy"), this, SIGNAL(CopyItem()));
                        if ((!b->Locked) && (doku->AppMode != 7))
                                pmen->insertItem( tr("Delete"), this, SLOT(DeleteItem()));
                        pmen->exec(QCursor::pos());
                        delete pmen;
                        delete pmen2;
                        disconnect(pmen3, SIGNAL(activated(int)), this, SLOT(sentToLayer(int)));
                        delete pmen3;
                        }
                if (doku->AppMode == 10)
                        update();
                if (doku->AppMode == 12)
                        {
                        b = SelItem.at(0);
                        QPainter p;
                        FPointArray cli;
                        p.begin(this);
                        Transform(b, &p);
                        QPoint np1 = p.xFormDev(m->pos());
                        p.end();
                        np1 = ApplyGrid(np1);
                        b->Width = np1.x();
                        b->Height = np1.y();
                        cli = RegularPolygonF(b->Width, b->Height, PolyC, PolyS, PolyF, PolyR);
                        FPoint np = FPoint(cli.point(0));
                        b->PoLine.resize(2);
                        b->PoLine.setPoint(0, np);
                        b->PoLine.setPoint(1, np);
                        for (uint ax = 1; ax < cli.size(); ++ax)
                                {
                                np = FPoint(cli.point(ax));
                                b->PoLine.putPoints(b->PoLine.size(), 4, np.x(), np.y(), np.x(), np.y(), np.x(), np.y(), np.x(), np.y());
                                }
                        np = FPoint(cli.point(0));
                        b->PoLine.putPoints(b->PoLine.size(), 2, np.x(), np.y(), np.x(), np.y());
                        FPoint tp2 = GetMinClipF(b->PoLine);
                        if ((tp2.x() > -1) || (tp2.y() > -1))
                                {
                                SizeItem(b->Width - tp2.x(), b->Height - tp2.y(), b->ItemNr, false, false);
                                }
                        FPoint tp = GetMaxClipF(b->PoLine);
                        SizeItem(tp.x(), tp.y(), b->ItemNr, false, false);
                        b->Clip = FlattenPath(b->PoLine, b->Segments);
                        update();
                        }
                if (doku->AppMode == 8)
                        {
                        b = SelItem.at(0);
                        QPainter p;
                        p.begin(this);
                        Transform(b, &p);
                        QPoint np = p.xFormDev(m->pos());
                        p.end();
                        np = ApplyGrid(np);
                        b->Rot = xy2Deg(np.x(), np.y());
                        b->Width = sqrt(pow(np.x(),2)+pow(np.y(),2));
                        b->Height = 0;
                        b->Sizing = false;
                        UpdateClip(b);
                        update();
                        }
                if (GetItem(&b))
                        {
                        if (GroupSel)
                                {
                                if (mCG)
                                        {
                                        double gx, gy, gh, gw, mx, my, scx, scy;
                                        mx = Mxp;
                                        my = Myp;
                                        getGroupRect(&gx, &gy, &gw, &gh);
                                        scx = fabs(mx-gx) / gw;
                                        scy = fabs(my-gy) / gh;
                                        scaleGroup(scx, scy);
                                        }
                                }
                        else
                                {
                                if (b->Sizing)
                                        {
                                        FPoint npx;
                                        double nx = m->pos().x()/doku->Scale;
                                        double ny = m->pos().y()/doku->Scale;
                                        if (doku->SnapGuides)
                                                {
                                                ApplyGuides(&nx, &ny);
                                                npx = transformPointI(FPoint(nx, ny), b->Xpos, b->Ypos, b->Rot, 1, 1);
                                                }
                                        else
                                                {
                                                npx = ApplyGridF(transformPointI(FPoint(nx, ny), b->Xpos, b->Ypos, b->Rot, 1, 1));
                                                }
                                        if ((HowTo == 1) && (b->PType != 5) && (doku->SnapGuides))
                                                {
                                                SizeItem(npx.x(), npx.y(), b->ItemNr);
                                                }
                                        bool sav = doku->SnapGuides;
                                        doku->SnapGuides = false;
                                        switch (HowTo)
                                                {
                                                case 1:
                                                        if (b->PType != 5)
                                                                {
                                                                if (b->flippedH % 2 != 0)
                                                                        MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                                if (b->flippedV % 2 != 0)
                                                                        MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                                }
                                                        else
                                                                {
                                                                if (sav)
                                                                        {
                                                                        double nx = m->pos().x()/doku->Scale;
                                                                        double ny = m->pos().y()/doku->Scale;
                                                                        if (doku->useRaster)
                                                                                {
                                                                                FPoint ra = ApplyGridF(FPoint(nx, ny));
                                                                                nx = ra.x();
                                                                                ny = ra.y();
                                                                                }
                                                                        doku->SnapGuides = sav;
                                                                        ApplyGuides(&nx, &ny);
                                                                        doku->SnapGuides = false;
                                                                        double r = atan2(ny - b->Ypos, nx - b->Xpos)*(180.0/3.1415927);
                                                                        RotateItem(r, b->ItemNr);
                                                                        double w = sqrt(pow(nx - b->Xpos, 2) + pow(ny - b->Ypos,2));
                                                                        SizeItem(w, b->Height, b->ItemNr, true);
                                                                        }
                                                                }
                                                        b->Sizing = false;
                                                        break;
                                                case 2:
                                                        if (b->PType != 5)
                                                                {
                                                                MoveSizeItem(npx, npx, b->ItemNr);
                                                                b->Sizing = false;
                                                                if (b->flippedH % 2 == 0)
                                                                        MoveItemI((b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                                if (b->flippedV % 2 == 0)
                                                                        MoveItemI(0, (b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                                }
                                                        else
                                                                {
                                                                if (sav)
                                                                        {
                                                                        double nx = m->pos().x()/doku->Scale;
                                                                        double ny = m->pos().y()/doku->Scale;
                                                                        if (doku->useRaster)
                                                                                {
                                                                                FPoint ra = ApplyGridF(FPoint(nx, ny));
                                                                                nx = ra.x();
                                                                                ny = ra.y();
                                                                                }
                                                                        doku->SnapGuides = sav;
                                                                        ApplyGuides(&nx, &ny);
                                                                        doku->SnapGuides = false;
                                                                        QWMatrix ma;
                                                                        ma.translate(b->Xpos, b->Ypos);
                                                                        ma.rotate(b->Rot);
                                                                        double mx = ma.m11() * b->Width + ma.m21() * b->Height + ma.dx();
                                                                        double my = ma.m22() * b->Height + ma.m12() * b->Width + ma.dy();
                                                                        double r = atan2(my-ny,mx-nx)*(180.0/3.1415927);
                                                                        double w = sqrt(pow(mx-nx,2)+pow(my-ny,2));
                                                                        MoveItem(nx - b->Xpos, ny - b->Ypos, b, true);
                                                                        SizeItem(w, b->Height, b->ItemNr, true);
                                                                        RotateItem(r, b->ItemNr);
                                                                        b->Sizing = false;
                                                                        }
                                                                }
                                                        break;
                                                case 3:
                                                        MoveSizeItem(FPoint(0, npx.y()), FPoint(b->Width - npx.x(), npx.y()), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedH % 2 != 0)
                                                                MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                        if (b->flippedV % 2 == 0)
                                                                MoveItemI(0, (b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                        break;
                                                case 4:
                                                        MoveSizeItem(FPoint(npx.x(), 0), FPoint(npx.x(), b->Height - npx.y()), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedH % 2 == 0)
                                                                MoveItemI((b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                        if (b->flippedV % 2 != 0)
                                                                MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                        break;
                                                case 5:
                                                        MoveSizeItem(FPoint(0, 0), FPoint(0, b->Height - npx.y()), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedV % 2 != 0)
                                                                MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                        break;
                                                case 6:
                                                        MoveSizeItem(FPoint(0, 0), FPoint(b->Width - npx.x(), 0), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedH % 2 != 0)
                                                                MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                        break;
                                                case 7:
                                                        MoveSizeItem(FPoint(npx.x(), 0), FPoint(npx.x(), 0), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedH % 2 == 0)
                                                                MoveItemI((b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                        if (b->flippedV % 2 != 0)
                                                                MoveItemI(0, -(b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                        break;
                                                case 8:
                                                        MoveSizeItem(FPoint(0, npx.y()), FPoint(0, npx.y()), b->ItemNr);
                                                        b->Sizing = false;
                                                        if (b->flippedH % 2 != 0)
                                                                MoveItemI(-(b->Width - b->OldB2)/b->LocalScX, 0, b->ItemNr);
                                                        if (b->flippedV % 2 == 0)
                                                                MoveItemI(0, (b->Height - b->OldH2)/b->LocalScY, b->ItemNr);
                                                        break;
                                                }
                                        if ((b->PType == 4) && (m->state() & ShiftButton) && (m->state() & ControlButton))
                                                {
                                                double scx = b->Width / b->OldB2;
                                                double scy = b->Height / b->OldH2;
                                                if (scx != scy)
                                                        scx = scx / scy;
                                                else
                                                        scx = 1.0;
                                                if (b->Ptext.count() != 0)
                                                        {
                                                        b->ISize = QMAX(qRound(b->ISize * scy), 1);
                                                        b->LineSp = ((b->ISize / 10.0)* static_cast<double>(doku->AutoLine) / 100) + (b->ISize / 10.0);
                                                        b->TxtScale = QMIN(QMAX(qRound(b->TxtScale * scx), 25), 400);
                                                        doku->CurrTextScale = b->TxtScale;
                                                        doku->CurrFontSize = b->ISize;
                                                        emit ItemTextAttr(b->LineSp);
                                                        emit ItemTextSize(b->ISize);
                                                        emit ItemTextSca(b->TxtScale);
                                                        for (uint aa = 0; aa < b->Ptext.count(); ++aa)
                                                                {
                                                                b->Ptext.at(aa)->csize = QMAX(qRound(b->Ptext.at(aa)->csize*scy), 1);
                                                                b->Ptext.at(aa)->cscale = QMAX(QMIN(qRound(b->Ptext.at(aa)->cscale*scx), 400), 25);
                                                                }
                                                        }
                                                }
                                        if (b->PType == 2)
                                                {
                                                AdjustPictScale(b);
                                                AdjustPreview(b);
                                                }
                                        UpdateClip(b);
                                        doku->SnapGuides = sav;
                                        update();
                                        emit DocChanged();
                                        }
                                }
                        if (Imoved)
                                {
                                b = SelItem.at(0);
                                if (b->PType != 5)
                                        {
                                        if (fabs(b->Width) < 5)
                                                b->Width = 5;
                                        if (fabs(b->Height) < 5)
                                                b->Height = 5;
                                        }
                                Imoved = false;
                                MoveItem(0, 0, b, false);
                                update();
                                emit DocChanged();
                                }
                        }
                if ((SelItem.count() == 0) && (HaveSelRect) && (!MidButt))
                        {
                        double sc = doku->Scale;
                        QPainter p;
                        p.begin(this);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        p.drawRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                        p.end();
                if((Mxp*sc) > SeRx)
                        {
                double tmp=SeRx;
                SeRx=static_cast<int>(Mxp*sc);
                Mxp=static_cast<int>(tmp/sc);
                        }
                if((Myp*sc) > SeRy)
                        {
                double tmp=SeRy;
                SeRy=static_cast<int>(Myp*sc);
                Myp=static_cast<int>(tmp/sc);
                        }
                        QRect Sele = QRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                        if (Items.count() != 0)
                                {
                                for (uint a = 0; a < Items.count(); ++a)
                                        {
                                        p.begin(this);
                                        Transform(Items.at(a), &p);
                                        QRegion apr = QRegion(p.xForm(Items.at(a)->Clip));
                                        p.end();
                                        if ((Sele.contains(apr.boundingRect())) && (Items.at(a)->LayerNr == doku->ActiveLayer))
                                                SelectItemNr(a);
                                        }
                                }
                        HaveSelRect = false;
                        }
                if (doku->AppMode != 7)
                        {
                        doku->AppMode = 1;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        emit PaintingDone();
                        }
                if (GetItem(&b))
                        {
                        if (doku->ActPage->SelItem.count() > 1)
                                {
                                setGroupRect();
                                paintGroupRect();
                                double x, y, w, h;
                                getGroupRect(&x, &y, &w, &h);
                                emit ItemPos(x, y);
                                emit ItemGeom(w, h);
                                }
                        else
                                EmitValues(b);
                        }
                }
        if (doku->AppMode == 6)
                {
                if (HaveSelRect)
                        {
                        double sc = doku->Scale;
                if((Mxp*sc) > SeRx)
                        {
                double tmp=SeRx;
                SeRx=static_cast<int>(Mxp*sc);
                Mxp=static_cast<int>(tmp/sc);
                        }
                if((Myp*sc) > SeRy)
                        {
                double tmp=SeRy;
                SeRy=static_cast<int>(Myp*sc);
                Myp=static_cast<int>(tmp/sc);
                        }
                        double yf = height() / (SeRy/sc-Myp);
                        double xf = width() / (SeRx/sc-Mxp);
                        doku->Scale = QMIN(yf, xf);
                        emit ZoomAbs();
                        emit AbsPosi(Mxp, Myp);
                        HaveSelRect = false;
                        doku->AppMode = 1;
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                        emit PaintingDone();
                        }
                else
                        {
                        if (Magnify)
                                emit ZoomIn();
                        else
                                emit ZoomOut();
                        if (SelItem.count() == 0)
                                emit AbsPosi2(Mxp, Myp);
                        HaveSelRect = false;
                        }
                }
        if ((doku->AppMode == 7) && !HanMove)
                {
                b = SelItem.at(0);
                uint a;
                if (b->PType == 4)
                        {
                        if (oldCp == b->CPos)
                                {
                                for (a = 0; a < b->Ptext.count(); ++a)
                                        {
                                        b->Ptext.at(a)->cselect = false;
                                        }
                                b->HasSel = false;
                                emit HasNoTextSel();
                                b->Dirty = true;
                                RefreshItem(b);
                                }
                        }
                }
        if ((doku->AppMode == 13) && (m->button() == LeftButton))
                {
                b = SelItem.at(0);
                QPainter p;
                QPointArray Bez(4);
                p.begin(this);
                Transform(b, &p);
                FPoint npf = FPoint(p.xFormDev(m->pos()));
                npf = ApplyGridF(npf);
                b->PoLine.addPoint(npf);
                if ((b->PoLine.size() % 4 == 0) && (b->PoLine.size() > 3))
                        {
                        FPoint lxy = b->PoLine.point(b->PoLine.size()-2);
                        FPoint lk = b->PoLine.point(b->PoLine.size()-1);
                        double dx = lxy.x() - lk.x();
                        double dy = lxy.y() - lk.y();
                        lk.setX(lk.x() + dx*2);
                        lk.setY(lk.y() + dy*2);
                        b->PoLine.addPoint(lxy);
                        b->PoLine.addPoint(lk);
                        }
                FPoint np2 = GetMinClipF(b->PoLine);
                if (np2.x() < 0)
                        {
                        b->PoLine.translate(-np2.x(), 0);
                        MoveItem(np2.x(), 0, b);
                        }
                if (np2.y() < 0)
                        {
                        b->PoLine.translate(0, -np2.y());
                        MoveItem(0, np2.y(), b);
                        }
                SizeItem(b->PoLine.WidthHeight().x(), b->PoLine.WidthHeight().y(), b->ItemNr, false, false);
                SetPolyClip(b, qRound(QMAX(b->Pwidth / 2, 1)), qRound(QMAX(b->Pwidth / 2, 1)));
                AdjustItemSize(b);
                RefreshItem(b);
                p.end();
                }
        if ((doku->AppMode == 13) && (m->button() == RightButton))
                {
                b = SelItem.at(0);
                b->PoLine.resize(b->PoLine.size()-2);
                SizeItem(b->PoLine.WidthHeight().x(), b->PoLine.WidthHeight().y(), b->ItemNr, false, false);
                SetPolyClip(b, qRound(QMAX(b->Pwidth / 2, 1)), qRound(QMAX(b->Pwidth / 2, 1)));
                AdjustItemSize(b);
                doku->AppMode = 1;
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                emit PaintingDone();
                emit DocChanged();
                FirstPoly = true;
                update();
                }
        doku->DragP = false;
        Imoved = false;
        mCG = false;
        MidButt = false;
        doku->SubMode = -1;
}

void Page::SetYGuide(QMouseEvent *m)
{
        QPoint py = mapFromGlobal(m->globalPos());
        double newY = py.y() / doku->Scale;
        if ((newY > 0) && (newY < doku->PageH) && (doku->Guides))
                {
                YGuides.append(newY);
                qHeapSort(YGuides);
                update();
                emit DocChanged();
                }
}

void Page::SetXGuide(QMouseEvent *m)
{
        QPoint py = mapFromGlobal(m->globalPos());
        double newY = py.x() / doku->Scale;
        if ((newY > 0) && (newY < doku->PageB) && (doku->Guides))
                {
                XGuides.append(newY);
                qHeapSort(XGuides);
                update();
                emit DocChanged();
                }
}

void Page::FromHRuler(QMouseEvent *m)
{
        double sc = doku->Scale;
        int newY;
        if (doku->Guides)
                {
                QPoint py = mapFromGlobal(m->globalPos());
                newY = py.y();
                emit MousePos(py.x()/sc, py.y()/sc);
                emit Hrule(py.x()+Anz->childX(parentWidget()));
                emit Vrule(py.y()+Anz->childY(parentWidget()));
                QPainter p;
                p.begin(this);
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, SolidLine, FlatCap, MiterJoin));
                p.drawLine(0, DrHY, static_cast<int>(doku->PageB * sc), DrHY);
                p.drawLine(0, newY, static_cast<int>(doku->PageB * sc), newY);
                p.end();
                DrHY = newY;
                }
}

void Page::FromVRuler(QMouseEvent *m)
{
        double sc = doku->Scale;
        int newY;
        if (doku->Guides)
                {
                QPoint py = mapFromGlobal(m->globalPos());
                newY = py.x();
                emit MousePos(py.x()/sc, py.y()/sc);
                emit Hrule(py.x()+Anz->childX(parentWidget()));
                emit Vrule(py.y()+Anz->childY(parentWidget()));
                QPainter p;
                p.begin(this);
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, SolidLine, FlatCap, MiterJoin));
                p.drawLine(DrVX, 0, DrVX, static_cast<int>(doku->PageH * sc));
                p.drawLine(newY, 0, newY, static_cast<int>(doku->PageH * sc));
                p.end();
                DrVX = newY;
        }
}

void Page::mouseMoveEvent(QMouseEvent *m)
{
        int newX, newY, c;
        double nx, ny, dx, dy;
        uint a;
        PageItem *b;
        QPoint np, np2, mop;
        FPoint npf, npf2;
        QPainter p;
        QRect tx;
        QPointArray Bez(4);
        bool erf = false;
        double sc = doku->Scale;
        emit MousePos(m->x()/sc, m->y()/sc);
        emit Hrule(m->x()+Anz->childX(parentWidget()));
        emit Vrule(m->y()+Anz->childY(parentWidget()));
        if (doku->Guides)
                {
                if (MoveGY)
                        {
                        FromHRuler(m);
                        if (((m->y()/sc) < 0) || ((m->y()/sc) > doku->PageH))
                                qApp->setOverrideCursor(QCursor(loadIcon("DelPoint.png")), true);
                        else
                                qApp->setOverrideCursor(QCursor(SplitHCursor), true);
                        return;
                        }
                if (MoveGX)
                        {
                        FromVRuler(m);
                        if (((m->x()/sc) < 0) || ((m->x()/sc) > doku->PageB))
                                qApp->setOverrideCursor(QCursor(loadIcon("DelPoint.png")), true);
                        else
                                qApp->setOverrideCursor(QCursor(SplitVCursor), true);
                        return;
                        }
                }
        if ((!doku->DragP) && (Mpressed) && (SelItem.count() != 0))
                {
                int cx = Anz->contentsX() - Anz->childX(doku->ActPage->parentWidget());
                int cy = Anz->contentsY() - Anz->childY(doku->ActPage->parentWidget());
                int cw = Anz->visibleWidth();
                int ch = Anz->visibleHeight();
                if (m->y() < cy)
                        Anz->scrollBy(0, m->y() - cy);
                if ((ch - (m->y() - cy)) < 0)
                        Anz->scrollBy(0, m->y() - cy - ch);
                if (m->x() < cx)
                        Anz->scrollBy(m->x() - cx, 0);
                if ((cw - (m->x() - cx)) < 0)
                        Anz->scrollBy(m->x() - cx - cw, 0);
                }
        if (GetItem(&b))
                {
                newX = static_cast<int>(m->x()/sc);
                newY = static_cast<int>(m->y()/sc);
                if ((Mpressed) && (m->state() == RightButton) && (!doku->DragP) && (doku->AppMode == 1) && (!b->Locked))
                        {
                        if ((abs(Dxp - newX) > 3) || (abs(Dyp - newY) > 3))
                                {
                                doku->DragP = 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;
                                doku->DragP = false;
                                Mpressed = false;
                                doku->DraggedElem = 0;
                                doku->DragElements.clear();
                                }
                        return;
                        }
                if (doku->DragP)
                        return;
                if (Mpressed && (doku->AppMode == 9))
                        {
                        double newW = xy2Deg(newX - qRound(RCenter.x()), newY - qRound(RCenter.y()));
                        RotateItem(b->Rot - (oldW - newW), b->ItemNr);
                        oldW = newW;
//                      emit DocChanged();
                        }
                if (doku->AppMode == 13)
                        {
                        p.begin(this);
                        Transform(b, &p);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        if (doku->useRaster)
                                {
                                newX = static_cast<int>(qRound(newX / doku->minorGrid) * doku->minorGrid);
                                newY = static_cast<int>(qRound(newY / doku->minorGrid) * doku->minorGrid);
                                }
                        if (!Mpressed)
                                {
                                BezierPoints(&Bez, b->PoLine.pointQ(b->PoLine.size()-2), b->PoLine.pointQ(b->PoLine.size()-1),
                                                                                                         p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc))), p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc))));
                                p.drawCubicBezier(Bez);
                                Bez.setPoint(2, p.xFormDev(QPoint(static_cast<int>(newX*sc), static_cast<int>(newY*sc))));
                                Bez.setPoint(3, p.xFormDev(QPoint(static_cast<int>(newX*sc), static_cast<int>(newY*sc))));
                                p.drawCubicBezier(Bez);
                                }
                        else
                                {
                                if (b->PoLine.size() > 2)
                                        {
                                        BezierPoints(&Bez, b->PoLine.pointQ(b->PoLine.size()-3), b->PoLine.pointQ(b->PoLine.size()-2),
                                                                                                                 p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc))), b->PoLine.pointQ(b->PoLine.size()-1));
                                        p.drawCubicBezier(Bez);
                                        Bez.setPoint(2, p.xFormDev(QPoint(static_cast<int>(newX*sc), static_cast<int>(newY*sc))));
                                        Bez.setPoint(3, b->PoLine.pointQ(b->PoLine.size()-1));
                                        p.drawCubicBezier(Bez);
                                        }
                                p.drawLine(b->PoLine.pointQ(b->PoLine.size()-1), p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc))));
                                p.drawLine(b->PoLine.pointQ(b->PoLine.size()-1), p.xFormDev(QPoint(static_cast<int>(newX*sc), static_cast<int>(newY*sc))));
                                }
                        p.end();
                        Mxp = newX;
                        Myp = newY;
                        }
                if (Mpressed && (doku->AppMode == 12))
                        {
                        p.begin(this);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        if (m->state() & ShiftButton)
                                {
                                mop = QPoint(m->x(), static_cast<int>((b->Ypos + (newX - b->Xpos)) * sc));
                                QCursor::setPos(mapToGlobal(mop));
                                newY = static_cast<int>(mop.y()/sc);
                                }
                        if (doku->useRaster)
                                {
                                newX = static_cast<int>(qRound(newX / doku->minorGrid) * doku->minorGrid);
                                newY = static_cast<int>(qRound(newY / doku->minorGrid) * doku->minorGrid);
                                }
                        p.drawRect(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(Mxp*sc-b->Xpos*sc), static_cast<int>(Myp*sc-b->Ypos*sc));
                        p.drawRect(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(newX*sc-b->Xpos*sc), static_cast<int>(newY*sc-b->Ypos*sc));
                        p.end();
                        emit ItemGeom(newX - b->Xpos, newY - b->Ypos);
                        Mxp = newX;
                        Myp = newY;
                        }
                if (Mpressed && (doku->AppMode == 8))
                        {
                        p.begin(this);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        if (doku->useRaster)
                                {
                                newX = static_cast<int>(qRound(newX / doku->minorGrid) * doku->minorGrid);
                                newY = static_cast<int>(qRound(newY / doku->minorGrid) * doku->minorGrid);
                                }
                        p.drawLine(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc));
                        p.drawLine(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(newX*sc), static_cast<int>(newY*sc));
                        p.end();
                        emit SetAngle(xy2Deg(newX - b->Xpos, newY - b->Ypos));
                        emit ItemGeom(sqrt(pow(newX - b->Xpos,2)+pow(newY - b->Ypos,2)), 0);
                        Mxp = newX;
                        Myp = newY;
                        }
                if (Mpressed && (doku->AppMode == 7) && (!HanMove))
                        {
                        if (b->PType == 2)
                                {
                                MoveItemI((newX-Mxp)/b->LocalScX, (newY-Myp)/b->LocalScY, b->ItemNr);
                                Mxp = newX;
                                Myp = newY;
                                }
                        if (b->PType == 4)
                                {
                                for (a = 0; a < b->Ptext.count(); ++a)
                                        {
                                        b->Ptext.at(a)->cselect = false;
                                        }
                                b->HasSel = false;
                                slotSetCurs(m->x(), m->y());
                                if (b->CPos < oldCp)
                                        {
                                        for (c = b->CPos; c < oldCp; ++c)
                                                {
                                                b->Ptext.at(c)->cselect = true;
                                                b->HasSel = true;
                                                }
                                        }
                                if (b->CPos > oldCp)
                                        {
                                        for (c = oldCp; c < b->CPos; ++c)
                                                {
                                                b->Ptext.at(c)->cselect = true;
                                                b->HasSel = true;
                                                }
                                        }
                                RefreshItem(b);
                                if (b->HasSel)
                                        emit HasTextSel();
                                else
                                        emit HasNoTextSel();
                                }
                        }
                if (Mpressed && ((doku->AppMode == 1) || ((doku->AppMode == 7) && HanMove)))
                        {
                        if (doku->EditClip)
                                {
                                if ((Mpressed) && (ClRe == -1) && (SegP1 == -1) && (SegP2 == -1))
                                        {
                                        newX = m->x();
                                        newY = m->y();
                                        p.begin(this);
                                        p.setRasterOp(XorROP);
                                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                                        p.drawRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                                        p.drawRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(newX-(Mxp*sc)), static_cast<int>(newY-(Myp*sc)));
                                        p.end();
                                        SeRx = newX;
                                        SeRy = newY;
                                        HaveSelRect = true;
                                        return;
                                        }
                                Imoved = true;
                                b = SelItem.at(0);
                                b->OldB2 = b->Width;
                                b->OldH2 = b->Height;
                                p.begin(this);
                                Transform(b, &p);
                                npf = FPoint(p.xFormDev(m->pos()));
                                p.end();
                                if ((SegP1 != -1) && (SegP2 != -1))
                                        {
                                        FPointArray Clip;
                                        Clip = b->PoLine;
                                        npf.setX(Clip.point(SegP2).x() + (newX-Mxp));
                                        npf.setY(Clip.point(SegP2).y() + (newY-Myp));
                                        ClRe = SegP2;
                                        MoveClipPoint(b, npf);
                                        b->OldB2 = b->Width;
                                        b->OldH2 = b->Height;
                                        Clip = b->PoLine;
                                        ClRe = SegP1;
                                        npf2.setX(Clip.point(SegP1).x() + (newX-Mxp));
                                        npf2.setY(Clip.point(SegP1).y() + (newY-Myp));
                                        MoveClipPoint(b, npf2);
                                        Mxp = newX;
                                        Myp = newY;
                                        }
                                else
                                        {
                                        if ((SelNode.count() != 0) && (EdPoints))
                                                {
                                                int storedClRe = ClRe;
                                                for (uint itm = 0; itm < SelNode.count(); ++itm)
                                                        {
                                                        npf.setX(b->PoLine.point(*SelNode.at(itm)).x() + (newX-Mxp));
                                                        npf.setY(b->PoLine.point(*SelNode.at(itm)).y() + (newY-Myp));
                                                        ClRe = *SelNode.at(itm);
                                                        b->OldB2 = b->Width;
                                                        b->OldH2 = b->Height;
                                                        MoveClipPoint(b, npf);
                                                        }
                                                b->OldB2 = b->Width;
                                                b->OldH2 = b->Height;
                                                ClRe = storedClRe;
                                                Mxp = newX;
                                                Myp = newY;
                                                }
                                        else
                                                MoveClipPoint(b, npf);
                                        }
                                return;
                                }
                        if (mCG)
                                {
                                Imoved = false;
                                if (GroupSel)
                                        {
                                        double gx, gy, gh, gw;
                                        getGroupRect(&gx, &gy, &gw, &gh);
                                        p.begin(this);
                                        switch (HowTo)
                                                {
                                                case 1:
                                                        np = QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc));
                                                        np2 = QPoint(m->x(), static_cast<int>((gy+(gh * ((newX-gx) / gw)))*sc));
                                                        QCursor::setPos(mapToGlobal(np2));
/*                                                      if (m->state() & ShiftButton)
                                                                {
                                                                np2 = QPoint(m->x(), int((gy+(gh * ((newX-gx) / gw)))*sc));
                                                                QCursor::setPos(mapToGlobal(np2));
                                                                }
                                                        else
                                                                np2 = QPoint(m->x(), m->y());    */

                                                        Mxp = static_cast<int>(np2.x()/sc);
                                                        Myp = static_cast<int>(np2.y()/sc);
                                                        PaintSizeRect(&p, QRect(QPoint(static_cast<int>(gx*sc), static_cast<int>(gy*sc)), np), QRect(QPoint(static_cast<int>(gx*sc), static_cast<int>(gy*sc)), np2));
                                                        break;
                                                }
                                        p.end();
                                        }
                                else
                                        {
                                        for (a = 0; a < SelItem.count(); ++a)
                                                {
                                                b = SelItem.at(0);
                                                switch (HowTo)
                                                        {
                                                        case 0:
                                                                break;
                                                        case 1:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                if ((m->state() & ShiftButton) && (!(m->state() & ControlButton)))
                                                                        {
                                                                        mop = QPoint(m->x(), static_cast<int>((b->Ypos + (newX - b->Xpos)) * sc));
                                                                        QCursor::setPos(mapToGlobal(mop));
                                                                        }
                                                                else
                                                                        {
                                                                        if ((m->state() & ControlButton) && (!(m->state() & ShiftButton)))
                                                                                {
                                                                                mop = QPoint(m->x(), static_cast<int>((b->Ypos + ((newX - b->Xpos) / b->OldB2 * b->OldH2)) * sc));
                                                                                QCursor::setPos(mapToGlobal(mop));
                                                                                }
                                                                        else
                                                                                mop = QPoint(m->x(), m->y());
                                                                        }
                                                                np = p.xFormDev(mop);
                                                                nx = np.x();
                                                                ny = np.y();
                                                                p.end();
                                                                if (b->PType != 5)
                                                                        {
                                                                        if (doku->useRaster)
                                                                                {
                                                                                dx = b->Xpos - int (b->Xpos / doku->minorGrid) * doku->minorGrid;
                                                                                dy = b->Ypos - int (b->Ypos / doku->minorGrid) * doku->minorGrid;
                                                                                nx = (qRound(np.x() / doku->minorGrid) * doku->minorGrid - dx);
                                                                                ny = (qRound(np.y() / doku->minorGrid) * doku->minorGrid - dy);
                                                                                }
                                                                        erf = SizeItem(nx, ny, b->ItemNr);
                                                                        }
                                                                else
                                                                        {
                                                                        p.begin(this);
                                                                        double rba = b->Rot;
                                                                        b->Rot = 0;
                                                                        Transform(b, &p);
                                                                        np = p.xFormDev(QPoint(m->x(), m->y()));
                                                                        p.end();
                                                                        b->Rot = rba;
                                                                        np = ApplyGrid(np);
                                                                        erf = SizeItem(np.x(), np.y(), b->ItemNr);
                                                                        if (doku->SnapGuides)
                                                                                {
                                                                                p.begin(this);
                                                                                b->Sizing = true;
                                                                                p.setRasterOp(XorROP);
                                                                                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                                                                                p.drawLine(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc));
                                                                                p.drawLine(static_cast<int>(b->Xpos*sc), static_cast<int>(b->Ypos*sc), static_cast<int>(newX*sc), static_cast<int>(newY*sc));
                                                                                p.end();
                                                                                }
                                                                        }
                                                                break;
                                                        case 2:
                                                                if (b->PType == 5)
                                                                        {
                                                                        p.begin(this);
                                                                        Transform(b, &p);
                                                                        mop = QPoint(m->x(), m->y());
                                                                        npf = p.xFormDev(mop);
                                                                        nx = np.x();
                                                                        ny = np.y();
                                                                        p.end();
                                                                        double sav = doku->SnapGuides;
                                                                        npf2 = FPoint(nx-Mxp, ny-Myp);
                                                                        erf = MoveSizeItem(npf, npf, b->ItemNr);
                                                                        doku->SnapGuides = sav;
                                                                        if (sav)
                                                                                b->Sizing = true;
                                                                        }
                                                                else
                                                                        {
                                                                        p.begin(this);
                                                                        Transform(b, &p);
                                                                        np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                        np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                        PaintSizeRect(&p, QRect(np, QPoint(static_cast<int>(b->Width), static_cast<int>(b->Height))), QRect(np2, QPoint(static_cast<int>(b->Width), static_cast<int>(b->Height))));
                                                                        p.end();
                                                                        }
                                                                break;
                                                        case 3:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(np, QPoint(0, static_cast<int>(b->Height))), QRect(np2, QPoint(0, static_cast<int>(b->Height))));
                                                                p.end();
                                                                break;
                                                        case 4:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(np, QPoint(static_cast<int>(b->Width), 0)), QRect(np2, QPoint(static_cast<int>(b->Width), 0)));
                                                                p.end();
                                                                break;
                                                        case 5:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(QPoint(static_cast<int>(b->Width), np.y()), QPoint(0, 0)), QRect(QPoint(static_cast<int>(b->Width), np2.y()), QPoint(0, 0)));
                                                                p.end();
                                                                break;
                                                        case 6:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(QPoint(np.x(), static_cast<int>(b->Height)), QPoint(0, 0)), QRect(QPoint(np2.x(), static_cast<int>(b->Height)), QPoint(0, 0)));
                                                                p.end();
                                                                break;
                                                        case 7:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(QPoint(np.x(), static_cast<int>(b->Height)), QPoint(static_cast<int>(b->Width), 0)), QRect(QPoint(np2.x(), static_cast<int>(b->Height)), QPoint(static_cast<int>(b->Width), 0)));
                                                                p.end();
                                                                break;
                                                        case 8:
                                                                p.begin(this);
                                                                Transform(b, &p);
                                                                np = p.xFormDev(QPoint(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc)));
                                                                np2 = ApplyGrid(p.xFormDev(QPoint(m->x(), m->y())));
                                                                PaintSizeRect(&p, QRect(QPoint(static_cast<int>(b->Width),np.y()), QPoint(0, static_cast<int>(b->Height))), QRect(QPoint(static_cast<int>(b->Width),np2.y()), QPoint(0, static_cast<int>(b->Height))));
                                                                p.end();
                                                                break;
                                                        }
                                                }
                                        }
                                if ((erf) || (HowTo > 1))
                                        {
                                        Mxp