Subversion Repositories Scribus

Rev

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