Subversion Repositories Scribus

Rev

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

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