Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
6443 avox 1
/*
2
 For general Scribus (>=1.3.2) copyright and licensing information please refer
3
 to the COPYING file provided with the program. Following this notice may exist
4
 a copyright and/or license notice that predates the release of Scribus 1.3.2
5
 for which a new license (GPL+exception) is in place.
6
 */
7
 
8
 
10223 cbradney 9
#include <QObject>
12283 cbradney 10
#include <QDebug>
11
 
12
#include "commonstrings.h"
6443 avox 13
#include "sctextstruct.h"
14
#include "scfonts.h"
8455 avox 15
#include "resourcecollection.h"
8382 avox 16
 
17
#include "styles/style.h"
8337 avox 18
#include "charstyle.h"
8193 avox 19
#include "desaxe/saxiohelper.h"
8266 avox 20
#include "desaxe/simple_actions.h"
21
#include "prefsmanager.h"
6443 avox 22
 
7456 jghali 23
StyleFlag& StyleFlag::operator&= (const StyleFlag& right){        
24
        int result = static_cast<int>(value) & static_cast<int>(right.value);        
25
        value = static_cast<StyleFlagValue>(result);
26
        return *this;
6443 avox 27
}
28
 
7456 jghali 29
StyleFlag& StyleFlag::operator|= (const StyleFlag& right)
6443 avox 30
{
7456 jghali 31
        int result = static_cast<int>(value) | static_cast<int>(right.value);
32
        value = static_cast<StyleFlagValue>(result);
33
        return *this;
6443 avox 34
}
35
 
7456 jghali 36
StyleFlag StyleFlag::operator& (const StyleFlag& right)
6443 avox 37
{
7456 jghali 38
        int val = static_cast<int>(value) & static_cast<int>(right.value);
39
        StyleFlag result(static_cast<StyleFlagValue>(val));
40
        return result;
6443 avox 41
}
42
 
7456 jghali 43
StyleFlag StyleFlag::operator& (int right)
44
{
45
        int val = static_cast<int>(value) & right;
46
        StyleFlag result(static_cast<StyleFlagValue>(val));
47
        return result;
48
}
49
 
50
StyleFlag StyleFlag::operator| (const StyleFlag& right)
6443 avox 51
{        
7456 jghali 52
        int val = static_cast<int>(value) | static_cast<int>(right.value);
53
        StyleFlag result(static_cast<StyleFlagValue>(val));
54
        return result;
6443 avox 55
}
56
 
7456 jghali 57
StyleFlag StyleFlag::operator^ (const StyleFlag& right)
58
{
59
        int val = static_cast<int>(value) ^ static_cast<int>(right.value);
60
        StyleFlag result(static_cast<StyleFlagValue>(val));
61
        return result;
6443 avox 62
}
63
 
7456 jghali 64
StyleFlag StyleFlag::operator^  (int right)
6443 avox 65
{
7456 jghali 66
        int val = static_cast<int>(value) ^ right;
67
        StyleFlag result(static_cast<StyleFlagValue>(val));
68
        return result;
6443 avox 69
}
70
 
7456 jghali 71
StyleFlag StyleFlag::operator~ ()
72
{
73
        int val = ~ static_cast<int>(value);
74
        StyleFlag result(static_cast<StyleFlagValue>(val));
75
        return result;
76
}
77
 
78
bool StyleFlag::operator== (const StyleFlag& right) const
7017 avox 79
{        
7456 jghali 80
        int result = static_cast<int>( (value ^ right.value) & ScStyle_UserStyles);
81
        return (result == 0);
7017 avox 82
}
6443 avox 83
 
7456 jghali 84
bool StyleFlag::operator== (const StyleFlagValue right) const
7017 avox 85
{
7456 jghali 86
        int result = static_cast<int>( (value ^ right) & ScStyle_UserStyles);
87
        return (result == 0);
7017 avox 88
}
89
 
7456 jghali 90
bool StyleFlag::operator== (int right) const
91
{
92
        int result = static_cast<int>( (value ^ right) & ScStyle_UserStyles);
93
        return (result == 0);
94
}
95
 
96
bool StyleFlag::operator!= (const StyleFlag& right) const
97
{
98
        return !(*this==right);
99
}
100
 
101
bool StyleFlag::operator!= (const StyleFlagValue right) const
102
{
103
        return !(*this==right);
104
}
105
 
8193 avox 106
 
9607 avox 107
 
12340 pierre 108
void CharStyle::applyCharStyle(const QString& other)
6443 avox 109
{
110
        Style::applyStyle(other);
12340 pierre 111
        CharStyle *pOther = StylesLibrary::Char(other);
6443 avox 112
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
12340 pierre 113
        if (! pOther->inh_##attr_NAME) \
114
        set##attr_NAME(pOther->m_##attr_NAME);
6443 avox 115
#include "charstyle.attrdefs.cxx"
116
#undef ATTRDEF
9607 avox 117
        updateFeatures();
6443 avox 118
}
119
 
120
 
12340 pierre 121
void CharStyle::eraseCharStyle(const QString& other)
6443 avox 122
{
123
        Style::eraseStyle(other);
12340 pierre 124
        CharStyle *pOther = StylesLibrary::Char(other);
125
        pOther->validate();
6443 avox 126
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
12340 pierre 127
        if (!inh_##attr_NAME && m_##attr_NAME == pOther->m_##attr_NAME) \
6443 avox 128
                reset##attr_NAME();
129
#include "charstyle.attrdefs.cxx"
130
#undef ATTRDEF
9607 avox 131
        updateFeatures();
6443 avox 132
}
133
 
12340 pierre 134
bool CharStyle::equiv(const QString & other) const
6443 avox 135
{
12340 pierre 136
        const CharStyle * oth = StylesLibrary::Char( other );
6443 avox 137
        return  oth &&
6733 avox 138
                parent() == oth->parent()
6443 avox 139
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
6733 avox 140
                && (inh_##attr_NAME == oth->inh_##attr_NAME) \
141
                && (inh_##attr_NAME || m_##attr_NAME == oth->m_##attr_NAME)
6443 avox 142
#include "charstyle.attrdefs.cxx"
143
#undef ATTRDEF
144
                ;      
145
}
146
 
147
 
12314 pierre 148
// QString CharStyle::displayName() const
149
// {
150
//      if ( isDefaultStyle() )
151
//              return CommonStrings::trDefaultCharacterStyle;
152
//      if ( hasName() || !hasParent() || ! m_context)
153
//              return name();
154
// //   else if ( inheritsAll() )
155
// //           return parent()->displayName();
156
//      else 
157
//              return parentStyle()->displayName() + "+";
158
// }
6443 avox 159
 
160
 
161
 
162
QString CharStyle::asString() const
163
{
164
        QString result;
165
        if ( !inh_Font )
166
                result += QObject::tr("font %1 ").arg(font().scName());
167
        if ( !inh_FontSize )
168
                result += QObject::tr("size %1 ").arg(fontSize());
9607 avox 169
        if ( !inh_Features )
6443 avox 170
                result += QObject::tr("+style ");
171
        if ( !inh_StrokeColor  ||  !inh_StrokeShade  ||  !inh_FillColor || !inh_FillShade )
172
                result += QObject::tr("+color ");
173
        if ( !inh_UnderlineWidth  ||  !inh_UnderlineOffset )
174
                result += underlineWidth() > 0 ? QObject::tr("+underline ") : QObject::tr("-underline ");
6733 avox 175
        if ( !inh_StrikethruWidth || !inh_StrikethruOffset )
6443 avox 176
                result += strikethruWidth() > 0 ? QObject::tr("+strikeout ") : QObject::tr("-strikeout ");
177
        if ( !inh_ShadowXOffset || !inh_ShadowYOffset )
6733 avox 178
                result += shadowXOffset() != 0 || shadowYOffset() != 0 ? QObject::tr("+shadow ") : QObject::tr("-shadow ");
6443 avox 179
        if ( !inh_OutlineWidth )
180
                result += outlineWidth() > 0 ? QObject::tr("+outline ") : QObject::tr("-outline ");
181
        if ( !inh_Tracking )
182
                result += tracking() > 0 ? QObject::tr("+tracking %1 ").arg(tracking()) : QObject::tr("-tracking ");
183
        if ( !inh_BaselineOffset )
184
                result += QObject::tr("+baseline %1 ").arg(baselineOffset());
185
        if ( !inh_ScaleH || !inh_ScaleV )
186
                result += QObject::tr("+stretch ");
187
        if ( hasParent() )
188
                result += QObject::tr("parent= %1").arg(parent());
10394 cbradney 189
        return result.trimmed();
6443 avox 190
}
191
 
192
 
193
 
194
 
9607 avox 195
 
196
const QString CharStyle::INHERIT = "inherit";
197
const QString CharStyle::BOLD = "bold";
198
const QString CharStyle::ITALIC = "italic";
199
const QString CharStyle::UNDERLINE = "underline";
200
const QString CharStyle::UNDERLINEWORDS = "underlinewords";
201
const QString CharStyle::STRIKETHROUGH = "strike";
202
const QString CharStyle::SUPERSCRIPT = "superscript";
203
const QString CharStyle::SUBSCRIPT = "subscript";
204
const QString CharStyle::OUTLINE = "outline";
205
const QString CharStyle::SHADOWED = "shadowed";
206
const QString CharStyle::ALLCAPS = "allcaps";
207
const QString CharStyle::SMALLCAPS = "smallcaps";
208
// This is for loading legacy docs only. Scribus 1.3.4 should write smart hyphens in another way 
209
static const QString SHYPHEN = "shyphen";
210
 
211
 
212
QStringList StyleFlag::featureList() const
213
{
214
        QStringList result(CharStyle::INHERIT);
215
        if (*this & ScStyle_Underline)
216
                result << CharStyle::UNDERLINE;
217
        if (*this & ScStyle_UnderlineWords)
218
                result << CharStyle::UNDERLINEWORDS;
219
        if (*this & ScStyle_Strikethrough)
220
                result << CharStyle::STRIKETHROUGH;
221
        if (*this & ScStyle_Superscript)
222
                result << CharStyle::SUPERSCRIPT;
223
        if (*this & ScStyle_Subscript)
224
                result << CharStyle::SUBSCRIPT;
225
        if (*this & ScStyle_Outline)
226
                result << CharStyle::OUTLINE;
227
        if (*this & ScStyle_Shadowed)
228
                result << CharStyle::SHADOWED;
229
        if (*this & ScStyle_AllCaps)
230
                result << CharStyle::ALLCAPS;
231
        if (*this & ScStyle_SmallCaps)
232
                result << CharStyle::SMALLCAPS;
233
        if (*this & ScStyle_HyphenationPossible)
234
                result << SHYPHEN;
235
        return result;
236
}
237
 
238
 
239
void CharStyle::updateFeatures()
240
{
241
        m_Effects &= ~ScStyle_UserStyles;
242
        runFeatures(m_Features, dynamic_cast<const CharStyle*>(parentStyle()));
243
/* need to access global fontlist :-/
244
        if (!font().name().endsWith(fontVariant()))
245
        {
246
                m_font = ScFonts.instance().findFont(font().family() + fontVariant());
247
        }
248
 */
249
}
250
 
251
 
252
void CharStyle::runFeatures(const QStringList& featureList, const CharStyle* parent)
253
{
254
        QStringList::ConstIterator it;
255
        for (it = featureList.begin(); it != featureList.end(); ++it)
256
        {
10394 cbradney 257
                QString feature = it->trimmed();
9607 avox 258
                if (feature == INHERIT)
259
                {
260
                        if (parent)
261
                                runFeatures(parent->features(), dynamic_cast<const CharStyle*>(parent->parentStyle()));
262
                }
263
                else if (feature == BOLD)
264
                {
265
                        // select bolder font
266
                }
267
                else if (feature == ITALIC)
268
                {
269
                        // select italic font
270
                }
271
                else if (feature == UNDERLINE)
272
                {
273
                        m_Effects |= ScStyle_Underline;
274
                }
275
                else if (feature == UNDERLINEWORDS)
276
                {
277
                        m_Effects |= ScStyle_UnderlineWords;
278
                }
279
                else if (feature == STRIKETHROUGH)
280
                {
281
                        m_Effects |= ScStyle_Strikethrough;
282
                }
283
                else if (feature == SUPERSCRIPT)
284
                {
285
                        m_Effects |= ScStyle_Superscript;
286
                }
287
                else if (feature == SUBSCRIPT)
288
                {
289
                        m_Effects |= ScStyle_Subscript;
290
                }
291
                else if (feature == OUTLINE)
292
                {
293
                        m_Effects |= ScStyle_Outline;
294
                }
295
                else if (feature == SHADOWED)
296
                {
297
                        m_Effects |= ScStyle_Shadowed;
298
                }
299
                else if (feature == ALLCAPS)
300
                {
301
                        m_Effects |= ScStyle_AllCaps;
302
                }
303
                else if (feature == SMALLCAPS)
304
                {
305
                        m_Effects |= ScStyle_SmallCaps;
306
                }
307
                else if (feature == SHYPHEN)
308
                {
309
                        m_Effects |= ScStyle_HyphenationPossible;
310
                }
311
                else if (feature.startsWith("-"))
312
                {
313
                        QString no_feature = feature.mid(1);
314
                        if (no_feature == BOLD)
315
                        {
316
                                // deselect bolder font
317
                        }
318
                        else if (no_feature == ITALIC)
319
                        {
320
                                // deselect italic font
321
                        }
322
                        else if (no_feature == UNDERLINE)
323
                        {
324
                                m_Effects &= ~ScStyle_Underline;
325
                        }
326
                        else if (no_feature == UNDERLINEWORDS)
327
                        {
328
                                m_Effects &= ~ScStyle_UnderlineWords;
329
                        }
330
                        else if (no_feature == STRIKETHROUGH)
331
                        {
332
                                m_Effects &= ~ScStyle_Strikethrough;
333
                        }
334
                        else if (no_feature == SUPERSCRIPT)
335
                        {
336
                                m_Effects &= ~ScStyle_Superscript;
337
                        }
338
                        else if (no_feature == SUBSCRIPT)
339
                        {
340
                                m_Effects &= ~ScStyle_Subscript;
341
                        }
342
                        else if (no_feature == OUTLINE)
343
                        {
344
                                m_Effects &= ~ScStyle_Outline;
345
                        }
346
                        else if (no_feature == SHADOWED)
347
                        {
348
                                m_Effects &= ~ScStyle_Shadowed;
349
                        }
350
                        else if (no_feature == ALLCAPS)
351
                        {
352
                                m_Effects &= ~ScStyle_AllCaps;
353
                        }
354
                        else if (no_feature == SMALLCAPS)
355
                        {
356
                                m_Effects &= ~ScStyle_SmallCaps;
357
                        }
358
                        else {
10394 cbradney 359
                                qDebug("CharStyle: unknown feature: %s", feature.toLocal8Bit().constData());
9607 avox 360
                        }
361
                }
362
                else {
10394 cbradney 363
                        qDebug("CharStyle: unknown feature: %s", feature.toLocal8Bit().constData());
9607 avox 364
                }
365
 
366
        }
367
}
368
 
369
 
370
 
12340 pierre 371
void CharStyle::setStyle(const QString& other)
7242 avox 372
{
12340 pierre 373
        CharStyle *pOther = StylesLibrary::Char(other);
374
        pOther->validate();
375
        setParent(pOther->parent());
7242 avox 376
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
12340 pierre 377
        inh_##attr_NAME = pOther->inh_##attr_NAME; \
378
        m_##attr_NAME = pOther->m_##attr_NAME;
7242 avox 379
#include "charstyle.attrdefs.cxx"
380
#undef ATTRDEF
9607 avox 381
        updateFeatures();
7242 avox 382
}
6443 avox 383
 
8455 avox 384
void CharStyle::getNamedResources(ResourceCollection& lists) const
385
{
8858 cbradney 386
        for (const Style* sty = parentStyle(); sty != NULL; sty = sty->parentStyle())
12314 pierre 387
                lists.collectCharStyle(sty->uuid());
8455 avox 388
        lists.collectColor(fillColor());
389
        lists.collectColor(strokeColor());
390
        lists.collectFont(font().scName());
391
}
6443 avox 392
 
7242 avox 393
 
8455 avox 394
void CharStyle::replaceNamedResources(ResourceCollection& newNames)
395
{
8775 cbradney 396
        QMap<QString,QString>::ConstIterator it;
8455 avox 397
 
8775 cbradney 398
        if (!inh_FillColor && (it = newNames.colors().find(fillColor())) != newNames.colors().end())
10394 cbradney 399
                setFillColor(it.value());
8455 avox 400
 
8775 cbradney 401
        if (!inh_StrokeColor && (it = newNames.colors().find(strokeColor())) != newNames.colors().end())
10394 cbradney 402
                setStrokeColor(it.value());
8455 avox 403
 
8775 cbradney 404
        if (hasParent() && (it = newNames.charStyles().find(parent())) != newNames.charStyles().end())
10394 cbradney 405
                setParent(it.value());
8455 avox 406
 
8775 cbradney 407
        if (!inh_Font && (it = newNames.fonts().find(font().scName())) != newNames.fonts().end())
10394 cbradney 408
                setFont(newNames.availableFonts->findFont(it.value(), NULL));
9607 avox 409
        updateFeatures();
8455 avox 410
}
411
 
412
                                                                  /*
6443 avox 413
bool CharStyle::definesAll() const
414
{
415
        return definesLineSpacing() &&
416
        definesLeftMargin() &&
417
        definesRightMargin() &&
418
        definesFirstIndent() &&
419
        definesAlignment() &&
420
        definesGapBefore()  &&
421
        definesLineSpacingMode()  &&
422
        definesGapAfter()  &&
423
        definesHasDropCap() &&
424
        definesDropCapOffset() &&
425
        definesDropCapLines() &&
426
        definesUseBaselineGrid() &&
427
        charStyle().definesAll() ;
428
 
429
}
430
 
7242 avox 431
// equiv. to "*this == CharStyle()"
6443 avox 432
bool CharStyle::inheritsAll() const
433
{
434
        return inheritsLineSpacing() &&
435
        inheritsLeftMargin() &&
436
        inheritsRightMargin() &&
437
        inheritsFirstIndent() &&
438
        inheritsAlignment() &&
439
        inheritsGapBefore()  &&
440
        inheritsLineSpacingMode()  &&
441
        inheritsGapAfter()  &&
442
        inheritsHasDropCap() &&
443
        inheritsDropCapOffset() &&
444
        inheritsDropCapLines() &&
445
        inheritsUseBaselineGrid() &&
446
        charStyle().inheritsAll() ;
447
}
448
*/
449
 
8266 avox 450
 
451
Xml_string toXMLString(StyleFlag val)
452
{
453
        return toXMLString(static_cast<unsigned int>(val & ScStyle_UserStyles));
454
}
455
 
456
 
8800 jghali 457
void CharStyle::saxx(SaxHandler& handler, const Xml_string& elemtag) const
8266 avox 458
{
459
        Xml_attr att;
8337 avox 460
        Style::saxxAttributes(att);
8266 avox 461
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
462
        if (!inh_##attr_NAME) \
463
                att.insert(# attr_NAME, toXMLString(m_##attr_NAME));
464
#include "charstyle.attrdefs.cxx"
465
#undef ATTRDEF
12314 pierre 466
        if (!uuid().isEmpty())
467
                att["id"] = mkXMLName(elemtag + uuid());
8382 avox 468
        handler.begin(elemtag, att);
8455 avox 469
//      if (hasParent() && parentStyle())
470
//              parentStyle()->saxx(handler);   
8382 avox 471
        handler.end(elemtag);
8266 avox 472
}
473
 
474
 
475
 
476
template<>
8800 jghali 477
StyleFlag parse<StyleFlag>(const Xml_string& str)
8266 avox 478
{
479
        return StyleFlag(parseInt(str));
480
}
481
 
482
template<>
8800 jghali 483
ScFace parse<ScFace>(const Xml_string& str)
8266 avox 484
{
485
        // FIXME: enable font substitution here
486
        return PrefsManager::instance()->appPrefs.AvailFonts[str];
487
}
488
 
489
 
490
using namespace desaxe;
491
 
492
 
493
const Xml_string CharStyle::saxxDefaultElem("charstyle");
494
 
8834 cbradney 495
void CharStyle::desaxeRules(const Xml_string& prefixPattern, Digester& ruleset, Xml_string elemtag)
8382 avox 496
{
497
        Xml_string stylePrefix(Digester::concat(prefixPattern, elemtag));
498
        ruleset.addRule(stylePrefix, Factory<CharStyle>());
499
        ruleset.addRule(stylePrefix, IdRef<CharStyle>());
500
        Style::desaxeRules<CharStyle>(prefixPattern, ruleset, elemtag);
8266 avox 501
#define ATTRDEF(attr_TYPE, attr_GETTER, attr_NAME, attr_DEFAULT) \
8382 avox 502
        ruleset.addRule(stylePrefix, SetAttributeWithConversion<CharStyle, attr_TYPE> ( & CharStyle::set##attr_NAME,  # attr_NAME, &parse<attr_TYPE> ));
8266 avox 503
#include "charstyle.attrdefs.cxx"
504
#undef ATTRDEF          
8382 avox 505
}