Subversion Repositories Scribus

Rev

Rev 12916 | 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
 
10859 cbradney 8
#include <QEvent>
9
 
10355 subik 10
#include "smpstylewidget.h"
11
#include "units.h"
12
#include "util.h"
13
#include "util_icon.h"
14
 
15
 
16
static bool isEqual(double a, double b)
17
{
18
        Q_ASSERT(a >  -21473 && b > -21473 && a < 21474 && b < 21474);
19
        long al = static_cast<long>(10000 * a);
20
        long bl = static_cast<long>(10000 * b);
21
    return al == bl;
22
}
23
 
24
 
25
SMPStyleWidget::SMPStyleWidget() : QWidget()
26
{
27
        setupUi(this);
28
 
12423 cbradney 29
        lineSpacingLabel->setPixmap(loadIcon("linespacing2.png"));
30
        spaceAboveLabel->setPixmap( loadIcon("above.png") );
31
        spaceBelowLabel->setPixmap( loadIcon("below.png") );
10355 subik 32
 
10585 fschmid 33
        lineSpacingMode_->addItem( tr("Fixed Linespacing"));
34
        lineSpacingMode_->addItem( tr("Automatic Linespacing"));
35
        lineSpacingMode_->addItem( tr("Align to Baseline Grid"));
10355 subik 36
        connect(lineSpacingMode_, SIGNAL(highlighted(int)), this, SLOT(slotLineSpacingModeChanged(int)));
37
 
38
        lineSpacing_->setSuffix(unitGetSuffixFromIndex(0));
39
        spaceAbove_->setSuffix(unitGetSuffixFromIndex(0));
12828 pierre 40
        spaceBelow_->setSuffix(unitGetSuffixFromIndex(0));
10355 subik 41
 
12828 pierre 42
        optMarginCombo->addItem(tr("None"), ParagraphStyle::OM_None);
43
        optMarginCombo->addItem(tr("Left Protruding"), ParagraphStyle::OM_LeftProtruding);
44
        optMarginCombo->addItem(tr("Right Protruding"), ParagraphStyle::OM_RightProtruding);
12829 pierre 45
        optMarginCombo->addItem(tr("Left Hanging Punctuation"), ParagraphStyle::OM_LeftHangingPunct);
46
        optMarginCombo->addItem(tr("Right Hanging Punctuation"), ParagraphStyle::OM_RightHangingPunct);
12828 pierre 47
        optMarginCombo->addItem(tr("Default"), ParagraphStyle::OM_Default);
48
 
10355 subik 49
        dropCapOffset_->setSuffix(unitGetSuffixFromIndex(0));
12829 pierre 50
 
51
        minSpaceSpin->setSuffix(unitGetSuffixFromIndex(SC_PERCENT));
52
        minGlyphExtSpin->setSuffix(unitGetSuffixFromIndex(SC_PERCENT));
53
        maxGlyphExtSpin->setSuffix(unitGetSuffixFromIndex(SC_PERCENT));
10355 subik 54
}
55
 
56
void SMPStyleWidget::slotLineSpacingModeChanged(int i)
57
{
58
        lineSpacing_->setEnabled(i == 0);
59
}
60
 
10859 cbradney 61
void SMPStyleWidget::changeEvent(QEvent *e)
62
{
63
        if (e->type() == QEvent::LanguageChange)
64
        {
65
                languageChange();
66
        }
10903 cbradney 67
        else
68
                QWidget::changeEvent(e);
10859 cbradney 69
}
70
 
10355 subik 71
void SMPStyleWidget::languageChange()
72
{
73
/***********************************/
74
/*      Begin Tooltips             */
75
/***********************************/
76
// These are for the paragraph style
77
 
10397 cbradney 78
        parentCombo->setToolTip(      tr("Parent Style"));
79
        lineSpacingMode_->setToolTip( tr("Line Spacing Mode"));
80
        lineSpacing_->setToolTip(     tr("Line Spacing"));
81
        spaceAbove_->setToolTip(      tr("Space Above"));
82
        spaceBelow_->setToolTip(      tr("Space Below"));
12423 cbradney 83
        lineSpacingLabel->setToolTip(lineSpacing_->toolTip());
84
        spaceAboveLabel->setToolTip(spaceAbove_->toolTip());
12828 pierre 85
        spaceBelowLabel->setToolTip(spaceBelow_->toolTip());
86
        optMarginCombo->setToolTip(tr("Activate an optical margins layout"));
87
        optMarginLabel->setToolTip(optMarginCombo->toolTip());
10355 subik 88
        //CB Unneeded, gets in the way of single widget tooltips
10397 cbradney 89
        //dropCapsBox->setToolTip(      tr("Enable or disable drop cap"));
90
        dropCapLines_->setToolTip(    tr("Drop Cap Lines"));
91
        dropCapOffset_->setToolTip(   tr("Drop Cap Offset"));
92
        alignement_->setToolTip(      tr("Alignment"));
10575 cbradney 93
        tabList_->first_->setToolTip( tr("First Line Indent"));
94
        tabList_->left_->setToolTip(  tr("Left Indent"));
95
        tabList_->right_->setToolTip( tr("Right Indent"));
10355 subik 96
        //CB Unneeded, gets in the way of single widget tooltips
10397 cbradney 97
        //tabList_->setToolTip(         tr("Tabulators"));
12829 pierre 98
 
99
        minSpaceSpin->setToolTip(tr("Maximum white space compression allowed.\nExpressed as a percentage of the current white space value."));
100
        minSpaceLabel->setToolTip(minSpaceSpin->toolTip());
101
        minGlyphExtSpin->setToolTip(tr("Maximum compression of glyphs"));
102
        minGlyphExtLabel->setToolTip(minGlyphExtSpin->toolTip());
103
        maxGlyphExtSpin->setToolTip(tr("Maximum extension of glyphs"));
104
        maxGlyphExtLabel->setToolTip(maxGlyphExtSpin->toolTip());
105
 
10355 subik 106
 
107
/***********************************/
108
/*      End Tooltips               */
109
/***********************************/
110
 
111
        lineSpacingMode_->clear();
10585 fschmid 112
        lineSpacingMode_->addItem( tr("Fixed Linespacing"));
113
        lineSpacingMode_->addItem( tr("Automatic Linespacing"));
12828 pierre 114
        lineSpacingMode_->addItem( tr("Align to Baseline Grid"));
12829 pierre 115
 
116
        optMarginCombo->clear();
117
        optMarginCombo->addItem(tr("None"), ParagraphStyle::OM_None);
118
        optMarginCombo->addItem(tr("Left Protruding"), ParagraphStyle::OM_LeftProtruding);
119
        optMarginCombo->addItem(tr("Right Protruding"), ParagraphStyle::OM_RightProtruding);
120
        optMarginCombo->addItem(tr("Left Hanging Punctuation"), ParagraphStyle::OM_LeftHangingPunct);
121
        optMarginCombo->addItem(tr("Right Hanging Punctuation"), ParagraphStyle::OM_RightHangingPunct);
122
        optMarginCombo->addItem(tr("Default"), ParagraphStyle::OM_Default);
123
 
12828 pierre 124
        optMarginLabel->setText(tr("Optical Margins"));
10355 subik 125
        lineSpacing_->setSuffix(unitGetSuffixFromIndex(0));
126
        spaceAbove_->setSuffix(unitGetSuffixFromIndex(0));
127
        spaceBelow_->setSuffix(unitGetSuffixFromIndex(0));
128
        parentLabel->setText( tr("Based On:"));
129
        distancesBox->setTitle( tr("Distances and Alignment"));
130
        dropCapsBox->setTitle( tr("Drop Caps"));
131
        tabsBox->setTitle( tr("Tabulators and Indentation"));
10585 fschmid 132
        tabWidget->setTabText(0, tr("Properties"));
133
        tabWidget->setTabText(1, tr("Character Style"));
12829 pierre 134
 
135
        minSpaceLabel->setText(tr("Min. space width"));
136
        minGlyphExtLabel->setText(tr("Max. glyph comp."));
137
        maxGlyphExtLabel->setText(tr("Max. glyph ext."));
10355 subik 138
}
139
 
140
void SMPStyleWidget::unitChange(double oldRatio, double newRatio, int unitIndex)
141
{
142
        dropCapOffset_->setNewUnit(unitIndex);
143
        tabList_->left_->setNewUnit(unitIndex);
144
        tabList_->right_->setNewUnit(unitIndex);
145
        tabList_->first_->setNewUnit(unitIndex);
146
}
147
 
148
void SMPStyleWidget::show(ParagraphStyle *pstyle, QList<ParagraphStyle> &pstyles, QList<CharStyle> &cstyles, int unitIndex, const QString &defLang)
149
{
150
        double unitRatio = unitGetRatioFromIndex(unitIndex);
12916 jghali 151
        parentCombo->setEnabled(!pstyle->isDefaultStyle());
10355 subik 152
        const ParagraphStyle *parent = dynamic_cast<const ParagraphStyle*>(pstyle->parentStyle());
153
        hasParent_ = pstyle->hasParent() && parent != NULL && parent->hasName() && pstyle->parent() != "";
154
 
155
        lineSpacingMode_->clear();
10585 fschmid 156
        lineSpacingMode_->addItem( tr("Fixed Linespacing"));
157
        lineSpacingMode_->addItem( tr("Automatic Linespacing"));
158
        lineSpacingMode_->addItem( tr("Align to Baseline Grid"));
12828 pierre 159
 
12829 pierre 160
        optMarginCombo->clear();
161
        optMarginCombo->addItem(tr("None"), ParagraphStyle::OM_None);
162
        optMarginCombo->addItem(tr("Left Protruding"), ParagraphStyle::OM_LeftProtruding);
163
        optMarginCombo->addItem(tr("Right Protruding"), ParagraphStyle::OM_RightProtruding);
164
        optMarginCombo->addItem(tr("Left Hanging Punctuation"), ParagraphStyle::OM_LeftHangingPunct);
165
        optMarginCombo->addItem(tr("Right Hanging Punctuation"), ParagraphStyle::OM_RightHangingPunct);
166
        optMarginCombo->addItem(tr("Default"), ParagraphStyle::OM_Default);
12828 pierre 167
 
12829 pierre 168
        // One could think it’s too much (aesthetic) or not enough (freedom)!
169
        minSpaceSpin->setRange(1.0,100.0);
170
        minGlyphExtSpin->setRange(90.0,100.0);
171
        maxGlyphExtSpin->setRange(100.0,110.0);
172
 
10355 subik 173
 
174
        if (hasParent_)
175
        {
176
                lineSpacingMode_->setCurrentItem(pstyle->lineSpacingMode(), pstyle->isInhLineSpacingMode());
177
                lineSpacingMode_->setParentItem(parent->lineSpacingMode());
12828 pierre 178
 
179
                optMarginCombo->setCurrentItemByData( pstyle->opticalMargins(),  pstyle->isInhOpticalMargins() );
180
                optMarginCombo->setParentItem(optMarginCombo->getItemIndexForData( parent->opticalMargins()));
12829 pierre 181
 
182
                minSpaceSpin->setValue(pstyle->minWordTracking() * 100.0,  pstyle->isInhMinWordTracking());
183
                minSpaceSpin->setParentValue(parent->minWordTracking());
184
                minGlyphExtSpin->setValue(pstyle->minGlyphExtension() * 100.0,  pstyle->isInhMinGlyphExtension());
185
                minGlyphExtSpin->setParentValue(parent->minGlyphExtension());
186
                maxGlyphExtSpin->setValue(pstyle->maxGlyphExtension() * 100.0,  pstyle->isInhMaxGlyphExtension());
187
                maxGlyphExtSpin->setParentValue(parent->maxGlyphExtension());
10355 subik 188
 
189
                lineSpacing_->setValue(pstyle->lineSpacing(), pstyle->isInhLineSpacing());
190
                lineSpacing_->setParentValue(parent->lineSpacing());
191
 
10377 cbradney 192
                spaceAbove_->setValue(pstyle->gapBefore(), pstyle->isInhGapBefore());
193
                spaceAbove_->setParentValue(parent->gapBefore());
10355 subik 194
 
10377 cbradney 195
                spaceBelow_->setValue(pstyle->gapAfter(), pstyle->isInhGapAfter());
196
                spaceBelow_->setParentValue(parent->gapAfter());
10355 subik 197
 
198
                dropCapsBox->setChecked(pstyle->hasDropCap());;
199
                parentDropCap_ = parent->hasDropCap();
200
                if (pstyle->isInhHasDropCap())
201
                        parentDropCapButton->hide();
202
                else
203
                        parentDropCapButton->show();
204
 
205
                connect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
206
 
207
                dropCapLines_->setValue(pstyle->dropCapLines(), pstyle->isInhDropCapLines());
208
                dropCapLines_->setParentValue(parent->dropCapLines());
209
 
210
                dropCapOffset_->setValue(pstyle->dropCapOffset() * unitRatio, pstyle->isInhDropCapOffset());
211
                dropCapOffset_->setParentValue(parent->dropCapOffset() * unitRatio);
212
 
213
                alignement_->setStyle(pstyle->alignment(), pstyle->isInhAlignment());
214
                alignement_->setParentItem(parent->alignment());
215
 
216
                bool hasParentTabs = pstyle->isInhTabValues();
217
                QList<ParagraphStyle::TabRecord> tabs;
218
                if (hasParentTabs)
219
                        tabs = QList<ParagraphStyle::TabRecord>(parent->tabValues());
220
                else
221
                        tabs = pstyle->tabValues();
222
 
223
                tabList_->setTabs(tabs, unitIndex, hasParentTabs);
224
                tabList_->setParentTabs(parent->tabValues());
225
 
226
                tabList_->setLeftIndentValue(pstyle->leftMargin() * unitRatio,pstyle->isInhLeftMargin());
227
                tabList_->setParentLeftIndent(parent->leftMargin() * unitRatio);
228
 
229
                tabList_->setFirstLineValue(pstyle->firstIndent() * unitRatio, pstyle->isInhFirstIndent());
230
                tabList_->setParentFirstLine(parent->firstIndent() * unitRatio);
231
 
232
                tabList_->setRightIndentValue(pstyle->rightMargin() * unitRatio, pstyle->isInhRightMargin());
233
                tabList_->setParentRightIndent(parent->rightMargin() * unitRatio);
234
        }
235
        else
236
        {
10585 fschmid 237
                lineSpacingMode_->setCurrentIndex(pstyle->lineSpacingMode());
10355 subik 238
                lineSpacing_->setValue(pstyle->lineSpacing());
10377 cbradney 239
                spaceAbove_->setValue(pstyle->gapBefore());
240
                spaceBelow_->setValue(pstyle->gapAfter());
12828 pierre 241
                optMarginCombo->setCurrentItemByData( pstyle->opticalMargins() );
12829 pierre 242
                minSpaceSpin->setValue(pstyle->minWordTracking() * 100.0);
243
                minGlyphExtSpin->setValue(pstyle->minGlyphExtension() * 100.0);
244
                maxGlyphExtSpin->setValue(pstyle->maxGlyphExtension() * 100.0);
10355 subik 245
                dropCapsBox->setChecked(pstyle->hasDropCap());
246
                parentDropCapButton->hide();
247
                disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
248
                dropCapLines_->setValue(pstyle->dropCapLines());
249
                dropCapOffset_->setValue(pstyle->dropCapOffset() * unitRatio);
250
                parentDropCapButton->hide();
251
                alignement_->setStyle(pstyle->alignment());
252
                tabList_->setTabs(pstyle->tabValues(), unitIndex);
253
                tabList_->setLeftIndentValue(pstyle->leftMargin() * unitRatio);
254
                tabList_->setFirstLineValue(pstyle->firstIndent() * unitRatio);
255
                tabList_->setRightIndentValue(pstyle->rightMargin() * unitRatio);
12829 pierre 256
 
10355 subik 257
        }
258
 
259
        lineSpacing_->setEnabled(pstyle->lineSpacingMode() == ParagraphStyle::FixedLineSpacing);
260
        dropCapLines_->setEnabled(pstyle->hasDropCap());
261
        dropCapOffset_->setEnabled(pstyle->hasDropCap());
262
 
263
        QFont f(font());
264
        f.setBold(true);
265
        parentDropCapButton->setFont(f);
266
 
267
        cpage->parentLabel->setText( tr("Based On:"));
268
        cpage->show(&pstyle->charStyle(), cstyles, defLang, unitIndex);
269
 
270
        parentCombo->clear();
12929 jghali 271
        parentCombo->addItem( pstyle->isDefaultStyle()? tr("A default style cannot be assigned a parent style") : "");
272
        if (!pstyle->isDefaultStyle())
10355 subik 273
        {
12929 jghali 274
                for (int i = 0; i < pstyles.count(); ++i)
275
                {
276
                        if (pstyles[i].hasName() && pstyles[i].name() != pstyle->name())
277
                                parentCombo->addItem(pstyles[i].name());
278
                }
10355 subik 279
        }
280
 
12929 jghali 281
        if (pstyle->isDefaultStyle() || !hasParent_)
282
                parentCombo->setCurrentIndex(0);
283
        else
10355 subik 284
        {
285
                int index = 0;
286
                for (int i = 0; i < parentCombo->count(); ++i)
287
                {
10585 fschmid 288
                        if (parentCombo->itemText(i) == parent->name())
10355 subik 289
                        {
290
                                index = i;
291
                                break;
292
                        }
293
                }
10585 fschmid 294
                parentCombo->setCurrentIndex(index);
10355 subik 295
        }
296
 
297
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
298
}
299
 
300
void SMPStyleWidget::show(QList<ParagraphStyle*> &pstyles, QList<ParagraphStyle> &pstylesAll, QList<CharStyle> &cstyles, int unitIndex, const QString &defLang)
301
{
302
        if (pstyles.count() == 1)
303
                show(pstyles[0], pstylesAll, cstyles, unitIndex, defLang);
304
        else if (pstyles.count() > 1)
305
        {
306
                showLineSpacing(pstyles);
307
                showSpaceAB(pstyles, unitIndex);
308
                showDropCap(pstyles, unitIndex);
309
                showAlignment(pstyles);
12829 pierre 310
                showOpticalMargin(pstyles);
311
                showMinSpace(pstyles);
312
                showMinGlyphExt(pstyles);
313
                showMaxGlyphExt(pstyles);
10355 subik 314
                showTabs(pstyles, unitIndex);
315
                showCStyle(pstyles, cstyles, defLang, unitIndex);
316
                showParent(pstyles);
317
        }
318
}
319
 
320
void SMPStyleWidget::showLineSpacing(QList<ParagraphStyle*> &pstyles)
321
{
322
        lineSpacingMode_->clear();
10585 fschmid 323
        lineSpacingMode_->addItem( tr("Fixed Linespacing"));
324
        lineSpacingMode_->addItem( tr("Automatic Linespacing"));
325
        lineSpacingMode_->addItem( tr("Align to Baseline Grid"));
10355 subik 326
 
327
        int tmpLP = -1;
328
        for (int i = 0; i < pstyles.count(); ++i)
329
        {
330
                if (tmpLP != -1 && pstyles[i]->lineSpacingMode() != tmpLP)
331
                {
332
                        tmpLP = -1;
333
                        break;
334
                }
335
                else
336
                        tmpLP = pstyles[i]->lineSpacingMode();
337
        }
338
 
339
        if (tmpLP == -1)
340
        {
10585 fschmid 341
                if (lineSpacingMode_->itemText(lineSpacingMode_->count() - 1) != "")
342
                        lineSpacingMode_->addItem("");
343
                lineSpacingMode_->setCurrentIndex(lineSpacingMode_->count() - 1);
10355 subik 344
        }
345
        else
10585 fschmid 346
                lineSpacingMode_->setCurrentIndex(tmpLP);
10355 subik 347
 
348
        double tmpLS = -1.0;
349
        for (int i = 0; i < pstyles.count(); ++i)
350
        {
351
                if (tmpLS > 0 && !isEqual(pstyles[i]->lineSpacing(), tmpLS))
352
                {
353
                        tmpLS = -1.0;
354
                        break;
355
                }
356
                else
357
                        tmpLS = pstyles[i]->lineSpacing();
358
        }
359
        lineSpacing_->setEnabled(true);
360
        if (tmpLS < 0)
361
                lineSpacing_->clear();
362
        else
363
                lineSpacing_->setValue(tmpLS);
364
}
365
 
366
void SMPStyleWidget::showSpaceAB(QList<ParagraphStyle*> &pstyles, int unitIndex)
367
{
10378 subik 368
//      double unitRatio = unitGetRatioFromIndex(unitIndex);
10355 subik 369
        double tmpA = -1.2;
370
        for (int i = 0; i < pstyles.count(); ++i)
371
        {
372
                if (tmpA > -1.0 && !isEqual(pstyles[i]->gapBefore(), tmpA))
373
                {
374
                        tmpA = -1.2;
375
                        break;
376
                }
377
                else
378
                        tmpA = pstyles[i]->gapBefore();
379
        }
380
 
381
        if (tmpA < 0)
382
                spaceAbove_->clear();
383
        else
10377 cbradney 384
                spaceAbove_->setValue(tmpA);
10355 subik 385
 
386
        tmpA = -1.2;
387
        for (int i = 0; i < pstyles.count(); ++i)
388
        {
389
                if (tmpA > -1.0 && !isEqual(pstyles[i]->gapAfter(), tmpA))
390
                {
391
                        tmpA = -1.2;
392
                        break;
393
                }
394
        }
395
 
396
        if (tmpA < 0)
397
                spaceBelow_->clear();
398
        else
10377 cbradney 399
                spaceBelow_->setValue(tmpA);
10355 subik 400
}
401
 
402
void SMPStyleWidget::showDropCap(QList<ParagraphStyle*> &pstyles, int unitIndex)
403
{
404
        double unitRatio = unitGetRatioFromIndex(unitIndex);
405
        parentDropCapButton->hide();
406
        disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
407
 
408
        bool dc = pstyles[0]->hasDropCap();
409
        for (int i = 0; i < pstyles.count(); ++i)
410
        {
411
                if (dc != pstyles[i]->hasDropCap())
412
                {
413
                        dc = false;
414
                        break;
415
                }
416
        }
417
        dropCapsBox->setChecked(dc);
418
 
419
        int lines = -1;
420
        for (int i = 0; i < pstyles.count(); ++i)
421
        {
422
                if (lines > -1 && pstyles[i]->dropCapLines() != lines)
423
                {
424
                        lines = -1;
425
                        break;
426
                }
427
                else
428
                        lines = pstyles[i]->dropCapLines();
429
        }
430
        if (lines == -1)
431
                dropCapLines_->clear();
432
        else
433
                dropCapLines_->setValue(lines);
434
 
435
        double dco = -4000.0;
436
        for (int i = 0; i < pstyles.count(); ++i)
437
        {
438
                if (dco > -3980.0 && !isEqual(pstyles[i]->dropCapOffset(), dco))
439
                {
440
                        dco = -4000.0;
441
                        break;
442
                }
443
                else
444
                        dco = pstyles[i]->dropCapOffset();
445
        }
446
 
447
        if (dco < -3800.0)
448
                dropCapOffset_->clear();
449
        else
450
                dropCapOffset_->setValue(dco * unitRatio);
451
 
452
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
453
        dropCapsBox->setEnabled(true);
454
        dropCapLines_->setEnabled(true);
455
        dropCapOffset_->setEnabled(true);
456
}
457
 
458
void SMPStyleWidget::showAlignment(QList<ParagraphStyle*> &pstyles)
459
{
12274 pierre 460
        if(pstyles.isEmpty())
461
        {
462
                qDebug()<<"Warning showAlignment called with an empty list of styles";
463
                return;
464
        }
10355 subik 465
        ParagraphStyle::AlignmentType a = pstyles[0]->alignment();
466
        for (int i = 0; i < pstyles.count(); ++i)
467
        {
468
                if (a != pstyles[i]->alignment())
469
                {
12274 pierre 470
                        if (alignement_->selectedId() > -1 && alignement_->selectedId() < 5)
10355 subik 471
                        {
472
                                alignement_->buttonGroup->setExclusive(false);
473
                                alignement_->buttonGroup->button(alignement_->selectedId())->toggle();
474
                                alignement_->buttonGroup->setExclusive(true);
475
                        }
476
                        return;
477
                }
478
        }
479
        alignement_->setStyle(a);
480
}
481
 
12828 pierre 482
void SMPStyleWidget::showOpticalMargin(QList< ParagraphStyle * > & pstyles)
483
{
484
        if(pstyles.isEmpty())
485
        {
486
                qDebug()<<"Warning showOpticalMargin called with an empty list of styles";
487
                return;
488
        }
12829 pierre 489
 
490
        optMarginCombo->clear();
491
        optMarginCombo->addItem(tr("None"), ParagraphStyle::OM_None);
492
        optMarginCombo->addItem(tr("Left Protruding"), ParagraphStyle::OM_LeftProtruding);
493
        optMarginCombo->addItem(tr("Right Protruding"), ParagraphStyle::OM_RightProtruding);
494
        optMarginCombo->addItem(tr("Left Hanging Punctuation"), ParagraphStyle::OM_LeftHangingPunct);
495
        optMarginCombo->addItem(tr("Right Hanging Punctuation"), ParagraphStyle::OM_RightHangingPunct);
496
        optMarginCombo->addItem(tr("Default"), ParagraphStyle::OM_Default);
497
 
12828 pierre 498
        // the static cast should not be required if opticalMargins() would return OpticalMarginType. Why it does not? mystery
499
        ParagraphStyle::OpticalMarginType o( static_cast<ParagraphStyle::OpticalMarginType>(pstyles[0]->opticalMargins()) );
500
        for (int i = 0; i < pstyles.count(); ++i)
501
        {
502
                if (o != pstyles[i]->opticalMargins())
503
                {
504
                        optMarginCombo->setCurrentItem(0);
505
                        return;
506
                }
507
        }
508
        optMarginCombo->setCurrentItemByData(o);
509
}
510
 
12829 pierre 511
void SMPStyleWidget::showMinSpace(QList< ParagraphStyle * > & pstyles)
512
{
513
        if(pstyles.isEmpty())
514
        {
515
                qDebug()<<"Warning showMinSpace called with an empty list of styles";
516
                return;
517
        }
518
 
519
        double ms(pstyles[0]->minWordTracking());
520
        for (int i = 0; i < pstyles.count(); ++i)
521
        {
522
                if (ms != pstyles[i]->minWordTracking())
523
                {
524
                        minSpaceSpin->setValue(100.0);
525
                        return;
526
                }
527
        }
528
        minSpaceSpin->setValue(ms * 100.0);
529
}
530
 
531
void SMPStyleWidget::showMinGlyphExt(QList< ParagraphStyle * > & pstyles)
532
{
533
        if(pstyles.isEmpty())
534
        {
535
                qDebug()<<"Warning showMinGlyphExt called with an empty list of styles";
536
                return;
537
        }
538
 
539
        double mge(pstyles[0]->minGlyphExtension());
540
        for (int i = 0; i < pstyles.count(); ++i)
541
        {
542
                if (mge != pstyles[i]->minGlyphExtension())
543
                {
544
                        minGlyphExtSpin->setValue(100.0);
545
                        return;
546
                }
547
        }
548
        minGlyphExtSpin->setValue(mge * 100.0);
549
}
550
 
551
void SMPStyleWidget::showMaxGlyphExt(QList< ParagraphStyle * > & pstyles)
552
{
553
        if(pstyles.isEmpty())
554
        {
555
                qDebug()<<"Warning showMaxGlyphExt called with an empty list of styles";
556
                return;
557
        }
558
 
559
        double mge(pstyles[0]->maxGlyphExtension());
560
        for (int i = 0; i < pstyles.count(); ++i)
561
        {
562
                if (mge != pstyles[i]->maxGlyphExtension())
563
                {
564
                        maxGlyphExtSpin->setValue(100.0);
565
                        return;
566
                }
567
        }
568
        maxGlyphExtSpin->setValue(mge * 100.0);
569
}
570
 
571
 
10355 subik 572
void SMPStyleWidget::showTabs(QList<ParagraphStyle*> &pstyles, int unitIndex)
573
{
574
        double unitRatio = unitGetRatioFromIndex(unitIndex);
575
        QList<ParagraphStyle::TabRecord> t = pstyles[0]->tabValues();
576
        for (int i = 0; i < pstyles.count(); ++i)
577
        {
578
                if (t != pstyles[i]->tabValues())
579
                {
580
                        t = QList<ParagraphStyle::TabRecord>();
581
                        break;
582
                }
583
        }
584
        tabList_->setTabs(t, unitIndex);
585
 
586
        double l = -4000.0;
587
        for (int i = 0; i < pstyles.count(); ++i)
588
        {
589
                if (l > -3800.0 && !isEqual(pstyles[i]->leftMargin(), l))
590
                {
591
                        l = -4000.0;
592
                        break;
593
                }
594
                else
595
                        l = pstyles[i]->leftMargin();
596
        }
597
        if (l < -3800.0)
598
        {
599
                tabList_->setLeftIndentValue(0.0);
600
                tabList_->left_->clear();
601
        }
602
        else
603
                tabList_->setLeftIndentValue(l * unitRatio);
604
 
605
        l = -4000.0;
606
        for (int i = 0; i < pstyles.count(); ++i)
607
        {
608
                if (l > -3800.0 && !isEqual(pstyles[i]->firstIndent(), l))
609
                {
610
                        l = -4000.0;
611
                        break;
612
                }
613
                else
614
                        l = pstyles[i]->firstIndent();
615
        }
616
        if (l < -3800.0)
617
        {
618
                tabList_->setFirstLineValue(0.0);
619
                tabList_->first_->clear();
620
        }
621
        else
622
                tabList_->setFirstLineValue(l * unitRatio);
623
 
624
        l = -4000.0;
625
        for (int i = 0; i < pstyles.count(); ++i)
626
        {
627
                if (l > -3800.0 && !isEqual(pstyles[i]->rightMargin(), l))
628
                {
629
                        l = -4000.0;
630
                        break;
631
                }
632
                else
633
                        l = pstyles[i]->rightMargin();
634
        }
635
        if (l < -3800.0)
636
        {
637
                tabList_->setRightIndentData(0.0);
638
                tabList_->right_->clear();
639
        }
640
        else
641
                tabList_->setRightIndentValue(l * unitRatio);
642
 
643
}
644
 
645
void SMPStyleWidget::showCStyle(QList<ParagraphStyle*> &pstyles, QList<CharStyle> &cstyles, const QString &defLang, int unitIndex)
646
{
647
        cpage->parentLabel->setText( tr("Based On:"));
648
 
649
        QList<CharStyle*> cstyle;
650
        for (int i = 0; i < pstyles.count(); ++i)
651
                cstyle << &pstyles[i]->charStyle();
652
 
653
        cpage->show(cstyle, cstyles, defLang, unitIndex);
654
}
655
 
656
void SMPStyleWidget::showParent(QList<ParagraphStyle*> &pstyles)
657
{
658
        parentCombo->setEnabled(false);
659
 
660
//      parentCombo->clear();
661
//      parentCombo->insertItem("");
662
//      for (uint i = 0; i < pstyles.count(); ++i)
663
//      {
664
//              if (pstyles[i].hasName() && pstyles[i].name() != pstyle->name())
665
//                      parentCombo->insertItem(pstyles[i].name());
666
//      }
667
// 
668
//      if (hasParent_)
669
//      {
670
//              int index = 0;
671
//              for (int i = 0; i < parentCombo->count(); ++i)
672
//              {
673
//                      if (parentCombo->text(i) == parent->name())
674
//                      {
675
//                              index = i;
676
//                              break;
677
//                      }
678
//              }
679
//              parentCombo->setCurrentItem(index);
680
//      }
681
//      else
682
//              parentCombo->setCurrentItem(0);
683
}
684
 
685
void SMPStyleWidget::clearAll()
686
{
687
 
688
}
689
 
690
void SMPStyleWidget::slotDropCap(bool isOn)
691
{
692
        if (isOn)
693
        {
694
                dropCapsBox->setEnabled(true);
695
                dropCapLines_->setEnabled(true);
696
                dropCapOffset_->setEnabled(true);
697
        }
698
        else
699
        {
700
                dropCapsBox->setEnabled(true);
701
                dropCapLines_->setEnabled(false);
702
                dropCapOffset_->setEnabled(false);
703
        }
704
        if (hasParent_)
705
                parentDropCapButton->show();
706
}
707
 
708
void SMPStyleWidget::slotParentDropCap()
709
{
710
        disconnect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
711
        disconnect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
712
        parentDropCapButton->hide();
713
        dropCapsBox->setChecked(parentDropCap_);
714
        emit useParentDropCap();
715
        connect(parentDropCapButton, SIGNAL(clicked()), this, SLOT(slotParentDropCap()));
716
        connect(dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
717
}
718
 
719
SMPStyleWidget::~SMPStyleWidget()
720
{
721
 
722
}
723
 
12828 pierre 724
 
12829 pierre 725