Subversion Repositories Scribus

Rev

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

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