Subversion Repositories Scribus

Rev

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