Subversion Repositories Scribus

Rev

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

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