Subversion Repositories Scribus

Rev

Rev 415 | Go to most recent revision | Details | Last modification | View Log | RSS feed

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