Subversion Repositories Scribus

Rev

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

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