Subversion Repositories Scribus

Rev

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