Subversion Repositories Scribus

Rev

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