Subversion Repositories Scribus

Rev

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

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