Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
23152 jghali 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
 */
7
/***************************************************************************
8
*                                                                         *
9
*   This program is free software; you can redistribute it and/or modify  *
10
*   it under the terms of the GNU General Public License as published by  *
11
*   the Free Software Foundation; either version 2 of the License, or     *
12
*   (at your option) any later version.                                   *
13
*                                                                         *
14
***************************************************************************/
15
 
16
#include "canvasgesture_rulermove.h"
17
 
18
#include <QEvent>
19
#include <QMouseEvent>
20
#include <QPainter>
21
 
22
#include "appmodes.h"
23
#include "guidemanagercore.h"
24
#include "scribus.h"
25
#include "scribusdoc.h"
26
#include "scribusview.h"
27
#include "ui/guidemanager.h"
28
#include "iconmanager.h"
29
 
30
 
31
RulerGesture::RulerGesture(ScribusView *view, RulerGesture::Mode mode) :
32
        CanvasGesture(view),
33
        m_mode(mode),
23612 craig 34
        m_ScMW(m_view->m_ScMW)
23152 jghali 35
{
36
}
37
 
38
 
39
void RulerGesture::drawControls(QPainter* p)
40
{
41
        int page = -1;
42
        //This is !null where we've entered the RulerGesture::mouseMoveEvent
43
        if (!m_mousePoint.isNull())
44
                page = m_doc->OnPage(m_mousePoint.x(), m_mousePoint.y());
45
        if (page == -1)
46
                return;
47
        ScPage* dragToPage=m_doc->Pages->at(page);
48
        if (!dragToPage)
49
                return;
50
        if (m_haveGuide)
51
                dragToPage = m_doc->Pages->at(m_page);
52
        QColor color(m_doc->guidesPrefs().guideColor);
53
        p->save();
54
        QPoint pageOrigin = m_canvas->canvasToLocal(QPointF(dragToPage->xOffset(), dragToPage->yOffset()));
55
        QSize pageSize = (QSizeF(dragToPage->width(), dragToPage->height()) * m_canvas->scale()).toSize();
56
        switch (m_mode)
57
        {
58
                case HORIZONTAL:
59
                        p->setPen(QPen(color, 1.0, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin));
60
                        p->drawLine(QPoint(pageOrigin.x(), m_xy.y()), QPoint(pageOrigin.x() + pageSize.width(), m_xy.y()));
61
                        break;
62
                case VERTICAL:
63
                        p->setPen(QPen(color, 1.0, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin));
64
                        p->drawLine(QPoint(m_xy.x(), pageOrigin.y()), QPoint(m_xy.x(), pageOrigin.y() + pageSize.height()));
65
                        break;
66
                case ORIGIN:
67
                        p->setPen(QPen(color, 1.0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
68
                        p->drawLine(QPoint(m_xy.x(), 0), QPoint(m_xy.x(), m_canvas->height()));
69
                        p->drawLine(QPoint(0, m_xy.y()), QPoint(m_canvas->width(), m_xy.y()));
70
                        break;
71
        }
72
        p->restore();
73
}
74
 
75
void RulerGesture::clear()
76
{
77
        m_haveGuide = false;
78
}
79
 
80
void RulerGesture::prepare(Mode mode)
81
{
82
        m_haveGuide = false;
83
        m_mode = mode;
84
}
85
 
86
void RulerGesture::activate(bool fromGesture)
87
{
23613 jghali 88
        CanvasGesture::activate(fromGesture);
89
 
23152 jghali 90
        m_haveCursor = (qApp->overrideCursor() != nullptr);
91
        if ( (!fromGesture) && qApp->overrideCursor())
92
        {
93
                m_haveCursor = true;
94
                m_cursor = *(qApp->overrideCursor());
95
        }
96
        else
97
        {
98
                m_haveCursor = false;
99
        }
100
        switch (m_mode)
101
        {
102
                case HORIZONTAL:
103
                        qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
104
                        break;
105
                case VERTICAL:
106
                        qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
107
                        break;
108
                case ORIGIN:
109
                        qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
110
                        break;
111
        }
112
        emit guideInfo(m_mode, m_guide);
113
}
114
 
23613 jghali 115
void RulerGesture::deactivate(bool fromGesture)
23152 jghali 116
{
117
        if (m_haveCursor)
118
                qApp->changeOverrideCursor(m_cursor);
119
        m_haveGuide = false;
23613 jghali 120
        m_mousePoint = FPoint();
121
 
122
        CanvasGesture::deactivate(fromGesture);
23152 jghali 123
}
124
 
125
 
126
bool RulerGesture::mouseHitsGuide(const FPoint& mousePointDoc)
127
{
128
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
129
        if ((m_doc->guidesPrefs().guidesShown) && (!m_doc->GuideLock) && page >= 0)
130
        {
131
                double grabRadScale = m_doc->guidesPrefs().grabRadius / m_canvas->scale();
132
                int index = m_doc->Pages->at(page)->guides.isMouseOnVertical(mousePointDoc.x() + grabRadScale, mousePointDoc.x() - grabRadScale, GuideManagerCore::Standard);
133
                if (index >= 0)
134
                {
135
                        m_mode = VERTICAL;
136
                        m_haveGuide = true;
137
                        m_guide = m_doc->Pages->at(page)->guides.vertical(index, GuideManagerCore::Standard);
138
                        m_currentGuide = m_guide;
139
                        m_page = page;
140
                        return true;
141
                }
142
                index = m_doc->Pages->at(page)->guides.isMouseOnHorizontal(mousePointDoc.y() + grabRadScale, mousePointDoc.y() - grabRadScale, GuideManagerCore::Standard);
143
                if (index >= 0)
144
                {
145
                        m_mode = HORIZONTAL;
146
                        m_haveGuide = true;
147
                        m_guide = m_doc->Pages->at(page)->guides.horizontal(index, GuideManagerCore::Standard);
148
                        m_currentGuide = m_guide;
149
                        m_page = page;
150
                        return true;
151
                }
152
        }
153
        m_haveGuide = false;
154
        return false;
155
}
156
 
157
void RulerGesture::mouseSelectGuide(QMouseEvent *m)
158
{
159
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
160
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
161
        if ((m_doc->guidesPrefs().guidesShown) && page >= 0)
162
        {
163
                double grabRadScale = m_doc->guidesPrefs().grabRadius / m_canvas->scale();
164
                int index = m_doc->Pages->at(page)->guides.isMouseOnVertical(mousePointDoc.x() + grabRadScale, mousePointDoc.x() - grabRadScale, GuideManagerCore::Standard);
165
                if (index >= 0)
166
                {
167
                        emit guideInfo(VERTICAL, m_doc->Pages->at(page)->guides.vertical(index, GuideManagerCore::Standard));
168
                        return;
169
                }
170
                index = m_doc->Pages->at(page)->guides.isMouseOnHorizontal(mousePointDoc.y() + grabRadScale, mousePointDoc.y() - grabRadScale, GuideManagerCore::Standard);
171
                if (index >= 0)
172
                {
173
                        emit guideInfo(HORIZONTAL, m_doc->Pages->at(page)->guides.horizontal(index, GuideManagerCore::Standard));
174
                        return;
175
                }
176
        }
177
}
178
 
179
void RulerGesture::movePoint(QMouseEvent* m, bool mouseRelease)
180
{
181
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
182
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
183
        QRect  viewport(m_view->viewport()->mapToGlobal(QPoint(0,0)), QSize(m_view->visibleWidth(), m_view->visibleHeight()));
184
        QPoint newMousePoint = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
185
        double x = mousePointDoc.x();
186
        double y = mousePointDoc.y();
187
        switch (m_mode)
188
        {
189
                case ORIGIN:
190
                        m_canvas->repaint();
25013 jghali 191
                        m_canvas->displayCorrectedXYHUD(m->globalPosition(), x, y);
23152 jghali 192
                        break;
193
                case HORIZONTAL:
194
                        if (!m_ScMW->doc->guidesPrefs().guidesShown)
195
                                break;
196
                        m_canvas->update(0, m_xy.y() - 2, m_canvas->width(), 4);
197
 
198
                        if ((page >= 0) && (viewport.contains(m->globalPos())))
199
                        {
200
                                ScPage* currentPage = m_doc->Pages->at(page);
201
                                if (m_doc->SnapElement)
202
                                {
203
                                        double xout = 0;
204
                                        double yout = 0;
23177 jghali 205
                                        m_doc->getClosestElementBorder(x, y, &xout, &yout, ScribusDoc::IncludeSelection);
23159 jghali 206
                                        if (yout != y)
23152 jghali 207
                                        {
23159 jghali 208
                                                y = yout;
23152 jghali 209
                                                newMousePoint = m_canvas->canvasToLocal(QPointF(x, y));
210
                                        }
211
                                }
212
                                if (!m_haveGuide)
213
                                {
214
                                        qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
215
                                        if (mouseRelease)
216
                                        {
217
                                                currentPage->guides.addHorizontal(y - currentPage->yOffset(), GuideManagerCore::Standard);
218
                                                m_guide = y - currentPage->yOffset();
219
                                                m_page  = page;
220
                                                m_haveGuide = true;
221
                                                m_doc->changed();
222
                                        }
223
                                }
224
                                else if (mouseRelease)
225
                                {
226
                                        if (page == m_page)
227
                                                currentPage->guides.moveHorizontal(m_guide, y - currentPage->yOffset(), GuideManagerCore::Standard);
228
                                        else
229
                                        {
230
                                                m_doc->Pages->at(m_page)->guides.deleteHorizontal(m_guide, GuideManagerCore::Standard);
231
                                                currentPage->guides.addHorizontal(y - currentPage->yOffset(), GuideManagerCore::Standard);
232
                                                m_page = page;
233
                                        }
234
                                        if (m_doc->currentPage() != m_doc->Pages->at(m_page))
235
                                                m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
236
                                        m_doc->changed();
237
                                }
238
                                else
239
                                {
240
                                        QCursor* cursor = qApp->overrideCursor();
241
                                        if (cursor && (cursor->shape() != Qt::SplitVCursor))
242
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
243
                                }
244
                                m_currentGuide = y - currentPage->yOffset();
245
                        }
246
                        else
247
                        {
248
                                if (m_haveGuide)
249
                                {
250
                                        qApp->changeOverrideCursor(IconManager::instance().loadCursor("DelPoint.png"));
251
                                        if (mouseRelease)
252
                                        {
253
                                                m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
254
                                                m_haveGuide = false;
255
                                                m_doc->changed();
256
                                        }
257
                                }
258
                        }
259
                        m_canvas->update(0, newMousePoint.y() - 2, m_canvas->width(), 4);
25013 jghali 260
                        m_canvas->displayCorrectedSingleHUD(m->globalPosition(), y, false);
23152 jghali 261
                        break;
262
                case VERTICAL:
263
                        if (!m_ScMW->doc->guidesPrefs().guidesShown)
264
                                break;
265
                        m_canvas->update(m_xy.x() - 2, 0, 4, m_canvas->height());
266
                        if ((page >= 0) && viewport.contains(m->globalPos()))
267
                        {
268
                                ScPage* currentPage = m_doc->Pages->at(page);
269
                                if (m_doc->SnapElement)
270
                                {
271
                                        double xout = 0;
272
                                        double yout = 0;
23177 jghali 273
                                        m_doc->getClosestElementBorder(x, y, &xout, &yout, ScribusDoc::IncludeSelection);
23159 jghali 274
                                        if (xout != x)
23152 jghali 275
                                        {
23159 jghali 276
                                                x = xout;
23152 jghali 277
                                                newMousePoint = m_canvas->canvasToLocal(QPointF(x, y));
278
                                        }
279
                                }
280
                                if (!m_haveGuide)
281
                                {
282
                                        qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
283
                                        if (mouseRelease)
284
                                        {
285
                                                currentPage->guides.addVertical(x - currentPage->xOffset(), GuideManagerCore::Standard);
286
                                                m_guide = x - currentPage->xOffset();
287
                                                m_page  = page;
288
                                                m_haveGuide = true;
289
                                                m_doc->changed();
290
                                        }
291
                                }
292
                                else if (mouseRelease)
293
                                {
294
                                        if (page == m_page)
295
                                                currentPage->guides.moveVertical(m_guide, x - currentPage->xOffset(), GuideManagerCore::Standard);
296
                                        else
297
                                        {
298
                                                m_doc->Pages->at(m_page)->guides.deleteVertical(m_guide, GuideManagerCore::Standard);
299
                                                currentPage->guides.addVertical(x - currentPage->xOffset(), GuideManagerCore::Standard);
300
                                                m_page = page;
301
                                        }
302
                                        if (m_doc->currentPage() != m_doc->Pages->at(m_page))
303
                                                m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
304
                                        m_doc->changed();
305
                                }
306
                                else
307
                                {
308
                                        QCursor* cursor = qApp->overrideCursor();
309
                                        if (cursor && (cursor->shape() != Qt::SplitHCursor))
310
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
311
                                }
312
                                m_currentGuide = x - currentPage->xOffset();
313
                        }
314
                        else
315
                        {
316
                                if (m_haveGuide)
317
                                {
318
                                        qApp->changeOverrideCursor(IconManager::instance().loadCursor("DelPoint.png"));
319
                                        if (mouseRelease)
320
                                        {
321
                                                m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
322
                                                m_haveGuide = false;
323
                                                m_doc->changed();
324
                                        }
325
                                }
326
                        }
327
                        m_canvas->update(newMousePoint.x() - 2, 0, 4, m_canvas->height());
25013 jghali 328
                        m_canvas->displayCorrectedSingleHUD(m->globalPosition(), x, true);
23152 jghali 329
                        break;
330
        }
331
        m_xy = newMousePoint;
332
}
333
 
334
 
23613 jghali 335
void RulerGesture::keyPressEvent(QKeyEvent* e)
336
{
337
        e->accept();
338
 
339
        if (e->key() == Qt::Key_Escape)
340
        {
341
                // Go back to normal mode.
342
                m_view->stopGesture();
343
                return;
344
        }
345
}
346
 
23152 jghali 347
void RulerGesture::mouseMoveEvent(QMouseEvent* m)
348
{
349
        m_mousePoint=m_canvas->globalToCanvas(m->globalPos());
350
        m->accept();
351
        if (m_view->moveTimerElapsed())
352
        {
353
                movePoint(m, false);
354
                if (m_ScMW->doc->guidesPrefs().guidesShown)
355
                        emit guideInfo(m_mode, m_currentGuide);
356
        }
357
}
358
 
359
 
360
void RulerGesture::mouseReleaseEvent(QMouseEvent* m)
361
{
362
        m->accept();
363
        if (m_view->moveTimerElapsed())
364
        {
365
                movePoint(m, true);
366
                if (m_mode == ORIGIN)
367
                        m_view->setNewRulerOrigin(m);
368
                else
369
                {
370
                        if (m_ScMW->doc->guidesPrefs().guidesShown)
371
                                m_ScMW->guidePalette->setupPage();
372
                }
373
        }
374
        m_haveGuide = false;
375
        //#9391: Force redraw to get the guide drawn if we draw a guide in an edit mode
376
        if (m_ScMW->doc->appMode != modeNormal)
377
                m_canvas->setForcedRedraw(true);
378
        m_canvas->repaint();
379
        m_view->stopGesture();
380
        m_mousePoint=QPoint(0,0);
381
        if (m_ScMW->doc->guidesPrefs().guidesShown)
382
                emit guideInfo(m_mode, m_currentGuide);
383
}
384
 
385
 
386
void RulerGesture::mousePressEvent(QMouseEvent* m)
387
{
388
        m->accept();
389
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
390
        m_view->registerMousePress(m->globalPos());
391
        if (mouseHitsGuide(mousePointDoc))
392
        {
393
                m_xy = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
394
        }
395
        if (m_ScMW->doc->guidesPrefs().guidesShown)
396
                emit guideInfo(m_mode, m_currentGuide);
397
}
398