Subversion Repositories Scribus

Rev

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