Subversion Repositories Scribus

Rev

Rev 2212 | Rev 2501 | 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());
2282 fschmid 521
// TODO is this important ??
522
/*              QValueList<double>* tmp = s->getTabValues();
1579 tsoots 523
                for (uint i = 0; i < tmp->count(); ++i)
524
                {
525
                        double td = (*tmp)[i];
526
                        nameByAttrs += QString("%1-").arg(td);
2282 fschmid 527
                } */
1579 tsoots 528
                if (attrsStyles.contains(nameByAttrs))
529
                {
530
                        tname = attrsStyles[nameByAttrs]->getName();
531
                        ++pstyleCounts[nameByAttrs];
532
                        style->setName(tname);
533
                }
534
                else
535
                {
536
                        attrsStyles[nameByAttrs] = style;
537
                        pstyleCounts[nameByAttrs] = 1;
538
                        tname = style->getName();
539
                }
540
        }
541
        else if (!packStyles)
542
        {
543
                attrsStyles[name] = style;
544
                pstyleCounts[name] = 1;
545
                tname = style->getName();
546
        }
547
        if (!styles.contains(name))
548
        {
549
                if ((tname.find(docname) == -1) && (usePrefix))
550
                        style->setName(docname + "_" + tname);
551
                styles[name] = style;
552
        }
553
 }
554
 
555
 QString StyleReader::getFont(const QString& key)
556
 {
557
        if (fonts.contains(key))
558
                return fonts[key];
559
        else
560
                return key;
561
 }
562
 
563
 void StyleReader::setupFrameStyle()
564
 {
565
        QString fstyleName = "";
566
        int count = 0;
567
        CounterMap::Iterator it;
568
        for (it = pstyleCounts.begin(); it != pstyleCounts.end(); ++it)
569
        {
570
                if (it.data() > count)
571
                {
572
                        count = it.data();
573
                        fstyleName = it.key();
574
                }
575
        }
576
        gtFrameStyle* fstyle;
577
        gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(attrsStyles[fstyleName]);
578
        fstyle = new gtFrameStyle(*pstyle);
579
 
580
        if (!importTextOnly)
581
                writer->setFrameStyle(fstyle);
582
        delete fstyle;
583
 }
584
 
2212 tsoots 585
ListStyle* StyleReader::getList(const QString &name)
586
{
587
        ListStyle *tmp = 0;
588
        if (lists.contains(name))
589
                tmp = lists[name];
590
        return tmp;
591
}
592
 
1579 tsoots 593
 bool StyleReader::updateStyle(gtStyle* style, gtStyle* parent2Style, const QString& key, const QString& value)
594
 {
595
        gtParagraphStyle* pstyle = NULL;
596
        if (style->target() == "paragraph")
597
                pstyle = dynamic_cast<gtParagraphStyle*>(style);
598
        else
599
                pstyle = NULL;
600
        QString align = NULL;
601
        QString force = NULL;
602
 
603
        if (key == "style:font-name")
604
                style->getFont()->setName(getFont(value));
605
        else if (key == "fo:font-size")
606
        {
607
                double size = 0;
608
                double psize = 0;
609
                if (parent2Style != NULL)
610
                        psize = static_cast<double>(parent2Style->getFont()->getSize());
611
                else if (styles.contains("default-style"))
612
                        psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
613
                        psize = psize / 10;
614
                size = getSize(value, psize);
615
                int nsize = static_cast<int>(size * 10);
616
                style->getFont()->setSize(nsize);
1622 tsoots 617
                if (pstyle)
1579 tsoots 618
                        pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
619
        }
620
        else if ((key == "fo:line-height") && (parent2Style != NULL))
621
        {
622
                gtParagraphStyle* ppstyle;
623
                if (parent2Style->target() == "paragraph")
624
                {
625
                        ppstyle = dynamic_cast<gtParagraphStyle*>(parent2Style);
626
                        pstyle->setLineSpacing(getSize(value, writer->getPreferredLineSpacing(style->getFont()->getSize())));
627
                }
628
        }
629
        else if (key == "fo:color")
630
                style->getFont()->setColor(value);
631
        else if ((key == "style:use-window-font-color") && (value == "true"))
632
                        style->getFont()->setColor("Black");
633
        else if ((key == "fo:font-weight") && (value == "bold"))
634
                style->getFont()->setWeight(BOLD);
635
        else if ((key == "fo:font-style") && (value == "italic"))
636
                style->getFont()->setSlant(ITALIC);
1610 tsoots 637
        else if ((key == "style:text-underline-style") && (value != "none"))
1579 tsoots 638
                style->getFont()->toggleEffect(UNDERLINE);
639
        else if ((key == "style:text-crossing-out") && (value != "none"))
640
                style->getFont()->toggleEffect(STRIKETHROUGH);
641
        else if ((key == "fo:font-variant") && (value == "small-caps"))
642
                style->getFont()->toggleEffect(SMALL_CAPS);
643
        else if ((key == "style:text-outline") && (value == "true"))
644
        {
645
                style->getFont()->toggleEffect(OUTLINE);
646
                style->getFont()->setStrokeColor("Black");
647
                style->getFont()->setColor("White");
648
        }
649
        else if (key == "fo:letter-spacing")
650
                style->getFont()->setKerning(getSize(value));
651
        else if (key == "style:text-scale")
652
                style->getFont()->setHscale(static_cast<int>(getSize(value, -1.0)));
653
        else if ((key == "style:text-position") &&
654
                (((value).find("sub") != -1) ||
655
                        (((value).left(1) == "-") && ((value).left(1) != "0"))))
656
                style->getFont()->toggleEffect(SUBSCRIPT);
657
        else if ((key == "style:text-position") &&
658
                (((value).find("super") != -1) ||
659
                        (((value).left(1) != "-") && ((value).left(1) != "0"))))
660
                style->getFont()->toggleEffect(SUPERSCRIPT);
661
        else if ((key == "fo:margin-top") && (pstyle != NULL))
662
                pstyle->setSpaceAbove(getSize(value));
663
        else if ((key == "fo:margin-bottom") && (pstyle != NULL))
664
                pstyle->setSpaceBelow(getSize(value));
665
        else if ((key == "fo:margin-left") && (pstyle != NULL))
666
        {
667
                if (inList)
668
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
669
                else
670
                        pstyle->setIndent(getSize(value));     
671
        }
672
        else if ((key == "text:space-before") && (pstyle != NULL))
673
        {
674
                if (inList)
675
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
676
                else
677
                        pstyle->setIndent(getSize(value));     
678
        }
679
        else if ((key == "fo:text-indent") && (pstyle != NULL))
680
                pstyle->setFirstLineIndent(getSize(value));
681
        else if ((key == "fo:text-align") && (pstyle != NULL))
682
                align = value;
683
        else if ((key == "style:justify-single-word") && (pstyle != NULL))
684
                force = value;
685
 
686
        if (align != NULL)
687
        {
688
                if (align == "end")
689
                        pstyle->setAlignment(RIGHT);
690
                else if (align == "center")
691
                        pstyle->setAlignment(CENTER);
692
                else if (align == "justify")
693
                {
694
                        if (force != "false")
695
                                pstyle->setAlignment(FORCED);
696
                        else
697
                                pstyle->setAlignment(BLOCK);
698
                }
699
        }
700
 
701
        return true;
702
 }
703
 
704
 double StyleReader::getSize(QString s, double parentSize)
705
 {
706
        QString dbl = "0.0";
707
        QString lowerValue = s.lower();
708
        double ret = 0.0;
709
        if (lowerValue.find("pt") != -1)
710
        {
711
                dbl = lowerValue.remove("pt");
712
                ret = gtMeasure::d2d(dbl.toDouble(), PT);
713
        }
714
        else if (lowerValue.find("mm") != -1)
715
        {
716
                dbl = lowerValue.remove("mm");
717
                ret = gtMeasure::d2d(dbl.toDouble(), MM);
718
        }
719
        else if (lowerValue.find("cm") != -1)
720
        {
721
                dbl = lowerValue.remove("cm");
722
                ret = gtMeasure::d2d(dbl.toDouble() * 10, MM);
723
        }
724
        else if (lowerValue.find("in") != -1)
725
        {
726
                dbl = lowerValue.remove("inch");
727
                dbl = lowerValue.remove("in");
728
                ret = gtMeasure::d2d(dbl.toDouble(), IN);
729
        }
730
        else if (lowerValue.find("pi") != -1)
731
        {
732
                dbl = lowerValue.remove("pica");
733
                dbl = lowerValue.remove("pi");
734
                ret = gtMeasure::d2d(dbl.toDouble(), P);
735
        }
736
        else if (lowerValue.find("%") != -1)
737
        {
738
                dbl = lowerValue.remove("%");
739
                double factor = dbl.toDouble();
740
                if (parentSize != -1.0)
741
                {
742
                        factor = factor / 100;
743
                        ret = factor * parentSize;
744
                }
745
                else
746
                        ret = factor;
747
        }
748
        return ret;
749
 }
750
 
751
 StyleReader::~StyleReader()
752
 {
753
        sreader = NULL;
754
        StyleMap::Iterator it;
755
        for (it = styles.begin(); it != styles.end(); ++it)
756
        {
757
                if (it.data())
758
                {
759
                        delete it.data();
760
                        it.data() = NULL;
761
                }
762
        }
763
 }
764
 
765
 xmlSAXHandler sSAXHandlerStruct = {
766
        NULL, // internalSubset,
767
        NULL, // isStandalone,
768
        NULL, // hasInternalSubset,
769
        NULL, // hasExternalSubset,
770
        NULL, // resolveEntity,
771
        NULL, // getEntity,
772
        NULL, // entityDecl,
773
        NULL, // notationDecl,
774
        NULL, // attributeDecl,
775
        NULL, // elementDecl,
776
        NULL, // unparsedEntityDecl,
777
        NULL, // setDocumentLocator,
778
        NULL, // startDocument,
779
        NULL, // endDocument,
780
        StyleReader::startElement,
781
        StyleReader::endElement,
782
        NULL, // reference,
783
        NULL, // characters
784
        NULL, // ignorableWhitespace,
785
        NULL, // processingInstruction,
786
        NULL, // comment,
787
        NULL, // warning,
788
        NULL, // error,
789
        NULL, // fatalError,
790
        NULL, // getParameterEntity,
791
        NULL, // cdata,
792
        NULL,
793
        1
794
 #ifdef HAVE_XML26
795
        ,
796
        NULL,
797
        NULL,
798
        NULL,
799
        NULL
800
 #endif
801
 };
802
 
803
 xmlSAXHandlerPtr sSAXHandler = &sSAXHandlerStruct;
804
 
805
 void StyleReader::startElement(void*, const xmlChar * fullname, const xmlChar ** atts)
806
 {
807
        QString* name = new QString((const char*) fullname);
808
        name = new QString(name->lower());
809
        QXmlAttributes* attrs = new QXmlAttributes();
810
        if (atts)
811
        {
812
                for(const xmlChar** cur = atts; cur && *cur; cur += 2)
813
                        attrs->append(QString((char*)*cur), NULL, QString((char*)*cur), QString((char*)*(cur + 1)));
814
        }
815
        sreader->startElement(NULL, NULL, *name, *attrs);
816
 }
817
 
818
 void StyleReader::endElement(void*, const xmlChar * name)
819
 {
820
        QString *nname = new QString((const char*) name);
821
        nname = new QString(nname->lower());
822
        sreader->endElement(NULL, NULL, *nname);
823
 }
2212 tsoots 824
 
825
/*** ListLevel *****************************************************************************************/
826
 
827
const QString ListLevel::lowerUnits[10] = {"", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"};
828
const QString ListLevel::lowerTens[10] = {"", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"};
829
const QString ListLevel::lowerHundreds[10] = {"", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"};
830
const QString ListLevel::lowerThousands[4] = {"", "m", "mm", "mmm"};
831
const QString ListLevel::upperUnits[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
832
const QString ListLevel::upperTens[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
833
const QString ListLevel::upperHundreds[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCC", "CM"};
834
const QString ListLevel::upperThousands[4] = {"", "M", "MM", "MMM"};
835
const QString ListLevel::lowerAlphabets[27] = {"", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
836
                                    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
837
const QString ListLevel::upperAlphabets[27] = {"", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
838
                                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
839
 
840
ListLevel::ListLevel(uint level,
841
                         BulletType btype,
842
                         const QString &prefix,
843
                         const QString &suffix,
844
                         const QString &bullet,
845
                         uint displayLevels,
846
                         uint startValue) :
847
m_level(level),
848
m_btype(btype),
849
m_prefix(prefix),
850
m_suffix(suffix),
851
m_bullet(bullet),
852
m_displayLevels(displayLevels),
853
m_next(startValue)
854
{
855
 
856
}
857
 
858
QString ListLevel::bulletString()
859
{
860
        QString tmp;
861
        switch (m_btype) {
862
        case Bullet:
863
                tmp = m_bullet;
864
                break;
865
        case Number:
866
                tmp = QString("%1").arg(m_next);
867
                break;
868
        case LowerRoman:
869
                tmp = lowerRoman(m_next);
870
                break;
871
        case UpperRoman:
872
                tmp = upperRoman(m_next);
873
                break;
874
        case LowerAlpha:
875
                tmp = lowerAlpha(m_next);
876
                break;
877
        case UpperAlpha:
878
                tmp = upperAlpha(m_next);
879
                break;
880
        case Graphic:
881
                tmp = "*";
882
                break;
883
        default:
884
                tmp = "";
885
        };
886
        return tmp;
887
}
888
 
889
QString ListLevel::bullet()
890
{
891
 
892
        return QString(m_prefix + bulletString() + m_suffix);
893
}
894
 
895
QString ListLevel::prefix()
896
{
897
        return m_prefix;
898
}
899
 
900
QString ListLevel::suffix()
901
{
902
        return m_suffix;
903
}
904
 
905
void ListLevel::advance()
906
{
907
        ++m_next;
908
}
909
 
910
uint ListLevel::level()
911
{
912
        return m_level;
913
}
914
 
915
uint ListLevel::displayLevels()
916
{
917
        return m_displayLevels;
918
}
919
 
920
void ListLevel::reset()
921
{
922
        m_next = 0;
923
}
924
 
925
QString ListLevel::lowerRoman(uint n)
926
{
927
        return QString(lowerThousands[(n / 1000)] +
928
                       lowerHundreds[(n / 100) % 10] +
929
                       lowerTens[(n / 10) % 10] +
930
                       lowerUnits[(n) % 10]);
931
}
932
 
933
QString ListLevel::upperRoman(uint n)
934
{
935
        return QString(upperThousands[(n / 1000)] +
936
                       upperHundreds[(n / 100) % 10] +
937
                       upperTens[(n / 10) % 10] +
938
                       upperUnits[(n) % 10]);
939
}
940
 
941
QString ListLevel::lowerAlpha(uint n)
942
{
943
        QString tmp;
944
        uint rounds = static_cast<uint>(n / 26);
945
        if (rounds > 26)
946
                rounds = 0;
947
        uint leftover = n % 26;
948
        return QString(lowerAlphabets[rounds] + lowerAlphabets[leftover]);
949
}
950
 
951
QString ListLevel::upperAlpha(uint n)
952
{
953
        QString tmp;
954
        uint rounds = static_cast<uint>(n / 26);
955
        if (rounds > 26)
956
                rounds = 0;
957
        uint leftover = n % 26;
958
        return QString(upperAlphabets[rounds] + upperAlphabets[leftover]);
959
}
960
 
961
ListLevel::~ListLevel()
962
{
963
 
964
}
965
 
966
/*** ListStyle **********************************************************************************/
967
 
968
ListStyle::ListStyle(const QString &name, bool consecutiveNumbering, uint currentLevel) :
969
m_name(name),
970
m_consecutiveNumbering(consecutiveNumbering),
971
m_currentLevel(currentLevel),
972
m_count(0)
973
{
974
        for (uint i = 0; i < 11; ++i)
975
                levels[i] = 0;
976
}
977
 
978
void ListStyle::addLevel(uint level, ListLevel *llevel)
979
{
980
        if (level > 0 && level < 11)
981
                levels[level] = llevel;
982
}
983
 
984
QString ListStyle::bullet()
985
{
986
        uint displayLevels = levels[m_currentLevel]->displayLevels();
987
        if (displayLevels == 1)
988
                return QString(levels[m_currentLevel]->bullet() + " ");
989
 
990
        QString prefix = levels[m_currentLevel]->prefix();
991
        QString suffix = levels[m_currentLevel]->suffix();
992
        QString bullet = "";
993
        int start = m_currentLevel - displayLevels + 1;
994
        if (start < 1)
995
                return QString(levels[m_currentLevel]->bullet() + " ");
996
        while (static_cast<uint>(start) <= m_currentLevel)
997
        {
998
                if (static_cast<uint>(start) == m_currentLevel)
999
                        bullet += levels[start]->bulletString();
1000
                else
1001
                        bullet += levels[start]->bulletString() + ".";
1002
                ++start;
1003
        }
1004
        return QString(prefix + bullet + suffix + " ");
1005
}
1006
 
1007
void ListStyle::advance()
1008
{
1009
        ++m_count;
1010
        if (levels[m_currentLevel])
1011
                levels[m_currentLevel]->advance();
1012
}
1013
 
1014
void ListStyle::setLevel(uint level)
1015
{
1016
        if (level > 0 && level < 11)
1017
                m_currentLevel = level;
1018
}
1019
 
1020
QString& ListStyle::name()
1021
{
1022
        return m_name;
1023
}
1024
 
1025
void ListStyle::resetLevel()
1026
{
1027
        levels[m_currentLevel]->reset();
1028
}
1029
 
1030
ListStyle::~ListStyle()
1031
{
1032
        for (uint i = 0; i < 11; ++i)
1033
        {
1034
                delete levels[i];
1035
                levels[i] = 0;
1036
        }
1037
}
1038
 
1039
#endif