Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
10355 subik 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
8
#include "smpstylewidget.h"
9
#include "units.h"
10
#include "util.h"
11
#include "util_icon.h"
12
 
13
 
14
static bool isEqual(double a, double b)
15
{
16
        Q_ASSERT(a >  -21473 && b > -21473 && a < 21474 && b < 21474);
17
        long al = static_cast<long>(10000 * a);
18
        long bl = static_cast<long>(10000 * b);
19
    return al == bl;
20
}
21
 
22
 
23
SMPStyleWidget::SMPStyleWidget() : QWidget()
24
{
25
        setupUi(this);
26
 
27
        pixmapLabel0->setPixmap(loadIcon("linespacing2.png"));
28
        pixmapLabel3->setPixmap( loadIcon("above.png") );
29
        pixmapLabel4->setPixmap( loadIcon("below.png") );
30
 
31
        lineSpacingMode_->insertItem( tr("Fixed Linespacing"));
32
        lineSpacingMode_->insertItem( tr("Automatic Linespacing"));
33
        lineSpacingMode_->insertItem( tr("Align to Baseline Grid"));
34
        connect(lineSpacingMode_, SIGNAL(highlighted(int)), this, SLOT(slotLineSpacingModeChanged(int)));
35
 
36
        lineSpacing_->setSuffix(unitGetSuffixFromIndex(0));
37
        spaceAbove_->setSuffix(unitGetSuffixFromIndex(0));
38
        spaceBelow_->setSuffix(unitGetSuffixFromIndex(0));
39
 
40
        dropCapOffset_->setSuffix(unitGetSuffixFromIndex(0));
41
}
42
 
43
void SMPStyleWidget::slotLineSpacingModeChanged(int i)
44
{
45
        lineSpacing_->setEnabled(i == 0);
46
}
47
 
48
void SMPStyleWidget::languageChange()
49
{
50
/***********************************/
51
/*      Begin Tooltips             */
52
/***********************************/
53
// These are for the paragraph style
54
 
55
        QToolTip::add(parentCombo,      tr("Parent Style"));
56
        QToolTip::add(lineSpacingMode_, tr("Line Spacing Mode"));
57
        QToolTip::add(lineSpacing_,     tr("Line Spacing"));
58
        QToolTip::add(spaceAbove_,      tr("Space Above"));
59
        QToolTip::add(spaceBelow_,      tr("Space Below"));
60
        //CB Unneeded, gets in the way of single widget tooltips
61
        //QToolTip::add(dropCapsBox,      tr("Enable or disable drop cap"));
62
        QToolTip::add(dropCapLines_,    tr("Drop Cap Lines"));
63
        QToolTip::add(dropCapOffset_,   tr("Drop Cap Offset"));
64
        QToolTip::add(alignement_,      tr("Alignment"));
65
        QToolTip::add(tabList_->first_, tr("First Line Indent"));
66
        QToolTip::add(tabList_->left_,  tr("Left Indent"));
67
        QToolTip::add(tabList_->right_, tr("Right Indent"));
68
        //CB Unneeded, gets in the way of single widget tooltips
69
        //QToolTip::add(tabList_,         tr("Tabulators"));
70
 
71
/***********************************/
72
/*      End Tooltips               */
73
/***********************************/
74
 
75
        lineSpacingMode_->clear();
76
        lineSpacingMode_->insertItem( tr("Fixed Linespacing"));
77
        lineSpacingMode_->insertItem( tr("Automatic Linespacing"));
78
        lineSpacingMode_->insertItem( tr("Align to Baseline Grid"));
79
        lineSpacing_->setSuffix(unitGetSuffixFromIndex(0));
80
        spaceAbove_->setSuffix(unitGetSuffixFromIndex(0));
81
        spaceBelow_->setSuffix(unitGetSuffixFromIndex(0));
82
        parentLabel->setText( tr("Based On:"));
83
        distancesBox->setTitle( tr("Distances and Alignment"));
84
        dropCapsBox->setTitle( tr("Drop Caps"));
85
        tabsBox->setTitle( tr("Tabulators and Indentation"));
86
        tabWidget->setTabLabel(tabWidget->page(0), tr("Properties"));
87
        tabWidget->setTabLabel(tabWidget->page(1), tr("Character Style"));
88
}
89
 
90
void SMPStyleWidget::unitChange(double oldRatio, double newRatio, int unitIndex)
91
{
92
        dropCapOffset_->setNewUnit(unitIndex);
93
        tabList_->left_->setNewUnit(unitIndex);
94
        tabList_->right_->setNewUnit(unitIndex);
95
        tabList_->first_->setNewUnit(unitIndex);
96
}
97
 
98
void SMPStyleWidget::show(ParagraphStyle *pstyle, QList<ParagraphStyle> &pstyles, QList<CharStyle> &cstyles, int unitIndex, const QString &defLang)
99
{
100
        double unitRatio = unitGetRatioFromIndex(unitIndex);
101
        parentCombo->setEnabled(true);
102
        const ParagraphStyle *parent = dynamic_cast<const ParagraphStyle*>(pstyle->parentStyle());
103
        hasParent_ = pstyle->hasParent() && parent != NULL && parent->hasName() && pstyle->parent() != "";
104
 
105
        lineSpacingMode_->clear();
106
        lineSpacingMode_->insertItem( tr("Fixed Linespacing"));
107
        lineSpacingMode_->insertItem( tr("Automatic Linespacing"));
108
        lineSpacingMode_->insertItem( tr("Align to Baseline Grid"));
109
 
110
        if (hasParent_)
111
        {
112
                lineSpacingMode_->setCurrentItem(pstyle->lineSpacingMode(), pstyle->isInhLineSpacingMode());
113
                lineSpacingMode_->setParentItem(parent->lineSpacingMode());
114
 
115
                lineSpacing_->setValue(pstyle->lineSpacing(), pstyle->isInhLineSpacing());
116
                lineSpacing_->setParentValue(parent->lineSpacing());
117
 
10377 cbradney 118
                spaceAbove_->setValue(pstyle->gapBefore(), pstyle->isInhGapBefore());
119
                spaceAbove_->setParentValue(parent->gapBefore());
10355 subik 120
 
10377 cbradney 121
                spaceBelow_->setValue(pstyle->gapAfter(), pstyle->isInhGapAfter());
122
                spaceBelow_->setParentValue(parent->gapAfter());
10355 subik 123
 
124
                dropCapsBox->setChecked(pstyle->hasDropCap());;
125
                parentDropCap_ = parent->hasDropCap();
126
                if (pstyle->isInhHasDropCap())
127
                        parentDropCapButton->hide();
128
                else
129
                        parentDropCapButton->show();
130
 
131
                connect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
132
 
133
                dropCapLines_->setValue(pstyle->dropCapLines(), pstyle->isInhDropCapLines());
134
                dropCapLines_->setParentValue(parent->dropCapLines());
135
 
136
                dropCapOffset_->setValue(pstyle->dropCapOffset() * unitRatio, pstyle->isInhDropCapOffset());
137
                dropCapOffset_->setParentValue(parent->dropCapOffset() * unitRatio);
138
 
139
                alignement_->setStyle(pstyle->alignment(), pstyle->isInhAlignment());
140
                alignement_->setParentItem(parent->alignment());
141
 
142
                bool hasParentTabs = pstyle->isInhTabValues();
143
                QList<ParagraphStyle::TabRecord> tabs;
144
                if (hasParentTabs)
145
                        tabs = QList<ParagraphStyle::TabRecord>(parent->tabValues());
146
                else
147
                        tabs = pstyle->tabValues();
148
 
149
                tabList_->setTabs(tabs, unitIndex, hasParentTabs);
150
                tabList_->setParentTabs(parent->tabValues());
151
 
152
                tabList_->setLeftIndentValue(pstyle->leftMargin() * unitRatio,pstyle->isInhLeftMargin());
153
                tabList_->setParentLeftIndent(parent->leftMargin() * unitRatio);
154
 
155
                tabList_->setFirstLineValue(pstyle->firstIndent() * unitRatio, pstyle->isInhFirstIndent());
156
                tabList_->setParentFirstLine(parent->firstIndent() * unitRatio);
157
 
158
                tabList_->setRightIndentValue(pstyle->rightMargin() * unitRatio, pstyle->isInhRightMargin());
159
                tabList_->setParentRightIndent(parent->rightMargin() * unitRatio);
160
        }
161
        else
162
        {
163
                lineSpacingMode_->setCurrentItem(pstyle->lineSpacingMode());
164
                lineSpacing_->setValue(pstyle->lineSpacing());
10377 cbradney 165
                spaceAbove_->setValue(pstyle->gapBefore());
166
                spaceBelow_->setValue(pstyle->gapAfter());
10355 subik 167
                dropCapsBox->setChecked(pstyle->hasDropCap());
168
                parentDropCapButton->hide();
169
                disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
170
                dropCapLines_->setValue(pstyle->dropCapLines());
171
                dropCapOffset_->setValue(pstyle->dropCapOffset() * unitRatio);
172
                parentDropCapButton->hide();
173
                alignement_->setStyle(pstyle->alignment());
174
                tabList_->setTabs(pstyle->tabValues(), unitIndex);
175
                tabList_->setLeftIndentValue(pstyle->leftMargin() * unitRatio);
176
                tabList_->setFirstLineValue(pstyle->firstIndent() * unitRatio);
177
                tabList_->setRightIndentValue(pstyle->rightMargin() * unitRatio);
178
        }
179
 
180
        lineSpacing_->setEnabled(pstyle->lineSpacingMode() == ParagraphStyle::FixedLineSpacing);
181
        dropCapLines_->setEnabled(pstyle->hasDropCap());
182
        dropCapOffset_->setEnabled(pstyle->hasDropCap());
183
 
184
        QFont f(font());
185
        f.setBold(true);
186
        parentDropCapButton->setFont(f);
187
 
188
        cpage->parentLabel->setText( tr("Based On:"));
189
        cpage->show(&pstyle->charStyle(), cstyles, defLang, unitIndex);
190
 
191
        parentCombo->clear();
192
        parentCombo->insertItem("");
193
 
194
        for (int i = 0; i < pstyles.count(); ++i)
195
        {
196
                if (pstyles[i].hasName() && pstyles[i].name() != pstyle->name())
197
                        parentCombo->insertItem(pstyles[i].name());
198
        }
199
 
200
        if (hasParent_)
201
        {
202
                int index = 0;
203
                for (int i = 0; i < parentCombo->count(); ++i)
204
                {
205
                        if (parentCombo->text(i) == parent->name())
206
                        {
207
                                index = i;
208
                                break;
209
                        }
210
                }
211
                parentCombo->setCurrentItem(index);
212
        }
213
        else
214
                parentCombo->setCurrentItem(0);
215
 
216
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
217
}
218
 
219
void SMPStyleWidget::show(QList<ParagraphStyle*> &pstyles, QList<ParagraphStyle> &pstylesAll, QList<CharStyle> &cstyles, int unitIndex, const QString &defLang)
220
{
221
        if (pstyles.count() == 1)
222
                show(pstyles[0], pstylesAll, cstyles, unitIndex, defLang);
223
        else if (pstyles.count() > 1)
224
        {
225
                showLineSpacing(pstyles);
226
                showSpaceAB(pstyles, unitIndex);
227
                showDropCap(pstyles, unitIndex);
228
                showAlignment(pstyles);
229
                showTabs(pstyles, unitIndex);
230
                showCStyle(pstyles, cstyles, defLang, unitIndex);
231
                showParent(pstyles);
232
        }
233
}
234
 
235
void SMPStyleWidget::showLineSpacing(QList<ParagraphStyle*> &pstyles)
236
{
237
        lineSpacingMode_->clear();
238
        lineSpacingMode_->insertItem( tr("Fixed Linespacing"));
239
        lineSpacingMode_->insertItem( tr("Automatic Linespacing"));
240
        lineSpacingMode_->insertItem( tr("Align to Baseline Grid"));
241
 
242
        int tmpLP = -1;
243
        for (int i = 0; i < pstyles.count(); ++i)
244
        {
245
                if (tmpLP != -1 && pstyles[i]->lineSpacingMode() != tmpLP)
246
                {
247
                        tmpLP = -1;
248
                        break;
249
                }
250
                else
251
                        tmpLP = pstyles[i]->lineSpacingMode();
252
        }
253
 
254
        if (tmpLP == -1)
255
        {
256
                if (lineSpacingMode_->text(lineSpacingMode_->count() - 1) != "")
257
                        lineSpacingMode_->insertItem("");
258
                lineSpacingMode_->setCurrentItem(lineSpacingMode_->count() - 1);
259
        }
260
        else
261
                lineSpacingMode_->setCurrentItem(tmpLP);
262
 
263
        double tmpLS = -1.0;
264
        for (int i = 0; i < pstyles.count(); ++i)
265
        {
266
                if (tmpLS > 0 && !isEqual(pstyles[i]->lineSpacing(), tmpLS))
267
                {
268
                        tmpLS = -1.0;
269
                        break;
270
                }
271
                else
272
                        tmpLS = pstyles[i]->lineSpacing();
273
        }
274
        lineSpacing_->setEnabled(true);
275
        if (tmpLS < 0)
276
                lineSpacing_->clear();
277
        else
278
                lineSpacing_->setValue(tmpLS);
279
}
280
 
281
void SMPStyleWidget::showSpaceAB(QList<ParagraphStyle*> &pstyles, int unitIndex)
282
{
10378 subik 283
//      double unitRatio = unitGetRatioFromIndex(unitIndex);
10355 subik 284
        double tmpA = -1.2;
285
        for (int i = 0; i < pstyles.count(); ++i)
286
        {
287
                if (tmpA > -1.0 && !isEqual(pstyles[i]->gapBefore(), tmpA))
288
                {
289
                        tmpA = -1.2;
290
                        break;
291
                }
292
                else
293
                        tmpA = pstyles[i]->gapBefore();
294
        }
295
 
296
        if (tmpA < 0)
297
                spaceAbove_->clear();
298
        else
10377 cbradney 299
                spaceAbove_->setValue(tmpA);
10355 subik 300
 
301
        tmpA = -1.2;
302
        for (int i = 0; i < pstyles.count(); ++i)
303
        {
304
                if (tmpA > -1.0 && !isEqual(pstyles[i]->gapAfter(), tmpA))
305
                {
306
                        tmpA = -1.2;
307
                        break;
308
                }
309
        }
310
 
311
        if (tmpA < 0)
312
                spaceBelow_->clear();
313
        else
10377 cbradney 314
                spaceBelow_->setValue(tmpA);
10355 subik 315
}
316
 
317
void SMPStyleWidget::showDropCap(QList<ParagraphStyle*> &pstyles, int unitIndex)
318
{
319
        double unitRatio = unitGetRatioFromIndex(unitIndex);
320
        parentDropCapButton->hide();
321
        disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
322
 
323
        bool dc = pstyles[0]->hasDropCap();
324
        for (int i = 0; i < pstyles.count(); ++i)
325
        {
326
                if (dc != pstyles[i]->hasDropCap())
327
                {
328
                        dc = false;
329
                        break;
330
                }
331
        }
332
        dropCapsBox->setChecked(dc);
333
 
334
        int lines = -1;
335
        for (int i = 0; i < pstyles.count(); ++i)
336
        {
337
                if (lines > -1 && pstyles[i]->dropCapLines() != lines)
338
                {
339
                        lines = -1;
340
                        break;
341
                }
342
                else
343
                        lines = pstyles[i]->dropCapLines();
344
        }
345
        if (lines == -1)
346
                dropCapLines_->clear();
347
        else
348
                dropCapLines_->setValue(lines);
349
 
350
        double dco = -4000.0;
351
        for (int i = 0; i < pstyles.count(); ++i)
352
        {
353
                if (dco > -3980.0 && !isEqual(pstyles[i]->dropCapOffset(), dco))
354
                {
355
                        dco = -4000.0;
356
                        break;
357
                }
358
                else
359
                        dco = pstyles[i]->dropCapOffset();
360
        }
361
 
362
        if (dco < -3800.0)
363
                dropCapOffset_->clear();
364
        else
365
                dropCapOffset_->setValue(dco * unitRatio);
366
 
367
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
368
        dropCapsBox->setEnabled(true);
369
        dropCapLines_->setEnabled(true);
370
        dropCapOffset_->setEnabled(true);
371
}
372
 
373
void SMPStyleWidget::showAlignment(QList<ParagraphStyle*> &pstyles)
374
{
375
        ParagraphStyle::AlignmentType a = pstyles[0]->alignment();
376
        for (int i = 0; i < pstyles.count(); ++i)
377
        {
378
                if (a != pstyles[i]->alignment())
379
                {
380
                        if (alignement_->selectedId() > -1)
381
                        {
382
                                alignement_->buttonGroup->setExclusive(false);
383
                                alignement_->buttonGroup->button(alignement_->selectedId())->toggle();
384
                                alignement_->buttonGroup->setExclusive(true);
385
                        }
386
                        return;
387
                }
388
        }
389
        alignement_->setStyle(a);
390
}
391
 
392
void SMPStyleWidget::showTabs(QList<ParagraphStyle*> &pstyles, int unitIndex)
393
{
394
        double unitRatio = unitGetRatioFromIndex(unitIndex);
395
        QList<ParagraphStyle::TabRecord> t = pstyles[0]->tabValues();
396
        for (int i = 0; i < pstyles.count(); ++i)
397
        {
398
                if (t != pstyles[i]->tabValues())
399
                {
400
                        t = QList<ParagraphStyle::TabRecord>();
401
                        break;
402
                }
403
        }
404
        tabList_->setTabs(t, unitIndex);
405
 
406
        double l = -4000.0;
407
        for (int i = 0; i < pstyles.count(); ++i)
408
        {
409
                if (l > -3800.0 && !isEqual(pstyles[i]->leftMargin(), l))
410
                {
411
                        l = -4000.0;
412
                        break;
413
                }
414
                else
415
                        l = pstyles[i]->leftMargin();
416
        }
417
        if (l < -3800.0)
418
        {
419
                tabList_->setLeftIndentValue(0.0);
420
                tabList_->left_->clear();
421
        }
422
        else
423
                tabList_->setLeftIndentValue(l * unitRatio);
424
 
425
        l = -4000.0;
426
        for (int i = 0; i < pstyles.count(); ++i)
427
        {
428
                if (l > -3800.0 && !isEqual(pstyles[i]->firstIndent(), l))
429
                {
430
                        l = -4000.0;
431
                        break;
432
                }
433
                else
434
                        l = pstyles[i]->firstIndent();
435
        }
436
        if (l < -3800.0)
437
        {
438
                tabList_->setFirstLineValue(0.0);
439
                tabList_->first_->clear();
440
        }
441
        else
442
                tabList_->setFirstLineValue(l * unitRatio);
443
 
444
        l = -4000.0;
445
        for (int i = 0; i < pstyles.count(); ++i)
446
        {
447
                if (l > -3800.0 && !isEqual(pstyles[i]->rightMargin(), l))
448
                {
449
                        l = -4000.0;
450
                        break;
451
                }
452
                else
453
                        l = pstyles[i]->rightMargin();
454
        }
455
        if (l < -3800.0)
456
        {
457
                tabList_->setRightIndentData(0.0);
458
                tabList_->right_->clear();
459
        }
460
        else
461
                tabList_->setRightIndentValue(l * unitRatio);
462
 
463
}
464
 
465
void SMPStyleWidget::showCStyle(QList<ParagraphStyle*> &pstyles, QList<CharStyle> &cstyles, const QString &defLang, int unitIndex)
466
{
467
        cpage->parentLabel->setText( tr("Based On:"));
468
 
469
        QList<CharStyle*> cstyle;
470
        for (int i = 0; i < pstyles.count(); ++i)
471
                cstyle << &pstyles[i]->charStyle();
472
 
473
        cpage->show(cstyle, cstyles, defLang, unitIndex);
474
}
475
 
476
void SMPStyleWidget::showParent(QList<ParagraphStyle*> &pstyles)
477
{
478
        parentCombo->setEnabled(false);
479
 
480
//      parentCombo->clear();
481
//      parentCombo->insertItem("");
482
//      for (uint i = 0; i < pstyles.count(); ++i)
483
//      {
484
//              if (pstyles[i].hasName() && pstyles[i].name() != pstyle->name())
485
//                      parentCombo->insertItem(pstyles[i].name());
486
//      }
487
// 
488
//      if (hasParent_)
489
//      {
490
//              int index = 0;
491
//              for (int i = 0; i < parentCombo->count(); ++i)
492
//              {
493
//                      if (parentCombo->text(i) == parent->name())
494
//                      {
495
//                              index = i;
496
//                              break;
497
//                      }
498
//              }
499
//              parentCombo->setCurrentItem(index);
500
//      }
501
//      else
502
//              parentCombo->setCurrentItem(0);
503
}
504
 
505
void SMPStyleWidget::clearAll()
506
{
507
 
508
}
509
 
510
void SMPStyleWidget::slotDropCap(bool isOn)
511
{
512
        if (isOn)
513
        {
514
                dropCapsBox->setEnabled(true);
515
                dropCapLines_->setEnabled(true);
516
                dropCapOffset_->setEnabled(true);
517
        }
518
        else
519
        {
520
                dropCapsBox->setEnabled(true);
521
                dropCapLines_->setEnabled(false);
522
                dropCapOffset_->setEnabled(false);
523
        }
524
        if (hasParent_)
525
                parentDropCapButton->show();
526
}
527
 
528
void SMPStyleWidget::slotParentDropCap()
529
{
530
        disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
531
        disconnect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
532
        parentDropCapButton->hide();
533
        dropCapsBox->setChecked(parentDropCap_);
534
        emit useParentDropCap();
535
        connect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
536
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
537
}
538
 
539
SMPStyleWidget::~SMPStyleWidget()
540
{
541
 
542
}
543