Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
5850 tsoots 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>
12283 cbradney 9
#include <QTabWidget>
10859 cbradney 10
 
5850 tsoots 11
#include "alignselect.h"
10862 cbradney 12
#include "colorcombo.h"
13
#include "commonstrings.h"
5850 tsoots 14
#include "fontcombo.h"
10862 cbradney 15
#include "menumanager.h"
16
#include "prefsmanager.h"
17
#include "propertiespalette.h"
5850 tsoots 18
#include "sccombobox.h"
10862 cbradney 19
#include "scribus.h"
5859 tsoots 20
#include "scribusdoc.h"
10862 cbradney 21
#include "scrspinbox.h"
5859 tsoots 22
#include "selection.h"
10862 cbradney 23
#include "shadebutton.h"
10339 subik 24
#include "smalignselect.h"
10862 cbradney 25
#include "smcolorcombo.h"
26
#include "smcstylewidget.h"
27
#include "smpstylewidget.h"
10339 subik 28
#include "smsccombobox.h"
10862 cbradney 29
#include "smshadebutton.h"
30
#include "smspinbox.h"
10339 subik 31
#include "smtabruler.h"
10862 cbradney 32
#include "smtextstyles.h"
33
#include "story.h"
34
#include "style.h"
35
#include "styleselect.h"
36
#include "tabruler.h"
37
#include "util.h"
5850 tsoots 38
 
10862 cbradney 39
 
7063 tsoots 40
SMParagraphStyle::SMParagraphStyle(StyleSet<CharStyle> *cstyles) : StyleItem(),
8453 tsoots 41
pwidget_(0), doc_(0), selectionIsDirty_(false), unitRatio_(1.0), cstyles_(cstyles)
5850 tsoots 42
{
7063 tsoots 43
        Q_ASSERT(cstyles_);
6093 tsoots 44
        pwidget_ = new SMPStyleWidget();
45
        Q_CHECK_PTR(pwidget_);
5850 tsoots 46
}
47
 
48
QTabWidget* SMParagraphStyle::widget()
49
{
50
        return pwidget_->tabWidget;
51
}
52
 
6029 tsoots 53
QString SMParagraphStyle::typeNamePlural()
5850 tsoots 54
{
55
        return tr("Paragraph Styles");
56
}
57
 
6029 tsoots 58
QString SMParagraphStyle::typeNameSingular()
59
{
6195 tsoots 60
        return tr("Paragraph Style");
6029 tsoots 61
}
62
 
12283 cbradney 63
void SMParagraphStyle::setCurrentDoc(ScribusDoc *doc)
5850 tsoots 64
{
5859 tsoots 65
        doc_ = doc;
6072 tsoots 66
        if (doc_)
6025 tsoots 67
        {
6072 tsoots 68
                if (pwidget_)
69
                {
7012 tsoots 70
                        pwidget_->cpage->fillLangCombo(doc_->scMW()->LangTransl);
6072 tsoots 71
                        pwidget_->cpage->fillColorCombo(doc_->PageColors);
6094 tsoots 72
                        pwidget_->cpage->fontFace_->RebuildList(doc_);
8453 tsoots 73
                        if (unitRatio_ != doc_->unitRatio())
74
                                unitChange();
6072 tsoots 75
                }
6025 tsoots 76
        }
6072 tsoots 77
        else
78
        {
79
                removeConnections();
80
                selection_.clear();
81
                tmpStyles_.clear();
7008 tsoots 82
                deleted_.clear();
6072 tsoots 83
        }
5850 tsoots 84
}
85
 
7063 tsoots 86
StyleSet<ParagraphStyle>* SMParagraphStyle::tmpStyles()
87
{
88
        return &tmpStyles_;
89
}
90
 
9790 avox 91
QList<StyleName> SMParagraphStyle::styles(bool reloadFromDoc)
5850 tsoots 92
{
9790 avox 93
        QList<StyleName> tmpList;
5850 tsoots 94
 
6019 tsoots 95
        if (!doc_)
96
                return tmpList; // no doc available
5859 tsoots 97
 
6051 tsoots 98
        if (reloadFromDoc)
6113 tsoots 99
        {
100
                deleted_.clear();
6051 tsoots 101
                reloadTmpStyles();
6113 tsoots 102
        }
6023 tsoots 103
 
10400 subik 104
        for (int i = 0; i < tmpStyles_.count(); ++i)
6019 tsoots 105
        {
6023 tsoots 106
                if (tmpStyles_[i].hasName())
6019 tsoots 107
                {
12283 cbradney 108
                        QString styleName(tmpStyles_[i].displayName());
8457 cbradney 109
                        QString parentName(QString::null);
5859 tsoots 110
 
7062 avox 111
                        if (tmpStyles_[i].hasParent() )
112
                                parentName = tmpStyles_[i].parent();
6019 tsoots 113
 
114
                        tmpList << StyleName(styleName, parentName);
115
                }
116
        }
117
 
5850 tsoots 118
        return tmpList;
119
}
120
 
6029 tsoots 121
void SMParagraphStyle::reload()
122
{
123
        reloadTmpStyles();
124
}
125
 
5850 tsoots 126
void SMParagraphStyle::selected(const QStringList &styleNames)
7063 tsoots 127
{
6072 tsoots 128
        if (!doc_)
129
                return;
130
 
6023 tsoots 131
        selection_.clear();
6025 tsoots 132
        selectionIsDirty_ = false;
6044 tsoots 133
        removeConnections(); // we don't want to record changes during style setup
6097 tsoots 134
 
7067 tsoots 135
        tmpStyles_.invalidate();
7064 tsoots 136
 
9790 avox 137
        QList<ParagraphStyle> pstyles; // get saved styles
138
        QList<CharStyle> cstyles;
10400 subik 139
        for (int i = 0; i < tmpStyles_.count(); ++i)
7063 tsoots 140
                pstyles << tmpStyles_[i];
10400 subik 141
        for (int i = 0; i < cstyles_->count(); ++i)
7063 tsoots 142
                cstyles << (*cstyles_)[i];
6097 tsoots 143
 
7008 tsoots 144
        int index;
8583 cbradney 145
        for (int i = 0; i < styleNames.count(); ++i)
6019 tsoots 146
        {
7008 tsoots 147
                index = tmpStyles_.find(styleNames[i]);
12395 cbradney 148
                //FIXME: #7133: Use .isDefaultStyle() instead here rather than relying on tr text comparison
149
                if (index<0 && styleNames[i]==CommonStrings::trDefaultParagraphStyle)
150
                        index = tmpStyles_.find(CommonStrings::DefaultParagraphStyle);
7008 tsoots 151
                if (index > -1)
152
                        selection_.append(&tmpStyles_[index]);
6019 tsoots 153
        }
7008 tsoots 154
 
9790 avox 155
        pwidget_->show(selection_, pstyles, cstyles, doc_->unitIndex(), PrefsManager::instance()->appPrefs.Language);
7008 tsoots 156
 
6025 tsoots 157
        setupConnections();
5850 tsoots 158
}
159
 
9790 avox 160
QList<CharStyle> SMParagraphStyle::getCharStyles()
6023 tsoots 161
{
9790 avox 162
        QList<CharStyle> charStyles;
6072 tsoots 163
        if (!doc_)
164
                return charStyles; // no doc available
165
 
7442 avox 166
        const StyleSet<CharStyle> &tmp(doc_->charStyles());
10400 subik 167
        for (int i = 0; i < tmp.count(); ++i)
6023 tsoots 168
                charStyles.append(tmp[i]);
169
        return charStyles;
170
}
171
 
5859 tsoots 172
QString SMParagraphStyle::fromSelection() const
173
{
8457 cbradney 174
        QString lsName(QString::null);
6072 tsoots 175
        if (!doc_)
176
                return lsName; // no doc available
5859 tsoots 177
 
10400 subik 178
        for (int i = 0; i < doc_->m_Selection->count(); ++i)
6044 tsoots 179
        {
180
                // wth is going on here
181
                PageItem *item = doc_->m_Selection->itemAt(i);
182
 
7032 avox 183
                QString tmpName = item->itemText.defaultStyle().parent();
6044 tsoots 184
 
8457 cbradney 185
                if (lsName.isNull() && !tmpName.isEmpty() && tmpName != "")
6044 tsoots 186
                {
187
                        lsName = tmpName;
188
                }
8457 cbradney 189
                else if (!lsName.isNull() && !tmpName.isEmpty() && tmpName != "" && lsName != tmpName)
6044 tsoots 190
                {
191
                        lsName = QString::null;
192
                        break;
193
                }
194
        }
6029 tsoots 195
        return lsName;
5859 tsoots 196
}
197
 
6044 tsoots 198
void SMParagraphStyle::toSelection(const QString &styleName) const
199
{
6819 tsoots 200
        if (!doc_)
6072 tsoots 201
                return; // nowhere to apply or no doc
6044 tsoots 202
 
7032 avox 203
        doc_->itemSelection_SetNamedParagraphStyle(styleName);
6044 tsoots 204
}
205
 
206
QString SMParagraphStyle::newStyle()
207
{
6072 tsoots 208
        if (!doc_)
209
                return QString::null;
210
 
8457 cbradney 211
        QString s(getUniqueName( tr("New Style")));
7032 avox 212
        ParagraphStyle p;
12283 cbradney 213
        p.setDefaultStyle(false);
6958 tsoots 214
        p.setName(s);
215
        tmpStyles_.create(p);
6044 tsoots 216
        return s;
217
}
218
 
6047 tsoots 219
QString SMParagraphStyle::newStyle(const QString &fromStyle)
220
{
6958 tsoots 221
        Q_ASSERT(tmpStyles_.resolve(fromStyle));
222
        if (!tmpStyles_.resolve(fromStyle))
223
                return QString::null;
6047 tsoots 224
 
8457 cbradney 225
        QString s(getUniqueName( tr("Clone of %1").arg(fromStyle)));
8641 cbradney 226
        ParagraphStyle p(tmpStyles_.get(fromStyle));
12283 cbradney 227
        p.setDefaultStyle(false);
6958 tsoots 228
        p.setName(s);
229
        p.setShortcut(QString::null); // do not clone the sc
230
        tmpStyles_.create(p);
6047 tsoots 231
 
232
        return s;
233
}
234
 
235
// helper function to find a unique name to a new style or a clone
236
QString SMParagraphStyle::getUniqueName(const QString &name)
237
{
238
        int id = 0;
239
        bool done = false;
8457 cbradney 240
        QString s(name);
6047 tsoots 241
 
242
        while (!done)
243
        {
244
start:
245
                ++id;
10400 subik 246
                for (int i = 0; i < tmpStyles_.count(); ++i)
6047 tsoots 247
                {
248
                        if (tmpStyles_[i].name() == s)
249
                        {
250
                                s = tr("%1 (%2)", "This for unique name when creating "
251
                                                "a new character style. %1 will be the name "
252
                                                                "of the style and %2 will be a number forming "
253
                                                                "a style name like: New Style (2)").arg(name).arg(id);
254
                                goto start;
255
                        }
256
                }
257
                done = true;
258
        }
259
 
260
        return s;
261
}
262
 
5850 tsoots 263
void SMParagraphStyle::apply()
264
{
6072 tsoots 265
        if (!doc_)
266
                return;
6051 tsoots 267
 
6066 tsoots 268
        QMap<QString, QString> replacement;
8583 cbradney 269
        for (int i = 0; i < deleted_.count(); ++i)
6066 tsoots 270
                replacement[deleted_[i].first] = deleted_[i].second;
271
 
8094 tsoots 272
        doc_->redefineStyles(tmpStyles_, false);
273
        doc_->replaceStyles(replacement);
6113 tsoots 274
 
275
        deleted_.clear(); // deletion done at this point
276
 
7990 cbradney 277
        doc_->scMW()->propertiesPalette->paraStyleCombo->updateFormatList();
7992 cbradney 278
        doc_->scMW()->propertiesPalette->charStyleCombo->updateFormatList();
12132 jghali 279
        // Better not call DrawNew() here, as this will cause several unnecessary calls
280
        // doc_->view()->DrawNew();
6066 tsoots 281
        doc_->changed();
6023 tsoots 282
}
5850 tsoots 283
 
6023 tsoots 284
void SMParagraphStyle::editMode(bool isOn)
285
{
286
        if (isOn)
287
                reloadTmpStyles();
5850 tsoots 288
}
289
 
12283 cbradney 290
bool SMParagraphStyle::isDefaultStyle(const QString &stylename) const
291
{
292
        int index = tmpStyles_.find(stylename);
293
        bool b=false;
294
        if (index > -1)
295
                b = tmpStyles_[index].isDefaultStyle();
296
        else
297
        {
298
                if (CommonStrings::trDefaultParagraphStyle==stylename)
299
                {
300
                        index = tmpStyles_.find(CommonStrings::DefaultParagraphStyle);
301
                        if (index > -1)
302
                                b = tmpStyles_[index].isDefaultStyle();
303
                }
304
        }
305
        return b;
306
}
307
 
308
void SMParagraphStyle::setDefaultStyle(bool ids)
309
{
310
        Q_ASSERT(selection_.count() == 1);
311
        if (selection_.count() != 1)
312
                return;
313
 
314
        selection_[0]->setDefaultStyle(ids);
315
 
316
        if (!selectionIsDirty_)
317
        {
318
                selectionIsDirty_ = true;
319
                emit selectionDirty();
320
        }
321
}
322
 
6949 tsoots 323
QString SMParagraphStyle::shortcut(const QString &stylename) const
324
{
8457 cbradney 325
        QString s(QString::null);
6949 tsoots 326
 
7008 tsoots 327
        int index = tmpStyles_.find(stylename);
328
        if (index > -1)
329
                s = tmpStyles_[index].shortcut();
330
 
6949 tsoots 331
        return s;
332
}
333
 
334
void SMParagraphStyle::setShortcut(const QString &shortcut)
335
{
336
        Q_ASSERT(selection_.count() == 1);
337
        if (selection_.count() != 1)
338
                return;
339
 
340
        selection_[0]->setShortcut(shortcut);
6951 tsoots 341
 
342
        if (!selectionIsDirty_)
343
        {
344
                selectionIsDirty_ = true;
345
                emit selectionDirty();
346
        }
6949 tsoots 347
}
348
 
9790 avox 349
void SMParagraphStyle::deleteStyles(const QList<RemoveItem> &removeList)
5850 tsoots 350
{
8583 cbradney 351
        for (int i = 0; i < removeList.count(); ++i)
6051 tsoots 352
        {
8583 cbradney 353
                for (int k = 0; k < selection_.count(); ++k)
6051 tsoots 354
                {
355
                        if (selection_[k]->name() == removeList[i].first)
356
                        {
9790 avox 357
                                selection_.removeAt(k);
6051 tsoots 358
                                break;
359
                        }
360
                }
6958 tsoots 361
 
362
                int index = tmpStyles_.find(removeList[i].first);
363
                if (index > -1)
364
                        tmpStyles_.remove(index);
365
 
6051 tsoots 366
                deleted_.append(removeList[i]);
367
        }
5850 tsoots 368
}
369
 
370
void SMParagraphStyle::nameChanged(const QString &newName)
371
{
6072 tsoots 372
        if (selection_.count() != 1)
373
                return;
5850 tsoots 374
 
8457 cbradney 375
        QString oldName(selection_[0]->name());
6958 tsoots 376
        ParagraphStyle p(*selection_[0]);
377
        p.setName(newName);
378
        tmpStyles_.create(p);
6072 tsoots 379
        selection_.clear();
6958 tsoots 380
        selection_.append(&tmpStyles_[tmpStyles_.find(newName)]);
10400 subik 381
        for (int j = 0; j < tmpStyles_.count(); ++j)
6072 tsoots 382
        {
6958 tsoots 383
                int index = tmpStyles_.find(oldName);
384
                if (index > -1)
6072 tsoots 385
                {
6958 tsoots 386
                        tmpStyles_.remove(index);
6072 tsoots 387
                        break;
388
                }
389
        }
390
 
10400 subik 391
        for (int j = 0; j < tmpStyles_.count(); ++j)
8125 tsoots 392
        {
393
                if (tmpStyles_[j].parent() == oldName)
394
                        tmpStyles_[j].setParent(newName);
395
        }
396
 
9790 avox 397
        QList<RemoveItem>::iterator it;
6072 tsoots 398
        for (it = deleted_.begin(); it != deleted_.end(); ++it)
399
        {
400
                if ((*it).second == oldName)
401
                {
402
                        oldName = (*it).first;
10585 fschmid 403
                        deleted_.erase(it);
6072 tsoots 404
                        break;
405
                }
406
        }
407
 
408
        deleted_.append(RemoveItem(oldName, newName));
409
 
6029 tsoots 410
        if (!selectionIsDirty_)
411
        {
412
                selectionIsDirty_ = true;
413
                emit selectionDirty();
414
        }
5850 tsoots 415
}
416
 
6025 tsoots 417
void SMParagraphStyle::languageChange()
418
{
6044 tsoots 419
        if (pwidget_)
420
        {
421
                pwidget_->languageChange();
422
                pwidget_->cpage->languageChange();
423
        }
6025 tsoots 424
}
425
 
8453 tsoots 426
void SMParagraphStyle::unitChange()
427
{
428
        double oldRatio = unitRatio_;
429
        unitRatio_ = doc_->unitRatio();
430
        pwidget_->unitChange(oldRatio, unitRatio_, doc_->unitIndex());
431
}
432
 
6023 tsoots 433
void SMParagraphStyle::reloadTmpStyles()
5850 tsoots 434
{
6051 tsoots 435
        if (!doc_)
436
                return;
6072 tsoots 437
 
6023 tsoots 438
        selection_.clear();
439
        tmpStyles_.clear();
7008 tsoots 440
        deleted_.clear();
7442 avox 441
        tmpStyles_.redefine(doc_->paragraphStyles(), true);
7063 tsoots 442
        Q_ASSERT(tmpStyles_.count() > 0);
8134 avox 443
        tmpStyles_[0].charStyle().setContext(cstyles_);
5850 tsoots 444
}
445
 
6025 tsoots 446
void SMParagraphStyle::setupConnections()
447
{
6072 tsoots 448
        if (!pwidget_)
449
                return;
6025 tsoots 450
 
451
        // paragraph attributes
6093 tsoots 452
        connect(pwidget_->lineSpacingMode_, SIGNAL(activated(int)), this, SLOT(slotLineSpacingMode(int)));
8687 cbradney 453
        connect(pwidget_->lineSpacing_, SIGNAL(valueChanged(double)), this, SLOT(slotLineSpacing()));
454
        connect(pwidget_->spaceAbove_, SIGNAL(valueChanged(double)), this, SLOT(slotSpaceAbove()));
455
        connect(pwidget_->spaceBelow_, SIGNAL(valueChanged(double)), this, SLOT(slotSpaceBelow()));
6025 tsoots 456
        connect(pwidget_->alignement_->TextL, SIGNAL(clicked()), this, SLOT(slotAlignment()));
457
        connect(pwidget_->alignement_->TextR, SIGNAL(clicked()), this, SLOT(slotAlignment()));
458
        connect(pwidget_->alignement_->TextC, SIGNAL(clicked()), this, SLOT(slotAlignment()));
459
        connect(pwidget_->alignement_->TextB, SIGNAL(clicked()), this, SLOT(slotAlignment()));
460
        connect(pwidget_->alignement_->TextF, SIGNAL(clicked()), this, SLOT(slotAlignment()));
6099 tsoots 461
        connect(pwidget_->alignement_->parentButton, SIGNAL(clicked()), this, SLOT(slotAlignment()));
6025 tsoots 462
 
6111 tsoots 463
        connect(pwidget_, SIGNAL(useParentDropCap()), this, SLOT(slotParentDropCap()));
6025 tsoots 464
        connect(pwidget_->dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
465
        connect(pwidget_->dropCapLines_, SIGNAL(valueChanged(int)), this, SLOT(slotDropCapLines(int)));
8687 cbradney 466
        connect(pwidget_->dropCapOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotDropCapOffset()));
6025 tsoots 467
 
468
        connect(pwidget_->tabList_, SIGNAL(tabsChanged()), this, SLOT(slotTabRuler()));
6107 tsoots 469
        connect(pwidget_->tabList_, SIGNAL(mouseReleased()), this, SLOT(slotTabRuler()));
8687 cbradney 470
        connect(pwidget_->tabList_->left_, SIGNAL(valueChanged(double)), this, SLOT(slotLeftIndent()));
471
        connect(pwidget_->tabList_->right_, SIGNAL(valueChanged(double)), this, SLOT(slotRightIndent()));
472
        connect(pwidget_->tabList_->first_, SIGNAL(valueChanged(double)), this, SLOT(slotFirstLine()));
6091 tsoots 473
 
474
        connect(pwidget_->parentCombo, SIGNAL(activated(const QString&)),
475
                        this, SLOT(slotParentChanged(const QString&)));
476
 
6025 tsoots 477
        // character attributes
478
        connect(pwidget_->cpage->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
479
        connect(pwidget_->cpage->effects_, SIGNAL(State(int)), this, SLOT(slotEffects(int)));
8687 cbradney 480
        connect(pwidget_->cpage->effects_->ShadowVal->Xoffset, SIGNAL(valueChanged(double)),
6100 tsoots 481
                        this, SLOT(slotEffectProperties()));
8687 cbradney 482
        connect(pwidget_->cpage->effects_->ShadowVal->Yoffset, SIGNAL(valueChanged(double)),
6100 tsoots 483
                        this, SLOT(slotEffectProperties()));
8687 cbradney 484
        connect(pwidget_->cpage->effects_->OutlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 485
                        this, SLOT(slotEffectProperties()));
8687 cbradney 486
        connect(pwidget_->cpage->effects_->UnderlineVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 487
                        this, SLOT(slotEffectProperties()));
8687 cbradney 488
        connect(pwidget_->cpage->effects_->UnderlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 489
                        this, SLOT(slotEffectProperties()));
8687 cbradney 490
        connect(pwidget_->cpage->effects_->StrikeVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 491
                        this, SLOT(slotEffectProperties()));
8687 cbradney 492
        connect(pwidget_->cpage->effects_->StrikeVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 493
                        this, SLOT(slotEffectProperties()));
494
        connect(pwidget_->cpage->fillColor_, SIGNAL(activated(const QString&)), this, SLOT(slotFillColor()));
6025 tsoots 495
        connect(pwidget_->cpage->fillShade_, SIGNAL(clicked()), this, SLOT(slotFillShade()));
6100 tsoots 496
        connect(pwidget_->cpage->strokeColor_, SIGNAL(activated(const QString&)), this, SLOT(slotStrokeColor()));
6025 tsoots 497
        connect(pwidget_->cpage->strokeShade_, SIGNAL(clicked()), this, SLOT(slotStrokeShade()));
6093 tsoots 498
        connect(pwidget_->cpage->language_, SIGNAL(activated(int)), this, SLOT(slotLanguage()));
8687 cbradney 499
        connect(pwidget_->cpage->fontSize_, SIGNAL(valueChanged(double)), this, SLOT(slotFontSize()));
500
        connect(pwidget_->cpage->fontHScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleH()));
501
        connect(pwidget_->cpage->fontVScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleV()));
502
        connect(pwidget_->cpage->tracking_, SIGNAL(valueChanged(double)), this, SLOT(slotTracking()));
503
        connect(pwidget_->cpage->baselineOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotBaselineOffset()));
6025 tsoots 504
        connect(pwidget_->cpage->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
6091 tsoots 505
        connect(pwidget_->cpage->parentCombo, SIGNAL(activated(const QString&)),
506
                        this, SLOT(slotCharParentChanged(const QString&)));
6025 tsoots 507
}
508
 
509
void SMParagraphStyle::removeConnections()
510
{
6072 tsoots 511
        if (!pwidget_)
512
                return;
6025 tsoots 513
 
6093 tsoots 514
        disconnect(pwidget_->lineSpacingMode_, SIGNAL(activated(int)), this, SLOT(slotLineSpacingMode(int)));
8687 cbradney 515
        disconnect(pwidget_->lineSpacing_, SIGNAL(valueChanged(double)), this, SLOT(slotLineSpacing()));
516
        disconnect(pwidget_->spaceAbove_, SIGNAL(valueChanged(double)), this, SLOT(slotSpaceAbove()));
517
        disconnect(pwidget_->spaceBelow_, SIGNAL(valueChanged(double)), this, SLOT(slotSpaceBelow()));
6025 tsoots 518
        disconnect(pwidget_->alignement_->TextL, SIGNAL(clicked()), this, SLOT(slotAlignment()));
519
        disconnect(pwidget_->alignement_->TextR, SIGNAL(clicked()), this, SLOT(slotAlignment()));
520
        disconnect(pwidget_->alignement_->TextC, SIGNAL(clicked()), this, SLOT(slotAlignment()));
521
        disconnect(pwidget_->alignement_->TextB, SIGNAL(clicked()), this, SLOT(slotAlignment()));
522
        disconnect(pwidget_->alignement_->TextF, SIGNAL(clicked()), this, SLOT(slotAlignment()));
6099 tsoots 523
        disconnect(pwidget_->alignement_->parentButton, SIGNAL(clicked()), this, SLOT(slotAlignment()));
6025 tsoots 524
 
6111 tsoots 525
        disconnect(pwidget_, SIGNAL(useParentDropCap()), this, SLOT(slotParentDropCap()));
6025 tsoots 526
        disconnect(pwidget_->dropCapsBox, SIGNAL(toggled(bool)), this, SLOT(slotDropCap(bool)));
527
        disconnect(pwidget_->dropCapLines_, SIGNAL(valueChanged(int)), this, SLOT(slotDropCapLines(int)));
8687 cbradney 528
        disconnect(pwidget_->dropCapOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotDropCapOffset()));
6025 tsoots 529
 
6091 tsoots 530
        disconnect(pwidget_->parentCombo, SIGNAL(activated(const QString&)),
531
                        this, SLOT(slotParentChanged(const QString&)));
532
 
6025 tsoots 533
        disconnect(pwidget_->tabList_, SIGNAL(tabsChanged()), this, SLOT(slotTabRuler()));
8687 cbradney 534
        disconnect(pwidget_->tabList_->left_, SIGNAL(valueChanged(double)), this, SLOT(slotLeftIndent()));
535
        disconnect(pwidget_->tabList_->right_, SIGNAL(valueChanged(double)), this, SLOT(slotRightIndent()));
536
        disconnect(pwidget_->tabList_->first_, SIGNAL(valueChanged(double)), this, SLOT(slotFirstLine()));
6029 tsoots 537
 
538
        disconnect(pwidget_->cpage->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
539
        disconnect(pwidget_->cpage->effects_, SIGNAL(State(int)), this, SLOT(slotEffects(int)));
8687 cbradney 540
        disconnect(pwidget_->cpage->effects_->ShadowVal->Xoffset, SIGNAL(valueChanged(double)),
6100 tsoots 541
                        this, SLOT(slotEffectProperties()));
8687 cbradney 542
        disconnect(pwidget_->cpage->effects_->ShadowVal->Yoffset, SIGNAL(valueChanged(double)),
6100 tsoots 543
                        this, SLOT(slotEffectProperties()));
8687 cbradney 544
        disconnect(pwidget_->cpage->effects_->OutlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 545
                        this, SLOT(slotEffectProperties()));
8687 cbradney 546
        disconnect(pwidget_->cpage->effects_->UnderlineVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 547
                        this, SLOT(slotEffectProperties()));
8687 cbradney 548
        disconnect(pwidget_->cpage->effects_->UnderlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 549
                        this, SLOT(slotEffectProperties()));
8687 cbradney 550
        disconnect(pwidget_->cpage->effects_->StrikeVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 551
                        this, SLOT(slotEffectProperties()));
8687 cbradney 552
        disconnect(pwidget_->cpage->effects_->StrikeVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 553
                        this, SLOT(slotEffectProperties()));
554
        disconnect(pwidget_->cpage->fillColor_, SIGNAL(activated(const QString&)), this, SLOT(slotFillColor()));
6029 tsoots 555
        disconnect(pwidget_->cpage->fillShade_, SIGNAL(clicked()), this, SLOT(slotFillShade()));
6100 tsoots 556
        disconnect(pwidget_->cpage->strokeColor_, SIGNAL(activated(const QString&)), this, SLOT(slotStrokeColor()));
6029 tsoots 557
        disconnect(pwidget_->cpage->strokeShade_, SIGNAL(clicked()), this, SLOT(slotStrokeShade()));
6093 tsoots 558
        disconnect(pwidget_->cpage->language_, SIGNAL(activated(int)), this, SLOT(slotLanguage()));
8687 cbradney 559
        disconnect(pwidget_->cpage->fontSize_, SIGNAL(valueChanged(double)), this, SLOT(slotFontSize()));
560
        disconnect(pwidget_->cpage->fontHScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleH()));
561
        disconnect(pwidget_->cpage->fontVScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleV()));
562
        disconnect(pwidget_->cpage->tracking_, SIGNAL(valueChanged(double)), this, SLOT(slotTracking()));
563
        disconnect(pwidget_->cpage->baselineOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotBaselineOffset()));
6029 tsoots 564
        disconnect(pwidget_->cpage->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
6091 tsoots 565
        disconnect(pwidget_->cpage->parentCombo, SIGNAL(activated(const QString&)),
566
                        this, SLOT(slotCharParentChanged(const QString&)));
6025 tsoots 567
}
568
 
569
void SMParagraphStyle::slotLineSpacingMode(int mode)
570
{
6733 avox 571
        ParagraphStyle::LineSpacingMode lsm = static_cast<ParagraphStyle::LineSpacingMode>(mode);
572
 
6093 tsoots 573
        if (pwidget_->lineSpacingMode_->useParentValue())
8583 cbradney 574
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 575
                        selection_[i]->resetLineSpacingMode();
6093 tsoots 576
        else
8583 cbradney 577
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 578
                        selection_[i]->setLineSpacingMode(lsm);
6093 tsoots 579
 
6025 tsoots 580
        if (!selectionIsDirty_)
581
        {
582
                selectionIsDirty_ = true;
583
                emit selectionDirty();
584
        }
585
}
586
 
587
void SMParagraphStyle::slotLineSpacing()
588
{
6091 tsoots 589
        if (pwidget_->lineSpacing_->useParentValue())
8583 cbradney 590
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 591
                        selection_[i]->resetLineSpacing();
8457 cbradney 592
        else
593
        {
594
                double a, b, value;
595
                int c;
596
 
6091 tsoots 597
                pwidget_->lineSpacing_->getValues(&a, &b, &c, &value);
8583 cbradney 598
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 599
                        selection_[i]->setLineSpacing(value);
600
        }
601
 
6025 tsoots 602
        if (!selectionIsDirty_)
603
        {
604
                selectionIsDirty_ = true;
605
                emit selectionDirty();
606
        }
607
}
608
 
609
void SMParagraphStyle::slotSpaceAbove()
610
{
6091 tsoots 611
        if (pwidget_->spaceAbove_->useParentValue())
8583 cbradney 612
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 613
                        selection_[i]->resetGapBefore();
8457 cbradney 614
        else
615
        {
616
                double a, b, value;
617
                int c;
618
 
6091 tsoots 619
                pwidget_->spaceAbove_->getValues(&a, &b, &c, &value);
8583 cbradney 620
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 621
                        selection_[i]->setGapBefore(value);
622
        }
623
 
6025 tsoots 624
        if (!selectionIsDirty_)
625
        {
626
                selectionIsDirty_ = true;
627
                emit selectionDirty();
628
        }
629
}
630
 
631
void SMParagraphStyle::slotSpaceBelow()
632
{
6091 tsoots 633
        if (pwidget_->spaceBelow_->useParentValue())
8583 cbradney 634
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 635
                        selection_[i]->resetGapAfter();
8457 cbradney 636
        else
637
        {
638
                double a, b, value;
639
                int c;
640
 
6091 tsoots 641
                pwidget_->spaceBelow_->getValues(&a, &b, &c, &value);
8583 cbradney 642
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 643
                        selection_[i]->setGapAfter(value);
644
        }
645
 
6025 tsoots 646
        if (!selectionIsDirty_)
647
        {
648
                selectionIsDirty_ = true;
649
                emit selectionDirty();
650
        }
651
}
652
 
653
void SMParagraphStyle::slotAlignment()
654
{
6733 avox 655
        ParagraphStyle::AlignmentType style = static_cast<ParagraphStyle::AlignmentType>(pwidget_->alignement_->getStyle());
6099 tsoots 656
        if (pwidget_->alignement_->useParentValue())
8583 cbradney 657
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 658
                        selection_[i]->resetAlignment();
659
        else
8583 cbradney 660
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 661
                        selection_[i]->setAlignment(style);
6099 tsoots 662
 
6025 tsoots 663
        if (!selectionIsDirty_)
664
        {
665
                selectionIsDirty_ = true;
666
                emit selectionDirty();
667
        }
668
}
669
 
670
void SMParagraphStyle::slotDropCap(bool isOn)
671
{
8583 cbradney 672
        for (int i = 0; i < selection_.count(); ++i)
6025 tsoots 673
                selection_[i]->setHasDropCap(isOn);
674
 
675
        if (!selectionIsDirty_)
676
        {
677
                selectionIsDirty_ = true;
678
                emit selectionDirty();
679
        }
680
}
681
 
6111 tsoots 682
void SMParagraphStyle::slotParentDropCap()
683
{
8583 cbradney 684
        for (int i = 0; i < selection_.count(); ++i)
6733 avox 685
                selection_[i]->resetHasDropCap();
6111 tsoots 686
 
687
        if (!selectionIsDirty_)
688
        {
689
                selectionIsDirty_ = true;
690
                emit selectionDirty();
691
        }
692
}
693
 
6025 tsoots 694
void SMParagraphStyle::slotDropCapLines(int lines)
695
{
6733 avox 696
        if (pwidget_->dropCapLines_->useParentValue())
8583 cbradney 697
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 698
                        selection_[i]->resetDropCapLines();
699
        else           
8583 cbradney 700
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 701
                        selection_[i]->setDropCapLines(lines);
6092 tsoots 702
 
6025 tsoots 703
        if (!selectionIsDirty_)
704
        {
705
                selectionIsDirty_ = true;
706
                emit selectionDirty();
707
        }
708
}
709
 
710
void SMParagraphStyle::slotDropCapOffset()
711
{
6091 tsoots 712
        if (pwidget_->dropCapOffset_->useParentValue())
8583 cbradney 713
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 714
                        selection_[i]->resetDropCapOffset();
8457 cbradney 715
        else
716
        {
717
                double a, b, value;
718
                int c;
719
 
6091 tsoots 720
                pwidget_->dropCapOffset_->getValues(&a, &b, &c, &value);
8453 tsoots 721
                value = value / unitRatio_;
8583 cbradney 722
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 723
                        selection_[i]->setDropCapOffset(value);
724
        }
725
 
6025 tsoots 726
        if (!selectionIsDirty_)
727
        {
728
                selectionIsDirty_ = true;
729
                emit selectionDirty();
730
        }
731
}
732
 
733
void SMParagraphStyle::slotTabRuler()
734
{
6107 tsoots 735
        if (pwidget_->tabList_->useParentTabs())
6025 tsoots 736
        {
8583 cbradney 737
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 738
                        selection_[i]->resetTabValues();
6025 tsoots 739
        }
6107 tsoots 740
        else
741
        {
9790 avox 742
                QList<ParagraphStyle::TabRecord> newTabs = pwidget_->tabList_->getTabVals();
8583 cbradney 743
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 744
                        selection_[i]->setTabValues(newTabs);
6107 tsoots 745
        }
6025 tsoots 746
 
747
        if (!selectionIsDirty_)
748
        {
749
                selectionIsDirty_ = true;
750
                emit selectionDirty();
751
        }
752
}
753
 
6107 tsoots 754
void SMParagraphStyle::slotLeftIndent()
6025 tsoots 755
{
6107 tsoots 756
        if (pwidget_->tabList_->useParentLeftIndent())
8583 cbradney 757
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 758
                        selection_[i]->resetLeftMargin();
8457 cbradney 759
        else
760
        {
761
                double a, b, value;
762
                int c;
763
 
6107 tsoots 764
                pwidget_->tabList_->left_->getValues(&a, &b, &c, &value);
8453 tsoots 765
                value = value / unitRatio_;
8583 cbradney 766
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 767
                        selection_[i]->setLeftMargin(value);
768
        }
769
 
6025 tsoots 770
        if (!selectionIsDirty_)
771
        {
772
                selectionIsDirty_ = true;
773
                emit selectionDirty();
774
        }
775
}
776
 
6107 tsoots 777
void SMParagraphStyle::slotRightIndent()
6025 tsoots 778
{
6107 tsoots 779
        if (pwidget_->tabList_->useParentRightIndent())
8583 cbradney 780
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 781
                        selection_[i]->resetRightMargin();
8457 cbradney 782
        else
783
        {
784
                double a, b, value;
785
                int c;
786
 
6107 tsoots 787
                pwidget_->tabList_->right_->getValues(&a, &b, &c, &value);
8453 tsoots 788
                value = value / unitRatio_;
8583 cbradney 789
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 790
                        selection_[i]->setRightMargin(value);
791
        }
792
 
6025 tsoots 793
        if (!selectionIsDirty_)
794
        {
795
                selectionIsDirty_ = true;
796
                emit selectionDirty();
797
        }
798
}
799
 
6107 tsoots 800
void SMParagraphStyle::slotFirstLine()
6025 tsoots 801
{
6107 tsoots 802
        if (pwidget_->tabList_->useParentFirstLine())
8583 cbradney 803
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 804
                        selection_[i]->resetFirstIndent();
8457 cbradney 805
        else
806
        {
807
                double a, b, value;
808
                int c;
809
 
6107 tsoots 810
                pwidget_->tabList_->first_->getValues(&a, &b, &c, &value);
8453 tsoots 811
                value = value / unitRatio_;
8583 cbradney 812
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 813
                        selection_[i]->setFirstIndent(value);
814
        }
815
 
6025 tsoots 816
        if (!selectionIsDirty_)
817
        {
818
                selectionIsDirty_ = true;
819
                emit selectionDirty();
820
        }
821
}
822
 
823
void SMParagraphStyle::slotFontSize()
824
{
6091 tsoots 825
        if (pwidget_->cpage->fontSize_->useParentValue())
8583 cbradney 826
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 827
                        selection_[i]->charStyle().resetFontSize();
6091 tsoots 828
        else
6100 tsoots 829
        {
8457 cbradney 830
                double a, b, value;
831
                int c;
832
 
6091 tsoots 833
                pwidget_->cpage->fontSize_->getValues(&a, &b, &c, &value);
6100 tsoots 834
                value = value * 10;
8583 cbradney 835
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 836
                        selection_[i]->charStyle().setFontSize(qRound(value));
6100 tsoots 837
        }
6025 tsoots 838
 
839
 
840
        if (!selectionIsDirty_)
841
        {
842
                selectionIsDirty_ = true;
843
                emit selectionDirty();
844
        }
845
}
846
 
847
void SMParagraphStyle::slotEffects(int e)
848
{
6100 tsoots 849
        StyleFlag s = ScStyle_None;
850
        if (pwidget_->cpage->effects_->useParentValue())
851
        {
8583 cbradney 852
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 853
                {
9607 avox 854
                        selection_[i]->charStyle().resetFeatures();
6733 avox 855
                        selection_[i]->charStyle().resetShadowXOffset();
856
                        selection_[i]->charStyle().resetShadowYOffset();
857
                        selection_[i]->charStyle().resetOutlineWidth();
858
                        selection_[i]->charStyle().resetUnderlineOffset();
859
                        selection_[i]->charStyle().resetUnderlineWidth();
860
                        selection_[i]->charStyle().resetStrikethruOffset();
861
                        selection_[i]->charStyle().resetStrikethruWidth();
862
                }
6100 tsoots 863
        }
864
        else
865
        {
8457 cbradney 866
                double a, b, sxo, syo, olw, ulp, ulw, slp, slw;
867
                int c;
868
 
6100 tsoots 869
                s = static_cast<StyleFlag>(e);
870
                pwidget_->cpage->effects_->ShadowVal->Xoffset->getValues(&a, &b, &c, &sxo);
8457 cbradney 871
                sxo *= 10;
6100 tsoots 872
                pwidget_->cpage->effects_->ShadowVal->Yoffset->getValues(&a, &b, &c, &syo);
8457 cbradney 873
                syo *= 10;
6100 tsoots 874
 
875
                pwidget_->cpage->effects_->OutlineVal->LWidth->getValues(&a, &b, &c, &olw);
8457 cbradney 876
                olw *= 10;
6100 tsoots 877
 
878
                pwidget_->cpage->effects_->UnderlineVal->LPos->getValues(&a, &b, &c, &ulp);
8457 cbradney 879
                ulp *= 10;
6100 tsoots 880
                pwidget_->cpage->effects_->UnderlineVal->LWidth->getValues(&a, &b, &c, &ulw);
8457 cbradney 881
                ulw *= 10;
6100 tsoots 882
 
883
                pwidget_->cpage->effects_->StrikeVal->LPos->getValues(&a, &b, &c, &slp);
8457 cbradney 884
                slp *= 10;
6100 tsoots 885
                pwidget_->cpage->effects_->StrikeVal->LWidth->getValues(&a, &b, &c, &slw);
8457 cbradney 886
                slw *= 10;
6100 tsoots 887
 
8583 cbradney 888
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 889
                {
9607 avox 890
                        selection_[i]->charStyle().setFeatures(s.featureList());
6733 avox 891
                        selection_[i]->charStyle().setShadowXOffset(qRound(sxo));
892
                        selection_[i]->charStyle().setShadowYOffset(qRound(syo));
893
                        selection_[i]->charStyle().setOutlineWidth(qRound(olw));
894
                        selection_[i]->charStyle().setUnderlineOffset(qRound(ulp));
895
                        selection_[i]->charStyle().setUnderlineWidth(qRound(ulw));
896
                        selection_[i]->charStyle().setStrikethruOffset(qRound(slp));
897
                        selection_[i]->charStyle().setStrikethruWidth(qRound(slw));
898
                }
6100 tsoots 899
        }
900
 
6733 avox 901
 
6100 tsoots 902
        if (!selectionIsDirty_)
903
        {
904
                selectionIsDirty_ = true;
905
                emit selectionDirty();
906
        }
907
}
908
 
909
void SMParagraphStyle::slotEffectProperties()
910
{
911
        double a, b, sxo, syo, olw, ulp, ulw, slp, slw;
912
        int c;
913
 
6029 tsoots 914
        pwidget_->cpage->effects_->ShadowVal->Xoffset->getValues(&a, &b, &c, &sxo);
8457 cbradney 915
        sxo *= 10;
6029 tsoots 916
        pwidget_->cpage->effects_->ShadowVal->Yoffset->getValues(&a, &b, &c, &syo);
8457 cbradney 917
        syo *= 10;
6029 tsoots 918
 
919
        pwidget_->cpage->effects_->OutlineVal->LWidth->getValues(&a, &b, &c, &olw);
8457 cbradney 920
        olw *= 10;
6029 tsoots 921
 
922
        pwidget_->cpage->effects_->UnderlineVal->LPos->getValues(&a, &b, &c, &ulp);
8457 cbradney 923
        ulp *= 10;
6029 tsoots 924
        pwidget_->cpage->effects_->UnderlineVal->LWidth->getValues(&a, &b, &c, &ulw);
8457 cbradney 925
        ulw *= 10;
6029 tsoots 926
 
927
        pwidget_->cpage->effects_->StrikeVal->LPos->getValues(&a, &b, &c, &slp);
8457 cbradney 928
        slp *= 10;
6029 tsoots 929
        pwidget_->cpage->effects_->StrikeVal->LWidth->getValues(&a, &b, &c, &slw);
8457 cbradney 930
        slw *= 10;
6100 tsoots 931
 
8583 cbradney 932
        for (int i = 0; i < selection_.count(); ++i)
6029 tsoots 933
        {
6091 tsoots 934
                selection_[i]->charStyle().setShadowXOffset(qRound(sxo));
935
                selection_[i]->charStyle().setShadowYOffset(qRound(syo));
936
                selection_[i]->charStyle().setOutlineWidth(qRound(olw));
937
                selection_[i]->charStyle().setUnderlineOffset(qRound(ulp));
938
                selection_[i]->charStyle().setUnderlineWidth(qRound(ulw));
939
                selection_[i]->charStyle().setStrikethruOffset(qRound(slp));
940
                selection_[i]->charStyle().setStrikethruWidth(qRound(slw));
6029 tsoots 941
        }
6025 tsoots 942
 
943
        if (!selectionIsDirty_)
944
        {
945
                selectionIsDirty_ = true;
946
                emit selectionDirty();
947
        }
948
}
949
 
950
void SMParagraphStyle::slotFillColor()
951
{
6733 avox 952
        if (pwidget_->cpage->fillColor_->useParentValue())
8583 cbradney 953
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 954
                        selection_[i]->charStyle().resetFillColor();
955
        else {
8457 cbradney 956
                QString c( pwidget_->cpage->fillColor_->currentText());
8583 cbradney 957
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 958
                        selection_[i]->charStyle().setFillColor(c);
959
        }
960
 
6025 tsoots 961
        if (!selectionIsDirty_)
962
        {
963
                selectionIsDirty_ = true;
964
                emit selectionDirty();
965
        }
966
}
967
 
968
void SMParagraphStyle::slotFillShade()
969
{
6733 avox 970
        if (pwidget_->cpage->fillShade_->useParentValue())
8583 cbradney 971
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 972
                        selection_[i]->charStyle().resetFillShade();
973
        else {
8457 cbradney 974
                int fs = pwidget_->cpage->fillShade_->getValue();
6100 tsoots 975
 
8583 cbradney 976
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 977
                        selection_[i]->charStyle().setFillShade(fs);
978
        }
979
 
6025 tsoots 980
        if (!selectionIsDirty_)
981
        {
982
                selectionIsDirty_ = true;
983
                emit selectionDirty();
984
        }
985
}
986
 
987
void SMParagraphStyle::slotStrokeColor()
988
{
6733 avox 989
        if (pwidget_->cpage->strokeColor_->useParentValue())
8583 cbradney 990
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 991
                        selection_[i]->charStyle().resetStrokeColor();
992
        else {
8457 cbradney 993
                QString c(pwidget_->cpage->strokeColor_->currentText());
6101 tsoots 994
 
8583 cbradney 995
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 996
                        selection_[i]->charStyle().setStrokeColor(c);
997
        }
998
 
6025 tsoots 999
        if (!selectionIsDirty_)
1000
        {
1001
                selectionIsDirty_ = true;
1002
                emit selectionDirty();
1003
        }
1004
}
1005
 
1006
void SMParagraphStyle::slotStrokeShade()
1007
{
6733 avox 1008
        if (pwidget_->cpage->strokeShade_->useParentValue())
8583 cbradney 1009
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1010
                        selection_[i]->charStyle().resetStrokeShade();
8457 cbradney 1011
        else
1012
        {
1013
                int ss = pwidget_->cpage->strokeShade_->getValue();
6100 tsoots 1014
 
8583 cbradney 1015
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1016
                        selection_[i]->charStyle().setStrokeShade(ss);
1017
        }
1018
 
6025 tsoots 1019
        if (!selectionIsDirty_)
1020
        {
1021
                selectionIsDirty_ = true;
1022
                emit selectionDirty();
1023
        }
1024
}
1025
 
1026
void SMParagraphStyle::slotLanguage()
1027
{
6029 tsoots 1028
        QMap<QString,QString>::Iterator it;
7442 avox 1029
        QString language = doc_->paragraphStyle("").charStyle().language();
6029 tsoots 1030
 
6093 tsoots 1031
        if (pwidget_->cpage->language_->useParentValue())
8583 cbradney 1032
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1033
                        selection_[i]->charStyle().resetLanguage();
6093 tsoots 1034
        else
6029 tsoots 1035
        {
6093 tsoots 1036
                for (it = doc_->scMW()->LangTransl.begin(); it != doc_->scMW()->LangTransl.end(); ++it)
6029 tsoots 1037
                {
10516 cbradney 1038
                        if (it.value() == pwidget_->cpage->language_->currentText())
6093 tsoots 1039
                        {
1040
                                language = it.key();
1041
                                break;
1042
                        }
6029 tsoots 1043
                }
8583 cbradney 1044
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1045
                        selection_[i]->charStyle().setLanguage(language);
6029 tsoots 1046
        }
1047
 
6025 tsoots 1048
        if (!selectionIsDirty_)
1049
        {
1050
                selectionIsDirty_ = true;
1051
                emit selectionDirty();
1052
        }
1053
}
1054
 
1055
void SMParagraphStyle::slotScaleH()
1056
{
6091 tsoots 1057
        if (pwidget_->cpage->fontHScale_->useParentValue())
8583 cbradney 1058
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1059
                        selection_[i]->charStyle().resetScaleH();
6091 tsoots 1060
        else
6100 tsoots 1061
        {
8457 cbradney 1062
                double a, b, value;
1063
                int c;
6091 tsoots 1064
                pwidget_->cpage->fontHScale_->getValues(&a, &b, &c, &value);
6100 tsoots 1065
                value = value * 10;
8583 cbradney 1066
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1067
                        selection_[i]->charStyle().setScaleH(qRound(value));
6100 tsoots 1068
        }
6025 tsoots 1069
 
1070
        if (!selectionIsDirty_)
1071
        {
1072
                selectionIsDirty_ = true;
1073
                emit selectionDirty();
1074
        }
1075
}
1076
 
1077
void SMParagraphStyle::slotScaleV()
1078
{
6091 tsoots 1079
        if (pwidget_->cpage->fontVScale_->useParentValue())
8583 cbradney 1080
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1081
                        selection_[i]->charStyle().resetScaleV();
6091 tsoots 1082
        else
6100 tsoots 1083
        {
8457 cbradney 1084
                double a, b, value;
1085
                int c;
6091 tsoots 1086
                pwidget_->cpage->fontVScale_->getValues(&a, &b, &c, &value);
6100 tsoots 1087
                value = value * 10;
8583 cbradney 1088
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1089
                        selection_[i]->charStyle().setScaleV(qRound(value));
6100 tsoots 1090
        }
6025 tsoots 1091
 
1092
        if (!selectionIsDirty_)
1093
        {
1094
                selectionIsDirty_ = true;
1095
                emit selectionDirty();
1096
        }
1097
}
1098
 
1099
void SMParagraphStyle::slotTracking()
1100
{
6091 tsoots 1101
        if (pwidget_->cpage->tracking_->useParentValue())
8583 cbradney 1102
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1103
                        selection_[i]->charStyle().resetTracking();
6091 tsoots 1104
        else
6100 tsoots 1105
        {
8457 cbradney 1106
                double a, b, value;
1107
                int c;
6091 tsoots 1108
                pwidget_->cpage->tracking_->getValues(&a, &b, &c, &value);
6100 tsoots 1109
                value = value * 10;
8583 cbradney 1110
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1111
                        selection_[i]->charStyle().setTracking(qRound(value));
6100 tsoots 1112
        }
6025 tsoots 1113
 
1114
        if (!selectionIsDirty_)
1115
        {
1116
                selectionIsDirty_ = true;
1117
                emit selectionDirty();
1118
        }
1119
}
1120
 
1121
void SMParagraphStyle::slotBaselineOffset()
1122
{
6091 tsoots 1123
        if (pwidget_->cpage->baselineOffset_->useParentValue())
8583 cbradney 1124
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1125
                        selection_[i]->charStyle().resetBaselineOffset();
6091 tsoots 1126
        else
6100 tsoots 1127
        {
8457 cbradney 1128
                double a, b, value;
1129
                int c; 
6091 tsoots 1130
                pwidget_->cpage->baselineOffset_->getValues(&a, &b, &c, &value);
6100 tsoots 1131
                value = value * 10;
8583 cbradney 1132
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1133
                        selection_[i]->charStyle().setBaselineOffset(qRound(value));
6100 tsoots 1134
        }
6025 tsoots 1135
 
1136
        if (!selectionIsDirty_)
1137
        {
1138
                selectionIsDirty_ = true;
1139
                emit selectionDirty();
1140
        }
1141
}
1142
 
1143
void SMParagraphStyle::slotFont(QString s)
1144
{
6733 avox 1145
        if (pwidget_->cpage->fontFace_->useParentFont())
8583 cbradney 1146
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1147
                        selection_[i]->charStyle().resetFont();
1148
        else {
8457 cbradney 1149
                ScFace sf = PrefsManager::instance()->appPrefs.AvailFonts[s];
6733 avox 1150
 
8583 cbradney 1151
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1152
                        selection_[i]->charStyle().setFont(sf);
1153
        }
1154
 
6025 tsoots 1155
        if (!selectionIsDirty_)
1156
        {
1157
                selectionIsDirty_ = true;
1158
                emit selectionDirty();
1159
        }
1160
}
1161
 
6091 tsoots 1162
void SMParagraphStyle::slotParentChanged(const QString &parent)
1163
{
8457 cbradney 1164
        Q_ASSERT(!parent.isNull());
6915 tsoots 1165
 
6091 tsoots 1166
        QStringList sel;
1167
 
8583 cbradney 1168
        for (int i = 0; i < selection_.count(); ++i)
6091 tsoots 1169
        {
9050 avox 1170
                selection_[i]->erase(); // reset everything to NOVALUE
1171
                selection_[i]->setParent(parent);
1172
                selection_[i]->charStyle().setParent("");
1173
                sel << selection_[i]->name();
6091 tsoots 1174
        }
1175
 
1176
        selected(sel);
6094 tsoots 1177
 
1178
        if (!selectionIsDirty_)
1179
        {
1180
                selectionIsDirty_ = true;
1181
                emit selectionDirty();
1182
        }
6091 tsoots 1183
}
1184
 
1185
void SMParagraphStyle::slotCharParentChanged(const QString &parent)
6976 tsoots 1186
{
6915 tsoots 1187
        Q_ASSERT(parent != QString::null);
1188
 
6091 tsoots 1189
        QStringList sel;
1190
 
8583 cbradney 1191
        for (int i = 0; i < selection_.count(); ++i)
6094 tsoots 1192
        {
6915 tsoots 1193
                selection_[i]->charStyle().erase();
7063 tsoots 1194
                if (parent != QString::null)
6976 tsoots 1195
                        selection_[i]->charStyle().setParent(parent);
6091 tsoots 1196
 
1197
                sel << selection_[i]->name();
1198
        }
1199
 
1200
        selected(sel);
6094 tsoots 1201
 
1202
        if (!selectionIsDirty_)
1203
        {
1204
                selectionIsDirty_ = true;
1205
                emit selectionDirty();
1206
        }
6091 tsoots 1207
}
1208
 
6023 tsoots 1209
SMParagraphStyle::~SMParagraphStyle()
5850 tsoots 1210
{
1211
 
1212
}
1213
 
1214
/******************************************************************************/
1215
/******************************************************************************/
1216
 
6029 tsoots 1217
SMCharacterStyle::SMCharacterStyle() : StyleItem(), widget_(0), page_(0), doc_(0), selectionIsDirty_(false)
5850 tsoots 1218
{
6094 tsoots 1219
        widget_ = new QTabWidget();
1220
        Q_CHECK_PTR(widget_);
10585 fschmid 1221
        widget_->setContentsMargins(5, 5, 5, 5);//CB the SMCStylePage parent has a 0 value to fit properly onto the pstyle page, so add it here
10355 subik 1222
        page_ = new SMCStyleWidget();
6094 tsoots 1223
        Q_CHECK_PTR(page_);
1224
        widget_->addTab(page_, tr("Properties"));
5850 tsoots 1225
}
1226
 
1227
QTabWidget* SMCharacterStyle::widget()
1228
{
6019 tsoots 1229
        return widget_;
5850 tsoots 1230
}
1231
 
6029 tsoots 1232
QString SMCharacterStyle::typeNamePlural()
5850 tsoots 1233
{
1234
        return tr("Character Styles");
1235
}
1236
 
6029 tsoots 1237
QString SMCharacterStyle::typeNameSingular()
1238
{
1239
        return tr("Character Style");
1240
}
1241
 
12283 cbradney 1242
void SMCharacterStyle::setCurrentDoc(ScribusDoc *doc)
5850 tsoots 1243
{
6019 tsoots 1244
        doc_ = doc;
6072 tsoots 1245
        if (doc_)
6029 tsoots 1246
        {
6072 tsoots 1247
                if (page_)
1248
                {
7012 tsoots 1249
                        page_->fillLangCombo(doc_->scMW()->LangTransl);
6072 tsoots 1250
                        page_->fillColorCombo(doc_->PageColors);
6094 tsoots 1251
                        page_->fontFace_->RebuildList(doc_);
6072 tsoots 1252
                }
6029 tsoots 1253
        }
6072 tsoots 1254
        else
1255
        {
1256
                removeConnections();
1257
                selection_.clear();
1258
                tmpStyles_.clear();
1259
        }
1260
 
5850 tsoots 1261
}
1262
 
7063 tsoots 1263
StyleSet<CharStyle>* SMCharacterStyle::tmpStyles()
1264
{
1265
        return &tmpStyles_;
1266
}
1267
 
9790 avox 1268
QList<StyleName> SMCharacterStyle::styles(bool reloadFromDoc)
5850 tsoots 1269
{
9790 avox 1270
        QList<StyleName> tmpList;
5850 tsoots 1271
 
6019 tsoots 1272
        if (!doc_)
1273
                return tmpList; // no doc available
1274
 
6051 tsoots 1275
        if (reloadFromDoc)
1276
                reloadTmpStyles();
6023 tsoots 1277
 
10400 subik 1278
        for (int i = 0; i < tmpStyles_.count(); ++i)
6019 tsoots 1279
        {
6023 tsoots 1280
                if (tmpStyles_[i].hasName())
6019 tsoots 1281
                {
12283 cbradney 1282
                        QString styleName(tmpStyles_[i].displayName());
8457 cbradney 1283
                        QString parentName(QString::null);
6019 tsoots 1284
 
7062 avox 1285
                        if (tmpStyles_[i].hasParent())
1286
                                parentName = tmpStyles_[i].parent();
6019 tsoots 1287
 
1288
                        tmpList << StyleName(styleName, parentName);
1289
                }
1290
        }
1291
 
5850 tsoots 1292
        return tmpList;
1293
}
1294
 
6029 tsoots 1295
void SMCharacterStyle::reload()
1296
{
1297
        reloadTmpStyles();
1298
}
1299
 
5850 tsoots 1300
void SMCharacterStyle::selected(const QStringList &styleNames)
1301
{
6023 tsoots 1302
        selection_.clear();
6029 tsoots 1303
        selectionIsDirty_ = false;
1304
        removeConnections();
9790 avox 1305
        QList<CharStyle> cstyles;
7020 tsoots 1306
 
7067 tsoots 1307
        tmpStyles_.invalidate();
7064 tsoots 1308
 
10400 subik 1309
        for (int i = 0; i < tmpStyles_.count(); ++i)
7063 tsoots 1310
                cstyles << tmpStyles_[i];
6098 tsoots 1311
 
8583 cbradney 1312
        for (int i = 0; i < styleNames.count(); ++i)
6019 tsoots 1313
        {
7008 tsoots 1314
                int index = tmpStyles_.find(styleNames[i]);
12395 cbradney 1315
                //FIXME: #7133: Use .isDefaultStyle() instead here rather than relying on tr text comparison
1316
                if (index<0 && styleNames[i]==CommonStrings::trDefaultCharacterStyle)
1317
                        index = tmpStyles_.find(CommonStrings::DefaultCharacterStyle);
7008 tsoots 1318
                if (index > -1)
1319
                        selection_.append(&tmpStyles_[index]);
7020 tsoots 1320
 
6019 tsoots 1321
        }
9790 avox 1322
        page_->show(selection_, cstyles, PrefsManager::instance()->appPrefs.Language, doc_->unitIndex());
6029 tsoots 1323
        setupConnections();
5850 tsoots 1324
}
1325
 
5859 tsoots 1326
QString SMCharacterStyle::fromSelection() const
1327
{
8457 cbradney 1328
        QString lsName(QString::null);
6914 tsoots 1329
        if (!doc_)
1330
                return lsName; // no doc available
1331
 
10400 subik 1332
        for (int i = 0; i < doc_->m_Selection->count(); ++i)
6914 tsoots 1333
        {
1334
                // wth is going on here
1335
                PageItem *item = doc_->m_Selection->itemAt(i);
1336
 
7032 avox 1337
                QString tmpName = item->itemText.defaultStyle().charStyle().parent();
6914 tsoots 1338
 
8457 cbradney 1339
                if (lsName.isNull() && !tmpName.isEmpty() && tmpName != "")
6914 tsoots 1340
                {
1341
                        lsName = tmpName;
1342
                }
8457 cbradney 1343
                else if (!lsName.isNull() && !tmpName.isEmpty() && tmpName != "" && lsName != tmpName)
6914 tsoots 1344
                {
1345
                        lsName = QString::null;
1346
                        break;
1347
                }
1348
        }
1349
        return lsName;
5859 tsoots 1350
}
1351
 
6044 tsoots 1352
void SMCharacterStyle::toSelection(const QString &styleName) const
1353
{
6819 tsoots 1354
        if (!doc_)
1355
                return; // nowhere to apply or no doc
1356
 
7032 avox 1357
        doc_->itemSelection_SetNamedCharStyle(styleName);
6044 tsoots 1358
}
1359
 
1360
QString SMCharacterStyle::newStyle()
1361
{
7442 avox 1362
        Q_ASSERT(doc_ && doc_->paragraphStyles().count() > 0);
6044 tsoots 1363
 
6260 fschmid 1364
        QString s = getUniqueName( tr("New Style"));
7032 avox 1365
        CharStyle c;
12283 cbradney 1366
        c.setDefaultStyle(false);
6958 tsoots 1367
        c.setName(s);
1368
        tmpStyles_.create(c);
6044 tsoots 1369
        return s;
1370
}
1371
 
6047 tsoots 1372
QString SMCharacterStyle::newStyle(const QString &fromStyle)
1373
{
6958 tsoots 1374
        Q_ASSERT(tmpStyles_.resolve(fromStyle));
1375
        if (!tmpStyles_.resolve(fromStyle))
1376
                return QString::null;
6047 tsoots 1377
 
6958 tsoots 1378
        QString s = getUniqueName( tr("Clone of %1").arg(fromStyle));
8641 cbradney 1379
        CharStyle c(tmpStyles_.get(fromStyle));
12283 cbradney 1380
        c.setDefaultStyle(false);
6958 tsoots 1381
        c.setName(s);
1382
        c.setShortcut(QString::null);
1383
        tmpStyles_.create(c);
6047 tsoots 1384
 
1385
        return s;
1386
}
1387
 
1388
QString SMCharacterStyle::getUniqueName(const QString &name)
1389
{
1390
        int id = 0;
1391
        bool done = false;
8457 cbradney 1392
        QString s(name);
6047 tsoots 1393
 
1394
        while (!done)
1395
        {
1396
start:
1397
                ++id;
10400 subik 1398
                for (int i = 0; i < tmpStyles_.count(); ++i)
6047 tsoots 1399
                {
1400
                        if (tmpStyles_[i].name() == s)
1401
                        {
1402
                                s = tr("%1 (%2)", "This for unique name when creating "
1403
                                                "a new character style. %1 will be the name "
1404
                                                                "of the style and %2 will be a number forming "
1405
                                                                "a style name like: New Style (2)").arg(name).arg(id);
1406
                                goto start;
1407
                        }
1408
                }
1409
                done = true;
1410
        }
1411
 
1412
        return s;
1413
}
1414
 
5850 tsoots 1415
void SMCharacterStyle::apply()
1416
{
6072 tsoots 1417
        if (!doc_)
1418
                return;
1419
 
8094 tsoots 1420
        QMap<QString, QString> replacement;
8583 cbradney 1421
        for (int i = 0; i < deleted_.count(); ++i)
8094 tsoots 1422
                replacement[deleted_[i].first] = deleted_[i].second;
1423
 
1424
        doc_->redefineCharStyles(tmpStyles_, false);
1425
        doc_->replaceCharStyles(replacement);
1426
 
1427
        deleted_.clear(); // deletion done at this point
1428
 
1429
        doc_->scMW()->propertiesPalette->paraStyleCombo->updateFormatList();
1430
        doc_->scMW()->propertiesPalette->charStyleCombo->updateFormatList();
12132 jghali 1431
        // Better not call DrawNew() here, as this will cause several unnecessary calls
1432
        // doc_->view()->DrawNew();
8094 tsoots 1433
        doc_->changed();
6023 tsoots 1434
}
5850 tsoots 1435
 
6023 tsoots 1436
void SMCharacterStyle::editMode(bool isOn)
1437
{
1438
        if (isOn)
1439
                reloadTmpStyles();
5850 tsoots 1440
}
1441
 
12283 cbradney 1442
bool SMCharacterStyle::isDefaultStyle(const QString &stylename) const
1443
{
1444
        int index = tmpStyles_.find(stylename);
1445
        bool b=false;
1446
        if (index > -1)
1447
                b = tmpStyles_[index].isDefaultStyle();
1448
        else
1449
        {
1450
                if (CommonStrings::trDefaultCharacterStyle==stylename)
1451
                {
1452
                        index = tmpStyles_.find(CommonStrings::DefaultCharacterStyle);
1453
                        if (index > -1)
1454
                                b = tmpStyles_[index].isDefaultStyle();
1455
                }
1456
        }
1457
        return b;
1458
}
1459
 
1460
void SMCharacterStyle::setDefaultStyle(bool ids)
1461
{
1462
        Q_ASSERT(selection_.count() == 1);
1463
        if (selection_.count() != 1)
1464
                return;
1465
 
1466
        selection_[0]->setDefaultStyle(ids);
1467
 
1468
        if (!selectionIsDirty_)
1469
        {
1470
                selectionIsDirty_ = true;
1471
                emit selectionDirty();
1472
        }
1473
}
1474
 
6949 tsoots 1475
QString SMCharacterStyle::shortcut(const QString &stylename) const
1476
{
1477
        QString s = QString::null;
7008 tsoots 1478
        int index = tmpStyles_.find(stylename);
1479
        if (index > -1)
1480
                s = tmpStyles_[index].shortcut();
1481
 
6949 tsoots 1482
        return s;
1483
}
1484
 
1485
void SMCharacterStyle::setShortcut(const QString &shortcut)
1486
{
1487
        Q_ASSERT(selection_.count() == 1);
1488
        if (selection_.count() != 1)
1489
                return;
1490
 
1491
        selection_[0]->setShortcut(shortcut);
6951 tsoots 1492
 
1493
        if (!selectionIsDirty_)
1494
        {
1495
                selectionIsDirty_ = true;
1496
                emit selectionDirty();
1497
        }
6949 tsoots 1498
}
1499
 
9790 avox 1500
void SMCharacterStyle::deleteStyles(const QList<RemoveItem> &removeList)
5850 tsoots 1501
{
8583 cbradney 1502
        for (int i = 0; i < removeList.count(); ++i)
6051 tsoots 1503
        {
8583 cbradney 1504
                for (int k = 0; k < selection_.count(); ++k)
6051 tsoots 1505
                {
1506
                        if (selection_[k]->name() == removeList[i].first)
1507
                        {
9790 avox 1508
                                selection_.removeAt(k);
6051 tsoots 1509
                                break;
1510
                        }
1511
                }
6958 tsoots 1512
 
1513
                int index = tmpStyles_.find(removeList[i].first);
1514
                if (index > -1)
1515
                        tmpStyles_.remove(index);
6051 tsoots 1516
                deleted_ << removeList[i];
1517
        }
5850 tsoots 1518
}
1519
 
1520
void SMCharacterStyle::nameChanged(const QString &newName)
1521
{
8583 cbradney 1522
//      for (int i = 0; i < selection_.count(); ++i)
8125 tsoots 1523
//              selection_[i]->setName(newName);
5850 tsoots 1524
 
8457 cbradney 1525
        QString oldName(selection_[0]->name());
8125 tsoots 1526
        CharStyle c(*selection_[0]);
1527
        c.setName(newName);
1528
        tmpStyles_.create(c);
1529
        selection_.clear();
1530
        selection_.append(&tmpStyles_[tmpStyles_.find(newName)]);
10400 subik 1531
        for (int j = 0; j < tmpStyles_.count(); ++j)
8125 tsoots 1532
        {
1533
                int index = tmpStyles_.find(oldName);
1534
                if (index > -1)
1535
                {
1536
                        tmpStyles_.remove(index);
1537
                        break;
1538
                }
1539
        }
1540
 
10400 subik 1541
        for (int j = 0; j < tmpStyles_.count(); ++j)
8125 tsoots 1542
        {
1543
                if (tmpStyles_[j].parent() == oldName)
1544
                        tmpStyles_[j].setParent(newName);
1545
        }
1546
 
9790 avox 1547
        QList<RemoveItem>::iterator it;
8125 tsoots 1548
        for (it = deleted_.begin(); it != deleted_.end(); ++it)
1549
        {
1550
                if ((*it).second == oldName)
1551
                {
1552
                        oldName = (*it).first;
10585 fschmid 1553
                        deleted_.erase(it);
8125 tsoots 1554
                        break;
1555
                }
1556
        }
1557
 
1558
        deleted_.append(RemoveItem(oldName, newName));
1559
 
6051 tsoots 1560
        if (!selectionIsDirty_)
1561
        {
1562
                selectionIsDirty_ = true;
1563
                emit selectionDirty();
1564
        }
5850 tsoots 1565
}
1566
 
6025 tsoots 1567
void SMCharacterStyle::languageChange()
1568
{
6029 tsoots 1569
        if (widget_ && page_)
1570
        {
10585 fschmid 1571
                widget_->setTabText(widget_->indexOf(page_), tr("Properties"));
6029 tsoots 1572
                page_->languageChange();
1573
        }
6025 tsoots 1574
}
1575
 
8453 tsoots 1576
void SMCharacterStyle::unitChange()
1577
{
1578
 
1579
}
1580
 
6023 tsoots 1581
void SMCharacterStyle::reloadTmpStyles()
1582
{
6072 tsoots 1583
        if (!doc_)
1584
                return;
1585
 
6023 tsoots 1586
        selection_.clear();
1587
        tmpStyles_.clear();
7442 avox 1588
        tmpStyles_.redefine(doc_->charStyles(), true);
6023 tsoots 1589
}
1590
 
6029 tsoots 1591
void SMCharacterStyle::setupConnections()
1592
{
6072 tsoots 1593
        if (!page_)
1594
                return;
6029 tsoots 1595
 
1596
        connect(page_->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
1597
        connect(page_->effects_, SIGNAL(State(int)), this, SLOT(slotEffects(int)));
8687 cbradney 1598
        connect(page_->effects_->ShadowVal->Xoffset, SIGNAL(valueChanged(double)),
6100 tsoots 1599
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1600
        connect(page_->effects_->ShadowVal->Yoffset, SIGNAL(valueChanged(double)),
6100 tsoots 1601
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1602
        connect(page_->effects_->OutlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1603
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1604
        connect(page_->effects_->UnderlineVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 1605
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1606
        connect(page_->effects_->UnderlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1607
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1608
        connect(page_->effects_->StrikeVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 1609
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1610
        connect(page_->effects_->StrikeVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1611
                           this, SLOT(slotEffectProperties()));
1612
        connect(page_->fillColor_, SIGNAL(activated(const QString&)), this, SLOT(slotFillColor()));
6029 tsoots 1613
        connect(page_->fillShade_, SIGNAL(clicked()), this, SLOT(slotFillShade()));
6100 tsoots 1614
        connect(page_->strokeColor_, SIGNAL(activated(const QString&)), this, SLOT(slotStrokeColor()));
6029 tsoots 1615
        connect(page_->strokeShade_, SIGNAL(clicked()), this, SLOT(slotStrokeShade()));
6093 tsoots 1616
        connect(page_->language_, SIGNAL(activated(int)), this, SLOT(slotLanguage()));
8687 cbradney 1617
        connect(page_->fontSize_, SIGNAL(valueChanged(double)), this, SLOT(slotFontSize()));
1618
        connect(page_->fontHScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleH()));
1619
        connect(page_->fontVScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleV()));
1620
        connect(page_->tracking_, SIGNAL(valueChanged(double)), this, SLOT(slotTracking()));
1621
        connect(page_->baselineOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotBaselineOffset()));
6029 tsoots 1622
        connect(page_->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
6091 tsoots 1623
        connect(page_->parentCombo, SIGNAL(activated(const QString&)),
1624
                this, SLOT(slotParentChanged(const QString&)));
6029 tsoots 1625
}
1626
 
1627
void SMCharacterStyle::removeConnections()
1628
{
6072 tsoots 1629
        if (!page_)
1630
                return;
6029 tsoots 1631
 
1632
        disconnect(page_->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
1633
        disconnect(page_->effects_, SIGNAL(State(int)), this, SLOT(slotEffects(int)));
8687 cbradney 1634
        disconnect(page_->effects_->ShadowVal->Xoffset, SIGNAL(valueChanged(double)),
6100 tsoots 1635
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1636
        disconnect(page_->effects_->ShadowVal->Yoffset, SIGNAL(valueChanged(double)),
6100 tsoots 1637
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1638
        disconnect(page_->effects_->OutlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1639
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1640
        disconnect(page_->effects_->UnderlineVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 1641
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1642
        disconnect(page_->effects_->UnderlineVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1643
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1644
        disconnect(page_->effects_->StrikeVal->LPos, SIGNAL(valueChanged(double)),
6100 tsoots 1645
                           this, SLOT(slotEffectProperties()));
8687 cbradney 1646
        disconnect(page_->effects_->StrikeVal->LWidth, SIGNAL(valueChanged(double)),
6100 tsoots 1647
                           this, SLOT(slotEffectProperties()));
1648
        disconnect(page_->fillColor_, SIGNAL(activated(const QString&)), this, SLOT(slotFillColor()));
6029 tsoots 1649
        disconnect(page_->fillShade_, SIGNAL(clicked()), this, SLOT(slotFillShade()));
6100 tsoots 1650
        disconnect(page_->strokeColor_, SIGNAL(activated(const QString&)), this, SLOT(slotStrokeColor()));
6029 tsoots 1651
        disconnect(page_->strokeShade_, SIGNAL(clicked()), this, SLOT(slotStrokeShade()));
6093 tsoots 1652
        disconnect(page_->language_, SIGNAL(activated(int)), this, SLOT(slotLanguage()));
8687 cbradney 1653
        disconnect(page_->fontSize_, SIGNAL(valueChanged(double)), this, SLOT(slotFontSize()));
1654
        disconnect(page_->fontHScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleH()));
1655
        disconnect(page_->fontVScale_, SIGNAL(valueChanged(double)), this, SLOT(slotScaleV()));
1656
        disconnect(page_->tracking_, SIGNAL(valueChanged(double)), this, SLOT(slotTracking()));
1657
        disconnect(page_->baselineOffset_, SIGNAL(valueChanged(double)), this, SLOT(slotBaselineOffset()));
6029 tsoots 1658
        disconnect(page_->fontFace_, SIGNAL(fontSelected(QString)), this, SLOT(slotFont(QString)));
6091 tsoots 1659
        disconnect(page_->parentCombo, SIGNAL(activated(const QString&)),
1660
                        this, SLOT(slotParentChanged(const QString&)));
6029 tsoots 1661
}
1662
 
1663
void SMCharacterStyle::slotFontSize()
1664
{
6091 tsoots 1665
        if (page_->fontSize_->useParentValue())
8583 cbradney 1666
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1667
                        selection_[i]->resetFontSize();
6091 tsoots 1668
        else
6100 tsoots 1669
        {
8457 cbradney 1670
                double a, b, value;
1671
                int c;
1672
 
6091 tsoots 1673
                page_->fontSize_->getValues(&a, &b, &c, &value);
6100 tsoots 1674
                value = value * 10;
8583 cbradney 1675
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1676
                        selection_[i]->setFontSize(qRound(value));
6100 tsoots 1677
        }
6029 tsoots 1678
 
1679
        if (!selectionIsDirty_)
1680
        {
1681
                selectionIsDirty_ = true;
1682
                emit selectionDirty();
1683
        }
1684
}
1685
 
1686
void SMCharacterStyle::slotEffects(int e)
1687
{
6100 tsoots 1688
        StyleFlag s = ScStyle_None;
1689
        if (page_->effects_->useParentValue())
1690
        {
8583 cbradney 1691
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1692
                {
9607 avox 1693
                        selection_[i]->resetFeatures();
6733 avox 1694
                        selection_[i]->resetShadowXOffset();
1695
                        selection_[i]->resetShadowYOffset();
1696
                        selection_[i]->resetOutlineWidth();
1697
                        selection_[i]->resetUnderlineOffset();
1698
                        selection_[i]->resetUnderlineWidth();
1699
                        selection_[i]->resetStrikethruOffset();
1700
                        selection_[i]->resetStrikethruWidth();
1701
                }
6100 tsoots 1702
        }
1703
        else
1704
        {
1705
                s = static_cast<StyleFlag>(e);
8457 cbradney 1706
                double a, b, sxo, syo, olw, ulp, ulw, slp, slw;
1707
                int c;
1708
 
6100 tsoots 1709
                page_->effects_->ShadowVal->Xoffset->getValues(&a, &b, &c, &sxo);
8457 cbradney 1710
                sxo *= 10;
6100 tsoots 1711
                page_->effects_->ShadowVal->Yoffset->getValues(&a, &b, &c, &syo);
8457 cbradney 1712
                syo *= 10;
6100 tsoots 1713
 
1714
                page_->effects_->OutlineVal->LWidth->getValues(&a, &b, &c, &olw);
8457 cbradney 1715
                olw *= 10;
6100 tsoots 1716
 
1717
                page_->effects_->UnderlineVal->LPos->getValues(&a, &b, &c, &ulp);
8457 cbradney 1718
                ulp *= 10;
6100 tsoots 1719
                page_->effects_->UnderlineVal->LWidth->getValues(&a, &b, &c, &ulw);
8457 cbradney 1720
                ulw *= 10;
6100 tsoots 1721
 
1722
                page_->effects_->StrikeVal->LPos->getValues(&a, &b, &c, &slp);
8457 cbradney 1723
                slp *= 10;
6100 tsoots 1724
                page_->effects_->StrikeVal->LWidth->getValues(&a, &b, &c, &slw);
8457 cbradney 1725
                slw *= 10;
6100 tsoots 1726
 
8583 cbradney 1727
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1728
                {
9607 avox 1729
                        selection_[i]->setFeatures(s.featureList());
6733 avox 1730
                        selection_[i]->setShadowXOffset(qRound(sxo));
1731
                        selection_[i]->setShadowYOffset(qRound(syo));
1732
                        selection_[i]->setOutlineWidth(qRound(olw));
1733
                        selection_[i]->setUnderlineOffset(qRound(ulp));
1734
                        selection_[i]->setUnderlineWidth(qRound(ulw));
1735
                        selection_[i]->setStrikethruOffset(qRound(slp));
1736
                        selection_[i]->setStrikethruWidth(qRound(slw));
1737
                }
6100 tsoots 1738
        }
1739
 
6733 avox 1740
 
6100 tsoots 1741
        if (!selectionIsDirty_)
1742
        {
1743
                selectionIsDirty_ = true;
1744
                emit selectionDirty();
1745
        }
1746
}
1747
 
1748
void SMCharacterStyle::slotEffectProperties()
1749
{
1750
        double a, b, sxo, syo, olw, ulp, ulw, slp, slw;
1751
        int c;
1752
 
6029 tsoots 1753
        page_->effects_->ShadowVal->Xoffset->getValues(&a, &b, &c, &sxo);
8457 cbradney 1754
        sxo *= 10;
6029 tsoots 1755
        page_->effects_->ShadowVal->Yoffset->getValues(&a, &b, &c, &syo);
8457 cbradney 1756
        syo *= 10;
6029 tsoots 1757
 
1758
        page_->effects_->OutlineVal->LWidth->getValues(&a, &b, &c, &olw);
8457 cbradney 1759
        olw *= 10;
6029 tsoots 1760
 
1761
        page_->effects_->UnderlineVal->LPos->getValues(&a, &b, &c, &ulp);
8457 cbradney 1762
        ulp *= 10;
6029 tsoots 1763
        page_->effects_->UnderlineVal->LWidth->getValues(&a, &b, &c, &ulw);
8457 cbradney 1764
        ulw *= 10;
6029 tsoots 1765
 
1766
        page_->effects_->StrikeVal->LPos->getValues(&a, &b, &c, &slp);
8457 cbradney 1767
        slp *= 10;
6029 tsoots 1768
        page_->effects_->StrikeVal->LWidth->getValues(&a, &b, &c, &slw);
8457 cbradney 1769
        slw *= 10;
6100 tsoots 1770
 
8583 cbradney 1771
        for (int i = 0; i < selection_.count(); ++i)
6029 tsoots 1772
        {
6091 tsoots 1773
                selection_[i]->setShadowXOffset(qRound(sxo));
1774
                selection_[i]->setShadowYOffset(qRound(syo));
1775
                selection_[i]->setOutlineWidth(qRound(olw));
1776
                selection_[i]->setUnderlineOffset(qRound(ulp));
1777
                selection_[i]->setUnderlineWidth(qRound(ulw));
1778
                selection_[i]->setStrikethruOffset(qRound(slp));
1779
                selection_[i]->setStrikethruWidth(qRound(slw));
6029 tsoots 1780
        }
1781
 
1782
        if (!selectionIsDirty_)
1783
        {
1784
                selectionIsDirty_ = true;
1785
                emit selectionDirty();
1786
        }
1787
}
1788
 
1789
void SMCharacterStyle::slotFillColor()
1790
{
6733 avox 1791
        if (page_->fillColor_->useParentValue())
8583 cbradney 1792
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1793
                        selection_[i]->resetFillColor();
1794
        else {         
8457 cbradney 1795
                QString col(page_->fillColor_->currentText());
6733 avox 1796
 
8583 cbradney 1797
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1798
                        selection_[i]->setFillColor(col);
1799
        }
1800
 
6029 tsoots 1801
        if (!selectionIsDirty_)
1802
        {
1803
                selectionIsDirty_ = true;
1804
                emit selectionDirty();
1805
        }
1806
}
1807
 
1808
void SMCharacterStyle::slotFillShade()
1809
{
6733 avox 1810
        if (page_->fillShade_->useParentValue())
8583 cbradney 1811
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1812
                        selection_[i]->resetFillShade();
1813
        else {
8457 cbradney 1814
                int fs = page_->fillShade_->getValue();
6100 tsoots 1815
 
8583 cbradney 1816
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1817
                        selection_[i]->setFillShade(fs);
1818
        }
1819
 
6029 tsoots 1820
        if (!selectionIsDirty_)
1821
        {
1822
                selectionIsDirty_ = true;
1823
                emit selectionDirty();
1824
        }
1825
}
1826
 
1827
void SMCharacterStyle::slotStrokeColor()
1828
{
6733 avox 1829
        if (page_->strokeColor_->useParentValue())
8583 cbradney 1830
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1831
                        selection_[i]->resetStrokeColor();
1832
        else {
8457 cbradney 1833
                QString c(page_->strokeColor_->currentText());
6101 tsoots 1834
 
8583 cbradney 1835
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1836
                        selection_[i]->setStrokeColor(c);
1837
        }
1838
 
6029 tsoots 1839
        if (!selectionIsDirty_)
1840
        {
1841
                selectionIsDirty_ = true;
1842
                emit selectionDirty();
1843
        }
1844
}
1845
 
1846
void SMCharacterStyle::slotStrokeShade()
1847
{
6733 avox 1848
        if (page_->strokeShade_->useParentValue())
8583 cbradney 1849
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1850
                        selection_[i]->resetStrokeShade();
1851
        else {
8457 cbradney 1852
                int ss = page_->strokeShade_->getValue();
6733 avox 1853
 
8583 cbradney 1854
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1855
                        selection_[i]->setStrokeShade(ss);
1856
        }
1857
 
6029 tsoots 1858
        if (!selectionIsDirty_)
1859
        {
1860
                selectionIsDirty_ = true;
1861
                emit selectionDirty();
1862
        }
1863
}
1864
 
1865
void SMCharacterStyle::slotLanguage()
1866
{
1867
        QMap<QString,QString>::Iterator it;
7442 avox 1868
        QString language = doc_->paragraphStyle("").charStyle().language();
6029 tsoots 1869
 
6093 tsoots 1870
        if (page_->language_->useParentValue())
8583 cbradney 1871
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1872
                        selection_[i]->resetLanguage();
6093 tsoots 1873
        else
6029 tsoots 1874
        {
6093 tsoots 1875
                for (it = doc_->scMW()->LangTransl.begin(); it != doc_->scMW()->LangTransl.end(); ++it)
6029 tsoots 1876
                {
10516 cbradney 1877
                        if (it.value() == page_->language_->currentText())
6093 tsoots 1878
                        {
1879
                                language = it.key();
1880
                                break;
1881
                        }
6029 tsoots 1882
                }
8583 cbradney 1883
                for (int i = 0; i < selection_.count(); ++i)
7012 tsoots 1884
                        selection_[i]->setLanguage(language);
6029 tsoots 1885
        }
1886
 
1887
 
1888
        if (!selectionIsDirty_)
1889
        {
1890
                selectionIsDirty_ = true;
1891
                emit selectionDirty();
1892
        }
1893
}
1894
 
1895
void SMCharacterStyle::slotScaleH()
1896
{
6091 tsoots 1897
        if (page_->fontHScale_->useParentValue())
8583 cbradney 1898
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1899
                        selection_[i]->resetScaleH();
6091 tsoots 1900
        else
6100 tsoots 1901
        {
8457 cbradney 1902
                double a, b, value;
1903
                int c;
1904
 
6091 tsoots 1905
                page_->fontHScale_->getValues(&a, &b, &c, &value);
6100 tsoots 1906
                value = value * 10;
8583 cbradney 1907
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1908
                        selection_[i]->setScaleH(qRound(value));
6100 tsoots 1909
        }
6029 tsoots 1910
 
1911
 
1912
        if (!selectionIsDirty_)
1913
        {
1914
                selectionIsDirty_ = true;
1915
                emit selectionDirty();
1916
        }
1917
}
1918
 
1919
void SMCharacterStyle::slotScaleV()
1920
{
6091 tsoots 1921
        if (page_->fontVScale_->useParentValue())
8583 cbradney 1922
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1923
                        selection_[i]->resetScaleV();
6091 tsoots 1924
        else
6100 tsoots 1925
        {
8457 cbradney 1926
                double a, b, value;
1927
                int c;
1928
 
6091 tsoots 1929
                page_->fontVScale_->getValues(&a, &b, &c, &value);
6100 tsoots 1930
                value = value * 10;
8583 cbradney 1931
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1932
                        selection_[i]->setScaleV(qRound(value));
6100 tsoots 1933
        }
6029 tsoots 1934
 
1935
 
1936
        if (!selectionIsDirty_)
1937
        {
1938
                selectionIsDirty_ = true;
1939
                emit selectionDirty();
1940
        }
1941
}
1942
 
1943
void SMCharacterStyle::slotTracking()
1944
{
6091 tsoots 1945
        if (page_->tracking_->useParentValue())
8583 cbradney 1946
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1947
                        selection_[i]->resetTracking();
6091 tsoots 1948
        else
6100 tsoots 1949
        {
8457 cbradney 1950
                double a, b, value;
1951
                int c;
1952
 
6091 tsoots 1953
                page_->tracking_->getValues(&a, &b, &c, &value);
6100 tsoots 1954
                value = value * 10;
8583 cbradney 1955
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1956
                        selection_[i]->setTracking(qRound(value));
6100 tsoots 1957
        }
6029 tsoots 1958
 
1959
        if (!selectionIsDirty_)
1960
        {
1961
                selectionIsDirty_ = true;
1962
                emit selectionDirty();
1963
        }
1964
}
1965
 
1966
void SMCharacterStyle::slotBaselineOffset()
1967
{
6091 tsoots 1968
        if (page_->baselineOffset_->useParentValue())
8583 cbradney 1969
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1970
                        selection_[i]->resetBaselineOffset();
6091 tsoots 1971
        else
6100 tsoots 1972
        {
8457 cbradney 1973
                double a, b, value;
1974
                int c;
1975
 
6091 tsoots 1976
                page_->baselineOffset_->getValues(&a, &b, &c, &value);
6100 tsoots 1977
                value = value * 10;
8583 cbradney 1978
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1979
                        selection_[i]->setBaselineOffset(qRound(value));
6100 tsoots 1980
        }
6029 tsoots 1981
 
1982
        if (!selectionIsDirty_)
1983
        {
1984
                selectionIsDirty_ = true;
1985
                emit selectionDirty();
1986
        }
1987
}
1988
 
1989
void SMCharacterStyle::slotFont(QString s)
1990
{
6102 tsoots 1991
        ScFace sf;
6733 avox 1992
        if (page_->fontFace_->useParentFont())
8583 cbradney 1993
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1994
                        selection_[i]->resetFont();
1995
        else {
6102 tsoots 1996
                sf = PrefsManager::instance()->appPrefs.AvailFonts[s];
1997
 
8583 cbradney 1998
                for (int i = 0; i < selection_.count(); ++i)
6733 avox 1999
                        selection_[i]->setFont(sf);
2000
        }
2001
 
6029 tsoots 2002
        if (!selectionIsDirty_)
2003
        {
2004
                selectionIsDirty_ = true;
2005
                emit selectionDirty();
2006
        }
2007
}
2008
 
6091 tsoots 2009
void SMCharacterStyle::slotParentChanged(const QString &parent)
2010
{
8457 cbradney 2011
        Q_ASSERT(!parent.isNull());
6915 tsoots 2012
 
6091 tsoots 2013
        QStringList sel;
2014
 
8583 cbradney 2015
        for (int i = 0; i < selection_.count(); ++i)
6091 tsoots 2016
        {
7019 tsoots 2017
                selection_[i]->erase();
6915 tsoots 2018
                selection_[i]->setParent(parent);
6091 tsoots 2019
                sel << selection_[i]->name();
2020
        }
2021
 
2022
        selected(sel);
6094 tsoots 2023
 
2024
        if (!selectionIsDirty_)
2025
        {
2026
                selectionIsDirty_ = true;
2027
                emit selectionDirty();
2028
        }
6091 tsoots 2029
}
2030
 
5850 tsoots 2031
SMCharacterStyle::~SMCharacterStyle()
2032
{
6019 tsoots 2033
        delete page_;
2034
        delete widget_;
2035
        page_ = 0;
2036
        widget_ = 0;
5850 tsoots 2037
}
2038