Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
280 Franz 1
#include "tabruler.h"
2
#include "tabruler.moc"
3
#include <qvariant.h>
4
#include <qcombobox.h>
5
#include <qlabel.h>
6
#include <qpushbutton.h>
7
#include "mspinbox.h"
8
#include <qtoolbutton.h>
9
#include <qlayout.h>
10
#include <qtooltip.h>
11
#include <qwhatsthis.h>
12
#include <qpainter.h>
13
#include <qcursor.h>
14
#include <qcolor.h>
820 cbradney 15
#include "units.h"
280 Franz 16
extern QPixmap loadIcon(QString nam);
17
 
2282 fschmid 18
RulerT::RulerT(QWidget *pa, int ein, QValueList<PageItem::TabRecord> Tabs, bool ind, double wid) : QWidget(pa)
280 Franz 19
{
20
        setEraseColor(QColor(255,255,255));
820 cbradney 21
        unitIndex = ein;
22
        tabValues = Tabs;
280 Franz 23
        haveInd = ind;
820 cbradney 24
        offset = 0;
25
        firstLine = 0;
26
        leftIndent = 0;
27
        mousePressed = false;
28
        rulerCode = 0;
2282 fschmid 29
        actTab = -1;
280 Franz 30
        setMouseTracking(true);
31
        if (wid < 0)
32
        {
33
                setMinimumSize(QSize(400,25));
34
                setMaximumSize(QSize(4000,25));
35
                Width = 4000;
36
                resize(400, 25);
37
        }
38
        else
39
        {
40
                Width = wid;
41
                setMinimumSize(QSize(QMIN(static_cast<int>(Width), 400),25));
2282 fschmid 42
                setMaximumSize(QSize(4000,25));
280 Franz 43
                resize(QMIN(static_cast<int>(wid), 400), 25);
44
        }
45
}
46
 
47
void RulerT::paintEvent(QPaintEvent *)
48
{
49
        double xl, iter, iter2;
820 cbradney 50
        switch (unitIndex)
280 Franz 51
        {
52
                case 0:
53
                        iter = 10.0;
820 cbradney 54
                        iter2 = 100.0;
280 Franz 55
                        break;
56
                case 1:
57
                        iter = (10.0 / 25.4) * 72.0;
58
                        iter2 = iter * 10.0;
59
                        break;
60
                case 2:
61
                        iter = 18.0;
62
                        iter2 = 72.0;
63
                        break;
64
                case 3:
65
                        iter = 12.0;
66
                        iter2 = 120.0;
67
                        break;
68
        }
69
        QPainter p;
70
        p.begin(this);
71
        p.drawLine(0, 24, width(), 24);
820 cbradney 72
        p.translate(-offset, 0);
280 Franz 73
        p.setBrush(black);
74
        p.setFont(font());
75
        p.setPen(QPen(black, 1, SolidLine, FlatCap, MiterJoin));
820 cbradney 76
        for (xl = 0; xl < width()+offset; xl += iter)
280 Franz 77
        {
820 cbradney 78
                if (xl < offset)
280 Franz 79
                        continue;
80
                p.drawLine(qRound(xl), 18, qRound(xl), 24);
81
        }
820 cbradney 82
        for (xl = 0; xl < width()+(iter2/2)+offset; xl += iter2)
280 Franz 83
        {
820 cbradney 84
                if (xl < offset)
280 Franz 85
                        continue;
86
                p.drawLine(qRound(xl), 11, qRound(xl), 24);
820 cbradney 87
                switch (unitIndex)
280 Franz 88
                {
89
                        case 2:
90
                        {
91
                                QString tx = "";
92
                                int num1 = static_cast<int>(xl / iter2);
93
                                if (num1 != 0)
94
                                        tx = QString::number(num1);
95
                                double frac = (xl / iter2) - num1;
96
                                if ((frac > 0.24) && (frac < 0.26))
97
                                        tx += QChar(0xBC);
98
                                if ((frac > 0.49) && (frac < 0.51))
99
                                        tx += QChar(0xBD);
100
                                if ((frac > 0.74) && (frac < 0.76))
101
                                        tx += QChar(0xBE);
102
                                p.drawText(qRound(xl+2), 17, tx);
103
                                break;
104
                        }
105
                        case 3:
106
                                p.drawText(qRound(xl+2), 17, QString::number(xl / iter));
107
                                break;
108
                        default:
109
                                p.drawText(qRound(xl+2), 17, QString::number(xl / iter * 10));
110
                                break;
111
                }
112
        }
820 cbradney 113
        if (tabValues.count() != 0)
280 Franz 114
        {
2282 fschmid 115
                for (int yg = 0; yg < static_cast<int>(tabValues.count()); yg++)
280 Franz 116
                {
820 cbradney 117
                        if (yg == actTab)
280 Franz 118
                                p.setPen(QPen(red, 2, SolidLine, FlatCap, MiterJoin));
119
                        else
120
                                p.setPen(QPen(black, 2, SolidLine, FlatCap, MiterJoin));
2282 fschmid 121
                        switch (static_cast<int>(tabValues[yg].tabType))
280 Franz 122
                        {
123
                                case 0:
2282 fschmid 124
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23);
125
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 23, qRound(tabValues[yg].tabPosition+8), 23);
280 Franz 126
                                        break;
127
                                case 1:
2282 fschmid 128
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23);
129
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 23, qRound(tabValues[yg].tabPosition-8), 23);
280 Franz 130
                                        break;
131
                                case 2:
132
                                case 3:
2282 fschmid 133
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23);
134
                                        p.drawLine(qRound(tabValues[yg].tabPosition-4), 23, qRound(tabValues[yg].tabPosition+4), 23);
135
                                        p.drawLine(qRound(tabValues[yg].tabPosition+3), 20, qRound(tabValues[yg].tabPosition+2), 20);
280 Franz 136
                                        break;
137
                                case 4:
2282 fschmid 138
                                        p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23);
139
                                        p.drawLine(qRound(tabValues[yg].tabPosition-4), 23, qRound(tabValues[yg].tabPosition+4), 23);
280 Franz 140
                                        break;
141
                                default:
142
                                        break;
143
                        }
144
                }
145
        }
146
        if (haveInd)
147
        {
148
                p.setPen(QPen(blue, 1, SolidLine, FlatCap, MiterJoin));
149
                p.setBrush(blue);
150
                QPointArray cr;
820 cbradney 151
                cr.setPoints(3, qRound(firstLine+leftIndent), 12, qRound(firstLine+leftIndent-4), 0, qRound(firstLine+leftIndent+4), 0);
280 Franz 152
                p.drawPolygon(cr);
153
                QPointArray cr2;
820 cbradney 154
                cr2.setPoints(3, qRound(leftIndent), 12, qRound(leftIndent+4), 24, qRound(leftIndent-4), 24);
280 Franz 155
                p.drawPolygon(cr2);
156
        }
157
        p.end();
158
}
159
 
160
void RulerT::mousePressEvent(QMouseEvent *m)
161
{
162
        QRect fpo;
820 cbradney 163
        mousePressed = true;
164
        rulerCode = 0;
280 Franz 165
        if (haveInd)
166
        {
820 cbradney 167
                fpo = QRect(static_cast<int>(firstLine+leftIndent-offset)-4, 0, 8, 12);
280 Franz 168
                if (fpo.contains(m->pos()))
169
                {
820 cbradney 170
                        rulerCode = 1;
171
                        mouseX = m->x();
280 Franz 172
                        return;
173
                }
820 cbradney 174
                fpo = QRect(static_cast<int>(leftIndent-offset)-4, 12, 8, 12);
280 Franz 175
                if (fpo.contains(m->pos()))
176
                {
820 cbradney 177
                        rulerCode = 2;
178
                        mouseX = m->x();
280 Franz 179
                        return;
180
                }
181
        }
820 cbradney 182
        if (tabValues.count() != 0)
280 Franz 183
        {
2282 fschmid 184
                for (int yg = 0; yg < static_cast<int>(tabValues.count()); yg++)
280 Franz 185
                {
2282 fschmid 186
                        fpo = QRect(static_cast<int>(tabValues[yg].tabPosition-offset)-3, 15, 8, 8);
280 Franz 187
                        if (fpo.contains(m->pos()))
188
                        {
820 cbradney 189
                                rulerCode = 3;
190
                                actTab = yg;
191
                                mouseX = m->x();
2282 fschmid 192
                                emit tabSelected();
193
                                emit typeChanged(tabValues[actTab].tabType);
194
                                emit tabMoved(tabValues[actTab].tabPosition);
195
                                emit fillCharChanged(tabValues[actTab].tabFillChar);
280 Franz 196
                                repaint();
197
                                return;
198
                        }
199
                }
200
        }
820 cbradney 201
        if ((rulerCode == 0) && (m->button() == LeftButton))
280 Franz 202
        {
2282 fschmid 203
                struct PageItem::TabRecord tb;
204
                tb.tabPosition = static_cast<double>(m->x() + offset);
205
                tb.tabType = 0;
206
                tb.tabFillChar = QChar();
207
                tabValues.prepend(tb);
820 cbradney 208
                actTab = 0;
209
                rulerCode = 3;
210
                updateTabList();
280 Franz 211
                repaint();
820 cbradney 212
                emit newTab();
2282 fschmid 213
                emit typeChanged(tabValues[actTab].tabType);
214
                emit tabMoved(tabValues[actTab].tabPosition);
215
                emit fillCharChanged(tabValues[actTab].tabFillChar);
280 Franz 216
                qApp->setOverrideCursor(QCursor(SizeHorCursor), true);
217
        }
820 cbradney 218
        mouseX = m->x();
280 Franz 219
}
220
 
221
void RulerT::mouseReleaseEvent(QMouseEvent *m)
222
{
820 cbradney 223
        mousePressed = false;
280 Franz 224
        if ((m->y() < height()) && (m->y() > 0))
225
        {
820 cbradney 226
                if (rulerCode == 3)
280 Franz 227
                {
228
                        if (m->button() == RightButton)
229
                        {
2282 fschmid 230
                                tabValues[actTab].tabType += 1;
231
                                if (tabValues[actTab].tabType > 4)
232
                                        tabValues[actTab].tabType = 0;
233
                                emit typeChanged(tabValues[actTab].tabType);
280 Franz 234
                                repaint();
235
                        }
236
                }
237
        }
238
        else
239
        {
820 cbradney 240
                if (rulerCode == 3)
280 Franz 241
                {
2282 fschmid 242
                        QValueList<PageItem::TabRecord>::Iterator it;
820 cbradney 243
                        it = tabValues.at(actTab);
244
                        tabValues.remove(it);
245
                        actTab = 0;
246
                        if (tabValues.count() != 0)
280 Franz 247
                        {
2282 fschmid 248
                                emit typeChanged(tabValues[actTab].tabType);
249
                                emit tabMoved(tabValues[actTab].tabPosition);
250
                                emit fillCharChanged(tabValues[actTab].tabFillChar);
280 Franz 251
                        }
252
                        else
820 cbradney 253
                                emit noTabs();
280 Franz 254
                        repaint();
255
                        qApp->setOverrideCursor(QCursor(ArrowCursor), true);
256
                }
257
        }
820 cbradney 258
        rulerCode = 0;
2254 fschmid 259
        emit mouseReleased();
280 Franz 260
}
261
 
262
void RulerT::mouseMoveEvent(QMouseEvent *m)
263
{
264
        double oldInd;
265
        QRect fpo;
820 cbradney 266
        if ((mousePressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > 0) && (m->x() < width()))
280 Franz 267
        {
268
                qApp->setOverrideCursor(QCursor(SizeHorCursor), true);
820 cbradney 269
                switch (rulerCode)
280 Franz 270
                {
271
                        case 1:
820 cbradney 272
                                firstLine -= mouseX - m->x();
273
                                if (firstLine+leftIndent+offset < offset)
274
                                        firstLine += mouseX - m->x();
275
                                if (firstLine+leftIndent > Width)
276
                                        firstLine  = Width-leftIndent;
277
                                emit firstLineMoved(firstLine);
280 Franz 278
                                repaint();
279
                                break;
280
                        case 2:
820 cbradney 281
                                oldInd = leftIndent+firstLine;
282
                                leftIndent -= mouseX - m->x();
283
                                if (leftIndent < 0)
284
                                        leftIndent = 0;
285
                                if (leftIndent > Width-1)
286
                                        leftIndent  = Width-1;
287
                                firstLine = oldInd - leftIndent;
288
                                emit leftIndentMoved(leftIndent);
289
                                emit firstLineMoved(firstLine);
280 Franz 290
                                repaint();
291
                                break;
292
                        case 3:
2282 fschmid 293
                                tabValues[actTab].tabPosition -= mouseX - m->x();
294
                                if (tabValues[actTab].tabPosition < 0)
295
                                        tabValues[actTab].tabPosition = 0;
296
                                if (tabValues[actTab].tabPosition > Width-1)
297
                                        tabValues[actTab].tabPosition = Width-1;
820 cbradney 298
                                updateTabList();
2282 fschmid 299
                                emit tabMoved(tabValues[actTab].tabPosition);
280 Franz 300
                                repaint();
301
                                break;
302
                        default:
303
                                break;
304
                }
820 cbradney 305
                mouseX = m->x();
280 Franz 306
                return;
307
        }
820 cbradney 308
        if ((!mousePressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > 0) && (m->x() < width()))
280 Franz 309
        {
310
                qApp->setOverrideCursor(QCursor(loadIcon("tab.png"), 3), true);
311
                if (haveInd)
312
                {
820 cbradney 313
                        fpo = QRect(static_cast<int>(firstLine+leftIndent-offset)-4, 0, 8, 12);
280 Franz 314
                        if (fpo.contains(m->pos()))
315
                        {
316
                                qApp->setOverrideCursor(QCursor(SizeHorCursor), true);
317
                                return;
318
                        }
820 cbradney 319
                        fpo = QRect(static_cast<int>(leftIndent-offset)-4, 12, 8, 12);
280 Franz 320
                        if (fpo.contains(m->pos()))
321
                        {
322
                                qApp->setOverrideCursor(QCursor(SizeHorCursor), true);
323
                                return;
324
                        }
325
                }
820 cbradney 326
                if (tabValues.count() != 0)
280 Franz 327
                {
2282 fschmid 328
                        for (int yg = 0; yg < static_cast<int>(tabValues.count()); yg++)
280 Franz 329
                        {
2282 fschmid 330
                                fpo = QRect(static_cast<int>(tabValues[yg].tabPosition-offset)-3, 15, 8, 8);
280 Franz 331
                                if (fpo.contains(m->pos()))
332
                                {
333
                                        qApp->setOverrideCursor(QCursor(SizeHorCursor), true);
334
                                        return;
335
                                }
336
                        }
337
                }
338
        }
339
}
340
 
341
void RulerT::leaveEvent(QEvent*)
342
{
820 cbradney 343
        if ((mousePressed) && (rulerCode == 3))
280 Franz 344
        {
345
                qApp->setOverrideCursor(QCursor(loadIcon("DelPoint.png"), 4, 3), true);
346
                return;
347
        }
348
        else
349
                qApp->setOverrideCursor(QCursor(ArrowCursor), true);
350
}
351
 
820 cbradney 352
void RulerT::updateTabList()
280 Franz 353
{
2282 fschmid 354
        struct PageItem::TabRecord tb;
355
        tb.tabPosition = tabValues[actTab].tabPosition;
356
        tb.tabType = tabValues[actTab].tabType;
357
        tb.tabFillChar =  tabValues[actTab].tabFillChar;
358
        QValueList<PageItem::TabRecord>::Iterator it;
820 cbradney 359
        int gg = static_cast<int>(tabValues.count()-1);
280 Franz 360
        int g = gg;
820 cbradney 361
        it = tabValues.at(actTab);
362
        tabValues.remove(it);
2282 fschmid 363
        for (int yg = static_cast<int>(tabValues.count()); yg > -1; yg--)
280 Franz 364
        {
2282 fschmid 365
                if (tb.tabPosition < tabValues[yg].tabPosition)
280 Franz 366
                        g = yg;
367
        }
2282 fschmid 368
        actTab = g;
280 Franz 369
        if (gg == g)
370
        {
2282 fschmid 371
                tabValues.append(tb);
372
                actTab = static_cast<int>(tabValues.count()-1);
280 Franz 373
        }
374
        else
375
        {
820 cbradney 376
                it = tabValues.at(actTab);
2282 fschmid 377
                tabValues.insert(it, tb);
280 Franz 378
        }
379
}
380
 
381
void RulerT::increaseOffset()
382
{
820 cbradney 383
        offset += 5;
384
        if (offset + width() > static_cast<int>(Width))
385
                offset -= 5;
280 Franz 386
        repaint();
387
}
388
 
389
void RulerT::decreaseOffset()
390
{
820 cbradney 391
        offset -= 5;
392
        if (offset < 0)
393
                offset = 0;
280 Franz 394
        repaint();
395
}
396
 
397
void RulerT::changeTab(int t)
398
{
2282 fschmid 399
        tabValues[actTab].tabType = t;
280 Franz 400
        repaint();
401
}
402
 
2282 fschmid 403
void RulerT::changeTabChar(QChar t)
404
{
405
        tabValues[actTab].tabFillChar = t;
406
        repaint();
407
}
408
 
280 Franz 409
void RulerT::moveTab(double t)
410
{
2282 fschmid 411
        tabValues[actTab].tabPosition = t;
820 cbradney 412
        updateTabList();
280 Franz 413
        repaint();
414
}
415
 
820 cbradney 416
void RulerT::moveFirstLine(double t)
280 Franz 417
{
820 cbradney 418
        firstLine = t;
419
        if (firstLine+leftIndent+offset < offset)
280 Franz 420
        {
820 cbradney 421
                firstLine = 0-leftIndent;
422
                emit firstLineMoved(firstLine);
280 Franz 423
        }
820 cbradney 424
        if (firstLine+leftIndent > Width)
280 Franz 425
        {
820 cbradney 426
                firstLine = Width-leftIndent;
427
                emit firstLineMoved(firstLine);
280 Franz 428
        }
429
        repaint();
430
}
431
 
820 cbradney 432
void RulerT::moveLeftIndent(double t)
280 Franz 433
{
820 cbradney 434
        double oldInd = leftIndent+firstLine;
435
        leftIndent = t;
436
        if (leftIndent > Width-1)
280 Franz 437
        {
820 cbradney 438
                leftIndent  = Width-1;
439
                emit leftIndentMoved(leftIndent);
280 Franz 440
        }
820 cbradney 441
        firstLine = oldInd - leftIndent;
442
        emit firstLineMoved(firstLine);
280 Franz 443
        repaint();
444
}
445
 
2282 fschmid 446
Tabruler::Tabruler( QWidget* parent, bool haveFirst, int dEin, QValueList<PageItem::TabRecord> Tabs, double wid ) : QWidget( parent )
280 Franz 447
{
1843 cbradney 448
        docUnitRatio=unitGetRatioFromIndex(dEin);
280 Franz 449
        double ww;
820 cbradney 450
        ww = (wid < 0) ? 4000 : wid;
280 Franz 451
        setName( "tabruler" );
452
        tabrulerLayout = new QVBoxLayout( this, 0, 6, "tabrulerLayout");
453
        layout2 = new QHBoxLayout( 0, 0, 6, "layout2");
820 cbradney 454
        TypeCombo = new QComboBox( false, this, "TypeCombo" );
280 Franz 455
        TypeCombo->clear();
456
        TypeCombo->insertItem( tr( "Left" ) );
457
        TypeCombo->insertItem( tr( "Right" ) );
458
        TypeCombo->insertItem( tr( "Full Stop" ) );
459
        TypeCombo->insertItem( tr( "Comma" ) );
460
        TypeCombo->insertItem( tr( "Center" ) );
461
        layout2->addWidget( TypeCombo );
820 cbradney 462
        rulerScrollL = new QToolButton( LeftArrow, this, "rulerScrollL" );
463
        rulerScrollL->setAutoRepeat( true );
464
        layout2->addWidget( rulerScrollL );
465
        ruler = new RulerT( this, dEin, Tabs, haveFirst, wid );
466
        ruler->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)5, 0, 0, ruler->sizePolicy().hasHeightForWidth() ) );
467
        layout2->addWidget( ruler );
468
        rulerScrollR = new QToolButton( RightArrow, this, "RulserScrollR" );
469
        rulerScrollR->setAutoRepeat( true );
470
        layout2->addWidget( rulerScrollR );
280 Franz 471
        tabrulerLayout->addLayout( layout2 );
2282 fschmid 472
        layout1 = new QHBoxLayout( 0, 0, 6, "layout1" );
473
        layout1->setAlignment( Qt::AlignTop );
820 cbradney 474
        tabData = new MSpinBox( 0, ww, this, 1 );
475
        tabData->setValue(0);
476
        positionLabel = new QLabel( tabData, tr("&Position:"), this, "positionLabel" );
477
        layout1->addWidget( positionLabel );
478
        layout1->addWidget( tabData );
2282 fschmid 479
        tabFillCombo = new QComboBox( true, this, "tabFillCombo" );
480
        tabFillCombo->setEditable(false);
481
        tabFillCombo->insertItem( tr("None"));
482
        tabFillCombo->insertItem( "Dot");
2292 cbradney 483
        tabFillCombo->insertItem( "Hyphen");
2282 fschmid 484
        tabFillCombo->insertItem( "Underscore");
485
        tabFillCombo->insertItem( "Custom");
486
        tabFillComboT = new QLabel(tabFillCombo, tr( "Fill Char:" ), this, "tabFillComboT" );
487
        layout1->addWidget( tabFillComboT );
488
        layout1->addWidget( tabFillCombo );
280 Franz 489
        if (haveFirst)
490
        {
820 cbradney 491
                firstLineData = new MSpinBox( -3000, ww, this, 1);
492
                firstLineData->setValue(0);
2370 fschmid 493
                firstLineLabel = new QLabel( "", this, "firstLineLabel" );
494
                firstLineLabel->setText("");
495
                firstLineLabel->setPixmap(loadIcon("firstline.png"));
820 cbradney 496
                layout1->addWidget( firstLineLabel );
497
                layout1->addWidget( firstLineData );
498
                leftIndentData = new MSpinBox( 0, ww, this, 1 );
499
                leftIndentData->setValue(0);
2370 fschmid 500
                leftIndentLabel = new QLabel( "", this, "leftIndentLabel" );
501
                leftIndentLabel->setText("");
502
                leftIndentLabel->setPixmap(loadIcon("leftindent.png"));
820 cbradney 503
                layout1->addWidget( leftIndentLabel );
504
                layout1->addWidget( leftIndentData );
280 Franz 505
        }
820 cbradney 506
        clearButton = new QPushButton( this, "clearButton" );
507
        clearButton->setText( tr( "Delete All" ) );
508
        layout1->addWidget( clearButton );
280 Franz 509
        if (!haveFirst)
510
        {
511
                QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
512
                layout1->addItem( spacer );
513
        }
514
        tabrulerLayout->addLayout( layout1 );
2282 fschmid 515
        TypeCombo->setEnabled(false);
516
        tabData->setEnabled(false);
517
        tabFillCombo->setEnabled(false);
280 Franz 518
        if (Tabs.count() == 0)
820 cbradney 519
                clearButton->setEnabled(false);
280 Franz 520
        resize( minimumSizeHint() );
820 cbradney 521
        connect(rulerScrollL, SIGNAL(clicked()), ruler, SLOT(decreaseOffset()));
522
        connect(rulerScrollR, SIGNAL(clicked()), ruler, SLOT(increaseOffset()));
822 cbradney 523
        connect(ruler, SIGNAL(typeChanged(int)) , this, SLOT(setTabType(int)));
2282 fschmid 524
        connect(ruler, SIGNAL(fillCharChanged(QChar)) , this, SLOT(setTabFillChar(QChar)));
280 Franz 525
        connect(TypeCombo, SIGNAL(activated(int)), this, SLOT(setType()));
2282 fschmid 526
        connect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
527
        connect(tabFillCombo, SIGNAL(textChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
822 cbradney 528
        connect(ruler, SIGNAL(tabMoved(double)) , this, SLOT(setTabData(double)));
2282 fschmid 529
        connect(ruler, SIGNAL(tabSelected()), this, SLOT(tabAdded()));
822 cbradney 530
        connect(ruler, SIGNAL(newTab()), this, SLOT(tabAdded()));
531
        connect(ruler, SIGNAL(noTabs()), this, SLOT(lastTabRemoved()));
820 cbradney 532
        connect(tabData, SIGNAL(valueChanged(int)), this, SLOT(setTab()));
533
        connect(clearButton, SIGNAL(clicked()), this, SLOT(clearAll()));
280 Franz 534
        if (haveFirst)
535
        {
822 cbradney 536
                connect(ruler, SIGNAL(firstLineMoved(double)) , this, SLOT(setFirstLineData(double)));
537
                connect(ruler, SIGNAL(leftIndentMoved(double)) , this, SLOT(setLeftIndentData(double)));
2254 fschmid 538
                connect(ruler, SIGNAL(mouseReleased()), this, SIGNAL(tabrulerChanged()));
822 cbradney 539
                connect(firstLineData, SIGNAL(valueChanged(int)), this, SLOT(setFirstLine()));
540
                connect(leftIndentData, SIGNAL(valueChanged(int)), this, SLOT(setLeftIndent()));
820 cbradney 541
                QToolTip::add( firstLineData, tr( "Indentation for first line of the paragraph" ) );
542
                QToolTip::add( leftIndentData, tr( "Indentation from the left for the whole paragraph" ) );
280 Franz 543
        }
820 cbradney 544
        QToolTip::add( clearButton, tr( "Delete all Tabulators" ) );
545
        QString ein = unitGetSuffixFromIndex(dEin);
280 Franz 546
        if (dEin == 2)
547
        {
548
                if (haveFirst)
549
                {
820 cbradney 550
                        firstLineData->setDecimals(10000);
551
                        leftIndentData->setDecimals(10000);
280 Franz 552
                }
820 cbradney 553
                tabData->setDecimals(10000);
280 Franz 554
        }
555
        if (haveFirst)
556
        {
820 cbradney 557
                firstLineData->setSuffix(ein);
558
                leftIndentData->setSuffix(ein);
280 Franz 559
        }
820 cbradney 560
        tabData->setSuffix(ein);
280 Franz 561
        haveF = haveFirst;
562
}
563
 
564
void Tabruler::clearAll()
565
{
820 cbradney 566
        ruler->tabValues.clear();
567
        ruler->repaint();
280 Franz 568
        lastTabRemoved();
1879 subik 569
        emit tabrulerChanged();
280 Franz 570
}
571
 
572
void Tabruler::tabAdded()
573
{
574
        TypeCombo->setEnabled(true);
820 cbradney 575
        tabData->setEnabled(true);
576
        clearButton->setEnabled(true);
2282 fschmid 577
        tabFillCombo->setEnabled(true);
1879 subik 578
        emit tabrulerChanged();
280 Franz 579
}
580
 
581
void Tabruler::lastTabRemoved()
582
{
583
        TypeCombo->setEnabled(false);
820 cbradney 584
        tabData->setEnabled(false);
585
        clearButton->setEnabled(false);
2282 fschmid 586
        tabFillCombo->setEnabled(false);
1879 subik 587
        emit tabrulerChanged();
280 Franz 588
}
589
 
2282 fschmid 590
void Tabruler::setFillChar()
591
{
592
        disconnect(tabFillCombo, SIGNAL(textChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
593
        disconnect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
594
        QChar ret;
595
        switch (tabFillCombo->currentItem())
596
        {
597
                case 0:
598
                        tabFillCombo->setEditable(false);
599
                        ret = QChar();
600
                        break;
601
                case 1:
602
                        tabFillCombo->setEditable(false);
603
                        ret = '.';
604
                        break;
605
                case 2:
606
                        tabFillCombo->setEditable(false);
607
                        ret = '-';
608
                        break;
609
                case 3:
610
                        tabFillCombo->setEditable(false);
611
                        ret = '_';
612
                        break;
613
                case 4:
614
                        tabFillCombo->setEditable(true);
615
                        tabFillCombo->setEditText( tr("Custom:"));
616
                        break;
617
        }
618
        if (tabFillCombo->currentItem() != 4)
619
                ruler->changeTabChar(ret);
620
        connect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
621
        connect(tabFillCombo, SIGNAL(textChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
622
}
623
 
624
void Tabruler::setCustomFillChar(const QString &txt)
625
{
626
        if (txt == tr("Custom:"))
627
                return;
628
        disconnect(tabFillCombo, SIGNAL(textChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
629
        disconnect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
630
        QChar ret = txt[txt.length()-1];
631
        ruler->changeTabChar(ret);
632
        connect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
633
        connect(tabFillCombo, SIGNAL(textChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
634
}
635
 
636
void Tabruler::setTabFillChar(QChar t)
637
{
638
        if (t.isNull())
639
        {
640
                tabFillCombo->setEditable(false);
641
                tabFillCombo->setCurrentItem(0);
642
        }
643
        else if (t == ".")
644
        {
645
                tabFillCombo->setEditable(false);
646
                tabFillCombo->setCurrentItem(1);
647
        }
648
        else if (t == "-")
649
        {
650
                tabFillCombo->setEditable(false);
651
                tabFillCombo->setCurrentItem(2);
652
        }
653
        else if (t == "_")
654
        {
655
                tabFillCombo->setEditable(false);
656
                tabFillCombo->setCurrentItem(3);
657
        }
658
        else
659
        {
660
                tabFillCombo->setCurrentItem(4);
661
                tabFillCombo->setEditable(true);
662
                tabFillCombo->setEditText( tr("Custom: ")+QString(t));
663
        }
664
        emit tabrulerChanged();
665
}
666
 
280 Franz 667
void Tabruler::setTabType(int t)
668
{
669
        TypeCombo->setCurrentItem(t);
1879 subik 670
        emit tabrulerChanged();
280 Franz 671
}
672
 
673
void Tabruler::setType()
674
{
675
        disconnect(TypeCombo, SIGNAL(activated(int)), this, SLOT(setType()));
820 cbradney 676
        ruler->changeTab(TypeCombo->currentItem());
280 Franz 677
        connect(TypeCombo, SIGNAL(activated(int)), this, SLOT(setType()));
1879 subik 678
        emit tabrulerChanged();
280 Franz 679
}
680
 
820 cbradney 681
void Tabruler::setTabData(double t)
280 Franz 682
{
820 cbradney 683
        disconnect(tabData, SIGNAL(valueChanged(int)), this, SLOT(setTab()));
1843 cbradney 684
        tabData->setValue(t * docUnitRatio);
820 cbradney 685
        connect(tabData, SIGNAL(valueChanged(int)), this, SLOT(setTab()));
2254 fschmid 686
        if (!ruler->mousePressed)
687
                emit tabrulerChanged();
280 Franz 688
}
689
 
690
void Tabruler::setTab()
691
{
1843 cbradney 692
        ruler->moveTab(tabData->value() / docUnitRatio);
1879 subik 693
        emit tabrulerChanged();
280 Franz 694
}
695
 
820 cbradney 696
void Tabruler::setFirstLineData(double t)
280 Franz 697
{
822 cbradney 698
        disconnect(firstLineData, SIGNAL(valueChanged(int)), this, SLOT(setFirstLine()));
1843 cbradney 699
        firstLineData->setValue(t * docUnitRatio);
822 cbradney 700
        connect(firstLineData, SIGNAL(valueChanged(int)), this, SLOT(setFirstLine()));
2254 fschmid 701
        if (!ruler->mousePressed)
702
                emit tabrulerChanged();
280 Franz 703
}
704
 
820 cbradney 705
void Tabruler::setFirstLine()
280 Franz 706
{
1843 cbradney 707
        ruler->moveFirstLine(firstLineData->value() / docUnitRatio);
1879 subik 708
        emit tabrulerChanged();
280 Franz 709
}
710
 
820 cbradney 711
void Tabruler::setLeftIndentData(double t)
280 Franz 712
{
822 cbradney 713
        disconnect(leftIndentData, SIGNAL(valueChanged(int)), this, SLOT(setLeftIndent()));
1843 cbradney 714
        leftIndentData->setValue(t * docUnitRatio);
822 cbradney 715
        connect(leftIndentData, SIGNAL(valueChanged(int)), this, SLOT(setLeftIndent()));
2254 fschmid 716
        if (!ruler->mousePressed)
717
                emit tabrulerChanged();
280 Franz 718
}
719
 
820 cbradney 720
void Tabruler::setLeftIndent()
280 Franz 721
{
1843 cbradney 722
        ruler->moveLeftIndent(leftIndentData->value() / docUnitRatio);
1879 subik 723
        emit tabrulerChanged();
280 Franz 724
}
725
 
2282 fschmid 726
QValueList<PageItem::TabRecord> Tabruler::getTabVals()
280 Franz 727
{
820 cbradney 728
        return ruler->tabValues;
280 Franz 729
}
730
 
820 cbradney 731
double Tabruler::getFirstLine()
280 Franz 732
{
1843 cbradney 733
        return firstLineData->value() / docUnitRatio;
280 Franz 734
}
735
 
820 cbradney 736
double Tabruler::getLeftIndent()
280 Franz 737
{
1843 cbradney 738
        return leftIndentData->value() / docUnitRatio;
280 Franz 739
}