Subversion Repositories Scribus

Rev

Rev 6383 | Rev 10107 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 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
*/
1579 tsoots 7
 /***************************************************************************
8
  *   Copyright (C) 2004 by Riku Leino                                      *
9
  *   tsoots@gmail.com                                                      *
10
  *                                                                         *
11
  *   This program is free software; you can redistribute it and/or modify  *
12
  *   it under the terms of the GNU General Public License as published by  *
13
  *   the Free Software Foundation; either version 2 of the License, or     *
14
  *   (at your option) any later version.                                   *
15
  *                                                                         *
16
  *   This program is distributed in the hope that it will be useful,       *
17
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
18
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
19
  *   GNU General Public License for more details.                          *
20
  *                                                                         *
21
  *   You should have received a copy of the GNU General Public License     *
22
  *   along with this program; if not, write to the                         *
23
  *   Free Software Foundation, Inc.,                                       *
24
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
25
  ***************************************************************************/
26
 
27
 #include "stylereader.h"
28
 
29
 #ifdef HAVE_XML
30
 
2986 craig 31
 #include <scribusstructs.h>
1579 tsoots 32
 #include <gtmeasure.h>
33
 #include <gtparagraphstyle.h>
34
 #include <gtframestyle.h>
35
 #include <gtfont.h>
36
 
37
 StyleReader* StyleReader::sreader = NULL;
38
 
39
 extern xmlSAXHandlerPtr sSAXHandler;
40
 
41
StyleReader::StyleReader(QString documentName, gtWriter *w,
42
                         bool textOnly, bool prefix, bool combineStyles)
43
{
44
        sreader      = this;
45
        docname      = documentName;
46
        readProperties = false;
47
        writer       = w;
48
        importTextOnly = textOnly;
49
        usePrefix    = prefix;
50
        packStyles   = combineStyles;
2212 tsoots 51
        currentStyle = 0;
52
        currentListStyle = 0;
53
        parentStyle  = 0;
1579 tsoots 54
        inList       = false;
55
        currentList  = "";
56
        defaultStyleCreated = false;
57
}
58
 
59
 bool StyleReader::startElement(const QString&, const QString&, const QString &name, const QXmlAttributes &attrs)
60
 {
61
        if (name == "style:default-style")
62
                defaultStyle(attrs);
63
        else if (name == "style:paragraph-properties" ||
64
                 name == "style:text-properties" ||
65
                 name == "style:list-level-properties")
66
                styleProperties(attrs);
67
        else if (name == "style:style")
68
        {
69
                if (!defaultStyleCreated)
70
                {
71
                        currentStyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
72
                        currentStyle->setName("default-style");
73
                        defaultStyleCreated = true;
74
                }
75
                styleStyle(attrs);
76
        }
77
        else if (name == "style:tab-stop")
78
                tabStop(attrs);
79
        else if (name == "text:list-style")
80
        {
81
                for (int i = 0; i < attrs.count(); ++i)
82
                        if (attrs.localName(i) == "style:name")
83
                                currentList = attrs.value(i);
2212 tsoots 84
                currentListStyle = new ListStyle(currentList);
1579 tsoots 85
                inList = true;
86
        }
87
        else if (((name == "text:list-level-style-bullet") ||
88
                  (name == "text:list-level-style-number") ||
89
                  (name == "text:list-level-style-image")) && (inList))
90
        {
2212 tsoots 91
                BulletType bstyle = Bullet;
92
                QString prefix = "";
93
                QString suffix = "";
94
                QString bullet = "-";
95
                uint ulevel = 0;
96
                uint displayLevels = 1;
97
                uint startAt = 0;
1579 tsoots 98
                QString level = "";
99
                for (int i = 0; i < attrs.count(); ++i)
100
                {
101
                        if (attrs.localName(i) == "text:level")
102
                        {
2212 tsoots 103
                                ulevel = QString(attrs.value(i)).toUInt();
1579 tsoots 104
                                gtStyle *plist;
105
                                if (attrs.value(i) == "1")
106
                                {
107
                                        plist = listParents[currentList];
108
                                }
109
                                else
110
                                {
111
                                        int level = (attrs.value(i)).toInt();
112
                                        --level;
113
                                        plist = styles[QString(currentList + "_%1").arg(level)];
114
                                }
115
                                gtParagraphStyle *pstyle;
116
                                if (plist == NULL)
117
                                        plist = new gtStyle(*(styles["default-style"]));
118
 
119
                                if (plist->target() == "paragraph")
120
                                {
121
                                        pstyle = dynamic_cast<gtParagraphStyle*>(plist);
122
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*pstyle);
123
                                        currentStyle = tmp;
124
                                }
125
                                else
126
                                {
127
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*plist);
128
                                        currentStyle = tmp;
129
                                }
130
                                currentStyle->setName(currentList + "_" + attrs.value(i));
131
                        }
2212 tsoots 132
                        else if (attrs.localName(i) == "style:num-prefix")
133
                                prefix = attrs.value(i);
134
                        else if (attrs.localName(i) == "style:num-suffix")
135
                                suffix = attrs.value(i);
136
                        /*else if (attrs.localName(i) == "text:bullet-char")
137
                                bullet = attrs.value(i);*/
138
                        else if (attrs.localName(i) == "style:num-format") {
139
                                QString tmp = attrs.value(i);
140
                                if (tmp == "i")
141
                                        bstyle = LowerRoman;
142
                                else if (tmp == "I")
143
                                        bstyle = UpperRoman;
144
                                else if (tmp == "a")
145
                                        bstyle = LowerAlpha;
146
                                else if (tmp == "A")
147
                                        bstyle = UpperAlpha;
148
                                else if (tmp == "1")
149
                                        bstyle = Number;
150
                        }
151
                        else if (attrs.localName(i) == "text:start-value") {
152
                                startAt = QString(attrs.value(i)).toUInt();
153
                                if (startAt > 0)
154
                                        --startAt;
155
                        }
156
                        else if (attrs.localName(i) == "text:display-levels") {
157
                                displayLevels = QString(attrs.value(i)).toUInt();
158
                                if (displayLevels == 0)
159
                                        displayLevels = 1;
160
                        }
1579 tsoots 161
                }
2212 tsoots 162
                if (bstyle == Bullet) {
163
                        prefix = "";
164
                        suffix = "";
165
                }
166
                ListLevel *llevel = new ListLevel(ulevel, bstyle, prefix, suffix, bullet, displayLevels, startAt);
167
                currentListStyle->addLevel(ulevel, llevel);
1579 tsoots 168
                readProperties = true;
169
        }
170
        else if ((name == "style:drop-cap") && (readProperties))
171
        {
172
                if (currentStyle->target() == "paragraph")
173
                {
174
                        for (int i = 0; i < attrs.count(); ++i)
175
                        {
176
                                if (attrs.localName(i) == "style:lines")
177
                                {
178
                                        bool ok = false;
179
                                        QString sd = attrs.value(i);
180
                                        int dh = sd.toInt(&ok);
181
                                        if (ok)
182
                                        {
183
                                                gtParagraphStyle* s = dynamic_cast<gtParagraphStyle*>(currentStyle);
184
                                                s->setDropCapHeight(dh);
185
                                                s->setDropCap(true);
186
                                        }
187
                                }
188
                        }
189
                }
190
        }
191
        else if (name == "style:font-face")
192
        {
193
                QString key = "";
194
                QString family = "";
195
                QString style = "";
196
                for (int i = 0; i < attrs.count(); ++i)
197
                {
198
                        if (attrs.localName(i) == "style:name")
199
                                key = attrs.value(i);
200
                        else if (attrs.localName(i) == "svg:font-family")
201
                        {
202
                                family = attrs.value(i);
203
                                family = family.remove("'");
204
                        }
205
                        else if (attrs.localName(i) == "style:font-style-name")
206
                                style += attrs.value(i) + " ";
207
                }
208
                QString name = family + " " + style;
209
                name = name.simplifyWhiteSpace();
210
                fonts[key] = name;
211
        }
212
        return true;
213
 }
214
 
215
 void StyleReader::defaultStyle(const QXmlAttributes& attrs)
216
 {
217
        currentStyle = NULL;
218
        for (int i = 0; i < attrs.count(); ++i)
219
                if (attrs.localName(i) == "style:family")
220
                        if (attrs.value(i) == "paragraph")
221
                        {
222
                                currentStyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
223
                                currentStyle->setName("default-style");
224
                                readProperties = true;
225
                                defaultStyleCreated = true;
226
                        }
227
 }
228
 
229
 void StyleReader::styleProperties(const QXmlAttributes& attrs)
230
 {
231
        if ((currentStyle == NULL) || (!readProperties))
232
                return;
233
        gtParagraphStyle* pstyle = NULL;
234
        if (currentStyle->target() == "paragraph")
235
                pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
236
        else
237
                pstyle = NULL;
238
        QString align = NULL;
239
        QString force = NULL;
240
        bool hasColorTag = false;
241
        for (int i = 0; i < attrs.count(); ++i)
242
        {
243
                if ((attrs.localName(i) == "style:font-name") && (!inList))
244
                        currentStyle->getFont()->setName(getFont(attrs.value(i)));
245
                else if (attrs.localName(i) == "fo:font-size")
246
                {
247
                        double size = 0;
248
                        double psize = 0;
249
                        if (parentStyle != NULL)
250
                                psize = static_cast<double>(parentStyle->getFont()->getSize());
251
                        else if (styles.contains("default-style"))
252
                                psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
253
 
254
                        psize = psize / 10;
255
                        size = getSize(attrs.value(i), psize);
256
                        int nsize = static_cast<int>(size * 10);
257
                        currentStyle->getFont()->setSize(nsize);
1622 tsoots 258
                        if (pstyle)
1579 tsoots 259
                                pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
260
                }
261
                else if ((attrs.localName(i) == "fo:line-height") && (parentStyle != NULL))
262
                {
263
                        gtParagraphStyle* ppstyle;
264
                        if (parentStyle->target() == "paragraph")
265
                        {
266
                                ppstyle = dynamic_cast<gtParagraphStyle*>(parentStyle);
267
                                pstyle->setLineSpacing(getSize(attrs.value(i), writer->getPreferredLineSpacing(currentStyle->getFont()->getSize())));
268
                        }
269
                }
270
                else if (attrs.localName(i) == "fo:color")
271
                {
272
                        currentStyle->getFont()->setColor(attrs.value(i));
273
                        hasColorTag = true;
274
                }
275
                else if ((attrs.localName(i) == "style:use-window-font-color") && (attrs.value(i) == "true"))
276
                {
277
                        currentStyle->getFont()->setColor("Black");
278
                        hasColorTag = true;
279
                }
280
                else if ((attrs.localName(i) == "fo:font-weight") && (attrs.value(i) == "bold"))
281
                        currentStyle->getFont()->setWeight(BOLD);
282
                else if ((attrs.localName(i) == "fo:font-style") && (attrs.value(i) == "italic"))
283
                        currentStyle->getFont()->setSlant(ITALIC);
1610 tsoots 284
                else if ((attrs.localName(i) == "style:text-underline-style") && (attrs.value(i) != "none"))
1579 tsoots 285
                        currentStyle->getFont()->toggleEffect(UNDERLINE);
286
                else if ((attrs.localName(i) == "style:text-crossing-out") && (attrs.value(i) != "none"))
287
                        currentStyle->getFont()->toggleEffect(STRIKETHROUGH);
288
                else if ((attrs.localName(i) == "fo:font-variant") && (attrs.value(i) == "small-caps"))
289
                        currentStyle->getFont()->toggleEffect(SMALL_CAPS);
290
                else if ((attrs.localName(i) == "style:text-outline") && (attrs.value(i) == "true"))
291
                {
292
                        currentStyle->getFont()->toggleEffect(OUTLINE);
293
                        currentStyle->getFont()->setStrokeColor("Black");
294
                        currentStyle->getFont()->setColor("White");
295
                }
296
                else if (attrs.localName(i) == "fo:letter-spacing")
2501 fschmid 297
                        currentStyle->getFont()->setKerning(static_cast<int>(getSize(attrs.value(i), -1.0)));
1579 tsoots 298
                else if (attrs.localName(i) == "style:text-scale")
299
                        currentStyle->getFont()->setHscale(static_cast<int>(getSize(attrs.value(i), -1.0)));
300
                else if ((attrs.localName(i) == "style:text-position") &&
301
                        (((attrs.value(i)).find("sub") != -1) ||
302
                                (((attrs.value(i)).left(1) == "-") && ((attrs.value(i)).left(1) != "0"))))
303
                        currentStyle->getFont()->toggleEffect(SUBSCRIPT);
304
                else if ((attrs.localName(i) == "style:text-position") &&
305
                        (((attrs.value(i)).find("super") != -1) ||
306
                                (((attrs.value(i)).left(1) != "-") && ((attrs.value(i)).left(1) != "0"))))
307
                        currentStyle->getFont()->toggleEffect(SUPERSCRIPT);
308
                else if ((attrs.localName(i) == "fo:margin-top") && (pstyle != NULL))
309
                        pstyle->setSpaceAbove(getSize(attrs.value(i)));
310
                else if ((attrs.localName(i) == "fo:margin-bottom") && (pstyle != NULL))
311
                        pstyle->setSpaceBelow(getSize(attrs.value(i)));
312
                else if ((attrs.localName(i) == "fo:margin-left") && (pstyle != NULL))
313
                {
314
                        if (inList)
315
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
316
                        else
317
                                pstyle->setIndent(getSize(attrs.value(i)));    
318
                }
319
                else if ((attrs.localName(i) == "text:space-before") && (pstyle != NULL))
320
                {
2212 tsoots 321
                        /*if (inList)
1579 tsoots 322
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
2212 tsoots 323
                        else*/
1579 tsoots 324
                                pstyle->setIndent(getSize(attrs.value(i)));
325
                }
326
                else if ((attrs.localName(i) == "fo:text-indent") && (pstyle != NULL))
327
                        pstyle->setFirstLineIndent(getSize(attrs.value(i)));
328
                else if ((attrs.localName(i) == "fo:text-align") && (pstyle != NULL))
329
                        align = attrs.value(i);
330
                else if ((attrs.localName(i) == "style:justify-single-word") && (pstyle != NULL))
331
                        force = attrs.value(i);
332
        }
333
        if (align != NULL)
334
        {
335
                if (align == "end")
336
                        pstyle->setAlignment(RIGHT);
337
                else if (align == "center")
338
                        pstyle->setAlignment(CENTER);
339
                else if (align == "justify")
340
                {
341
                        if (force == "false")
342
                                pstyle->setAlignment(BLOCK);
343
                        else
344
                                pstyle->setAlignment(FORCED);
345
                }
346
        }
347
        if (!hasColorTag)
348
                currentStyle->getFont()->setColor("Black");
349
 }
350
 
351
 void StyleReader::styleStyle(const QXmlAttributes& attrs)
352
 {
353
        QString name = "";
354
        QString listName = NULL;
355
        bool isParaStyle = false;
356
        bool create = true;
357
        for (int i = 0; i < attrs.count(); ++i)
358
        {
359
                if (attrs.localName(i) == "style:family")
360
                {
361
                        if (attrs.value(i) == "paragraph")
362
                        {
363
                                isParaStyle = true;
364
                                readProperties = true;
365
                        }
366
                        else if (attrs.value(i) == "text")
367
                        {
368
                                isParaStyle = false;
369
                                readProperties = true;
370
                        }
371
                        else
372
                        {
373
                                readProperties = false;
374
                                return;
375
                        }
376
                }
377
                else if (attrs.localName(i) == "style:name")
378
                        name = attrs.value(i);
379
                else if (attrs.localName(i) == "style:parent-style-name")
380
                {
381
                        if (styles.contains(attrs.value(i)))
382
                                parentStyle = styles[attrs.value(i)];
383
                        else
384
                                parentStyle = NULL;
385
                }
386
                else if (attrs.localName(i) == "style:list-style-name")
387
                        listName = attrs.value(i);
388
        }
389
        if ((parentStyle == NULL) && (styles.contains("default-style")))
390
                parentStyle = styles["default-style"];
391
 
392
        if (create)
393
        {
394
                if (parentStyle == NULL)
395
                {
396
                        parentStyle = new gtStyle("tmp-parent");
397
                }
398
                if (isParaStyle)
399
                {
400
                        gtParagraphStyle *tmpP;
401
                        if (parentStyle->target() == "paragraph")
402
                        {
403
                                tmpP = dynamic_cast<gtParagraphStyle*>(parentStyle);
404
                                gtParagraphStyle* tmp = new gtParagraphStyle(*tmpP);
405
 //                             tmp->setAutoLineSpacing(true);
406
                                currentStyle = tmp;
407
                        }
408
                        else
409
                        {
410
                                gtParagraphStyle* tmp = new gtParagraphStyle(*parentStyle);
411
 //                             tmp->setAutoLineSpacing(true);
412
                                currentStyle = tmp;
413
                        }
414
                        if (listName != NULL)
415
                        {
416
                                listParents[listName] = currentStyle;
417
                        }
418
                }
419
                else
420
                        currentStyle = new gtStyle(*parentStyle);
421
 
422
                currentStyle->setName(name);
423
        }
424
        else
425
                currentStyle = NULL;
426
 }
427
 
428
 void StyleReader::tabStop(const QXmlAttributes& attrs)
429
 {
430
        if (currentStyle->target() == "paragraph")
431
        {
432
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
433
                QString pos = NULL;
434
                QString type = NULL;
435
                for (int i = 0; i < attrs.count(); ++i)
436
                {
437
                        if (attrs.localName(i) == "style:position")
438
                                pos = attrs.value(i);
439
                        else if (attrs.localName(i) == "style:type")
440
                                type = attrs.value(i);
441
 
442
                }
443
                if (pos != NULL)
444
                {
445
                        if (type == NULL)
446
                                type = "left";
447
                        double posd = getSize(pos);
448
                        if (type == "left")
449
                                pstyle->setTabValue(posd, LEFT_T);
450
                        else if (type == "right")
451
                                pstyle->setTabValue(posd, RIGHT_T);
452
                        else if (type == "center")
453
                                pstyle->setTabValue(posd, CENTER_T);
454
                        else
455
                                pstyle->setTabValue(posd, CENTER_T);
456
                }
457
        }
458
 }
459
 
460
 bool StyleReader::endElement(const QString&, const QString&, const QString &name)
461
 {
462
        if ((name == "style:default-style") && (currentStyle != NULL) && (readProperties))
463
        {
464
                setStyle(currentStyle->getName(), currentStyle);
465
                currentStyle = NULL;
466
                parentStyle = NULL;
467
                readProperties = false;
468
        }
469
        else if (((name == "style:style") ||
470
                  (name == "text:list-level-style-bullet") ||
471
                          (name == "text:list-level-style-number") ||
472
                          (name == "text:list-level-style-image")) && (currentStyle != NULL))
473
        {
474
                setStyle(currentStyle->getName(), currentStyle);
475
                currentStyle = NULL;
476
                parentStyle = NULL;
477
                readProperties = false;
478
        }
479
        else if (name == "text:list-style")
480
        {
2212 tsoots 481
                if (currentListStyle) {
482
                        lists[currentListStyle->name()] = currentListStyle;
483
                        currentListStyle = 0;
484
                }
1579 tsoots 485
                inList = false;
486
        }
487
 
488
        return true;
489
 }
490
 
491
 void StyleReader::parse(QString fileName)
492
 {
7276 jghali 493
#if defined(_WIN32)
494
        QString fname = QDir::convertSeparators(fileName);
495
        QCString fn = (qWinVersion() & Qt::WV_NT_based) ? fname.utf8() : fname.local8Bit();
496
#else
497
        QCString fn(fileName.local8Bit());
498
#endif
499
        xmlSAXParseFile(sSAXHandler, fn.data(), 1);
1579 tsoots 500
 }
501
 
502
 gtStyle* StyleReader::getStyle(const QString& name)
503
 {
504
        if (styles.contains(name))
505
        {
506
                gtStyle* tmp = styles[name];
507
                QString tname = tmp->getName();
508
                if ((tname.find(docname) == -1) && (usePrefix))
509
                        tmp->setName(docname + "_" + tname);
510
 
511
                return tmp;
512
        }
513
        else
514
                return styles["default-style"];
515
 
516
 }
517
 
518
 void StyleReader::setStyle(const QString& name, gtStyle* style)
519
 {
520
        gtParagraphStyle *s;
521
        QString tname = style->getName();
522
        if ((style->target() == "paragraph") && (packStyles))
523
        {
524
                s = dynamic_cast<gtParagraphStyle*>(style);
525
                QString nameByAttrs = QString("%1-").arg(s->getSpaceAbove());
526
                nameByAttrs += QString("%1-").arg(s->getSpaceBelow());
527
                nameByAttrs += QString("%1-").arg(s->getLineSpacing());
528
                nameByAttrs += QString("%1-").arg(s->getIndent());
529
                nameByAttrs += QString("%1-").arg(s->getFirstLineIndent());
530
                nameByAttrs += QString("%1-").arg(s->getAlignment());
531
                nameByAttrs += QString("%1-").arg(s->hasDropCap());
532
                nameByAttrs += QString("%1-").arg(s->getFont()->getColor());
533
                nameByAttrs += QString("%1-").arg(s->getFont()->getStrokeColor());
2282 fschmid 534
// TODO is this important ??
535
/*              QValueList<double>* tmp = s->getTabValues();
1579 tsoots 536
                for (uint i = 0; i < tmp->count(); ++i)
537
                {
538
                        double td = (*tmp)[i];
539
                        nameByAttrs += QString("%1-").arg(td);
2282 fschmid 540
                } */
1579 tsoots 541
                if (attrsStyles.contains(nameByAttrs))
542
                {
543
                        tname = attrsStyles[nameByAttrs]->getName();
544
                        ++pstyleCounts[nameByAttrs];
545
                        style->setName(tname);
546
                }
547
                else
548
                {
549
                        attrsStyles[nameByAttrs] = style;
550
                        pstyleCounts[nameByAttrs] = 1;
551
                        tname = style->getName();
552
                }
553
        }
554
        else if (!packStyles)
555
        {
556
                attrsStyles[name] = style;
557
                pstyleCounts[name] = 1;
558
                tname = style->getName();
559
        }
560
        if (!styles.contains(name))
561
        {
562
                if ((tname.find(docname) == -1) && (usePrefix))
563
                        style->setName(docname + "_" + tname);
564
                styles[name] = style;
565
        }
566
 }
567
 
568
 QString StyleReader::getFont(const QString& key)
569
 {
570
        if (fonts.contains(key))
571
                return fonts[key];
572
        else
573
                return key;
574
 }
575
 
576
 void StyleReader::setupFrameStyle()
577
 {
578
        QString fstyleName = "";
579
        int count = 0;
580
        CounterMap::Iterator it;
581
        for (it = pstyleCounts.begin(); it != pstyleCounts.end(); ++it)
582
        {
583
                if (it.data() > count)
584
                {
585
                        count = it.data();
586
                        fstyleName = it.key();
587
                }
588
        }
589
        gtFrameStyle* fstyle;
590
        gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(attrsStyles[fstyleName]);
591
        fstyle = new gtFrameStyle(*pstyle);
592
 
593
        if (!importTextOnly)
594
                writer->setFrameStyle(fstyle);
595
        delete fstyle;
596
 }
597
 
2212 tsoots 598
ListStyle* StyleReader::getList(const QString &name)
599
{
600
        ListStyle *tmp = 0;
601
        if (lists.contains(name))
602
                tmp = lists[name];
603
        return tmp;
604
}
605
 
1579 tsoots 606
 bool StyleReader::updateStyle(gtStyle* style, gtStyle* parent2Style, const QString& key, const QString& value)
607
 {
608
        gtParagraphStyle* pstyle = NULL;
609
        if (style->target() == "paragraph")
610
                pstyle = dynamic_cast<gtParagraphStyle*>(style);
611
        else
612
                pstyle = NULL;
613
        QString align = NULL;
614
        QString force = NULL;
615
 
616
        if (key == "style:font-name")
617
                style->getFont()->setName(getFont(value));
618
        else if (key == "fo:font-size")
619
        {
620
                double size = 0;
621
                double psize = 0;
622
                if (parent2Style != NULL)
623
                        psize = static_cast<double>(parent2Style->getFont()->getSize());
624
                else if (styles.contains("default-style"))
625
                        psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
626
                        psize = psize / 10;
627
                size = getSize(value, psize);
628
                int nsize = static_cast<int>(size * 10);
629
                style->getFont()->setSize(nsize);
1622 tsoots 630
                if (pstyle)
1579 tsoots 631
                        pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
632
        }
633
        else if ((key == "fo:line-height") && (parent2Style != NULL))
634
        {
635
                gtParagraphStyle* ppstyle;
636
                if (parent2Style->target() == "paragraph")
637
                {
638
                        ppstyle = dynamic_cast<gtParagraphStyle*>(parent2Style);
639
                        pstyle->setLineSpacing(getSize(value, writer->getPreferredLineSpacing(style->getFont()->getSize())));
640
                }
641
        }
642
        else if (key == "fo:color")
643
                style->getFont()->setColor(value);
644
        else if ((key == "style:use-window-font-color") && (value == "true"))
645
                        style->getFont()->setColor("Black");
646
        else if ((key == "fo:font-weight") && (value == "bold"))
647
                style->getFont()->setWeight(BOLD);
648
        else if ((key == "fo:font-style") && (value == "italic"))
649
                style->getFont()->setSlant(ITALIC);
1610 tsoots 650
        else if ((key == "style:text-underline-style") && (value != "none"))
1579 tsoots 651
                style->getFont()->toggleEffect(UNDERLINE);
652
        else if ((key == "style:text-crossing-out") && (value != "none"))
653
                style->getFont()->toggleEffect(STRIKETHROUGH);
654
        else if ((key == "fo:font-variant") && (value == "small-caps"))
655
                style->getFont()->toggleEffect(SMALL_CAPS);
656
        else if ((key == "style:text-outline") && (value == "true"))
657
        {
658
                style->getFont()->toggleEffect(OUTLINE);
659
                style->getFont()->setStrokeColor("Black");
660
                style->getFont()->setColor("White");
661
        }
662
        else if (key == "fo:letter-spacing")
2501 fschmid 663
                style->getFont()->setKerning(static_cast<int>(getSize(value, -1.0)));
1579 tsoots 664
        else if (key == "style:text-scale")
665
                style->getFont()->setHscale(static_cast<int>(getSize(value, -1.0)));
666
        else if ((key == "style:text-position") &&
667
                (((value).find("sub") != -1) ||
668
                        (((value).left(1) == "-") && ((value).left(1) != "0"))))
669
                style->getFont()->toggleEffect(SUBSCRIPT);
670
        else if ((key == "style:text-position") &&
671
                (((value).find("super") != -1) ||
672
                        (((value).left(1) != "-") && ((value).left(1) != "0"))))
673
                style->getFont()->toggleEffect(SUPERSCRIPT);
674
        else if ((key == "fo:margin-top") && (pstyle != NULL))
675
                pstyle->setSpaceAbove(getSize(value));
676
        else if ((key == "fo:margin-bottom") && (pstyle != NULL))
677
                pstyle->setSpaceBelow(getSize(value));
678
        else if ((key == "fo:margin-left") && (pstyle != NULL))
679
        {
680
                if (inList)
681
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
682
                else
683
                        pstyle->setIndent(getSize(value));     
684
        }
685
        else if ((key == "text:space-before") && (pstyle != NULL))
686
        {
687
                if (inList)
688
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
689
                else
690
                        pstyle->setIndent(getSize(value));     
691
        }
692
        else if ((key == "fo:text-indent") && (pstyle != NULL))
693
                pstyle->setFirstLineIndent(getSize(value));
694
        else if ((key == "fo:text-align") && (pstyle != NULL))
695
                align = value;
696
        else if ((key == "style:justify-single-word") && (pstyle != NULL))
697
                force = value;
698
 
699
        if (align != NULL)
700
        {
701
                if (align == "end")
702
                        pstyle->setAlignment(RIGHT);
703
                else if (align == "center")
704
                        pstyle->setAlignment(CENTER);
705
                else if (align == "justify")
706
                {
707
                        if (force != "false")
708
                                pstyle->setAlignment(FORCED);
709
                        else
710
                                pstyle->setAlignment(BLOCK);
711
                }
712
        }
713
 
714
        return true;
715
 }
716
 
717
 double StyleReader::getSize(QString s, double parentSize)
718
 {
719
        QString dbl = "0.0";
720
        QString lowerValue = s.lower();
721
        double ret = 0.0;
722
        if (lowerValue.find("pt") != -1)
723
        {
724
                dbl = lowerValue.remove("pt");
2594 cbradney 725
                ret = gtMeasure::d2d(dbl.toDouble(), SC_PT);
1579 tsoots 726
        }
727
        else if (lowerValue.find("mm") != -1)
728
        {
729
                dbl = lowerValue.remove("mm");
2594 cbradney 730
                ret = gtMeasure::d2d(dbl.toDouble(), SC_MM);
1579 tsoots 731
        }
732
        else if (lowerValue.find("cm") != -1)
733
        {
734
                dbl = lowerValue.remove("cm");
2594 cbradney 735
                ret = gtMeasure::d2d(dbl.toDouble() * 10, SC_MM);
1579 tsoots 736
        }
737
        else if (lowerValue.find("in") != -1)
738
        {
739
                dbl = lowerValue.remove("inch");
740
                dbl = lowerValue.remove("in");
2594 cbradney 741
                ret = gtMeasure::d2d(dbl.toDouble(), SC_IN);
1579 tsoots 742
        }
743
        else if (lowerValue.find("pi") != -1)
744
        {
745
                dbl = lowerValue.remove("pica");
746
                dbl = lowerValue.remove("pi");
2594 cbradney 747
                ret = gtMeasure::d2d(dbl.toDouble(), SC_P);
1579 tsoots 748
        }
2594 cbradney 749
        else if (lowerValue.find("c") != -1)
750
        {
751
                dbl = lowerValue.remove("cicero");
752
                dbl = lowerValue.remove("c");
753
                ret = gtMeasure::d2d(dbl.toDouble(), SC_C);
754
        }
1579 tsoots 755
        else if (lowerValue.find("%") != -1)
756
        {
757
                dbl = lowerValue.remove("%");
758
                double factor = dbl.toDouble();
759
                if (parentSize != -1.0)
760
                {
761
                        factor = factor / 100;
762
                        ret = factor * parentSize;
763
                }
764
                else
765
                        ret = factor;
766
        }
767
        return ret;
768
 }
769
 
770
 StyleReader::~StyleReader()
771
 {
772
        sreader = NULL;
773
        StyleMap::Iterator it;
774
        for (it = styles.begin(); it != styles.end(); ++it)
775
        {
776
                if (it.data())
777
                {
778
                        delete it.data();
779
                        it.data() = NULL;
780
                }
781
        }
782
 }
783
 
784
 xmlSAXHandler sSAXHandlerStruct = {
785
        NULL, // internalSubset,
786
        NULL, // isStandalone,
787
        NULL, // hasInternalSubset,
788
        NULL, // hasExternalSubset,
789
        NULL, // resolveEntity,
790
        NULL, // getEntity,
791
        NULL, // entityDecl,
792
        NULL, // notationDecl,
793
        NULL, // attributeDecl,
794
        NULL, // elementDecl,
795
        NULL, // unparsedEntityDecl,
796
        NULL, // setDocumentLocator,
797
        NULL, // startDocument,
798
        NULL, // endDocument,
799
        StyleReader::startElement,
800
        StyleReader::endElement,
801
        NULL, // reference,
802
        NULL, // characters
803
        NULL, // ignorableWhitespace,
804
        NULL, // processingInstruction,
805
        NULL, // comment,
806
        NULL, // warning,
807
        NULL, // error,
808
        NULL, // fatalError,
809
        NULL, // getParameterEntity,
810
        NULL, // cdata,
811
        NULL,
812
        1
813
 #ifdef HAVE_XML26
814
        ,
815
        NULL,
816
        NULL,
817
        NULL,
818
        NULL
819
 #endif
820
 };
821
 
822
 xmlSAXHandlerPtr sSAXHandler = &sSAXHandlerStruct;
823
 
824
 void StyleReader::startElement(void*, const xmlChar * fullname, const xmlChar ** atts)
825
 {
826
        QString* name = new QString((const char*) fullname);
827
        name = new QString(name->lower());
828
        QXmlAttributes* attrs = new QXmlAttributes();
829
        if (atts)
830
        {
831
                for(const xmlChar** cur = atts; cur && *cur; cur += 2)
832
                        attrs->append(QString((char*)*cur), NULL, QString((char*)*cur), QString((char*)*(cur + 1)));
833
        }
834
        sreader->startElement(NULL, NULL, *name, *attrs);
835
 }
836
 
837
 void StyleReader::endElement(void*, const xmlChar * name)
838
 {
839
        QString *nname = new QString((const char*) name);
840
        nname = new QString(nname->lower());
841
        sreader->endElement(NULL, NULL, *nname);
842
 }
2212 tsoots 843
 
844
/*** ListLevel *****************************************************************************************/
845
 
846
const QString ListLevel::lowerUnits[10] = {"", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"};
847
const QString ListLevel::lowerTens[10] = {"", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"};
848
const QString ListLevel::lowerHundreds[10] = {"", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"};
849
const QString ListLevel::lowerThousands[4] = {"", "m", "mm", "mmm"};
850
const QString ListLevel::upperUnits[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
851
const QString ListLevel::upperTens[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
852
const QString ListLevel::upperHundreds[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCC", "CM"};
853
const QString ListLevel::upperThousands[4] = {"", "M", "MM", "MMM"};
854
const QString ListLevel::lowerAlphabets[27] = {"", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
855
                                    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
856
const QString ListLevel::upperAlphabets[27] = {"", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
857
                                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
858
 
859
ListLevel::ListLevel(uint level,
860
                         BulletType btype,
861
                         const QString &prefix,
862
                         const QString &suffix,
863
                         const QString &bullet,
864
                         uint displayLevels,
865
                         uint startValue) :
866
m_level(level),
867
m_btype(btype),
868
m_prefix(prefix),
869
m_suffix(suffix),
870
m_bullet(bullet),
871
m_displayLevels(displayLevels),
872
m_next(startValue)
873
{
874
 
875
}
876
 
877
QString ListLevel::bulletString()
878
{
879
        QString tmp;
880
        switch (m_btype) {
881
        case Bullet:
882
                tmp = m_bullet;
883
                break;
884
        case Number:
885
                tmp = QString("%1").arg(m_next);
886
                break;
887
        case LowerRoman:
888
                tmp = lowerRoman(m_next);
889
                break;
890
        case UpperRoman:
891
                tmp = upperRoman(m_next);
892
                break;
893
        case LowerAlpha:
894
                tmp = lowerAlpha(m_next);
895
                break;
896
        case UpperAlpha:
897
                tmp = upperAlpha(m_next);
898
                break;
899
        case Graphic:
900
                tmp = "*";
901
                break;
902
        default:
903
                tmp = "";
904
        };
905
        return tmp;
906
}
907
 
908
QString ListLevel::bullet()
909
{
910
 
911
        return QString(m_prefix + bulletString() + m_suffix);
912
}
913
 
914
QString ListLevel::prefix()
915
{
916
        return m_prefix;
917
}
918
 
919
QString ListLevel::suffix()
920
{
921
        return m_suffix;
922
}
923
 
924
void ListLevel::advance()
925
{
926
        ++m_next;
927
}
928
 
929
uint ListLevel::level()
930
{
931
        return m_level;
932
}
933
 
934
uint ListLevel::displayLevels()
935
{
936
        return m_displayLevels;
937
}
938
 
939
void ListLevel::reset()
940
{
941
        m_next = 0;
942
}
943
 
944
QString ListLevel::lowerRoman(uint n)
945
{
946
        return QString(lowerThousands[(n / 1000)] +
947
                       lowerHundreds[(n / 100) % 10] +
948
                       lowerTens[(n / 10) % 10] +
949
                       lowerUnits[(n) % 10]);
950
}
951
 
952
QString ListLevel::upperRoman(uint n)
953
{
954
        return QString(upperThousands[(n / 1000)] +
955
                       upperHundreds[(n / 100) % 10] +
956
                       upperTens[(n / 10) % 10] +
957
                       upperUnits[(n) % 10]);
958
}
959
 
960
QString ListLevel::lowerAlpha(uint n)
961
{
962
        QString tmp;
963
        uint rounds = static_cast<uint>(n / 26);
964
        if (rounds > 26)
965
                rounds = 0;
966
        uint leftover = n % 26;
967
        return QString(lowerAlphabets[rounds] + lowerAlphabets[leftover]);
968
}
969
 
970
QString ListLevel::upperAlpha(uint n)
971
{
972
        QString tmp;
973
        uint rounds = static_cast<uint>(n / 26);
974
        if (rounds > 26)
975
                rounds = 0;
976
        uint leftover = n % 26;
977
        return QString(upperAlphabets[rounds] + upperAlphabets[leftover]);
978
}
979
 
980
ListLevel::~ListLevel()
981
{
982
 
983
}
984
 
985
/*** ListStyle **********************************************************************************/
986
 
987
ListStyle::ListStyle(const QString &name, bool consecutiveNumbering, uint currentLevel) :
988
m_name(name),
989
m_consecutiveNumbering(consecutiveNumbering),
990
m_currentLevel(currentLevel),
991
m_count(0)
992
{
993
        for (uint i = 0; i < 11; ++i)
994
                levels[i] = 0;
995
}
996
 
997
void ListStyle::addLevel(uint level, ListLevel *llevel)
998
{
999
        if (level > 0 && level < 11)
1000
                levels[level] = llevel;
1001
}
1002
 
1003
QString ListStyle::bullet()
1004
{
1005
        uint displayLevels = levels[m_currentLevel]->displayLevels();
1006
        if (displayLevels == 1)
1007
                return QString(levels[m_currentLevel]->bullet() + " ");
1008
 
1009
        QString prefix = levels[m_currentLevel]->prefix();
1010
        QString suffix = levels[m_currentLevel]->suffix();
1011
        QString bullet = "";
1012
        int start = m_currentLevel - displayLevels + 1;
1013
        if (start < 1)
1014
                return QString(levels[m_currentLevel]->bullet() + " ");
1015
        while (static_cast<uint>(start) <= m_currentLevel)
1016
        {
1017
                if (static_cast<uint>(start) == m_currentLevel)
1018
                        bullet += levels[start]->bulletString();
1019
                else
1020
                        bullet += levels[start]->bulletString() + ".";
1021
                ++start;
1022
        }
1023
        return QString(prefix + bullet + suffix + " ");
1024
}
1025
 
1026
void ListStyle::advance()
1027
{
1028
        ++m_count;
1029
        if (levels[m_currentLevel])
1030
                levels[m_currentLevel]->advance();
1031
}
1032
 
1033
void ListStyle::setLevel(uint level)
1034
{
1035
        if (level > 0 && level < 11)
1036
                m_currentLevel = level;
1037
}
1038
 
1039
QString& ListStyle::name()
1040
{
1041
        return m_name;
1042
}
1043
 
1044
void ListStyle::resetLevel()
1045
{
1046
        levels[m_currentLevel]->reset();
1047
}
1048
 
1049
ListStyle::~ListStyle()
1050
{
1051
        for (uint i = 0; i < 11; ++i)
1052
        {
1053
                delete levels[i];
1054
                levels[i] = 0;
1055
        }
1056
}
1057
 
1058
#endif