Subversion Repositories Scribus

Rev

Rev 18921 | 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
                          hruler.cpp  -  description
9
                             -------------------
10
    begin                : Tue Apr 10 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
 
15706 jghali 24
#include <cmath>
25
 
10369 cbradney 26
#include <QCursor>
27
#include <QMouseEvent>
16477 craig 28
#include <QPainter>
8501 cbradney 29
#include <QPaintEvent>
9832 fschmid 30
#include <QPixmap>
10369 cbradney 31
#include <QPolygon>
9832 fschmid 32
#include <QRect>
10369 cbradney 33
 
11319 avox 34
#include "canvasgesture_rulermove.h"
10369 cbradney 35
#include "hruler.h"
36
#include "page.h"
37
#include "prefsmanager.h"
38
#include "scribus.h"
39
#include "scribusdoc.h"
838 cbradney 40
#include "scribusview.h"
3934 cbradney 41
#include "selection.h"
2380 cbradney 42
#include "units.h"
161 Franz 43
 
10369 cbradney 44
 
272 Franz 45
#if QT_VERSION  > 0x030102
8501 cbradney 46
        #define SPLITHC Qt::SplitVCursor
272 Franz 47
#else
8501 cbradney 48
        #define SPLITHC Qt::SplitHCursor
272 Franz 49
#endif
50
 
10200 cbradney 51
#include "util_icon.h"
278 Franz 52
 
3205 craig 53
 
10532 avox 54
#ifdef Q_WS_MAC
3055 avox 55
    #define topline 1
56
#else
57
    #define topline 3
58
#endif
15468 craig 59
#define bottomline 15
60
#define rulerheight (bottomline - topline)
61
#define midline (topline + rulerheight/2)
62
#define tabline 7
3055 avox 63
 
5569 avox 64
enum ruler_code
65
{
66
        rc_none = 0,
67
        rc_leftFrameDist = 1,
68
        rc_rightFrameDist = 2,
69
        rc_indentFirst = 3,
70
        rc_leftMargin = 4,
71
        rc_tab = 5,
72
        rc_rightMargin = 6
73
};
3055 avox 74
 
5569 avox 75
 
456 fschmid 76
Hruler::Hruler(ScribusView *pa, ScribusDoc *doc) : QWidget(pa)
3 paul 77
{
2834 cbradney 78
        prefsManager=PrefsManager::instance();
8692 fschmid 79
        setBackgroundRole(QPalette::Window);
80
        setAutoFillBackground(true);
81
        QPalette palette;
82
        palette.setBrush(QPalette::Window, QColor(255, 255, 255));
83
        setPalette(palette);
2380 cbradney 84
        currDoc = doc;
85
        currView = pa;
2863 fschmid 86
        offs = 0;
3 paul 87
        Markp = 0;
5403 avox 88
        oldMark = 0;
7988 fschmid 89
        ActCol = 1;
3 paul 90
        Mpressed = false;
15468 craig 91
        textEditMode = false;
8692 fschmid 92
        drawMark = false;
5569 avox 93
        RulerCode = rc_none;
277 Franz 94
        setMouseTracking(true);
11319 avox 95
        rulerGesture = new RulerGesture(currView, RulerGesture::HORIZONTAL);
2380 cbradney 96
        unitChange();
3 paul 97
}
98
 
15468 craig 99
double Hruler::textBase() const
3 paul 100
{
15468 craig 101
        return ItemPos + lineCorr + Extra;
102
}
103
 
104
double Hruler::textWidth() const
105
{
106
        return ItemEndPos - ItemPos - 2*lineCorr - Extra - RExtra;
107
}
108
 
109
double Hruler::textPosToCanvas(double x) const
110
{
111
        return x + textBase();
112
}
113
 
114
int Hruler::textPosToLocal(double x) const
115
{
16089 jghali 116
        return qRound(textPosToCanvas(x) * Scaling) - currView->contentsX();
15468 craig 117
}
118
 
119
double Hruler::localToTextPos(int x) const
120
{
16089 jghali 121
        return ((x + currView->contentsX()) / Scaling - textBase());
15468 craig 122
}
123
 
124
void Hruler::shift(double pos)
125
{
126
        offs = pos;
127
}
128
 
129
void Hruler::shiftRel(double dist)
130
{
131
        offs += dist;
132
}
133
 
134
 
135
int Hruler::findRulerHandle(QPoint mp, double grabRadius)
136
{
137
        int mx = mp.x();
138
        QRect fpo;
139
        int result = rc_none;
140
        int Pos = textPosToLocal(0);
141
        if (Pos-1 < (mx + grabRadius) && Pos-1 > (mx - grabRadius))
142
                result = rc_leftFrameDist;
143
        Pos = textPosToLocal(textWidth());
144
        if (Pos+1 < (mx + grabRadius) && Pos+1 > (mx - grabRadius))
145
                result = rc_rightFrameDist;
146
        double ColWidth = (textWidth() - ColGap * (Cols - 1)) / Cols;
147
        ActCol = 0;
148
        for (int CurrCol = 0; CurrCol < Cols; ++CurrCol)
275 Franz 149
        {
15468 craig 150
                Pos = textPosToLocal((ColWidth+ColGap)*CurrCol);
151
                fpo = QRect(Pos, topline, static_cast<int>(ColWidth*Scaling), rulerheight);
152
                if (fpo.contains(mp))
278 Franz 153
                {
15468 craig 154
                        ActCol = CurrCol+1;
155
                        break;
278 Franz 156
                }
15468 craig 157
        }
158
        if (ActCol == 0)
159
        {
160
                ActCol = 1;
161
                return result;
162
        }
163
        Pos = textPosToLocal(First+Indent+(ColWidth+ColGap)*(ActCol-1));
164
        fpo = QRect(Pos-1, topline, grabRadius+1, rulerheight/2);
165
        if (fpo.contains(mp))
166
        {
167
                return rc_indentFirst;
168
        }
169
        Pos = textPosToLocal(Indent+(ColWidth+ColGap)*(ActCol-1));
170
        fpo = QRect(Pos-1, midline, grabRadius+1, rulerheight/2);
171
        if (fpo.contains(mp))
172
        {
173
                return rc_leftMargin;
174
        }
175
        Pos = textPosToLocal(RMargin+(ColWidth+ColGap)*(ActCol-1));
176
        fpo = QRect(Pos-grabRadius, midline, grabRadius, rulerheight/2);
177
        if (fpo.contains(mp))
178
        {
179
                return rc_rightMargin;
180
        }
181
        if (TabValues.count() != 0)
182
        {
183
                for (int yg = 0; yg < signed(TabValues.count()); yg++)
7988 fschmid 184
                {
15468 craig 185
                        Pos = textPosToLocal(TabValues[yg].tabPosition+(ColWidth+ColGap)*(ActCol-1));
186
                        fpo = QRect(Pos-grabRadius, tabline, 2*grabRadius, rulerheight/2 + 2);
187
                        if (fpo.contains(mp))
278 Franz 188
                        {
15468 craig 189
                                result = rc_tab;
190
                                ActTab = yg;
191
                                break;
276 Franz 192
                        }
193
                }
15468 craig 194
        }
195
        return result;
196
}
197
 
198
void Hruler::mousePressEvent(QMouseEvent *m)
199
{
200
        if (currDoc->isLoading())
201
                return;
202
        Mpressed = true;
203
        MouseX = m->x();
204
        if (textEditMode)
205
        {
206
                RulerCode = findRulerHandle(m->pos(), currDoc->guidesSettings.grabRad);
8508 cbradney 207
                if ((RulerCode == rc_none) && (ActCol != 0) && (m->button() == Qt::LeftButton))
278 Franz 208
                {
5184 avox 209
                        ParagraphStyle::TabRecord tb;
15468 craig 210
                        tb.tabPosition = localToTextPos(m->x());
2282 fschmid 211
                        tb.tabType = 0;
2380 cbradney 212
                        tb.tabFillChar = currDoc->toolSettings.tabFillChar[0];
2282 fschmid 213
                        TabValues.prepend(tb);
278 Franz 214
                        ActTab = 0;
5569 avox 215
                        RulerCode = rc_tab;
278 Franz 216
                        UpdateTabList();
18921 jghali 217
                        qApp->setOverrideCursor(QCursor(Qt::SizeHorCursor));
284 Franz 218
                        emit DocChanged(false);
278 Franz 219
                }
275 Franz 220
        }
221
        else
358 Franz 222
        {
11319 avox 223
                if (currDoc->guidesSettings.guidesShown)
456 fschmid 224
                {
18921 jghali 225
                        qApp->setOverrideCursor(QCursor(SPLITHC));
11319 avox 226
                        currView->startGesture(rulerGesture);
456 fschmid 227
                }
358 Franz 228
        }
3 paul 229
}
230
 
231
void Hruler::mouseReleaseEvent(QMouseEvent *m)
232
{
2891 cbradney 233
        if (currDoc->isLoading())
1005 fschmid 234
        {
235
                Mpressed = false;
236
                return;
237
        }
15468 craig 238
        if (textEditMode && currItem)
275 Franz 239
        {
278 Franz 240
                if ((m->y() < height()) && (m->y() > 0))
275 Franz 241
                {
13722 jghali 242
                        bool mustApplyStyle = false;
243
                        ParagraphStyle paraStyle;
15468 craig 244
                        double ColWidth = (textWidth() - ColGap * (Cols - 1)) / Cols;                  
278 Franz 245
                        switch (RulerCode)
246
                        {
5569 avox 247
                                case rc_leftFrameDist:
4847 cbradney 248
                                        currDoc->m_Selection->itemAt(0)->setTextToFrameDistLeft(Extra);
284 Franz 249
                                        emit DocChanged(false);
278 Franz 250
                                        break;
5569 avox 251
                                case rc_rightFrameDist:
4847 cbradney 252
                                        currDoc->m_Selection->itemAt(0)->setTextToFrameDistRight(RExtra);
284 Franz 253
                                        emit DocChanged(false);
278 Franz 254
                                        break;
5569 avox 255
                                case rc_indentFirst:
13722 jghali 256
                                        paraStyle.setFirstIndent(First);
257
                                        mustApplyStyle = true;
284 Franz 258
                                        emit DocChanged(false);
278 Franz 259
                                        break;
5569 avox 260
                                case rc_leftMargin:
13722 jghali 261
                                        paraStyle.setLeftMargin(Indent);
262
                                        paraStyle.setFirstIndent(First);
263
                                        mustApplyStyle = true;
284 Franz 264
                                        emit DocChanged(false);
278 Franz 265
                                        break;
5569 avox 266
                                case rc_rightMargin:
13722 jghali 267
                                        paraStyle.setRightMargin(ColWidth - RMargin);
268
                                        mustApplyStyle = true;
5569 avox 269
                                        emit DocChanged(false);
270
                                        break;
271
                                case rc_tab:
8508 cbradney 272
                                        if (m->button() == Qt::RightButton)
278 Franz 273
                                        {
2282 fschmid 274
                                                TabValues[ActTab].tabType += 1;
275
                                                if (TabValues[ActTab].tabType > 4)
276
                                                        TabValues[ActTab].tabType = 0;
278 Franz 277
                                        }
13722 jghali 278
                                        paraStyle.setTabValues(TabValues);
279
                                        mustApplyStyle = true;
284 Franz 280
                                        emit DocChanged(false);
278 Franz 281
                                        break;
282
                                default:
283
                                        break;
284
                        }
13722 jghali 285
                        if (mustApplyStyle)
286
                        {
287
                                Selection tempSelection(this, false);
288
                                tempSelection.addItem(currItem);
289
                                currDoc->itemSelection_ApplyParagraphStyle(paraStyle, &tempSelection);
290
                        }
291
                        else
292
                        {
293
                                currItem->update();
294
                        }
275 Franz 295
                }
278 Franz 296
                else
277 Franz 297
                {
5569 avox 298
                        if (RulerCode == rc_tab)
278 Franz 299
                        {
9797 avox 300
                                TabValues.removeAt(ActTab);
278 Franz 301
                                ActTab = 0;
13722 jghali 302
                                ParagraphStyle paraStyle;
303
                                paraStyle.setTabValues(TabValues);
304
                                Selection tempSelection(this, false);
305
                                tempSelection.addItem(currItem);
306
                                currDoc->itemSelection_ApplyParagraphStyle(paraStyle, &tempSelection);
284 Franz 307
                                emit DocChanged(false);
278 Franz 308
                        }
309
                }
5569 avox 310
                RulerCode = rc_none;
2380 cbradney 311
                currView->DrawNew();
4847 cbradney 312
                currDoc->m_Selection->itemAt(0)->emitAllToGUI();
275 Franz 313
        }
314
        else
315
        {
11319 avox 316
                if (Mpressed)
456 fschmid 317
                {
11319 avox 318
                        rulerGesture->mouseReleaseEvent(m);
319
                        Mpressed = false;
456 fschmid 320
                }
275 Franz 321
        }
456 fschmid 322
        Mpressed = false;
18921 jghali 323
        qApp->restoreOverrideCursor();
3 paul 324
}
325
 
15468 craig 326
void Hruler::enterEvent(QEvent *e)
327
{
15734 fschmid 328
        if (textEditMode)
329
                qApp->changeOverrideCursor(QCursor(loadIcon("tab.png"), 3));
15468 craig 330
}
331
 
15484 jghali 332
void Hruler::leaveEvent(QEvent *e)
333
{
334
        emit MarkerMoved(0, -1);
19633 craig 335
        qApp->restoreOverrideCursor();
15484 jghali 336
        currView->m_canvasMode->setModeCursor();
337
}
338
 
3 paul 339
void Hruler::mouseMoveEvent(QMouseEvent *m)
340
{
2891 cbradney 341
        if (currDoc->isLoading())
1005 fschmid 342
                return;
15468 craig 343
        if (textEditMode)
275 Franz 344
        {
15468 craig 345
                double ColWidth = (textWidth() - ColGap * (Cols - 1)) / Cols;
277 Franz 346
                int ColEnd, ColStart;
347
                double oldInd;
5569 avox 348
                if (RulerCode == rc_leftFrameDist || RulerCode == rc_rightFrameDist)
275 Franz 349
                {
15468 craig 350
                        ColStart = 0; //textPosToLocal(0);
351
                        ColEnd = width(); //textPosToLocal(textWidth());
277 Franz 352
                }
353
                else
354
                {
15468 craig 355
                        ColStart = textPosToLocal((ColWidth+ColGap)*(ActCol-1));
356
                        ColEnd = textPosToLocal((ColWidth+ColGap)*(ActCol-1) + ColWidth);
277 Franz 357
                }
15468 craig 358
                if ((Mpressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > ColStart - currDoc->guidesSettings.grabRad) && (m->x() < ColEnd + currDoc->guidesSettings.grabRad))
277 Franz 359
                {
9379 fschmid 360
                        qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
15468 craig 361
                        double toplimit = textWidth() + RExtra - (ColGap * (Cols - 1))-1;
362
                        double toplimit2 = textWidth() + Extra - (ColGap * (Cols - 1))-1;
275 Franz 363
                        switch (RulerCode)
364
                        {
5569 avox 365
                                case rc_leftFrameDist:
276 Franz 366
                                        Extra -= (MouseX - m->x()) / Scaling;
275 Franz 367
                                        if (Extra < 0)
368
                                                Extra = 0;
369
                                        if (Extra > toplimit2)
370
                                                Extra = toplimit2;
15468 craig 371
                                        emit MarkerMoved(currItem->xPos(), textBase()-currItem->xPos());
275 Franz 372
                                        repaint();
373
                                        break;
5569 avox 374
                                case rc_rightFrameDist:
276 Franz 375
                                        RExtra += (MouseX - m->x()) / Scaling;
275 Franz 376
                                        if (RExtra < 0)
377
                                                RExtra = 0;
378
                                        if (RExtra > toplimit)
379
                                                RExtra = toplimit;
284 Franz 380
                                        emit MarkerMoved(RExtra, 0);
275 Franz 381
                                        repaint();
382
                                        break;
5569 avox 383
                                case rc_indentFirst:
276 Franz 384
                                        First -= (MouseX - m->x()) / Scaling;
15468 craig 385
                                        if (First+Indent < 0)
386
                                                First = -Indent;                                       
276 Franz 387
                                        if (First+Indent > ColWidth)
388
                                                First  = ColWidth-Indent;
15468 craig 389
                                        emit MarkerMoved(textBase(), First+Indent);
276 Franz 390
                                        repaint();
391
                                        break;
5569 avox 392
                                case rc_leftMargin:
277 Franz 393
                                        oldInd = Indent+First;
276 Franz 394
                                        Indent -= (MouseX - m->x()) / Scaling;
395
                                        if (Indent < 0)
396
                                                Indent = 0;
397
                                        if (Indent > ColWidth-1)
398
                                                Indent  = ColWidth-1;
277 Franz 399
                                        First = oldInd - Indent;
15468 craig 400
                                        emit MarkerMoved(textBase(), Indent);
276 Franz 401
                                        repaint();
402
                                        break;
5569 avox 403
                                case rc_rightMargin:
404
                                        RMargin -= (MouseX - m->x()) / Scaling;
405
                                        if (RMargin < 0)
406
                                                RMargin = 0;
407
                                        if (RMargin > ColWidth-1)
408
                                                RMargin  = ColWidth-1;
15468 craig 409
                                        emit MarkerMoved(textBase(), RMargin);
5569 avox 410
                                        repaint();
411
                                        break;
412
                                case rc_tab:
2282 fschmid 413
                                        TabValues[ActTab].tabPosition -= (MouseX - m->x()) / Scaling;
414
                                        if (TabValues[ActTab].tabPosition < 0)
415
                                                TabValues[ActTab].tabPosition = 0;
416
                                        if (TabValues[ActTab].tabPosition > ColWidth-1)
417
                                                TabValues[ActTab].tabPosition  = ColWidth-1;
15468 craig 418
                                        emit MarkerMoved(textBase(), TabValues[ActTab].tabPosition);
278 Franz 419
                                        UpdateTabList();
420
                                        repaint();
421
                                        break;
275 Franz 422
                                default:
423
                                        break;
424
                        }
425
                        MouseX = m->x();
15468 craig 426
/*                      if (RulerCode != rc_none)
277 Franz 427
                        {
2380 cbradney 428
                                QPoint py = currView->viewport()->mapFromGlobal(m->globalPos());
15468 craig 429
                                QPainter p;
2380 cbradney 430
                                p.begin(currView->viewport());
8651 jghali 431
                                p.setCompositionMode(QPainter::CompositionMode_Xor);
8508 cbradney 432
                                p.setPen(QPen(Qt::white, 1, Qt::DotLine, Qt::FlatCap, Qt::MiterJoin));
5087 subik 433
                                QPoint out = currView->contentsToViewport(QPoint(0, qRound(currDoc->currentPage()->yOffset() * Scaling)));
434
                                p.drawLine(Markp, out.y(), Markp, out.y()+qRound(currDoc->currentPage()->height() * Scaling));
435
                                p.drawLine(py.x(), out.y(), py.x(), out.y()+qRound(currDoc->currentPage()->height() * Scaling));
15468 craig 436
                                p.end();
277 Franz 437
                                Markp = py.x();
15468 craig 438
                        }*/
278 Franz 439
                        return;
275 Franz 440
                }
15468 craig 441
                if ((!Mpressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > ColStart - 2*currDoc->guidesSettings.grabRad) && (m->x() < ColEnd + 2*currDoc->guidesSettings.grabRad))
277 Franz 442
                {
18921 jghali 443
                        setCursor(QCursor(loadIcon("tab.png"), 3));
15468 craig 444
                        switch(findRulerHandle(m->pos(), currDoc->guidesSettings.grabRad))
277 Franz 445
                        {
15468 craig 446
                                case rc_leftFrameDist:
18921 jghali 447
                                        setCursor(QCursor(Qt::SplitHCursor));
15468 craig 448
                                        break;
449
                                case rc_rightFrameDist:
18921 jghali 450
                                        setCursor(QCursor(Qt::SplitHCursor));
15468 craig 451
                                        break;
452
                                case rc_indentFirst:
18921 jghali 453
                                        setCursor(QCursor(Qt::SizeHorCursor));
15468 craig 454
                                        break;
455
                                case rc_leftMargin:
18921 jghali 456
                                        setCursor(QCursor(Qt::SizeHorCursor));
15468 craig 457
                                        break;
458
                                case rc_rightMargin:
18921 jghali 459
                                        setCursor(QCursor(Qt::SizeHorCursor));
15468 craig 460
                                        break;
461
                                case rc_tab:
18921 jghali 462
                                        setCursor(QCursor(Qt::SizeHorCursor));
15468 craig 463
                                        break;
277 Franz 464
                        }
15468 craig 465
                        Draw(m->x());
466
                        double marker = localToTextPos(m->x());
467
                        emit MarkerMoved(textBase(), marker);
278 Franz 468
                        return;
277 Franz 469
                }
5569 avox 470
                if ((Mpressed) && (RulerCode == rc_tab) && ((m->y() > height()) || (m->y() < 0)))
278 Franz 471
                {
18921 jghali 472
                        setCursor(QCursor(loadIcon("DelPoint.png"), 1, 1));
278 Franz 473
                        return;
474
                }
18921 jghali 475
                setCursor(QCursor(Qt::ArrowCursor));
275 Franz 476
        }
477
        else
478
        {
11319 avox 479
                if (Mpressed)
480
                        rulerGesture->mouseMoveEvent(m);
15295 jghali 481
                else
18921 jghali 482
                        setCursor(QCursor(Qt::ArrowCursor));
275 Franz 483
        }
3 paul 484
}
485
 
2892 fschmid 486
void Hruler::paintEvent(QPaintEvent *e)
3 paul 487
{
2891 cbradney 488
        if (currDoc->isLoading())
1005 fschmid 489
                return;
2860 fschmid 490
        QString tx = "";
4593 cbradney 491
        double sc = currView->scale();
2863 fschmid 492
        Scaling = sc;
2860 fschmid 493
        QFont ff = font();
494
        ff.setPointSize(8);
495
        setFont(ff);
496
        QPainter p;
497
        p.begin(this);
2892 fschmid 498
        p.setClipRect(e->rect());
2860 fschmid 499
        p.setFont(font());
15468 craig 500
 
501
        drawMarks(p);
502
 
503
        if (textEditMode)
2860 fschmid 504
        {
16089 jghali 505
                int rectX1 = textPosToLocal(Extra);
506
                int rectX2 = textPosToLocal(ItemEndPos-ItemPos-RExtra);
507
                p.eraseRect(QRect(QPoint(rectX1, 1), QPoint(rectX2, 15)));
508
                p.drawLine(rectX1, 16, rectX2, 16);
2860 fschmid 509
                p.save();
15468 craig 510
                p.setRenderHints(QPainter::Antialiasing, true);
2860 fschmid 511
                if (Revers)
512
                {
16089 jghali 513
                        p.translate( textPosToLocal(0), 0);
2860 fschmid 514
                        p.scale(-1, 1);
16089 jghali 515
                        p.translate( textPosToLocal(Extra) - textPosToLocal(ItemEndPos-ItemPos-RExtra), 0);
516
                        p.translate(-textPosToLocal(0), 0);
2860 fschmid 517
                }
518
                for (int CurrCol = 0; CurrCol < Cols; ++CurrCol)
519
                {
15468 craig 520
                        double ColWidth = (textWidth() - ColGap * (Cols - 1)) / Cols;
521
                        double Pos = (ColWidth + ColGap) * CurrCol;
522
                        double EndPos = Pos + ColWidth;
523
                        drawTextMarks(Pos, EndPos, p);
524
 
8508 cbradney 525
                        p.setPen(QPen(Qt::blue, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
15468 craig 526
                        int xPos = textPosToLocal(Pos);
527
                        p.drawLine(xPos, topline, xPos, bottomline);
2860 fschmid 528
                        if (CurrCol == 0)
529
                        {
15468 craig 530
                                p.drawLine(xPos, 15, (xPos+4), 15);
531
                                p.drawLine(xPos, topline, (xPos+4), topline);
2860 fschmid 532
                        }
15468 craig 533
 
534
                        p.setPen(QPen(Qt::blue, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
535
                        xPos = textPosToLocal(Pos+First+Indent);
536
                        QPolygon cr;
537
                        cr.setPoints(3, xPos, midline, xPos+3, topline, xPos-3, topline);
538
                        p.drawPolygon(cr);
539
 
540
                        xPos = textPosToLocal(Pos+Indent);
541
                        QPolygon cr2;
542
                        cr2.setPoints(3, xPos, midline, xPos+3, bottomline, xPos-3, bottomline);
543
                        p.drawPolygon(cr2);
544
                        xPos = textPosToLocal(Pos+RMargin);
545
                        QPolygon cr3;
546
                        cr3.setPoints(3, xPos, topline, xPos, bottomline, xPos-3, midline);
547
                        p.drawPolygon(cr3);
548
 
2860 fschmid 549
                        if (TabValues.count() != 0)
550
                        {
8508 cbradney 551
                                p.setPen(QPen(Qt::black, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
15468 craig 552
                                for (int yg = 0; yg < signed(TabValues.count()); yg++)                         
2860 fschmid 553
                                {
15468 craig 554
                                        xPos = textPosToLocal(Pos+TabValues[yg].tabPosition);
2860 fschmid 555
                                        if (Pos+TabValues[yg].tabPosition < EndPos)
556
                                        {
557
                                                switch (static_cast<int>(TabValues[yg].tabType))
558
                                                {
559
                                                        case 0:
560
                                                                if (Revers)
561
                                                                {
562
                                                                        p.save();
15468 craig 563
                                                                        p.translate(Pos + TabValues[yg].tabPosition,0);
2860 fschmid 564
                                                                        p.scale(-1,1);
15468 craig 565
                                                                        p.drawLine(0, tabline, 0, bottomline);
566
                                                                        p.drawLine(0, bottomline, 8, bottomline);
2860 fschmid 567
                                                                        p.restore();
568
                                                                }
569
                                                                else
570
                                                                {
15468 craig 571
                                                                        p.drawLine(xPos, tabline, xPos, bottomline);
572
                                                                        p.drawLine(xPos, bottomline, xPos+8, bottomline);
2860 fschmid 573
                                                                }
574
                                                                break;
575
                                                        case 1:
576
                                                                if (Revers)
577
                                                                {
578
                                                                        p.save();
15468 craig 579
                                                                        p.translate(Pos+TabValues[yg].tabPosition,0);
2860 fschmid 580
                                                                        p.scale(-1,1);
15468 craig 581
                                                                        p.drawLine(0, tabline, 0, bottomline);
582
                                                                        p.drawLine(0, bottomline, -8, bottomline);
2860 fschmid 583
                                                                        p.restore();
584
                                                                }
585
                                                                else
586
                                                                {
15468 craig 587
                                                                        p.drawLine(xPos, tabline, xPos, bottomline);
588
                                                                        p.drawLine(xPos, bottomline, xPos-8, bottomline);
2860 fschmid 589
                                                                }
590
                                                                break;
591
                                                        case 2:
592
                                                        case 3:
15468 craig 593
                                                                p.drawLine(xPos, tabline, xPos, bottomline);
594
                                                                p.drawLine(xPos-4, bottomline, xPos+4, bottomline);
595
                                                                p.drawLine(xPos+3, bottomline-3, xPos+2, bottomline-3);
2860 fschmid 596
                                                                break;
597
                                                        case 4:
15468 craig 598
                                                                p.drawLine(xPos, tabline, xPos, bottomline);
599
                                                                p.drawLine(xPos-4, bottomline, xPos+4, bottomline);
2860 fschmid 600
                                                                break;
601
                                                        default:
602
                                                                break;
603
                                                }
604
                                        }
605
                                }
606
                        }
15468 craig 607
 
8508 cbradney 608
                        p.setPen(QPen(Qt::blue, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
15468 craig 609
                        xPos = textPosToLocal(EndPos);
610
                        p.drawLine(xPos, topline, xPos, bottomline);
2860 fschmid 611
                        if (CurrCol == Cols-1)
612
                        {
15468 craig 613
                                p.drawLine(xPos, bottomline, xPos-4 , bottomline);
614
                                p.drawLine(xPos, topline, xPos-4, topline);
2860 fschmid 615
                        }
616
                }
2863 fschmid 617
                p.restore();
2860 fschmid 618
        }
15468 craig 619
        if (drawMark && !Mpressed)
8692 fschmid 620
        {
15468 craig 621
                drawMarker(p);
622
        }
623
        p.end();
624
}
625
 
626
void Hruler::drawMarker(QPainter& p)
627
{
628
        QPolygon cr;
8692 fschmid 629
#ifdef OPTION_SMOOTH_MARKERS
15468 craig 630
        // draw new marker to pixmap
631
        static const int SCALE = 16;
632
        static const QColor BACKGROUND(255, 255, 255);
633
        static QPixmap pix( 4*SCALE, 16*SCALE );
634
        static bool initpix = true;
635
        if (initpix) {
636
                initpix = false;
637
                QPainter pp( &pix );
638
                pp.setBrush( BACKGROUND );
639
                pp.drawRect( 0, 0, 4*SCALE, 16*SCALE );
640
                pp.setPen(Qt::red);
641
                pp.setBrush(Qt::red);
642
                cr.setPoints(3, 2*SCALE, 16*SCALE, 4*SCALE, 0, 0, 0);
643
                pp.drawPolygon(cr);
644
        }
645
        // draw pixmap
646
        p.save();
647
        p.translate(-currView->contentsX(), 0);
648
        p.scale(1.0/SCALE, 1.0/(SCALE+1));
649
        p.drawPixmap((where-2)*SCALE, 1, pix);
650
        p.restore();
651
        // restore marks
652
        p.setBrush(Qt::black);
653
        p.setPen(Qt::black);
654
        p.setFont(font());
655
        double sc = currView->getScale();
656
        double cc = width() / sc;
657
        double firstMark = ceil(offs / iter) * iter - offs;
658
        while (firstMark < cc)
659
        {
660
                p.drawLine(qRound(firstMark * sc), 10, qRound(firstMark * sc), 16);
661
                firstMark += iter;
662
        }
663
#else
664
        // draw slim marker
665
        p.resetTransform();
666
        p.translate(-currView->contentsX(), 0);
667
        p.setPen(Qt::red);
668
        p.setBrush(Qt::red);
669
        cr.setPoints(5, whereToDraw, 5, whereToDraw, 16, whereToDraw, 5, whereToDraw+2, 0, whereToDraw-2, 0);
670
        p.drawPolygon(cr);
671
#endif
672
}
673
 
674
 
675
void Hruler::drawMarks(QPainter& p)
676
{
677
        p.setBrush(Qt::black);
678
        p.setPen(Qt::black);
679
        p.drawLine(0, 16, width(), 16);
680
        double sc = Scaling;
681
        double cc = width() / sc;
682
        double firstMark = ceil(offs / iter) * iter - offs;
683
        while (firstMark < cc)
684
        {
685
                p.drawLine(qRound(firstMark * sc), 10, qRound(firstMark * sc), 16);
686
                firstMark += iter;
687
        }
688
        firstMark = ceil(offs / iter2) * iter2 - offs;
689
        int markC = static_cast<int>(ceil(offs / iter2));
690
 
691
        QString tx;
692
        double xl, frac;
693
        while (firstMark < cc)
694
        {
695
                p.drawLine(qRound(firstMark * sc), topline, qRound(firstMark * sc), 16);
696
                switch (currDoc->unitIndex())
697
                {
698
                        case SC_MM:
699
                                tx = QString::number(markC * iter2 / (iter2 / 100) / cor);
700
                                break;
701
                        case SC_IN:
702
                                xl = (markC * iter2 / iter2) / cor;
703
                                tx = QString::number(static_cast<int>(xl));
704
                                frac = fabs(xl - static_cast<int>(xl));
705
                                if ((static_cast<int>(xl) == 0) && (frac > 0.1))
706
                                        tx = "";
707
                                if ((frac > 0.24) && (frac < 0.26))
708
                                        tx += QChar(0xBC);
709
                                if ((frac > 0.49) && (frac < 0.51))
710
                                        tx += QChar(0xBD);
711
                                if ((frac > 0.74) && (frac < 0.76))
712
                                        tx += QChar(0xBE);
713
                                tx = tx;
714
                                break;
715
                        case SC_P:
716
                        case SC_C:
717
                                tx = QString::number(markC * iter2 / (iter2 / 5) / cor);
718
                                break;
719
                        case SC_CM:
720
                                tx = QString::number(markC * iter2 / iter2 / cor);
721
                                break;
722
                        default:
723
                                tx = QString::number(markC * iter2);
724
                                break;
8692 fschmid 725
                }
15468 craig 726
                drawNumber(tx, qRound(firstMark * sc) + 2, 9, p);
727
                //p.drawText(qRound(firstMark * sc)+2, 9, tx);
728
                firstMark += iter2;
729
                markC++;
730
        }
731
}
732
 
733
void Hruler::drawTextMarks(double Pos, double EndPos, QPainter& p)
734
{
735
        double xl;
736
        p.setPen(QPen(Qt::blue, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
737
        p.setBrush(Qt::blue);
738
        for (xl = Pos; xl < EndPos; xl += iter)
739
        {
740
                int xli = textPosToLocal(xl);
741
                p.drawLine(xli, 10, xli, 16);
742
        }
743
        for (xl = Pos; xl < EndPos; xl += iter2)
744
        {
745
                int xli = textPosToLocal(xl);
746
                p.drawLine(xli, topline, xli, 16);
747
                switch (currDoc->unitIndex())
8692 fschmid 748
                {
15468 craig 749
                        case SC_IN:
750
                        {
751
                                QString tx = "";
752
                                int num1 = static_cast<int>((xl-Pos) / iter2 / cor);
753
                                if (num1 != 0)
754
                                        tx = QString::number(num1);
755
                                double frac = (xl / iter2 / cor) - num1;
756
                                if ((frac > 0.24) && (frac < 0.26))
757
                                        tx += QChar(0xBC);
758
                                if ((frac > 0.49) && (frac < 0.51))
759
                                        tx += QChar(0xBD);
760
                                if ((frac > 0.74) && (frac < 0.76))
761
                                        tx += QChar(0xBE);
762
                                if (Revers)
763
                                {
764
                                        p.save();
765
                                        p.translate(xli-2, 0);
766
                                        p.scale(-1,1);
767
                                        drawNumber(tx, 0, 17, p);
768
                                        //p.drawText(0, 17, tx);
769
                                        p.restore();
770
                                }
771
                                else
772
                                        drawNumber(tx, xli+2, 9, p);
773
                                //p.drawText(qRound((xl+2/sc) * sc), 9, tx);
774
                                break;
775
                        }
776
                        case SC_P:
777
                                if (Revers)
778
                                {
779
                                        p.save();
780
                                        p.translate(xli-2,0);
781
                                        p.scale(-1,1);
782
                                        drawNumber(QString::number((xl-Pos) / iter / cor), 0, 17, p);
783
                                        //p.drawText(0, 17, QString::number((xl-Pos) / iter / cor));
784
                                        p.restore();
785
                                }
786
                                else
787
                                        drawNumber(QString::number((xl-Pos) / iter / cor), xli+2, 9, p);
788
                                //p.drawText(qRound((xl+2/sc) * sc), 9, QString::number((xl-Pos) / iter / cor));
789
                                break;
790
                        case SC_CM:
791
                                if (Revers)
792
                                {
793
                                        p.save();
794
                                        p.translate(xli-2,0);
795
                                        p.scale(-1,1);
796
                                        drawNumber(QString::number((xl-Pos) / iter / 10 / cor), 0, 9, p);
797
                                        //p.drawText(0, 9, QString::number((xl-Pos) / iter / 10 / cor));
798
                                        p.restore();
799
                                }
800
                                else
801
                                        drawNumber(QString::number((xl-Pos) / iter / 10 / cor), xli+2, 9, p);
802
                                //p.drawText(qRound((xl+2/sc) * sc), 9, QString::number((xl-Pos) / iter / 10 / cor));
803
                                break;
804
                        case SC_C:
805
                                if (Revers)
806
                                {
807
                                        p.save();
808
                                        p.translate(xli-2,0);
809
                                        p.scale(-1,1);
810
                                        drawNumber(QString::number((xl-Pos) / iter / cor), 0, 9, p);
811
                                        //p.drawText(0, 9, QString::number((xl-Pos) / iter / cor));
812
                                        p.restore();
813
                                }
814
                                else
815
                                        drawNumber(QString::number((xl-Pos) / iter / cor), xli+2, 9, p);
816
                                //p.drawText(qRound((xl+2/sc) * sc), 9, QString::number((xl-Pos) / iter / cor));
817
                                break;
818
                        default:
819
                                if (Revers)
820
                                {
821
                                        p.save();
822
                                        p.translate(xli-2,0);
823
                                        p.scale(-1,1);
824
                                        drawNumber(QString::number((xl-Pos) / iter * 10 / cor), 0, 9, p);
825
                                        //p.drawText(0, 9, QString::number((xl-Pos) / iter * 10 / cor));
826
                                        p.restore();
827
                                }
828
                                else
829
                                        drawNumber(QString::number((xl-Pos) / iter * 10 / cor), xli+2, 9, p);
830
                                //p.drawText(qRound((xl+2/sc) * sc), 9, QString::number((xl-Pos) / iter * 10 / cor));
831
                                break;
8692 fschmid 832
                }
833
        }
3 paul 834
}
835
 
3055 avox 836
 
837
void Hruler::drawNumber(QString txt, int x, int y0, QPainter & p)
838
{
839
        const int y = y0 - 3 + topline;
840
        p.drawText(x,y,txt);
4272 subik 841
}
3055 avox 842
 
15181 jghali 843
double Hruler::ruleSpacing() {
844
        return iter;
845
}
846
 
4272 subik 847
void Hruler::Draw(int where)
3 paul 848
{
3055 avox 849
        // erase old marker
11691 fschmid 850
        int currentCoor = where - currView->contentsX();
8692 fschmid 851
        whereToDraw = where;
852
        drawMark = true;
2892 fschmid 853
        repaint(oldMark-3, 0, 7, 17);
10532 avox 854
//      drawMark = false;
2892 fschmid 855
        oldMark = currentCoor;
3 paul 856
}
278 Franz 857
 
5569 avox 858
void Hruler::setItem(PageItem * item)
2863 fschmid 859
{
5569 avox 860
        currItem = item;
861
        ItemPos = item->xPos();
862
        ItemEndPos = ItemPos + item->width();
15468 craig 863
        /*if (currDoc->guidesSettings.rulerMode)
2863 fschmid 864
        {
5087 subik 865
                ItemPos -= currDoc->currentPage()->xOffset();
866
                ItemEndPos -= currDoc->currentPage()->xOffset();
15468 craig 867
        }*/
13115 pierre 868
 
869
        if (item->lineColor() != CommonStrings::None)
870
                lineCorr = item->lineWidth() / 2.0;
871
        else
872
                lineCorr = 0;
873
        ColGap = item->ColGap;
874
        Cols = item->Cols;
875
        Extra = item->textToFrameDistLeft();
876
        RExtra = item->textToFrameDistRight();
877
        First = item->currentStyle().firstIndent();
878
        Indent = item->currentStyle().leftMargin();
879
        double columnWidth = (item->width() - (item->columnGap() * (item->columns() - 1))
880
                                - item->textToFrameDistLeft() - item->textToFrameDistLeft()
881
                                - 2*lineCorr) / item->columns();
882
        RMargin = columnWidth - item->currentStyle().rightMargin();
883
        if (item->imageFlippedH() || (item->reversed()))
884
                Revers = true;
885
        else
886
                Revers = false;
15468 craig 887
        textEditMode = true;
13115 pierre 888
        TabValues = item->currentStyle().tabValues();
2863 fschmid 889
}
890
 
278 Franz 891
void Hruler::UpdateTabList()
892
{
5184 avox 893
        ParagraphStyle::TabRecord tb;
2282 fschmid 894
        tb.tabPosition = TabValues[ActTab].tabPosition;
895
        tb.tabType = TabValues[ActTab].tabType;
896
        tb.tabFillChar =  TabValues[ActTab].tabFillChar;
897
        int gg = static_cast<int>(TabValues.count());
278 Franz 898
        int g = gg;
9797 avox 899
        TabValues.removeAt(ActTab);
2282 fschmid 900
        for (int yg = static_cast<int>(TabValues.count()-1); yg > -1; yg--)
278 Franz 901
        {
2282 fschmid 902
                if (tb.tabPosition < TabValues[yg].tabPosition)
278 Franz 903
                        g = yg;
904
        }
2282 fschmid 905
        ActTab = g;
278 Franz 906
        if (gg == g)
907
        {
2282 fschmid 908
                TabValues.append(tb);
909
                ActTab = static_cast<int>(TabValues.count()-1);
278 Franz 910
        }
911
        else
912
        {
9797 avox 913
                TabValues.insert(ActTab, tb);
278 Franz 914
        }
915
}
2380 cbradney 916
 
917
void Hruler::unitChange()
918
{
4593 cbradney 919
        double sc = currView->scale();
2380 cbradney 920
        cor=1;
2965 cbradney 921
        int docUnitIndex=currDoc->unitIndex();
922
        switch (docUnitIndex)
2380 cbradney 923
        {
12350 cbradney 924
                case SC_PT:
2380 cbradney 925
                        if (sc > 1 && sc <= 4)
926
                                cor = 2;
927
                        if (sc > 4)
928
                                cor = 10;
7438 fschmid 929
                        if (sc < 0.3)
930
                        {
931
                                iter = unitRulerGetIter1FromIndex(docUnitIndex) * 3;
932
                                iter2 = unitRulerGetIter2FromIndex(docUnitIndex) * 3;
933
                        }
934
                        else if (sc < 0.5)
935
                        {
936
                                iter = unitRulerGetIter1FromIndex(docUnitIndex) * 2;
937
                                iter2 = unitRulerGetIter2FromIndex(docUnitIndex) * 2;
938
                        }
939
                        else
940
                        {
941
                                iter = unitRulerGetIter1FromIndex(docUnitIndex) / cor;
942
                                iter2 = unitRulerGetIter2FromIndex(docUnitIndex) / cor;
943
                        }
2380 cbradney 944
                        break;
12350 cbradney 945
                case SC_MM:
2380 cbradney 946
                        if (sc > 1)
947
                                cor = 10;
2965 cbradney 948
                        iter = unitRulerGetIter1FromIndex(docUnitIndex) / cor;
949
                        iter2 = unitRulerGetIter2FromIndex(docUnitIndex) / cor;
2380 cbradney 950
                        break;
12350 cbradney 951
                case SC_IN:
2965 cbradney 952
                        iter = unitRulerGetIter1FromIndex(docUnitIndex);
953
                        iter2 = unitRulerGetIter2FromIndex(docUnitIndex);
2380 cbradney 954
                        if (sc > 1 && sc <= 4)
955
                        {
956
                                cor = 2;
957
                                iter /= cor;
958
                                iter2 /= cor;
959
                        }
960
                        if (sc > 4)
961
                        {
962
                                cor = 4;
963
                                iter /= cor;
964
                                iter2 /= cor;
965
                        }
12347 fschmid 966
                        if (sc < 0.25)
967
                        {
968
                                cor = 0.5;
969
                                iter = 72.0*16.0;
970
                                iter2 = 72.0*2.0;
971
                        }
2380 cbradney 972
                        break;
12350 cbradney 973
                case SC_P:
2965 cbradney 974
                        iter = unitRulerGetIter1FromIndex(docUnitIndex);
975
                        iter2 = unitRulerGetIter2FromIndex(docUnitIndex);
12351 cbradney 976
                        if (sc >= 1 && sc <= 4)
2380 cbradney 977
                        {
978
                                cor = 1;
979
                                iter = 12.0;
980
                                iter2 = 60.0;
981
                        }
982
                        if (sc > 4)
983
                        {
984
                                cor = 2;
985
                                iter = 6.0;
986
                                iter2 = 12.0;
987
                        }
12351 cbradney 988
                        if (sc < 0.3)
989
                        {
990
                                cor = 0.25;
991
                                iter = 12.0*4;
992
                                iter2 = 60.0*4;
993
                        }
994
                        else
995
                        if (sc < 1)
996
                        {
997
                                cor = 1;
998
                                iter = 12.0;
999
                                iter2 = 60.0;
1000
                        }
2380 cbradney 1001
                        break;
12350 cbradney 1002
                case SC_CM:
2380 cbradney 1003
                        if (sc > 1 && sc <= 4)
1004
                                cor = 1;
1005
                        if (sc > 4)
1006
                                cor = 10;
12353 cbradney 1007
                        if (sc < 0.6)
7438 fschmid 1008
                        {
12353 cbradney 1009
                                cor=0.1;
1010
                                iter = 720.0/25.4;
1011
                                iter2 = 7200.0/25.4;
7527 fschmid 1012
                        }
7438 fschmid 1013
                        else
1014
                        {
1015
                                iter = unitRulerGetIter1FromIndex(docUnitIndex) / cor;
1016
                                iter2 = unitRulerGetIter2FromIndex(docUnitIndex) / cor;
1017
                        }
2380 cbradney 1018
                        break;
12350 cbradney 1019
                case SC_C:
2965 cbradney 1020
                        iter = unitRulerGetIter1FromIndex(docUnitIndex);
1021
                        iter2 = unitRulerGetIter2FromIndex(docUnitIndex);
12354 cbradney 1022
                        if (sc >= 1 && sc <= 4)
2575 cbradney 1023
                        {
1024
                                cor = 1;
1025
                                iter = 72.0/25.4*4.512;
1026
                                iter2 = 72.0/25.4*4.512*5.0;
1027
                        }
1028
                        if (sc > 4)
1029
                        {
1030
                                cor = 2;
1031
                                iter = 72.0/25.4*4.512/2.0;
1032
                                iter2 = 72.0/25.4*4.512;
1033
                        }
12354 cbradney 1034
                        if (sc < 0.3)
1035
                        {
1036
                                cor = 0.1;
1037
                                iter = 72.0/25.4*4.512*10;
1038
                                iter2 = 72.0/25.4*4.512*5.0*10;
1039
                        }
1040
                        else
1041
                        if (sc < 1)
1042
                        {
1043
                                cor = 1;
1044
                                iter = 72.0/25.4*4.512;
1045
                                iter2 = 72.0/25.4*4.512*5.0;
1046
                        }
4272 subik 1047
                        break;
2380 cbradney 1048
                default:
1049
                        if (sc > 1 && sc <= 4)
1050
                                cor = 2;
1051
                        if (sc > 4)
1052
                                cor = 10;
1053
                        iter = unitRulerGetIter1FromIndex(0) / cor;
1054
                        iter2 = unitRulerGetIter2FromIndex(0) / cor;
1055
                        break;
1056
        }
1057
}