Subversion Repositories Scribus

Rev

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