Subversion Repositories Scribus

Rev

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

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