Subversion Repositories Scribus

Rev

Rev 7276 | 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
*/
1579 tsoots 7
 /***************************************************************************
8
  *   Copyright (C) 2004 by Riku Leino                                      *
9
  *   tsoots@gmail.com                                                      *
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>
1579 tsoots 32
 #include <gtmeasure.h>
33
 #include <gtparagraphstyle.h>
34
 #include <gtframestyle.h>
35
 #include <gtfont.h>
36
 
37
 StyleReader* StyleReader::sreader = NULL;
38
 
39
 extern xmlSAXHandlerPtr sSAXHandler;
40
 
41
StyleReader::StyleReader(QString documentName, gtWriter *w,
42
                         bool textOnly, bool prefix, bool combineStyles)
43
{
44
        sreader      = this;
45
        docname      = documentName;
46
        readProperties = false;
47
        writer       = w;
48
        importTextOnly = textOnly;
49
        usePrefix    = prefix;
50
        packStyles   = combineStyles;
2212 tsoots 51
        currentStyle = 0;
52
        currentListStyle = 0;
53
        parentStyle  = 0;
1579 tsoots 54
        inList       = false;
55
        currentList  = "";
56
        defaultStyleCreated = false;
57
}
58
 
59
 bool StyleReader::startElement(const QString&, const QString&, const QString &name, const QXmlAttributes &attrs)
60
 {
61
        if (name == "style:default-style")
62
                defaultStyle(attrs);
63
        else if (name == "style:paragraph-properties" ||
64
                 name == "style:text-properties" ||
65
                 name == "style:list-level-properties")
66
                styleProperties(attrs);
67
        else if (name == "style:style")
68
        {
69
                if (!defaultStyleCreated)
70
                {
10107 jghali 71
                        gtParagraphStyle* pstyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
72
                        pstyle->setDefaultStyle(true);
73
                        currentStyle = dynamic_cast<gtStyle*>(pstyle);
1579 tsoots 74
                        currentStyle->setName("default-style");
75
                        defaultStyleCreated = true;
76
                }
77
                styleStyle(attrs);
78
        }
79
        else if (name == "style:tab-stop")
80
                tabStop(attrs);
81
        else if (name == "text:list-style")
82
        {
83
                for (int i = 0; i < attrs.count(); ++i)
84
                        if (attrs.localName(i) == "style:name")
85
                                currentList = attrs.value(i);
2212 tsoots 86
                currentListStyle = new ListStyle(currentList);
1579 tsoots 87
                inList = true;
88
        }
89
        else if (((name == "text:list-level-style-bullet") ||
90
                  (name == "text:list-level-style-number") ||
91
                  (name == "text:list-level-style-image")) && (inList))
92
        {
2212 tsoots 93
                BulletType bstyle = Bullet;
94
                QString prefix = "";
95
                QString suffix = "";
96
                QString bullet = "-";
97
                uint ulevel = 0;
98
                uint displayLevels = 1;
99
                uint startAt = 0;
1579 tsoots 100
                QString level = "";
101
                for (int i = 0; i < attrs.count(); ++i)
102
                {
103
                        if (attrs.localName(i) == "text:level")
104
                        {
2212 tsoots 105
                                ulevel = QString(attrs.value(i)).toUInt();
1579 tsoots 106
                                gtStyle *plist;
107
                                if (attrs.value(i) == "1")
108
                                {
109
                                        plist = listParents[currentList];
110
                                }
111
                                else
112
                                {
113
                                        int level = (attrs.value(i)).toInt();
114
                                        --level;
115
                                        plist = styles[QString(currentList + "_%1").arg(level)];
116
                                }
117
                                gtParagraphStyle *pstyle;
118
                                if (plist == NULL)
119
                                        plist = new gtStyle(*(styles["default-style"]));
120
 
121
                                if (plist->target() == "paragraph")
122
                                {
123
                                        pstyle = dynamic_cast<gtParagraphStyle*>(plist);
124
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*pstyle);
125
                                        currentStyle = tmp;
126
                                }
127
                                else
128
                                {
129
                                        gtParagraphStyle* tmp = new gtParagraphStyle(*plist);
130
                                        currentStyle = tmp;
131
                                }
132
                                currentStyle->setName(currentList + "_" + attrs.value(i));
133
                        }
2212 tsoots 134
                        else if (attrs.localName(i) == "style:num-prefix")
135
                                prefix = attrs.value(i);
136
                        else if (attrs.localName(i) == "style:num-suffix")
137
                                suffix = attrs.value(i);
138
                        /*else if (attrs.localName(i) == "text:bullet-char")
139
                                bullet = attrs.value(i);*/
140
                        else if (attrs.localName(i) == "style:num-format") {
141
                                QString tmp = attrs.value(i);
142
                                if (tmp == "i")
143
                                        bstyle = LowerRoman;
144
                                else if (tmp == "I")
145
                                        bstyle = UpperRoman;
146
                                else if (tmp == "a")
147
                                        bstyle = LowerAlpha;
148
                                else if (tmp == "A")
149
                                        bstyle = UpperAlpha;
150
                                else if (tmp == "1")
151
                                        bstyle = Number;
152
                        }
153
                        else if (attrs.localName(i) == "text:start-value") {
154
                                startAt = QString(attrs.value(i)).toUInt();
155
                                if (startAt > 0)
156
                                        --startAt;
157
                        }
158
                        else if (attrs.localName(i) == "text:display-levels") {
159
                                displayLevels = QString(attrs.value(i)).toUInt();
160
                                if (displayLevels == 0)
161
                                        displayLevels = 1;
162
                        }
1579 tsoots 163
                }
2212 tsoots 164
                if (bstyle == Bullet) {
165
                        prefix = "";
166
                        suffix = "";
167
                }
168
                ListLevel *llevel = new ListLevel(ulevel, bstyle, prefix, suffix, bullet, displayLevels, startAt);
169
                currentListStyle->addLevel(ulevel, llevel);
1579 tsoots 170
                readProperties = true;
171
        }
172
        else if ((name == "style:drop-cap") && (readProperties))
173
        {
174
                if (currentStyle->target() == "paragraph")
175
                {
176
                        for (int i = 0; i < attrs.count(); ++i)
177
                        {
178
                                if (attrs.localName(i) == "style:lines")
179
                                {
180
                                        bool ok = false;
181
                                        QString sd = attrs.value(i);
182
                                        int dh = sd.toInt(&ok);
183
                                        if (ok)
184
                                        {
185
                                                gtParagraphStyle* s = dynamic_cast<gtParagraphStyle*>(currentStyle);
186
                                                s->setDropCapHeight(dh);
187
                                                s->setDropCap(true);
188
                                        }
189
                                }
190
                        }
191
                }
192
        }
193
        else if (name == "style:font-face")
194
        {
195
                QString key = "";
196
                QString family = "";
197
                QString style = "";
198
                for (int i = 0; i < attrs.count(); ++i)
199
                {
200
                        if (attrs.localName(i) == "style:name")
201
                                key = attrs.value(i);
202
                        else if (attrs.localName(i) == "svg:font-family")
203
                        {
204
                                family = attrs.value(i);
205
                                family = family.remove("'");
206
                        }
207
                        else if (attrs.localName(i) == "style:font-style-name")
208
                                style += attrs.value(i) + " ";
209
                }
210
                QString name = family + " " + style;
211
                name = name.simplifyWhiteSpace();
212
                fonts[key] = name;
213
        }
214
        return true;
215
 }
216
 
217
 void StyleReader::defaultStyle(const QXmlAttributes& attrs)
218
 {
219
        currentStyle = NULL;
220
        for (int i = 0; i < attrs.count(); ++i)
221
                if (attrs.localName(i) == "style:family")
222
                        if (attrs.value(i) == "paragraph")
223
                        {
10107 jghali 224
                                gtParagraphStyle* pstyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
225
                                pstyle->setDefaultStyle(true);
226
                                currentStyle = dynamic_cast<gtStyle*>(pstyle);
1579 tsoots 227
                                currentStyle->setName("default-style");
228
                                readProperties = true;
229
                                defaultStyleCreated = true;
230
                        }
231
 }
232
 
233
 void StyleReader::styleProperties(const QXmlAttributes& attrs)
234
 {
235
        if ((currentStyle == NULL) || (!readProperties))
236
                return;
237
        gtParagraphStyle* pstyle = NULL;
238
        if (currentStyle->target() == "paragraph")
239
                pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
240
        else
241
                pstyle = NULL;
242
        QString align = NULL;
243
        QString force = NULL;
244
        bool hasColorTag = false;
245
        for (int i = 0; i < attrs.count(); ++i)
246
        {
247
                if ((attrs.localName(i) == "style:font-name") && (!inList))
248
                        currentStyle->getFont()->setName(getFont(attrs.value(i)));
249
                else if (attrs.localName(i) == "fo:font-size")
250
                {
251
                        double size = 0;
252
                        double psize = 0;
253
                        if (parentStyle != NULL)
254
                                psize = static_cast<double>(parentStyle->getFont()->getSize());
255
                        else if (styles.contains("default-style"))
256
                                psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
257
 
258
                        psize = psize / 10;
259
                        size = getSize(attrs.value(i), psize);
260
                        int nsize = static_cast<int>(size * 10);
261
                        currentStyle->getFont()->setSize(nsize);
1622 tsoots 262
                        if (pstyle)
1579 tsoots 263
                                pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
264
                }
265
                else if ((attrs.localName(i) == "fo:line-height") && (parentStyle != NULL))
266
                {
267
                        gtParagraphStyle* ppstyle;
268
                        if (parentStyle->target() == "paragraph")
269
                        {
270
                                ppstyle = dynamic_cast<gtParagraphStyle*>(parentStyle);
271
                                pstyle->setLineSpacing(getSize(attrs.value(i), writer->getPreferredLineSpacing(currentStyle->getFont()->getSize())));
272
                        }
273
                }
274
                else if (attrs.localName(i) == "fo:color")
275
                {
276
                        currentStyle->getFont()->setColor(attrs.value(i));
277
                        hasColorTag = true;
278
                }
279
                else if ((attrs.localName(i) == "style:use-window-font-color") && (attrs.value(i) == "true"))
280
                {
281
                        currentStyle->getFont()->setColor("Black");
282
                        hasColorTag = true;
283
                }
284
                else if ((attrs.localName(i) == "fo:font-weight") && (attrs.value(i) == "bold"))
285
                        currentStyle->getFont()->setWeight(BOLD);
286
                else if ((attrs.localName(i) == "fo:font-style") && (attrs.value(i) == "italic"))
287
                        currentStyle->getFont()->setSlant(ITALIC);
1610 tsoots 288
                else if ((attrs.localName(i) == "style:text-underline-style") && (attrs.value(i) != "none"))
1579 tsoots 289
                        currentStyle->getFont()->toggleEffect(UNDERLINE);
290
                else if ((attrs.localName(i) == "style:text-crossing-out") && (attrs.value(i) != "none"))
291
                        currentStyle->getFont()->toggleEffect(STRIKETHROUGH);
292
                else if ((attrs.localName(i) == "fo:font-variant") && (attrs.value(i) == "small-caps"))
293
                        currentStyle->getFont()->toggleEffect(SMALL_CAPS);
294
                else if ((attrs.localName(i) == "style:text-outline") && (attrs.value(i) == "true"))
295
                {
296
                        currentStyle->getFont()->toggleEffect(OUTLINE);
297
                        currentStyle->getFont()->setStrokeColor("Black");
298
                        currentStyle->getFont()->setColor("White");
299
                }
300
                else if (attrs.localName(i) == "fo:letter-spacing")
2501 fschmid 301
                        currentStyle->getFont()->setKerning(static_cast<int>(getSize(attrs.value(i), -1.0)));
1579 tsoots 302
                else if (attrs.localName(i) == "style:text-scale")
303
                        currentStyle->getFont()->setHscale(static_cast<int>(getSize(attrs.value(i), -1.0)));
304
                else if ((attrs.localName(i) == "style:text-position") &&
305
                        (((attrs.value(i)).find("sub") != -1) ||
306
                                (((attrs.value(i)).left(1) == "-") && ((attrs.value(i)).left(1) != "0"))))
307
                        currentStyle->getFont()->toggleEffect(SUBSCRIPT);
308
                else if ((attrs.localName(i) == "style:text-position") &&
309
                        (((attrs.value(i)).find("super") != -1) ||
310
                                (((attrs.value(i)).left(1) != "-") && ((attrs.value(i)).left(1) != "0"))))
311
                        currentStyle->getFont()->toggleEffect(SUPERSCRIPT);
312
                else if ((attrs.localName(i) == "fo:margin-top") && (pstyle != NULL))
313
                        pstyle->setSpaceAbove(getSize(attrs.value(i)));
314
                else if ((attrs.localName(i) == "fo:margin-bottom") && (pstyle != NULL))
315
                        pstyle->setSpaceBelow(getSize(attrs.value(i)));
316
                else if ((attrs.localName(i) == "fo:margin-left") && (pstyle != NULL))
317
                {
318
                        if (inList)
319
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
320
                        else
321
                                pstyle->setIndent(getSize(attrs.value(i)));    
322
                }
323
                else if ((attrs.localName(i) == "text:space-before") && (pstyle != NULL))
324
                {
2212 tsoots 325
                        /*if (inList)
1579 tsoots 326
                                pstyle->setIndent(pstyle->getIndent() + getSize(attrs.value(i)));
2212 tsoots 327
                        else*/
1579 tsoots 328
                                pstyle->setIndent(getSize(attrs.value(i)));
329
                }
330
                else if ((attrs.localName(i) == "fo:text-indent") && (pstyle != NULL))
331
                        pstyle->setFirstLineIndent(getSize(attrs.value(i)));
332
                else if ((attrs.localName(i) == "fo:text-align") && (pstyle != NULL))
333
                        align = attrs.value(i);
334
                else if ((attrs.localName(i) == "style:justify-single-word") && (pstyle != NULL))
335
                        force = attrs.value(i);
336
        }
337
        if (align != NULL)
338
        {
339
                if (align == "end")
340
                        pstyle->setAlignment(RIGHT);
341
                else if (align == "center")
342
                        pstyle->setAlignment(CENTER);
343
                else if (align == "justify")
344
                {
345
                        if (force == "false")
346
                                pstyle->setAlignment(BLOCK);
347
                        else
348
                                pstyle->setAlignment(FORCED);
349
                }
350
        }
351
        if (!hasColorTag)
352
                currentStyle->getFont()->setColor("Black");
353
 }
354
 
355
 void StyleReader::styleStyle(const QXmlAttributes& attrs)
356
 {
357
        QString name = "";
358
        QString listName = NULL;
359
        bool isParaStyle = false;
360
        bool create = true;
361
        for (int i = 0; i < attrs.count(); ++i)
362
        {
363
                if (attrs.localName(i) == "style:family")
364
                {
365
                        if (attrs.value(i) == "paragraph")
366
                        {
367
                                isParaStyle = true;
368
                                readProperties = true;
369
                        }
370
                        else if (attrs.value(i) == "text")
371
                        {
372
                                isParaStyle = false;
373
                                readProperties = true;
374
                        }
375
                        else
376
                        {
377
                                readProperties = false;
378
                                return;
379
                        }
380
                }
381
                else if (attrs.localName(i) == "style:name")
382
                        name = attrs.value(i);
383
                else if (attrs.localName(i) == "style:parent-style-name")
384
                {
385
                        if (styles.contains(attrs.value(i)))
386
                                parentStyle = styles[attrs.value(i)];
387
                        else
388
                                parentStyle = NULL;
389
                }
390
                else if (attrs.localName(i) == "style:list-style-name")
391
                        listName = attrs.value(i);
392
        }
393
        if ((parentStyle == NULL) && (styles.contains("default-style")))
394
                parentStyle = styles["default-style"];
395
 
396
        if (create)
397
        {
398
                if (parentStyle == NULL)
399
                {
400
                        parentStyle = new gtStyle("tmp-parent");
401
                }
402
                if (isParaStyle)
403
                {
404
                        gtParagraphStyle *tmpP;
405
                        if (parentStyle->target() == "paragraph")
406
                        {
407
                                tmpP = dynamic_cast<gtParagraphStyle*>(parentStyle);
408
                                gtParagraphStyle* tmp = new gtParagraphStyle(*tmpP);
409
 //                             tmp->setAutoLineSpacing(true);
410
                                currentStyle = tmp;
411
                        }
412
                        else
413
                        {
414
                                gtParagraphStyle* tmp = new gtParagraphStyle(*parentStyle);
415
 //                             tmp->setAutoLineSpacing(true);
416
                                currentStyle = tmp;
417
                        }
418
                        if (listName != NULL)
419
                        {
420
                                listParents[listName] = currentStyle;
421
                        }
422
                }
423
                else
424
                        currentStyle = new gtStyle(*parentStyle);
425
 
426
                currentStyle->setName(name);
427
        }
428
        else
429
                currentStyle = NULL;
430
 }
431
 
432
 void StyleReader::tabStop(const QXmlAttributes& attrs)
433
 {
434
        if (currentStyle->target() == "paragraph")
435
        {
436
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
437
                QString pos = NULL;
438
                QString type = NULL;
439
                for (int i = 0; i < attrs.count(); ++i)
440
                {
441
                        if (attrs.localName(i) == "style:position")
442
                                pos = attrs.value(i);
443
                        else if (attrs.localName(i) == "style:type")
444
                                type = attrs.value(i);
445
 
446
                }
447
                if (pos != NULL)
448
                {
449
                        if (type == NULL)
450
                                type = "left";
451
                        double posd = getSize(pos);
452
                        if (type == "left")
453
                                pstyle->setTabValue(posd, LEFT_T);
454
                        else if (type == "right")
455
                                pstyle->setTabValue(posd, RIGHT_T);
456
                        else if (type == "center")
457
                                pstyle->setTabValue(posd, CENTER_T);
458
                        else
459
                                pstyle->setTabValue(posd, CENTER_T);
460
                }
461
        }
462
 }
463
 
464
 bool StyleReader::endElement(const QString&, const QString&, const QString &name)
465
 {
466
        if ((name == "style:default-style") && (currentStyle != NULL) && (readProperties))
467
        {
468
                setStyle(currentStyle->getName(), currentStyle);
469
                currentStyle = NULL;
470
                parentStyle = NULL;
471
                readProperties = false;
472
        }
473
        else if (((name == "style:style") ||
474
                  (name == "text:list-level-style-bullet") ||
475
                          (name == "text:list-level-style-number") ||
476
                          (name == "text:list-level-style-image")) && (currentStyle != NULL))
477
        {
478
                setStyle(currentStyle->getName(), currentStyle);
479
                currentStyle = NULL;
480
                parentStyle = NULL;
481
                readProperties = false;
482
        }
483
        else if (name == "text:list-style")
484
        {
2212 tsoots 485
                if (currentListStyle) {
486
                        lists[currentListStyle->name()] = currentListStyle;
487
                        currentListStyle = 0;
488
                }
1579 tsoots 489
                inList = false;
490
        }
491
 
492
        return true;
493
 }
494
 
495
 void StyleReader::parse(QString fileName)
496
 {
7276 jghali 497
#if defined(_WIN32)
498
        QString fname = QDir::convertSeparators(fileName);
499
        QCString fn = (qWinVersion() & Qt::WV_NT_based) ? fname.utf8() : fname.local8Bit();
500
#else
501
        QCString fn(fileName.local8Bit());
502
#endif
503
        xmlSAXParseFile(sSAXHandler, fn.data(), 1);
1579 tsoots 504
 }
10107 jghali 505
 
506
 gtStyle* StyleReader::getDefaultStyle(void)
507
 {
508
         gtStyle* defStyle = writer->getDefaultStyle();
509
         StyleMap::Iterator it, itEnd = styles.end();
510
         for (it = styles.begin(); it != itEnd; ++it)
511
         {
512
                 gtParagraphStyle *pStyle = dynamic_cast<gtParagraphStyle*> (it.data());
513
                 if (pStyle && pStyle->isDefaultStyle())
514
                 {
515
                         defStyle = pStyle;
516
                         break;
517
                 }
518
         }
519
         return defStyle;
520
 }
1579 tsoots 521
 
522
 gtStyle* StyleReader::getStyle(const QString& name)
523
 {
524
        if (styles.contains(name))
525
        {
526
                gtStyle* tmp = styles[name];
527
                QString tname = tmp->getName();
528
                if ((tname.find(docname) == -1) && (usePrefix))
529
                        tmp->setName(docname + "_" + tname);
530
 
531
                return tmp;
532
        }
533
        else
10107 jghali 534
                return getDefaultStyle();
1579 tsoots 535
 }
536
 
537
 void StyleReader::setStyle(const QString& name, gtStyle* style)
538
 {
539
        gtParagraphStyle *s;
540
        QString tname = style->getName();
541
        if ((style->target() == "paragraph") && (packStyles))
542
        {
543
                s = dynamic_cast<gtParagraphStyle*>(style);
544
                QString nameByAttrs = QString("%1-").arg(s->getSpaceAbove());
545
                nameByAttrs += QString("%1-").arg(s->getSpaceBelow());
546
                nameByAttrs += QString("%1-").arg(s->getLineSpacing());
547
                nameByAttrs += QString("%1-").arg(s->getIndent());
548
                nameByAttrs += QString("%1-").arg(s->getFirstLineIndent());
549
                nameByAttrs += QString("%1-").arg(s->getAlignment());
550
                nameByAttrs += QString("%1-").arg(s->hasDropCap());
551
                nameByAttrs += QString("%1-").arg(s->getFont()->getColor());
552
                nameByAttrs += QString("%1-").arg(s->getFont()->getStrokeColor());
2282 fschmid 553
// TODO is this important ??
554
/*              QValueList<double>* tmp = s->getTabValues();
1579 tsoots 555
                for (uint i = 0; i < tmp->count(); ++i)
556
                {
557
                        double td = (*tmp)[i];
558
                        nameByAttrs += QString("%1-").arg(td);
2282 fschmid 559
                } */
1579 tsoots 560
                if (attrsStyles.contains(nameByAttrs))
561
                {
562
                        tname = attrsStyles[nameByAttrs]->getName();
563
                        ++pstyleCounts[nameByAttrs];
564
                        style->setName(tname);
565
                }
566
                else
567
                {
568
                        attrsStyles[nameByAttrs] = style;
569
                        pstyleCounts[nameByAttrs] = 1;
570
                        tname = style->getName();
571
                }
572
        }
573
        else if (!packStyles)
574
        {
575
                attrsStyles[name] = style;
576
                pstyleCounts[name] = 1;
577
                tname = style->getName();
578
        }
579
        if (!styles.contains(name))
580
        {
581
                if ((tname.find(docname) == -1) && (usePrefix))
582
                        style->setName(docname + "_" + tname);
583
                styles[name] = style;
584
        }
585
 }
586
 
587
 QString StyleReader::getFont(const QString& key)
588
 {
589
        if (fonts.contains(key))
590
                return fonts[key];
591
        else
592
                return key;
593
 }
594
 
595
 void StyleReader::setupFrameStyle()
596
 {
597
        QString fstyleName = "";
598
        int count = 0;
599
        CounterMap::Iterator it;
600
        for (it = pstyleCounts.begin(); it != pstyleCounts.end(); ++it)
601
        {
602
                if (it.data() > count)
603
                {
604
                        count = it.data();
605
                        fstyleName = it.key();
606
                }
607
        }
608
        gtFrameStyle* fstyle;
609
        gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(attrsStyles[fstyleName]);
610
        fstyle = new gtFrameStyle(*pstyle);
611
 
612
        if (!importTextOnly)
613
                writer->setFrameStyle(fstyle);
614
        delete fstyle;
615
 }
616
 
2212 tsoots 617
ListStyle* StyleReader::getList(const QString &name)
618
{
619
        ListStyle *tmp = 0;
620
        if (lists.contains(name))
621
                tmp = lists[name];
622
        return tmp;
623
}
624
 
1579 tsoots 625
 bool StyleReader::updateStyle(gtStyle* style, gtStyle* parent2Style, const QString& key, const QString& value)
626
 {
627
        gtParagraphStyle* pstyle = NULL;
628
        if (style->target() == "paragraph")
629
                pstyle = dynamic_cast<gtParagraphStyle*>(style);
630
        else
631
                pstyle = NULL;
632
        QString align = NULL;
633
        QString force = NULL;
634
 
635
        if (key == "style:font-name")
636
                style->getFont()->setName(getFont(value));
637
        else if (key == "fo:font-size")
638
        {
639
                double size = 0;
640
                double psize = 0;
641
                if (parent2Style != NULL)
642
                        psize = static_cast<double>(parent2Style->getFont()->getSize());
643
                else if (styles.contains("default-style"))
644
                        psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
645
                        psize = psize / 10;
646
                size = getSize(value, psize);
647
                int nsize = static_cast<int>(size * 10);
648
                style->getFont()->setSize(nsize);
1622 tsoots 649
                if (pstyle)
1579 tsoots 650
                        pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
651
        }
652
        else if ((key == "fo:line-height") && (parent2Style != NULL))
653
        {
654
                gtParagraphStyle* ppstyle;
655
                if (parent2Style->target() == "paragraph")
656
                {
657
                        ppstyle = dynamic_cast<gtParagraphStyle*>(parent2Style);
658
                        pstyle->setLineSpacing(getSize(value, writer->getPreferredLineSpacing(style->getFont()->getSize())));
659
                }
660
        }
661
        else if (key == "fo:color")
662
                style->getFont()->setColor(value);
663
        else if ((key == "style:use-window-font-color") && (value == "true"))
664
                        style->getFont()->setColor("Black");
665
        else if ((key == "fo:font-weight") && (value == "bold"))
666
                style->getFont()->setWeight(BOLD);
667
        else if ((key == "fo:font-style") && (value == "italic"))
668
                style->getFont()->setSlant(ITALIC);
1610 tsoots 669
        else if ((key == "style:text-underline-style") && (value != "none"))
1579 tsoots 670
                style->getFont()->toggleEffect(UNDERLINE);
671
        else if ((key == "style:text-crossing-out") && (value != "none"))
672
                style->getFont()->toggleEffect(STRIKETHROUGH);
673
        else if ((key == "fo:font-variant") && (value == "small-caps"))
674
                style->getFont()->toggleEffect(SMALL_CAPS);
675
        else if ((key == "style:text-outline") && (value == "true"))
676
        {
677
                style->getFont()->toggleEffect(OUTLINE);
678
                style->getFont()->setStrokeColor("Black");
679
                style->getFont()->setColor("White");
680
        }
681
        else if (key == "fo:letter-spacing")
2501 fschmid 682
                style->getFont()->setKerning(static_cast<int>(getSize(value, -1.0)));
1579 tsoots 683
        else if (key == "style:text-scale")
684
                style->getFont()->setHscale(static_cast<int>(getSize(value, -1.0)));
685
        else if ((key == "style:text-position") &&
686
                (((value).find("sub") != -1) ||
687
                        (((value).left(1) == "-") && ((value).left(1) != "0"))))
688
                style->getFont()->toggleEffect(SUBSCRIPT);
689
        else if ((key == "style:text-position") &&
690
                (((value).find("super") != -1) ||
691
                        (((value).left(1) != "-") && ((value).left(1) != "0"))))
692
                style->getFont()->toggleEffect(SUPERSCRIPT);
693
        else if ((key == "fo:margin-top") && (pstyle != NULL))
694
                pstyle->setSpaceAbove(getSize(value));
695
        else if ((key == "fo:margin-bottom") && (pstyle != NULL))
696
                pstyle->setSpaceBelow(getSize(value));
697
        else if ((key == "fo:margin-left") && (pstyle != NULL))
698
        {
699
                if (inList)
700
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
701
                else
702
                        pstyle->setIndent(getSize(value));     
703
        }
704
        else if ((key == "text:space-before") && (pstyle != NULL))
705
        {
706
                if (inList)
707
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
708
                else
709
                        pstyle->setIndent(getSize(value));     
710
        }
711
        else if ((key == "fo:text-indent") && (pstyle != NULL))
712
                pstyle->setFirstLineIndent(getSize(value));
713
        else if ((key == "fo:text-align") && (pstyle != NULL))
714
                align = value;
715
        else if ((key == "style:justify-single-word") && (pstyle != NULL))
716
                force = value;
717
 
718
        if (align != NULL)
719
        {
720
                if (align == "end")
721
                        pstyle->setAlignment(RIGHT);
722
                else if (align == "center")
723
                        pstyle->setAlignment(CENTER);
724
                else if (align == "justify")
725
                {
726
                        if (force != "false")
727
                                pstyle->setAlignment(FORCED);
728
                        else
729
                                pstyle->setAlignment(BLOCK);
730
                }
731
        }
732
 
733
        return true;
734
 }
735
 
736
 double StyleReader::getSize(QString s, double parentSize)
737
 {
738
        QString dbl = "0.0";
739
        QString lowerValue = s.lower();
740
        double ret = 0.0;
741
        if (lowerValue.find("pt") != -1)
742
        {
743
                dbl = lowerValue.remove("pt");
2594 cbradney 744
                ret = gtMeasure::d2d(dbl.toDouble(), SC_PT);
1579 tsoots 745
        }
746
        else if (lowerValue.find("mm") != -1)
747
        {
748
                dbl = lowerValue.remove("mm");
2594 cbradney 749
                ret = gtMeasure::d2d(dbl.toDouble(), SC_MM);
1579 tsoots 750
        }
751
        else if (lowerValue.find("cm") != -1)
752
        {
753
                dbl = lowerValue.remove("cm");
2594 cbradney 754
                ret = gtMeasure::d2d(dbl.toDouble() * 10, SC_MM);
1579 tsoots 755
        }
756
        else if (lowerValue.find("in") != -1)
757
        {
758
                dbl = lowerValue.remove("inch");
759
                dbl = lowerValue.remove("in");
2594 cbradney 760
                ret = gtMeasure::d2d(dbl.toDouble(), SC_IN);
1579 tsoots 761
        }
762
        else if (lowerValue.find("pi") != -1)
763
        {
764
                dbl = lowerValue.remove("pica");
765
                dbl = lowerValue.remove("pi");
2594 cbradney 766
                ret = gtMeasure::d2d(dbl.toDouble(), SC_P);
1579 tsoots 767
        }
2594 cbradney 768
        else if (lowerValue.find("c") != -1)
769
        {
770
                dbl = lowerValue.remove("cicero");
771
                dbl = lowerValue.remove("c");
772
                ret = gtMeasure::d2d(dbl.toDouble(), SC_C);
773
        }
1579 tsoots 774
        else if (lowerValue.find("%") != -1)
775
        {
776
                dbl = lowerValue.remove("%");
777
                double factor = dbl.toDouble();
778
                if (parentSize != -1.0)
779
                {
780
                        factor = factor / 100;
781
                        ret = factor * parentSize;
782
                }
783
                else
784
                        ret = factor;
785
        }
786
        return ret;
787
 }
788
 
789
 StyleReader::~StyleReader()
790
 {
791
        sreader = NULL;
792
        StyleMap::Iterator it;
793
        for (it = styles.begin(); it != styles.end(); ++it)
794
        {
795
                if (it.data())
796
                {
797
                        delete it.data();
798
                        it.data() = NULL;
799
                }
800
        }
801
 }
802
 
803
 xmlSAXHandler sSAXHandlerStruct = {
804
        NULL, // internalSubset,
805
        NULL, // isStandalone,
806
        NULL, // hasInternalSubset,
807
        NULL, // hasExternalSubset,
808
        NULL, // resolveEntity,
809
        NULL, // getEntity,
810
        NULL, // entityDecl,
811
        NULL, // notationDecl,
812
        NULL, // attributeDecl,
813
        NULL, // elementDecl,
814
        NULL, // unparsedEntityDecl,
815
        NULL, // setDocumentLocator,
816
        NULL, // startDocument,
817
        NULL, // endDocument,
818
        StyleReader::startElement,
819
        StyleReader::endElement,
820
        NULL, // reference,
821
        NULL, // characters
822
        NULL, // ignorableWhitespace,
823
        NULL, // processingInstruction,
824
        NULL, // comment,
825
        NULL, // warning,
826
        NULL, // error,
827
        NULL, // fatalError,
828
        NULL, // getParameterEntity,
829
        NULL, // cdata,
830
        NULL,
831
        1
832
 #ifdef HAVE_XML26
833
        ,
834
        NULL,
835
        NULL,
836
        NULL,
837
        NULL
838
 #endif
839
 };
840
 
841
 xmlSAXHandlerPtr sSAXHandler = &sSAXHandlerStruct;
842
 
843
 void StyleReader::startElement(void*, const xmlChar * fullname, const xmlChar ** atts)
844
 {
845
        QString* name = new QString((const char*) fullname);
846
        name = new QString(name->lower());
847
        QXmlAttributes* attrs = new QXmlAttributes();
848
        if (atts)
849
        {
850
                for(const xmlChar** cur = atts; cur && *cur; cur += 2)
851
                        attrs->append(QString((char*)*cur), NULL, QString((char*)*cur), QString((char*)*(cur + 1)));
852
        }
853
        sreader->startElement(NULL, NULL, *name, *attrs);
854
 }
855
 
856
 void StyleReader::endElement(void*, const xmlChar * name)
857
 {
858
        QString *nname = new QString((const char*) name);
859
        nname = new QString(nname->lower());
860
        sreader->endElement(NULL, NULL, *nname);
861
 }
2212 tsoots 862
 
863
/*** ListLevel *****************************************************************************************/
864
 
865
const QString ListLevel::lowerUnits[10] = {"", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"};
866
const QString ListLevel::lowerTens[10] = {"", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"};
867
const QString ListLevel::lowerHundreds[10] = {"", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"};
868
const QString ListLevel::lowerThousands[4] = {"", "m", "mm", "mmm"};
869
const QString ListLevel::upperUnits[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
870
const QString ListLevel::upperTens[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
871
const QString ListLevel::upperHundreds[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCC", "CM"};
872
const QString ListLevel::upperThousands[4] = {"", "M", "MM", "MMM"};
873
const QString ListLevel::lowerAlphabets[27] = {"", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
874
                                    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
875
const QString ListLevel::upperAlphabets[27] = {"", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
876
                                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
877
 
878
ListLevel::ListLevel(uint level,
879
                         BulletType btype,
880
                         const QString &prefix,
881
                         const QString &suffix,
882
                         const QString &bullet,
883
                         uint displayLevels,
884
                         uint startValue) :
885
m_level(level),
886
m_btype(btype),
887
m_prefix(prefix),
888
m_suffix(suffix),
889
m_bullet(bullet),
890
m_displayLevels(displayLevels),
891
m_next(startValue)
892
{
893
 
894
}
895
 
896
QString ListLevel::bulletString()
897
{
898
        QString tmp;
899
        switch (m_btype) {
900
        case Bullet:
901
                tmp = m_bullet;
902
                break;
903
        case Number:
904
                tmp = QString("%1").arg(m_next);
905
                break;
906
        case LowerRoman:
907
                tmp = lowerRoman(m_next);
908
                break;
909
        case UpperRoman:
910
                tmp = upperRoman(m_next);
911
                break;
912
        case LowerAlpha:
913
                tmp = lowerAlpha(m_next);
914
                break;
915
        case UpperAlpha:
916
                tmp = upperAlpha(m_next);
917
                break;
918
        case Graphic:
919
                tmp = "*";
920
                break;
921
        default:
922
                tmp = "";
923
        };
924
        return tmp;
925
}
926
 
927
QString ListLevel::bullet()
928
{
929
 
930
        return QString(m_prefix + bulletString() + m_suffix);
931
}
932
 
933
QString ListLevel::prefix()
934
{
935
        return m_prefix;
936
}
937
 
938
QString ListLevel::suffix()
939
{
940
        return m_suffix;
941
}
942
 
943
void ListLevel::advance()
944
{
945
        ++m_next;
946
}
947
 
948
uint ListLevel::level()
949
{
950
        return m_level;
951
}
952
 
953
uint ListLevel::displayLevels()
954
{
955
        return m_displayLevels;
956
}
957
 
958
void ListLevel::reset()
959
{
960
        m_next = 0;
961
}
962
 
963
QString ListLevel::lowerRoman(uint n)
964
{
965
        return QString(lowerThousands[(n / 1000)] +
966
                       lowerHundreds[(n / 100) % 10] +
967
                       lowerTens[(n / 10) % 10] +
968
                       lowerUnits[(n) % 10]);
969
}
970
 
971
QString ListLevel::upperRoman(uint n)
972
{
973
        return QString(upperThousands[(n / 1000)] +
974
                       upperHundreds[(n / 100) % 10] +
975
                       upperTens[(n / 10) % 10] +
976
                       upperUnits[(n) % 10]);
977
}
978
 
979
QString ListLevel::lowerAlpha(uint n)
980
{
981
        QString tmp;
982
        uint rounds = static_cast<uint>(n / 26);
983
        if (rounds > 26)
984
                rounds = 0;
985
        uint leftover = n % 26;
986
        return QString(lowerAlphabets[rounds] + lowerAlphabets[leftover]);
987
}
988
 
989
QString ListLevel::upperAlpha(uint n)
990
{
991
        QString tmp;
992
        uint rounds = static_cast<uint>(n / 26);
993
        if (rounds > 26)
994
                rounds = 0;
995
        uint leftover = n % 26;
996
        return QString(upperAlphabets[rounds] + upperAlphabets[leftover]);
997
}
998
 
999
ListLevel::~ListLevel()
1000
{
1001
 
1002
}
1003
 
1004
/*** ListStyle **********************************************************************************/
1005
 
1006
ListStyle::ListStyle(const QString &name, bool consecutiveNumbering, uint currentLevel) :
1007
m_name(name),
1008
m_consecutiveNumbering(consecutiveNumbering),
1009
m_currentLevel(currentLevel),
1010
m_count(0)
1011
{
1012
        for (uint i = 0; i < 11; ++i)
1013
                levels[i] = 0;
1014
}
1015
 
1016
void ListStyle::addLevel(uint level, ListLevel *llevel)
1017
{
1018
        if (level > 0 && level < 11)
1019
                levels[level] = llevel;
1020
}
1021
 
1022
QString ListStyle::bullet()
1023
{
1024
        uint displayLevels = levels[m_currentLevel]->displayLevels();
1025
        if (displayLevels == 1)
1026
                return QString(levels[m_currentLevel]->bullet() + " ");
1027
 
1028
        QString prefix = levels[m_currentLevel]->prefix();
1029
        QString suffix = levels[m_currentLevel]->suffix();
1030
        QString bullet = "";
1031
        int start = m_currentLevel - displayLevels + 1;
1032
        if (start < 1)
1033
                return QString(levels[m_currentLevel]->bullet() + " ");
1034
        while (static_cast<uint>(start) <= m_currentLevel)
1035
        {
1036
                if (static_cast<uint>(start) == m_currentLevel)
1037
                        bullet += levels[start]->bulletString();
1038
                else
1039
                        bullet += levels[start]->bulletString() + ".";
1040
                ++start;
1041
        }
1042
        return QString(prefix + bullet + suffix + " ");
1043
}
1044
 
1045
void ListStyle::advance()
1046
{
1047
        ++m_count;
1048
        if (levels[m_currentLevel])
1049
                levels[m_currentLevel]->advance();
1050
}
1051
 
1052
void ListStyle::setLevel(uint level)
1053
{
1054
        if (level > 0 && level < 11)
1055
                m_currentLevel = level;
1056
}
1057
 
1058
QString& ListStyle::name()
1059
{
1060
        return m_name;
1061
}
1062
 
1063
void ListStyle::resetLevel()
1064
{
1065
        levels[m_currentLevel]->reset();
1066
}
1067
 
1068
ListStyle::~ListStyle()
1069
{
1070
        for (uint i = 0; i < 11; ++i)
1071
        {
1072
                delete levels[i];
1073
                levels[i] = 0;
1074
        }
1075
}
1076
 
1077
#endif