Subversion Repositories Scribus

Rev

Rev 24236 | 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"
128 Franz 25
 
2688 craig 26
#include "scconfig.h"
17796 fschmid 27
#include "sclimits.h"
128 Franz 28
 
10220 cbradney 29
#include <QColor>
23480 jghali 30
#include <QCursor>
16673 craig 31
#include <QDebug>
10859 cbradney 32
#include <QDrag>
33
#include <QEvent>
34
#include <QFile>
35
#include <QFileInfo>
10220 cbradney 36
#include <QFont>
37
#include <QFontMetrics>
10859 cbradney 38
#include <QImage>
39
#include <QImageReader>
40
#include <QList>
41
#include <QMenu>
17941 jghali 42
#include <QMessageBox>
10859 cbradney 43
#include <QMimeData>
10220 cbradney 44
#include <QPixmap>
10284 fschmid 45
#include <QPolygon>
10859 cbradney 46
#include <QStack>
10220 cbradney 47
#include <QStringList>
23263 jghali 48
#include <QStyleOptionRubberBand>
9514 fschmid 49
#include <QWidgetAction>
10859 cbradney 50
 
456 fschmid 51
#include <cstdio>
52
#include <cstdlib>
2702 craig 53
 
54
#ifdef HAVE_UNISTD_H
456 fschmid 55
#include <unistd.h>
2702 craig 56
#endif
57
 
10281 jghali 58
#include <QUrl>
10220 cbradney 59
#include <QDir>
60
#include <QSizeGrip>
18454 craig 61
 
19067 craig 62
#include "actionmanager.h"
19495 craig 63
#include "appmodehelper.h"
20185 craig 64
#include "appmodes.h"
10532 avox 65
#include "canvas.h"
10701 avox 66
#include "canvasgesture.h"
10532 avox 67
#include "canvasmode.h"
19067 craig 68
#include "canvasmode_imageimport.h"
12971 jghali 69
#include "canvasmode_objimport.h"
10212 cbradney 70
#include "commonstrings.h"
19067 craig 71
#include "fileloader.h"
10212 cbradney 72
#include "filewatcher.h"
73
#include "hyphenator.h"
20185 craig 74
#include "iconmanager.h"
19067 craig 75
#include "loadsaveplugin.h"
21107 craig 76
#include "text/textlayoutpainter.h"
17519 craig 77
#include "pageitem.h"
17130 fschmid 78
#include "pageitem_group.h"
3625 avox 79
#include "pageitem_imageframe.h"
19067 craig 80
#include "pageitem_latexframe.h"
3625 avox 81
#include "pageitem_line.h"
82
#include "pageitem_pathtext.h"
83
#include "pageitem_polygon.h"
84
#include "pageitem_polyline.h"
16856 craig 85
#include "pageitem_table.h"
3625 avox 86
#include "pageitem_textframe.h"
19067 craig 87
#include "plugins/formatidlist.h"
7284 fschmid 88
#include "prefscontext.h"
89
#include "prefsfile.h"
10212 cbradney 90
#include "prefsmanager.h"
13466 cbradney 91
#include "scclocale.h"
12841 jghali 92
#include "scmimedata.h"
16736 jghali 93
#include "scpage.h"
10601 mrdocs 94
#include "scpainter.h"
10212 cbradney 95
#include "scpaths.h"
23474 jghali 96
#include "scribusapp.h"
13516 jghali 97
#include "scribuscore.h"
13950 fschmid 98
#include "scribuswin.h"
23474 jghali 99
#include "scribusXml.h"
10212 cbradney 100
#include "selection.h"
18438 craig 101
#include "selectionrubberband.h"
10212 cbradney 102
#include "serializer.h"
16546 jghali 103
#include "ui/extimageprops.h"
104
#include "ui/guidemanager.h"
105
#include "ui/hruler.h"
106
#include "ui/insertTable.h"
107
#include "ui/pageitemattributes.h"
108
#include "ui/pageselector.h"
109
#include "ui/propertiespalette.h"
110
#include "ui/propertiespalette_line.h"
111
#include "ui/rulermover.h"
112
#include "ui/scrapbookpalette.h"
13576 cbradney 113
#include "ui/storyeditor.h"
15060 fschmid 114
#include "ui/symbolpalette.h"
19009 craig 115
#include "ui/viewtoolbar.h"
16546 jghali 116
#include "ui/vruler.h"
10212 cbradney 117
#include "undomanager.h"
118
#include "units.h"
119
#include "util.h"
120
#include "util_color.h"
121
#include "util_formats.h"
10203 cbradney 122
#include "util_math.h"
2495 cbradney 123
 
504 cbradney 124
using namespace std;
125
 
5781 cbradney 126
ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
10532 avox 127
        QScrollArea(win),
23509 craig 128
        m_doc(doc),
10532 avox 129
        m_canvas(new Canvas(doc, this)),
23060 craig 130
        Prefs(&(PrefsManager::instance().appPrefs)),
3982 craig 131
        undoManager(UndoManager::instance()),
11814 fschmid 132
        m_ScMW(mw),
3982 craig 133
        RCenter(-1,-1),
17533 fschmid 134
        m_vhRulerHW(17)
3 paul 135
{
10585 fschmid 136
        setObjectName("s");
15139 cbradney 137
        QPalette p=palette();
23060 craig 138
        p.setBrush(QPalette::Window, PrefsManager::instance().appPrefs.displayPrefs.scratchColor);
15139 cbradney 139
        setPalette(p);
10575 cbradney 140
        setAttribute(Qt::WA_StaticContents);
16546 jghali 141
        setAttribute(Qt::WA_InputMethodEnabled, true);
10532 avox 142
        setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
143
        setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
144
        setViewportMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
145
        setWidgetResizable(false);
23509 craig 146
        m_canvasMode = CanvasMode::createForAppMode(this, m_doc->appMode);
10532 avox 147
        setWidget(m_canvas);
148
        //already done by QScrollArea: widget()->installEventFilter(this);
10550 avox 149
        installEventFilter(this); // FIXME:av
22638 craig 150
        //      viewport()->setBackgroundMode(Qt::PaletteBackground);
11158 avox 151
        setFocusPolicy(Qt::ClickFocus);
3 paul 152
        QFont fo = QFont(font());
13516 jghali 153
        // #8058: Better not use too small font size on Windows
154
        // in case ClearType is not enabled
155
        int posi = fo.pointSize() - (ScCore->isWinGUI() ? 1 : 2);
2887 fschmid 156
        fo.setPointSize(posi);
23474 jghali 157
 
23509 craig 158
        horizRuler = new Hruler(this, m_doc);
159
        vertRuler = new Vruler(this, m_doc);
10532 avox 160
        horizRuler->installEventFilter(this);
161
        vertRuler->installEventFilter(this);
23474 jghali 162
 
3309 cbradney 163
        rulerMover = new RulerMover(this);
8573 jghali 164
        rulerMover->setFocusPolicy(Qt::NoFocus);
10532 avox 165
        horizRuler->setGeometry(m_vhRulerHW, 1, width()-m_vhRulerHW-1, m_vhRulerHW);
166
        vertRuler->setGeometry(1, m_vhRulerHW, m_vhRulerHW, height()-m_vhRulerHW-1);
167
        rulerMover->setGeometry(1, 1, m_vhRulerHW, m_vhRulerHW);
23474 jghali 168
 
22801 jghali 169
        m_ready = true;
10560 avox 170
        m_canvas->setMouseTracking(true);
456 fschmid 171
        setAcceptDrops(true);
10560 avox 172
        m_canvas->setAcceptDrops(true);
10532 avox 173
        // FIXME setDragAutoScroll(false);
23509 craig 174
        m_doc->DragP = false;
175
        m_doc->leaveDrag = false;
176
        m_doc->SubMode = -1;
177
        storedFramesShown = m_doc->guidesPrefs().framesShown;
178
        storedShowControls = m_doc->guidesPrefs().showControls;
179
        setRulersShown(m_doc->guidesPrefs().rulersShown);
23474 jghali 180
 
10532 avox 181
        m_canvas->m_viewMode.viewAsPreview = false;
17913 fschmid 182
        m_canvas->setPreviewVisual(-1);
10532 avox 183
        m_previousMode = -1;
23474 jghali 184
 
18438 craig 185
        redrawMarker = new SelectionRubberBand(QRubberBand::Rectangle, this);
8720 fschmid 186
        redrawMarker->hide();
23474 jghali 187
 
10532 avox 188
        m_canvas->newRedrawPolygon();
189
        m_canvas->resetRenderMode();
22638 craig 190
        //  #13101 : "viewPreviewMode" is checked if necessary in ScribusMainWindow::newActWin()
191
        //  At this point the view and parent window may not be able to perform all what is necessary to
192
        //  enable preview mode anyway, especially when loading an existing doc.
193
        //      m_ScMW->scrActions["viewPreviewMode"]->setChecked(m_canvas->m_viewMode.viewAsPreview);
19547 craig 194
        m_mousePointDoc = FPoint(0,0);
23509 craig 195
        m_doc->regionsChanged()->connectObserver(this);
196
        connect(this, SIGNAL(HaveSel()), m_doc, SLOT(selectionChanged()));
22638 craig 197
        // Commented out to fix bug #7865
198
        //      m_dragTimer = new QTimer(this);
199
        //      connect(m_dragTimer, SIGNAL(timeout()), this, SLOT(dragTimerTimeOut()));
200
        //      m_dragTimer->stop();
10978 avox 201
        m_dragTimerFired = false;
23474 jghali 202
 
23509 craig 203
        clockLabel = new ClockWidget(this, m_doc);
17797 fschmid 204
        clockLabel->setGeometry(m_vhRulerHW + 1, height() - m_vhRulerHW - 61, 60, 60);
205
        clockLabel->setVisible(false);
23474 jghali 206
 
23054 craig 207
        endEditButton = new QPushButton(IconManager::instance().loadIcon("22/exit.png"), tr("End Edit"), this);
17971 fschmid 208
        endEditButton->setGeometry(m_vhRulerHW + 1, height() - m_vhRulerHW - endEditButton->minimumSizeHint().height() - 1, endEditButton->minimumSizeHint().width(), endEditButton->minimumSizeHint().height());
209
        endEditButton->setVisible(false);
18972 craig 210
 
17971 fschmid 211
        languageChange();
23474 jghali 212
 
213
        connect(ScQApp, SIGNAL(iconSetChanged()), this, SLOT(iconSetChange()));
214
        connect(endEditButton, SIGNAL(clicked()), m_ScMW, SLOT(slotEndSpecialEdit()));
3 paul 215
}
216
 
11190 avox 217
ScribusView::~ScribusView()
218
{
219
        while (m_canvasMode)
220
        {
221
                m_canvasMode->deactivate(false);
222
                m_canvasMode = m_canvasMode->delegate();
223
        }
224
}
225
 
10859 cbradney 226
void ScribusView::changeEvent(QEvent *e)
227
{
228
        if (e->type() == QEvent::LanguageChange)
229
        {
230
                languageChange();
231
        }
10903 cbradney 232
        else
22640 craig 233
                QFrame::changeEvent(e);
10859 cbradney 234
}
235
 
23591 craig 236
void ScribusView::nativeGestureEvent(QNativeGestureEvent *e)
237
{
238
        if (e->gestureType() == Qt::ZoomNativeGesture)
239
        {
240
                double delta = 1 + e->value();
241
                FPoint mp = m_canvas->globalToCanvas(e->globalPos());
242
                zoom(mp.x(), mp.y(), m_canvas->scale() * delta, true);
243
        }
23593 craig 244
        if (e->gestureType() == Qt::SmartZoomNativeGesture)
245
        {
246
                static bool zoomTo100 = false;
247
                FPoint mp = m_canvas->globalToCanvas(e->globalPos());
248
                if (zoomTo100)
249
                {
250
                        zoom(mp.x(), mp.y(), Prefs->displayPrefs.displayScale, true);
251
                }
252
                else
253
                {
254
                        zoom(mp.x(), mp.y(), Prefs->displayPrefs.displayScale*0.75, true);
255
                }
256
                zoomTo100 = !zoomTo100;
257
        }
258
        e->accept();
23591 craig 259
}
260
 
23474 jghali 261
void ScribusView::iconSetChange()
262
{
263
        IconManager& iconManager = IconManager::instance();
264
        endEditButton->setIcon(iconManager.loadIcon("22/exit.png"));
265
}
266
 
2199 cbradney 267
void ScribusView::languageChange()
268
{
20272 craig 269
        endEditButton->setToolTip( tr("Click here to leave this special edit mode"));
2199 cbradney 270
}
271
 
19009 craig 272
void ScribusView::toggleCMS(bool cmsOn)
6726 fschmid 273
{
23509 craig 274
        m_doc->enableCMS(cmsOn);
16546 jghali 275
        m_ScMW->requestUpdate(reqCmsOptionsUpdate);
10867 fschmid 276
        DrawNew();
6726 fschmid 277
}
278
 
12362 fschmid 279
 
6549 fschmid 280
void ScribusView::switchPreviewVisual(int vis)
281
{
10532 avox 282
        m_canvas->setPreviewVisual(vis);
23509 craig 283
        m_doc->viewAsPreview = m_canvas->usePreviewVisual();
284
        m_doc->previewVisual = m_canvas->previewVisual();
285
        m_doc->recalculateColors();
286
        m_doc->recalcPicturesRes();
10867 fschmid 287
        DrawNew();
6549 fschmid 288
}
289
 
19009 craig 290
void ScribusView::togglePreviewEdit(bool edit)
17915 fschmid 291
{
23509 craig 292
        m_doc->editOnPreview = edit;
17915 fschmid 293
        m_ScMW->setPreviewToolbar();
18590 fschmid 294
        m_EditModeWasOn = true;
17999 fschmid 295
        DrawNew();
17915 fschmid 296
}
297
 
19009 craig 298
void ScribusView::togglePreview(bool inPreview)
5235 fschmid 299
{
17909 fschmid 300
        this->requestMode(modeNormal);
23390 craig 301
        deselectItems(true);
17744 craig 302
        undoManager->setUndoEnabled(false);
19009 craig 303
        m_canvas->m_viewMode.viewAsPreview = inPreview;
23509 craig 304
        m_doc->drawAsPreview = inPreview;
17910 fschmid 305
        bool recalc = false;
23509 craig 306
        m_doc->editOnPreview = false;
19009 craig 307
        m_ScMW->scrActions["viewEditInPreview"]->setChecked(false);
18590 fschmid 308
        m_AnnotChanged = false;
309
        m_EditModeWasOn = false;
23509 craig 310
        m_ChangedState = m_doc->isModified();
19009 craig 311
 
312
        if (inPreview)
5237 fschmid 313
        {
19009 craig 314
                m_ScMW->scrActions["viewEditInPreview"]->setEnabled(true);
23509 craig 315
                storedFramesShown = m_doc->guidesPrefs().framesShown;
316
                m_doc->guidesPrefs().framesShown = false;
317
                storedShowControls = m_doc->guidesPrefs().showControls;
318
                m_doc->guidesPrefs().showControls = false;
17915 fschmid 319
                m_canvas->m_viewMode.previewVisual = 0;
23509 craig 320
                m_doc->previewVisual = 0;
6802 subik 321
                // warning popping up in case colour management and out-of-gamut-display are active
322
                // as from #4346: Add a preview for daltonian - PV
23509 craig 323
                if (m_doc->HasCMS && m_doc->Gamut)
19605 jghali 324
                        ScMessageBox::information(m_ScMW, tr("Preview Mode"),
22638 craig 325
                                                                          "<qt>" + tr("CMS is active. Therefore the color display may not match the perception by visually impaired") + "</qt>");
5237 fschmid 326
        }
327
        else
7624 fschmid 328
        {
18590 fschmid 329
                if (m_AnnotChanged)
23509 craig 330
                        m_doc->ResetFormFields();
19009 craig 331
                m_ScMW->scrActions["viewEditInPreview"]->setEnabled(false);
23509 craig 332
                m_doc->guidesPrefs().framesShown = storedFramesShown;
333
                m_doc->guidesPrefs().showControls = storedShowControls;
19510 jghali 334
                m_canvas->m_viewMode.previewVisual = 0;
23509 craig 335
                m_doc->previewVisual = 0;
336
                if (m_ScMW->viewToolBar->visualMenu->currentIndex() != m_doc->previewVisual)
17910 fschmid 337
                        recalc = true;
23509 craig 338
                m_ScMW->viewToolBar->setDoc(m_doc);
7624 fschmid 339
        }
19495 craig 340
        m_ScMW->appModeHelper->setPreviewMode(inPreview);
17909 fschmid 341
        m_ScMW->setPreviewToolbar();
19009 craig 342
        m_ScMW->viewToolBar->setViewPreviewMode(inPreview);
23509 craig 343
        ScGuardedPtr<ScribusDoc> docPtr = m_doc->guardedPtr();
17910 fschmid 344
        if (recalc)
345
        {
23509 craig 346
                m_doc->recalculateColors();
347
                m_doc->recalcPicturesRes();
17910 fschmid 348
        }
13909 jghali 349
        if (docPtr) // document may have been destroyed in-between
350
        {
351
                DrawNew();
18590 fschmid 352
                if ((!m_EditModeWasOn) && (!m_AnnotChanged))
23509 craig 353
                        m_doc->setModified(m_ChangedState);
13909 jghali 354
        }
17744 craig 355
        undoManager->setUndoEnabled(true);
5235 fschmid 356
}
357
 
16639 jghali 358
void ScribusView::changed(QRectF re, bool)
2171 fschmid 359
{
12079 avox 360
        double scale = m_canvas->scale();
23509 craig 361
        int newCanvasWidth  = qRound((m_doc->maxCanvasCoordinate.x() - m_doc->minCanvasCoordinate.x()) * scale);
362
        int newCanvasHeight = qRound((m_doc->maxCanvasCoordinate.y() - m_doc->minCanvasCoordinate.y()) * scale);
22801 jghali 363
        QSize newCanvasSize(newCanvasWidth, newCanvasHeight);
364
        if (!re.isValid() && /* don't check this all the time */
365
                        (m_oldCanvasSize != newCanvasSize))
12079 avox 366
        {
367
                QSize maxViewport = maximumViewportSize();
22801 jghali 368
                horizontalScrollBar()->setRange(0, newCanvasWidth - maxViewport.width());
369
                verticalScrollBar()->setRange(0, newCanvasHeight - maxViewport.height());
370
                /*      qDebug() << "adjustCanvas [" << m_oldCanvasSize.width() << m_oldCanvasSize.height() << " ] -> [" << newCanvasWidth << newCanvasHeight
12079 avox 371
                                << "] (" << Doc->minCanvasCoordinate.x() << Doc->minCanvasCoordinate.y() << ") - ("
372
                                << Doc->maxCanvasCoordinate.x() << Doc->maxCanvasCoordinate.y() << ") @" << scale << maxViewport;
373
                */
22801 jghali 374
                widget()->resize(newCanvasWidth, newCanvasHeight);
375
                m_oldCanvasSize = newCanvasSize;
12079 avox 376
        }
23509 craig 377
        if (!m_doc->isLoading() && !m_ScMW->scriptIsRunning())
11509 fschmid 378
        {
12820 pierre 379
//              qDebug() << "ScribusView-changed(): changed region:" << re;
18499 craig 380
                m_canvas->setForcedRedraw(true);
11509 fschmid 381
                updateCanvas(re);
382
        }
2171 fschmid 383
}
384
 
13371 jghali 385
bool ScribusView::handleObjectImport(QMimeData* mimeData, TransactionSettings* trSettings)
12971 jghali 386
{
387
        requestMode(modeImportObject);
23662 craig 388
        CanvasMode_ObjImport* objImport = qobject_cast<CanvasMode_ObjImport*>(m_canvasMode);
12971 jghali 389
        if (objImport)
390
        {
391
                objImport->setMimeData(mimeData);
13371 jghali 392
                objImport->setTransactionSettings(trSettings);
12971 jghali 393
                return true;
394
        }
13371 jghali 395
        delete trSettings;
12971 jghali 396
        delete mimeData;
397
        return false;
398
}
399
 
10701 avox 400
void ScribusView::startGesture(CanvasGesture* gesture)
401
{
19954 craig 402
        //qDebug() << "start gesture" << typeid(*m_canvasMode).name()
403
        //              << "---->"
404
        //              << typeid(*gesture).name();
13220 jghali 405
        if (m_canvasMode != gesture)
406
        {
407
                m_canvasMode->deactivate(true);
408
                gesture->setDelegate(m_canvasMode);
409
                m_canvasMode = gesture;
410
                m_canvasMode->activate(false);
23509 craig 411
                if (m_doc->appMode != modeEditClip)
13220 jghali 412
                        m_canvas->repaint();
413
        }
10701 avox 414
}
415
 
416
void ScribusView::stopGesture()
417
{
19954 craig 418
        //qDebug() << "stop gesture" << typeid(*m_canvasMode).name() << (m_canvasMode->delegate() != 0);
10701 avox 419
        if (m_canvasMode->delegate())
420
        {
421
                m_canvasMode->deactivate(false);
422
                m_canvasMode = m_canvasMode->delegate();
423
                m_canvasMode->activate(true);
23060 craig 424
                if (PrefsManager::instance().appPrefs.uiPrefs.stickyTools)
11531 fschmid 425
                {
18499 craig 426
                        m_canvas->setForcedRedraw(true);
22638 craig 427
                        //                      Doc->m_Selection->clear();
428
                        //                      emit HaveSel();
11531 fschmid 429
                        m_canvas->resetRenderMode();
430
                        updateContents();
431
                }
432
                else
433
                        m_canvas->repaint();
10701 avox 434
        }
435
}
436
 
10532 avox 437
/**
438
switches between appmodes:
20681 craig 439
 - for submodes, activate the appropriate dialog or palette
10532 avox 440
 - set a new CanvasMode if necessary
441
 - call ScribusMainWindow::setAppMode(), which de/activates actions
442
 */
443
void ScribusView::requestMode(int appMode)
456 fschmid 444
{
10532 avox 445
        bool updateNecessary = false;
22638 craig 446
        //      qDebug() << "request mode:" << appMode;
22801 jghali 447
        switch (appMode) // filter submodes
456 fschmid 448
        {
10532 avox 449
                case submodePaintingDone:   // return to normal mode
11171 fschmid 450
                        appMode = modeNormal;
10532 avox 451
                        m_previousMode = -1;
452
                        updateNecessary = true;
11960 subik 453
                        break;
10532 avox 454
                case submodeEndNodeEdit:     // return from node/shape editing
11171 fschmid 455
                        appMode = modeNormal;
10532 avox 456
                        m_previousMode = -1;
457
                        updateNecessary = true;
10560 avox 458
                        break;
10532 avox 459
                case submodeLoadPic:         // open GetImage dialog
17735 craig 460
                        m_ScMW->slotGetContent();
23509 craig 461
                        appMode = m_doc->appMode;
10532 avox 462
                        m_previousMode = appMode;
463
                        break;
464
                case submodeStatusPic:       // open ManageImages dialog
23509 craig 465
                        appMode = m_doc->appMode;
10532 avox 466
                        m_previousMode = appMode;
467
                        m_ScMW->StatusPic();
468
                        break;
469
                case submodeEditExternal:    // open external image editor
23509 craig 470
                        appMode = m_doc->appMode;
10532 avox 471
                        m_previousMode = appMode;
472
                        m_ScMW->callImageEditor();
473
                        break;
11960 subik 474
                case submodeAnnotProps:
23509 craig 475
                        appMode = m_doc->appMode;
10532 avox 476
                        m_previousMode = appMode;
477
                        m_ScMW->ModifyAnnot();
478
                        break;
16029 fschmid 479
                case submodeEditSymbol:
23509 craig 480
                        appMode = m_doc->appMode;
16029 fschmid 481
                        m_previousMode = appMode;
482
                        m_ScMW->editSelectedSymbolStart();
483
                        break;
10532 avox 484
                default:
485
                        if (appMode < 0 || appMode > submodeFirstSubmode)
486
                                appMode = modeNormal;
11960 subik 487
                        m_previousMode = appMode;
10532 avox 488
                        break;
489
        }
6922 fschmid 490
 
23509 craig 491
        if (m_doc->appMode != appMode)
456 fschmid 492
        {
23509 craig 493
                m_ScMW->appModeHelper->setApplicationMode(m_ScMW, m_doc, appMode);
10532 avox 494
                CanvasMode* newCanvasMode = modeInstances.value(appMode);
495
                if (!newCanvasMode)
2934 fschmid 496
                {
10532 avox 497
                        newCanvasMode = CanvasMode::createForAppMode(this, appMode);
498
                        modeInstances[appMode] = newCanvasMode;
8994 fschmid 499
                }
10532 avox 500
                if (newCanvasMode)
8994 fschmid 501
                {
10701 avox 502
                        m_canvasMode->deactivate(false);
10532 avox 503
                        m_canvasMode = newCanvasMode;
10701 avox 504
                        m_canvasMode->activate(false);
2934 fschmid 505
                }
10532 avox 506
                updateNecessary = true;
8770 fschmid 507
        }
10604 fschmid 508
        else
19495 craig 509
        {
23509 craig 510
                m_ScMW->appModeHelper->setApplicationMode(m_ScMW, m_doc, appMode);
19495 craig 511
        }
10532 avox 512
        if (updateNecessary)
10869 avox 513
                updateCanvas();
21915 craig 514
        //setCursorBasedOnAppMode(appMode);
456 fschmid 515
}
516
 
21915 craig 517
/*
19495 craig 518
void ScribusView::setCursorBasedOnAppMode(int appMode)
519
{
20185 craig 520
        IconManager* im=IconManager::instance();
19495 craig 521
        int docSelectionCount = Doc->m_Selection->count();
522
        switch (appMode)
523
        {
524
                case modeDrawShapes:
525
                case modeDrawArc:
526
                case modeDrawSpiral:
527
                        if (docSelectionCount!=0)
528
                                Deselect(true);
21740 craig 529
                        setCursor(im->loadCursor("drawframe.png"));
19495 craig 530
                        break;
531
                case modeDrawImage:
532
                        if (docSelectionCount!=0)
533
                                Deselect(true);
21740 craig 534
                        setCursor(im->loadCursor("drawimageframe.png"));
19495 craig 535
                        break;
536
                case modeDrawLatex:
537
                        if (docSelectionCount!=0)
538
                                Deselect(true);
21740 craig 539
                        setCursor(im->loadCursor("drawlatexframe.png"));
19495 craig 540
                        break;
541
                case modeDrawText:
542
                        if (docSelectionCount!=0)
543
                                Deselect(true);
21740 craig 544
                        setCursor(im->loadCursor("drawtextframe.png"));
19495 craig 545
                        break;
546
                case modeDrawTable2:
547
                        if (docSelectionCount!=0)
548
                                Deselect(true);
21740 craig 549
                        setCursor(im->loadCursor("drawtable.png"));
19495 craig 550
                        break;
551
                case modeDrawRegularPolygon:
552
                        if (docSelectionCount!=0)
553
                                Deselect(true);
21915 craig 554
                        setCursor(im->loadCursor("drawpolyline.png"));
19495 craig 555
                        break;
556
                case modeMagnifier:
557
                        if (docSelectionCount!=0)
558
                                Deselect(true);
559
                        Magnify = true;
21740 craig 560
                        setCursor(im->loadCursor("lupez.png"));
19495 craig 561
                        break;
562
                case modePanning:
21740 craig 563
                        setCursor(im->loadCursor("handc.png"));
19495 craig 564
                        break;
565
                case modeDrawLine:
566
                case modeDrawBezierLine:
567
                        setCursor(QCursor(Qt::CrossCursor));
568
                        break;
569
                case modeDrawCalligraphicLine:
570
                case modeDrawFreehandLine:
20195 craig 571
                        setCursor(im->loadCursor("DrawFreeLine.png", 0, 32));
19495 craig 572
                        break;
573
                case modeEyeDropper:
20195 craig 574
                        setCursor(im->loadCursor("colorpickercursor.png", 0, 32));
19495 craig 575
                        break;
576
                case modeInsertPDFButton:
577
                case modeInsertPDFRadioButton:
578
                case modeInsertPDFTextfield:
579
                case modeInsertPDFCheckbox:
580
                case modeInsertPDFCombobox:
581
                case modeInsertPDFListbox:
582
                case modeInsertPDFTextAnnotation:
583
                case modeInsertPDFLinkAnnotation:
584
                case modeInsertPDF3DAnnotation:
585
                        if (docSelectionCount!=0)
586
                                Deselect(true);
587
                        setCursor(QCursor(Qt::CrossCursor));
588
                        break;
20539 craig 589
                case modeLinkFrames:
590
                        setCursor(im->loadCursor("LinkTextFrame.png", 0, 31));
591
                        break;
19495 craig 592
                case modeMeasurementTool:
593
                case modeEditGradientVectors:
594
                case modeEditMeshGradient:
595
                case modeEditArc:
596
                case modeEditPolygon:
597
                case modeEditSpiral:
598
                        setCursor(QCursor(Qt::CrossCursor));
599
                        break;
600
                default:
601
                        setCursor(QCursor(Qt::ArrowCursor));
602
                break;
603
        }
604
}
21915 craig 605
*/
456 fschmid 606
 
10532 avox 607
 
10701 avox 608
/*
10532 avox 609
void ScribusView::paintEvent ( QPaintEvent * p )
456 fschmid 610
{
10532 avox 611
        #ifndef _WIN32
612
        if (p->spontaneous())
613
                evSpon = true;
614
        #endif
615
        QScrollArea::paintEvent(p);
616
//      QPainter qp(viewport());
617
//      drawContents(&qp, p->rect().x(), p->rect().y(), p->rect().width(), p->rect().height());
456 fschmid 618
}
10701 avox 619
*/
456 fschmid 620
 
10532 avox 621
void ScribusView::enterEvent(QEvent * e)
6583 fschmid 622
{
10532 avox 623
        m_canvasMode->enterEvent(e);
6583 fschmid 624
}
625
 
10532 avox 626
void ScribusView::leaveEvent(QEvent *e)
456 fschmid 627
{
10532 avox 628
        m_canvasMode->leaveEvent(e);
456 fschmid 629
}
630
 
631
void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
632
{
633
        QString text;
12973 fschmid 634
        bool /* dataFound = false, */ fromFile = false;
23662 craig 635
        const ScElemMimeData* elemData = qobject_cast<const ScElemMimeData*>(e->mimeData());
12841 jghali 636
        if (elemData)
637
                text = elemData->scribusElem();
638
        else if (e->mimeData()->hasUrls())
456 fschmid 639
        {
21322 fschmid 640
                QList<QUrl> urls = e->mimeData()->urls();
641
                if (!urls.isEmpty())
12841 jghali 642
                {
21322 fschmid 643
                        QUrl url = urls[0];
644
                        QFileInfo fi(url.toLocalFile());
645
                        if (fi.exists())
646
                        {
647
                                fromFile = true;
648
                                text = url.toLocalFile();
649
                        }
12841 jghali 650
                }
651
        }
20579 jghali 652
 
653
        bool hasSupportedFormat = !text.isEmpty();
654
        hasSupportedFormat |= e->mimeData()->hasFormat("text/inline");
655
        hasSupportedFormat |= e->mimeData()->hasFormat("text/symbol");
656
        hasSupportedFormat |= e->mimeData()->hasUrls();
657
        if (!hasSupportedFormat)
12841 jghali 658
        {
20579 jghali 659
                e->ignore();
660
                return;
456 fschmid 661
        }
20579 jghali 662
 
663
        e->accept();
664
        e->acceptProposedAction();
665
 
666
        if (text.isEmpty())
667
                return;
668
 
669
        double gx, gy, gw, gh;
670
        ScriXmlDoc ss;
22686 jghali 671
        if (ss.readElemHeader(text, fromFile, &gx, &gy, &gw, &gh))
20579 jghali 672
        {
673
                FPoint dragPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
674
                dragX = dragPosDoc.x(); //e->pos().x() / m_canvas->scale();
675
                dragY = dragPosDoc.y(); //e->pos().y() / m_canvas->scale();
676
                dragW = gw;
677
                dragH = gh;
678
                DraggedGroup = true;
679
                getDragRectScreen(&gx, &gy, &gw, &gh);
22638 craig 680
                //              QPoint evP = viewport()->mapToGlobal(e->pos());
681
                //              evP -= QPoint(contentsX(), contentsY());
682
                //              redrawMarker->setGeometry(QRect(evP.x() + 1, evP.y() + 1, qRound(gw), qRound(gh)).normalized());
683
                //              if (!redrawMarker->isVisible())
684
                //                      redrawMarker->show();
20579 jghali 685
                emit ItemGeom();
686
        }
456 fschmid 687
}
688
 
689
void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
690
{
691
        QString text;
9745 fschmid 692
        e->accept();
9764 jghali 693
        if (e->mimeData()->hasText())
456 fschmid 694
        {
9745 fschmid 695
                e->acceptProposedAction();
9764 jghali 696
                text = e->mimeData()->text();
456 fschmid 697
                if (DraggedGroup)
698
                {
22638 craig 699
                        //                      double gx, gy, gw, gh;
11477 avox 700
                        FPoint dragPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
701
                        dragX = dragPosDoc.x(); //e->pos().x() / m_canvas->scale();
702
                        dragY = dragPosDoc.y(); //e->pos().y() / m_canvas->scale();
22638 craig 703
                        //                      getDragRectScreen(&gx, &gy, &gw, &gh);
704
                        //                      QPoint evP = viewport()->mapToGlobal(e->pos());
705
                        //                      evP -= QPoint(contentsX(), contentsY());
706
                        //                      redrawMarker->setGeometry(QRect(evP.x() + 2, evP.y() + 2, qRound(gw - 2), qRound(gh - 2)).normalized());
707
                        //                      if (!redrawMarker->isVisible())
708
                        //                              redrawMarker->show();
10532 avox 709
                        emit MousePos(dragX, dragY); //+Doc->minCanvasCoordinate.x(), dragY+Doc->minCanvasCoordinate.y());
11477 avox 710
                        QPoint pos = m_canvas->canvasToLocal(dragPosDoc);
22805 jghali 711
                        horizRuler->draw(pos.x());
712
                        vertRuler->draw(pos.y());
22638 craig 713
                        //                      return;
456 fschmid 714
                }
22638 craig 715
                /*              QUrl ur(text);
12838 jghali 716
                QFileInfo fi = QFileInfo(ur.toLocalFile());
10398 cbradney 717
                QString ext = fi.extension(false).toUpper();
456 fschmid 718
                QStrList imfo = QImageIO::inputFormats();
719
                if (ext == "JPG")
720
                        ext = "JPEG";
721
                img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
722
                if (!SeleItemPos(e->pos()))
723
                {
724
                        if (SelItem.count() != 0)
725
                                Deselect(true);
726
                }
727
                else
728
                {
22705 jghali 729
                        item = SelItem.at(0);
456 fschmid 730
                        if (img)
731
                        {
22705 jghali 732
                                if (item->PType != 2)
456 fschmid 733
                                        Deselect(true);
734
                        }
735
                        else
736
                        {
22705 jghali 737
                                if (item->PType != 4)
456 fschmid 738
                                        Deselect(true);
739
                        }
740
                } */
741
        }
742
}
743
 
632 fschmid 744
void ScribusView::contentsDragLeaveEvent(QDragLeaveEvent *)
456 fschmid 745
{
746
        if (DraggedGroup)
747
        {
748
                DraggedGroup = false;
10532 avox 749
                m_canvas->resetRenderMode();
22638 craig 750
                //              redrawMarker->hide();
9745 fschmid 751
                updateContents();
456 fschmid 752
        }
753
}
754
 
755
void ScribusView::contentsDropEvent(QDropEvent *e)
756
{
757
        QString text;
11486 avox 758
        QUrl url;
1957 cbradney 759
        PageItem *currItem;
19421 jghali 760
        UndoTransaction activeTransaction;
456 fschmid 761
        bool img = false;
22704 jghali 762
        bool selectedItemByDrag = false;
763
        int re = 0;
764
 
10532 avox 765
        m_canvas->resetRenderMode();
9745 fschmid 766
        e->accept();
22704 jghali 767
 
11477 avox 768
        FPoint dropPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
11475 avox 769
        QPointF dropPosDocQ(dropPosDoc.x(), dropPosDoc.y());
22704 jghali 770
 
21241 fschmid 771
        //Loop through all items and see which one(s) were under the drop point on the current layer
772
        //Should make a nice function for this.
24601 jghali 773
        //#9051: loop in reverse order so that items in front of others are prioritized
23509 craig 774
        m_doc->m_Selection->delaySignalsOn();
775
        for (int i = m_doc->Items->count() - 1; i >= 0 ; --i)
456 fschmid 776
        {
24601 jghali 777
                PageItem* item = m_doc->Items->at(i);
778
                if (item->m_layerID != m_doc->activeLayer())
779
                        continue;
780
                if ((m_doc->masterPageMode())  && (!((item->OwnPage == -1) || (item->OwnPage == m_doc->currentPage()->pageNr()))))
781
                        continue;
782
                if (m_canvas->frameHitTest(dropPosDocQ, item) >= Canvas::INSIDE)
21241 fschmid 783
                {
24601 jghali 784
                        deselectItems(false);
785
                        m_doc->m_Selection->addItem(item);
786
                        selectedItemByDrag = true;
787
                        break;
21241 fschmid 788
                }
12841 jghali 789
        }
23509 craig 790
        m_doc->m_Selection->delaySignalsOff();
22704 jghali 791
 
21241 fschmid 792
        QStringList imfo;
793
        QList<QByteArray> imgs = QImageReader::supportedImageFormats();
794
        for (int i = 0; i < imgs.count(); ++i )
12841 jghali 795
        {
21241 fschmid 796
                imfo.append(QString(imgs.at(i)).toUpper());
797
        }
798
        QString formatD(FormatsManager::instance()->extensionListForFormat(FormatsManager::IMAGESIMGFRAME, 1).toUpper());
799
        imfo += formatD.split("|");
22704 jghali 800
 
21241 fschmid 801
        if (e->mimeData()->hasUrls())
802
        {
803
                if ((e->mimeData()->urls().count() == 1) || selectedItemByDrag)
804
                {
805
                        url = e->mimeData()->urls().at(0);
22704 jghali 806
                        text.clear();
21241 fschmid 807
                }
808
                else
809
                {
810
                        int dropOffsetX = 0;
811
                        int dropOffsetY = 0;
812
                        QList<QUrl> fileUrls = e->mimeData()->urls();
813
                        for (int a = 0; a < fileUrls.count(); a++)
814
                        {
815
                                url = fileUrls[a];
816
                                QFileInfo fi(url.toLocalFile());
817
                                QString ext = fi.suffix().toUpper();
818
                                if (ext == "JPG")
819
                                        ext = "JPEG";
22705 jghali 820
                                if (!imfo.contains(ext) || !fi.exists() || selectedItemByDrag)
821
                                        continue;
23509 craig 822
                                int z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, dropPosDoc.x() + dropOffsetX, dropPosDoc.y() + dropOffsetY, 1, 1, m_doc->itemToolPrefs().shapeLineWidth, m_doc->itemToolPrefs().imageFillColor, m_doc->itemToolPrefs().imageStrokeColor);
823
                                PageItem *item = m_doc->Items->at(z);
824
                                item->m_layerID = m_doc->activeLayer();
825
                                m_doc->loadPict(url.toLocalFile(), item);
22705 jghali 826
                                double iw = static_cast<double>(item->OrigW * 72.0 / item->pixm.imgInfo.xres);
827
                                double ih = static_cast<double>(item->OrigH * 72.0 / item->pixm.imgInfo.yres);
828
                                if (iw > ih)
21241 fschmid 829
                                {
23509 craig 830
                                        double pw = m_doc->currentPage()->width();
22705 jghali 831
                                        if (iw > pw)
21241 fschmid 832
                                        {
22705 jghali 833
                                                ih = pw * (ih / iw);
834
                                                iw = pw;
21241 fschmid 835
                                        }
22705 jghali 836
                                }
837
                                else
838
                                {
23509 craig 839
                                        double ph = m_doc->currentPage()->height();
22705 jghali 840
                                        if (ih > ph)
21241 fschmid 841
                                        {
22705 jghali 842
                                                iw = ph * (iw / ih);
843
                                                ih = ph;
21241 fschmid 844
                                        }
845
                                }
22705 jghali 846
                                item->setWidth(iw);
847
                                item->setHeight(ih);
848
                                item->OldB2 = item->width();
849
                                item->OldH2 = item->height();
850
                                item->updateClip();
22821 jghali 851
                                item->adjustPictScale();
22705 jghali 852
                                item->update();
23509 craig 853
                                dropOffsetX += m_doc->opToolPrefs().dispX;
854
                                dropOffsetY += m_doc->opToolPrefs().dispY;
21241 fschmid 855
                        }
856
                        emit DocChanged();
857
                        update();
858
                        return;
859
                }
860
        }
22704 jghali 861
        else if (e->mimeData()->hasFormat("application/x-scribus-elem"))
21241 fschmid 862
        {
23662 craig 863
                const ScElemMimeData* scMimeData = qobject_cast<const ScElemMimeData*>(e->mimeData());
22704 jghali 864
                if (scMimeData)
865
                        text = scMimeData->scribusElem();
11486 avox 866
        }
15060 fschmid 867
        else if (e->mimeData()->hasFormat("text/symbol"))
868
        {
869
                e->acceptProposedAction();
870
                activateWindow();
871
                if (!m_ScMW->scriptIsRunning())
872
                        raise();
23509 craig 873
                m_ScMW->newActWin((dynamic_cast<ScribusWin*>(m_doc->WinHan))->getSubWin());
15060 fschmid 874
                updateContents();
875
                QString patternVal = e->mimeData()->data("text/symbol");
23509 craig 876
                m_doc->m_Selection->delaySignalsOn();
877
                for (int i = m_doc->Items->count() - 1; i >= 0 ; --i)
15060 fschmid 878
                {
24601 jghali 879
                        PageItem* item = m_doc->Items->at(i);
880
                        if (item->m_layerID != m_doc->activeLayer())
881
                                continue;
882
                        if ((m_doc->masterPageMode())  && (!((item->OwnPage == -1) || (item->OwnPage == m_doc->currentPage()->pageNr()))))
883
                                continue;
884
                        if ((m_canvas->frameHitTest(dropPosDocQ, m_doc->Items->at(i)) >= Canvas::INSIDE) && (item->itemType() == PageItem::Symbol))
15060 fschmid 885
                        {
24601 jghali 886
                                deselectItems(false);
887
                                m_doc->m_Selection->addItem(m_doc->Items->at(i));
888
                                m_doc->Items->at(i)->setPattern(patternVal);
889
                                selectedItemByDrag = true;
890
                                break;
15060 fschmid 891
                        }
892
                }
23509 craig 893
                m_doc->m_Selection->delaySignalsOff();
15060 fschmid 894
                if (!selectedItemByDrag)
895
                {
23509 craig 896
                        int z = m_doc->itemAdd(PageItem::Symbol, PageItem::Unspecified, dropPosDoc.x(), dropPosDoc.y(), 1, 1, 0, CommonStrings::None, CommonStrings::None);
897
                        PageItem *item = m_doc->Items->at(z);
898
                        item->m_layerID = m_doc->activeLayer();
899
                        ScPattern pat = m_doc->docPatterns[patternVal];
22705 jghali 900
                        item->setWidth(pat.width);
901
                        item->setHeight(pat.height);
902
                        item->OldB2 = item->width();
903
                        item->OldH2 = item->height();
904
                        item->setPattern(patternVal);
905
                        item->updateClip();
23390 craig 906
                        deselectItems(false);
23509 craig 907
                        m_doc->m_Selection->addItem(item);
15060 fschmid 908
                }
909
                emit DocChanged();
910
                update();
911
                return;
912
        }
17799 fschmid 913
        else if (e->mimeData()->hasFormat("text/inline"))
914
        {
23509 craig 915
                if (((m_doc->appMode == modeEditTable) || (m_doc->appMode == modeEdit)) && (!m_doc->m_Selection->isEmpty()))
17799 fschmid 916
                {
23509 craig 917
                        PageItem *item = m_doc->m_Selection->itemAt(0);
22705 jghali 918
                        if (item->isTextFrame() || item->isTable())
17799 fschmid 919
                        {
920
                                e->acceptProposedAction();
921
                                activateWindow();
922
                                if (!m_ScMW->scriptIsRunning())
923
                                        raise();
23509 craig 924
                                m_ScMW->newActWin((dynamic_cast<ScribusWin*>(m_doc->WinHan))->getSubWin());
17799 fschmid 925
                                updateContents();
926
                                QString patternVal = e->mimeData()->data("text/inline");
927
                                int id = patternVal.toInt();
928
                                PageItem_TextFrame *cItem;
23509 craig 929
                                if (m_doc->appMode == modeEditTable)
22705 jghali 930
                                        cItem = item->asTable()->activeCell().textFrame();
17799 fschmid 931
                                else
22705 jghali 932
                                        cItem = item->asTextFrame();
17799 fschmid 933
                                if (cItem->HasSel)
934
                                        cItem->deleteSelectedTextFromFrame();
17826 craig 935
                                cItem->invalidateLayout(false);
17799 fschmid 936
                                cItem->itemText.insertObject(id);
22705 jghali 937
                                if (item->isTable())
938
                                        item->asTable()->update();
17799 fschmid 939
                                else
22705 jghali 940
                                        item->update();
17799 fschmid 941
                                emit DocChanged();
942
                                update();
943
                                return;
944
                        }
945
                }
946
        }
20579 jghali 947
 
22638 craig 948
        //      qDebug() << "ScribusView::contentsDropEvent" << e->mimeData()->formats() << url;
22704 jghali 949
        if (url.isEmpty() && text.isEmpty())
11486 avox 950
        {
20579 jghali 951
                e->ignore();
952
                return;
953
        }
954
 
955
        e->acceptProposedAction();
956
        //<<#3524
957
        activateWindow();
958
        if (!m_ScMW->scriptIsRunning())
959
                raise();
22318 craig 960
 
23509 craig 961
        ScribusWin* sw = dynamic_cast<ScribusWin*>(m_doc->WinHan);
22318 craig 962
        if (!sw)
963
                qFatal("ScribusView::contentsDropEvent !sw");
964
        m_ScMW->newActWin(sw->getSubWin());
20579 jghali 965
        updateContents();
966
        //>>
967
        QFileInfo fi;
22318 craig 968
        QString ext;
22704 jghali 969
        if (!e->mimeData()->hasFormat("application/x-scribus-elem"))
20579 jghali 970
        {
971
                fi.setFile(url.toLocalFile());
972
                ext = fi.suffix().toUpper();
973
        }
974
        if (ext == "JPG")
975
                ext = "JPEG";
976
        img = imfo.contains(ext);
977
        bool vectorFile = false;
978
        if (fi.exists())
979
        {
980
                if (fi.suffix().toLower() == "sce")
981
                        vectorFile = true;
12061 fschmid 982
                else
983
                {
20579 jghali 984
                        FileLoader *fileLoader = new FileLoader(url.toLocalFile());
985
                        int testResult = fileLoader->testFile();
986
                        delete fileLoader;
987
                        if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
12061 fschmid 988
                                vectorFile = true;
989
                }
20579 jghali 990
        }
991
        else
992
        {
993
                if ((text.startsWith("<SCRIBUSELEM")) || (text.startsWith("SCRIBUSFRAGMENT")))
994
                        vectorFile = true;
995
        }
22638 craig 996
        //              qDebug() << "drop - img:" << img << "file:" << fi.exists() << "suffix:" << fi.suffix() << "select by drag:" << selectedItemByDrag;
20579 jghali 997
        //CB When we drag an image to a page from outside
998
        //SeleItemPos is from 1.2.x. Needs reenabling for dragging *TO* a frame
999
        if ((fi.exists()) && (img) && !selectedItemByDrag && !vectorFile)// && (!SeleItemPos(e->pos())))
1000
        {
23509 craig 1001
                int z = m_doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, dropPosDoc.x(), dropPosDoc.y(), 1, 1, m_doc->itemToolPrefs().shapeLineWidth, m_doc->itemToolPrefs().imageFillColor, m_doc->itemToolPrefs().imageStrokeColor);
1002
                PageItem *item = m_doc->Items->at(z);
1003
                item->m_layerID = m_doc->activeLayer();
1004
                m_doc->loadPict(url.toLocalFile(), item);
20579 jghali 1005
 
22705 jghali 1006
                double iw = static_cast<double>(item->OrigW * 72.0 / item->pixm.imgInfo.xres);
1007
                double ih = static_cast<double>(item->OrigH * 72.0 / item->pixm.imgInfo.yres);
20579 jghali 1008
                if (iw > ih)
12110 fschmid 1009
                {
23509 craig 1010
                        double pw = m_doc->currentPage()->width();
20579 jghali 1011
                        if (iw > pw)
19384 craig 1012
                        {
20579 jghali 1013
                                ih = pw * (ih / iw);
1014
                                iw = pw;
19384 craig 1015
                        }
20579 jghali 1016
                }
1017
                else
1018
                {
23509 craig 1019
                        double ph = m_doc->currentPage()->height();
20579 jghali 1020
                        if (ih > ph)
19384 craig 1021
                        {
20579 jghali 1022
                                iw = ph * (iw / ih);
1023
                                ih = ph;
19384 craig 1024
                        }
20579 jghali 1025
                }
19384 craig 1026
 
22705 jghali 1027
                item->setWidth(iw);
1028
                item->setHeight(ih);
1029
                item->OldB2 = item->width();
1030
                item->OldH2 = item->height();
1031
                item->updateClip();
22821 jghali 1032
                item->adjustPictScale();
22705 jghali 1033
                item->update();
20579 jghali 1034
                emit DocChanged();
1035
                update();
1036
                return;
1037
        }
1038
        //if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
22638 craig 1039
        //              if (Doc->m_Selection->count()>0 && (m_canvas->frameHitTest(dropPosDocQ, Doc->m_Selection->itemAt(0)) >= Canvas::INSIDE) && !vectorFile) // && (img))
23509 craig 1040
        if (selectedItemByDrag && (m_canvas->frameHitTest(dropPosDocQ, m_doc->m_Selection->itemAt(0)) >= Canvas::INSIDE) && ((!vectorFile) || (img)))
20579 jghali 1041
        {
23509 craig 1042
                PageItem *item = m_doc->m_Selection->itemAt(0);
22705 jghali 1043
                if (item->itemType() == PageItem::ImageFrame)
456 fschmid 1044
                {
20579 jghali 1045
                        if ((fi.exists()) && (img))
23509 craig 1046
                                m_doc->loadPict(url.toLocalFile(), item);
20579 jghali 1047
                }
22705 jghali 1048
                else if (item->itemType() == PageItem::TextFrame)
1049
                {
1050
                        if ((fi.exists()) && (!img))
456 fschmid 1051
                        {
23509 craig 1052
                                gtGetText* gt = new gtGetText(m_doc);
22705 jghali 1053
                                QStringList exts = gt->getSupportedTypes();
1054
                                if (exts.contains(fi.suffix().toLower()))
4494 cbradney 1055
                                {
22705 jghali 1056
                                        ImportSetup impsetup;
1057
                                        impsetup.runDialog = true;
1058
                                        impsetup.encoding = "";
1059
                                        impsetup.prefixNames = true;
1060
                                        impsetup.textOnly = false;
1061
                                        impsetup.importer = -1;
1062
                                        impsetup.filename = url.toLocalFile();
1063
                                        if (item->itemText.length() != 0)
21314 fschmid 1064
                                        {
22705 jghali 1065
                                                int t = ScMessageBox::warning(this, CommonStrings::trWarning, tr("Do you really want to clear all your text?"),
1066
                                                                                                                QMessageBox::Yes | QMessageBox::No,
1067
                                                                                                                QMessageBox::No,        // GUI default
1068
                                                                                                                QMessageBox::Yes);      // batch default
1069
                                                if (t == QMessageBox::No)
21314 fschmid 1070
                                                {
22705 jghali 1071
                                                        delete gt;
1072
                                                        return;
21314 fschmid 1073
                                                }
1074
                                        }
22705 jghali 1075
                                        gt->launchImporter(impsetup.importer, impsetup.filename, impsetup.textOnly, impsetup.encoding, false, impsetup.prefixNames, item);
1076
                                        m_ScMW->updateFromDrop();
1077
                                }
1078
                                else
1079
                                {
1080
                                        QByteArray file;
1081
                                        QTextCodec *codec = QTextCodec::codecForLocale();
1082
                                        // TODO create a Dialog for selecting the codec
1083
                                        if (loadRawText(url.toLocalFile(), file))
21314 fschmid 1084
                                        {
22705 jghali 1085
                                                QString txt = codec->toUnicode( file.data() );
1086
                                                txt.replace(QRegExp("\r"), QChar(13));
1087
                                                txt.replace(QRegExp("\n"), QChar(13));
1088
                                                txt.replace(QRegExp("\t"), QChar(9));
1089
                                                item->itemText.insertChars(txt, true);
21314 fschmid 1090
                                        }
1091
                                }
23509 craig 1092
                                if (m_doc->docHyphenator->AutoCheck)
1093
                                        m_doc->docHyphenator->slotHyphenate(item);
22705 jghali 1094
                                item->invalidateLayout();
1095
                                item->update();
1096
                                delete gt;
11806 fschmid 1097
                        }
22705 jghali 1098
                }
20579 jghali 1099
                emit DocChanged();
1100
                update();
1101
        }
1102
        else
1103
        {
23390 craig 1104
                deselectItems(true);
23509 craig 1105
                int oldDocItemCount = m_doc->Items->count();
1106
                if (((!img) || (vectorFile)) && (m_doc->DraggedElem == nullptr))
4042 subik 1107
                {
20579 jghali 1108
                        activeTransaction = undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Create, "", Um::ICreate);
1109
                        if (fi.exists())
1163 fschmid 1110
                        {
20579 jghali 1111
                                if (fi.suffix().toLower() == "sce")
7289 fschmid 1112
                                {
23509 craig 1113
                                        emit LoadElem(url.toLocalFile(), dropPosDoc.x(), dropPosDoc.y(), true, false, m_doc, this);
20579 jghali 1114
                                }
1115
                                else
1116
                                {
1117
                                        FileLoader *fileLoader = new FileLoader(url.toLocalFile());
1118
                                        int testResult = fileLoader->testFile();
1119
                                        delete fileLoader;
1120
                                        if ((testResult != -1) && (testResult >= FORMATID_FIRSTUSER))
7289 fschmid 1121
                                        {
20579 jghali 1122
                                                const FileFormat * fmt = LoadSavePlugin::getFormatById(testResult);
1123
                                                if( fmt )
10878 fschmid 1124
                                                {
20579 jghali 1125
                                                        // We disable undo here as we are only interested by the item creation undo actions
1126
                                                        // We create them manually after import
1127
                                                        undoManager->setUndoEnabled(false);
23509 craig 1128
                                                        m_doc->dontResize = true;
20579 jghali 1129
                                                        fmt->loadFile(url.toLocalFile(), LoadSavePlugin::lfUseCurrentPage|LoadSavePlugin::lfInteractive|LoadSavePlugin::lfScripted);
1130
                                                        undoManager->setUndoEnabled(true);
23509 craig 1131
                                                        if (m_doc->m_Selection->count() > 0)
10878 fschmid 1132
                                                        {
20579 jghali 1133
                                                                if (UndoManager::undoEnabled())
10878 fschmid 1134
                                                                {
20579 jghali 1135
                                                                        // Create undo actions for created items
23509 craig 1136
                                                                        for (int i = 0; i < m_doc->m_Selection->count(); ++i)
13384 jghali 1137
                                                                        {
23509 craig 1138
                                                                                PageItem* newItem = m_doc->m_Selection->itemAt(i);
20579 jghali 1139
                                                                                ScItemState<PageItem*> *is = new ScItemState<PageItem*>("Create PageItem");
20800 jghali 1140
                                                                                is->set("CREATE_ITEM");
20579 jghali 1141
                                                                                is->setItem(newItem);
1142
                                                                                //Undo target rests with the Page for object specific undo
1143
                                                                                int pindex = (newItem->OwnPage > -1) ? newItem->OwnPage : 0;
23509 craig 1144
                                                                                UndoObject *target = m_doc->Pages->at(pindex);
20579 jghali 1145
                                                                                undoManager->action(target, is);
13384 jghali 1146
                                                                        }
10878 fschmid 1147
                                                                }
20579 jghali 1148
                                                                double x2, y2, w, h;
1149
                                                                // We disable undo temporarily as move actions are not necessary
1150
                                                                // to perform undo correctly here
1151
                                                                undoManager->setUndoEnabled(false);
23509 craig 1152
                                                                m_doc->m_Selection->getGroupRect(&x2, &y2, &w, &h);
1153
                                                                m_doc->moveGroup(dropPosDoc.x() - x2, dropPosDoc.y() - y2);
20579 jghali 1154
                                                                m_ScMW->requestUpdate(reqColorsUpdate | reqSymbolsUpdate | reqTextStylesUpdate | reqLineStylesUpdate);
1155
                                                                undoManager->setUndoEnabled(true);
10878 fschmid 1156
                                                        }
23509 craig 1157
                                                        m_doc->dontResize = false;
10878 fschmid 1158
                                                }
1159
                                        }
7289 fschmid 1160
                                }
20579 jghali 1161
                        }
1162
                        else
1163
                        {
23509 craig 1164
                                emit LoadElem(QString(text), dropPosDoc.x(), dropPosDoc.y(), false, false, m_doc, this);
20579 jghali 1165
                        }
1166
                        Selection tmpSelection(this, false);
23509 craig 1167
                        tmpSelection.copy(*m_doc->m_Selection, true);
1168
                        for (int as = oldDocItemCount; as < m_doc->Items->count(); ++as)
20579 jghali 1169
                        {
23509 craig 1170
                                currItem = m_doc->Items->at(as);
1171
                                m_doc->setRedrawBounding(currItem);
20579 jghali 1172
                                tmpSelection.addItem(currItem, true);
1173
                                if (currItem->isBookmark)
1174
                                        emit AddBM(currItem);
1175
                        }
23509 craig 1176
                        m_doc->m_Selection->copy(tmpSelection, false);
1177
                        if (m_doc->m_Selection->count() == 1)
20579 jghali 1178
                        {
23509 craig 1179
                                PageItem *newItem = m_doc->m_Selection->itemAt(0);
1180
                                if ((newItem->width() > m_doc->currentPage()->width()) || (newItem->height() > m_doc->currentPage()->height()))
11486 avox 1181
                                {
22638 craig 1182
                                        //      QMenu *pmen = new QMenu();
1183
                                        //      pmen->addAction( tr("Keep original Size"));
1184
                                        //      pmen->addAction( tr("Scale to Page Size"));
1185
                                        //      re = pmen->actions().indexOf(pmen->exec(QCursor::pos()));
1186
                                        //      delete pmen;
1187
                                        //      if (re == 1)
1188
                                        //      {
23509 craig 1189
                                        m_doc->rescaleGroup(newItem, qMin(qMin(m_doc->currentPage()->width() / newItem->width(), m_doc->currentPage()->height() / newItem->height()), 1.0));
22638 craig 1190
                                        newItem->update();
1191
                                        //      }
11486 avox 1192
                                }
1163 fschmid 1193
                        }
20579 jghali 1194
                        activeTransaction.commit();
1195
                        activeTransaction.reset();
1196
                }
1197
                else
1198
                {
23509 craig 1199
                        if (m_doc->DraggedElem != nullptr)
456 fschmid 1200
                        {
23509 craig 1201
                                if (!m_doc->leaveDrag)
456 fschmid 1202
                                {
20579 jghali 1203
                                        QMenu *pmen = new QMenu();
1204
                                        pmen->addAction( tr("Copy Here"));
1205
                                        QAction* mov = pmen->addAction( tr("Move Here"));
1206
                                        pmen->addAction( tr("Cancel"));
23509 craig 1207
                                        for (int dre=0; dre<m_doc->DragElements.count(); ++dre)
456 fschmid 1208
                                        {
23509 craig 1209
                                                if (m_doc->DragElements[dre]->locked())
6271 fschmid 1210
                                                {
20579 jghali 1211
                                                        mov->setEnabled(false);
1212
                                                        break;
6271 fschmid 1213
                                                }
456 fschmid 1214
                                        }
20579 jghali 1215
                                        re = pmen->actions().indexOf(pmen->exec(QCursor::pos()));
1216
                                        delete pmen;
22516 craig 1217
                                        pmen=nullptr;
20579 jghali 1218
                                }
1219
                                else
1220
                                        re = 1;
1221
                                if ((re == 2) || (re == -1))
1222
                                {
1223
                                        updateContents();
1224
                                        return;
1225
                                }
23509 craig 1226
                                if ((re == 1) || (m_doc->leaveDrag))
20579 jghali 1227
                                {
1228
                                        QList<PageItem*> pasted;
23509 craig 1229
                                        emit LoadElem(QString(text), dropPosDoc.x(), dropPosDoc.y(), false, false, m_doc, this);
1230
                                        for (int as = oldDocItemCount; as < m_doc->Items->count(); ++as)
456 fschmid 1231
                                        {
23509 craig 1232
                                                pasted.append(m_doc->Items->at(as));
456 fschmid 1233
                                        }
20579 jghali 1234
                                        Selection tmpSelection(this, false);
23509 craig 1235
                                        tmpSelection.copy(*m_doc->m_Selection, true);
1236
                                        for (int dre=0; dre<m_doc->DragElements.count(); ++dre)
456 fschmid 1237
                                        {
23509 craig 1238
                                                tmpSelection.addItem(m_doc->DragElements[dre], true);
20579 jghali 1239
                                        }
23509 craig 1240
                                        m_doc->m_Selection->copy(tmpSelection, false);
20579 jghali 1241
                                        PageItem* bb;
1242
                                        int fin;
23509 craig 1243
                                        for (int dre=0; dre<m_doc->DragElements.count(); ++dre)
20579 jghali 1244
                                        {
1245
                                                bb = pasted.at(dre);
23509 craig 1246
                                                currItem = m_doc->m_Selection->itemAt(dre);
23794 craig 1247
                                                if ((currItem->isTextFrame()) && ((currItem->nextInChain() != nullptr) || (currItem->prevInChain() != nullptr)))
456 fschmid 1248
                                                {
20579 jghali 1249
                                                        PageItem* before = currItem->prevInChain();
1250
                                                        PageItem* after = currItem->nextInChain();
1251
                                                        currItem->unlink();
22607 craig 1252
                                                        if (before != nullptr)
456 fschmid 1253
                                                        {
23509 craig 1254
                                                                fin = m_doc->m_Selection->findItem(before);
20579 jghali 1255
                                                                if (fin != -1)
1256
                                                                        before = pasted.at(fin);
1257
                                                                before->unlink();
1258
                                                                before->link(bb);
456 fschmid 1259
                                                        }
22607 craig 1260
                                                        if (after != nullptr)
20579 jghali 1261
                                                        {
23509 craig 1262
                                                                fin = m_doc->m_Selection->findItem(after);
20579 jghali 1263
                                                                if (fin != -1)
1264
                                                                        after = pasted.at(fin);
1265
                                                                bb->link(after);
1266
                                                        }
456 fschmid 1267
                                                }
1268
                                        }
20579 jghali 1269
                                        pasted.clear();
23509 craig 1270
                                        m_doc->itemSelection_DeleteItem();
456 fschmid 1271
                                }
1272
                        }
20579 jghali 1273
                        if ((!img) && ((re == 0)))
23509 craig 1274
                                emit LoadElem(QString(text), dropPosDoc.x(), dropPosDoc.y(), false, false, m_doc, this);
1275
                        m_doc->DraggedElem = nullptr;
1276
                        m_doc->DragElements.clear();
20579 jghali 1277
                        Selection tmpSelection(this, false);
23509 craig 1278
                        tmpSelection.copy(*m_doc->m_Selection, true);
1279
                        for (int as = oldDocItemCount; as < m_doc->Items->count(); ++as)
3640 fschmid 1280
                        {
23509 craig 1281
                                currItem = m_doc->Items->at(as);
1282
                                m_doc->setRedrawBounding(currItem);
20579 jghali 1283
                                tmpSelection.addItem(currItem, true);
1284
                                if (currItem->isBookmark)
1285
                                        emit AddBM(currItem);
1286
                        }
23509 craig 1287
                        m_doc->m_Selection->copy(tmpSelection, false);
20579 jghali 1288
                }
23509 craig 1289
                if (m_doc->m_Selection->count() > 1)
20579 jghali 1290
                {
23509 craig 1291
                        m_doc->m_Selection->connectItemToGUI();
20579 jghali 1292
                        double gx, gy, gh, gw;
23509 craig 1293
                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
20579 jghali 1294
                        double nx = gx;
1295
                        double ny = gy;
23509 craig 1296
                        if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
20579 jghali 1297
                        {
1298
                                FPoint npx;
23509 craig 1299
                                npx = m_doc->ApplyGridF(FPoint(nx, ny));
20579 jghali 1300
                                nx = npx.x();
1301
                                ny = npx.y();
1302
                        }
1303
                        activeTransaction = undoManager->beginTransaction(Um::SelectionGroup, Um::IGroup, Um::Move, "", Um::IMove);
23640 jghali 1304
                        m_doc->moveGroup(nx - gx, ny - gy);
23509 craig 1305
                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
23640 jghali 1306
                        nx = gx + gw;
1307
                        ny = gy + gh;
23509 craig 1308
                        m_doc->ApplyGuides(&nx, &ny);
1309
                        m_doc->ApplyGuides(&nx, &ny,true);
23640 jghali 1310
                        m_doc->moveGroup(nx - (gx + gw), ny - (gy + gh));
23509 craig 1311
                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1312
                        for (int a = 0; a < m_doc->m_Selection->count(); ++a)
20579 jghali 1313
                        {
23509 craig 1314
                                PageItem *currItem = m_doc->m_Selection->itemAt(a);
1315
                                currItem->m_layerID = m_doc->activeLayer();
20579 jghali 1316
                                currItem->gXpos = currItem->xPos() - gx;
1317
                                currItem->gYpos = currItem->yPos() - gy;
1318
                                currItem->gWidth = gw;
1319
                                currItem->gHeight = gh;
1320
                        }
1321
                        activeTransaction.commit();
1322
                        activeTransaction.reset();
1323
                        emit ItemGeom();
1324
                }
23509 craig 1325
                else if (m_doc->m_Selection->count() == 1)
20579 jghali 1326
                {
23509 craig 1327
                        m_doc->m_Selection->connectItemToGUI();
1328
                        currItem = m_doc->m_Selection->itemAt(0);
1329
                        currItem->m_layerID = m_doc->activeLayer();
1330
                        if (m_doc->SnapGrid)
20579 jghali 1331
                        {
1332
                                double nx = currItem->xPos();
1333
                                double ny = currItem->yPos();
23509 craig 1334
                                if (!m_doc->ApplyGuides(&nx, &ny) && !m_doc->ApplyGuides(&nx, &ny,true))
6289 fschmid 1335
                                {
1336
                                        FPoint npx;
23509 craig 1337
                                        npx = m_doc->ApplyGridF(FPoint(nx, ny));
6289 fschmid 1338
                                        nx = npx.x();
1339
                                        ny = npx.y();
1340
                                }
23640 jghali 1341
                                m_doc->moveItem(nx - currItem->xPos(), ny - currItem->yPos(), currItem);
3640 fschmid 1342
                        }
4019 cbradney 1343
                }
23509 craig 1344
                if ((m_doc->m_Selection->count() > 0) && (m_doc->appMode != modeNormal))
20579 jghali 1345
                        this->requestMode(modeNormal);
1346
                updateContents();
1347
        }
23509 craig 1348
        if (!m_doc->masterPageMode())
20579 jghali 1349
        {
23509 craig 1350
                int docPagesCount=m_doc->Pages->count();
1351
                int docCurrPageNo=m_doc->currentPageNumber();
22271 craig 1352
                for (int i = 0; i < docPagesCount; ++i)
6236 fschmid 1353
                {
23509 craig 1354
                        double x = m_doc->Pages->at(i)->xOffset();
1355
                        double y = m_doc->Pages->at(i)->yOffset();
1356
                        double w = m_doc->Pages->at(i)->width();
1357
                        double h = m_doc->Pages->at(i)->height();
20579 jghali 1358
                        if (QRectF(x, y, w, h).contains(dropPosDocQ))
6236 fschmid 1359
                        {
20579 jghali 1360
                                if (docCurrPageNo != i)
6236 fschmid 1361
                                {
23509 craig 1362
                                        m_doc->setCurrentPage(m_doc->Pages->at(i));
20579 jghali 1363
                                        m_ScMW->slotSetCurrentPage(i);
1364
                                        DrawNew();
6236 fschmid 1365
                                }
20579 jghali 1366
                                break;
6236 fschmid 1367
                        }
1368
                }
20579 jghali 1369
                setRulerPos(contentsX(), contentsY());
456 fschmid 1370
        }
1371
}
1372
 
7575 cbradney 1373
void ScribusView::getDragRectScreen(double *x, double *y, double *w, double *h)
456 fschmid 1374
{
23633 jghali 1375
        QPoint in(qRound(dragX * m_canvas->scale()), qRound(dragY * m_canvas->scale()));
22638 craig 1376
        //      in -= QPoint(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(Doc->minCanvasCoordinate.y() * m_canvas->scale()));
7575 cbradney 1377
        QPoint out = contentsToViewport(in);
1378
        *x = static_cast<double>(out.x());
1379
        *y = static_cast<double>(out.y());
23633 jghali 1380
        *w = dragW * m_canvas->scale();
1381
        *h = dragH * m_canvas->scale();
456 fschmid 1382
}
1383
 
1384
void ScribusView::getGroupRectScreen(double *x, double *y, double *w, double *h)
1385
{
7575 cbradney 1386
        double gx, gy, gh, gw;
23509 craig 1387
        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
23633 jghali 1388
        QPoint in(qRound(gx * m_canvas->scale()), qRound(gy * m_canvas->scale()));
22638 craig 1389
        //      in -= QPoint(qRound(Doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(Doc->minCanvasCoordinate.y() * m_canvas->scale()));
456 fschmid 1390
        QPoint out = contentsToViewport(in);
1391
        *x = static_cast<double>(out.x());
1392
        *y = static_cast<double>(out.y());
23633 jghali 1393
        *w = gw * m_canvas->scale();
1394
        *h = gh * m_canvas->scale();
456 fschmid 1395
}
1396
 
10701 avox 1397
 
456 fschmid 1398
 
6344 jghali 1399
void ScribusView::RefreshGradient(PageItem *currItem, double dx, double dy)
1400
{
13951 fschmid 1401
        QTransform matrix;
10532 avox 1402
        QRect rect = currItem->getRedrawBounding(m_canvas->scale());
1403
        m_canvas->Transform(currItem, matrix);
6344 jghali 1404
        FPointArray fpNew;
14197 fschmid 1405
        if (editStrokeGradient)
1406
                fpNew.setPoints(2, currItem->GrStrokeStartX, currItem->GrStrokeStartY, currItem->GrStrokeEndX, currItem->GrStrokeEndY);
1407
        else
1408
                fpNew.setPoints(2, currItem->GrStartX, currItem->GrStartY, currItem->GrEndX, currItem->GrEndY);
6344 jghali 1409
        fpNew.map(matrix);
1410
        if (dx < 8.0) dx = 8.0;
1411
        if (dy < 8.0) dy = 8.0;
8562 jghali 1412
        int grl = (int) floor( qMin(fpNew.point(0).x(), fpNew.point(1).x()) - dx );
1413
        int grr = (int) ceil ( qMax(fpNew.point(0).x(), fpNew.point(1).x()) + dx );
1414
        int grb = (int) ceil ( qMax(fpNew.point(0).y(), fpNew.point(1).y()) + dy );
1415
        int grt = (int) floor( qMin(fpNew.point(0).y(), fpNew.point(1).y()) - dy );
6344 jghali 1416
        rect |= QRect(grl, grt, grr-grl, grb-grt);
1417
        updateContents(rect);
1418
}
1419
 
456 fschmid 1420
 
7571 cbradney 1421
//CB-->elsewhere, util, however, only used in the view for now
1422
bool ScribusView::PointOnLine(QPoint Start, QPoint End, QRect MArea)
456 fschmid 1423
{
1424
        QPoint an, en;
7571 cbradney 1425
        if (Start.x() == End.x())
456 fschmid 1426
        {
7571 cbradney 1427
                an = Start.y() > End.y() ? End : Start;
1428
                en = an == End ? Start : End;
456 fschmid 1429
                for (int a=an.y(); a<en.y(); ++a)
1430
                {
7571 cbradney 1431
                        if (MArea.contains(an.x(), a))
456 fschmid 1432
                                return true;
1433
                }
1434
        }
7571 cbradney 1435
        if (Start.y() == End.y())
456 fschmid 1436
        {
7571 cbradney 1437
                an = Start.x() > End.x() ? End : Start;
1438
                en = an == End ? Start : End;
456 fschmid 1439
                for (int a=an.x(); a<en.x(); ++a)
1440
                {
7571 cbradney 1441
                        if (MArea.contains(a, an.y()))
456 fschmid 1442
                                return true;
1443
                }
1444
        }
7571 cbradney 1445
        if (abs(Start.x() - End.x()) > abs(Start.y() - End.y()))
456 fschmid 1446
        {
7571 cbradney 1447
                an = Start.x() > End.x() ? End : Start;
1448
                en = an == End ? Start : End;
6046 fschmid 1449
                double stg = (en.y() - an.y()) / static_cast<double>((en.x() - an.x()));
1450
                for (int a = an.x(); a < en.x(); ++a)
1451
                {
7571 cbradney 1452
                        if (MArea.contains(a, an.y()+qRound((a-an.x())*stg)))
6046 fschmid 1453
                                return true;
1454
                }
456 fschmid 1455
        }
6046 fschmid 1456
        else
1457
        {
7571 cbradney 1458
                an = Start.y() > End.y() ? End : Start;
1459
                en = an == End ? Start : End;
6046 fschmid 1460
                double stg = (en.x() - an.x()) / static_cast<double>((en.y() - an.y()));
1461
                for (int a = an.y(); a < en.y(); ++a)
1462
                {
7571 cbradney 1463
                        if (MArea.contains(an.x()+qRound((a-an.y())*stg), a))
6046 fschmid 1464
                                return true;
1465
                }
1466
        }
456 fschmid 1467
        return false;
1468
}
1469
 
4704 cbradney 1470
//CB-->Doc??
1510 tsoots 1471
void ScribusView::TransformPoly(int mode, int rot, double scaling)
456 fschmid 1472
{
23509 craig 1473
        PageItem *currItem = m_doc->m_Selection->itemAt(0);
1957 cbradney 1474
        currItem->ClipEdited = true;
13951 fschmid 1475
        QTransform ma;
17640 craig 1476
        undoManager->setUndoEnabled(false);
23509 craig 1477
        if (m_doc->nodeEdit.isContourLine())
456 fschmid 1478
        {
3993 cbradney 1479
                FPoint tp2(getMinClipF(&currItem->ContourLine));
1480
                FPoint tp(getMaxClipF(&currItem->ContourLine));
23038 jghali 1481
                FPoint tpS = currItem->ContourLine.widthHeight();
1957 cbradney 1482
                currItem->ContourLine.translate(-qRound((tp.x() + tp2.x()) / 2.0), -qRound((tp.y() + tp2.y()) / 2.0));
456 fschmid 1483
                switch (mode)
1484
                {
22638 craig 1485
                        case 0:
1486
                                ma.rotate(-rot);
1487
                                break;
1488
                        case 1:
1489
                                ma.rotate(rot);
1490
                                break;
1491
                        case 2:
1492
                                ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
1493
                                break;
1494
                        case 3:
1495
                                ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
1496
                                break;
1497
                        case 4:
1498
                                ma.shear(0.017455, 0);
1499
                                break;
1500
                        case 5:
1501
                                ma.shear(-0.017455, 0);
1502
                                break;
1503
                        case 6:
1504
                                ma.shear(0, -0.017455);
1505
                                break;
1506
                        case 7:
1507
                                ma.shear(0, 0.017455);
1508
                                break;
1509
                        case 8:
23945 jghali 1510
                                ma.scale(1.0 - (scaling / tpS.x()), 1.0 - (scaling / tpS.y()));
22638 craig 1511
                                break;
1512
                        case 9:
23945 jghali 1513
                                ma.scale(1.0 + (scaling / tpS.x()), 1.0 + (scaling / tpS.y()));
22638 craig 1514
                                break;
1515
                                //10-13 are for scaling the contour line in shape edit mode
1516
                        case 10:
1517
                                {
23945 jghali 1518
                                        double s = 1.0 - (scaling / (tp2.x() - tp.x()));
22638 craig 1519
                                        ma.scale(s, 1);
23945 jghali 1520
                                        ma.translate(-scaling / s / 2, 0);
22638 craig 1521
                                }
1522
                                break;
1523
                        case 11:
1524
                                {
23945 jghali 1525
                                        double s = 1.0 - (scaling / (tp2.x() - tp.x()));
22638 craig 1526
                                        ma.scale(s, 1);
23945 jghali 1527
                                        ma.translate(scaling / s / 2, 0);
22638 craig 1528
                                }
1529
                                break;
1530
                        case 12:
1531
                                {
23945 jghali 1532
                                        double s = 1.0 - (scaling / (tp2.y() - tp.y()));
22638 craig 1533
                                        ma.scale(1, s);
23945 jghali 1534
                                        ma.translate(0, -scaling / s / 2);
22638 craig 1535
                                }
1536
                                break;
1537
                        case 13:
1538
                                {
23945 jghali 1539
                                        double s = 1.0 - (scaling/(tp2.y() - tp.y()));
22638 craig 1540
                                        ma.scale(1, s);
23945 jghali 1541
                                        ma.translate(0, scaling / s / 2);
22638 craig 1542
                                }
1543
                                break;
456 fschmid 1544
                }
1957 cbradney 1545
                currItem->ContourLine.map(ma);
1546
                currItem->ContourLine.translate(qRound((tp.x() + tp2.x()) / 2.0), qRound((tp.y() + tp2.y()) / 2.0));
2183 fschmid 1547
                updateContents();
8179 fschmid 1548
                currItem->FrameOnly = true;
23509 craig 1549
                m_doc->regionsChanged()->update(QRect());
17640 craig 1550
                undoManager->setUndoEnabled(true);
1509 tsoots 1551
                if (UndoManager::undoEnabled())
1552
                {
1553
                        undoManager->setUndoEnabled(false);
1957 cbradney 1554
                        currItem->checkChanges(true);
1509 tsoots 1555
                        undoManager->setUndoEnabled(true);
1556
                        SimpleState *ss = new SimpleState(Um::EditContourLine, "", Um::IBorder);
20800 jghali 1557
                        ss->set("EDIT_CONTOUR");
1509 tsoots 1558
                        ss->set("MODE", mode);
1559
                        ss->set("ROT", rot);
1560
                        ss->set("SCALING", scaling);
1957 cbradney 1561
                        undoManager->action(currItem, ss);
1509 tsoots 1562
                }
4078 fschmid 1563
                emit DocChanged();
456 fschmid 1564
                return;
1565
        }
3942 cbradney 1566
        FPoint oldPos(currItem->xyPos());
3934 cbradney 1567
        double offsX = currItem->width() / 2.0;
1568
        double offsY = currItem->height() / 2.0;
14815 fschmid 1569
        double oldWidth = currItem->width();
1570
        double oldHeight = currItem->height();
456 fschmid 1571
        ma.translate(-offsX, -offsY);
1572
        switch (mode)
1573
        {
22638 craig 1574
                case 0:
1575
                        ma.rotate(-rot);
1576
                        break;
1577
                case 1:
1578
                        ma.rotate(rot);
1579
                        break;
1580
                case 2:
1581
                        ma.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
1582
                        break;
1583
                case 3:
1584
                        ma.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
1585
                        break;
1586
                case 4:
1587
                        ma.shear(0.017455, 0);
1588
                        break;
1589
                case 5:
1590
                        ma.shear(-0.017455, 0);
1591
                        break;
1592
                case 6:
1593
                        ma.shear(0, -0.017455);
1594
                        break;
1595
                case 7:
1596
                        ma.shear(0, 0.017455);
1597
                        break;
1598
                case 8:
23945 jghali 1599
                        ma.scale(1.0 - (scaling / oldWidth), 1.0 - (scaling / oldHeight));
22638 craig 1600
                        break;
1601
                case 9:
23945 jghali 1602
                        ma.scale(1.0 + (scaling / oldWidth), 1.0 + (scaling / oldHeight));
22638 craig 1603
                        break;
456 fschmid 1604
        }
1957 cbradney 1605
        currItem->PoLine.map(ma);
1606
        currItem->PoLine.translate(offsX, offsY);
23509 craig 1607
        m_doc->adjustItemSize(currItem);
13951 fschmid 1608
        QTransform ma2;
456 fschmid 1609
        ma2.translate(oldPos.x(), oldPos.y());
1610
        ma2.scale(1, 1);
1611
        ma2.translate(offsX, offsY);
3993 cbradney 1612
        FPoint n(-offsX, -offsY);
456 fschmid 1613
        switch (mode)
1614
        {
22638 craig 1615
                case 0:
1616
                        ma2.rotate(-rot);
1617
                        break;
1618
                case 1:
1619
                        ma2.rotate(rot);
1620
                        break;
1621
                case 2:
1622
                        ma2.scale(1.0 - (scaling / 100.0), 1.0 - (scaling / 100.0));
1623
                        break;
1624
                case 3:
1625
                        ma2.scale(1.0 + (scaling / 100.0), 1.0 + (scaling / 100.0));
1626
                        break;
1627
                case 4:
1628
                        ma2.shear(0.017455, 0);
1629
                        break;
1630
                case 5:
1631
                        ma2.shear(-0.017455, 0);
1632
                        break;
1633
                case 6:
1634
                        ma2.shear(0, -0.017455);
1635
                        break;
1636
                case 7:
1637
                        ma2.shear(0, 0.017455);
1638
                        break;
1639
                case 8:
23945 jghali 1640
                        ma2.scale(1.0 - (scaling / oldWidth), 1.0 - (scaling / oldHeight));
22638 craig 1641
                        break;
1642
                case 9:
23945 jghali 1643
                        ma2.scale(1.0 + (scaling / oldWidth), 1.0 + (scaling / oldHeight));
22638 craig 1644
                        break;
456 fschmid 1645
        }
1646
        double x = ma2.m11() * n.x() + ma2.m21() * n.y() + ma2.dx();
1647
        double y = ma2.m22() * n.y() + ma2.m12() * n.x() + ma2.dy();
23509 craig 1648
        m_doc->moveItem(x-oldPos.x(), y-oldPos.y(), currItem);
23794 craig 1649
        if (currItem->isPathText())
4688 cbradney 1650
                currItem->updatePolyClip();
23509 craig 1651
        m_doc->setRedrawBounding(currItem);
1652
        m_doc->regionsChanged()->update(QRect());
10701 avox 1653
        currItem->update();
1957 cbradney 1654
        currItem->FrameType = 3;
17640 craig 1655
        undoManager->setUndoEnabled(true);
1509 tsoots 1656
        if (UndoManager::undoEnabled())
1657
        {
1658
                undoManager->setUndoEnabled(false);
1957 cbradney 1659
                currItem->checkChanges(true);
1509 tsoots 1660
                undoManager->setUndoEnabled(true);
1661
                SimpleState *ss = new SimpleState(Um::EditShape, "", Um::IBorder);
20800 jghali 1662
                ss->set("EDIT_SHAPE");
1509 tsoots 1663
                ss->set("MODE", mode);
1664
                ss->set("ROT", rot);
1665
                ss->set("SCALING", scaling);
1957 cbradney 1666
                undoManager->action(currItem, ss);
1509 tsoots 1667
        }
4078 fschmid 1668
        emit DocChanged();
456 fschmid 1669
}
1670
 
1671
bool ScribusView::slotSetCurs(int x, int y)
1672
{
16856 craig 1673
        PageItem *item;
23509 craig 1674
        if (!m_doc->getItem(&item))
16856 craig 1675
                return false;
1676
 
1677
        PageItem_TextFrame *textFrame;
1678
        QPointF canvasPoint;
17119 fschmid 1679
        QTransform mm = item->getTransform();
1680
        QPointF textFramePoint = mm.map(QPointF(0, 0));
16856 craig 1681
        if (item->isTextFrame())
456 fschmid 1682
        {
16856 craig 1683
                textFrame = item->asTextFrame();
1684
                canvasPoint = m_canvas->globalToCanvas(QPoint(x,y)).toQPointF();
1685
        }
1686
        else if (item->isTable())
1687
        {
1688
                // Move to cell under cursor and position the text cursor.
1689
                PageItem_Table *table = item->asTable();
18994 jghali 1690
                QPointF tablePoint = m_canvas->globalToCanvas(QPoint(x, y)).toQPointF();
1691
                table->moveTo(table->cellAt(tablePoint));
16856 craig 1692
                textFrame = table->activeCell().textFrame();
18994 jghali 1693
                mm = textFrame->getTransform();
1694
                canvasPoint = table->getTransform().inverted().map(tablePoint) - table->gridOffset();
16856 craig 1695
        }
1696
        else if (item->isImageFrame())
1697
                return true;
1698
        else
1699
                return false;
16738 jghali 1700
 
16856 craig 1701
        if (m_canvas->frameHitTest(canvasPoint, textFrame) == Canvas::INSIDE)
1702
        {
1703
                // #9592 : layout must be valid here, or screenToPosition() may crash
1704
                if (textFrame->invalid)
1705
                        textFrame->layout();
18696 jghali 1706
 
1707
                double px = canvasPoint.x() - textFramePoint.x();
1708
                double py = canvasPoint.y() - textFramePoint.y();
18984 jghali 1709
                FPoint point(px, py);
1710
                if (mm.isInvertible() && textFrame->itemText.length() > 0)
1711
                {
1712
                        qreal tx = 0, ty = 0;
1713
                        mm.inverted().map(canvasPoint.x(), canvasPoint.y(), &tx, &ty);
1714
                        point.setXY(tx, ty);
1715
                }
18696 jghali 1716
                if (textFrame->imageFlippedH())
18984 jghali 1717
                        point.setX(textFrame->width() - point.x());
18696 jghali 1718
                if (textFrame->imageFlippedV())
18984 jghali 1719
                        point.setY(textFrame->height() - point.y());
21107 craig 1720
                if (textFrame->itemText.length() == 0)
1721
                        textFrame->itemText.setCursorPosition(0);
1722
                else
1723
                {
1724
                        int result = textFrame->textLayout.pointToPosition(point.toQPointF());
1725
                        if (result >= 0)
1726
                                textFrame->itemText.setCursorPosition(result);
1727
                }
18696 jghali 1728
 
16856 craig 1729
                if (textFrame->itemText.length() > 0)
1730
                {
21918 jghali 1731
                        int pos = qMax(0, qMin(textFrame->itemText.cursorPosition(), textFrame->itemText.length()));
23940 jghali 1732
                        if (textFrame->itemText.hasSelection())
21918 jghali 1733
                        {
1734
                                int firstSelected = textFrame->itemText.startOfSelection();
1735
                                int lastSelected  = qMax(textFrame->itemText.endOfSelection() - 1, 0);
1736
                                pos = qMax(firstSelected, qMin(pos, lastSelected));
1737
                        }
23509 craig 1738
                        m_doc->currentStyle.charStyle() = textFrame->currentCharStyle();
1739
                        emit ItemCharStyle(m_doc->currentStyle.charStyle());
1740
                        emit ItemTextEffects(m_doc->currentStyle.charStyle().effects());
16856 craig 1741
                        emit ItemTextAlign(textFrame->itemText.paragraphStyle(pos).alignment());
1742
                        return true;
1743
                }
23509 craig 1744
                m_doc->currentStyle.charStyle() = textFrame->itemText.defaultStyle().charStyle();
22607 craig 1745
                emit ItemCharStyle(textFrame->itemText.defaultStyle().charStyle());
1746
                emit ItemTextEffects(textFrame->itemText.defaultStyle().charStyle().effects());
1747
                emit ItemTextAlign(0);
1748
                return true;
456 fschmid 1749
        }
1750
        return false;
1751
}
1752
 
9391 fschmid 1753
 
9668 fschmid 1754
void ScribusView::dragTimerTimeOut()
1755
{
10978 avox 1756
        m_dragTimerFired = true;
13282 pierre 1757
        // #0007865
22638 craig 1758
        //      qApp->changeOverrideCursor(QCursor(loadIcon("dragpix.png")));
9668 fschmid 1759
}
1760
 
23389 craig 1761
Qt::CursorShape ScribusView::getResizeCursor(PageItem *currItem, QRect mpo, Qt::CursorShape cursorShape)
456 fschmid 1762
{
13951 fschmid 1763
        QTransform ma;
10532 avox 1764
        m_canvas->Transform(currItem, ma);
23389 craig 1765
        QPoint tx = ma.map(QPoint(static_cast<int>(currItem->width()), 0));
1766
        QPoint tx2 = ma.map(QPoint(0, static_cast<int>(currItem->height())));
456 fschmid 1767
        if (mpo.contains(tx) || mpo.contains(tx2))
1768
        {
21519 craig 1769
                double rr = fabs(currItem->rotation());
1770
                if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >=315.0) && (rr <= 360.0)))
23389 craig 1771
                        cursorShape = Qt::SizeBDiagCursor;
21519 craig 1772
                if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
23389 craig 1773
                        cursorShape = Qt::SizeFDiagCursor;
456 fschmid 1774
        }
9380 fschmid 1775
        tx = ma.map(QPoint(static_cast<int>(currItem->width()), static_cast<int>(currItem->height())/2));
1776
        tx2 = ma.map(QPoint(0, static_cast<int>(currItem->height())/2));
456 fschmid 1777
        if (mpo.contains(tx) || mpo.contains(tx2))
1778
        {
3934 cbradney 1779
                double rr = fabs(currItem->rotation());
456 fschmid 1780
                if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >= 315.0) && (rr <= 360.0)))
23389 craig 1781
                        cursorShape = Qt::SizeHorCursor;
456 fschmid 1782
                if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
23389 craig 1783
                        cursorShape = Qt::SizeVerCursor;
456 fschmid 1784
        }
9380 fschmid 1785
        tx = ma.map(QPoint(static_cast<int>(currItem->width())/2, 0));
1786
        tx2 = ma.map(QPoint(static_cast<int>(currItem->width())/2, static_cast<int>(currItem->height())));
456 fschmid 1787
        if (mpo.contains(tx) || mpo.contains(tx2))
1788
        {
3934 cbradney 1789
                double rr = fabs(currItem->rotation());
456 fschmid 1790
                if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) || ((rr >= 315.0) && (rr <= 360.0)))
23389 craig 1791
                        cursorShape = Qt::SizeVerCursor;
456 fschmid 1792
                if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
23389 craig 1793
                        cursorShape = Qt::SizeHorCursor;
456 fschmid 1794
        }
9380 fschmid 1795
        tx = ma.map(QPoint(static_cast<int>(currItem->width()), static_cast<int>(currItem->height())));
1796
        tx2 = ma.map(QPoint(0, 0));
456 fschmid 1797
        if (mpo.contains(tx) || mpo.contains(tx2))
1798
        {
21519 craig 1799
                if (!currItem->sizeHLocked() && ! currItem->sizeVLocked())
456 fschmid 1800
                {
3934 cbradney 1801
                        double rr = fabs(currItem->rotation());
456 fschmid 1802
                        if (((rr >= 0.0) && (rr < 45.0)) || ((rr >= 135.0) && (rr < 225.0)) ||
22638 craig 1803
                                        ((rr >= 315.0) && (rr <= 360.0)))
23389 craig 1804
                                cursorShape = Qt::SizeFDiagCursor;
456 fschmid 1805
                        if (((rr >= 45.0) && (rr < 135.0)) || ((rr >= 225.0) && (rr < 315.0)))
23389 craig 1806
                                cursorShape = Qt::SizeBDiagCursor;
456 fschmid 1807
                }
1808
        }
23389 craig 1809
        return cursorShape;
456 fschmid 1810
}
1811
 
23390 craig 1812
void ScribusView::selectItemByNumber(int nr, bool draw, bool single)
456 fschmid 1813
{
23509 craig 1814
        if (nr < m_doc->Items->count())
1815
                selectItem(m_doc->Items->at(nr), draw, single);
1292 tsoots 1816
}
1817
 
4704 cbradney 1818
//CB-->Doc/Fix
23390 craig 1819
void ScribusView::selectItem(PageItem *currItem, bool draw, bool single)
1292 tsoots 1820
{
3934 cbradney 1821
        if (!currItem->isSelected())
456 fschmid 1822
        {
1427 fschmid 1823
                if (single)
456 fschmid 1824
                {
23509 craig 1825
                        m_doc->m_Selection->addItem(currItem);
1957 cbradney 1826
                        currItem->isSingleSel = true;
16961 fschmid 1827
                        updateContents();
1427 fschmid 1828
                }
1829
                else
1830
                {
23509 craig 1831
                        m_doc->m_Selection->addItem(currItem);
16118 fschmid 1832
                        if (draw)
1833
                                updateContents(currItem->getRedrawBounding(m_canvas->scale()));
456 fschmid 1834
                }
1835
        }
23509 craig 1836
        if (draw && !m_doc->m_Selection->isEmpty())
456 fschmid 1837
        {
23390 craig 1838
                double x, y, w, h;
23509 craig 1839
                m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
23390 craig 1840
                getGroupRectScreen(&x, &y, &w, &h);
1841
                updateContents();
1842
                emit ItemGeom();
1843
                emit HaveSel();
456 fschmid 1844
        }
1845
}
1846
 
4704 cbradney 1847
//CB Remove bookmark interaction here, item/doc should do it
23390 craig 1848
void ScribusView::deselectItems(bool /*prop*/)
456 fschmid 1849
{
23509 craig 1850
        if (m_doc->m_Selection->isEmpty())
19330 jghali 1851
                return;
1852
 
1853
        const double scale = m_canvas->scale();
22516 craig 1854
        PageItem* currItem = nullptr;
23509 craig 1855
        for (int i = 0; i < m_doc->m_Selection->count(); ++i)
456 fschmid 1856
        {
23509 craig 1857
                currItem = m_doc->m_Selection->itemAt(i);
23794 craig 1858
                if ((currItem->isTextFrame()) && (currItem->isBookmark))
19330 jghali 1859
                        emit ChBMText(currItem);
1860
        }
23633 jghali 1861
        if (!m_doc->m_Selection->isMultipleSelection())
19330 jghali 1862
        {
23509 craig 1863
                currItem = m_doc->m_Selection->itemAt(0);
22516 craig 1864
                if (currItem != nullptr)
456 fschmid 1865
                {
19330 jghali 1866
                        currItem->itemText.deselectAll();
1867
                        currItem->HasSel = false;
456 fschmid 1868
                }
1869
        }
23633 jghali 1870
        double x, y, w, h;
23638 jghali 1871
        m_doc->m_Selection->getVisualGroupRect(&x, &y, &w, &h);
23633 jghali 1872
        m_doc->m_Selection->clear();
1873
        updateCanvas(x - 5 / scale, y - 5 / scale, w + 10 / scale, h + 10 / scale);
456 fschmid 1874
}
1875
 
22638 craig 1876
// FIXME:av -> CanvasMode_legacy / Doc
4704 cbradney 1877
//CB Remove emit/start pasting objects
456 fschmid 1878
void ScribusView::PasteToPage()
1879
{
19421 jghali 1880
        UndoTransaction activeTransaction;
23509 craig 1881
        int ac = m_doc->Items->count();
1369 tsoots 1882
        if (UndoManager::undoEnabled())
23509 craig 1883
                activeTransaction = undoManager->beginTransaction(m_doc->currentPage()->getUName(), nullptr, Um::Paste, "", Um::IPaste);
21483 jghali 1884
 
1885
        QString buffer = ScMimeData::clipboardScribusElem();
23509 craig 1886
        emit LoadElem(buffer, dragX, dragY, false, false, m_doc, this);
21483 jghali 1887
 
23509 craig 1888
        m_doc->DraggedElem = nullptr;
1889
        m_doc->DragElements.clear();
456 fschmid 1890
        updateContents();
8735 cbradney 1891
        Selection newObjects(this, false);
23509 craig 1892
        for (int as = ac; as < m_doc->Items->count(); ++as)
2193 fschmid 1893
        {
23509 craig 1894
                PageItem* currItem = m_doc->Items->at(as);
2193 fschmid 1895
                if (currItem->isBookmark)
1896
                        emit AddBM(currItem);