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
*/
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
        {
10117 jghali 69
                /*if (!defaultStyleCreated)
1579 tsoots 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;
10117 jghali 76
                }*/
1579 tsoots 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;
10117 jghali 359
        bool setDefaultStyle = false;
1579 tsoots 360
        bool isParaStyle = false;
361
        bool create = true;
10117 jghali 362
 
363
        if (!defaultStyleCreated)
364
        {
365
                gtParagraphStyle* pstyle = new gtParagraphStyle(*(writer->getDefaultStyle()));
366
                pstyle->setDefaultStyle(true);
367
                currentStyle = dynamic_cast<gtStyle*>(pstyle);
368
                currentStyle->setName("default-style");
369
                defaultStyleCreated = true;
370
                setDefaultStyle     = true;
371
                parentStyle  = currentStyle;
372
        }
373
 
1579 tsoots 374
        for (int i = 0; i < attrs.count(); ++i)
375
        {
376
                if (attrs.localName(i) == "style:family")
377
                {
378
                        if (attrs.value(i) == "paragraph")
379
                        {
380
                                isParaStyle = true;
381
                                readProperties = true;
382
                        }
383
                        else if (attrs.value(i) == "text")
384
                        {
385
                                isParaStyle = false;
386
                                readProperties = true;
387
                        }
388
                        else
389
                        {
390
                                readProperties = false;
391
                                return;
392
                        }
393
                }
394
                else if (attrs.localName(i) == "style:name")
395
                        name = attrs.value(i);
396
                else if (attrs.localName(i) == "style:parent-style-name")
397
                {
398
                        if (styles.contains(attrs.value(i)))
399
                                parentStyle = styles[attrs.value(i)];
400
                        else
401
                                parentStyle = NULL;
402
                }
403
                else if (attrs.localName(i) == "style:list-style-name")
404
                        listName = attrs.value(i);
405
        }
406
        if ((parentStyle == NULL) && (styles.contains("default-style")))
407
                parentStyle = styles["default-style"];
408
 
409
        if (create)
410
        {
411
                if (parentStyle == NULL)
412
                {
413
                        parentStyle = new gtStyle("tmp-parent");
414
                }
415
                if (isParaStyle)
416
                {
417
                        gtParagraphStyle *tmpP;
418
                        if (parentStyle->target() == "paragraph")
419
                        {
420
                                tmpP = dynamic_cast<gtParagraphStyle*>(parentStyle);
421
                                gtParagraphStyle* tmp = new gtParagraphStyle(*tmpP);
422
 //                             tmp->setAutoLineSpacing(true);
423
                                currentStyle = tmp;
424
                        }
425
                        else
426
                        {
427
                                gtParagraphStyle* tmp = new gtParagraphStyle(*parentStyle);
428
 //                             tmp->setAutoLineSpacing(true);
429
                                currentStyle = tmp;
430
                        }
431
                        if (listName != NULL)
432
                        {
433
                                listParents[listName] = currentStyle;
434
                        }
435
                }
436
                else
437
                        currentStyle = new gtStyle(*parentStyle);
438
 
439
                currentStyle->setName(name);
10117 jghali 440
                if (setDefaultStyle)
441
                {
442
                        gtParagraphStyle* tmp = dynamic_cast<gtParagraphStyle*>(currentStyle);
443
                        if (tmp)
444
                                tmp->setDefaultStyle(true);
445
                }
1579 tsoots 446
        }
447
        else
448
                currentStyle = NULL;
449
 }
450
 
451
 void StyleReader::tabStop(const QXmlAttributes& attrs)
452
 {
453
        if (currentStyle->target() == "paragraph")
454
        {
455
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(currentStyle);
456
                QString pos = NULL;
457
                QString type = NULL;
458
                for (int i = 0; i < attrs.count(); ++i)
459
                {
460
                        if (attrs.localName(i) == "style:position")
461
                                pos = attrs.value(i);
462
                        else if (attrs.localName(i) == "style:type")
463
                                type = attrs.value(i);
464
 
465
                }
466
                if (pos != NULL)
467
                {
468
                        if (type == NULL)
469
                                type = "left";
470
                        double posd = getSize(pos);
471
                        if (type == "left")
472
                                pstyle->setTabValue(posd, LEFT_T);
473
                        else if (type == "right")
474
                                pstyle->setTabValue(posd, RIGHT_T);
475
                        else if (type == "center")
476
                                pstyle->setTabValue(posd, CENTER_T);
477
                        else
478
                                pstyle->setTabValue(posd, CENTER_T);
479
                }
480
        }
481
 }
482
 
483
 bool StyleReader::endElement(const QString&, const QString&, const QString &name)
484
 {
485
        if ((name == "style:default-style") && (currentStyle != NULL) && (readProperties))
486
        {
487
                setStyle(currentStyle->getName(), currentStyle);
488
                currentStyle = NULL;
489
                parentStyle = NULL;
490
                readProperties = false;
491
        }
492
        else if (((name == "style:style") ||
493
                  (name == "text:list-level-style-bullet") ||
494
                          (name == "text:list-level-style-number") ||
495
                          (name == "text:list-level-style-image")) && (currentStyle != NULL))
496
        {
497
                setStyle(currentStyle->getName(), currentStyle);
498
                currentStyle = NULL;
499
                parentStyle = NULL;
500
                readProperties = false;
501
        }
502
        else if (name == "text:list-style")
503
        {
2212 tsoots 504
                if (currentListStyle) {
505
                        lists[currentListStyle->name()] = currentListStyle;
506
                        currentListStyle = 0;
507
                }
1579 tsoots 508
                inList = false;
509
        }
510
 
511
        return true;
512
 }
513
 
514
 void StyleReader::parse(QString fileName)
515
 {
7276 jghali 516
#if defined(_WIN32)
517
        QString fname = QDir::convertSeparators(fileName);
518
        QCString fn = (qWinVersion() & Qt::WV_NT_based) ? fname.utf8() : fname.local8Bit();
519
#else
520
        QCString fn(fileName.local8Bit());
521
#endif
522
        xmlSAXParseFile(sSAXHandler, fn.data(), 1);
1579 tsoots 523
 }
10107 jghali 524
 
525
 gtStyle* StyleReader::getDefaultStyle(void)
526
 {
527
         gtStyle* defStyle = writer->getDefaultStyle();
528
         StyleMap::Iterator it, itEnd = styles.end();
529
         for (it = styles.begin(); it != itEnd; ++it)
530
         {
531
                 gtParagraphStyle *pStyle = dynamic_cast<gtParagraphStyle*> (it.data());
532
                 if (pStyle && pStyle->isDefaultStyle())
533
                 {
534
                         defStyle = pStyle;
535
                         break;
536
                 }
537
         }
538
         return defStyle;
539
 }
1579 tsoots 540
 
541
 gtStyle* StyleReader::getStyle(const QString& name)
542
 {
543
        if (styles.contains(name))
544
        {
545
                gtStyle* tmp = styles[name];
546
                QString tname = tmp->getName();
547
                if ((tname.find(docname) == -1) && (usePrefix))
548
                        tmp->setName(docname + "_" + tname);
549
 
550
                return tmp;
551
        }
552
        else
10107 jghali 553
                return getDefaultStyle();
1579 tsoots 554
 }
555
 
556
 void StyleReader::setStyle(const QString& name, gtStyle* style)
557
 {
558
        gtParagraphStyle *s;
559
        QString tname = style->getName();
560
        if ((style->target() == "paragraph") && (packStyles))
561
        {
562
                s = dynamic_cast<gtParagraphStyle*>(style);
563
                QString nameByAttrs = QString("%1-").arg(s->getSpaceAbove());
564
                nameByAttrs += QString("%1-").arg(s->getSpaceBelow());
565
                nameByAttrs += QString("%1-").arg(s->getLineSpacing());
566
                nameByAttrs += QString("%1-").arg(s->getIndent());
567
                nameByAttrs += QString("%1-").arg(s->getFirstLineIndent());
568
                nameByAttrs += QString("%1-").arg(s->getAlignment());
569
                nameByAttrs += QString("%1-").arg(s->hasDropCap());
570
                nameByAttrs += QString("%1-").arg(s->getFont()->getColor());
571
                nameByAttrs += QString("%1-").arg(s->getFont()->getStrokeColor());
2282 fschmid 572
// TODO is this important ??
573
/*              QValueList<double>* tmp = s->getTabValues();
1579 tsoots 574
                for (uint i = 0; i < tmp->count(); ++i)
575
                {
576
                        double td = (*tmp)[i];
577
                        nameByAttrs += QString("%1-").arg(td);
2282 fschmid 578
                } */
1579 tsoots 579
                if (attrsStyles.contains(nameByAttrs))
580
                {
581
                        tname = attrsStyles[nameByAttrs]->getName();
582
                        ++pstyleCounts[nameByAttrs];
583
                        style->setName(tname);
584
                }
585
                else
586
                {
587
                        attrsStyles[nameByAttrs] = style;
588
                        pstyleCounts[nameByAttrs] = 1;
589
                        tname = style->getName();
590
                }
591
        }
592
        else if (!packStyles)
593
        {
594
                attrsStyles[name] = style;
595
                pstyleCounts[name] = 1;
596
                tname = style->getName();
597
        }
598
        if (!styles.contains(name))
599
        {
600
                if ((tname.find(docname) == -1) && (usePrefix))
601
                        style->setName(docname + "_" + tname);
602
                styles[name] = style;
603
        }
604
 }
605
 
606
 QString StyleReader::getFont(const QString& key)
607
 {
608
        if (fonts.contains(key))
609
                return fonts[key];
610
        else
611
                return key;
612
 }
613
 
614
 void StyleReader::setupFrameStyle()
615
 {
616
        QString fstyleName = "";
617
        int count = 0;
618
        CounterMap::Iterator it;
619
        for (it = pstyleCounts.begin(); it != pstyleCounts.end(); ++it)
620
        {
621
                if (it.data() > count)
622
                {
623
                        count = it.data();
624
                        fstyleName = it.key();
625
                }
626
        }
627
        gtFrameStyle* fstyle;
628
        gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(attrsStyles[fstyleName]);
629
        fstyle = new gtFrameStyle(*pstyle);
630
 
631
        if (!importTextOnly)
632
                writer->setFrameStyle(fstyle);
633
        delete fstyle;
634
 }
635
 
2212 tsoots 636
ListStyle* StyleReader::getList(const QString &name)
637
{
638
        ListStyle *tmp = 0;
639
        if (lists.contains(name))
640
                tmp = lists[name];
641
        return tmp;
642
}
643
 
1579 tsoots 644
 bool StyleReader::updateStyle(gtStyle* style, gtStyle* parent2Style, const QString& key, const QString& value)
645
 {
646
        gtParagraphStyle* pstyle = NULL;
647
        if (style->target() == "paragraph")
648
                pstyle = dynamic_cast<gtParagraphStyle*>(style);
649
        else
650
                pstyle = NULL;
651
        QString align = NULL;
652
        QString force = NULL;
653
 
654
        if (key == "style:font-name")
655
                style->getFont()->setName(getFont(value));
656
        else if (key == "fo:font-size")
657
        {
658
                double size = 0;
659
                double psize = 0;
660
                if (parent2Style != NULL)
661
                        psize = static_cast<double>(parent2Style->getFont()->getSize());
662
                else if (styles.contains("default-style"))
663
                        psize = static_cast<double>(styles["default-style"]->getFont()->getSize());
664
                        psize = psize / 10;
665
                size = getSize(value, psize);
666
                int nsize = static_cast<int>(size * 10);
667
                style->getFont()->setSize(nsize);
1622 tsoots 668
                if (pstyle)
1579 tsoots 669
                        pstyle->setLineSpacing(writer->getPreferredLineSpacing(nsize));
670
        }
671
        else if ((key == "fo:line-height") && (parent2Style != NULL))
672
        {
673
                gtParagraphStyle* ppstyle;
674
                if (parent2Style->target() == "paragraph")
675
                {
676
                        ppstyle = dynamic_cast<gtParagraphStyle*>(parent2Style);
677
                        pstyle->setLineSpacing(getSize(value, writer->getPreferredLineSpacing(style->getFont()->getSize())));
678
                }
679
        }
680
        else if (key == "fo:color")
681
                style->getFont()->setColor(value);
682
        else if ((key == "style:use-window-font-color") && (value == "true"))
683
                        style->getFont()->setColor("Black");
684
        else if ((key == "fo:font-weight") && (value == "bold"))
685
                style->getFont()->setWeight(BOLD);
686
        else if ((key == "fo:font-style") && (value == "italic"))
687
                style->getFont()->setSlant(ITALIC);
1610 tsoots 688
        else if ((key == "style:text-underline-style") && (value != "none"))
1579 tsoots 689
                style->getFont()->toggleEffect(UNDERLINE);
690
        else if ((key == "style:text-crossing-out") && (value != "none"))
691
                style->getFont()->toggleEffect(STRIKETHROUGH);
692
        else if ((key == "fo:font-variant") && (value == "small-caps"))
693
                style->getFont()->toggleEffect(SMALL_CAPS);
694
        else if ((key == "style:text-outline") && (value == "true"))
695
        {
696
                style->getFont()->toggleEffect(OUTLINE);
697
                style->getFont()->setStrokeColor("Black");
698
                style->getFont()->setColor("White");
699
        }
700
        else if (key == "fo:letter-spacing")
2501 fschmid 701
                style->getFont()->setKerning(static_cast<int>(getSize(value, -1.0)));
1579 tsoots 702
        else if (key == "style:text-scale")
703
                style->getFont()->setHscale(static_cast<int>(getSize(value, -1.0)));
704
        else if ((key == "style:text-position") &&
705
                (((value).find("sub") != -1) ||
706
                        (((value).left(1) == "-") && ((value).left(1) != "0"))))
707
                style->getFont()->toggleEffect(SUBSCRIPT);
708
        else if ((key == "style:text-position") &&
709
                (((value).find("super") != -1) ||
710
                        (((value).left(1) != "-") && ((value).left(1) != "0"))))
711
                style->getFont()->toggleEffect(SUPERSCRIPT);
712
        else if ((key == "fo:margin-top") && (pstyle != NULL))
713
                pstyle->setSpaceAbove(getSize(value));
714
        else if ((key == "fo:margin-bottom") && (pstyle != NULL))
715
                pstyle->setSpaceBelow(getSize(value));
716
        else if ((key == "fo:margin-left") && (pstyle != NULL))
717
        {
718
                if (inList)
719
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
720
                else
721
                        pstyle->setIndent(getSize(value));     
722
        }
723
        else if ((key == "text:space-before") && (pstyle != NULL))
724
        {
725
                if (inList)
726
                        pstyle->setIndent(pstyle->getIndent() + getSize(value));
727
                else
728
                        pstyle->setIndent(getSize(value));     
729
        }
730
        else if ((key == "fo:text-indent") && (pstyle != NULL))
731
                pstyle->setFirstLineIndent(getSize(value));
732
        else if ((key == "fo:text-align") && (pstyle != NULL))
733
                align = value;
734
        else if ((key == "style:justify-single-word") && (pstyle != NULL))
735
                force = value;
736
 
737
        if (align != NULL)
738
        {
739
                if (align == "end")
740
                        pstyle->setAlignment(RIGHT);
741
                else if (align == "center")
742
                        pstyle->setAlignment(CENTER);
743
                else if (align == "justify")
744
                {
745
                        if (force != "false")
746
                                pstyle->setAlignment(FORCED);
747
                        else
748
                                pstyle->setAlignment(BLOCK);
749
                }
750
        }
751
 
752
        return true;
753
 }
754
 
755
 double StyleReader::getSize(QString s, double parentSize)
756
 {
757
        QString dbl = "0.0";
758
        QString lowerValue = s.lower();
759
        double ret = 0.0;
760
        if (lowerValue.find("pt") != -1)
761
        {
762
                dbl = lowerValue.remove("pt");
2594 cbradney 763
                ret = gtMeasure::d2d(dbl.toDouble(), SC_PT);
1579 tsoots 764
        }
765
        else if (lowerValue.find("mm") != -1)
766
        {
767
                dbl = lowerValue.remove("mm");
2594 cbradney 768
                ret = gtMeasure::d2d(dbl.toDouble(), SC_MM);
1579 tsoots 769
        }
770
        else if (lowerValue.find("cm") != -1)
771
        {
772
                dbl = lowerValue.remove("cm");
2594 cbradney 773
                ret = gtMeasure::d2d(dbl.toDouble() * 10, SC_MM);
1579 tsoots 774
        }
775
        else if (lowerValue.find("in") != -1)
776
        {
777
                dbl = lowerValue.remove("inch");
778
                dbl = lowerValue.remove("in");
2594 cbradney 779
                ret = gtMeasure::d2d(dbl.toDouble(), SC_IN);
1579 tsoots 780
        }
781
        else if (lowerValue.find("pi") != -1)
782
        {
783
                dbl = lowerValue.remove("pica");
784
                dbl = lowerValue.remove("pi");
2594 cbradney 785
                ret = gtMeasure::d2d(dbl.toDouble(), SC_P);
1579 tsoots 786
        }
2594 cbradney 787
        else if (lowerValue.find("c") != -1)
788
        {
789
                dbl = lowerValue.remove("cicero");
790
                dbl = lowerValue.remove("c");
791
                ret = gtMeasure::d2d(dbl.toDouble(), SC_C);
792
        }
1579 tsoots 793
        else if (lowerValue.find("%") != -1)
794
        {
795
                dbl = lowerValue.remove("%");
796
                double factor = dbl.toDouble();
797
                if (parentSize != -1.0)
798
                {
799
                        factor = factor / 100;
800
                        ret = factor * parentSize;
801
                }
802
                else
803
                        ret = factor;
804
        }
805
        return ret;
806
 }
807
 
808
 StyleReader::~StyleReader()
809
 {
810
        sreader = NULL;
811
        StyleMap::Iterator it;
812
        for (it = styles.begin(); it != styles.end(); ++it)
813
        {
814
                if (it.data())
815
                {
816
                        delete it.data();
817
                        it.data() = NULL;
818
                }
819
        }
820
 }
821
 
822
 xmlSAXHandler sSAXHandlerStruct = {
823
        NULL, // internalSubset,
824
        NULL, // isStandalone,
825
        NULL, // hasInternalSubset,
826
        NULL, // hasExternalSubset,
827
        NULL, // resolveEntity,
828
        NULL, // getEntity,
829
        NULL, // entityDecl,
830
        NULL, // notationDecl,
831
        NULL, // attributeDecl,
832
        NULL, // elementDecl,
833
        NULL, // unparsedEntityDecl,
834
        NULL, // setDocumentLocator,
835
        NULL, // startDocument,
836
        NULL, // endDocument,
837
        StyleReader::startElement,
838
        StyleReader::endElement,
839
        NULL, // reference,
840
        NULL, // characters
841
        NULL, // ignorableWhitespace,
842
        NULL, // processingInstruction,
843
        NULL, // comment,
844
        NULL, // warning,
845
        NULL, // error,
846
        NULL, // fatalError,
847
        NULL, // getParameterEntity,
848
        NULL, // cdata,
849
        NULL,
850
        1
851
 #ifdef HAVE_XML26
852
        ,
853
        NULL,
854
        NULL,
855
        NULL,
856
        NULL
857
 #endif
858
 };
859
 
860
 xmlSAXHandlerPtr sSAXHandler = &sSAXHandlerStruct;
861
 
862
 void StyleReader::startElement(void*, const xmlChar * fullname, const xmlChar ** atts)
863
 {
864
        QString* name = new QString((const char*) fullname);
865
        name = new QString(name->lower());
866
        QXmlAttributes* attrs = new QXmlAttributes();
867
        if (atts)
868
        {
869
                for(const xmlChar** cur = atts; cur && *cur; cur += 2)
870
                        attrs->append(QString((char*)*cur), NULL, QString((char*)*cur), QString((char*)*(cur + 1)));
871
        }
872
        sreader->startElement(NULL, NULL, *name, *attrs);
873
 }
874
 
875
 void StyleReader::endElement(void*, const xmlChar * name)
876
 {
877
        QString *nname = new QString((const char*) name);
878
        nname = new QString(nname->lower());
879
        sreader->endElement(NULL, NULL, *nname);
880
 }
2212 tsoots 881
 
882
/*** ListLevel *****************************************************************************************/
883
 
884
const QString ListLevel::lowerUnits[10] = {"", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"};
885
const QString ListLevel::lowerTens[10] = {"", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"};
886
const QString ListLevel::lowerHundreds[10] = {"", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"};
887
const QString ListLevel::lowerThousands[4] = {"", "m", "mm", "mmm"};
888
const QString ListLevel::upperUnits[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
889
const QString ListLevel::upperTens[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
890
const QString ListLevel::upperHundreds[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCC", "CM"};
891
const QString ListLevel::upperThousands[4] = {"", "M", "MM", "MMM"};
892
const QString ListLevel::lowerAlphabets[27] = {"", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
893
                                    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
894
const QString ListLevel::upperAlphabets[27] = {"", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
895
                                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
896
 
897
ListLevel::ListLevel(uint level,
898
                         BulletType btype,
899
                         const QString &prefix,
900
                         const QString &suffix,
901
                         const QString &bullet,
902
                         uint displayLevels,
903
                         uint startValue) :
904
m_level(level),
905
m_btype(btype),
906
m_prefix(prefix),
907
m_suffix(suffix),
908
m_bullet(bullet),
909
m_displayLevels(displayLevels),
910
m_next(startValue)
911
{
912
 
913
}
914
 
915
QString ListLevel::bulletString()
916
{
917
        QString tmp;
918
        switch (m_btype) {
919
        case Bullet:
920
                tmp = m_bullet;
921
                break;
922
        case Number:
923
                tmp = QString("%1").arg(m_next);
924
                break;
925
        case LowerRoman:
926
                tmp = lowerRoman(m_next);
927
                break;
928
        case UpperRoman:
929
                tmp = upperRoman(m_next);
930
                break;
931
        case LowerAlpha:
932
                tmp = lowerAlpha(m_next);
933
                break;
934
        case UpperAlpha:
935
                tmp = upperAlpha(m_next);
936
                break;
937
        case Graphic:
938
                tmp = "*";
939
                break;
940
        default:
941
                tmp = "";
942
        };
943
        return tmp;
944
}
945
 
946
QString ListLevel::bullet()
947
{
948
 
949
        return QString(m_prefix + bulletString() + m_suffix);
950
}
951
 
952
QString ListLevel::prefix()
953
{
954
        return m_prefix;
955
}
956
 
957
QString ListLevel::suffix()
958
{
959
        return m_suffix;
960
}
961
 
962
void ListLevel::advance()
963
{
964
        ++m_next;
965
}
966
 
967
uint ListLevel::level()
968
{
969
        return m_level;
970
}
971
 
972
uint ListLevel::displayLevels()
973
{
974
        return m_displayLevels;
975
}
976
 
977
void ListLevel::reset()
978
{
979
        m_next = 0;
980
}
981
 
982
QString ListLevel::lowerRoman(uint n)
983
{
984
        return QString(lowerThousands[(n / 1000)] +
985
                       lowerHundreds[(n / 100) % 10] +
986
                       lowerTens[(n / 10) % 10] +
987
                       lowerUnits[(n) % 10]);
988
}
989
 
990
QString ListLevel::upperRoman(uint n)
991
{
992
        return QString(upperThousands[(n / 1000)] +
993
                       upperHundreds[(n / 100) % 10] +
994
                       upperTens[(n / 10) % 10] +
995
                       upperUnits[(n) % 10]);
996
}
997
 
998
QString ListLevel::lowerAlpha(uint n)
999
{
1000
        QString tmp;
1001
        uint rounds = static_cast<uint>(n / 26);
1002
        if (rounds > 26)
1003
                rounds = 0;
1004
        uint leftover = n % 26;
1005
        return QString(lowerAlphabets[rounds] + lowerAlphabets[leftover]);
1006
}
1007
 
1008
QString ListLevel::upperAlpha(uint n)
1009
{
1010
        QString tmp;
1011
        uint rounds = static_cast<uint>(n / 26);
1012
        if (rounds > 26)
1013
                rounds = 0;
1014
        uint leftover = n % 26;
1015
        return QString(upperAlphabets[rounds] + upperAlphabets[leftover]);
1016
}
1017
 
1018
ListLevel::~ListLevel()
1019
{
1020
 
1021
}
1022
 
1023
/*** ListStyle **********************************************************************************/
1024
 
1025
ListStyle::ListStyle(const QString &name, bool consecutiveNumbering, uint currentLevel) :
1026
m_name(name),
1027
m_consecutiveNumbering(consecutiveNumbering),
1028
m_currentLevel(currentLevel),
1029
m_count(0)
1030
{
1031
        for (uint i = 0; i < 11; ++i)
1032
                levels[i] = 0;
1033
}
1034
 
1035
void ListStyle::addLevel(uint level, ListLevel *llevel)
1036
{
1037
        if (level > 0 && level < 11)
1038
                levels[level] = llevel;
1039
}
1040
 
1041
QString ListStyle::bullet()
1042
{
1043
        uint displayLevels = levels[m_currentLevel]->displayLevels();
1044
        if (displayLevels == 1)
1045
                return QString(levels[m_currentLevel]->bullet() + " ");
1046
 
1047
        QString prefix = levels[m_currentLevel]->prefix();
1048
        QString suffix = levels[m_currentLevel]->suffix();
1049
        QString bullet = "";
1050
        int start = m_currentLevel - displayLevels + 1;
1051
        if (start < 1)
1052
                return QString(levels[m_currentLevel]->bullet() + " ");
1053
        while (static_cast<uint>(start) <= m_currentLevel)
1054
        {
1055
                if (static_cast<uint>(start) == m_currentLevel)
1056
                        bullet += levels[start]->bulletString();
1057
                else
1058
                        bullet += levels[start]->bulletString() + ".";
1059
                ++start;
1060
        }
1061
        return QString(prefix + bullet + suffix + " ");
1062
}
1063
 
1064
void ListStyle::advance()
1065
{
1066
        ++m_count;
1067
        if (levels[m_currentLevel])
1068
                levels[m_currentLevel]->advance();
1069
}
1070
 
1071
void ListStyle::setLevel(uint level)
1072
{
1073
        if (level > 0 && level < 11)
1074
                m_currentLevel = level;
1075
}
1076
 
1077
QString& ListStyle::name()
1078
{
1079
        return m_name;
1080
}
1081
 
1082
void ListStyle::resetLevel()
1083
{
1084
        levels[m_currentLevel]->reset();
1085
}
1086
 
1087
ListStyle::~ListStyle()
1088
{
1089
        for (uint i = 0; i < 11; ++i)
1090
        {
1091
                delete levels[i];
1092
                levels[i] = 0;
1093
        }
1094
}
1095
 
1096
#endif