Subversion Repositories Scribus

Rev

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

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