Subversion Repositories Scribus

Rev

Rev 5752 | Rev 5780 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
3 paul 7
/***************************************************************************
8
                          scribusview.cpp  -  description
9
                             -------------------
10
    begin                : Fre Apr  6 21:47:55 CEST 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
24
#include "scribusview.h"
25
#include "scribusview.moc"
128 Franz 26
 
2688 craig 27
#include "scconfig.h"
128 Franz 28
 
3 paul 29
#include <qcolor.h>
30
#include <qfont.h>
31
#include <qfontmetrics.h>
32
#include <qpixmap.h>
33
#include <qpointarray.h>
34
#include <qstringlist.h>
1525 cbradney 35
#include <qdragobject.h>
3 paul 36
#include <qimage.h>
37
#include <qcstring.h>
173 Franz 38
#include <qfileinfo.h>
456 fschmid 39
#include <qfile.h>
307 Franz 40
#include <cmath>
456 fschmid 41
#include <cstdio>
42
#include <cstdlib>
2702 craig 43
 
44
#ifdef HAVE_UNISTD_H
456 fschmid 45
#include <unistd.h>
2702 craig 46
#endif
47
 
456 fschmid 48
#include <qcursor.h>
49
#include <qurl.h>
50
#include <qdir.h>
51
#include <qevent.h>
2880 fschmid 52
#include <qsizegrip.h>
456 fschmid 53
#if QT_VERSION  > 0x030102
54
        #define SPLITVC SplitHCursor
55
        #define SPLITHC SplitVCursor
56
#else
57
        #define SPLITVC SplitVCursor
58
        #define SPLITHC SplitHCursor
59
#endif
181 Franz 60
#include "scribus.h"
1427 fschmid 61
#include "tree.h"
456 fschmid 62
#include "mpalette.h"
63
#include "scribusXml.h"
3903 cbradney 64
#include "selection.h"
456 fschmid 65
#include "serializer.h"
66
#include "insertTable.h"
838 cbradney 67
#include "hruler.h"
68
#include "vruler.h"
1151 fschmid 69
#include "filewatcher.h"
1226 tsoots 70
#include "undomanager.h"
1525 cbradney 71
#include "units.h"
1633 fschmid 72
#include "extimageprops.h"
3695 cbradney 73
#include "page.h"
1655 cbradney 74
#include "pageitemattributes.h"
3625 avox 75
#include "pageitem_imageframe.h"
76
#include "pageitem_line.h"
77
#include "pageitem_pathtext.h"
78
#include "pageitem_polygon.h"
79
#include "pageitem_polyline.h"
80
#include "pageitem_textframe.h"
3053 avox 81
#include "pageselector.h"
1693 craig 82
#include "scpaths.h"
2103 cbradney 83
#include "actionmanager.h"
456 fschmid 84
#ifdef HAVE_TIFF
85
        #include <tiffio.h>
86
#endif
87
#ifdef HAVE_CMS
88
        #include CMS_INC
89
#endif
68 Franz 90
 
2529 craig 91
#include "scfontmetrics.h"
3942 cbradney 92
#include "scmessagebox.h"
2529 craig 93
#include "util.h"
2495 cbradney 94
#include "story.h"
2834 cbradney 95
#include "prefsmanager.h"
2868 fschmid 96
#include "rulermover.h"
3252 craig 97
#include "hyphenator.h"
3510 cbradney 98
#include "commonstrings.h"
5087 subik 99
#include "guidemanager.h"
5184 avox 100
#include "text/nlsconfig.h"
5746 fschmid 101
#ifdef HAVE_CAIRO
102
#include <cairo.h>
103
#endif
2495 cbradney 104
 
504 cbradney 105
using namespace std;
106
 
3 paul 107
 
3205 craig 108
 
3981 craig 109
ScribusView::ScribusView(QWidget *parent, ScribusDoc *doc) :
110
        QScrollView(parent, "s", WRepaintNoErase | WNorthWestGravity),
111
        Doc(doc),
112
        Prefs(&(PrefsManager::instance()->appPrefs)),
3982 craig 113
        undoManager(UndoManager::instance()),
114
        OldScale(0),
115
        GroupX(0), GroupY(0), GroupW(0), GroupH(0),
116
        oldW(-1), oldCp(-1),
117
        Mxp(-1), Myp(-1), Dxp(-1), Dyp(-1),
4663 cbradney 118
        frameResizeHandle(-1),
3982 craig 119
        SeRx(-1), SeRy(-1), GyM(-1), GxM(-1),
120
        ClRe(-1), ClRe2(-1),
121
        SegP1(-1), SegP2(-1),
122
        RotMode(0),
123
        DrHY(-1), DrVX(-1),
124
        EdPoints(true),
4705 cbradney 125
        m_MouseButtonPressed(false),   
4663 cbradney 126
        operItemMoving(false),
3982 craig 127
        MoveGY(false), MoveGX(false),
128
        HaveSelRect(false),
4663 cbradney 129
        operItemResizing(false),
3982 craig 130
        EditContour(false),
4049 cbradney 131
        //GroupSel(false),
3982 craig 132
        DraggedGroup(false),
133
        DraggedGroupFirst(false),
4663 cbradney 134
        operItemResizeInEditMode(false),
3982 craig 135
        MidButt(false),
136
        updateOn(true),
137
        FirstPoly(true),
138
        Magnify(false),
139
        MoveSym(false),
140
        previewMode(false),
141
        RCenter(-1,-1),
142
        RecordP(),
143
        Ready(false),
144
        oldX(0), oldY(0),
145
        _groupTransactionStarted(false),
146
        _isGlobalMode(true),
147
        evSpon(false),
148
        forceRedraw(false),
4654 cbradney 149
        Scale(Prefs->DisScale),
4704 cbradney 150
        m_vhRulerHW(17),
151
        m_cursorVisible(false)
3 paul 152
{
153
        setHScrollBarMode(QScrollView::AlwaysOn);
154
        setVScrollBarMode(QScrollView::AlwaysOn);
4654 cbradney 155
        setMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
3 paul 156
        setResizePolicy(Manual);
240 Franz 157
        viewport()->setBackgroundMode(PaletteBackground);
3 paul 158
        QFont fo = QFont(font());
2887 fschmid 159
        int posi = fo.pointSize()-2;
160
        fo.setPointSize(posi);
3689 cbradney 161
        unitSwitcher = new QComboBox( false, this, "unitSwitcher" );
2887 fschmid 162
        unitSwitcher->setFocusPolicy(QWidget::NoFocus);
163
        unitSwitcher->setFont(fo);
2966 fschmid 164
        for (int i=0;i<=unitGetMaxIndex();++i)
165
                unitSwitcher->insertItem(unitGetStrFromIndex(i));
3309 cbradney 166
        zoomSpinBox = new MSpinBox( 10, 3200, this, 2 );
167
        zoomSpinBox->setFont(fo);
168
        zoomSpinBox->setValue( 100 );
169
        zoomSpinBox->setFocusPolicy(QWidget::ClickFocus);
170
        zoomSpinBox->setSuffix( tr( " %" ) );
3053 avox 171
#if OPTION_USE_QTOOLBUTTON
172
        zoomOutToolbarButton = new QToolButton(this);
3274 fschmid 173
        zoomDefaultToolbarButton = new QToolButton(this);
3053 avox 174
        zoomInToolbarButton = new QToolButton(this);
3274 fschmid 175
        zoomDefaultToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
3053 avox 176
        zoomOutToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
177
        zoomInToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
178
#else
3274 fschmid 179
        zoomDefaultToolbarButton = new QPushButton(this);
180
        zoomDefaultToolbarButton->setFocusPolicy(QWidget::NoFocus);
181
        zoomDefaultToolbarButton->setDefault( false );
182
        zoomDefaultToolbarButton->setAutoDefault( false );
183
        zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
1822 cbradney 184
        zoomOutToolbarButton = new QPushButton(this);
185
        zoomOutToolbarButton->setFocusPolicy(QWidget::NoFocus);
3053 avox 186
        zoomOutToolbarButton->setDefault( false );
187
        zoomOutToolbarButton->setAutoDefault( false );
188
        zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
3274 fschmid 189
        zoomInToolbarButton = new QPushButton(this);
190
        zoomInToolbarButton->setFocusPolicy(QWidget::NoFocus);
3053 avox 191
        zoomInToolbarButton->setDefault( false );
192
        zoomInToolbarButton->setAutoDefault( false );
193
        zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
194
#endif
5287 cbradney 195
        //zoomDefaultToolbarButton->setText("1:1");
196
        zoomDefaultToolbarButton->setPixmap(loadIcon("16/zoom-original.png"));
197
        zoomOutToolbarButton->setPixmap(loadIcon("16/zoom-out.png"));
198
        zoomInToolbarButton->setPixmap(loadIcon("16/zoom-in.png"));
3309 cbradney 199
        pageSelector = new PageSelector(this, 1);
200
        pageSelector->setFont(fo);
201
        pageSelector->setFocusPolicy(QWidget::ClickFocus);
202
        layerMenu = new QComboBox( true, this, "LY" );
203
        layerMenu->setEditable(false);
204
        layerMenu->setFont(fo);
205
        layerMenu->setFocusPolicy(QWidget::NoFocus);
1612 cbradney 206
        horizRuler = new Hruler(this, Doc);
207
        vertRuler = new Vruler(this, Doc);
3309 cbradney 208
        rulerMover = new RulerMover(this);
209
        rulerMover->setFocusPolicy(QWidget::NoFocus);
3 paul 210
        Ready = true;
456 fschmid 211
        viewport()->setMouseTracking(true);
212
        setAcceptDrops(true);
213
        viewport()->setAcceptDrops(true);
214
        setDragAutoScroll(false);
3990 cbradney 215
        //languageChange();
456 fschmid 216
        Doc->DragP = false;
217
        Doc->leaveDrag = false;
1330 fschmid 218
        Doc->SubMode = -1;
5237 fschmid 219
        storedFramesShown = Doc->guidesSettings.framesShown;
5235 fschmid 220
        viewAsPreview = false;
5664 fschmid 221
#ifdef HAVE_CAIRO
222
        ScMW->scrActions["viewFit20"]->setOn(viewAsPreview);
223
#endif
1822 cbradney 224
        connect(zoomOutToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
225
        connect(zoomInToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
3274 fschmid 226
        connect(zoomDefaultToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoom100()));
4704 cbradney 227
        connect(zoomSpinBox, SIGNAL(valueChanged(int)), this, SLOT(setZoom()));
3309 cbradney 228
        connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
229
        connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
2966 fschmid 230
        connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
3 paul 231
        connect(this, SIGNAL(contentsMoving(int, int)), this, SLOT(setRulerPos(int, int)));
1443 tsoots 232
        connect(this, SIGNAL(HaveSel(int)), this, SLOT(selectionChanged()));
3 paul 233
}
234
 
2199 cbradney 235
void ScribusView::languageChange()
236
{
3309 cbradney 237
        disconnect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
2966 fschmid 238
        disconnect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
3309 cbradney 239
        zoomSpinBox->setSuffix( tr( " %" ) );
240
        layerMenu->setCurrentText( tr("Layer")+" 0");
2199 cbradney 241
        //CB TODO Convert to actions later
2966 fschmid 242
        unitSwitcher->clear();
2199 cbradney 243
        for (int i=0;i<=unitGetMaxIndex();++i)
2966 fschmid 244
                unitSwitcher->insertItem(unitGetStrFromIndex(i));
245
        unitSwitcher->setCurrentText(unitGetStrFromIndex(Doc->unitIndex()));
3309 cbradney 246
        connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
2966 fschmid 247
        connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
2199 cbradney 248
}
249
 
5235 fschmid 250
void ScribusView::togglePreview()
251
{
252
        viewAsPreview = !viewAsPreview;
5237 fschmid 253
        if (viewAsPreview)
254
        {
255
                storedFramesShown = Doc->guidesSettings.framesShown;
256
                Doc->guidesSettings.framesShown = false;
257
        }
258
        else
259
                Doc->guidesSettings.framesShown = storedFramesShown;
5664 fschmid 260
        ScMW->scrActions["viewFit20"]->setOn(viewAsPreview);
261
        ScMW->scrActions["viewShowMargins"]->setEnabled(!viewAsPreview);
262
        ScMW->scrActions["viewShowFrames"]->setEnabled(!viewAsPreview);
263
        ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!viewAsPreview);
264
        ScMW->scrActions["viewShowGrid"]->setEnabled(!viewAsPreview);
265
        ScMW->scrActions["viewShowGuides"]->setEnabled(!viewAsPreview);
266
        ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!viewAsPreview);
267
        ScMW->scrActions["viewShowBaseline"]->setEnabled(!viewAsPreview);
268
        ScMW->scrActions["viewShowTextChain"]->setEnabled(!viewAsPreview);
269
        ScMW->scrActions["viewShowTextControls"]->setEnabled(!viewAsPreview);
5235 fschmid 270
        updateContents();
271
}
272
 
2171 fschmid 273
void ScribusView::viewportPaintEvent ( QPaintEvent * p )
274
{
4011 cbradney 275
        #ifndef _WIN32
2171 fschmid 276
        if (p->spontaneous())
277
                evSpon = true;
4011 cbradney 278
        #endif
2171 fschmid 279
        QScrollView::viewportPaintEvent(p);
280
}
281
 
5373 fschmid 282
void ScribusView::drawContents(QPainter *psx, int clipx, int clipy, int clipw, int cliph)
456 fschmid 283
{
2891 cbradney 284
        if (Doc->isLoading())
456 fschmid 285
                return;
286
        if (!updateOn)
287
                return;
288
//      QTime tim;
289
//      tim.start();
290
        if ((clipw > 0) && (cliph > 0))
291
        {
3313 cbradney 292
                QPoint vr = contentsToViewport(QPoint(clipx, clipy));
5373 fschmid 293
                ScPainter *painter;
294
#ifdef HAVE_CAIRO
295
                struct Layer la;
296
                la.LNr = 0;
297
                int Lnr = 0;
298
                Level2Layer(Doc, &la, Lnr);
5433 fschmid 299
                QImage img = QImage(clipw, cliph, 32);
5746 fschmid 300
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 301
                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
302
                        painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
303
                else
304
                        painter = new ScPainter(&img, img.width(), img.height());
305
#else
5746 fschmid 306
                painter = new ScPainter(&img, img.width(), img.height(), 1.0, 0);
307
#endif
308
#else
5373 fschmid 309
                        painter = new ScPainter(viewport(), clipw, cliph, vr.x(), vr.y());
310
#endif
456 fschmid 311
                painter->clear(paletteBackgroundColor());
2848 fschmid 312
                painter->translate(-Doc->minCanvasCoordinate.x()*Scale, -Doc->minCanvasCoordinate.y()*Scale);
456 fschmid 313
                painter->translate(-clipx, -clipy);
314
                painter->setLineWidth(1);
315
                painter->setFillMode(ScPainter::Solid);
2538 fschmid 316
//              painter->translate(0.5, 0.5);
456 fschmid 317
                painter->setZoomFactor(1.0);
318
/* Draw Page Outlines */
3724 cbradney 319
                if (!Doc->masterPageMode())
456 fschmid 320
                {
3724 cbradney 321
                        uint docPagesCount=Doc->Pages->count();
5235 fschmid 322
                        if (viewAsPreview)
323
                        {
5233 fschmid 324
#ifdef HAVE_CAIRO
5235 fschmid 325
                                painter->newPath();
326
                                for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
5233 fschmid 327
                                {
5235 fschmid 328
                                        double x = Doc->Pages->at(a)->xOffset() * Scale;
329
                                        double y = Doc->Pages->at(a)->yOffset() * Scale;
330
                                        double w = Doc->Pages->at(a)->width() * Scale;
331
                                        double h = Doc->Pages->at(a)->height() * Scale;
332
                                        QRect drawRect = QRect(qRound(x), qRound(y), qRound(w)+5,qRound(h)+5);
333
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
334
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
335
                                        {
5664 fschmid 336
                                                QRect clR = QRect(qRound(x), qRound(y), qRound(w),qRound(h)).intersect(QRect(clipx, clipy, clipw, cliph));
337
                                                painter->moveTo( clR.x(), clR.y() );
338
                                                painter->lineTo( clR.x()+clR.width(), clR.y() );
339
                                                painter->lineTo( clR.x()+clR.width(), clR.y()+clR.height() );
340
                                                painter->lineTo( clR.x(), clR.y()+clR.height() );
5235 fschmid 341
                                                painter->closePath();
342
                                        }
5233 fschmid 343
                                }
5235 fschmid 344
                                painter->setClipPath();
345
#endif
456 fschmid 346
                        }
5664 fschmid 347
                        for (int a = 0; a < static_cast<int>(docPagesCount); ++a)
456 fschmid 348
                        {
5664 fschmid 349
                                int x = qRound(Doc->Pages->at(a)->xOffset() * Scale);
350
                                int y = qRound(Doc->Pages->at(a)->yOffset() * Scale);
351
                                int w = qRound(Doc->Pages->at(a)->width() * Scale);
352
                                int h = qRound(Doc->Pages->at(a)->height() * Scale);
353
                                QRect drawRect = QRect(x, y, w+5, h+5);
354
                                drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
355
                                if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
456 fschmid 356
                                {
5373 fschmid 357
#ifdef HAVE_CAIRO
5752 fschmid 358
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 359
                                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
360
                                                painter->beginLayer(1.0, 0);
5752 fschmid 361
#else
362
                                        painter->beginLayer(1.0, 0);
5373 fschmid 363
#endif
5752 fschmid 364
#endif
5664 fschmid 365
                                        painter->setFillMode(ScPainter::Solid);
366
                                        painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
367
                                        painter->setBrush(QColor(128,128,128));
368
                                        painter->drawRect(x+5, y+5, w, h);
369
                                        if (a == Doc->currentPageNumber())
370
                                                painter->setPen(red, 2, SolidLine, FlatCap, MiterJoin);
371
                                        else
5235 fschmid 372
                                                painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
5664 fschmid 373
                                        painter->setBrush(Doc->papColor);
374
                                        painter->drawRect(x, y, w, h);
375
                                        if ((Doc->guidesSettings.before) && (!viewAsPreview))
376
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
5373 fschmid 377
#ifdef HAVE_CAIRO
5752 fschmid 378
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 379
                                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
380
                                                painter->endLayer();
5752 fschmid 381
#else
382
                                        painter->endLayer();
5373 fschmid 383
#endif
5752 fschmid 384
#endif
456 fschmid 385
                                }
5664 fschmid 386
                        }
5601 fschmid 387
#ifdef HAVE_CAIRO
5752 fschmid 388
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 389
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
390
                                painter->beginLayer(1.0, 0);
5752 fschmid 391
#else
392
                        painter->beginLayer(1.0, 0);
5660 fschmid 393
#endif
5752 fschmid 394
#endif
5664 fschmid 395
                        for (uint a = 0; a < docPagesCount; ++a)
396
                        {
397
                                DrawMasterItems(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
398
                        }
399
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5604 fschmid 400
#ifdef HAVE_CAIRO
5752 fschmid 401
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5664 fschmid 402
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
403
                                painter->endLayer();
5752 fschmid 404
#else
405
                        painter->endLayer();
5604 fschmid 406
#endif
5752 fschmid 407
#endif
5664 fschmid 408
                        if ((!Doc->guidesSettings.before) && (!viewAsPreview))
409
                        {
410
                                for (uint a = 0; a < docPagesCount; ++a)
5235 fschmid 411
                                {
5664 fschmid 412
                                        int x = static_cast<int>(Doc->Pages->at(a)->xOffset() * Scale);
413
                                        int y = static_cast<int>(Doc->Pages->at(a)->yOffset() * Scale);
414
                                        int w = static_cast<int>(Doc->Pages->at(a)->width() * Scale);
415
                                        int h = static_cast<int>(Doc->Pages->at(a)->height() * Scale);
416
                                        QRect drawRect = QRect(x, y, w+5, h+5);
417
                                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
418
                                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
419
                                                DrawPageMarks(painter, Doc->Pages->at(a), QRect(clipx, clipy, clipw, cliph));
5235 fschmid 420
                                }
456 fschmid 421
                        }
422
                }
423
                else
424
                {
425
                        int x = static_cast<int>(Doc->ScratchLeft * Scale);
426
                        int y = static_cast<int>(Doc->ScratchTop * Scale);
5087 subik 427
                        int w = static_cast<int>(Doc->currentPage()->width() * Scale);
428
                        int h = static_cast<int>(Doc->currentPage()->height() * Scale);
2848 fschmid 429
                        QRect drawRect = QRect(x, y, w+5, h+5);
430
                        drawRect.moveBy(qRound(-Doc->minCanvasCoordinate.x() * Scale), qRound(-Doc->minCanvasCoordinate.y() * Scale));
431
                        if (drawRect.intersects(QRect(clipx, clipy, clipw, cliph)))
456 fschmid 432
                        {
5373 fschmid 433
#ifdef HAVE_CAIRO
5752 fschmid 434
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 435
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
436
                                        painter->beginLayer(1.0, 0);
5752 fschmid 437
#else
438
                                painter->beginLayer(1.0, 0);
5373 fschmid 439
#endif
5752 fschmid 440
#endif
456 fschmid 441
                                painter->setFillMode(ScPainter::Solid);
442
                                painter->setPen(black, 1, SolidLine, FlatCap, MiterJoin);
443
                                painter->setBrush(QColor(128,128,128));
444
                                painter->drawRect(x+5, y+5, w, h);
445
                                painter->setBrush(Doc->papColor);
446
                                painter->drawRect(x, y, w, h);
1187 fschmid 447
                                if (Doc->guidesSettings.before)
5087 subik 448
                                        DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
5373 fschmid 449
#ifdef HAVE_CAIRO
5752 fschmid 450
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5373 fschmid 451
                                if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
452
                                        painter->endLayer();
5752 fschmid 453
#else
454
                                painter->endLayer();
5373 fschmid 455
#endif
5752 fschmid 456
#endif
456 fschmid 457
                        }
5604 fschmid 458
#ifdef HAVE_CAIRO
5752 fschmid 459
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5604 fschmid 460
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
461
                                painter->beginLayer(1.0, 0);
5752 fschmid 462
#else
463
                        painter->beginLayer(1.0, 0);
5604 fschmid 464
#endif
5752 fschmid 465
#endif
456 fschmid 466
                        DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5604 fschmid 467
#ifdef HAVE_CAIRO
5752 fschmid 468
#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 8)
5604 fschmid 469
                        if ((Doc->layerCount() > 1) || (la.transparency != 1.0))
470
                                painter->endLayer();
5752 fschmid 471
#else
472
                        painter->endLayer();
5604 fschmid 473
#endif
5752 fschmid 474
#endif
2848 fschmid 475
                        if ((!Doc->guidesSettings.before) && (drawRect.intersects(QRect(clipx, clipy, clipw, cliph))))
5087 subik 476
                                DrawPageMarks(painter, Doc->currentPage(), QRect(clipx, clipy, clipw, cliph));
456 fschmid 477
                }
5235 fschmid 478
                if (((Doc->m_Selection->count() != 0) || (linkedFramesToShow.count() != 0))  && (!viewAsPreview))
456 fschmid 479
                {
480
                        double z = painter->zoomFactor();
481
                        painter->setZoomFactor(Scale);
482
                        painter->save();
1957 cbradney 483
                        PageItem *currItem;
879 fschmid 484
                        if ((Doc->guidesSettings.linkShown) && (linkedFramesToShow.count() != 0))
1957 cbradney 485
                                currItem = linkedFramesToShow.at(0);
705 fschmid 486
                        else
808 fschmid 487
                        {
488
                                if (linkedFramesToShow.count() != 0)
1957 cbradney 489
                                        currItem = linkedFramesToShow.at(0);
808 fschmid 490
                                else
4847 cbradney 491
                                        currItem = Doc->m_Selection->itemAt(0);
808 fschmid 492
                        }
3594 cbradney 493
                        //Draw the frame links
2603 cbradney 494
                        if ((((Doc->appMode == modeLinkFrames) || (Doc->appMode == modeUnlinkFrames))
1957 cbradney 495
                                   && (currItem->itemType() == PageItem::TextFrame)) || (Doc->guidesSettings.linkShown))
456 fschmid 496
                        {
1957 cbradney 497
                                PageItem *nextItem = currItem;
879 fschmid 498
                                if (Doc->guidesSettings.linkShown)
456 fschmid 499
                                {
705 fschmid 500
                                        for (uint lks = 0; lks < linkedFramesToShow.count(); ++lks)
501
                                        {
1957 cbradney 502
                                                nextItem = linkedFramesToShow.at(lks);
503
                                                while (nextItem != 0)
705 fschmid 504
                                                {
3954 cbradney 505
                                                        //Calculate the link points of the frames
3903 cbradney 506
                                                        double x11 = nextItem->xPos();
507
                                                        double y11 = nextItem->yPos();
3934 cbradney 508
                                                        double x12 = x11+nextItem->width();
509
                                                        double y12 = y11+nextItem->height();
3708 cbradney 510
                                                        double x1mid = x11+(x12-x11)/2;
511
                                                        double y1mid = y11+(y12-y11)/2;
814 cbradney 512
 
3934 cbradney 513
                                                        if (nextItem->rotation()!=0.000)
814 cbradney 514
                                                        {
3934 cbradney 515
                                                                FPoint tempPoint(0,0, x11, y11, nextItem->rotation(), 1, 1);
814 cbradney 516
                                                                x11=tempPoint.x();
517
                                                                y11=tempPoint.y();
3934 cbradney 518
                                                                FPoint tempPoint2(0,0, x12, y12, nextItem->rotation(), 1, 1);
3242 cbradney 519
                                                                x12=tempPoint2.x();
520
                                                                y12=tempPoint2.y();
3934 cbradney 521
                                                                FPoint tempPoint3(0,0, x1mid, y1mid, nextItem->rotation(), 1, 1);
3242 cbradney 522
                                                                x1mid=tempPoint3.x();
523
                                                                y1mid=tempPoint3.y();
814 cbradney 524
                                                        }
525
 
1485 tsoots 526
 
814 cbradney 527
                                                        double a1, b1, a2, b2;
823 fschmid 528
                                                        a1 = a2 = b1 = b2 = 0;
5732 avox 529
                                                        if (nextItem->NextBox != NULL)
814 cbradney 530
                                                        {
3903 cbradney 531
                                                                double x21 = nextItem->NextBox->xPos();
532
                                                                double y21 = nextItem->NextBox->yPos();
3934 cbradney 533
                                                                double x22 = x21+nextItem->NextBox->width();
534
                                                                double y22 = y21+nextItem->NextBox->height();
535
                                                                double x2mid = x21 + nextItem->NextBox->width()/2;
536
                                                                double y2mid = y21 + nextItem->NextBox->height()/2;
3708 cbradney 537
                                                                //x2mid = x21+(x22-x21)/2;
538
                                                                //y2mid = y21+(y22-y21)/2;
814 cbradney 539
 
3934 cbradney 540
                                                                if (nextItem->NextBox->rotation()!=0.000)
814 cbradney 541
                                                                {
3934 cbradney 542
                                                                        FPoint tempPoint(0,0, x21, y21, nextItem->NextBox->rotation(), 1, 1);
814 cbradney 543
                                                                        x21=tempPoint.x();
544
                                                                        y21=tempPoint.y();
3934 cbradney 545
                                                                        FPoint tempPoint2(0,0, x22, y22, nextItem->NextBox->rotation(), 1, 1);
3242 cbradney 546
                                                                        x22=tempPoint2.x();
547
                                                                        y22=tempPoint2.y();
3934 cbradney 548
                                                                        FPoint tempPoint3(0,0, x2mid, y2mid, nextItem->NextBox->rotation(), 1, 1);
3242 cbradney 549
                                                                        x2mid=tempPoint3.x();
550
                                                                        y2mid=tempPoint3.y();
814 cbradney 551
                                                                }
1485 tsoots 552
 
814 cbradney 553
                                                                if (x22<x11) { a1 = x11; a2 = x22; }
554
                                                                if (x21>x12) { a1 = x12; a2 = x21; }
555
                                                                if (y22<y11) { b1 = y11; b2 = y22; }
556
                                                                if (y21>y12) { b1 = y12; b2 = y21; }
557
 
558
                                                                if (x21<x12 && x21>x11) { a1 = x1mid; a2 = x2mid; }
559
                                                                if (x21<x11 && x22>x11) { a1 = x1mid; a2 = x2mid; }
560
 
561
                                                                if (y21<y12 && y21>y11) { b1 = y1mid; b2 = y2mid; }
562
                                                                if (y21<y11 && y22>y11) { b1 = y1mid; b2 = y2mid; }
563
 
564
                                                        }
3954 cbradney 565
                                                        //Draw the link frame lines
3934 cbradney 566
                                                        FPoint Start(a1-nextItem->xPos(), b1-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3903 cbradney 567
                                                        //FPoint Start = transformPoint(FPoint(nextItem->Width/2, nextItem->Height), nextItem->xPos(), nextItem->yPos(), nextItem->Rot, 1, 1);
1957 cbradney 568
                                                        nextItem = nextItem->NextBox;
569
                                                        if (nextItem != NULL)
705 fschmid 570
                                                        {
3934 cbradney 571
                                                                FPoint End(a2-nextItem->xPos(), b2-nextItem->yPos(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 572
                                                                drawLinkFrameLine(painter, Start, End);
705 fschmid 573
                                                        }
574
                                                }
575
                                        }
456 fschmid 576
                                }
705 fschmid 577
                                else
456 fschmid 578
                                {
1957 cbradney 579
                                        while (nextItem != 0)
456 fschmid 580
                                        {
1957 cbradney 581
                                                if (nextItem->BackBox != 0)
582
                                                        nextItem = nextItem->BackBox;
705 fschmid 583
                                                else
584
                                                        break;
456 fschmid 585
                                        }
1957 cbradney 586
                                        while (nextItem != 0)
705 fschmid 587
                                        {
3934 cbradney 588
                                                FPoint Start(nextItem->width()/2, nextItem->height(), nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
1957 cbradney 589
                                                nextItem = nextItem->NextBox;
3954 cbradney 590
                                                //Draw the link frame indicator for a new link
591
                                                //CB unsure if we need to do this
1957 cbradney 592
                                                if (nextItem != 0)
705 fschmid 593
                                                {
3934 cbradney 594
                                                        FPoint End(nextItem->width()/2, 0, nextItem->xPos(), nextItem->yPos(), nextItem->rotation(), 1, 1);
3954 cbradney 595
                                                        drawLinkFrameLine(painter, Start, End);
705 fschmid 596
                                                }
597
                                        }
456 fschmid 598
                                }
599
                        }
600
                        painter->setLineWidth(1);
601
                        painter->setPenOpacity(1.0);
602
                        painter->restore();
603
                        painter->setZoomFactor(z);
604
                }
605
                painter->end();
5373 fschmid 606
#ifdef HAVE_CAIRO
607
                psx->drawImage(clipx, clipy, img);
608
#endif
456 fschmid 609
                delete painter;
3708 cbradney 610
                painter=NULL;
456 fschmid 611
        }
4847 cbradney 612
        if (Doc->m_Selection->count() != 0)
456 fschmid 613
        {
4847 cbradney 614
                PageItem *currItem = Doc->m_Selection->itemAt(0);
1957 cbradney 615
                currItem->paintObj();
3934 cbradney 616
                if ((Doc->EditClip) && (currItem->isSelected()))
2934 fschmid 617
                {
618
                if (EditContour)
619
                        MarkClip(currItem, currItem->ContourLine, true);
620
                else
621
                        MarkClip(currItem, currItem->PoLine, true);
622
                }
4847 cbradney 623
                if (Doc->m_Selection->isMultipleSelection())
456 fschmid 624
                {
625
                        setGroupRect();
626
                        paintGroupRect();
627
                }
628
        }
2603 cbradney 629
        if (Doc->appMode == modeEdit)
456 fschmid 630
                slotDoCurs(true);
2603 cbradney 631
        if (Doc->appMode == modeEditGradientVectors)
735 fschmid 632
        {
4847 cbradney 633
                PageItem *currItem = Doc->m_Selection->itemAt(0);
735 fschmid 634
                QPainter p;
635
                p.begin(viewport());
636
                ToView(&p);
1957 cbradney 637
                Transform(currItem, &p);
735 fschmid 638
                p.setPen(QPen(blue, 1, SolidLine, FlatCap, MiterJoin));
639
                p.setBrush(NoBrush);
1957 cbradney 640
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
735 fschmid 641
                p.setPen(QPen(magenta, 8, SolidLine, RoundCap, MiterJoin));
1957 cbradney 642
                p.drawLine(QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)), QPoint(qRound(currItem->GrStartX), qRound(currItem->GrStartY)));
643
                p.drawLine(QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)), QPoint(qRound(currItem->GrEndX), qRound(currItem->GrEndY)));
735 fschmid 644
                p.end();
645
        }
2171 fschmid 646
        evSpon = false;
2951 fschmid 647
        forceRedraw = false;
456 fschmid 648
//      qDebug( "Time elapsed: %d ms", tim.elapsed() );
649
}
650
 
651
void ScribusView::DrawMasterItems(ScPainter *painter, Page *page, QRect clip)
652
{
653
        double z = painter->zoomFactor();
2877 cbradney 654
        if (!page->MPageNam.isEmpty())
456 fschmid 655
        {
656
                Page* Mp = Doc->MasterPages.at(Doc->MasterNames[page->MPageNam]);
657
                if (page->FromMaster.count() != 0)
658
                {
4689 mrdocs 659
                        //QPainter p;
3313 cbradney 660
                        int Lnr;
661
                        struct Layer ll;
662
                        PageItem *currItem;
663
                        ll.isViewable = false;
664
                        ll.LNr = 0;
456 fschmid 665
                        Lnr = 0;
2951 fschmid 666
                        uint layerCount=Doc->layerCount();
2937 cbradney 667
                        for (uint la = 0; la < layerCount; ++la)
456 fschmid 668
                        {
669
                                Level2Layer(Doc, &ll, Lnr);
1874 fschmid 670
                                bool pr = true;
671
                                if ((previewMode) && (!ll.isPrintable))
672
                                        pr = false;
673
                                if ((ll.isViewable) && (pr))
456 fschmid 674
                                {
5373 fschmid 675
#ifdef HAVE_CAIRO
676
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 677
                                                painter->beginLayer(ll.transparency, ll.blendMode);
5373 fschmid 678
#endif
3689 cbradney 679
                                        uint pageFromMasterCount=page->FromMaster.count();
680
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 681
                                        {
1957 cbradney 682
                                                currItem = page->FromMaster.at(a);
683
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 684
                                                        continue;
3200 cbradney 685
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 686
                                                        continue;
4698 cbradney 687
                                                if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 688
                                                        continue;
4401 fschmid 689
                                                currItem->savedOwnPage = currItem->OwnPage;
690
//                                              int savedOwnPage = currItem->OwnPage;
3903 cbradney 691
                                                double OldX = currItem->xPos();
692
                                                double OldY = currItem->yPos();
1957 cbradney 693
                                                double OldBX = currItem->BoundingX;
694
                                                double OldBY = currItem->BoundingY;
3200 cbradney 695
                                                currItem->OwnPage = page->pageNr();
1957 cbradney 696
                                                if (!currItem->ChangedMasterItem)
456 fschmid 697
                                                {
4644 cbradney 698
                                                        //Hack to not check for undo changes, indicate drawing only
699
                                                        currItem->moveBy(-Mp->xOffset() + page->xOffset(), -Mp->yOffset() + page->yOffset(), true);
3200 cbradney 700
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
701
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
456 fschmid 702
                                                }
5387 avox 703
                                                if (!evSpon || forceRedraw)
5362 avox 704
                                                        currItem->invalid = true;
3656 cbradney 705
                                                QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 706
                                                if (clip.intersects(oldR))
1957 cbradney 707
                                                        currItem->DrawObj(painter, clip);
4401 fschmid 708
                                                currItem->OwnPage = currItem->savedOwnPage;
709
//                                              currItem->OwnPage = savedOwnPage;
1957 cbradney 710
                                                if (!currItem->ChangedMasterItem)
456 fschmid 711
                                                {
4644 cbradney 712
                                                        //Hack to not check for undo changes, indicate drawing only
713
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 714
                                                        currItem->BoundingX = OldBX;
715
                                                        currItem->BoundingY = OldBY;
456 fschmid 716
                                                }
717
                                        }
3689 cbradney 718
                                        for (uint a = 0; a < pageFromMasterCount; ++a)
456 fschmid 719
                                        {
1957 cbradney 720
                                                currItem = page->FromMaster.at(a);
721
                                                if (currItem->LayerNr != ll.LNr)
456 fschmid 722
                                                        continue;
1957 cbradney 723
                                                if (!currItem->isTableItem)
456 fschmid 724
                                                        continue;
3200 cbradney 725
                                                if ((currItem->OwnPage != -1) && (currItem->OwnPage != static_cast<int>(Mp->pageNr())))
456 fschmid 726
                                                        continue;
3903 cbradney 727
                                                double OldX = currItem->xPos();
728
                                                double OldY = currItem->yPos();
1957 cbradney 729
                                                double OldBX = currItem->BoundingX;
730
                                                double OldBY = currItem->BoundingY;
731
                                                if (!currItem->ChangedMasterItem)
456 fschmid 732
                                                {
4644 cbradney 733
                                                        //Hack to not check for undo changes, indicate drawing only
734
                                                        currItem->setXYPos(OldX - Mp->xOffset() + page->xOffset(), OldY - Mp->yOffset() + page->yOffset(), true);
3200 cbradney 735
                                                        currItem->BoundingX = OldBX - Mp->xOffset() + page->xOffset();
736
                                                        currItem->BoundingY = OldBY - Mp->yOffset() + page->yOffset();
456 fschmid 737
                                                }
3656 cbradney 738
                                                QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 739
                                                if (clip.intersects(oldR))
456 fschmid 740
                                                {
741
                                                        painter->setZoomFactor(Scale);
742
                                                        painter->save();
3903 cbradney 743
                                                        painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
3934 cbradney 744
                                                        painter->rotate(currItem->rotation());
4546 subik 745
                                                        if (currItem->lineColor() != CommonStrings::None)
456 fschmid 746
                                                        {
747
                                                                QColor tmp;
1957 cbradney 748
                                                                currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
749
                                                                if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 750
                                                                {
4580 cbradney 751
                                                                        painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 752
                                                                        if (currItem->TopLine)
3934 cbradney 753
                                                                                painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 754
                                                                        if (currItem->RightLine)
3934 cbradney 755
                                                                                painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 756
                                                                        if (currItem->BottomLine)
3934 cbradney 757
                                                                                painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 758
                                                                        if (currItem->LeftLine)
3934 cbradney 759
                                                                                painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 760
                                                                }
761
                                                        }
762
                                                        painter->restore();
763
                                                }
1957 cbradney 764
                                                if (!currItem->ChangedMasterItem)
456 fschmid 765
                                                {
4644 cbradney 766
                                                        //Hack to not check for undo changes, indicate drawing only
767
                                                        currItem->setXYPos(OldX, OldY, true);
1957 cbradney 768
                                                        currItem->BoundingX = OldBX;
769
                                                        currItem->BoundingY = OldBY;
456 fschmid 770
                                                }
771
                                        }
5373 fschmid 772
#ifdef HAVE_CAIRO
773
                                        if ((layerCount > 1) || (ll.transparency != 1.0))
774
                                                painter->endLayer();
775
#endif
456 fschmid 776
                                }
777
                                Lnr++;
778
                        }
779
                }
780
        }
781
        painter->setZoomFactor(z);
782
}
783
 
784
void ScribusView::DrawPageItems(ScPainter *painter, QRect clip)
785
{
705 fschmid 786
        linkedFramesToShow.clear();
456 fschmid 787
        double z = painter->zoomFactor();
3727 cbradney 788
        if (Doc->Items->count() != 0)
456 fschmid 789
        {
3313 cbradney 790
                int Lnr=0;
791
                struct Layer ll;
792
                PageItem *currItem;
793
                ll.isViewable = false;
794
                ll.LNr = 0;
2951 fschmid 795
                uint layerCount=Doc->layerCount();
3689 cbradney 796
                int docCurrPageNo=static_cast<int>(Doc->currentPageNumber());
2937 cbradney 797
                for (uint la2 = 0; la2 < layerCount; ++la2)
456 fschmid 798
                {
799
                        Level2Layer(Doc, &ll, Lnr);
1874 fschmid 800
                        bool pr = true;
801
                        if ((previewMode) && (!ll.isPrintable))
802
                                pr = false;
803
                        if ((ll.isViewable) && (pr))
456 fschmid 804
                        {
5373 fschmid 805
#ifdef HAVE_CAIRO
806
                                if ((layerCount > 1) || (ll.transparency != 1.0))
5375 fschmid 807
                                        painter->beginLayer(ll.transparency, ll.blendMode);
5373 fschmid 808
#endif
3727 cbradney 809
                                QPtrListIterator<PageItem> docItem(*Doc->Items);
3689 cbradney 810
                                while ( (currItem = docItem.current()) != 0)
811
                                {
2434 fschmid 812
                                        ++docItem;
1957 cbradney 813
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 814
                                                continue;
4698 cbradney 815
                                        if ((previewMode) && (!currItem->printEnabled()))
1874 fschmid 816
                                                continue;
3724 cbradney 817
                                        if ((Doc->masterPageMode()) && ((currItem->OwnPage != -1) && (currItem->OwnPage != docCurrPageNo)))
456 fschmid 818
                                                continue;
3724 cbradney 819
                                        if (!Doc->masterPageMode() && !currItem->OnMasterPage.isEmpty())
1781 fschmid 820
                                        {
5685 cbradney 821
                                                if (currItem->OnMasterPage != Doc->currentPage()->pageName())
1781 fschmid 822
                                                        continue;
823
                                        }
3656 cbradney 824
                                        QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 825
                                        if (clip.intersects(oldR))
456 fschmid 826
                                        {
5362 avox 827
                                                if (!evSpon || forceRedraw)
828
                                                        currItem->invalid = true;
4704 cbradney 829
//                                              if ((!m_MouseButtonPressed) || (Doc->EditClip))
5637 fschmid 830
                                                currItem->DrawObj(painter, clip);
5362 avox 831
//                                              currItem->Redrawn = true;
3625 avox 832
                                                if ((currItem->asTextFrame()) && ((currItem->NextBox != 0) || (currItem->BackBox != 0)))
705 fschmid 833
                                                {
1957 cbradney 834
                                                        PageItem *nextItem = currItem;
835
                                                        while (nextItem != 0)
705 fschmid 836
                                                        {
1957 cbradney 837
                                                                if (nextItem->BackBox != 0)
838
                                                                        nextItem = nextItem->BackBox;
705 fschmid 839
                                                                else
840
                                                                        break;
841
                                                        }
1957 cbradney 842
                                                        if (linkedFramesToShow.find(nextItem) == -1)
843
                                                                linkedFramesToShow.append(nextItem);
705 fschmid 844
                                                }
3934 cbradney 845
                                                if ((Doc->appMode == modeEdit) && (currItem->isSelected()) && (currItem->itemType() == PageItem::TextFrame))
456 fschmid 846
                                                {
1764 cbradney 847
                                                        //CB 230305 Stop redrawing the horizontal ruler if it hasnt changed when typing text!!!
3934 cbradney 848
                                                        if ((qRound(horizRuler->ItemPos*10000) != qRound((currItem->xPos())*10000)) || (qRound(horizRuler->ItemEndPos*10000) != qRound(((currItem->xPos()+currItem->width()) )*10000)))
1764 cbradney 849
                                                        {
5569 avox 850
                                                                horizRuler->setItem(currItem);
4546 subik 851
                                                                if (currItem->lineColor() != CommonStrings::None)
4580 cbradney 852
                                                                        horizRuler->lineCorr = currItem->lineWidth() / 2.0;
1764 cbradney 853
                                                                else
854
                                                                        horizRuler->lineCorr = 0;
1957 cbradney 855
                                                                horizRuler->ColGap = currItem->ColGap;
856
                                                                horizRuler->Cols = currItem->Cols;
3988 cbradney 857
                                                                horizRuler->Extra = currItem->textToFrameDistLeft();
858
                                                                horizRuler->RExtra = currItem->textToFrameDistRight();
5569 avox 859
                                                                horizRuler->First = currItem->currentStyle().firstIndent();
860
                                                                horizRuler->Indent = currItem->currentStyle().leftMargin();
861
                                                                double columnWidth = (currItem->width() - (currItem->columnGap() * (currItem->columns() - 1))
862
                                                                        - currItem->textToFrameDistLeft() - currItem->textToFrameDistLeft()
863
                                                                        - 2*horizRuler->lineCorr) / currItem->columns();
864
                                                                horizRuler->RMargin = columnWidth - currItem->currentStyle().rightMargin();
3988 cbradney 865
                                                                if (currItem->imageFlippedH() || (currItem->reversed()))
1764 cbradney 866
                                                                        horizRuler->Revers = true;
867
                                                                else
868
                                                                        horizRuler->Revers = false;
869
                                                                horizRuler->ItemPosValid = true;
5569 avox 870
                                                                horizRuler->TabValues = currItem->currentStyle().tabValues();
1764 cbradney 871
                                                                horizRuler->repaint();
872
                                                        }
456 fschmid 873
                                                }
874
                                        }
875
                                }
3727 cbradney 876
                                QPtrListIterator<PageItem> docItem2(*Doc->Items);
3689 cbradney 877
                                while ( (currItem = docItem2.current()) != 0 )
878
                                {
2538 fschmid 879
                                        ++docItem2;
1957 cbradney 880
                                        if (currItem->LayerNr != ll.LNr)
456 fschmid 881
                                                continue;
1957 cbradney 882
                                        if (!currItem->isTableItem)
456 fschmid 883
                                                continue;
3656 cbradney 884
                                        QRect oldR(currItem->getRedrawBounding(Scale));
537 fschmid 885
                                        if (clip.intersects(oldR))
456 fschmid 886
                                        {
887
                                                painter->setZoomFactor(Scale);
888
                                                painter->save();
3903 cbradney 889
                                                painter->translate(currItem->xPos()*Scale, currItem->yPos()*Scale);
3934 cbradney 890
                                                painter->rotate(currItem->rotation());
4546 subik 891
                                                if (currItem->lineColor() != CommonStrings::None)
456 fschmid 892
                                                {
893
                                                        QColor tmp;
1957 cbradney 894
                                                        currItem->SetFarbe(&tmp, currItem->lineColor(), currItem->lineShade());
895
                                                        if ((currItem->TopLine) || (currItem->RightLine) || (currItem->BottomLine) || (currItem->LeftLine))
456 fschmid 896
                                                        {
4580 cbradney 897
                                                                painter->setPen(tmp, currItem->lineWidth(), currItem->PLineArt, Qt::SquareCap, currItem->PLineJoin);
1957 cbradney 898
                                                                if (currItem->TopLine)
3934 cbradney 899
                                                                        painter->drawLine(FPoint(0.0, 0.0), FPoint(currItem->width(), 0.0));
1957 cbradney 900
                                                                if (currItem->RightLine)
3934 cbradney 901
                                                                        painter->drawLine(FPoint(currItem->width(), 0.0), FPoint(currItem->width(), currItem->height()));
1957 cbradney 902
                                                                if (currItem->BottomLine)
3934 cbradney 903
                                                                        painter->drawLine(FPoint(currItem->width(), currItem->height()), FPoint(0.0, currItem->height()));
1957 cbradney 904
                                                                if (currItem->LeftLine)
3934 cbradney 905
                                                                        painter->drawLine(FPoint(0.0, currItem->height()), FPoint(0.0, 0.0));
456 fschmid 906
                                                        }
907
                                                }
908
                                                painter->restore();
909
                                        }
910
                                }
5373 fschmid 911
#ifdef HAVE_CAIRO
912
                                if ((layerCount > 1) || (ll.transparency != 1.0))
913
                                        painter->endLayer();
914
#endif
456 fschmid 915
                        }
916
                        Lnr++;
917
                }
918
        }
919
        painter->setZoomFactor(z);
920
}
921
 
5166 fschmid 922
void ScribusView::DrawPageMarks(ScPainter *p, Page *page, QRect clip)
456 fschmid 923
{
924
        double z = p->zoomFactor();
925
        p->save();
926
        p->setZoomFactor(Scale);
3200 cbradney 927
        p->translate(page->xOffset() * Scale, page->yOffset() * Scale);
4704 cbradney 928
        double lineWidth = 0.5 / Scale;
929
        p->setLineWidth(lineWidth);
3226 cbradney 930
        double pageHeight=page->height();
931
        double pageWidth=page->width();
3962 cbradney 932
        //Draw the margins
879 fschmid 933
        if (Doc->guidesSettings.marginsShown)
456 fschmid 934
        {
879 fschmid 935
                p->setPen(Doc->guidesSettings.margColor);
1065 cbradney 936
                if (Doc->marginColored)
456 fschmid 937
                {
879 fschmid 938
                        p->setBrush(Doc->guidesSettings.margColor);
3226 cbradney 939
                        p->drawRect(0, 0, pageWidth, page->Margins.Top);
940
                        p->drawRect(0, page->Margins.Top, page->Margins.Left, pageHeight - page->Margins.Top);
941
                        p->drawRect(page->Margins.Left, pageHeight - page->Margins.Bottom, pageWidth - page->Margins.Right - page->Margins.Left, page->Margins.Bottom);
942
                        p->drawRect(pageWidth - page->Margins.Right, page->Margins.Top, page->Margins.Right, pageHeight-page->Margins.Top);
456 fschmid 943
                }
879 fschmid 944
                p->setPen(Doc->guidesSettings.margColor);
3226 cbradney 945
                p->drawLine(FPoint(0, page->Margins.Top), FPoint(pageWidth, page->Margins.Top));
946
                p->drawLine(FPoint(0, pageHeight - page->Margins.Bottom), FPoint(pageWidth, pageHeight - page->Margins.Bottom));
947
                p->drawLine(FPoint(page->Margins.Left, 0), FPoint(page->Margins.Left, pageHeight));
948
                p->drawLine(FPoint(pageWidth - page->Margins.Right, 0), FPoint(pageWidth - page->Margins.Right, pageHeight));
456 fschmid 949
        }
3962 cbradney 950
        //Draw the baseline grid
879 fschmid 951
        if (Doc->guidesSettings.baseShown)
456 fschmid 952
        {
4704 cbradney 953
                p->setPen(Doc->guidesSettings.baseColor, lineWidth, SolidLine, FlatCap, MiterJoin);
3226 cbradney 954
                for (double yg = Doc->typographicSettings.offsetBaseGrid; yg < pageHeight; yg += Doc->typographicSettings.valueBaseGrid)
955
                        p->drawLine(FPoint(0, yg), FPoint(pageWidth, yg));
456 fschmid 956
        }
3962 cbradney 957
        //Draw the grid lines
879 fschmid 958
        if (Doc->guidesSettings.gridShown)
456 fschmid 959
        {
5233 fschmid 960
                double lowerBx = QMAX(clip.x() / Scale + Doc->minCanvasCoordinate.x() - page->xOffset(), 0);
961
                double lowerBy = QMAX(clip.y() / Scale + Doc->minCanvasCoordinate.y() - page->yOffset(), 0);
962
                double highBx = QMIN(lowerBx + clip.width() / Scale, pageWidth);
963
                double highBy = QMIN(lowerBy + clip.height() / Scale, pageHeight);
456 fschmid 964
                if (Scale > 0.49)
965
                {
966
                        double i,start;
879 fschmid 967
                        i = Doc->guidesSettings.majorGrid;
4704 cbradney 968
                        p->setPen(Doc->guidesSettings.majorColor, lineWidth, SolidLine, FlatCap, MiterJoin);
5233 fschmid 969
                        start=floor(lowerBy/i);
456 fschmid 970
                        start*=i;
5233 fschmid 971
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 972
                        {
5233 fschmid 973
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
5166 fschmid 974
                        }
5233 fschmid 975
                        start=floor(lowerBx/i);
456 fschmid 976
                        start*=i;
5233 fschmid 977
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 978
                        {
5233 fschmid 979
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
5166 fschmid 980
                        }
879 fschmid 981
                        i = Doc->guidesSettings.minorGrid;
4704 cbradney 982
                        p->setPen(Doc->guidesSettings.minorColor, lineWidth, DotLine, FlatCap, MiterJoin);
5233 fschmid 983
                        start=floor(lowerBy/i);
456 fschmid 984
                        start*=i;
5233 fschmid 985
                        for (double b = start; b <= highBy; b+=i)
5166 fschmid 986
                        {
5233 fschmid 987
                                p->drawLine(FPoint(QMAX(lowerBx, 0), b), FPoint(QMIN(pageWidth, highBx), b));
5166 fschmid 988
                        }
5233 fschmid 989
                        start=floor(lowerBx/i);
456 fschmid 990
                        start*=i;
5233 fschmid 991
                        for (double b = start; b <= highBx; b+=i)
5166 fschmid 992
                        {
5233 fschmid 993
                                p->drawLine(FPoint(b, QMAX(lowerBy, 0)), FPoint(b, QMIN(pageHeight, highBy)));
5166 fschmid 994
                        }
456 fschmid 995
                }
996
        }
3962 cbradney 997
        //Draw the guides
879 fschmid 998
        if (Doc->guidesSettings.guidesShown)
456 fschmid 999
        {
5087 subik 1000
                /* PV - guides refactoring
456 fschmid 1001
                if (page->XGuides.count() != 0)
1002
                {
1003
                        for (uint xg = 0; xg < page->XGuides.count(); ++xg)
3016 fschmid 1004
                        {
3200 cbradney 1005
                                if ((page->XGuides[xg] >= 0) && (page->XGuides[xg] <= page->width()))
3226 cbradney 1006
                                        p->drawLine(FPoint(page->XGuides[xg], 0), FPoint(page->XGuides[xg], pageHeight));
3016 fschmid 1007
                        }
456 fschmid 1008
                }
1009
                if (page->YGuides.count() != 0)
1010
                {
1011
                        for (uint yg = 0; yg < page->YGuides.count(); ++yg)
3016 fschmid 1012
                        {
3226 cbradney 1013
                                if ((page->YGuides[yg] >= 0) && (page->YGuides[yg] <= pageHeight))
3200 cbradney 1014
                                        p->drawLine(FPoint(0, page->YGuides[yg]), FPoint(page->width(), page->YGuides[yg]));
3016 fschmid 1015
                        }
456 fschmid 1016
                }
5087 subik 1017
                */
1018
                page->guides.drawPage(p, Doc, lineWidth);
456 fschmid 1019
        }
1020
        p->restore();
1021
        p->setZoomFactor(z);
1022
}
1023
 
1024
void ScribusView::leaveEvent(QEvent *)
1025
{
1026
/*      if (BlockLeave)
1027
                return; */
4704 cbradney 1028
        if (!m_MouseButtonPressed)
456 fschmid 1029
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1030
/*      else
1031
        {
4704 cbradney 1032
                if ((SelItem.count() != 0) && (m_MouseButtonPressed) && (!doku->DragP) && (doku->appMode == 1))
456 fschmid 1033
                {
1957 cbradney 1034
                        PageItem *currItem = SelItem.at(0);
456 fschmid 1035
                        if ((b->Locked) || (b->Sizing))
1036
                                return;
1037
                        doku->DragP = true;
1038
                        doku->leaveDrag = true;
1039
                        doku->DraggedElem = b;
1040
                        doku->DragElements.clear();
1041
                        for (uint dre=0; dre<SelItem.count(); ++dre)
1042
                                doku->DragElements.append(SelItem.at(dre)->ItemNr);
1043
                        ScriXmlDoc *ss = new ScriXmlDoc();
1044
                        QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
1045
                        dr->setPixmap(loadIcon("DragPix.xpm"));
1046
                        dr->drag();
1047
                        delete ss;
3708 cbradney 1048
                        ss=NULL;
456 fschmid 1049
                        doku->DragP = false;
1050
                        doku->leaveDrag = false;
4704 cbradney 1051
                        m_MouseButtonPressed = false;
456 fschmid 1052
                        doku->DraggedElem = 0;
1053
                        doku->DragElements.clear();
1054
                }
1055
        } */
1056
}
1057
 
1058
void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
1059
{
1060
        QString text;
1061
        e->accept(QTextDrag::canDecode(e));
1062
        if (QTextDrag::decode(e, text))
1063
        {
1064
                double gx, gy, gw, gh;
5055 cbradney 1065
                /*<< #3524
456 fschmid 1066
                setActiveWindow();
1067
                raise();
4026 craig 1068
                ScMW->newActWin(Doc->WinHan);
456 fschmid 1069
                updateContents();
5055 cbradney 1070
                >>*/
456 fschmid 1071
//              SeleItemPos(e->pos());
1072
                QUrl ur(text);
1073
                QFileInfo fi = QFileInfo(ur.path());
1074
                ScriXmlDoc *ss = new ScriXmlDoc();
1075
                if (fi.exists())
1076
                        text = ur.path();
1077
                if(ss->ReadElemHeader(text,fi.exists(), &gx, &gy, &gw, &gh))
1078
                {
1079
                        GroupX = e->pos().x() / Scale;
1080
                        GroupY = e->pos().y() / Scale;
1081
                        GroupW = gw;
1082
                        GroupH = gh;
1083
                        DraggedGroup = true;
1084
                        DraggedGroupFirst = true;
4049 cbradney 1085
                        //GroupSel = false;
456 fschmid 1086
                        QPainter p;
1087
                        p.begin(viewport());
1088
                        PaintSizeRect(&p, QRect());
3640 fschmid 1089
                        emit ItemGeom(gw, gh);
456 fschmid 1090
//                      QPoint pv = QPoint(qRound(gx), qRound(gy));
1091
//                      PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
1092
                        p.end();
1093
                }
1094
                delete ss;
3708 cbradney 1095
                ss=NULL;
456 fschmid 1096
        }
1097
}
1098
 
1099
void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
1100
{
1101
        QString text;
1957 cbradney 1102
//      PageItem *currItem;
456 fschmid 1103
//      bool img;
1104
        e->accept(QTextDrag::canDecode(e));
1105
        if (QTextDrag::decode(e, text))
1106
        {
1107
                if (DraggedGroup)
1108
                {
1109
                        double gx, gy, gw, gh;
1110
                        GroupX = e->pos().x() / Scale;
1111
                        GroupY = e->pos().y() / Scale;
1112
                        getGroupRectScreen(&gx, &gy, &gw, &gh);
1113
                        QPainter p;
1114
                        p.begin(viewport());
2852 fschmid 1115
                        gx += Doc->minCanvasCoordinate.x();
1116
                        gy += Doc->minCanvasCoordinate.y();
456 fschmid 1117
                        QPoint pv = QPoint(qRound(gx), qRound(gy));
1118
                        if (!DraggedGroupFirst)
1119
                                PaintSizeRect(&p, QRect(pv, QPoint(pv.x()+qRound(gw), pv.y()+qRound(gh))));
1120
                        DraggedGroupFirst = false;
1121
                        p.end();
2867 fschmid 1122
                        emit MousePos(GroupX+Doc->minCanvasCoordinate.x(), GroupY+Doc->minCanvasCoordinate.y());
1612 cbradney 1123
                        horizRuler->Draw(e->pos().x());
1124
                        vertRuler->Draw(e->pos().y());
456 fschmid 1125
                        return;
1126
                }
1127
/*              QUrl ur(text);
1128
                QFileInfo fi = QFileInfo(ur.path());
1129
                QString ext = fi.extension(false).upper();
1130
                QStrList imfo = QImageIO::inputFormats();
1131
                if (ext == "JPG")
1132
                        ext = "JPEG";
1133
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
1134
                if (!SeleItemPos(e->pos()))
1135
                {
1136
                        if (SelItem.count() != 0)
1137
                                Deselect(true);
1138
                }
1139
                else
1140
                {
1141
                        b = SelItem.at(0);
1142
                        if (img)
1143
                        {
1144
                                if (b->PType != 2)
1145
                                        Deselect(true);
1146
                        }
1147
                        else
1148
                        {
1149
                                if (b->PType != 4)
1150
                                        Deselect(true);
1151
                        }
1152
                } */
1153
        }
1154
}
1155
 
632 fschmid 1156
void ScribusView::contentsDragLeaveEvent(QDragLeaveEvent *)
456 fschmid 1157
{
1158
        if (DraggedGroup)
1159
        {
1160
                updateContents();
1161
                DraggedGroup = false;
1162
                DraggedGroupFirst = false;
1163
        }
1164
}
1165
 
1166
void ScribusView::contentsDropEvent(QDropEvent *e)
1167
{
1168
        QString text;
1957 cbradney 1169
        PageItem *currItem;
456 fschmid 1170
        bool img = false;
1065 cbradney 1171
//      struct ScText *hg;
456 fschmid 1172
//      uint a;
693 fschmid 1173
        int re = 0;
456 fschmid 1174
        e->accept(QTextDrag::canDecode(e));
1175
        DraggedGroupFirst = false;
2852 fschmid 1176
        int ex = qRound(e->pos().x()/Scale + Doc->minCanvasCoordinate.x());
1177
        int ey = qRound(e->pos().y()/Scale + Doc->minCanvasCoordinate.y());
456 fschmid 1178
        if (QTextDrag::decode(e, text))
1179
        {
5055 cbradney 1180
                //<<#3524
1181
                setActiveWindow();
1182
                raise();
1183
                ScMW->newActWin(Doc->WinHan);
1184
                updateContents();
1185
                //>>
456 fschmid 1186
                QUrl ur(text);
1187
                QFileInfo fi = QFileInfo(ur.path());
1188
                QString ext = fi.extension(false).upper();
1189
                QStrList imfo = QImageIO::inputFormats();
1190
                if (ext == "JPG")
1191
                        ext = "JPEG";
4020 cbradney 1192
                //CB Need to handle this ugly file extension list elsewhere... some capabilities class perhaps
1193
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="PDF")||(ext=="TIF")||(ext=="PSD"));
4019 cbradney 1194
                bool selectedItemByDrag=false;
1195
                int pscx=qRound(e->pos().x()/Scale), pscy=qRound(e->pos().y()/Scale);
1196
                //Loop through all items and see which one(s) were under the drop point on the current layer
1197
                //Should make a nice function for this.
4049 cbradney 1198
                for (uint i=0; i<Doc->Items->count(); ++i)
4019 cbradney 1199
                {
1200
                        if (Doc->Items->at(i)->LayerNr==Doc->activeLayer())
1201
                        {
1202
                                if (Doc->Items->at(i)->pointWithinItem(pscx, pscy))
1203
                                {
1204
                                        Deselect(false);
1205
                                        SelectItem(Doc->Items->at(i));
1206
                                        selectedItemByDrag=true;
1207
                                        break;
1208
                                }
1209
                        }
1210
                }
4018 cbradney 1211
                //CB When we drag an image to a page from outside
1212
                //SeleItemPos is from 1.2.x. Needs reenabling for dragging *TO* a frame
4019 cbradney 1213
                if ((fi.exists()) && (img) && !selectedItemByDrag)// && (!SeleItemPos(e->pos())))
456 fschmid 1214
                {
4018 cbradney 1215
                        //int z = PaintPict(qRound(e->pos().x()/doku->Scale), qRound(e->pos().y()/doku->Scale), 1, 1);
4546 subik 1216
                        int z = Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, pscx, pscy, 1, 1, 1, Doc->toolSettings.dBrushPict, CommonStrings::None, true);
4018 cbradney 1217
                        PageItem *b = Doc->Items->at(z);
1218
                        Doc->LoadPict(ur.path(), b->ItemNr);
1219
                        b->setWidth(static_cast<double>(b->pixm.width()));
1220
                        b->setHeight(static_cast<double>(b->pixm.height()));
1221
                        b->OldB2 = b->width();
1222
                        b->OldH2 = b->height();
4688 cbradney 1223
                        b->updateClip();
456 fschmid 1224
                        emit DocChanged();
1225
                        update();
1226
                        return;
4019 cbradney 1227
                }
1228
                //if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
4847 cbradney 1229
                if (Doc->m_Selection->count()>0 && Doc->m_Selection->itemAt(0)->pointWithinItem(pscx, pscy) && (!text.startsWith("<SCRIBUSELEM")))
456 fschmid 1230
                {
4847 cbradney 1231
                        PageItem *b = Doc->m_Selection->itemAt(0);
4494 cbradney 1232
                        if (b->itemType() == PageItem::ImageFrame)
456 fschmid 1233
                        {
4494 cbradney 1234
                                if ((fi.exists()) && (img))
456 fschmid 1235
                                {
4494 cbradney 1236
                                        Doc->LoadPict(ur.path(), b->ItemNr);
1237
                                        update();
1238
                                }
1239
                        }
1240
                        /* CB leaving this out for now...
1241
                        if (b->PType == 4)
1242
                        {
1243
                                if ((b->BackBox != 0) && (b->itemText.count() == 0))
1244
                                        return;
1245
                                if ((fi.exists()) && (!img) && (fi.size() < 500000))
1246
                                {
1247
                                        Serializer *ss = new Serializer(ur.path());
1248
                                        if (ss->Read())
456 fschmid 1249
                                        {
4494 cbradney 1250
                                                int st = doku->currentParaStyle;
1251
                                                ss->GetText(b, st, doku->docParagraphStyles[st].Font, doku->docParagraphStyles[st].FontSize, true);
1252
                                                emit DocChanged();
456 fschmid 1253
                                        }
4494 cbradney 1254
                                        delete ss;
1255
                                        ss=NULL;
1256
                                        update();
456 fschmid 1257
                                }
4494 cbradney 1258
                                else
456 fschmid 1259
                                {
4494 cbradney 1260
                                        slotDoCurs(false);
1261
                                        slotSetCurs(e->pos().x(), e->pos().y());
1262
                                        if (text.startsWith("<SCRIBUSELEM"))
456 fschmid 1263
                                                return;
4494 cbradney 1264
                                        for (a=0; a<text.length(); ++a)
456 fschmid 1265
                                        {
4494 cbradney 1266
                                                hg = new ScText;
1267
                                                hg->ch = text.at(a);
1268
                                                if (hg->ch == QChar(10))
1269
                                                        hg->ch = QChar(13);
1270
                                                if (hg->ch == QChar(4))
1271
                                                        hg->ch = QChar(9);
1272
                                                if (hg->ch == QChar(5))
1273
                                                        hg->ch = QChar(13);
1274
                                                hg->cfont = b->IFont;
1275
                                                hg->csize = b->ISize;
1276
                                                hg->ccolor = b->TxtFill;
1277
                                                hg->cshade = b->ShTxtFill;
1278
                                                hg->cstroke = b->TxtStroke;
1279
                                                hg->cshade2 = b->ShTxtStroke;
1280
                                                hg->cselect = false;
1281
                                                hg->cscale = b->TxtScale;
1282
                                                hg->cextra = 0;
1283
                                                hg->cstyle = 0;
1284
                                                hg->cab = 0;
1285
                                                hg->xp = 0;
1286
                                                hg->yp = 0;
1287
                                                hg->PRot = 0;
1288
                                                hg->PtransX = 0;
1289
                                                hg->PtransY = 0;
1290
                                                b->itemText.insert(b->CPos, hg);
1291
                                                b->CPos += 1;
456 fschmid 1292
                                        }
4494 cbradney 1293
                                        emit DocChanged();
1294
                                        update();
1295
                                }
1296
                        }*/
456 fschmid 1297
                }
1298
                else
4042 subik 1299
                {
3727 cbradney 1300
                        for (uint as = 0; as < Doc->Items->count(); ++as)
855 fschmid 1301
                        {
3934 cbradney 1302
                                Doc->Items->at(as)->setSelected(false);
855 fschmid 1303
                        }
3934 cbradney 1304
                        uint oldDocItemCount = Doc->Items->count();
456 fschmid 1305
                        if ((!img) && (Doc->DraggedElem == 0))
1163 fschmid 1306
                        {
1307
                                if ((fi.exists()) && (!img))
2852 fschmid 1308
                                        emit LoadElem(ur.path(), ex, ey, true, false, Doc, this);
1163 fschmid 1309
                                else
2852 fschmid 1310
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
4847 cbradney 1311
                                Doc->m_Selection->clear();
3934 cbradney 1312
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
2233 fschmid 1313
                                {
3727 cbradney 1314
                                        currItem = Doc->Items->at(as);
4847 cbradney 1315
                                        Doc->m_Selection->addItem(currItem);
2233 fschmid 1316
                                        if (currItem->isBookmark)
1317
                                                emit AddBM(currItem);
1318
                                }
1163 fschmid 1319
                        }
456 fschmid 1320
                        else
1321
                        {
1322
                                if (Doc->DraggedElem != 0)
1323
                                {
1324
                                        if (!Doc->leaveDrag)
1325
                                        {
1326
                                                QPopupMenu *pmen = new QPopupMenu();
1327
                                                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1328
                                                pmen->insertItem( tr("Copy Here"));
1329
                                                pmen->insertItem( tr("Move Here"));
1330
                                                pmen->insertItem( tr("Cancel"));
1331
                                                re = pmen->indexOf(pmen->exec(QCursor::pos()));
1332
                                                delete pmen;
3708 cbradney 1333
                                                pmen=NULL;
456 fschmid 1334
                                        }
1335
                                        else
1336
                                                re = 1;
1337
                                        if ((re == 2) || (re == -1))
1338
                                        {
1339
                                                updateContents();
1340
                                                return;
1341
                                        }
1342
                                        if ((re == 1) || (Doc->leaveDrag))
1343
                                        {
1344
                                                QPtrList<PageItem> pasted;
2852 fschmid 1345
                                                emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
3934 cbradney 1346
                                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
456 fschmid 1347
                                                {
3727 cbradney 1348
                                                        pasted.append(Doc->Items->at(as));
456 fschmid 1349
                                                }
4847 cbradney 1350
                                                Doc->m_Selection->clear();
456 fschmid 1351
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1352
                                                {
4847 cbradney 1353
                                                        Doc->m_Selection->addItem(Doc->Items->at(Doc->DragElements[dre]));
456 fschmid 1354
                                                }
1355
                                                PageItem* bb;
1356
                                                int fin;
1357
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1358
                                                {
1359
                                                        bb = pasted.at(dre);
4847 cbradney 1360
                                                        currItem = Doc->m_Selection->itemAt(dre);
3625 avox 1361
                                                        if ((currItem->asTextFrame()) && ((currItem->NextBox != 0) || (currItem->BackBox != 0)))
456 fschmid 1362
                                                        {
1957 cbradney 1363
                                                                if (currItem->BackBox != 0)
456 fschmid 1364
                                                                {
1957 cbradney 1365
                                                                        bb->BackBox = currItem->BackBox;
4847 cbradney 1366
                                                                        fin = Doc->m_Selection->findItem(currItem->BackBox);
456 fschmid 1367
                                                                        if (fin != -1)
1368
                                                                                bb->BackBox = pasted.at(fin);
1369
                                                                        bb->BackBox->NextBox = bb;
1370
                                                                }
1957 cbradney 1371
                                                                if (currItem->NextBox != 0)
456 fschmid 1372
                                                                {
1957 cbradney 1373
                                                                        bb->NextBox = currItem->NextBox;
4847 cbradney 1374
                                                                        fin = Doc->m_Selection->findItem(currItem->NextBox);
456 fschmid 1375
                                                                        if (fin != -1)
1376
                                                                                bb->NextBox = pasted.at(fin);
1377
                                                                        bb->NextBox->BackBox = bb;
1378
                                                                }
1379
                                                        }
1380
                                                }
1381
                                                for (uint dre=0; dre<Doc->DragElements.count(); ++dre)
1382
                                                {
4847 cbradney 1383
                                                        currItem = Doc->m_Selection->itemAt(dre);
1957 cbradney 1384
                                                        currItem->NextBox = 0;
1385
                                                        currItem->BackBox = 0;
456 fschmid 1386
                                                }
1387
                                                pasted.clear();
4707 cbradney 1388
                                                Doc->itemSelection_DeleteItem();
456 fschmid 1389
                                        }
1390
                                }
1391
                                if ((!img) && ((re == 0)))
2852 fschmid 1392
                                        emit LoadElem(QString(text), ex, ey, false, false, Doc, this);
456 fschmid 1393
                                Doc->DraggedElem = 0;
1394
                                Doc->DragElements.clear();
4847 cbradney 1395
                                Doc->m_Selection->clear();
3934 cbradney 1396
                                for (uint as = oldDocItemCount; as < Doc->Items->count(); ++as)
456 fschmid 1397
                                {
3727 cbradney 1398
                                        currItem = Doc->Items->at(as);
4847 cbradney 1399
                                        Doc->m_Selection->addItem(currItem);
2193 fschmid 1400
                                        if (currItem->isBookmark)
1401
                                                emit AddBM(currItem);
456 fschmid 1402
                                }
1403
                        }
4847 cbradney 1404
                        if (Doc->m_Selection->count() > 1)
3640 fschmid 1405
                        {
1406
                                setGroupRect();
1407
                                paintGroupRect();
1408
                                double x, y, w, h;
1409
                                getGroupRect(&x, &y, &w, &h);
1410
                                emit ItemPos(x, y);
1411
                                emit ItemGeom(w, h);
1412
                        }
3941 cbradney 1413
                        updateContents();
4019 cbradney 1414
                }
456 fschmid 1415
        }
1416
}
1417
 
1418
void ScribusView::contentsMouseDoubleClickEvent(QMouseEvent *m)
1419
{
1420
        m->accept();
4704 cbradney 1421
        m_MouseButtonPressed = false;
1957 cbradney 1422
        PageItem *currItem = 0;
456 fschmid 1423
        if (Doc->EditClip)
1424
        {
1425
                emit EndNodeEdit();
1426
                return;
1427
        }
4847 cbradney 1428
        if ((Doc->m_Selection->isMultipleSelection()) || (Doc->appMode != modeNormal))
456 fschmid 1429
        {
4847 cbradney 1430
                if ((Doc->m_Selection->isMultipleSelection()) && (Doc->appMode == modeNormal))
456 fschmid 1431
                {
1957 cbradney 1432
                        if (GetItem(&currItem))
456 fschmid 1433
                        {
1957 cbradney 1434
                                if (currItem->isTableItem)
456 fschmid 1435
                                {
1436
                                        Deselect(false);
4847 cbradney 1437
                                        Doc->m_Selection->addItem(currItem);
1957 cbradney 1438
                                        currItem->isSingleSel = true;
3946 cbradney 1439
                                        //CB FIXME dont call this if the added item is item 0
4847 cbradney 1440
                                        if (!Doc->m_Selection->primarySelectionIs(currItem))
4010 cbradney 1441
                                                currItem->emitAllToGUI();
1957 cbradney 1442
                                        currItem->paintObj();
456 fschmid 1443
                                }
1444
                        }
4351 cbradney 1445
                        return;
456 fschmid 1446
                }
1447
                else
4351 cbradney 1448
                {
1449
                        if (!(GetItem(&currItem) && (Doc->appMode == modeEdit) && currItem->asTextFrame()))
1450
                        {
1451
                                contentsMousePressEvent(m);
1452
                                return;
1453
                        }
1454
                }
456 fschmid 1455
        }
1957 cbradney 1456
        if (GetItem(&currItem))
456 fschmid 1457
        {
1957 cbradney 1458
                if ((currItem->itemType() == PageItem::Polygon) || (currItem->itemType() == PageItem::PolyLine) || (currItem->itemType() == PageItem::ImageFrame) || (currItem->itemType() == PageItem::PathText))
456 fschmid 1459
                {
1957 cbradney 1460
                        if ((currItem->locked()) || (!currItem->ScaleType))
456 fschmid 1461
                        {
1462
                                contentsMousePressEvent(m);
1463
                                return;
1464
                        }
3962 cbradney 1465
                        //If we double click on an image frame and theres no image assigned, open the
4492 cbradney 1466
                        //load picture dialog, else put it into edit mode if the frame is set to show the image
1467
                        if (currItem->itemType() == PageItem::ImageFrame)
1468
                        {
1469
                                if (currItem->Pfile.isEmpty())
1470
                                        emit LoadPic();
1471
                                else if (currItem->imageShown())
1472
                                        emit Amode(modeEdit);
1473
                        }
5036 cbradney 1474
                        else
1475
                                emit Amode(modeEdit);
456 fschmid 1476
                }
1477
                else
1957 cbradney 1478
                        if (currItem->itemType() == PageItem::TextFrame)
837 fschmid 1479
                        {
4351 cbradney 1480
                                //CB old code
1481
                                //emit currItem->isAnnotation() ? AnnotProps() : Amode(modeEdit);
1482
                                //contentsMousePressEvent(m);
1483
                                //CB if annotation, open the annotation dialog
1484
                                if (currItem->isAnnotation())
1485
                                {
1486
                                        emit AnnotProps();
1487
                                        contentsMousePressEvent(m);
1488
                                }
1489
                                //else if not in mode edit, set mode edit
1490
                                else if (Doc->appMode != modeEdit)
1491
                                {
4888 cbradney 1492
                                        emit Amode(modeEdit);
4351 cbradney 1493
                                        //CB ignore the double click and go with a single one
1494
                                        //if we werent in mode edit before.
1495
                                        //unsure if this is correct, but its ok given we had no
1496
                                        //double click select until now.
1497
                                        contentsMousePressEvent(m);
1498
                                }
1499
                                //otherwise, select between the whitespace
4546 subik 1500
                                else
4351 cbradney 1501
                                {       //Double click in a frame to select a word
1502
                                        PageItem_TextFrame *cItem=currItem->asTextFrame();
1503
                                        bool inText = slotSetCurs(m->x(), m->y());
1504
                                        if (!inText)
1505
                                        {
1506
                                                Deselect(true);
1507
                                                slotDoCurs(true);
1508
                                                emit Amode(modeNormal);
1509
                                                return;
1510
                                        }
1511
                                        int a=cItem->CPos;
1512
                                        while(a>0)
1513
                                        {
5184 avox 1514
                                                if (cItem->itemText.text(a-1).isLetterOrNumber())
4351 cbradney 1515
                                                        --a;
1516
                                                else
1517
                                                        break;
1518
                                        }
5569 avox 1519
                                        int b=cItem->CPos;
5184 avox 1520
                                        while(b<cItem->itemText.length())
4351 cbradney 1521
                                        {
5184 avox 1522
                                                if (cItem->itemText.text(b).isLetterOrNumber())
4351 cbradney 1523
                                                        ++b;
1524
                                                else
1525
                                                        break;
1526
                                        }
4968 cbradney 1527
                                        oldCp = a;
4351 cbradney 1528
                                        cItem->CPos=b;
1529
                                        cItem->ExpandSel(1, oldCp);
1530
                                        slotDoCurs(true);
1531
                                }
837 fschmid 1532
                        }
456 fschmid 1533
        }
1534
}
1535
 
1536
void ScribusView::contentsMouseReleaseEvent(QMouseEvent *m)
1537
{
1957 cbradney 1538
        PageItem *currItem;
4704 cbradney 1539
        m_MouseButtonPressed = false;
879 fschmid 1540
        if (Doc->guidesSettings.guidesShown)
456 fschmid 1541
        {
3962 cbradney 1542
                bool foundGuide = false;
2848 fschmid 1543
                double nx = m->x()/Scale + Doc->minCanvasCoordinate.x();
1544
                double ny = m->y()/Scale + Doc->minCanvasCoordinate.y();
5087 subik 1545
                /* PV - guides rafactoring
1065 cbradney 1546
                if (Doc->currentPage->YGuides.count() != 0)
456 fschmid 1547
                {
1065 cbradney 1548
                        for (uint yg = 0; yg < Doc->currentPage->YGuides.count(); ++yg)
456 fschmid 1549
                        {
3200 cbradney 1550
                                if ((Doc->currentPage->YGuides[yg]+Doc->currentPage->yOffset()< (ny+Doc->guidesSettings.grabRad)) &&
1551
                                         (Doc->currentPage->YGuides[yg]+Doc->currentPage->yOffset()> (ny-Doc->guidesSettings.grabRad)))
456 fschmid 1552
                                {
3962 cbradney 1553
                                        foundGuide = true;
456 fschmid 1554
                                        break;
1555
                                }
1556
                        }
1557
                }
1065 cbradney 1558
                if (Doc->currentPage->XGuides.count() != 0)
456 fschmid 1559
                {
1065 cbradney 1560
                        for (uint xg = 0; xg < Doc->currentPage->XGuides.count(); ++xg)
456 fschmid 1561
                        {
3200 cbradney 1562
                                if ((Doc->currentPage->XGuides[xg]+Doc->currentPage->xOffset()< (nx+Doc->guidesSettings.grabRad)) &&
1563
                                         (Doc->currentPage->XGuides[xg]+Doc->currentPage->xOffset()> (nx-Doc->guidesSettings.grabRad)))
456 fschmid 1564
                                {
3962 cbradney 1565
                                        foundGuide = true;
456 fschmid 1566
                                        break;
1567
                                }
1568
                        }
1569
                }
5087 subik 1570
                */
1571
                if (Doc->currentPage()->guides.isMouseOnHorizontal(ny + Doc->guidesSettings.grabRad,
1572
                                                                                                                ny - Doc->guidesSettings.grabRad,
1573
                                                                                                                GuideManagerCore::Standard)
1574
                                  || Doc->currentPage()->guides.isMouseOnVertical(nx + Doc->guidesSettings.grabRad,
1575
                                                                                                                        nx - Doc->guidesSettings.grabRad,
1576
                                                                                                                        GuideManagerCore::Standard))
1577
                        foundGuide = true;
3962 cbradney 1578
                if ((foundGuide) && (m->button() == RightButton) && (!GetItem(&currItem)))
456 fschmid 1579
                {
1580
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1581
                        MoveGY = false;
1582
                        MoveGX = false;
5087 subik 1583
                        //emit EditGuides(); // TODO: PV - guides refactoring
456 fschmid 1584
                        return;
1585
                }
1586
                if (MoveGY)
1587
                {
1115 tsoots 1588
                        SetYGuide(m, GyM);
456 fschmid 1589
                        MoveGY = false;
1590
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1591
                        updateContents();
2966 fschmid 1592
                        GyM = -1;
456 fschmid 1593
                        return;
1594
                }
1595
                if (MoveGX)
1596
                {
1115 tsoots 1597
                        SetXGuide(m, GxM);
456 fschmid 1598
                        MoveGX = false;
1599
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1600
                        updateContents();
2966 fschmid 1601
                        GxM = -1;
456 fschmid 1602
                        return;
1603
                }
1604
        }
2603 cbradney 1605
        if (Doc->appMode == modeEditGradientVectors)
735 fschmid 1606
                return;
2603 cbradney 1607
        if (Doc->appMode == modeCopyProperties)
1840 fschmid 1608
                return;
2603 cbradney 1609
        if (Doc->appMode == modeMeasurementTool)
456 fschmid 1610
        {
1611
                QPainter p;
1612
                p.begin(viewport());
2854 fschmid 1613
                QPoint out = contentsToViewport(QPoint(0, 0));
1614
                p.translate(out.x(), out.y());
456 fschmid 1615
                p.setRasterOp(XorROP);
1616
                p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
1617
                p.drawLine(Dxp, Dyp, Mxp, Myp);
1618
                p.end();
1619
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
1525 cbradney 1620
                //emit PaintingDone();
456 fschmid 1621
                return;
1622
        }
2603 cbradney 1623
        if (Doc->appMode == modePanning)
4105 cbradney 1624
        {
1625
                if ((m->state() & Qt::RightButton) && (m->state() & Qt::ControlButton))
1626
                {
1627
                        ScMW->setAppMode(modeNormal);
1628
                }
456 fschmid 1629
                return;
4105 cbradney 1630
        }
2603 cbradney 1631
        if (Doc->appMode == modeDrawTable)
456 fschmid 1632
        {
4847 cbradney 1633
                if ((Doc->m_Selection->count() == 0) && (HaveSelRect) && (!MidButt))
456 fschmid 1634
                {
1635
                        QRect AreaR = QRect(static_cast<int>(Mxp), static_cast<int>(Myp), static_cast<int>(SeRx-Mxp), static_cast<int>(SeRy-Myp));
1636
                        QPainter p;
1637
                        p.begin(viewport());
1638
                        ToView(&p);
1639
                        p.scale(Scale, Scale);
1640
                        p.setRasterOp(XorROP);
1641
                        p.setPen(QPen(white, 1, DotLine, FlatCap, MiterJoin));
1642
                        if(Mxp > SeRx)
1643
                        {
1644
                                double tmp=SeRx;
1645
                                SeRx=static_cast<int>(Mxp);
1646
                                Mxp=static_cast<int>(tmp);
1647
                        }
1648
                        if(Myp > SeRy)
1649
                        {
1650
                                double tmp=SeRy;
1651
                                SeRy=static_cast<int>(Myp);
1652
                                Myp=static_cast<int>(tmp);
1653
                        }
1654
                        HaveSelRect = false;
1655
                        double Tx, Ty, Tw, Th;
1656
                        Tx = Mxp;
1657
                        Ty = Myp;
1658
                        Tw = SeRx-Mxp;
1659
                        Th = SeRy-Myp;
1660
                        int z;
1661
                        int Cols, Rows;
1662
                        double deltaX, deltaY, offX, offY;
1663
                        if ((Th < 6) || (Tw < 6))
1664
                        {
1665
                                p.drawRect(AreaR);
1666
                                p.end();
2603 cbradney 1667
                                Doc->appMode = modeNormal;
456 fschmid 1668
                                emit PaintingDone();
1669
                                return;
1670
                        }
1671
                        InsertTable *dia = new InsertTable(this, static_cast<int>(Th / 6), static_cast<int>(Tw / 6));
1672
                        if (!dia->exec())
1673
                        {
1674
                                p.drawRect(AreaR);
1675
                                p.end();
2603 cbradney 1676
                                Doc->appMode = modeNormal;
456 fschmid 1677
                                emit PaintingDone();
1678
                                delete dia;
3708 cbradney 1679
                                dia=NULL;
456 fschmid 1680
                                return;
1681
                        }
1682
                        p.end();
1683
                        Cols = dia->Cols->value();
1684
                        Rows = dia->Rows->value();
1685
                        delete dia;
3708 cbradney 1686
                        dia=NULL;
456 fschmid 1687
                        deltaX = Tw / Cols;
1688
                        deltaY = Th / Rows;
1689
                        offX = 0.0;
1690
                        offY = 0.0;
4847 cbradney 1691
                        Doc->m_Selection->clear();
1396 tsoots 1692
                        if (UndoManager::undoEnabled())
5087 subik 1693
                                undoManager->beginTransaction(Doc->currentPage()->getUName(),
1694
                                                                                          Um::ITable, Um::CreateTable,
1695
                                                                                          QString(Um::RowsCols).arg(Rows).arg(Cols),
1696
                                                                                          Um::ICreate);
456 fschmid 1697
                        for (int rc = 0; rc < Rows; ++rc)
1698
                        {
1699
                                for (int cc = 0; cc < Cols; ++cc)
1700
                                {
3292 cbradney 1701
                                        //z = PaintText(Tx + offX, Ty + offY, deltaX, deltaY, Doc->toolSettings.dWidth, Doc->toolSettings.dPenText);
4704 cbradney 1702
                                        z = Doc->itemAdd(PageItem::TextFrame, PageItem::Unspecified, Tx + offX, Ty + offY, deltaX, deltaY, Doc->toolSettings.dWidth, CommonStrings::None, Doc->toolSettings.dPenText, !m_MouseButtonPressed);
3727 cbradney 1703
                                        currItem = Doc->Items->at(z);
1957 cbradney 1704
                                        currItem->isTableItem = true;
5620 jghali 1705
                                        //currItem->setTextFlowsAroundFrame(true);
1706
                                        //currItem->setTextFlowUsesBoundingBox(true);
1707
                                        currItem->setTextFlowMode(PageItem::TextFlowUsesBoundingBox);
4847 cbradney 1708
                                        Doc->m_Selection->addItem(currItem);
456 fschmid 1709
                                        offX += deltaX;
1710
                                }
1711
                                offY += deltaY;
1712
                                offX = 0.0;
1713
                        }
1714
                        for (int rc = 0; rc < Rows; ++rc)
1715
                        {
1716
                                for (int cc = 0; cc < Cols; ++cc)
1717
                                {
4847 cbradney 1718
                                        currItem = Doc->m_Selection->itemAt((rc * Cols) + cc);
456 fschmid 1719
                                        if (rc == 0)
1957 cbradney 1720
                                                currItem->TopLink = 0;
456 fschmid 1721
                                        else
4847 cbradney 1722
                                                currItem->TopLink = Doc->m_Selection->itemAt(((rc-1)*Cols)+cc);
456 fschmid 1723
                                        if (rc == Rows-1)
1957 cbradney 1724
                                                currItem->BottomLink = 0;
456 fschmid 1725
                                        else
4847 cbradney 1726
                                                currItem->BottomLink = Doc->m_Selection->itemAt(((rc+1)*Cols)+cc);
456 fschmid 1727
                                        if (cc == 0)
1957 cbradney 1728
                                                currItem->LeftLink = 0;
456 fschmid 1729
                                        else
4847 cbradney 1730
                                                currItem->LeftLink = Doc->m_Selection->itemAt((rc*Cols)+cc-1);
456 fschmid 1731
                                        if (cc == Cols-1)
1957 cbradney 1732
                                                currItem->RightLink = 0;
456 fschmid 1733
                                        else
4847 cbradney 1734
                                                currItem->RightLink = Doc->m_Selection->itemAt((rc*Cols)+cc+1);
456 fschmid 1735
                                }
1736
                        }
1737
                        emit DoGroup();
1396 tsoots 1738
                        if (UndoManager::undoEnabled())
1739
                                undoManager->commit();
456 fschmid 1740
                }
2603 cbradney 1741
                Doc->appMode = modeNormal;
456 fschmid 1742
                emit PaintingDone();
1743
                emit DocChanged();
1744
                updateContents();
1745
                return;
1746
        }
2603 cbradney 1747
        if (Doc->appMode == modeDrawFreehandLine)
456 fschmid 1748
        {
1749
                if (RecordP.size() > 1)
1750
                {
4704 cbradney 1751
                        uint z = Doc->itemAdd(PageItem::PolyLine, PageItem::Unspecified, 0, 0, 1, 1, Doc->toolSettings.dWidth, CommonStrings::None, Doc->toolSettings.dPenLine, !m_MouseButtonPressed);
3727 cbradney 1752
                        currItem = Doc->Items->at(z);
1957 cbradney 1753
                        currItem->PoLine.resize(0);
1754
                        currItem->PoLine.addPoint(RecordP.point(0));
1755
                        currItem->PoLine.addPoint(RecordP.point(0));
456 fschmid 1756
                        for (uint px = 1; px < RecordP.size()-1; ++px)
1757
                        {
1957 cbradney 1758
                                currItem->PoLine.addPoint(RecordP.point(px));
1759
                                currItem->PoLine.addPoint(RecordP.point(px));
1760
                                currItem->PoLine.addPoint(RecordP.point(px));
1761
                                currItem->PoLine.addPoint(RecordP.point(px));
456 fschmid 1762
                        }
1957 cbradney 1763
                        currItem->PoLine.addPoint(RecordP.point(RecordP.size()-1));
1764
                        currItem->PoLine.addPoint(RecordP.point(RecordP.size()-1));
1765
                        AdjustItemSize(currItem);
4847 cbradney 1766
                        Doc->m_Selection->clear();
1767
                        Doc->m_Selection->addItem(currItem);
1957 cbradney 1768
                        currItem->ClipEdited = true;
3934 cbradney 1769
                        //currItem->Select = true;
1957 cbradney 1770
                        currItem->FrameType = 3;
3657 cbradney 1771
                        currItem->OwnPage = Doc->OnPage(currItem);
3934 cbradney 1772
                        //qDebug("emit ItemPos(currItem->xPos(), currItem->yPos());");
3991 cbradney 1773
                        /*CB Done with addItem
1957 cbradney 1774
                        emit SetSizeValue(currItem->Pwidth);
1775
                        emit SetLineArt(currItem->PLineArt, currItem->PLineEnd, currItem->PLineJoin);
1776
                        emit ItemFarben(currItem->lineColor(), currItem->fillColor(), currItem->lineShade(), currItem->fillShade());
1777
                        emit ItemGradient(currItem->GrType);
1778
                        emit ItemTrans(currItem->fillTransparency(), currItem->lineTransparency());
3991 cbradney 1779
                        */
3946 cbradney 1780
                        //emit HaveSel(PageItem::PolyLine);
456 fschmid 1781
                }
4054 fschmid 1782
                Doc->appMode = modeNormal;
456 fschmid 1783
                updateContents();
1784
                emit PaintingDone();
1785
                emit DocChanged();
1786
                return;
1787
        }