Subversion Repositories Scribus

Rev

Rev 404 | 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 "scribus.h"
#include "insertTable.h"
#include "mpalette.h"

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

#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>
#include <qbuttongroup.h>
#include <qlayout.h>
#include <qevent.h>
#include <qeventloop.h>
#include <qprocess.h>
#include <qscrollbar.h>
#include <qmessagebox.h>
#include <unistd.h>
#if QT_VERSION  > 0x030102
        #define SPLITVC SplitHCursor
        #define SPLITHC SplitVCursor
#else
        #define SPLITVC SplitVCursor
        #define SPLITHC SplitHCursor
#endif

#include <unistd.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 double UmReFaktor;
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);
extern void WordAndPara(PageItem* b, int *w, int *p, int *c, int *wN, int *pN, int *cN);
extern ScribusApp* ScApp;
extern int callGS(const QStringList & args);

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;
        doku->leaveDrag = 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;
        CursVis = false;
        EditContour = 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();
                ScApp->newActWin(doku->WinHan);
                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;
        e->accept(QTextDrag::canDecode(e));
        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(4))
                                                        hg->ch = QChar(9);
                                                if (hg->ch == QChar(5))
                                                        hg->ch = QChar(13);
                                                hg->cfont = b->IFont;
                                                hg->csize = b->ISize;
                                                hg->ccolor = b->TxtFill;
                                                hg->cshade = b->ShTxtFill;
                                                hg->cstroke = b->TxtStroke;
                                                hg->cshade2 = b->ShTxtStroke;
                                                hg->cselect = false;
                                                hg->cscale = b->TxtScale;
                                                hg->cextra = 0;
                                                hg->cstyle = 0;
                                                hg->cab = 0;
                                                hg->xp = 0;
                                                hg->yp = 0;
                                                hg->PRot = 0;
                                                hg->PtransX = 0;
                                                hg->PtransY = 0;
                                                b->Ptext.insert(b->CPos, hg);
                                                b->CPos += 1;
                                        }
                                        emit DocChanged();
                                        update();
                                }
                        }
                }
                else
                {
                        uint ac = Items.count();
                        if ((!img) && (doku->DraggedElem == 0))
                                emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
                        else
                        {
                                if (doku->DraggedElem != 0)
                                {
                                        if (!doku->leaveDrag)
                                        {
                                                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;
                                        }
                                        else
                                                re = 1;
                                        if ((re == 2) || (re == -1))
                                        {
                                                update();
                                                return;
                                        }
                                        if ((re == 1) || (doku->leaveDrag))
                                        {
                                                QPtrList<PageItem> pasted;
                                                emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
                                                for (uint as = ac; as < doku->ActPage->Items.count(); ++as)
                                                {
                                                        pasted.append(Items.at(as));
                                                }
                                                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]));
                                                }
                                                PageItem* bb;
                                                int fin;
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
                                                {
                                                        bb = pasted.at(dre);
                                                        b = doku->DraggedElem->OwnPage->SelItem.at(dre);
                                                        if ((b->PType == 4) && ((b->NextBox != 0) || (b->BackBox != 0)))
                                                        {
                                                                if (b->BackBox != 0)
                                                                {
                                                                        bb->BackBox = b->BackBox;
                                                                        fin = doku->DraggedElem->OwnPage->SelItem.find(b->BackBox);
                                                                        if (fin != -1)
                                                                                bb->BackBox = pasted.at(fin);
                                                                        bb->BackBox->NextBox = bb;
                                                                }
                                                                if (b->NextBox != 0)
                                                                {
                                                                        bb->NextBox = b->NextBox;
                                                                        fin = doku->DraggedElem->OwnPage->SelItem.find(b->NextBox);
                                                                        if (fin != -1)
                                                                                bb->NextBox = pasted.at(fin);
                                                                        bb->NextBox->BackBox = bb;
                                                                }
                                                        }
                                                }
                                                for (uint dre=0; dre<doku->DragElements.count(); ++dre)
                                                {
                                                        b = doku->DraggedElem->OwnPage->SelItem.at(dre);
                                                        b->NextBox = 0;
                                                        b->BackBox = 0;
                                                }
                                                pasted.clear();
                                                doku->DraggedElem->OwnPage->DeleteItem();
                                        }
                                }
                                if ((!img) && ((re == 0)))
                                        emit LoadElem(QString(text), qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), false, false, doku);
                                doku->DraggedElem = 0;
                                doku->DragElements.clear();
                                doku->ActPage->SelItem.clear();
                                for (uint as = ac; as < doku->ActPage->Items.count(); ++as)
                                {
                                        doku->ActPage->SelectItemNr(as);
                                }
                                update();
                        }
                }
        }
}
void Page::leaveEvent(QEvent *)
{
        if (BlockLeave)
                return;
        if (!Mpressed)
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
        else
        {
                if ((SelItem.count() != 0) && (Mpressed) && (!doku->DragP) && (doku->AppMode == 1))
                {
                        PageItem *b = SelItem.at(0);
                        if ((b->Locked) || (b->Sizing))
                                return;
                        doku->DragP = true;
                        doku->leaveDrag = true;
                        doku->DraggedElem = b;
                        doku->DragElements.clear();
                        for (uint dre=0; dre<SelItem.count(); ++dre)
                                doku->DragElements.append(SelItem.at(dre)->ItemNr);
                        ScriXmlDoc *ss = new ScriXmlDoc();
                        QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
                        dr->setPixmap(loadIcon("DragPix.xpm"));
                        dr->drag();
                        delete ss;
                        doku->DragP = false;
                        doku->leaveDrag = false;
                        Mpressed = false;
                        doku->DraggedElem = 0;
                        doku->DragElements.clear();
                }
        }
}

void Page::paintEvent(QPaintEvent *e)
{
        if (doku->loading)
                return;
        QRect vr = ViewReg().boundingRect().intersect(e->rect());
        if ((vr.width() < 1) || (vr.height() < 1))
                return;
        if (doku->AppMode == 7)
                slotDoCurs(false);
        bool sp = e->spontaneous();
        QPixmap pgPix(vr.width(), vr.height());
        ScPainter *painter = new ScPainter(&pgPix, pgPix.width(), pgPix.height());
        painter->clear(doku->papColor);
        painter->translate(0.5, 0.5);
        if (doku->Before)
                DrawPageMarks(painter, vr);
//      QTime tim;
//      tim.start();
        DrawPageItems(painter, vr, sp);
//      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;
        if (doku->AppMode == 7)
                slotDoCurs(true);
}

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 (ScApp->Prefs.MarginsShown)
        {
                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 (ScApp->Prefs.BaseShown)
        {
                p->setPen(doku->baseColor, lw, SolidLine, FlatCap, MiterJoin);
                for (double yg = doku->BaseOffs; yg < doku->PageH; yg += doku->BaseGrid)
                        p->drawLine(FPoint(0, yg), FPoint(doku->PageB, yg));
        }
        if (ScApp->Prefs.GridShown)
        {
                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;
                        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;
                        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 (ScApp->Prefs.GuidesShown)
        {
                if (XGuides.count() != 0)
                {
                        p->setPen(doku->guideColor, lw, DotLine, 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, DotLine, 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, bool sp)
{
        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;
                                                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->Parent = Opa;
                                                b->OwnPage = Opa2;
                                        }
                                        for (a = 0; a < Mp->Items.count(); ++a)
                                        {
                                                b = Mp->Items.at(a);
                                                if (b->LayerNr != ll.LNr)
                                                        continue;
                                                if (!b->isTableItem)
                                                        continue;
                                                Opa = b->Parent;
                                                Opa2 = b->OwnPage;
                                                b->Parent = this;
                                                b->OwnPage = this;
                                                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())))
                                                {
                                                        painter->setZoomFactor(doku->Scale);
                                                        painter->save();
                                                        painter->translate(-rd.x(), -rd.y());
                                                        painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
                                                        painter->rotate(b->Rot);
                                                        if (b->Pcolor2 != "None")
                                                        {
                                                                QColor tmp;
                                                                b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
                                                                if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
                                                                {
                                                                        painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
                                                                        if (b->TopLine)
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
                                                                        if (b->RightLine)
                                                                                painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
                                                                        if (b->BottomLine)
                                                                                painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
                                                                        if (b->LeftLine)
                                                                                painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
                                                                }
                                                        }
                                                        painter->restore();
                                                }
                                                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())))
                                        {
//                                              if ((sp) && (b->Ptext.count() >= b->MaxChars))
//                                                      b->Dirty = true;
                                                if (!((doku->EditClip) && (Mpressed)))
                                                        b->DrawObj(painter, rd);
                                                b->Redrawn = true;
                                                if ((doku->AppMode == 7) && (b->Select) && (b->PType == 4))
                                                {
                                                        vi->HR->ItemPos = b->Xpos;
                                                        vi->HR->ItemEndPos = b->Xpos+b->Width;
                                                        if (b->Pcolor2 != "None")
                                                                vi->HR->lineCorr = b->Pwidth / 2.0;
                                                        else
                                                                vi->HR->lineCorr = 0;
                                                        vi->HR->ColGap = b->ColGap;
                                                        vi->HR->Cols = b->Cols;
                                                        vi->HR->Extra = b->Extra;
                                                        vi->HR->RExtra = b->RExtra;
                                                        vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
                                                        vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
                                                        if ((b->flippedH % 2 != 0) || (b->Reverse))
                                                                vi->HR->Revers = true;
                                                        else
                                                                vi->HR->Revers = false;
                                                        vi->HR->ItemPosValid = true;
                                                        vi->HR->repX = false;
                                                        if (doku->CurrentABStil < 5)
                                                                vi->HR->TabValues = b->TabValues;
                                                        else
                                                                vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
                                                        vi->HR->repaint();
                                                }
                                        }
                                }
                                for (a = 0; a < Items.count(); ++a)
                                {
                                        b = Items.at(a);
                                        if (b->LayerNr != ll.LNr)
                                                continue;
                                        if (!b->isTableItem)
                                                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())))
                                        {
                                                painter->setZoomFactor(doku->Scale);
                                                painter->save();
                                                painter->translate(-rd.x(), -rd.y());
                                                painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
                                                painter->rotate(b->Rot);
                                                if (b->Pcolor2 != "None")
                                                {
                                                        QColor tmp;
                                                        b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
                                                        if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
                                                        {
                                                                painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
                                                                if (b->TopLine)
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
                                                                if (b->RightLine)
                                                                        painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
                                                                if (b->BottomLine)
                                                                        painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
                                                                if (b->LeftLine)
                                                                        painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
                                                        }
                                                }
                                                painter->restore();
                                        }
                                }
                        }
                        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)
                {
                        FPointArray pb;
                        FPoint p1;
                        pb.resize(0);
                        pb.addPoint(FPoint(b->Xpos, b->Ypos));
                        p1 = transformPoint(FPoint(b->Width, 0.0), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
                        pb.addPoint(p1);
                        p1 = transformPoint(FPoint(b->Width, b->Height), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
                        pb.addPoint(p1);
                        p1 = transformPoint(FPoint(0.0, b->Height), b->Xpos, b->Ypos, b->Rot, 1.0, 1.0);
                        pb.addPoint(p1);
                        for (uint pc = 0; pc < 4; ++pc)
                        {
                                minx = QMIN(minx, pb.point(pc).x());
                                miny = QMIN(miny, pb.point(pc).y());
                                maxx = QMAX(maxx, pb.point(pc).x());
                                maxy = QMAX(maxy, pb.point(pc).y());
                        }
                }
                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;
        QPainter p;
        double gx, gy, gw, gh;
        if (GroupSel)
        {
                p.begin(this);
                getGroupRectScreen(&gx, &gy, &gw, &gh);
                PaintSizeRect(&p, QRect(qRound(gx), qRound(gy), qRound(gw), qRound(gh)));
                p.end();
        }
        for (uint a = 0; a < SelItem.count(); ++a)
        {
                b = SelItem.at(a);
                if (!fromMP)
                {
                        p.begin(this);
                        Transform(b, &p);
                        p.setRasterOp(XorROP);
                        p.setBrush(NoBrush);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        if ((b->PType != 5) && (b->FrameType != 0) || (b->PType == 7))
                                b->DrawPolyL(&p, b->Clip);
                        else
                                p.drawRect(0, 0, static_cast<int>(b->Width)+1, static_cast<int>(b->Height)+1);
                        p.end();
                }
                MoveItem(x, y, b, fromMP);
                if (!fromMP)
                {
                        p.begin(this);
                        Transform(b, &p);
                        p.setRasterOp(XorROP);
                        p.setBrush(NoBrush);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        if ((b->PType != 5) && (b->FrameType != 0) || (b->PType == 7))
                                b->DrawPolyL(&p, b->Clip);
                        else
                                p.drawRect(0, 0, static_cast<int>(b->Width)+1, static_cast<int>(b->Height)+1);
                        p.end();
                }
        }
        if ((GroupSel) && (fromMP))
                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);
        pgc.setPen(QPen((norm ? red : 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(qRound(x+w-6), qRound(y+h-6), 6, 6);
                pgc.drawRect(qRound(x+w/2 - 3), qRound(y+h-6), 6, 6);
                pgc.drawRect(qRound(x+w/2 - 3), qRound(y), 6, 6);
                pgc.drawRect(qRound(x+w-6), qRound(y+h/2 - 3), 6, 6);
                pgc.drawRect(qRound(x+w-6), qRound(y), 6, 6);
                pgc.drawRect(qRound(x), qRound(y), 6, 6);
                pgc.drawRect(qRound(x), qRound(y+h/2 - 3), 6, 6);
                pgc.drawRect(qRound(x), qRound(y+h-6), 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 neu)
{
        static QRect old;
        if (!neu.isNull())
        {
                QWMatrix ma = p->worldMatrix();
                ma.setTransformationMode ( QWMatrix::Areas );
                p->setWorldMatrix(ma);
                p->setRasterOp(XorROP);
                p->setBrush(NoBrush);
                p->setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                if (!old.isNull())
                        p->drawRect(old);
                p->drawRect(neu);
        }
        old = 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;
}

bool Page::ApplyGuides(double *x, double *y)
{
        bool ret = false;
        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];
                                        ret = true;
                                        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];
                                        ret = true;
                                        break;
                                }
                        }
                }
                if ((doku->PageM.Left < (*x+doku->GuideRad)) && (doku->PageM.Left > (*x-doku->GuideRad)))
                {
                        *x = doku->PageM.Left;
                        ret = true;
                }
                if (((doku->PageB - doku->PageM.Right) < (*x+doku->GuideRad)) && ((doku->PageB - doku->PageM.Right) > (*x-doku->GuideRad)))
                {
                        *x = doku->PageB - doku->PageM.Right;
                        ret = true;
                }
                if ((doku->PageM.Top < (*y+doku->GuideRad)) && (doku->PageM.Top > (*y-doku->GuideRad)))
                {
                        *y = doku->PageM.Top;
                        ret = true;
                }
                if (((doku->PageH - doku->PageM.Bottom) < (*y+doku->GuideRad)) && ((doku->PageH - doku->PageM.Bottom) > (*y-doku->GuideRad)))
                {
                        *y = doku->PageH - doku->PageM.Bottom;
                        ret = true;
                }
        }
        return ret;
}

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)
{
        bool dirtyT = b->Dirty;
        QPainter p;
        p.begin(this);
        Transform(b, &p);
        QRect rd;
        rd = QRect(qRound(ceil(-b->OldPwidth / 2.0))-2,
                                        qRound(ceil(-b->OldPwidth / 2.0))-2,
                                        qRound(ceil(b->Width+b->OldPwidth*2))+4,
                                        qRound(ceil(b->Height+b->OldPwidth*2))+4);
        if ((b->isTableItem) && (b->Pcolor2 != "None"))
        {
                if (!b->TopLine)
                {
                        rd.setY(rd.y()+qRound(ceil(b->OldPwidth / 2.0)));
                        rd.setHeight(rd.height()-qRound(ceil(b->OldPwidth)));
                }
                if (!b->RightLine)
                        rd.setWidth(rd.width()-qRound(ceil(b->OldPwidth)));
                if (!b->BottomLine)
                        rd.setHeight(rd.height()-qRound(ceil(b->OldPwidth)));
                if (!b->LeftLine)
                {
                        rd.setX(rd.x()+qRound(ceil(b->OldPwidth / 2.0)));
                        rd.setWidth(rd.width()-qRound(ceil(b->OldPwidth)));
                }
        }
        if (single)
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
        else
        {
                if (doku->AppMode == 7)
                        slotDoCurs(false);
                update(QRegion(p.xForm(rd)).intersect(ViewReg()).boundingRect());
                if (doku->AppMode == 7)
                {
                        slotDoCurs(true);
                        if ((b->PType == 4) && (!dirtyT))
                        {
                                ScribusView* vi = (ScribusView*)Anz;
                                vi->HR->ItemPos = b->Xpos;
                                vi->HR->ItemEndPos = b->Xpos+b->Width;
                                if (b->Pcolor2 != "None")
                                        vi->HR->lineCorr = b->Pwidth / 2.0;
                                else
                                        vi->HR->lineCorr = 0;
                                vi->HR->ColGap = b->ColGap;
                                vi->HR->Cols = b->Cols;
                                vi->HR->Extra = b->Extra;
                                vi->HR->RExtra = b->RExtra;
                                vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
                                vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
                                if ((b->flippedH % 2 != 0) || (b->Reverse))
                                        vi->HR->Revers = true;
                                else
                                        vi->HR->Revers = false;
                                vi->HR->ItemPosValid = true;
                                vi->HR->repX = false;
                                if (doku->CurrentABStil < 5)
                                        vi->HR->TabValues = b->TabValues;
                                else
                                        vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
                                vi->HR->repaint();
                        }
                }
        }
        p.end();
        b->OldPwidth = b->Pwidth;
}

void Page::RepaintTextRegion(PageItem *b, QRegion alt, bool single)
{
        if (!isUpdatesEnabled())
                return;
        bool dirtyT = b->Dirty;
        if (doku->AppMode == 7)
                slotDoCurs(false);
        QPainter p;
        QRegion neu;
        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();
        QRect g = neu.boundingRect();
        if (!single)
        {
                g.setX(g.x()-static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))-4);
                g.setY(g.y()-static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))-4);
                g.setWidth(g.width()+static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))+8);
                g.setHeight(g.height()+static_cast<int>(QMAX(0.0, b->OldPwidth * 1.4))+8);
        }
        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);
                if (!((doku->EditClip) && (Mpressed)))
                        b->DrawObj(painter, rd);
                if (!doku->Before)
                        DrawPageMarks(painter, rd);
                if (b->isTableItem)
                {
                        painter->setZoomFactor(doku->Scale);
                        painter->save();
                        painter->translate(-rd.x(), -rd.y());
                        painter->translate(b->Xpos*doku->Scale, b->Ypos*doku->Scale);
                        painter->rotate(b->Rot);
                        if (b->Pcolor2 != "None")
                        {
                                QColor tmp;
                                b->SetFarbe(&tmp, b->Pcolor2, b->Shade2);
                                if ((b->TopLine) || (b->RightLine) || (b->BottomLine) || (b->LeftLine))
                                {
                                        painter->setPen(tmp, b->Pwidth, b->PLineArt, Qt::SquareCap, b->PLineJoin);
                                        if (b->TopLine)
                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(b->Width, 0.0));
                                        if (b->RightLine)
                                                painter->drawLine(FPoint(b->Width, 0.0), FPoint(b->Width, b->Height));
                                        if (b->BottomLine)
                                                painter->drawLine(FPoint(b->Width, b->Height), FPoint(0.0, b->Height));
                                        if (b->LeftLine)
                                                painter->drawLine(FPoint(0.0, b->Height), FPoint(0.0, 0.0));
                                }
                        }
                        painter->restore();
                }
                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());
        }
        if (doku->AppMode == 7)
        {
                slotDoCurs(true);
                if ((b->PType == 4) && (!dirtyT))
                {
                        ScribusView* vi = (ScribusView*)Anz;
                        vi->HR->ItemPos = b->Xpos;
                        vi->HR->ItemEndPos = b->Xpos+b->Width;
                        if (b->Pcolor2 != "None")
                                vi->HR->lineCorr = b->Pwidth / 2.0;
                        else
                                vi->HR->lineCorr = 0;
                        vi->HR->ColGap = b->ColGap;
                        vi->HR->Cols = b->Cols;
                        vi->HR->Extra = b->Extra;
                        vi->HR->RExtra = b->RExtra;
                        vi->HR->First = doku->Vorlagen[doku->CurrentABStil].First;
                        vi->HR->Indent = doku->Vorlagen[doku->CurrentABStil].Indent;
                        if ((b->flippedH % 2 != 0) || (b->Reverse))
                                vi->HR->Revers = true;
                        else
                                vi->HR->Revers = false;
                        vi->HR->ItemPosValid = true;
                        vi->HR->repX = false;
                        if (doku->CurrentABStil < 5)
                                vi->HR->TabValues = b->TabValues;
                        else
                                vi->HR->TabValues = doku->Vorlagen[doku->CurrentABStil].TabValues;
                        vi->HR->repaint();
                }
        }
}

void Page::AdjustPreview(PageItem *b, bool reload)
{
        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;
                                if ( !b->pixmOrg.isNull() )
                                {
                                        b->pixm = b->pixmOrg.copy();
                                        b->OrigW = b->pixm.width();
                                        b->OrigH  = b->pixm.height();
                                        b->LocalViewX = b->LocalScX;
                                        b->LocalViewY = b->LocalScY;
                                }
                                else if (reload == false ) // jjsa begin
                                {
                                        b->OrigW = b->pixm.width();
                                        b->OrigH  = b->pixm.height();
                                        b->LocalViewX = b->LocalScX;
                                        b->LocalViewY = b->LocalScY; // jjsa end
                                }
                                else
                                        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, bool reload)
{
        if (b->ScaleType)
                return;
        if ((b->OrigW == 0) || (b->OrigH == 0))
                return;
        bool savF;
        b->LocalX = 0;
        b->LocalY = 0;
        double xs = b->Width / static_cast<double>(b->OrigW);
        double ys = b->Height / static_cast<double>(b->OrigH);
        if (!b->Sizing)
        {
                int fho = b->flippedH, fvo = b->flippedV;
                savF = b->PicArt;
                if (!b->pixmOrg.isNull())
                {
                        b->pixm = b->pixmOrg.copy();
                        b->OrigW = b->pixm.width();
                        b->OrigH  = b->pixm.height();
                        b->LocalViewX = b->LocalScX;
                        b->LocalViewY = b->LocalScY;
                }
                else if ( reload == false ) // jjsa begin
                        {
                        b->OrigW = b->pixm.width();
                        b->OrigH  = b->pixm.height();
                        b->LocalViewX = b->LocalScX;
                        b->LocalViewY = b->LocalScY;
                        }
                else // jjsa end
                        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, bool fromMP)
{
        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, fromMP);
                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
        {
                b->OldB2 = b->Width;
                b->OldH2 = b->Height;
                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, fromMP);
                        MoveItem(-mxc3, -myc3, b, fromMP);
                }
                else
                {
                        SizeItem(b->Width - newY.x(), b->Height - newY.y(), ite, fromMP);
                        MoveItem(newX.x(), newX.y(), b, fromMP);
                }
        }
        return true;
}

void Page::UpdateClip(PageItem* b)
{
        if (doku->AppMode == 13)
                return;
        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) || (b->FrameType < 3))
                {
                        switch (b->FrameType)
                        {
                        case 0:
                                SetRectFrame(b);
                                break;
                        case 1:
                                SetOvalFrame(b);
                                break;
                        case 2:
                                SetFrameRound(b);
                                break;
                        default:
                                break;
                        }
                        if ((b->OldB2 != 0) && (b->OldH2 != 0))
                        {
                                double scx = b->Width / b->OldB2;
                                double scy = b->Height / b->OldH2;
                                QWMatrix ma;
                                ma.scale(scx, scy);
                                FPointArray gr;
                                gr.addPoint(b->GrStartX, b->GrStartY);
                                gr.addPoint(b->GrEndX, b->GrEndY);
                                gr.map(ma);
                                b->GrStartX = gr.point(0).x();
                                b->GrStartY = gr.point(0).y();
                                b->GrEndX = gr.point(1).x();
                                b->GrEndY = gr.point(0).y();
                                if (b->FrameType > 2)
                                {
                                        b->PoLine.map(ma);
                                        b->ContourLine.map(ma);
                                        if (b->PType == 8)
                                                UpdatePolyClip(b);
                                        else
                                                b->Clip = FlattenPath(b->PoLine, b->Segments);
                                }
                        }
                        b->OldB2 = b->Width;
                        b->OldH2 = b->Height;
                        if (b->FrameType < 3)
                                b->ContourLine = b->PoLine.copy();
                }
                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;
                                b->ContourLine = b->PoLine.copy();
                        }
                        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);
                        FPointArray gr;
                        gr.addPoint(b->GrStartX, b->GrStartY);
                        gr.addPoint(b->GrEndX, b->GrEndY);
                        gr.map(ma);
                        b->GrStartX = gr.point(0).x();
                        b->GrStartY = gr.point(0).y();
                        b->GrEndX = gr.point(1).x();
                        b->GrEndY = gr.point(0).y();
                        b->PoLine.map(ma);
                        b->ContourLine.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;
        }
        updateGradientVectors(b);
}

bool Page::SizeItem(double newX, double newY, int ite, bool fromMP, bool DoUpdateClip)
{
        PageItem *b = Items.at(ite);
        if (b->Locked)
                return false;
        QRegion alt, neu;
        QPainter p;
        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();
        QWMatrix ma;
        ma.rotate(b->Rot);
        double dX = ma.m11() * (b->Width - newX) + ma.m21() * (b->Height - newY) + ma.dx();
        double dY = ma.m22() * (b->Height - newY) + ma.m12() * (b->Width - newX) + ma.dy();
        b->Width = newX;
        b->Height = newY;
        if ((doku->RotMode != 0) && (fromMP))
        {
                switch (doku->RotMode)
                {
                case 2:
                        MoveItem(dX / 2.0, dY / 2.0, b);
                        break;
                case 4:
                        MoveItem(dX, dY, b);
                        break;
                case 3:
                        MoveItem(0.0, dY, b);
                        break;
                case 1:
                        MoveItem(dX, 0.0, b);
                        break;
                }
        }
        b->RadRect = QMIN(b->RadRect, QMIN(b->Width,b->Height)/2);
        if ((b->PType == 2) && (!b->Sizing) && (!doku->EditClip))
        {
                AdjustPictScale(b);
                AdjustPreview(b, false);
        }
        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)
        {
                emit ItemGeom(b->Width, b->Height);
                emit ItemRadius(b->RadRect);
                b->FrameOnly = true;
                b->Tinput = true;
                if ((HowTo == 1) && (b->PType != 5))
                        b->paintObj();
                if ((b->FrameType == 0) || (b->PType == 5) || (HowTo != 1))
                        return true;
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                p.setRasterOp(XorROP);
                p.setBrush(NoBrush);
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                b->DrawPolyL(&p, b->Clip);
                UpdateClip(b);
                b->DrawPolyL(&p, b->Clip);
                p.end();
                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);
        }
        updateGradientVectors(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)
{
        PageItem *b = Items.at(ite);
        if ((b->Locked) || (!b->ScaleType))
                return;
        QPainter p;
        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;
        RepaintTextRegion(b, alt, true);
        emit SetLocalValues(b->LocalScX, b->LocalScY, b->LocalX, b->LocalY);
}

bool Page::MoveItem(double newX, double newY, PageItem* b, bool fromMP)
{
        if (b->Locked)
                return false;
        QRegion alt;
        bool retw = 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) && (!fromMP))
        {
                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) && (!fromMP))
                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::RotateGroup(double win)
{
        double gxS, gyS, ghS, gwS;
        PageItem* b;
        FPoint n;
        getGroupRectScreen(&gxS, &gyS, &gwS, &ghS);
        QWMatrix ma;
        ma.translate(RCenter.x(), RCenter.y());
        ma.scale(1, 1);
        ma.rotate(win);
        QRect alt = QRect(static_cast<int>(gxS-5), static_cast<int>(gyS-5), static_cast<int>(gwS+10),
                          static_cast<int>(ghS+10));
        for (uint a = 0; a < SelItem.count(); ++a)
        {
                b = SelItem.at(a);
                n = FPoint(b->Xpos - RCenter.x(), b->Ypos - RCenter.y());
                b->Xpos = ma.m11() * n.x() + ma.m21() * n.y() + ma.dx();
                b->Ypos = ma.m22() * n.y() + ma.m12() * n.x() + ma.dy();
                b->Rot += win;
        }
        setGroupRect();
        getGroupRectScreen(&gxS, &gyS, &gwS, &ghS);
        repaint(QRect(static_cast<int>(gxS-5), static_cast<int>(gyS-5), static_cast<int>(gwS+10),
                      static_cast<int>(ghS+10)).unite(alt));
}

void Page::RotateItem(double win, int ite)
{
        PageItem *b;
        b = Items.at(ite);
        if (b->Locked)
                return;
        QRegion alt, neu;
        QPainter p;
        FPoint n;
        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);
        int dd = doku->Layers[d].LNr;
        if (SelItem.count() != 0)
        {
                for (uint a = 0; a < SelItem.count(); ++a)
                {
                        PageItem *b = SelItem.at(a);
                        b->LayerNr = dd;
                }
        }
        Deselect(true);
        update();
        emit DocChanged();
}

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

void Page::AdjustItemSize(PageItem *b)
{
        bool siz = b->Sizing;
        b->Sizing = false;
        FPointArray Clip;
        Clip = b->PoLine;
        FPoint tp2 = GetMinClipF(Clip);
        SizeItem(b->Width - tp2.x(), b->Height - tp2.y(), b->ItemNr, true, false);
        Clip.translate(-tp2.x(), -tp2.y());
        if (b->Rot != 0)
        {
                FPoint npv = FPoint(tp2.x(), tp2.y());
                MoveRotated(b, npv, true);
        }
        else
                MoveItem(tp2.x(), tp2.y(), b, true);
        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, true, 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);
        b->Sizing = siz;
}

void Page::MirrorPolyH()
{
        PageItem *b = SelItem.at(0);
        b->ClipEdited = true;
        QWMatrix ma;
        if (EditContour)
        {
                FPoint tp, tp2;
                tp2 = GetMinClipF(b->ContourLine);
                tp = GetMaxClipF(b->ContourLine);
                QRect rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
                ma.translate(qRound(tp.x()), 0);
                ma.scale(-1, 1);
                b->ContourLine.map(ma);
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                p.end();
                b->FrameOnly = true;
                b->Tinput = true;
                b->paintObj();
                b->FrameOnly = false;
                MarkClip(b);
                return;
        }
        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);
        b->ClipEdited = true;
        QWMatrix ma;
        if (EditContour)
        {
                FPoint tp, tp2;
                tp2 = GetMinClipF(b->ContourLine);
                tp = GetMaxClipF(b->ContourLine);
                QRect rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
                ma.translate(0, qRound(tp.y()));
                ma.scale(1, -1);
                b->ContourLine.map(ma);
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                p.end();
                b->FrameOnly = true;
                b->Tinput = true;
                b->paintObj();
                b->FrameOnly = false;
                MarkClip(b);
                return;
        }
        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::TransformPoly(int mode, int rot, int scaling)
{
        PageItem *b = SelItem.at(0);
        b->ClipEdited = true;
        QWMatrix ma;
        if (EditContour)
        {
                FPoint tp, tp2;
                tp2 = GetMinClipF(b->ContourLine);
                tp = GetMaxClipF(b->ContourLine);
                QRect rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
                b->ContourLine.translate(-qRound((tp.x() + tp2.x()) / 2.0), -qRound((tp.y() + tp2.y()) / 2.0));
                switch (mode)
                {
                case 0:
                        ma.rotate(-rot);
                        break;
                case 1:
                        ma.rotate(rot);
                        break;
                case 2:
                        ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                        break;
                case 3:
                        ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                        break;
                case 4:
                        ma.shear(0.017455, 0);
                        break;
                case 5:
                        ma.shear(-0.017455, 0);
                        break;
                case 6:
                        ma.shear(0, -0.017455);
                        break;
                case 7:
                        ma.shear(0, 0.017455);
                        break;
                }
                b->ContourLine.map(ma);
                b->ContourLine.translate(qRound((tp.x() + tp2.x()) / 2.0), qRound((tp.y() + tp2.y()) / 2.0));
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                p.end();
                b->FrameOnly = true;
                b->Tinput = true;
                b->paintObj();
                b->FrameOnly = false;
                MarkClip(b);
                return;
        }
        FPoint oldPos = FPoint(b->Xpos, b->Ypos);
        double offsX = b->Width / 2.0;
        double offsY = b->Height / 2.0;
        ma.translate(-offsX, -offsY);
        switch (mode)
        {
        case 0:
                ma.rotate(-rot);
                break;
        case 1:
                ma.rotate(rot);
                break;
        case 2:
                ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                break;
        case 3:
                ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                break;
        case 4:
                ma.shear(0.017455, 0);
                break;
        case 5:
                ma.shear(-0.017455, 0);
                break;
        case 6:
                ma.shear(0, -0.017455);
                break;
        case 7:
                ma.shear(0, 0.017455);
                break;
        }
        b->PoLine.map(ma);
        b->PoLine.translate(offsX, offsY);
        AdjustItemSize(b);
        QWMatrix ma2;
        ma2.translate(oldPos.x(), oldPos.y());
        ma2.scale(1, 1);
        ma2.translate(offsX, offsY);
        FPoint n = FPoint(-offsX, -offsY);
        switch (mode)
        {
        case 0:
                ma2.rotate(-rot);
                break;
        case 1:
                ma2.rotate(rot);
                break;
        case 2:
                ma2.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
                break;
        case 3:
                ma2.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
                break;
        case 4:
                ma2.shear(0.017455, 0);
                break;
        case 5:
                ma2.shear(-0.017455, 0);
                break;
        case 6:
                ma2.shear(0, -0.017455);
                break;
        case 7:
                ma2.shear(0, 0.017455);
                break;
        }
        double x = ma2.m11() * n.x() + ma2.m21() * n.y() + ma2.dx();
        double y = ma2.m22() * n.y() + ma2.m12() * n.x() + ma2.dy();
        MoveItem(x-oldPos.x(), y-oldPos.y(), b);
        if (b->PType == 8)
                UpdatePolyClip(b);
        RefreshItem(b);
        MarkClip(b);
        b->FrameType = 3;
}

void Page::Reset1Control()
{
        PageItem *b = SelItem.at(0);
        b->ClipEdited = true;
        FPoint np, tp, tp2;
        QRect rd;
        if (EditContour)
        {
                np = b->ContourLine.point(ClRe-1);
                tp2 = GetMinClipF(b->ContourLine);
                tp = GetMaxClipF(b->ContourLine);
                rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
        }
        else
                np = b->PoLine.point(ClRe-1);
        b->OldB2 = b->Width;
        b->OldH2 = b->Height;
        if (EditContour)
        {
                b->ContourLine.setPoint(ClRe, np);
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                p.end();
                b->FrameOnly = true;
                b->Tinput = true;
                b->paintObj();
                b->FrameOnly = false;
        }
        else
        {
                b->PoLine.setPoint(ClRe, np);
                AdjustItemSize(b);
        }
        MarkClip(b);
}

void Page::ResetControl()
{
        PageItem *b = SelItem.at(0);
        b->ClipEdited = true;
        FPoint np, tp, tp2;
        QRect rd;
        if (EditContour)
        {
                np = b->ContourLine.point(ClRe);
                tp2 = GetMinClipF(b->ContourLine);
                tp = GetMaxClipF(b->ContourLine);
                rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
        }
        else
                np = b->PoLine.point(ClRe);
        b->OldB2 = b->Width;
        b->OldH2 = b->Height;
        if ((ClRe == 0) || (ClRe == static_cast<int>(b->PoLine.size()-2)))
        {
                if (EditContour)
                        b->ContourLine.setPoint(ClRe+1, np);
                else
                        b->PoLine.setPoint(ClRe+1, np);
        }
        else
        {
                if (EditContour)
                {
                        b->ContourLine.setPoint(ClRe+1, np);
                        b->ContourLine.setPoint((ClRe % 4 != 0 ? ClRe + 3 : ClRe - 1), np);
                }
                else
                {
                        b->PoLine.setPoint(ClRe+1, np);
                        b->PoLine.setPoint((ClRe % 4 != 0 ? ClRe + 3 : ClRe - 1), np);
                }
        }
        if (!EditContour)
                AdjustItemSize(b);
        else
        {
                QPainter p;
                p.begin(this);
                Transform(b, &p);
                RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                p.end();
                b->FrameOnly = true;
                b->Tinput = true;
                b->paintObj();
                b->FrameOnly = false;
        }
        MarkClip(b);
}

void Page::MoveClipPoint(PageItem *b, FPoint ip)
{
        if (((EdPoints) && (ClRe % 2 != 0)) || ((!EdPoints) && (ClRe % 2 == 0)))
                return;
        b->ClipEdited = true;
        FPointArray Clip;
        if (EditContour)
                Clip = b->ContourLine;
        else
                Clip = b->PoLine;
        b->FrameType = 3;
        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) && (!EditContour))
                {
                        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) && (!EditContour))
                {
                        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);
                }
                if (EditContour)
                        b->ContourLine = Clip.copy();
                else
                        b->PoLine = Clip.copy();
                b->Clip = FlattenPath(b->PoLine, b->Segments);
                if (!EditContour)
                        AdjustItemSize(b);
                else
                {
                        FPoint tp2 = GetMinClipF(b->ContourLine);
                        FPoint tp = GetMaxClipF(b->ContourLine);
                        QPainter p;
                        p.begin(this);
                        Transform(b, &p);
                        QRect rd;
                        rd = QRect(QPoint(qRound(tp2.x()-10), qRound(tp2.y()-10)), QPoint(qRound(tp.x()+20), qRound(tp.y()+20)));
                        RepaintTextRegion(b, QRegion(p.xForm(rd)), true);
                        p.end();
                        b->FrameOnly = true;
                        b->Tinput = true;
                        b->paintObj();
                        b->FrameOnly = false;
                        MarkClip(b);
                }
        }
}
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;
        PageItem *b = 0;
        if (doku->EditClip)
        {
                emit EndNodeEdit();
                return;
        }
        if ((GroupSel) || (doku->AppMode != 1))
        {
                if ((GroupSel) && (doku->AppMode == 1))
                {
                        if (GetItem(&b))
                        {
                                if (b->isTableItem)
                                {
                                        Deselect(false);
                                        SelItem.append(b);
                                        b->isSingleSel = true;
                                        b->Select = true;
                                        emit HaveSel(b->PType);
                                        EmitValues(b);
                                        b->paintObj();
                                }
                        }
                }
                else
                        mousePressEvent(m);
                return;
        }
        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)
                                emit b->isAnnotation ? AnnotProps() : 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, x, y;
        uint aa;
        FPoint n;
        getGroupRect(&gx, &gy, &gw, &gh);
        setUpdatesEnabled(false);
        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, oldLocalX, oldLocalY;
                oldRot = bb->Rot;
                oldLocalX = bb->LocalX;
                oldLocalY = bb->LocalY;
                FPointArray gr;
                gr.addPoint(bb->GrStartX, bb->GrStartY);
                gr.addPoint(bb->GrEndX, bb->GrEndY);
                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);
                if (bb->PType == 5)
                {
                        bb->Rot = atan2(t1.y()-b1.y(),t1.x()-b1.x())*(180.0/M_PI);
                        bb->Width = sqrt(pow(t1.x()-b1.x(),2)+pow(t1.y()-b1.y(),2));
                        bb->Xpos = b1.x()+gx;
                        bb->Ypos = b1.y()+gy;
                }
                else
                {
                        FPoint oldPos = FPoint(bb->Xpos, bb->Ypos);
                        QWMatrix ma;
                        ma.rotate(bb->Rot);
                        bb->PoLine.map(ma);
                        QWMatrix ma2;
                        ma2.translate(gx-bb->Xpos, gy-bb->Ypos);
                        ma2.scale(scx, scy);
                        bb->PoLine.map(ma2);
                        bb->Rot = 0;
                        bb->ClipEdited = true;
                        AdjustItemSize(bb);
                        QWMatrix ma3;
                        ma3.translate(gx, gy);
                        ma3.scale(scx, scy);
                        n = FPoint(gx-oldPos.x(), gy-oldPos.y());
                        x = ma3.m11() * n.x() + ma3.m21() * n.y() + ma3.dx();
                        y = ma3.m22() * n.y() + ma3.m12() * n.x() + ma3.dy();
                        MoveItem(gx-x, gy-y, bb, true);
                        if (oldRot != 0)
                        {
                                bb->Rot = atan2(t1.y()-b1.y(),t1.x()-b1.x())*(180.0/M_PI);
                                QWMatrix ma;
                                ma.rotate(-bb->Rot);
                                bb->PoLine.map(ma);
                                AdjustItemSize(bb);
                        }
                }
                bb->ISize = QMAX(qRound(bb->ISize*((scx+scy)/2)), 1);
                if ((bb->Ptext.count() != 0) && (!bb->isTableItem))
                {
                        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);
                }
                bb->LocalX = oldLocalX;
                bb->LocalY = oldLocalY;
                bb->OldB2 = bb->Width;
                bb->OldH2 = bb->Height;
                QWMatrix ma4;
                ma4.rotate(oldRot);
                ma4.scale(scx, scy);
                gr.map(ma4);
                bb->ContourLine.map(ma4);
                bb->GrStartX = gr.point(0).x();
                bb->GrStartY = gr.point(0).y();
                bb->GrEndX = gr.point(1).x();
                bb->GrEndY = gr.point(1).y();
                updateGradientVectors(bb);
        }
        setGroupRect();
        setUpdatesEnabled(true);
        update();
        emit DocChanged();
}

void Page::PasteToPage()
{
        emit LoadElem(ScApp->Buffer2, qRound(Mxp/doku->Scale), qRound(Myp/doku->Scale), false, false, doku);
        doku->DraggedElem = 0;
        doku->DragElements.clear();
        update();
}

void Page::mouseReleaseEvent(QMouseEvent *m)
{
        PageItem *b;
        Mpressed = false;
        if (ScApp->Prefs.GuidesShown)
        {
                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->AppMode == 24)
        {
                QPainter p;
                p.begin(this);
                p.setRasterOp(XorROP);
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                p.drawLine(Dxp, Dyp, Mxp, Myp);
                p.end();
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
                emit PaintingDone();
                return;
        }
        if (doku->AppMode == 23)
                return;
        if (doku->AppMode == 22)
        {
                if ((SelItem.count() == 0) && (HaveSelRect) && (!MidButt))
                {
                        double sc = doku->Scale;
                        QRect AreaR = QRect(static_cast<int>(Mxp*sc), static_cast<int>(Myp*sc), static_cast<int>(SeRx-(Mxp*sc)), static_cast<int>(SeRy-(Myp*sc)));
                        QPainter p;
                        p.begin(this);
                        p.setRasterOp(XorROP);
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
                        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);
                        }
                        HaveSelRect = false;
                        double Tx, Ty, Tw, Th;
                        Tx = Mxp;
                        Ty = Myp;
                        Tw = SeRx/sc-Mxp;
                        Th = SeRy/sc-Myp;
                        int z;
                        int Cols, Rows;
                        double deltaX, deltaY, offX, offY;
                        if ((Th < 6) || (Tw < 6))
                        {
                                p.drawRect(AreaR);
                                p.end();
                                doku->AppMode = 1;
                                emit PaintingDone();
                                return;
                        }
                        InsertTable *dia = new InsertTable(this, static_cast<int>(Th / 6), static_cast<int>(Tw / 6));
                        if (!dia->exec())
                        {
                                p.drawRect(AreaR);
                                p.end();
                                doku->AppMode = 1;
                                emit PaintingDone();
                                delete dia;
                                return;
                        }
                        p.end();
                        Cols = dia->Cols->value();
                        Rows = dia->Rows->value();
                        delete dia;
                        deltaX = Tw / Cols;
                        deltaY = Th / Rows;
                        offX = 0.0;
                        offY = 0.0;
                        SelItem.clear();
                        for (int rc = 0; rc < Rows; ++rc)
                        {
                                for (int cc = 0; cc < Cols; ++cc)
                                {
                                        z = PaintText(Tx + offX, Ty + offY, deltaX, deltaY, doku->Dwidth, doku->DpenText);
                                        b = Items.at(z);
                                        b->isTableItem = true;
                                        SelItem.append(b);
                                        offX += deltaX;
                                }
                                offY += deltaY;
                                offX = 0.0;
                        }
                        for (int rc = 0; rc < Rows; ++rc)
                        {
                                for (int cc = 0; cc < Cols; ++cc)
                                {
                                        b = SelItem.at((rc * Cols) + cc);
                                        if (rc == 0)
                                                b->TopLink = 0;
                                        else
                                                b->TopLink = SelItem.at(((rc-1)*Cols)+cc);
                                        if (rc == Rows-1)
                                                b->BottomLink = 0;
                                        else
                                                b->BottomLink = SelItem.at(((rc+1)*Cols)+cc);
                                        if (cc == 0)
                                                b->LeftLink = 0;
                                        else
                                                b->LeftLink = SelItem.at((rc*Cols)+cc-1);
                                        if (cc == Cols-1)
                                                b->RightLink = 0;
                                        else
                                                b->RightLink = SelItem.at((rc*Cols)+cc+1);
                                }
                        }
                        emit DoGroup();
                }
                doku->AppMode = 1;
                emit PaintingDone();
                emit DocChanged();
                update();
                return;
        }
        if (doku->AppMode == 21)
        {
                doku->AppMode = 1;
                if (RecordP.size() > 1)
                {
                        uint z = PaintPolyLine(0, 0, 1, 1, doku->Dwidth, "None", doku->Dpen);
                        b = Items.at(z);
                        b->PoLine.resize(0);
                        b->PoLine.addPoint(RecordP.point(0));
                        b->PoLine.addPoint(RecordP.point(0));
                        for (uint px = 1; px < RecordP.size()-1; ++px)
                        {
                                b->PoLine.addPoint(RecordP.point(px));
                                b->PoLine.addPoint(RecordP.point(px));
                                b->PoLine.addPoint(RecordP.point(px));
                                b->PoLine.addPoint(RecordP.point(px));
                        }
                        b->PoLine.addPoint(RecordP.point(RecordP.size()-1));
                        b->PoLine.addPoint(RecordP.point(RecordP.size()-1));
                        AdjustItemSize(b);
                        SelItem.clear();
                        SelItem.append(b);
                        b->Select = true;
                        emit ItemPos(b->Xpos, b->Ypos);
                        emit SetSizeValue(b->Pwidth);
                        emit SetLineArt(b->PLineArt, b->PLineEnd, b->PLineJoin);
                        emit ItemFarben(b->Pcolor2, b->Pcolor, b->Shade2, b->Shade);
                        emit ItemGradient(b->GrType);
                        emit ItemTrans(b->Transparency, b->TranspStroke);
                        emit HaveSel(7);
                }
                update();
                emit PaintingDone();
                emit DocChanged();
                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)));
                FPointArray Clip;
                if (EditContour)
                        Clip = b->ContourLine;
                else
                        Clip = b->PoLine;
                for (uint a = 0; a < Clip.count(); ++a)
                {
                        if (Clip.point(a).x() > 900000)
                                continue;
                        p.begin(this);
                        Transform(b, &p);
                        QPoint npf = p.xForm(Clip.pointQ(a));
                        p.end();
                        if ((Sele.contains(npf)) && ((a == 0) || (((a-2) % 4) == 0)))
                        {
                                ClRe = a;
                                SelNode.append(a);
                                emit ClipPo(Clip.point(a).x(), Clip.point(a).y());
                        }
                }
                HaveSelRect = false;
                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;
                        if (!ApplyGuides(&nx, &ny))
                        {
                                FPoint npg = ApplyGridF(FPoint(nx, ny));
                                nx = npg.x();
                                ny = npg.y();
                        }
                        FPoint np = transformPointI(FPoint(nx, ny), b->Xpos, b->Ypos, b->Rot, 1, 1);
                        MoveClipPoint(b, np);
                }
                else
                        update();
                Imoved = false;
                return;
        }
        if ((doku->EditClip) && (SegP1 != -1) && (SegP2 != -1))
        {
                SegP1 = -1;
                SegP2 = -1;
                b = SelItem.at(0);
                Imoved = false;
                update();
                return;
        }
        if ((!GetItem(&b)) && (m->button() == RightButton) && (!doku->DragP) && (doku->AppMode == 1))
        {
                int menid;
                QPopupMenu *pmen = new QPopupMenu();
                if (ScApp->Buffer2.startsWith("<SCRIBUSELEM"))
                {
                        Mxp = m->x();
                        Myp = m->y();
                        pmen->insertItem( tr("&Paste") , this, SLOT(PasteToPage()));
                        pmen->insertSeparator();
                }
                menid = pmen->insertItem(tr("Show &Margins"), ScApp, SLOT(ToggleMarks()));
                pmen->setItemChecked(menid, ScApp->Prefs.MarginsShown);
                menid = pmen->insertItem(tr("Show &Frames"), ScApp, SLOT(ToggleFrames()));
                pmen->setItemChecked(menid, ScApp->Prefs.FramesShown);
                menid = pmen->insertItem(tr("Show &Images"), ScApp, SLOT(TogglePics()));
                pmen->setItemChecked(menid, doku->ShowPic);
                menid = pmen->insertItem(tr("Show &Grid"), ScApp, SLOT(ToggleRaster()));
                pmen->setItemChecked(menid, ScApp->Prefs.GridShown);
                menid = pmen->insertItem(tr("Show G&uides"), ScApp, SLOT(ToggleGuides()));
                pmen->setItemChecked(menid, ScApp->Prefs.GuidesShown);
                menid = pmen->insertItem(tr("Show &Baseline Grid"), ScApp, SLOT(ToggleBase()));
                pmen->setItemChecked(menid, ScApp->Prefs.BaseShown);
                pmen->insertSeparator();
                int uRas = pmen->insertItem( tr("Sn&ap to Grid"), ScApp, SLOT(ToggleURaster()));
                pmen->setItemChecked(uRas, doku->useRaster);
                int uGuide = pmen->insertItem( tr("Sna&p to Guides"), ScApp, SLOT(ToggleUGuides()));
                pmen->setItemChecked(uGuide, doku->SnapGuides);
                pmen->exec(QCursor::pos());
                delete pmen;
                return;
        }
        if ((doku->AppMode != 6) && (!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);
                        QPopupMenu *pmen4 = new QPopupMenu();
                        QPopupMenu *pmenLevel = new QPopupMenu();
                        QPopupMenu *pmenPDF = new QPopupMenu();

                        if ((b->PType == 4) || (b->PType == 2) || (b->PType == 8))
                        {
                                QButtonGroup *InfoGroup = new QButtonGroup( this, "InfoGroup" );
                                InfoGroup->setFrameShape( QButtonGroup::NoFrame );
                                InfoGroup->setFrameShadow( QButtonGroup::Plain );
                                InfoGroup->setTitle("");
                                InfoGroup->setExclusive( true );
                                InfoGroup->setColumnLayout(0, Qt::Vertical );
                                InfoGroup->layout()->setSpacing( 0 );
                                InfoGroup->layout()->setMargin( 0 );
                                QGridLayout *InfoGroupLayout = new QGridLayout( InfoGroup->layout() );
                                InfoGroupLayout->setAlignment( Qt::AlignTop );
                                InfoGroupLayout->setSpacing( 2 );
                                InfoGroupLayout->setMargin( 0 );
                                QString txtC, txtC2;
                                QLabel *InfoT = new QLabel(InfoGroup, "ct");
                                QLabel *ParCT = new QLabel(InfoGroup, "pt");
                                QLabel *ParC = new QLabel(InfoGroup, "pc");
                                QLabel *WordCT = new QLabel(InfoGroup, "wt");
                                QLabel *WordC = new QLabel(InfoGroup, "wc");
                                QLabel *CharCT = new QLabel(InfoGroup, "ct");
                                QLabel *CharC = new QLabel(InfoGroup, "cc");
                                QLabel *PrintCT = new QLabel(InfoGroup, "nt"); // <a.l.e>
                                QLabel *PrintC = new QLabel(InfoGroup, "nc"); // </a.l.e>
                                if (b->PType == 2)
                                {
                                        QFileInfo fi = QFileInfo(b->Pfile);
                                        InfoT->setText( tr("Picture"));
                                        InfoGroupLayout->addMultiCellWidget( InfoT, 0, 0, 0, 1, Qt::AlignCenter );
                                        ParCT->setText( tr("File: "));
                                        InfoGroupLayout->addWidget( ParCT, 1, 0, Qt::AlignRight );
                                        ParC->setText(fi.fileName());
                                        InfoGroupLayout->addWidget( ParC, 1, 1 );
                                        WordCT->setText( tr("Original PPI: "));
                                        InfoGroupLayout->addWidget( WordCT, 2, 0, Qt::AlignRight );
                                        WordC->setText(txtC.setNum(qRound(b->dpiX))+" x "+txtC2.setNum(qRound(b->dpiY)));
                                        InfoGroupLayout->addWidget( WordC, 2, 1 );
                                        CharCT->setText( tr("Actual PPI: "));
                                        InfoGroupLayout->addWidget( CharCT, 3, 0, Qt::AlignRight );
                                        CharC->setText(txtC.setNum(qRound(72.0 / b->LocalScX))+" x "+
                                                       txtC2.setNum(qRound(72.0 / b->LocalScY)));
                                        InfoGroupLayout->addWidget( CharC, 3, 1 );
                                }
                                if ((b->PType == 4) || (b->PType == 8))
                                {
                                        int Parag = 0;
                                        int Words = 0;
                                        int Chara = 0;
                                        int ParagN = 0;
                                        int WordsN = 0;
                                        int CharaN = 0;
                                        if (b->PType == 4)
                                        {
                                                if ((b->NextBox != 0) || (b->BackBox != 0))
                                                        InfoT->setText( tr("Linked Text"));
                                                else
                                                        InfoT->setText( tr("Text Frame"));
                                        }
                                        else
                                                InfoT->setText( tr("Text on a Path"));
                                        InfoGroupLayout->addMultiCellWidget( InfoT, 0, 0, 0, 1, Qt::AlignCenter );
                                        WordAndPara(b, &Words, &Parag, &Chara, &WordsN, &ParagN, &CharaN);
                                        ParCT->setText( tr("Paragraphs: "));
                                        InfoGroupLayout->addWidget( ParCT, 1, 0, Qt::AlignRight );
                                        if (ParagN != 0)
                                                ParC->setText(txtC.setNum(Parag+ParagN)+" ("+txtC2.setNum(ParagN)+")");
                                        else
                                                ParC->setText(txtC.setNum(Parag));
                                        InfoGroupLayout->addWidget( ParC, 1, 1 );
                                        WordCT->setText( tr("Words: "));
                                        InfoGroupLayout->addWidget( WordCT, 2, 0, Qt::AlignRight );
                                        if (WordsN != 0)
                                                WordC->setText(txtC.setNum(Words+WordsN)+" ("+txtC2.setNum(WordsN)+")");
                                        else
                                                WordC->setText(txtC.setNum(Words));
                                        InfoGroupLayout->addWidget( WordC, 2, 1 );
                                        CharCT->setText( tr("Chars: "));
                                        InfoGroupLayout->addWidget( CharCT, 3, 0, Qt::AlignRight );
                                        if (CharaN != 0)
                                                CharC->setText(txtC.setNum(Chara+CharaN)+" ("+txtC2.setNum(CharaN)+")");
                                        else
                                                CharC->setText(txtC.setNum(Chara));
                                        InfoGroupLayout->addWidget( CharC, 3, 1 );
                                }

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

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

                                pmen4->insertItem(InfoGroup);

                                pmen->insertItem( tr("In&fo"), pmen4);
                        }
                        if (b->PType == 2)
                        {
                                pmen->insertItem( tr("&Get Picture..."), this, SIGNAL(LoadPic()));
                                int px = pmen->insertItem( tr("I&mage Visible"), this, SLOT(TogglePic()));
                                pmen->setItemChecked(px, b->PicArt);
                                if (b->PicAvail)
                                        pmen->insertItem( tr("&Update Picture"), this, SLOT(UpdatePic()));
                                if (b->PicAvail && b->isRaster)
                                        pmen->insertItem( tr("&Edit Picture"), this, SLOT(CallGimp()));
                                if ((b->PicAvail) && (!b->isTableItem))
                                        pmen->insertItem( tr("&Adjust Frame to Picture"), this, SLOT(FrameToPic()));
                        }
                        if (b->PType == 4)
                        {
                                pmen->insertItem( tr("&Get Text..."), this, SIGNAL(LoadPic()));
                                pmen->insertItem( tr("&Append Text..."), this, SIGNAL(AppendText()));
                                pmen->insertItem( tr("&Edit Text..."), this, SIGNAL(EditText()));
                                if (PageNam == "")
                                {
                                        int pxb = pmenPDF->insertItem( tr("Is PDF &Bookmark"), this, SLOT(ToggleBookmark()));
                                        pmenPDF->setItemChecked(pxb, b->isBookmark);
                                        pxb = pmenPDF->insertItem( tr("Is PDF A&nnotation"), this, SLOT(ToggleAnnotation()));
                                        pmenPDF->setItemChecked(pxb, b->isAnnotation);
                                        if (b->isAnnotation)
                                        {
                                                if ((b->AnType == 0) || (b->AnType == 1) || (b->AnType > 9))
                                                        pmenPDF->insertItem( tr("Annotation P&roperties"), this, SIGNAL(AnnotProps()));
                                                else
                                                        pmenPDF->insertItem( tr("Field P&roperties"), this, SIGNAL(AnnotProps()));
                                        }
                                }
                                pmen->insertItem( tr("&PDF Options"), pmenPDF);
                        }
                        if (b->PType == 8)
                                pmen->insertItem( tr("Edit Text..."), this, SIGNAL(EditText()));
                        if (!b->Locked)
                                pmen->insertItem( tr("&Lock"), this, SLOT(ToggleLock()));
                        else
                                pmen->insertItem( tr("Un&lock"), this, SLOT(ToggleLock()));
                        if (!b->LockRes)
                                pmen->insertItem( tr("Lock Object &Size"), this, SLOT(ToggleResize()));
                        else
                                pmen->insertItem( tr("Unlock Object &Size"), this, SLOT(ToggleResize()));
                        if (!b->isSingleSel)
                        {
                                pmen->insertItem( tr("Send to S&crapbook"), 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 La&yer"), pmen3);
                                }
                                connect(pmen3, SIGNAL(activated(int)), this, SLOT(sentToLayer(int)));
                        }
                        if (b->PType == 4)
                                pmen->insertItem( tr("&Insert Sample Text"), this, SLOT(LoremIpsum()));
                        if (!b->Locked)
                        {
                                if (SelItem.count() > 1)
                                {
                                        bool isGroup = true;
                                        int firstElem = -1;
                                        if (b->Groups.count() != 0)
                                                firstElem = b->Groups.top();
                                        for (uint bx = 0; bx < SelItem.count(); ++bx)
                                        {
                                                if (SelItem.at(bx)->Groups.count() != 0)
                                                {
                                                        if (SelItem.at(bx)->Groups.top() != firstElem)
                                                                isGroup = false;
                                                }
                                                else
                                                        isGroup = false;
                                        }
                                        if (!isGroup)
                                                pmen->insertItem( tr("&Group"), this, SIGNAL(DoGroup()));
                                }
                                if (b->Groups.count() != 0)
                                        pmen->insertItem( tr("Un&group"), this, SIGNAL(DoUnGroup()));
                                if ((!b->isTableItem) && (!b->isSingleSel))
                                {
                                        pmen->insertItem( tr("Le&vel"), pmenLevel);
                                        pmenLevel->insertItem( tr("Send to &Back"), this, SLOT(ToBack()));
                                        pmenLevel->insertItem( tr("Bring to &Front"), this, SLOT(ToFront()));
                                        pmenLevel->insertItem( tr("&Lower"), this, SLOT(LowerItem()));
                                        pmenLevel->insertItem( tr("&Raise"), this, SLOT(RaiseItem()));
                                }
                        }
                        if (((b->PType == 4) || (b->PType == 2) || (b->PType == 6)) && (doku->AppMode != 7))
                        {
                                if (b->PType == 4)
                                {
                                        pmen2->insertItem( tr("&Picture Frame"), this, SLOT(ToPicFrame()));
                                        if (!b->isTableItem)
                                        {
                                      &