1 /*
2 For general Scribus (>=1.3.2) copyright and licensing information please refer
3 to the COPYING file provided with the program. Following this notice may exist
4 a copyright and/or license notice that predates the release of Scribus 1.3.2
5 for which a new license (GPL+exception) is in place.
6 */
7 #include "tabruler.h"
8
9 #include <QApplication>
10 #include <QColor>
11 #include <QComboBox>
12 #include <QCursor>
13 #include <QEvent>
14 #include <QLabel>
15 #include <QLayout>
16 #include <QMouseEvent>
17 #include <QPaintEvent>
18 #include <QPainter>
19 #include <QPalette>
20 #include <QPixmap>
21 #include <QPolygon>
22 #include <QPushButton>
23 #include <QToolButton>
24 #include <QToolTip>
25 #include <QVariant>
26
27 #include "commonstrings.h"
28 #include "iconmanager.h"
29 #include "scribusapp.h"
30 #include "scribusstructs.h"
31 #include "scrspinbox.h"
32 #include "units.h"
33 #include "util.h"
34
RulerT(QWidget * pa,int unit,const QList<ParagraphStyle::TabRecord> & tabs,bool ind,double wid)35 RulerT::RulerT(QWidget *pa, int unit, const QList<ParagraphStyle::TabRecord>& tabs, bool ind, double wid) : QWidget(pa),
36 tabValues(tabs),
37 haveInd(ind),
38 unitIndex(unit)
39 {
40 QPalette palette;
41 palette.setColor(backgroundRole(), QColor(255,255,255));
42 setPalette(palette);
43 m_iter = unitRulerGetIter1FromIndex(unitIndex);
44 m_iter2 = unitRulerGetIter2FromIndex(unitIndex);
45
46 setMouseTracking(true);
47 if (wid < 0)
48 {
49 setMinimumSize(QSize(400,25));
50 setMaximumSize(QSize(4000,25));
51 m_rulerWidth = 4000;
52 resize(400, 25);
53 }
54 else
55 {
56 m_rulerWidth = wid;
57 setMinimumSize(QSize(qMin(static_cast<int>(m_rulerWidth), 400), 25));
58 setMaximumSize(QSize(4000, 25));
59 resize(qMin(static_cast<int>(wid), 400), 25);
60 }
61 }
62
setTabs(const QList<ParagraphStyle::TabRecord> & tabs,int unit)63 void RulerT::setTabs(const QList<ParagraphStyle::TabRecord>& tabs, int unit)
64 {
65 unitIndex = unit;
66 m_iter = unitRulerGetIter1FromIndex(unitIndex);
67 m_iter2 = unitRulerGetIter2FromIndex(unitIndex);
68 tabValues = tabs;
69 actTab = -1;
70 repaint();
71 }
72
paintEvent(QPaintEvent *)73 void RulerT::paintEvent(QPaintEvent *)
74 {
75 double xl;
76
77 const QPalette& palette = this->palette();
78 const QColor& textColor = palette.color(QPalette::Text);
79
80 QPainter p;
81 p.begin(this);
82 p.drawLine(0, 24, width(), 24);
83 p.translate(-offset, 0);
84 p.setBrush(textColor);
85 p.setFont(font());
86 p.setPen(QPen(textColor, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
87 for (xl = 0; xl < width() + offset; xl += m_iter)
88 {
89 if (xl < offset)
90 continue;
91 p.drawLine(qRound(xl), 18, qRound(xl), 24);
92 }
93
94 for (xl = 0; xl < width() + (m_iter2 / 2) + offset; xl += m_iter2)
95 {
96 if (xl < offset)
97 continue;
98 p.drawLine(qRound(xl), 11, qRound(xl), 24);
99 switch (unitIndex)
100 {
101 case 2:
102 {
103 QString tx;
104 int num1 = static_cast<int>(xl / m_iter2);
105 if (num1 != 0)
106 tx = QString::number(num1);
107 double frac = (xl / m_iter2) - num1;
108 if ((frac > 0.24) && (frac < 0.26))
109 tx += QChar(0xBC);
110 if ((frac > 0.49) && (frac < 0.51))
111 tx += QChar(0xBD);
112 if ((frac > 0.74) && (frac < 0.76))
113 tx += QChar(0xBE);
114 p.drawText(qRound(xl + 2), 17, tx);
115 break;
116 }
117 case 3:
118 p.drawText(qRound(xl + 2), 17, QString::number(xl / m_iter));
119 break;
120 default:
121 p.drawText(qRound(xl + 2), 17, QString::number(xl / m_iter * 10));
122 break;
123 }
124 }
125
126 for (int i = 0; i < tabValues.count(); i++)
127 {
128 if (i == actTab)
129 p.setPen(QPen(Qt::red, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
130 else
131 p.setPen(QPen(textColor, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
132 switch (static_cast<int>(tabValues[i].tabType))
133 {
134 case 0:
135 p.drawLine(qRound(tabValues[i].tabPosition), 15, qRound(tabValues[i].tabPosition), 23);
136 p.drawLine(qRound(tabValues[i].tabPosition), 23, qRound(tabValues[i].tabPosition + 8), 23);
137 break;
138 case 1:
139 p.drawLine(qRound(tabValues[i].tabPosition), 15, qRound(tabValues[i].tabPosition), 23);
140 p.drawLine(qRound(tabValues[i].tabPosition), 23, qRound(tabValues[i].tabPosition - 8), 23);
141 break;
142 case 2:
143 case 3:
144 p.drawLine(qRound(tabValues[i].tabPosition), 15, qRound(tabValues[i].tabPosition), 23);
145 p.drawLine(qRound(tabValues[i].tabPosition - 4), 23, qRound(tabValues[i].tabPosition + 4), 23);
146 p.drawLine(qRound(tabValues[i].tabPosition + 3), 20, qRound(tabValues[i].tabPosition + 2), 20);
147 break;
148 case 4:
149 p.drawLine(qRound(tabValues[i].tabPosition), 15, qRound(tabValues[i].tabPosition), 23);
150 p.drawLine(qRound(tabValues[i].tabPosition - 4), 23, qRound(tabValues[i].tabPosition + 4), 23);
151 break;
152 default:
153 break;
154 }
155 }
156
157 if (haveInd)
158 {
159 p.setPen(QPen(Qt::blue, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
160 p.setBrush(Qt::blue);
161 QPolygon cr;
162 cr.setPoints(3, qRound(firstLine + leftIndent), 12, qRound(firstLine + leftIndent - 4), 0, qRound(firstLine + leftIndent + 4), 0);
163 p.drawPolygon(cr);
164 QPolygon cr2;
165 cr2.setPoints(3, qRound(leftIndent), 12, qRound(leftIndent + 4), 24, qRound(leftIndent - 4), 24);
166 p.drawPolygon(cr2);
167 }
168 p.end();
169 }
170
mousePressEvent(QMouseEvent * m)171 void RulerT::mousePressEvent(QMouseEvent *m)
172 {
173 QRect fpo;
174 mousePressed = true;
175 qApp->setOverrideCursor(QCursor(Qt::ArrowCursor));
176 rulerCode = 0;
177 if (haveInd)
178 {
179 fpo = QRect(static_cast<int>(firstLine + leftIndent - offset) - 4, 0, 8, 12);
180 if (fpo.contains(m->pos()))
181 {
182 rulerCode = 1;
183 mouseX = m->x();
184 return;
185 }
186 fpo = QRect(static_cast<int>(leftIndent - offset) - 4, 12, 8, 12);
187 if (fpo.contains(m->pos()))
188 {
189 rulerCode = 2;
190 mouseX = m->x();
191 return;
192 }
193 }
194 if (tabValues.count() != 0)
195 {
196 for (int i = 0; i < tabValues.count(); ++i)
197 {
198 fpo = QRect(static_cast<int>(tabValues[i].tabPosition - offset) - 3, 15, 8, 8);
199 if (fpo.contains(m->pos()))
200 {
201 rulerCode = 3;
202 actTab = i;
203 mouseX = m->x();
204 emit tabSelected();
205 emit typeChanged(tabValues[actTab].tabType);
206 emit tabMoved(tabValues[actTab].tabPosition);
207 emit fillCharChanged(tabValues[actTab].tabFillChar);
208 repaint();
209 return;
210 }
211 }
212 }
213 if ((rulerCode == 0) && (m->button() == Qt::LeftButton))
214 {
215 ParagraphStyle::TabRecord tb;
216 tb.tabPosition = static_cast<double>(m->x() + offset);
217 tb.tabType = 0;
218 tb.tabFillChar = QChar();
219 tabValues.prepend(tb);
220 actTab = 0;
221 rulerCode = 3;
222 updateTabList();
223 repaint();
224 emit newTab();
225 emit typeChanged(tabValues[actTab].tabType);
226 emit tabMoved(tabValues[actTab].tabPosition);
227 emit fillCharChanged(tabValues[actTab].tabFillChar);
228 qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
229 }
230 mouseX = m->x();
231 }
232
mouseReleaseEvent(QMouseEvent * m)233 void RulerT::mouseReleaseEvent(QMouseEvent *m)
234 {
235 mousePressed = false;
236 qApp->restoreOverrideCursor();
237 if ((m->y() < height()) && (m->y() > 0))
238 {
239 if (rulerCode == 3)
240 {
241 if (m->button() == Qt::RightButton)
242 {
243 tabValues[actTab].tabType += 1;
244 if (tabValues[actTab].tabType > 4)
245 tabValues[actTab].tabType = 0;
246 emit typeChanged(tabValues[actTab].tabType);
247 repaint();
248 }
249 }
250 }
251 else
252 {
253 if (rulerCode == 3)
254 {
255 tabValues.removeAt(actTab);
256 actTab = 0;
257 if (tabValues.count() != 0)
258 {
259 emit typeChanged(tabValues[actTab].tabType);
260 emit tabMoved(tabValues[actTab].tabPosition);
261 emit fillCharChanged(tabValues[actTab].tabFillChar);
262 }
263 else
264 emit noTabs();
265 repaint();
266 }
267 }
268 rulerCode = 0;
269 emit mouseReleased();
270 }
271
mouseMoveEvent(QMouseEvent * m)272 void RulerT::mouseMoveEvent(QMouseEvent *m)
273 {
274 double oldInd;
275 QRect fpo;
276 if ((mousePressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > 0) && (m->x() < width()))
277 {
278 qApp->changeOverrideCursor(QCursor(Qt::SizeHorCursor));
279 switch (rulerCode)
280 {
281 case 1:
282 firstLine -= mouseX - m->x();
283 if (firstLine + leftIndent + offset < offset)
284 firstLine += mouseX - m->x();
285 if (firstLine + leftIndent > m_rulerWidth)
286 firstLine = m_rulerWidth - leftIndent;
287 emit firstLineMoved(firstLine);
288 repaint();
289 break;
290 case 2:
291 oldInd = leftIndent+firstLine;
292 leftIndent -= mouseX - m->x();
293 if (leftIndent < 0)
294 leftIndent = 0;
295 if (leftIndent > m_rulerWidth - 1)
296 leftIndent = m_rulerWidth - 1;
297 firstLine = oldInd - leftIndent;
298 emit leftIndentMoved(leftIndent);
299 emit firstLineMoved(firstLine);
300 repaint();
301 break;
302 case 3:
303 tabValues[actTab].tabPosition -= mouseX - m->x();
304 if (tabValues[actTab].tabPosition < 0)
305 tabValues[actTab].tabPosition = 0;
306 if (tabValues[actTab].tabPosition > m_rulerWidth - 1)
307 tabValues[actTab].tabPosition = m_rulerWidth - 1;
308 updateTabList();
309 emit tabMoved(tabValues[actTab].tabPosition);
310 repaint();
311 break;
312 default:
313 break;
314 }
315 mouseX = m->x();
316 return;
317 }
318 if ((!mousePressed) && (m->y() < height()) && (m->y() > 0) && (m->x() > 0) && (m->x() < width()))
319 {
320 setCursor(IconManager::instance().loadCursor("tab.png", 3));
321 if (haveInd)
322 {
323 fpo = QRect(static_cast<int>(firstLine + leftIndent - offset) - 4, 0, 8, 12);
324 if (fpo.contains(m->pos()))
325 {
326 setCursor(QCursor(Qt::SizeHorCursor));
327 return;
328 }
329 fpo = QRect(static_cast<int>(leftIndent - offset) - 4, 12, 8, 12);
330 if (fpo.contains(m->pos()))
331 {
332 setCursor(QCursor(Qt::SizeHorCursor));
333 return;
334 }
335 }
336 if (tabValues.count() != 0)
337 {
338 for (int i = 0; i < static_cast<int>(tabValues.count()); ++i)
339 {
340 fpo = QRect(static_cast<int>(tabValues[i].tabPosition-offset) - 3, 15, 8, 8);
341 if (fpo.contains(m->pos()))
342 {
343 setCursor(QCursor(Qt::SizeHorCursor));
344 return;
345 }
346 }
347 }
348 }
349 if ((mousePressed) && ((m->y() > height()) || (m->y() < 0) || (m->x() < 0) || (m->x() > width())))
350 {
351 qApp->changeOverrideCursor(IconManager::instance().loadCursor("DelPoint.png", 1, 1));
352 }
353 }
354
leaveEvent(QEvent *)355 void RulerT::leaveEvent(QEvent*)
356 {
357 if (mousePressed)
358 {
359 if (rulerCode == 3)
360 qApp->changeOverrideCursor(IconManager::instance().loadCursor("DelPoint.png", 1, 1));
361 else
362 qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
363 }
364 }
365
updateTabList()366 void RulerT::updateTabList()
367 {
368 ParagraphStyle::TabRecord tb;
369 tb.tabPosition = tabValues[actTab].tabPosition;
370 tb.tabType = tabValues[actTab].tabType;
371 tb.tabFillChar = tabValues[actTab].tabFillChar;
372 int gg = static_cast<int>(tabValues.count()-1);
373 int g = gg;
374 tabValues.removeAt(actTab);
375 for (int i = tabValues.count() - 1; i > -1; --i)
376 {
377 if (tb.tabPosition < tabValues[i].tabPosition)
378 g = i;
379 }
380 actTab = g;
381 if (gg == g)
382 {
383 tabValues.append(tb);
384 actTab = static_cast<int>(tabValues.count()-1);
385 }
386 else
387 {
388 tabValues.insert(actTab, tb);
389 }
390 }
391
resetOffsetInc()392 void RulerT::resetOffsetInc()
393 {
394 offsetIncrement = 5;
395 }
396
increaseOffset()397 void RulerT::increaseOffset()
398 {
399 offset += offsetIncrement;
400 offsetIncrement++;
401 if (offsetIncrement > 30)
402 offsetIncrement = 30;
403 if (offset + width() > static_cast<int>(m_rulerWidth))
404 offset -= 5;
405 repaint();
406 }
407
decreaseOffset()408 void RulerT::decreaseOffset()
409 {
410 offset -= offsetIncrement;
411 offsetIncrement++;
412 if (offsetIncrement > 30)
413 offsetIncrement = 30;
414 if (offset < 0)
415 offset = 0;
416 repaint();
417 }
418
changeTab(int t)419 void RulerT::changeTab(int t)
420 {
421 if (actTab < 0 || actTab >= tabValues.count())
422 return;
423 tabValues[actTab].tabType = t;
424 repaint();
425 }
426
changeTabChar(QChar t)427 void RulerT::changeTabChar(QChar t)
428 {
429 if (actTab < 0 || actTab >= tabValues.count())
430 return;
431 tabValues[actTab].tabFillChar = t;
432 repaint();
433 }
434
moveTab(double t)435 void RulerT::moveTab(double t)
436 {
437 if (actTab < 0 || actTab >= tabValues.count())
438 return;
439 tabValues[actTab].tabPosition = t;
440 updateTabList();
441 repaint();
442 }
443
removeActTab()444 void RulerT::removeActTab()
445 {
446 if (actTab > -1)
447 {
448 tabValues.removeAt(actTab);
449 actTab = 0;
450 if (tabValues.count() != 0)
451 {
452 emit typeChanged(tabValues[actTab].tabType);
453 emit tabMoved(tabValues[actTab].tabPosition);
454 emit fillCharChanged(tabValues[actTab].tabFillChar);
455 }
456 else
457 emit noTabs();
458 }
459 repaint();
460 }
461
moveFirstLine(double t)462 void RulerT::moveFirstLine(double t)
463 {
464 firstLine = t;
465 if (firstLine+leftIndent+offset < offset)
466 {
467 firstLine = 0-leftIndent;
468 emit firstLineMoved(firstLine);
469 }
470 if (firstLine+leftIndent > m_rulerWidth)
471 {
472 firstLine = m_rulerWidth - leftIndent;
473 emit firstLineMoved(firstLine);
474 }
475 repaint();
476 }
477
moveLeftIndent(double t)478 void RulerT::moveLeftIndent(double t)
479 {
480 double oldInd = leftIndent + firstLine;
481 leftIndent = t;
482 if (leftIndent > m_rulerWidth - 1)
483 {
484 leftIndent = m_rulerWidth - 1;
485 emit leftIndentMoved(leftIndent);
486 }
487 firstLine = oldInd - leftIndent;
488 emit firstLineMoved(firstLine);
489 repaint();
490 }
491
Tabruler(QWidget * parent,bool haveFirst,int unit,const QList<ParagraphStyle::TabRecord> & tabs,double wid)492 Tabruler::Tabruler( QWidget* parent, bool haveFirst, int unit, const QList<ParagraphStyle::TabRecord>& tabs, double wid ): QWidget( parent )
493 {
494 m_docUnitRatio = unitGetRatioFromIndex(unit);
495 double ww = (wid < 0) ? 4000 : wid;
496 tabrulerLayout = new QVBoxLayout( this );
497 tabrulerLayout->setContentsMargins(0, 0, 0, 0);
498 tabrulerLayout->setSpacing(6);
499 layout2 = new QHBoxLayout;
500 layout2->setContentsMargins(0, 0, 0, 0);
501 layout2->setSpacing(6);
502
503 rulerScrollL = new QToolButton(this);
504 rulerScrollL->setArrowType(Qt::LeftArrow);
505 rulerScrollL->setAutoRepeat( true );
506 layout2->addWidget( rulerScrollL );
507 ruler = new RulerT( this, unit, tabs, haveFirst, wid );
508 ruler->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
509 layout2->addWidget( ruler );
510 rulerScrollR = new QToolButton(this);
511 rulerScrollR->setArrowType(Qt::RightArrow);
512 rulerScrollR->setAutoRepeat( true );
513 layout2->addWidget( rulerScrollR );
514
515 layout1 = new QHBoxLayout;
516 layout1->setContentsMargins(0, 0, 0, 0);
517 layout1->setSpacing(6);
518 layout1->setAlignment( Qt::AlignTop );
519 typeCombo = new QComboBox(this);
520 typeCombo->setEditable(false);
521 typeCombo->clear();
522 typeCombo->addItem( tr( "Left" ) );
523 typeCombo->addItem( tr( "Right" ) );
524 typeCombo->addItem( tr( "Period" ) );
525 typeCombo->addItem( tr( "Comma" ) );
526 typeCombo->addItem( tr( "Center" ) );
527 layout1->addWidget( typeCombo );
528 tabData = new ScrSpinBox( 0, ww / m_docUnitRatio, this, unit );
529 tabData->setValue(0);
530 positionLabel = new QLabel( tr("&Position:"), this );
531 positionLabel->setBuddy(tabData);
532 layout1->addWidget( positionLabel );
533 layout1->addWidget( tabData );
534 tabFillCombo = new QComboBox(this);
535 tabFillCombo->setEditable(false);
536 tabFillCombo->addItem( tr("None", "tab fill"));
537 tabFillCombo->addItem( tr("Dot"));
538 tabFillCombo->addItem( tr("Hyphen"));
539 tabFillCombo->addItem( tr("Underscore"));
540 tabFillCombo->addItem( tr("Custom"));
541 tabFillComboT = new QLabel( tr( "Fill Char:" ), this );
542 tabFillComboT->setBuddy(tabFillCombo);
543 layout1->addWidget( tabFillComboT );
544 layout1->addWidget( tabFillCombo );
545 clearOneButton = new QToolButton( this );
546 clearOneButton->setIcon(IconManager::instance().loadIcon("16/edit-delete.png"));
547 layout1->addSpacing(12);
548 layout1->addWidget(clearOneButton);
549 clearButton = new QToolButton( this );
550 clearButton->setIcon(IconManager::instance().loadIcon("16/edit-delete-all.png"));
551 layout1->addWidget(clearButton);
552
553 indentLayout = new QHBoxLayout;
554 indentLayout->setContentsMargins(0, 0, 0, 0);
555 indentLayout->setSpacing(6);
556 if (haveFirst)
557 {
558 firstLineData = new ScrSpinBox( -3000, ww / m_docUnitRatio, this, unit);
559 firstLineData->setValue(0);
560 firstLineLabel = new QLabel(this);
561 firstLineLabel->setText("");
562 firstLineLabel->setPixmap(IconManager::instance().loadPixmap("firstline.png"));
563 indentLayout->addWidget( firstLineLabel );
564 indentLayout->addWidget( firstLineData );
565 leftIndentData = new ScrSpinBox( 0, ww / m_docUnitRatio, this, unit);
566 leftIndentData->setValue(0);
567 leftIndentLabel = new QLabel(this);
568 leftIndentLabel->setText("");
569 leftIndentLabel->setPixmap(IconManager::instance().loadPixmap("leftindent.png"));
570 indentLayout->addWidget(leftIndentLabel);
571 indentLayout->addWidget(leftIndentData);
572 rightIndentLabel = new QLabel(this);
573 rightIndentLabel->setText("");
574 rightIndentLabel->setPixmap(IconManager::instance().loadPixmap("rightindent.png"));
575 rightIndentData = new ScrSpinBox(0, ww / m_docUnitRatio, this, unit);
576 rightIndentData->setValue(0);
577 indentLayout->addWidget(rightIndentLabel);
578 indentLayout->addWidget(rightIndentData);
579 }
580 if (!haveFirst)
581 {
582 QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
583 layout1->addItem( spacer );
584 }
585
586 layout1->addStretch( 10 );
587 tabrulerLayout->addLayout( layout1 );
588 tabrulerLayout->addLayout( layout2 );
589 indentLayout->addStretch( 10 );
590 tabrulerLayout->addLayout( indentLayout );
591
592 tabData->setEnabled(false);
593 tabFillCombo->setEnabled(false);
594 typeCombo->setEnabled(false);
595 if (tabs.count() == 0)
596 clearButton->setEnabled(false);
597 clearOneButton->setEnabled(false);
598 resize( minimumSizeHint() );
599
600 connect(rulerScrollL, SIGNAL(clicked()), ruler, SLOT(decreaseOffset()));
601 connect(rulerScrollR, SIGNAL(clicked()), ruler, SLOT(increaseOffset()));
602 connect(rulerScrollL, SIGNAL(released()), this, SLOT(resetOFfL()));
603 connect(rulerScrollR, SIGNAL(released()), this, SLOT(resetOFfR()));
604 connect(ruler, SIGNAL(typeChanged(int)) , this, SLOT(setTabType(int)));
605 connect(ruler, SIGNAL(fillCharChanged(QChar)) , this, SLOT(setTabFillChar(QChar)));
606 connect(typeCombo, SIGNAL(activated(int)), this, SLOT(setType()));
607 connect(tabFillCombo, SIGNAL(activated(int)), this, SLOT(setFillChar()));
608 connect(tabFillCombo, SIGNAL(editTextChanged(const QString &)), this, SLOT(setCustomFillChar(const QString &)));
609 connect(ruler, SIGNAL(tabMoved(double)) , this, SLOT(setTabData(double)));
610 connect(ruler, SIGNAL(tabSelected()), this, SLOT(tabAdded()));
611 connect(ruler, SIGNAL(newTab()), this, SLOT(tabAdded()));
612 connect(ruler, SIGNAL(noTabs()), this, SLOT(lastTabRemoved()));
613 connect(tabData, SIGNAL(valueChanged(double)), this, SLOT(setTab()));
614 connect(clearButton, SIGNAL(clicked()), this, SLOT(clearAll()));
615 connect(clearOneButton, SIGNAL(clicked()), this, SLOT(clearOne()));
616
617 tabFillCombo->setToolTip( tr( "Fill Character of Tab" ) );
618 typeCombo->setToolTip( tr( "Type/Orientation of Tab" ) );
619 tabData->setToolTip( tr( "Position of Tab" ) );
620
621 if (haveFirst)
622 {
623 connect(ruler, SIGNAL(firstLineMoved(double)) , this, SLOT(setFirstLineData(double)));
624 connect(ruler, SIGNAL(leftIndentMoved(double)) , this, SLOT(setLeftIndentData(double)));
625 connect(ruler, SIGNAL(mouseReleased()), this, SIGNAL(tabrulerChanged()));
626 connect(ruler, SIGNAL(mouseReleased()), this, SLOT(slotMouseReleased()));
627 connect(firstLineData, SIGNAL(valueChanged(double)), this, SLOT(setFirstLine()));
628 connect(leftIndentData, SIGNAL(valueChanged(double)), this, SLOT(setLeftIndent()));
629 connect(rightIndentData, SIGNAL(valueChanged(double)), this, SLOT(setRightIndent()));
630 firstLineData->setToolTip( tr( "Indentation for first line of the paragraph" ) );
631 leftIndentData->setToolTip( tr( "Indentation from the left for the whole paragraph" ) );
632 rightIndentData->setToolTip( tr( "Indentation from the right for the whole paragraph" ) );
633 firstLineLabel->setToolTip(firstLineData->toolTip());
634 leftIndentLabel->setToolTip(leftIndentData->toolTip());
635 rightIndentLabel->setToolTip(rightIndentData->toolTip());
636 }
637 clearButton->setToolTip( tr( "Delete all Tabulators" ) );
638 clearOneButton->setToolTip( tr("Delete selected Tabulator"));
639
640 if (unit == SC_INCHES)
641 {
642 if (haveFirst)
643 {
644 firstLineData->setDecimals(4);
645 leftIndentData->setDecimals(4);
646 rightIndentData->setDecimals(4);
647 }
648 tabData->setDecimals(4);
649 }
650 m_haveFirst = haveFirst;
651
652 connect(ScQApp, SIGNAL(iconSetChanged()), this, SLOT(iconSetChange()));
653 }
654
changeEvent(QEvent * e)655 void Tabruler::changeEvent(QEvent *e)
656 {
657 if (e->type() == QEvent::LanguageChange)
658 {
659 languageChange();
660 return;
661 }
662 QWidget::changeEvent(e);
663 }
664
iconSetChange()665 void Tabruler::iconSetChange()
666 {
667 IconManager& iconManager = IconManager::instance();
668
669 if (firstLineLabel)
670 firstLineLabel->setPixmap(iconManager.loadPixmap("firstline.png"));
671
672 if (leftIndentLabel)
673 leftIndentLabel->setPixmap(iconManager.loadPixmap("leftindent.png"));
674
675 if (rightIndentLabel)
676 rightIndentLabel->setPixmap(iconManager.loadPixmap("rightindent.png"));
677
678 clearOneButton->setIcon(iconManager.loadIcon("16/edit-delete.png"));
679 clearButton->setIcon(iconManager.loadIcon("16/edit-delete-all.png"));
680 }
681
languageChange()682 void Tabruler::languageChange()
683 {
684 int oldTypeComboIndex = typeCombo->currentIndex();
685 bool typeComboBlocked = typeCombo->blockSignals(true);
686 typeCombo->clear();
687 typeCombo->addItem( tr( "Left" ) );
688 typeCombo->addItem( tr( "Right" ) );
689 typeCombo->addItem( tr( "Period" ) );
690 typeCombo->addItem( tr( "Comma" ) );
691 typeCombo->addItem( tr( "Center" ) );
692 typeCombo->setCurrentIndex(oldTypeComboIndex);
693 typeCombo->blockSignals(typeComboBlocked);
694
695 positionLabel->setText( tr("&Position:"));
696
697 int oldTabFillComboIndex = tabFillCombo->currentIndex();
698 bool tabFillComboBlocked = tabFillCombo->blockSignals(true);
699 tabFillCombo->clear();
700 tabFillCombo->addItem( tr("None", "tab fill"));
701 tabFillCombo->addItem( tr("Dot"));
702 tabFillCombo->addItem( tr("Hyphen"));
703 tabFillCombo->addItem( tr("Underscore"));
704 tabFillCombo->addItem( tr("Custom"));
705 tabFillCombo->setCurrentIndex(oldTabFillComboIndex);
706 tabFillCombo->blockSignals(tabFillComboBlocked);
707
708 tabFillComboT->setText( tr( "Fill Char:" ));
709
710 clearButton->setText( tr( "Delete All" ) );
711 clearOneButton->setText( tr( "Delete Selected" ) );
712
713 tabFillCombo->setToolTip( tr( "Fill Character of Tab" ) );
714 typeCombo->setToolTip( tr( "Type/Orientation of Tab" ) );
715 tabData->setToolTip( tr( "Position of Tab" ) );
716
717 if (m_haveFirst)
718 {
719 firstLineData->setToolTip( tr( "Indentation for first line of the paragraph" ) );
720 leftIndentData->setToolTip( tr( "Indentation from the left for the whole paragraph" ) );
721 rightIndentData->setToolTip( tr( "Indentation from the right for the whole paragraph" ) );
722 firstLineLabel->setToolTip(firstLineData->toolTip());
723 leftIndentLabel->setToolTip(leftIndentData->toolTip());
724 rightIndentLabel->setToolTip(rightIndentData->toolTip());
725 }
726 clearButton->setToolTip( tr( "Delete all Tabulators" ) );
727 clearOneButton->setToolTip( tr("Delete selected Tabulator"));
728
729 QString unitSuffix = unitGetSuffixFromIndex(tabData->unitIndex());
730 if (m_haveFirst)
731 {
732 firstLineData->setSuffix(unitSuffix);
733 leftIndentData->setSuffix(unitSuffix);
734 rightIndentData->setSuffix(unitSuffix);
735 }
736 tabData->setSuffix(unitSuffix);
737 }
738
setTabs(const QList<ParagraphStyle::TabRecord> & tabs,int unit)739 void Tabruler::setTabs(const QList<ParagraphStyle::TabRecord>& tabs, int unit)
740 {
741 m_docUnitRatio = unitGetRatioFromIndex(unit);
742 tabData->setNewUnit(unit);
743 if (m_haveFirst)
744 {
745 firstLineData->setNewUnit(unit);
746 leftIndentData->setNewUnit(unit);
747 rightIndentData->setNewUnit(unit);
748 }
749 ruler->setTabs(tabs, unit);
750 if (tabs.count() == 0)
751 clearButton->setEnabled(false);
752 clearOneButton->setEnabled(false);
753 tabData->setEnabled(false);
754 tabFillCombo->setEnabled(false);
755 typeCombo->setEnabled(false);
756 }
757
resetOFfL()758 void Tabruler::resetOFfL()
759 {
760 if (!rulerScrollL->isDown())
761 ruler->resetOffsetInc();
762 tabData->setEnabled(false);
763 tabFillCombo->setEnabled(false);
764 typeCombo->setEnabled(false);
765 }
766
resetOFfR()767 void Tabruler::resetOFfR()
768 {
769 if (!rulerScrollR->isDown())
770 ruler->resetOffsetInc();
771 }
772
clearAll()773 void Tabruler::clearAll()
774 {
775 ruler->tabValues.clear();
776 ruler->repaint();
777 lastTabRemoved();
778 emit tabrulerChanged();
779 emit tabsChanged();
780 }
781
clearOne()782 void Tabruler::clearOne()
783 {
784 ruler->removeActTab();
785 emit tabrulerChanged();
786 emit tabsChanged();
787 }
788
tabAdded()789 void Tabruler::tabAdded()
790 {
791 typeCombo->setEnabled(true);
792 tabData->setEnabled(true);
793 clearButton->setEnabled(true);
794 clearOneButton->setEnabled(true);
795 tabFillCombo->setEnabled(true);
796 emit tabrulerChanged();
797 emit tabsChanged();
798 }
799
lastTabRemoved()800 void Tabruler::lastTabRemoved()
801 {
802 typeCombo->setEnabled(false);
803 tabData->setEnabled(false);
804 clearButton->setEnabled(false);
805 clearOneButton->setEnabled(false);
806 tabFillCombo->setEnabled(false);
807 emit tabrulerChanged();
808 emit tabsChanged();
809 }
810
setFillChar()811 void Tabruler::setFillChar()
812 {
813 tabFillCombo->blockSignals(true);
814 QChar ret;
815 switch (tabFillCombo->currentIndex())
816 {
817 case 0:
818 tabFillCombo->setEditable(false);
819 ret = QChar();
820 break;
821 case 1:
822 tabFillCombo->setEditable(false);
823 ret = '.';
824 break;
825 case 2:
826 tabFillCombo->setEditable(false);
827 ret = '-';
828 break;
829 case 3:
830 tabFillCombo->setEditable(false);
831 ret = '_';
832 break;
833 case 4:
834 tabFillCombo->setEditable(true);
835 setCurrentComboItem(tabFillCombo, CommonStrings::trCustomTabFill);
836 break;
837 }
838 if (tabFillCombo->currentIndex() != 4)
839 ruler->changeTabChar(ret);
840 tabFillCombo->blockSignals(false);
841 emit tabrulerChanged();
842 emit tabsChanged();
843 }
844
setCustomFillChar(const QString & txt)845 void Tabruler::setCustomFillChar(const QString &txt)
846 {
847 if (txt == CommonStrings::trCustomTabFill)
848 return;
849 tabFillCombo->blockSignals(true);
850 QChar ret = (txt.length() > 0) ? txt[txt.length()-1] : QChar::Null;
851 ruler->changeTabChar(ret);
852 tabFillCombo->blockSignals(false);
853 emit tabrulerChanged();
854 emit tabsChanged();
855 }
856
setTabFillChar(QChar t)857 void Tabruler::setTabFillChar(QChar t)
858 {
859 if (t.isNull())
860 {
861 tabFillCombo->setEditable(false);
862 tabFillCombo->setCurrentIndex(0);
863 }
864 else if (t == '.')
865 {
866 tabFillCombo->setEditable(false);
867 tabFillCombo->setCurrentIndex(1);
868 }
869 else if (t == '-')
870 {
871 tabFillCombo->setEditable(false);
872 tabFillCombo->setCurrentIndex(2);
873 }
874 else if (t == '_')
875 {
876 tabFillCombo->setEditable(false);
877 tabFillCombo->setCurrentIndex(3);
878 }
879 else
880 {
881 tabFillCombo->setCurrentIndex(4);
882 tabFillCombo->setEditable(true);
883 if (!t.isNull())
884 {
885 bool sigBlocked = tabFillCombo->blockSignals(true);
886 tabFillCombo->setEditText(QString(t));
887 tabFillCombo->blockSignals(sigBlocked);
888 }
889 }
890 emit tabrulerChanged();
891 emit tabsChanged();
892 }
893
setTabType(int t)894 void Tabruler::setTabType(int t)
895 {
896 typeCombo->setCurrentIndex(t);
897 emit tabrulerChanged();
898 emit tabsChanged();
899 }
900
setType()901 void Tabruler::setType()
902 {
903 typeCombo->blockSignals(true);
904 ruler->changeTab(typeCombo->currentIndex());
905 typeCombo->blockSignals(false);
906 emit tabrulerChanged();
907 emit tabsChanged();
908 }
909
setTabData(double t)910 void Tabruler::setTabData(double t)
911 {
912 tabData->blockSignals(true);
913 tabData->setValue(t * m_docUnitRatio);
914 tabData->blockSignals(false);
915 if (!ruler->mousePressed)
916 {
917 emit tabrulerChanged();
918 emit tabsChanged();
919 }
920 }
921
setTab()922 void Tabruler::setTab()
923 {
924 ruler->moveTab(tabData->value() / m_docUnitRatio);
925 emit tabrulerChanged();
926 emit tabsChanged();
927 }
928
setFirstLineData(double t)929 void Tabruler::setFirstLineData(double t)
930 {
931 // firstLineData->blockSignals(true);
932 firstLineData->setValue(t * m_docUnitRatio);
933 // firstLineData->blockSignals(false);
934 if (!ruler->mousePressed)
935 {
936 emit tabrulerChanged();
937 double a, b, value;
938 int c;
939 firstLineData->getValues(&a, &b, &c, &value);
940 emit firstLineChanged(value);
941 }
942 }
943
setFirstLine()944 void Tabruler::setFirstLine()
945 {
946 ruler->moveFirstLine(firstLineData->value() / m_docUnitRatio);
947 emit tabrulerChanged();
948 double a, b, value;
949 int c;
950 firstLineData->getValues(&a, &b, &c, &value);
951 emit firstLineChanged(value);
952 }
953
setLeftIndentData(double t)954 void Tabruler::setLeftIndentData(double t)
955 {
956 // leftIndentData->blockSignals(true);
957 leftIndentData->setValue(t * m_docUnitRatio);
958 // leftIndentData->blockSignals(false);
959 if (!ruler->mousePressed)
960 {
961 emit tabrulerChanged();
962 double a, b, value;
963 int c;
964 leftIndentData->getValues(&a, &b, &c, &value);
965 emit leftIndentChanged(value);
966 }
967 }
968
setLeftIndent()969 void Tabruler::setLeftIndent()
970 {
971 ruler->moveLeftIndent(leftIndentData->value() / m_docUnitRatio);
972 emit tabrulerChanged();
973 double a, b, value;
974 int c;
975 leftIndentData->getValues(&a, &b, &c, &value);
976 emit leftIndentChanged(value);
977 }
978
getTabVals()979 QList<ParagraphStyle::TabRecord> Tabruler::getTabVals()
980 {
981 return ruler->tabValues;
982 }
983
getFirstLine()984 double Tabruler::getFirstLine()
985 {
986 return firstLineData->value() / m_docUnitRatio;
987 }
988
getLeftIndent()989 double Tabruler::getLeftIndent()
990 {
991 return leftIndentData->value() / m_docUnitRatio;
992 }
993
setRightIndentData(double t)994 void Tabruler::setRightIndentData(double t)
995 {
996 rightIndentData->blockSignals(true);
997 rightIndentData->setValue(t * m_docUnitRatio);
998 rightIndentData->blockSignals(false);
999 if (!ruler->mousePressed)
1000 {
1001 emit tabrulerChanged();
1002 double a, b, value;
1003 int c;
1004 rightIndentData->getValues(&a, &b, &c, &value);
1005 emit rightIndentChanged(value);
1006 }
1007 }
1008
setRightIndent()1009 void Tabruler::setRightIndent()
1010 {
1011 emit tabrulerChanged();
1012 double a, b, value;
1013 int c;
1014 rightIndentData->getValues(&a, &b, &c, &value);
1015 emit rightIndentChanged(value);
1016 }
1017
getRightIndent()1018 double Tabruler::getRightIndent()
1019 {
1020 return rightIndentData->value() / m_docUnitRatio;
1021 }
1022
slotMouseReleased()1023 void Tabruler::slotMouseReleased()
1024 {
1025 emit mouseReleased();
1026 }
1027