Subversion Repositories Scribus

Rev

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