Subversion Repositories Scribus

Rev

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