Subversion Repositories Scribus

Rev

Rev 17163 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
11190 avox 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 "guidemanager.h"
23
#include "guidemanagercore.h"
24
#include "scribus.h"
25
#include "scribusdoc.h"
11319 avox 26
#include "util_icon.h"
11190 avox 27
 
28
void RulerGesture::drawControls(QPainter* p)
29
{
11319 avox 30
        Page* page = m_doc->currentPage();
15800 jghali 31
        if (m_haveGuide)
32
                page = m_doc->Pages->at(m_page);
11319 avox 33
        QColor color(m_doc->guidesSettings.guideColor);
34
        p->save();
35
        QPoint pageOrigin = m_canvas->canvasToLocal(QPointF(page->xOffset(), page->yOffset()));
11320 avox 36
        QSize pageSize = (QSizeF(page->width(), page->height()) * m_canvas->scale()).toSize();
11190 avox 37
        switch (m_mode)
38
        {
39
                case HORIZONTAL:
18444 jghali 40
                        p->setPen(QPen(color, 1.0, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin));
11319 avox 41
                        p->drawLine(QPoint(pageOrigin.x(), m_xy.y()), QPoint(pageOrigin.x() + pageSize.width(), m_xy.y()));
11190 avox 42
                        break;
43
                case VERTICAL:
18444 jghali 44
                        p->setPen(QPen(color, 1.0, Qt::DashDotLine, Qt::FlatCap, Qt::MiterJoin));
11319 avox 45
                        p->drawLine(QPoint(m_xy.x(), pageOrigin.y()), QPoint(m_xy.x(), pageOrigin.y() + pageSize.height()));
11190 avox 46
                        break;
47
                case ORIGIN:
18444 jghali 48
                        p->setPen(QPen(color, 1.0, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
11319 avox 49
                        p->drawLine(QPoint(m_xy.x(), 0), QPoint(m_xy.x(), m_canvas->height()));
50
                        p->drawLine(QPoint(0, m_xy.y()), QPoint(m_canvas->width(), m_xy.y()));
11190 avox 51
                        break;
52
        }
11319 avox 53
        p->restore();
11190 avox 54
}
55
 
11339 avox 56
 
57
void RulerGesture::clear()
58
{
59
        m_haveGuide = false;
60
}
61
 
62
 
63
void RulerGesture::prepare(Mode mode)
64
{
65
        m_haveGuide = false;
66
        m_mode = mode; 
67
}
68
 
69
 
11190 avox 70
void RulerGesture::activate(bool fromGesture)
71
{
11327 avox 72
        m_haveCursor = (qApp->overrideCursor() != NULL);
73
        if ( (!fromGesture) && qApp->overrideCursor())
74
        {
75
                m_haveCursor = true;
76
                m_cursor = *(qApp->overrideCursor());
77
        }
78
        else
79
        {
80
                m_haveCursor = false;
81
        }
11190 avox 82
        switch (m_mode)
83
        {
84
                case HORIZONTAL:
85
                        qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
86
                        break;
87
                case VERTICAL:
88
                        qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
89
                        break;
90
                case ORIGIN:
11319 avox 91
                        qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
11190 avox 92
                        break;
93
        }
12581 pierre 94
        emit guideInfo(m_mode, m_guide);
11190 avox 95
}
96
 
97
void RulerGesture::deactivate(bool)
98
{
11327 avox 99
        if (m_haveCursor)
100
                qApp->changeOverrideCursor(m_cursor);
11339 avox 101
        m_haveGuide = false;
11190 avox 102
}
103
 
104
 
105
bool RulerGesture::mouseHitsGuide(FPoint mousePointDoc)
106
{
11319 avox 107
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
108
        if ((m_doc->guidesSettings.guidesShown) && (!m_doc->GuideLock) && page >= 0)
11190 avox 109
        {
110
                double grabRadScale = m_doc->guidesSettings.grabRad / m_canvas->scale();
11319 avox 111
                int index = m_doc->Pages->at(page)->guides.isMouseOnVertical(mousePointDoc.x() + grabRadScale, mousePointDoc.x() - grabRadScale, GuideManagerCore::Standard);
11190 avox 112
                if (index >= 0)
113
                {
11319 avox 114
                        m_mode = VERTICAL;
115
                        m_haveGuide = true;
116
                        m_guide = m_doc->Pages->at(page)->guides.vertical(index, GuideManagerCore::Standard);
14155 jghali 117
                        m_currentGuide = m_guide;
11319 avox 118
                        m_page = page;
11190 avox 119
                        return true;
120
                }
11319 avox 121
                index = m_doc->Pages->at(page)->guides.isMouseOnHorizontal(mousePointDoc.y() + grabRadScale, mousePointDoc.y() - grabRadScale, GuideManagerCore::Standard);
11190 avox 122
                if (index >= 0)
123
                {
11319 avox 124
                        m_mode = HORIZONTAL;
125
                        m_haveGuide = true;
126
                        m_guide = m_doc->Pages->at(page)->guides.horizontal(index, GuideManagerCore::Standard);
14155 jghali 127
                        m_currentGuide = m_guide;
11319 avox 128
                        m_page = page;
11190 avox 129
                        return true;
130
                }
131
        }
11339 avox 132
        m_haveGuide = false;
11190 avox 133
        return false;
134
}
135
 
12587 pierre 136
void RulerGesture::mouseSelectGuide(QMouseEvent *m)
137
{
138
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
139
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
140
        if ((m_doc->guidesSettings.guidesShown) && page >= 0)
141
        {
142
                double grabRadScale = m_doc->guidesSettings.grabRad / m_canvas->scale();
143
                int index = m_doc->Pages->at(page)->guides.isMouseOnVertical(mousePointDoc.x() + grabRadScale, mousePointDoc.x() - grabRadScale, GuideManagerCore::Standard);
144
                if (index >= 0)
145
                {
146
                        emit guideInfo(VERTICAL, m_doc->Pages->at(page)->guides.vertical(index, GuideManagerCore::Standard));
147
                        return;
148
                }
149
                index = m_doc->Pages->at(page)->guides.isMouseOnHorizontal(mousePointDoc.y() + grabRadScale, mousePointDoc.y() - grabRadScale, GuideManagerCore::Standard);
150
                if (index >= 0)
151
                {
152
                        emit guideInfo(HORIZONTAL, m_doc->Pages->at(page)->guides.horizontal(index, GuideManagerCore::Standard));
153
                        return;
154
                }
155
        }
156
}
11190 avox 157
 
14155 jghali 158
void RulerGesture::movePoint(QMouseEvent* m, bool mouseRelease)
11190 avox 159
{
160
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
161
        const int page = m_doc->OnPage(mousePointDoc.x(), mousePointDoc.y());
11814 fschmid 162
        QRect viewport(m_view->viewport()->mapToGlobal(QPoint(0,0)), QSize(m_view->visibleWidth(), m_view->visibleHeight()));
12649 fschmid 163
        QPoint newMousePoint = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
11190 avox 164
        switch (m_mode)
165
        {
166
                case ORIGIN:
11319 avox 167
                        m_canvas->repaint();
12776 fschmid 168
                        m_canvas->displayCorrectedXYHUD(m->globalPos(), mousePointDoc.x(), mousePointDoc.y());
11190 avox 169
                        break;
170
                case HORIZONTAL:
12729 subik 171
                        if (!m_ScMW->doc->guidesSettings.guidesShown)
172
                                break;
11319 avox 173
                        m_canvas->update(0, m_xy.y()-2, m_canvas->width(), 4);
174
                        m_canvas->update(0, newMousePoint.y()-2, m_canvas->width(), 4);
175
                        if ((page >= 0) && (viewport.contains(m->globalPos())))
176
                        {
177
                                if (!m_haveGuide)
178
                                {
179
                                        qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
14155 jghali 180
                                        if (mouseRelease)
181
                                        {
182
                                                m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
183
                                                m_guide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
184
                                                m_page  = page;
185
                                                m_haveGuide = true;
15729 fschmid 186
                                                m_doc->changed();
14155 jghali 187
                                        }
11319 avox 188
                                }
14155 jghali 189
                                else if (mouseRelease)
11319 avox 190
                                {
191
                                        if (page == m_page)
192
                                                m_doc->Pages->at(page)->guides.moveHorizontal( m_guide, mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
193
                                        else
194
                                        {
195
                                                m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
196
                                                m_doc->Pages->at(page)->guides.addHorizontal(mousePointDoc.y() - m_doc->Pages->at(page)->yOffset(), GuideManagerCore::Standard);
197
                                                m_page = page;
198
                                        }
15800 jghali 199
                                        if (m_doc->currentPage() != m_doc->Pages->at(m_page))
200
                                                m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
15729 fschmid 201
                                        m_doc->changed();
11319 avox 202
                                }
15232 jghali 203
                                else
204
                                {
15729 fschmid 205
                                        QCursor* cursor = qApp->overrideCursor();
206
                                        if (cursor && (cursor->shape() != Qt::SplitVCursor))
15232 jghali 207
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitVCursor));
208
                                }
14155 jghali 209
                                m_currentGuide = mousePointDoc.y() - m_doc->Pages->at(page)->yOffset();
11319 avox 210
                        }
211
                        else
212
                        {
213
                                if (m_haveGuide)
214
                                {
215
                                        qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
14155 jghali 216
                                        if (mouseRelease)
217
                                        {
218
                                                m_doc->Pages->at(m_page)->guides.deleteHorizontal( m_guide, GuideManagerCore::Standard);
219
                                                m_haveGuide = false;
15729 fschmid 220
                                                m_doc->changed();
14155 jghali 221
                                        }
11319 avox 222
                                }
223
                        }
12776 fschmid 224
                        m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.y(), false);
11190 avox 225
                        break;
226
                case VERTICAL:
12729 subik 227
                        if (!m_ScMW->doc->guidesSettings.guidesShown)
228
                                break;
11319 avox 229
                        m_canvas->update(m_xy.x()-2, 0, 4, m_canvas->height());
230
                        m_canvas->update(newMousePoint.x()-2, 0, 4, m_canvas->height());
231
                        if ((page >= 0) && viewport.contains(m->globalPos()))
11190 avox 232
                        {
11319 avox 233
                                if (!m_haveGuide)
11190 avox 234
                                {
11319 avox 235
                                        qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
14155 jghali 236
                                        if (mouseRelease)
237
                                        {
238
                                                m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
239
                                                m_guide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
240
                                                m_page  = page;
241
                                                m_haveGuide = true;
15729 fschmid 242
                                                m_doc->changed();
14155 jghali 243
                                        }
11190 avox 244
                                }
14155 jghali 245
                                else if (mouseRelease)
11190 avox 246
                                {
11319 avox 247
                                        if (page == m_page)
248
                                                m_doc->Pages->at(page)->guides.moveVertical( m_guide, mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
11190 avox 249
                                        else
250
                                        {
11319 avox 251
                                                m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
11190 avox 252
                                                m_doc->Pages->at(page)->guides.addVertical(mousePointDoc.x() - m_doc->Pages->at(page)->xOffset(), GuideManagerCore::Standard);
11319 avox 253
                                                m_page = page;
11190 avox 254
                                        }
15800 jghali 255
                                        if (m_doc->currentPage() != m_doc->Pages->at(m_page))
256
                                                m_doc->setCurrentPage( m_doc->Pages->at(m_page) );
15729 fschmid 257
                                        m_doc->changed();
11190 avox 258
                                }
15232 jghali 259
                                else
260
                                {
15729 fschmid 261
                                        QCursor* cursor = qApp->overrideCursor();
262
                                        if (cursor && (cursor->shape() != Qt::SplitHCursor))
15232 jghali 263
                                                qApp->changeOverrideCursor(QCursor(Qt::SplitHCursor));
264
                                }
14155 jghali 265
                                m_currentGuide = mousePointDoc.x() - m_doc->Pages->at(page)->xOffset();
11190 avox 266
                        }
267
                        else
268
                        {
11319 avox 269
                                if (m_haveGuide)
11190 avox 270
                                {
11319 avox 271
                                        qApp->changeOverrideCursor(QCursor(loadIcon("DelPoint.png")));
14155 jghali 272
                                        if (mouseRelease)
273
                                        {
274
                                                m_doc->Pages->at(m_page)->guides.deleteVertical( m_guide, GuideManagerCore::Standard);
275
                                                m_haveGuide = false;
15729 fschmid 276
                                                m_doc->changed();
14155 jghali 277
                                        }
11190 avox 278
                                }
279
                        }
12776 fschmid 280
                        m_canvas->displayCorrectedSingleHUD(m->globalPos(), mousePointDoc.x(), true);
11190 avox 281
                        break;
282
        }
11319 avox 283
        m_xy = newMousePoint;
11190 avox 284
}
285
 
286
 
287
void RulerGesture::mouseMoveEvent(QMouseEvent* m)
288
{
14155 jghali 289
        movePoint(m, false);
11319 avox 290
        m->accept();
12729 subik 291
        if (m_ScMW->doc->guidesSettings.guidesShown)
14155 jghali 292
                emit guideInfo(m_mode, m_currentGuide);
11190 avox 293
}
294
 
295
 
296
void RulerGesture::mouseReleaseEvent(QMouseEvent* m)
297
{
14155 jghali 298
        movePoint(m, true);
11319 avox 299
        if (m_mode == ORIGIN)
300
                m_view->setNewRulerOrigin(m);
11814 fschmid 301
        else
12729 subik 302
        {
303
                if (m_ScMW->doc->guidesSettings.guidesShown)
304
                        m_ScMW->guidePalette->setupPage();
305
        }
11327 avox 306
        m_haveGuide = false;
11319 avox 307
        m->accept();
308
        m_canvas->repaint();
11190 avox 309
        m_view->stopGesture();
12729 subik 310
        if (m_ScMW->doc->guidesSettings.guidesShown)
14155 jghali 311
                emit guideInfo(m_mode, m_currentGuide);
11190 avox 312
}
313
 
314
 
315
void RulerGesture::mousePressEvent(QMouseEvent* m)
316
{
317
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
318
        if (mouseHitsGuide(mousePointDoc))
11319 avox 319
        {
12649 fschmid 320
                m_xy = m->globalPos() - (m_canvas->mapToParent(QPoint(0, 0)) + m_canvas->parentWidget()->mapToGlobal(QPoint(0, 0)));
11319 avox 321
                m->accept();
322
        }
12729 subik 323
        if (m_ScMW->doc->guidesSettings.guidesShown)
14155 jghali 324
                emit guideInfo(m_mode, m_currentGuide);
11229 fschmid 325
}
12587 pierre 326