Subversion Repositories Scribus

Rev

Rev 1610 | Go to most recent revision | Details | 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;
44
        currentStyle = NULL;
45
        parentStyle  = NULL;
46
        inList       = false;
47
        currentList  = "";
48
        defaultStyleCreated = false;
49
}
50
 
51
 bool StyleReader::startElement(const QString&, const QString&, const QString &name, const QXmlAttributes &attrs)
52
 {
53
        if (name == "style:default-style")
54
                defaultStyle(attrs);
55
        else if (name == "style:paragraph-properties" ||
56
                 name == "style:text-properties" ||
57
                 name == "style:list-level-properties")
58
                styleProperties(attrs);
59
        else if (name == "style:style")
60
        {
61
                if (!defaultStyleCreated)
62
                {
63
                        currentStyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
64
                        currentStyle->setName("default-style");
65
                        defaultStyleCreated = true;
66
                }
67
                styleStyle(attrs);
68
        }
69
        else if (name == "style:tab-stop")
70
                tabStop(attrs);
71
        else if (name == "text:list-style")
72
        {
73
                for (int i = 0; i < attrs.count(); ++i)
74
                        if (attrs.localName(i) == "style:name")
75
                                currentList = attrs.value(i);
76
                inList = true;
77
        }
78
        else if (((name == "text:list-level-style-bullet") ||
79
                  (name == "text:list-level-style-number") ||
80
                  (name == "text:list-level-style-image")) && (inList))
81
        {
82
                QString level = "";
83
                for (int i = 0; i < attrs.count(); ++i)
84
                {
85
                        if (attrs.localName(i) == "text:level")
86
                        {
87
                                gtStyle *plist;
88
                                if (attrs.value(i) == "1")
89
                                {
90
                                        plist = listParents[currentList];
91
                                }
92
                                else
93
                                {
94
                                        int level = (attrs.value(i)).toInt();
95
                                        --level;
96
                                        plist = styles[QString(currentList + "_%1").arg(level)];
97
                                }
98
                                gtParagraphStyle *pstyle;
99
                                if (plist == NULL)
100
                                        plist = new gtStyle(*(styles["default-style"]));
101
 
102
                                if (plist->target() == "paragraph")
103
                                {
104
                                        pstyle = dynamic_cast<gtParagraphStyle*>(plist);
105
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*pstyle);
106
                                        currentStyle = tmp;
107
                                }
108
                                else
109
                                {
110
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*plist);
111
                                        currentStyle = tmp;
112
                                }
113
                                currentStyle->setName(currentList + "_" + attrs.value(i));
114
                        }
115
                }
116
                readProperties = true;
117
        }
118
        else if ((name == "style:drop-cap") && (readProperties))
119
        {
120
                if (currentStyle->target() == "paragraph")
121
                {
122
                        for (int i = 0; i < attrs.count(); ++i)
123
                        {
124
                                if (attrs.localName(i) == "style:lines")
125
                                {
126
                                        bool ok = false;
127
                                        QString sd = attrs.value(i);
128
                                        int dh = sd.toInt(&ok);
129
                                        if (ok)
130
                                        {
131
                                                gtParagraphStyle* s = dynamic_cast<gtParagraphStyle*>(currentStyle);
132
                                                s->setDropCapHeight(dh);
133
                                                s->setDropCap(true);
134
                                        }
135
                                }
136
                        }
137
                }
138
        }
139
        else if (name == "style:font-face")
140
        {
141
                QString key = "";
142
                QString family = "";
143
                QString style = "";
144
                for (int i = 0; i < attrs.count(); ++i)
145
                {
146
                        if (attrs.localName(i) == "style:name")
147
                                key = attrs.value(i);
148
                        else if (attrs.localName(i) == "svg:font-family")
149
                        {
150
                                family = attrs.value(i);
151
                                family = family.remove("'");
152
                        }
153
                        else if (attrs.localName(i) == "style:font-style-name")
154
                                style += attrs.value(i) + " ";
155
                }
156
                QString name = family + " " + style;
157
                name = name.simplifyWhiteSpace();
158
                fonts[key] = name;
159
        }
160
        return true;
161
 }
162
 
163
 void StyleReader::defaultStyle(const QXmlAttributes& attrs)
164
 {
165
        currentStyle = NULL;
166
        for (int i = 0; i < attrs.count(); ++i)
167
                if (attrs.localName(i) == "style:family")
168
                        if (attrs.value(i) == "paragraph")
169
                        {
170
                                currentStyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
171
                                currentStyle->setName("default-style");
172
                                readProperties = true;
173
                                defaultStyleCreated = true;
174
                        }
175
 }
176
 
177
 void StyleReader::styleProperties(const QXmlAttributes& attrs)
178
 {
179
        if ((currentStyle == NULL) || (!readProperties))
180
                return;
181
        gtParagraphStyle* pstyle = NULL;
182
        if (currentStyle->target() == "paragraph")
183
                pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
184
        else
185
                pstyle = NULL;
186
        QString align = NULL;
187
        QString force = NULL;
188
        bool hasColorTag = false;
189
        for (int i = 0; i < attrs.count(); ++i)
190
        {
191
                if ((attrs.localName(i) == "style:font-name") && (!inList))
192
                        currentStyle->getFont()->setName(getFont(attrs.value(i)));
193
                else if (attrs.localName(i) == "fo:font-size")
194
                {
195
                        double size = 0;
196
                        double psize = 0;
197
                        if (parentStyle != NULL)
198
                                psize = static_cast<double>(parentStyle->getFont()->getSize());
199
                        else if (styles.contains("default-style"))
200
                                psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
201
 
202
                        psize = psize / 10;
203
                        size = getSize(attrs.value(i), psize);
204
                        int nsize = static_cast<int>(size * 10);
205
                        currentStyle->getFont()->setSize(nsize);
206
                        if ((currentStyle->getName() == "default-style") && (pstyle != NULL))
207
                                pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
208
                }
209
                else if ((attrs.localName(i) == "fo:line-height") && (parentStyle != NULL))
210
                {
211
                        gtParagraphStyle* ppstyle;
212
                        if (parentStyle->target() == "paragraph")
213
                        {
214
                                ppstyle = dynamic_cast<gtParagraphStyle*>(parentStyle);
215
                                pstyle->setLineSpacing(getSize(attrs.value(i), writer->getPreferredLineSpacing(currentStyle->getFont()->getSize())));
216
                        }
217
                }
218
                else if (attrs.localName(i) == "fo:color")
219
                {
220
                        currentStyle->getFont()->setColor(attrs.value(i));
221
                        hasColorTag = true;
222
                }
223
                else if ((attrs.localName(i) == "style:use-window-font-color") && (attrs.value(i) == "true"))
224
                {
225
                        currentStyle->getFont()->setColor("Black");
226
                        hasColorTag = true;
227
                }
228
                else if ((attrs.localName(i) == "fo:font-weight") && (attrs.value(i) == "bold"))
229
                        currentStyle->getFont()->setWeight(BOLD);
230
                else if ((attrs.localName(i) == "fo:font-style") && (attrs.value(i) == "italic"))
231
                        currentStyle->getFont()->setSlant(ITALIC);
232
                else if ((attrs.localName(i) == "style:text-underline") && (attrs.value(i) != "none"))
233
                        currentStyle->getFont()->toggleEffect(UNDERLINE);
234
                else if ((attrs.localName(i) == "style:text-crossing-out") && (attrs.value(i) != "none"))
235
                        currentStyle->getFont()->toggleEffect(STRIKETHROUGH);
236
                else if ((attrs.localName(i) == "fo:font-variant") && (attrs.value(i) == "small-caps"))
237
                        currentStyle->getFont()->toggleEffect(SMALL_CAPS);
238
                else if ((attrs.localName(i) == "style:text-outline") && (attrs.value(i) == "true"))
239
                {
240
                        currentStyle->getFont()->toggleEffect(OUTLINE);
241
                        currentStyle->getFont()->setStrokeColor("Black");
242
                        currentStyle->getFont()->setColor("White");
243
                }
244
                else if (attrs.localName(i) == "fo:letter-spacing")
245
                        currentStyle->getFont()->setKerning(getSize(attrs.value(i)));
246
                else if (attrs.localName(i) == "style:text-scale")
247
                        currentStyle->getFont()->setHscale(static_cast<int>(getSize(attrs.value(i), -1.0)));
248
                else if ((attrs.localName(i) == "style:text-position") &&
249
                        (((attrs.value(i)).find("sub") != -1) ||
250
                                (((attrs.value(i)).left(1) == "-") && ((attrs.value(i)).left(1) != "0"))))
251
                        currentStyle->getFont()->toggleEffect(SUBSCRIPT);
252
                else if ((attrs.localName(i) == "style:text-position") &&
253
                        (((attrs.value(i)).find("super") != -1) ||
254
                                (((attrs.value(i)).left(1) != "-") && ((attrs.value(i)).left(1) != "0"))))
255
                        currentStyle->getFont()->toggleEffect(SUPERSCRIPT);
256
                else if ((attrs.localName(i) == "fo:margin-top") && (pstyle != NULL))
257
                        pstyle->setSpaceAbove(getSize(attrs.value(i)));
258
                else if ((attrs.localName(i) == "fo:margin-bottom") && (pstyle != NULL))
259
                        pstyle->setSpaceBelow(getSize(attrs.value(i)));
260
                else if ((attrs.localName(i) == "fo:margin-left") && (pstyle != NULL))
261
                {
262
                        if (inList)
263
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
264
                        else
265
                                pstyle->setIndent(getSize(attrs.value(i)));    
266
                }
267
                else if ((attrs.localName(i) == "text:space-before") && (pstyle != NULL))
268
                {
269
                        if (inList)
270
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
271
                        else
272
                                pstyle->setIndent(getSize(attrs.value(i)));
273
                }
274
                else if ((attrs.localName(i) == "fo:text-indent") && (pstyle != NULL))
275
                        pstyle->setFirstLineIndent(getSize(attrs.value(i)));
276
                else if ((attrs.localName(i) == "fo:text-align") && (pstyle != NULL))
277
                        align = attrs.value(i);
278
                else if ((attrs.localName(i) == "style:justify-single-word") && (pstyle != NULL))
279
                        force = attrs.value(i);
280
        }
281
        if (align != NULL)
282
        {
283
                if (align == "end")
284
                        pstyle->setAlignment(RIGHT);
285
                else if (align == "center")
286
                        pstyle->setAlignment(CENTER);
287
                else if (align == "justify")
288
                {
289
                        if (force == "false")
290
                                pstyle->setAlignment(BLOCK);
291
                        else
292
                                pstyle->setAlignment(FORCED);
293
                }
294
        }
295
        if (!hasColorTag)
296
                currentStyle->getFont()->setColor("Black");
297
 }
298
 
299
 void StyleReader::styleStyle(const QXmlAttributes& attrs)
300
 {
301
        QString name = "";
302
        QString listName = NULL;
303
        bool isParaStyle = false;
304
        bool create = true;
305
        for (int i = 0; i < attrs.count(); ++i)
306
        {
307
                if (attrs.localName(i) == "style:family")
308
                {
309
                        if (attrs.value(i) == "paragraph")
310
                        {
311
                                isParaStyle = true;
312
                                readProperties = true;
313
                        }
314
                        else if (attrs.value(i) == "text")
315
                        {
316
                                isParaStyle = false;
317
                                readProperties = true;
318
                        }
319
                        else
320
                        {
321
                                readProperties = false;
322
                                return;
323
                        }
324
                }
325
                else if (attrs.localName(i) == "style:name")
326
                        name = attrs.value(i);
327
                else if (attrs.localName(i) == "style:parent-style-name")
328
                {
329
                        if (styles.contains(attrs.value(i)))
330
                                parentStyle = styles[attrs.value(i)];
331
                        else
332
                                parentStyle = NULL;
333
                }
334
                else if (attrs.localName(i) == "style:list-style-name")
335
                        listName = attrs.value(i);
336
        }
337
        if ((parentStyle == NULL) && (styles.contains("default-style")))
338
                parentStyle = styles["default-style"];
339
 
340
        if (create)
341
        {
342
                if (parentStyle == NULL)
343
                {
344
                        parentStyle = new gtStyle("tmp-parent");
345
                }
346
                if (isParaStyle)
347
                {
348
                        gtParagraphStyle *tmpP;
349
                        if (parentStyle->target() == "paragraph")
350
                        {
351
                                tmpP = dynamic_cast<gtParagraphStyle*>(parentStyle);
352
                                gtParagraphStyle* tmp = new gtParagraphStyle(*tmpP);
353
 //                             tmp->setAutoLineSpacing(true);
354
                                currentStyle = tmp;
355
                        }
356
                        else
357
                        {
358
                                gtParagraphStyle* tmp = new gtParagraphStyle(*parentStyle);
359
 //                             tmp->setAutoLineSpacing(true);
360
                                currentStyle = tmp;
361
                        }
362
                        if (listName != NULL)
363
                        {
364
                                listParents[listName] = currentStyle;
365
                        }
366
                }
367
                else
368
                        currentStyle = new gtStyle(*parentStyle);
369
 
370
                currentStyle->setName(name);
371
        }
372
        else
373
                currentStyle = NULL;
374
 }
375
 
376
 void StyleReader::tabStop(const QXmlAttributes& attrs)
377
 {
378
        if (currentStyle->target() == "paragraph")
379
        {
380
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
381
                QString pos = NULL;
382
                QString type = NULL;
383
                for (int i = 0; i < attrs.count(); ++i)
384
                {
385
                        if (attrs.localName(i) == "style:position")
386
                                pos = attrs.value(i);
387
                        else if (attrs.localName(i) == "style:type")
388
                                type = attrs.value(i);
389
 
390
                }
391
                if (pos != NULL)
392
                {
393
                        if (type == NULL)
394
                                type = "left";
395
                        double posd = getSize(pos);
396
                        if (type == "left")
397
                                pstyle->setTabValue(posd, LEFT_T);
398
                        else if (type == "right")
399
                                pstyle->setTabValue(posd, RIGHT_T);
400
                        else if (type == "center")
401
                                pstyle->setTabValue(posd, CENTER_T);
402
                        else
403
                                pstyle->setTabValue(posd, CENTER_T);
404
                }
405
        }
406
 }
407
 
408
 bool StyleReader::endElement(const QString&, const QString&, const QString &name)
409
 {
410
        if ((name == "style:default-style") && (currentStyle != NULL) && (readProperties))
411
        {
412
                setStyle(currentStyle->getName(), currentStyle);
413
                currentStyle = NULL;
414
                parentStyle = NULL;
415
                readProperties = false;
416
        }
417
        else if (((name == "style:style") ||
418
                  (name == "text:list-level-style-bullet") ||
419
                          (name == "text:list-level-style-number") ||
420
                          (name == "text:list-level-style-image")) && (currentStyle != NULL))
421
        {
422
                setStyle(currentStyle->getName(), currentStyle);
423
                currentStyle = NULL;
424
                parentStyle = NULL;
425
                readProperties = false;
426
        }
427
        else if (name == "text:list-style")
428
        {
429
                inList = false;
430
        }
431
 
432
        return true;
433
 }
434
 
435
 void StyleReader::parse(QString fileName)
436
 {
437
        xmlSAXParseFile(sSAXHandler, fileName.ascii(), 1);
438
 }
439
 
440
 gtStyle* StyleReader::getStyle(const QString& name)
441
 {
442
        if (styles.contains(name))
443
        {
444
                gtStyle* tmp = styles[name];
445
                QString tname = tmp->getName();
446
                if ((tname.find(docname) == -1) && (usePrefix))
447
                        tmp->setName(docname + "_" + tname);
448
 
449
                return tmp;
450
        }
451
        else
452
                return styles["default-style"];
453
 
454
 }
455
 
456
 void StyleReader::setStyle(const QString& name, gtStyle* style)
457
 {
458
        gtParagraphStyle *s;
459
        QString tname = style->getName();
460
        if ((style->target() == "paragraph") && (packStyles))
461
        {
462
                s = dynamic_cast<gtParagraphStyle*>(style);
463
                QString nameByAttrs = QString("%1-").arg(s->getSpaceAbove());
464
                nameByAttrs += QString("%1-").arg(s->getSpaceBelow());
465
                nameByAttrs += QString("%1-").arg(s->getLineSpacing());
466
                nameByAttrs += QString("%1-").arg(s->getIndent());
467
                nameByAttrs += QString("%1-").arg(s->getFirstLineIndent());
468
                nameByAttrs += QString("%1-").arg(s->getAlignment());
469
                nameByAttrs += QString("%1-").arg(s->hasDropCap());
470
                nameByAttrs += QString("%1-").arg(s->getFont()->getColor());
471
                nameByAttrs += QString("%1-").arg(s->getFont()->getStrokeColor());
472
                QValueList<double>* tmp = s->getTabValues();
473
                for (uint i = 0; i < tmp->count(); ++i)
474
                {
475
                        double td = (*tmp)[i];
476
                        nameByAttrs += QString("%1-").arg(td);
477
                }
478
                if (attrsStyles.contains(nameByAttrs))
479
                {
480
                        tname = attrsStyles[nameByAttrs]->getName();
481
                        ++pstyleCounts[nameByAttrs];
482
                        style->setName(tname);
483
                }
484
                else
485
                {
486
                        attrsStyles[nameByAttrs] = style;
487
                        pstyleCounts[nameByAttrs] = 1;
488
                        tname = style->getName();
489
                }
490
        }
491
        else if (!packStyles)
492
        {
493
                attrsStyles[name] = style;
494
                pstyleCounts[name] = 1;
495
                tname = style->getName();
496
        }
497
        if (!styles.contains(name))
498
        {
499
                if ((tname.find(docname) == -1) && (usePrefix))
500
                        style->setName(docname + "_" + tname);
501
                styles[name] = style;
502
        }
503
 }
504
 
505
 QString StyleReader::getFont(const QString& key)
506
 {
507
        if (fonts.contains(key))
508
                return fonts[key];
509
        else
510
                return key;
511
 }
512
 
513
 void StyleReader::setupFrameStyle()
514
 {
515
        QString fstyleName = "";
516
        int count = 0;
517
        CounterMap::Iterator it;
518
        for (it = pstyleCounts.begin(); it != pstyleCounts.end(); ++it)
519
        {
520
                if (it.data() > count)
521
                {
522
                        count = it.data();
523
                        fstyleName = it.key();
524
                }
525
        }
526
        gtFrameStyle* fstyle;
527
        gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(attrsStyles[fstyleName]);
528
        fstyle = new gtFrameStyle(*pstyle);
529
 
530
        if (!importTextOnly)
531
                writer->setFrameStyle(fstyle);
532
        delete fstyle;
533
 }
534
 
535
 bool StyleReader::updateStyle(gtStyle* style, gtStyle* parent2Style, const QString& key, const QString& value)
536
 {
537
        gtParagraphStyle* pstyle = NULL;
538
        if (style->target() == "paragraph")
539
                pstyle = dynamic_cast<gtParagraphStyle*>(style);
540
        else
541
                pstyle = NULL;
542
        QString align = NULL;
543
        QString force = NULL;
544
 
545
        if (key == "style:font-name")
546
                style->getFont()->setName(getFont(value));
547
        else if (key == "fo:font-size")
548
        {
549
                double size = 0;
550
                double psize = 0;
551
                if (parent2Style != NULL)
552
                        psize = static_cast<double>(parent2Style->getFont()->getSize());
553
                else if (styles.contains("default-style"))
554
                        psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
555
                        psize = psize / 10;
556
                size = getSize(value, psize);
557
                int nsize = static_cast<int>(size * 10);
558
                style->getFont()->setSize(nsize);
559
                if ((style->getName() == "default-style") && (pstyle != NULL))
560
                        pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
561
        }
562
        else if ((key == "fo:line-height") && (parent2Style != NULL))
563
        {
564
                gtParagraphStyle* ppstyle;
565
                if (parent2Style->target() == "paragraph")
566
                {
567
                        ppstyle = dynamic_cast<gtParagraphStyle*>(parent2Style);
568
                        pstyle->setLineSpacing(getSize(value, writer->getPreferredLineSpacing(style->getFont()->getSize())));
569
                }
570
        }
571
        else if (key == "fo:color")
572
                style->getFont()->setColor(value);
573
        else if ((key == "style:use-window-font-color") && (value == "true"))
574
                        style->getFont()->setColor("Black");
575
        else if ((key == "fo:font-weight") && (value == "bold"))
576
                style->getFont()->setWeight(BOLD);
577
        else if ((key == "fo:font-style") && (value == "italic"))
578
                style->getFont()->setSlant(ITALIC);
579
        else if ((key == "style:text-underline") && (value != "none"))
580
                style->getFont()->toggleEffect(UNDERLINE);
581
        else if ((key == "style:text-crossing-out") && (value != "none"))
582
                style->getFont()->toggleEffect(STRIKETHROUGH);
583
        else if ((key == "fo:font-variant") && (value == "small-caps"))
584
                style->getFont()->toggleEffect(SMALL_CAPS);
585
        else if ((key == "style:text-outline") && (value == "true"))
586
        {
587
                style->getFont()->toggleEffect(OUTLINE);
588
                style->getFont()->setStrokeColor("Black");
589
                style->getFont()->setColor("White");
590
        }
591
        else if (key == "fo:letter-spacing")
592
                style->getFont()->setKerning(getSize(value));
593
        else if (key == "style:text-scale")
594
                style->getFont()->setHscale(static_cast<int>(getSize(value, -1.0)));
595
        else if ((key == "style:text-position") &&
596
                (((value).find("sub") != -1) ||
597
                        (((value).left(1) == "-") && ((value).left(1) != "0"))))
598
                style->getFont()->toggleEffect(SUBSCRIPT);
599
        else if ((key == "style:text-position") &&
600
                (((value).find("super") != -1) ||
601
                        (((value).left(1) != "-") && ((value).left(1) != "0"))))
602
                style->getFont()->toggleEffect(SUPERSCRIPT);
603
        else if ((key == "fo:margin-top") && (pstyle != NULL))
604
                pstyle->setSpaceAbove(getSize(value));
605
        else if ((key == "fo:margin-bottom") && (pstyle != NULL))
606
                pstyle->setSpaceBelow(getSize(value));
607
        else if ((key == "fo:margin-left") && (pstyle != NULL))
608
        {
609
                if (inList)
610
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
611
                else
612
                        pstyle->setIndent(getSize(value));     
613
        }
614
        else if ((key == "text:space-before") && (pstyle != NULL))
615
        {
616
                if (inList)
617
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
618
                else
619
                        pstyle->setIndent(getSize(value));     
620
        }
621
        else if ((key == "fo:text-indent") && (pstyle != NULL))
622
                pstyle->setFirstLineIndent(getSize(value));
623
        else if ((key == "fo:text-align") && (pstyle != NULL))
624
                align = value;
625
        else if ((key == "style:justify-single-word") && (pstyle != NULL))
626
                force = value;
627
 
628
        if (align != NULL)
629
        {
630
                if (align == "end")
631
                        pstyle->setAlignment(RIGHT);
632
                else if (align == "center")
633
                        pstyle->setAlignment(CENTER);
634
                else if (align == "justify")
635
                {
636
                        if (force != "false")
637
                                pstyle->setAlignment(FORCED);
638
                        else
639
                                pstyle->setAlignment(BLOCK);
640
                }
641
        }
642
 
643
        return true;
644
 }
645
 
646
 double StyleReader::getSize(QString s, double parentSize)
647
 {
648
        QString dbl = "0.0";
649
        QString lowerValue = s.lower();
650
        double ret = 0.0;
651
        if (lowerValue.find("pt") != -1)
652
        {
653
                dbl = lowerValue.remove("pt");
654
                ret = gtMeasure::d2d(dbl.toDouble(), PT);
655
        }
656
        else if (lowerValue.find("mm") != -1)
657
        {
658
                dbl = lowerValue.remove("mm");
659
                ret = gtMeasure::d2d(dbl.toDouble(), MM);
660
        }
661
        else if (lowerValue.find("cm") != -1)
662
        {
663
                dbl = lowerValue.remove("cm");
664
                ret = gtMeasure::d2d(dbl.toDouble() * 10, MM);
665
        }
666
        else if (lowerValue.find("in") != -1)
667
        {
668
                dbl = lowerValue.remove("inch");
669
                dbl = lowerValue.remove("in");
670
                ret = gtMeasure::d2d(dbl.toDouble(), IN);
671
        }
672
        else if (lowerValue.find("pi") != -1)
673
        {
674
                dbl = lowerValue.remove("pica");
675
                dbl = lowerValue.remove("pi");
676
                ret = gtMeasure::d2d(dbl.toDouble(), P);
677
        }
678
        else if (lowerValue.find("%") != -1)
679
        {
680
                dbl = lowerValue.remove("%");
681
                double factor = dbl.toDouble();
682
                if (parentSize != -1.0)
683
                {
684
                        factor = factor / 100;
685
                        ret = factor * parentSize;
686
                }
687
                else
688
                        ret = factor;
689
        }
690
        return ret;
691
 }
692
 
693
 StyleReader::~StyleReader()
694
 {
695
        sreader = NULL;
696
        StyleMap::Iterator it;
697
        for (it = styles.begin(); it != styles.end(); ++it)
698
        {
699
                if (it.data())
700
                {
701
                        delete it.data();
702
                        it.data() = NULL;
703
                }
704
        }
705
 }
706
 
707
 xmlSAXHandler sSAXHandlerStruct = {
708
        NULL, // internalSubset,
709
        NULL, // isStandalone,
710
        NULL, // hasInternalSubset,
711
        NULL, // hasExternalSubset,
712
        NULL, // resolveEntity,
713
        NULL, // getEntity,
714
        NULL, // entityDecl,
715
        NULL, // notationDecl,
716
        NULL, // attributeDecl,
717
        NULL, // elementDecl,
718
        NULL, // unparsedEntityDecl,
719
        NULL, // setDocumentLocator,
720
        NULL, // startDocument,
721
        NULL, // endDocument,
722
        StyleReader::startElement,
723
        StyleReader::endElement,
724
        NULL, // reference,
725
        NULL, // characters
726
        NULL, // ignorableWhitespace,
727
        NULL, // processingInstruction,
728
        NULL, // comment,
729
        NULL, // warning,
730
        NULL, // error,
731
        NULL, // fatalError,
732
        NULL, // getParameterEntity,
733
        NULL, // cdata,
734
        NULL,
735
        1
736
 #ifdef HAVE_XML26
737
        ,
738
        NULL,
739
        NULL,
740
        NULL,
741
        NULL
742
 #endif
743
 };
744
 
745
 xmlSAXHandlerPtr sSAXHandler = &sSAXHandlerStruct;
746
 
747
 void StyleReader::startElement(void*, const xmlChar * fullname, const xmlChar ** atts)
748
 {
749
        QString* name = new QString((const char*) fullname);
750
        name = new QString(name->lower());
751
        QXmlAttributes* attrs = new QXmlAttributes();
752
        if (atts)
753
        {
754
                for(const xmlChar** cur = atts; cur && *cur; cur += 2)
755
                        attrs->append(QString((char*)*cur), NULL, QString((char*)*cur), QString((char*)*(cur + 1)));
756
        }
757
        sreader->startElement(NULL, NULL, *name, *attrs);
758
 }
759
 
760
 void StyleReader::endElement(void*, const xmlChar * name)
761
 {
762
        QString *nname = new QString((const char*) name);
763
        nname = new QString(nname->lower());
764
        sreader->endElement(NULL, NULL, *nname);
765
 }
766
 
767
 #endif