Subversion Repositories Scribus

Rev

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