Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
14472 fschmid 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
*/
7
/***************************************************************************
15288 jghali 8
*   Copyright (C) 2009 by Jain Basil Aliyas                               *
9
*   mail@jainbasil.net                                                    *
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.,                                       *
18122 mrdocs 24
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
15288 jghali 25
***************************************************************************/
14472 fschmid 26
 
27
#include "xtgscanner.h"
28
#include "text/specialchars.h"
29
#include "fonts/scface.h"
30
#include <QString>
31
#include <QList>
32
#include <QDebug>
33
#include <QMessageBox>
34
 
35
class ScribusDoc;
36
 
37
XtgScanner::XtgScanner ( QString documentName,TextWriter *wr,QString& buffer, bool textOnly, bool prefix)
38
{
39
        writer = wr;
40
        docname = documentName;
41
        importTextOnly = textOnly;
42
        usePrefix    = prefix;
43
        input_Buffer = buffer;
44
        doc = writer->currentDoc();
45
        initTagMode();
46
        initTextMode();
47
        initNameMode();
48
        initLanguages();
49
        top=0;
50
        prevMode = textMode;
51
        textToAppend = "";
52
        define = 0;
15288 jghali 53
        isBold=false;
54
        isItalic=false;
14472 fschmid 55
}
56
 
57
/** Initialise a QHash which maps the values of n## to corresponding language strings
58
*/
59
 
60
void XtgScanner::initLanguages()
61
{
62
        /* For more info, look at langmgr.cpp */
63
        languages.insert(72,"Bulgarian");
64
        languages.insert(73,"Catalan");
65
        languages.insert(52,"Chinese");
66
        languages.insert(53,"Chinese");
67
        languages.insert(68,"Croatian");
68
        languages.insert(56,"Czech");
69
        languages.insert(9,"Danish");
70
        languages.insert(5,"Dutch");
71
        languages.insert(2,"English");
72
        languages.insert(0,"English");
73
        languages.insert(17,"Finnish");
74
        languages.insert(1,"French");
75
        languages.insert(3,"German");
76
        languages.insert(70,"German");
77
        languages.insert(19,"German");
78
        languages.insert(20,"Greek");
79
        languages.insert(43,"Hungarian");
80
        languages.insert(21,"Icelandic");
81
        languages.insert(4,"Italian");
82
        languages.insert(14,"Japanese");
83
        languages.insert(41,"Lithuanian");
84
        languages.insert(12,"Norwegian (Bokmål)");
85
        languages.insert(80,"Norwegian (Bokmål)");
86
        languages.insert(42,"Polish");
87
        languages.insert(71,"Portuguese (BR)");
88
        languages.insert(10,"Portuguese");
89
        languages.insert(39,"Romanian");
90
        languages.insert(57,"Slovak");
91
        languages.insert(66,"Slovenian");
92
        languages.insert(8,"Spanish");
93
        languages.insert(7,"Swedish");
94
        languages.insert(62,"Ukranian");
95
 
96
}
97
 
98
/** Initialise the tagModeHash with the tokens returned in tagMode and its corresponding function pointers */
99
 
100
void XtgScanner::initTagMode()
101
{
102
        tagModeHash.insert("P",&XtgScanner::setPlain);
103
        tagModeHash.insert("B",&XtgScanner::setBold);
104
        tagModeHash.insert("I",&XtgScanner::setItalics);
105
        tagModeHash.insert("O",&XtgScanner::setOutline);
106
        tagModeHash.insert("S",&XtgScanner::setShadow);
107
        tagModeHash.insert("U",&XtgScanner::setUnderline);
108
        tagModeHash.insert("W",&XtgScanner::setWordUnder);
109
        tagModeHash.insert("/",&XtgScanner::setStrikethrough);
110
        tagModeHash.insert("R",&XtgScanner::setDoubleStrike);
111
        tagModeHash.insert("K",&XtgScanner::setAllCaps);
112
        tagModeHash.insert("H",&XtgScanner::setSmallCaps);
113
        tagModeHash.insert("+",&XtgScanner::setSuperscript);
114
        tagModeHash.insert("-",&XtgScanner::setSubscript);
115
        tagModeHash.insert("V",&XtgScanner::setSuperior);
116
        tagModeHash.insert("f",&XtgScanner::setFont);
117
        tagModeHash.insert("z",&XtgScanner::setFontSize);
118
        tagModeHash.insert("c",&XtgScanner::setColor);
119
        tagModeHash.insert("s",&XtgScanner::setShade);
120
        tagModeHash.insert("h",&XtgScanner::setHorizontalScale);
121
        tagModeHash.insert("k",&XtgScanner::setKern);
122
        tagModeHash.insert("t",&XtgScanner::setTrack);
123
        tagModeHash.insert("b",&XtgScanner::setBaseLineShift);
124
        tagModeHash.insert("y",&XtgScanner::setVerticalScale);
125
        tagModeHash.insert("G",&XtgScanner::setLigatures);
126
        tagModeHash.insert("p",&XtgScanner::csetOpacity);
127
        tagModeHash.insert("o",&XtgScanner::setOpenType);
128
        tagModeHash.insert("*A",&XtgScanner::setCharAlignment);
129
        tagModeHash.insert("L",&XtgScanner::setVertStories);
130
        tagModeHash.insert("M",&XtgScanner::setEmphasisMarks);
131
        tagModeHash.insert("Y",&XtgScanner::setAsncjk);//Apply sending to non-CJK characters.
132
        tagModeHash.insert("n",&XtgScanner::setLanguages);
133
        tagModeHash.insert("A(",&XtgScanner::setXPresOwn); //Apply features like Rubi text, group characters & hyperlink
134
        tagModeHash.insert("*L",&XtgScanner::setAlignLeft);
135
        tagModeHash.insert("*C",&XtgScanner::setAlignCenter);
136
        tagModeHash.insert("*R",&XtgScanner::setAlignRight);
137
        tagModeHash.insert("*J",&XtgScanner::setAlignJustify);
138
        tagModeHash.insert("*F",&XtgScanner::setAlignFJustify);
139
        tagModeHash.insert("*t",&XtgScanner::setTabStops);
140
        tagModeHash.insert("*p",&XtgScanner::setPAttributes);
141
        tagModeHash.insert("*h",&XtgScanner::setHyphenation);
142
        tagModeHash.insert("*ra",&XtgScanner::setPRuleAbove);
143
        tagModeHash.insert("*rb",&XtgScanner::setPRuleBelow);
15288 jghali 144
        tagModeHash.insert("*d",&XtgScanner::setDropCap);
14472 fschmid 145
        tagModeHash.insert("*kn",&XtgScanner::setKeepNextPar);
146
        tagModeHash.insert("*kt",&XtgScanner::setKeepTogether);
147
        tagModeHash.insert("*s",&XtgScanner::setHangingCSet);
148
        tagModeHash.insert("DoO",&XtgScanner::setGlyph);
149
        tagModeHash.insert("EX",&XtgScanner::setTranscodeSeq);
150
        tagModeHash.insert("DO",&XtgScanner::setUnencodedGlyph);
151
 
152
        tagModeHash.insert("@>",&XtgScanner::applyCStyle1);
153
        tagModeHash.insert("@$",&XtgScanner::applyCStyle2);
154
        tagModeHash.insert("@$p",&XtgScanner::applyCStyle3);
155
        tagModeHash.insert("$$",&XtgScanner::applyCStyle4);
156
        tagModeHash.insert("a$",&XtgScanner::applyCStyle5);
157
        tagModeHash.insert("a$$",&XtgScanner::applyCStyle6);
158
 
159
        tagModeHash.insert("$",&XtgScanner::setTypeStyle);
160
 
161
        tagModeHash.insert("\\@",&XtgScanner::appendSpChar1);
162
        tagModeHash.insert("x",&XtgScanner::xFlag);
163
        tagModeHash.insert("\\>",&XtgScanner::appendSpChar2);
164
        tagModeHash.insert("\\",&XtgScanner::appendSpChar3);
165
        tagModeHash.insert(">",&XtgScanner::defClose);
166
}
167
 
168
/** Initialise the textModeHash with tokens returned in textMode and its corresponding function pointers */
169
 
170
void XtgScanner::initTextMode()
171
{
172
        textModeHash.insert("\n",&XtgScanner::defNewLine);
173
        textModeHash.insert("<",&XtgScanner::defOpen);
174
        textModeHash.insert("@",&XtgScanner::defAtRate);
175
        textModeHash.insert("\r",&XtgScanner::defHardReturn);
176
}
177
 
178
/** Initialise the nameModeHash with tokens returned in nameMode and its corresponding function pointers */
179
 
180
void XtgScanner::initNameMode()
181
{
182
        nameModeHash.insert("[F]",&XtgScanner::defFontSet);
183
        nameModeHash.insert("[C]",&XtgScanner::defColor);
184
        nameModeHash.insert("[Sp",&XtgScanner::definePStyles);
185
        nameModeHash.insert("[St",&XtgScanner::defineCStyle);
186
        nameModeHash.insert("=",&XtgScanner::defEquals);
187
        nameModeHash.insert(":",&XtgScanner::defColon);
188
}
189
 
190
/** Function for each tokens in tagMode. Each token is hashed with corresponding function pointers
191
*/
192
 
193
void XtgScanner::setPlain()
194
{
195
}
196
 
197
 
198
void XtgScanner::setBold()
199
{
15288 jghali 200
        /* We need to toggle the bold status, hence we set the font as Regular if it is Bold and Italic if it is Bold   Italic. If the case is not to toggle the font, we just set it to Bold or Bold Italic */
201
        if (curFontUsed.isNone()==true)
14472 fschmid 202
        {
15288 jghali 203
                isBold=true;
14472 fschmid 204
        }
15288 jghali 205
        else
206
        {
207
                QHash<QString,QString> font;
208
                font.insert("Regular","Bold");
209
                font.insert("Italic","Bold Italic");
210
                font.insert("Bold","Regular");
211
                font.insert("Bold Italic","Italic");
212
                QString fontStyle = curFontUsed.style();
213
                fontStyle = font.value(fontStyle);
214
                curFontUsed = (*(doc->AllFonts)).value( curFontUsed.family() +" "+ fontStyle );
215
                if (define==0)
216
                {
217
                        flushText();
218
                        currentCharStyle.setFont(curFontUsed);
219
                        writer->setCharStyle(currentCharStyle);
220
                        currentCharStyle = writer->getCurrentCharStyle();
221
                }
222
                if (define==1)
223
                        defCharStyle.setFont(curFontUsed);
224
                if (define==2)
225
                        defParagraphStyle.charStyle().setFont(curFontUsed);
226
        }
14472 fschmid 227
}
228
 
229
void XtgScanner::setItalics()
230
{
15288 jghali 231
        /* Hash is formed as in the case of setBold() */
232
        if (curFontUsed.isNone()==true)
233
                isItalic = true;
234
        else
235
        {
236
                QHash<QString,QString> font;
237
                font.insert("Regular","Italic");
238
                font.insert("Bold","Bold Italic");
239
                font.insert("Italic","Regular");
240
                font.insert("Bold Italic","Bold");
241
                QString fontStyle = curFontUsed.style();
242
                fontStyle = font.value(fontStyle);
243
                curFontUsed = (*(doc->AllFonts)).value( curFontUsed.family() +" "+ fontStyle );
14472 fschmid 244
 
15288 jghali 245
                if (define == 0)
246
                {
247
                        flushText();
248
                        currentCharStyle.setFont(curFontUsed);
249
                        writer->setCharStyle(currentCharStyle);
250
                        currentCharStyle = writer->getCurrentCharStyle();
251
                }
252
                if (define == 1)
253
                        defCharStyle.setFont(curFontUsed);
254
                if (define == 2)
255
                        defParagraphStyle.charStyle().setFont(curFontUsed);
256
        }
14472 fschmid 257
}
258
 
259
void XtgScanner::setShadow()
260
{
261
        applyFeature(CharStyle::SHADOWED);
262
}
263
 
264
void XtgScanner::setOutline()
265
{
266
        applyFeature(CharStyle::OUTLINE);
267
}
268
 
269
void XtgScanner::setUnderline()
270
{
271
        applyFeature(CharStyle::UNDERLINE);
272
}
273
 
274
void XtgScanner::setWordUnder()
275
{
276
        unSupported.append(token);
277
}
278
 
279
void XtgScanner::setStrikethrough()
280
{
281
        applyFeature(CharStyle::STRIKETHROUGH);
282
}
283
 
284
void XtgScanner::setDoubleStrike()
285
{
286
        unSupported.append(token);
287
}
288
 
289
void XtgScanner::setAllCaps()
290
{
291
        applyFeature(CharStyle::ALLCAPS);
292
}
293
 
294
void XtgScanner::setSmallCaps()
295
{
296
        applyFeature(CharStyle::SMALLCAPS);
297
}
298
 
299
void XtgScanner::setSuperscript()
300
{
301
        applyFeature(CharStyle::SUPERSCRIPT);
302
}
303
 
304
void XtgScanner::setSubscript()
305
{
306
        applyFeature(CharStyle::SUBSCRIPT);
307
}
308
 
309
void XtgScanner::setSuperior()
310
{
311
        unSupported.append(token);     
312
}
313
 
314
void XtgScanner::setFont()
315
{
316
        /** define/apply font */
15288 jghali 317
        flushText();
318
        token = getToken();
319
        curFontUsed = (*(doc->AllFonts)).value(token);
320
        if (curFontUsed.isNone())
321
        {
322
                QList<QString> List = ((*(doc->AllFonts)).keys());
323
                QStringList filter = static_cast<QStringList>(List).filter(token);
324
                if (!filter.empty())
325
                List = filter;
326
                FontSelect *f = new FontSelect(static_cast<QStringList>(List));
327
                if (f->exec())
328
                {
329
                        token = f->setFont();
330
                        delete f;
331
                }
332
                else
333
                        delete f;
334
        }
335
        curFontUsed = (*(doc->AllFonts)).value(token);
336
        /* Now we check whether isBold=true and isItalic=true. If yes, we will set those */
337
        if (isBold && !(curFontUsed.style()).contains("Bold"))
338
        {
339
                setBold();
340
                isBold=false;
341
        }
342
        if (isItalic && !(curFontUsed.style()).contains("Italic"))
343
        {
344
                setItalics();
345
                isItalic=false;
346
        }
347
        if (define == 0)
348
        {
349
                flushText();
350
                currentCharStyle.setFont(curFontUsed);
351
                writer->setCharStyle(currentCharStyle);
352
                currentCharStyle = writer->getCurrentCharStyle();
353
        }
354
        if (define == 1)
355
                defCharStyle.setFont(curFontUsed);
356
        if (define == 2)
357
                defParagraphStyle.charStyle().setFont( curFontUsed );
14472 fschmid 358
}
359
 
360
void XtgScanner::setFontSize()
361
{
362
        token = getToken();
15288 jghali 363
        if (define == 0)
14472 fschmid 364
        {
365
                flushText();
366
                currentCharStyle.setFontSize( token.toDouble() * 10 );
367
                writer->setCharStyle(currentCharStyle);
368
                currentCharStyle = writer->getCurrentCharStyle();
369
        }
15288 jghali 370
        if (define ==  1)
14472 fschmid 371
                defCharStyle.setFontSize( token.toDouble() * 10 );
15288 jghali 372
        if (define ==  2)
14472 fschmid 373
                defParagraphStyle.charStyle().setFontSize( token.toDouble() * 10 );
374
}
375
 
376
void XtgScanner::setColor()
377
{
378
        token = getToken();    
379
 
15288 jghali 380
        QHash<QString,QString> color;
14472 fschmid 381
        color.insert("cC","Cyan");
382
        color.insert("cM","Magenta");
383
        color.insert("cY","Yellow");
384
        color.insert("cK","Black");
385
 
15288 jghali 386
        if (token == "C" || token == "M" || token == "Y" || token == "K")
14472 fschmid 387
        {
388
                token = "c" + token;
389
                token = color.value(token);
390
        }
15288 jghali 391
        if (define == 0)
14472 fschmid 392
        {
393
                flushText();
394
                currentCharStyle.setFillColor(token);
395
                writer->setCharStyle(currentCharStyle);
396
                currentCharStyle = writer->getCurrentCharStyle();
397
        }
15288 jghali 398
        if (define == 1)
14472 fschmid 399
                defCharStyle.setFillColor(token);
15288 jghali 400
        if (define == 2)
14472 fschmid 401
                defParagraphStyle.charStyle().setFillColor(token);
402
}
403
 
404
void XtgScanner::setShade()
405
{
406
        token = getToken();
15288 jghali 407
        if (define == 0)
14472 fschmid 408
        {
409
                flushText();
410
                currentCharStyle.setFillShade(token.toDouble() * 10);
411
                writer->setCharStyle(currentCharStyle);
412
                currentCharStyle = writer->getCurrentCharStyle();
413
        }
15288 jghali 414
        if (define == 1)
14472 fschmid 415
                defCharStyle.setFillShade(token.toDouble() * 10);
15288 jghali 416
        if (define == 2)
14472 fschmid 417
                defParagraphStyle.charStyle().setFillShade(token.toDouble() * 10);
418
 
419
}
420
 
421
void XtgScanner::setHorizontalScale()
422
{
423
        token = getToken();
15288 jghali 424
        if (define == 0)
14472 fschmid 425
        {
426
                flushText();
427
                currentCharStyle.setScaleH(token.toDouble() * 10);
428
                writer->setCharStyle(currentCharStyle);
429
                currentCharStyle = writer->getCurrentCharStyle();
430
        }
15288 jghali 431
        if (define == 1)
14472 fschmid 432
                defCharStyle.setScaleH(token.toDouble() * 10);
15288 jghali 433
        if (define == 2)
14472 fschmid 434
                defParagraphStyle.charStyle().setScaleH(token.toDouble() * 10);
435
}
436
 
437
void XtgScanner::setKern()
438
{
439
        token = getToken();
15288 jghali 440
        if (define == 0)
14472 fschmid 441
        {
442
                flushText();
443
                currentCharStyle.setWordTracking(token.toDouble() * 10);
444
                writer->setCharStyle(currentCharStyle);
445
                currentCharStyle = writer->getCurrentCharStyle();
446
        }
15288 jghali 447
        if (define == 1)
448
        defCharStyle.setWordTracking(token.toDouble() * 10);
449
        if (define == 2)
450
        defParagraphStyle.charStyle().setWordTracking(token.toDouble() * 10);
14472 fschmid 451
}
452
 
453
void XtgScanner::setTrack()
454
{
455
        token = getToken();
15288 jghali 456
        if (define == 0)
14472 fschmid 457
        {
458
                flushText();
15288 jghali 459
                currentCharStyle.setTracking(token.toDouble() * 10);
14472 fschmid 460
                writer->setCharStyle(currentCharStyle);
461
                currentCharStyle = writer->getCurrentCharStyle();
462
        }
15288 jghali 463
        if (define == 1)
464
                defCharStyle.setTracking(token.toDouble() * 10);
465
        if (define == 2)
466
                defParagraphStyle.charStyle().setTracking(token.toDouble() * 10);
14472 fschmid 467
}
468
 
469
void XtgScanner::setBaseLineShift()
470
{
471
        token = getToken();
472
        unSupported.append("b"+token);
473
}
474
 
475
void XtgScanner::setVerticalScale()
476
{
477
        token = getToken();
15288 jghali 478
        if (define == 0)
14472 fschmid 479
        {
480
                flushText();
481
                currentCharStyle.setScaleV(token.toDouble() * 10);
482
                writer->setCharStyle(currentCharStyle);
483
                currentCharStyle = writer->getCurrentCharStyle();
484
        }
15288 jghali 485
        if (define == 1)
14472 fschmid 486
                defCharStyle.setScaleV(token.toDouble() * 10);
15288 jghali 487
        if (define == 2)
14472 fschmid 488
                defParagraphStyle.charStyle().setScaleV(token.toDouble() * 10);
489
}
490
 
491
void XtgScanner::setLigatures()
492
{
493
        token = getToken();
494
        unSupported.append("G"+token);
495
}
496
 
497
void XtgScanner::csetOpacity()
498
{
499
        token = getToken();
500
        unSupported.append("p"+token);
501
}
502
 
503
void XtgScanner::setOpenType()
504
{
15288 jghali 505
        /* OpenType can be like this : o("xxxx","yyyy","zzzz") */
14472 fschmid 506
}
507
 
508
void XtgScanner::setCharAlignment()
509
{
510
        token.append( nextSymbol() );
511
        unSupported.append(token);     
512
}
513
 
514
void XtgScanner::setVertStories()
515
{
516
        token.append( nextSymbol() );
517
        unSupported.append(token);
518
}
519
 
520
void XtgScanner::setEmphasisMarks()
521
{
522
        token.append( nextSymbol() );
523
        unSupported.append(token);
524
}
525
 
526
void XtgScanner::setAsncjk()
527
{
528
        //Apply sending to non-CJK characters.
529
        token.append( nextSymbol() );
530
        unSupported.append(token);
531
}
532
 
533
void XtgScanner::setLanguages()
534
{
535
        token = getToken();
15288 jghali 536
        if (define == 0)
14472 fschmid 537
        {
538
                flushText();
539
                currentCharStyle.setLanguage( languages.value( token.toInt() ) );
540
                writer->setCharStyle(currentCharStyle);
541
                currentCharStyle = writer->getCurrentCharStyle();
542
        }
15288 jghali 543
        if (define == 1)
14472 fschmid 544
                defCharStyle.setLanguage( languages.value( token.toInt() ) );
15288 jghali 545
        if (define == 2)
14472 fschmid 546
                defParagraphStyle.charStyle().setLanguage( languages.value( token.toInt() ) ); 
547
}
548
 
549
void XtgScanner::setXPresOwn()
550
{
551
 
15288 jghali 552
        unSupported.append(token+')');
553
        //All these tags are unsupported in Scribus, so just ignoring them till we find close paranthesis
554
        while (lookAhead() != ')')
555
                top=top+1;
556
        top=top+1;//Ignore )
14472 fschmid 557
}
558
 
559
void XtgScanner::setAlignLeft()
560
{
15288 jghali 561
        if (define == 0)
14472 fschmid 562
        {
563
                flushText();
564
                currentParagraphStyle.setAlignment(ParagraphStyle::Leftaligned);
565
                writer->setStyle(currentParagraphStyle);
566
                currentCharStyle = writer->getCurrentCharStyle();
567
        }
15288 jghali 568
        if (define == 2)
14472 fschmid 569
                defParagraphStyle.setAlignment(ParagraphStyle::Leftaligned);
570
}
15288 jghali 571
 
14472 fschmid 572
void XtgScanner::setAlignCenter()
573
{
15288 jghali 574
        if (define == 0)
14472 fschmid 575
        {
576
                flushText();
577
                currentParagraphStyle.setAlignment(ParagraphStyle::Centered);
578
                writer->setStyle(currentParagraphStyle);
579
                currentParagraphStyle = writer->getCurrentStyle();
580
                currentCharStyle = currentParagraphStyle.charStyle();
581
        }
15288 jghali 582
        if (define == 2)
14472 fschmid 583
                defParagraphStyle.setAlignment(ParagraphStyle::Centered);
584
}
585
 
586
void XtgScanner::setAlignRight()
587
{
15288 jghali 588
        if (define == 0)
14472 fschmid 589
        {
590
                flushText();
591
                currentParagraphStyle.setAlignment(ParagraphStyle::Rightaligned);
592
                writer->setStyle(currentParagraphStyle);
593
                currentParagraphStyle = writer->getCurrentStyle();
594
                currentCharStyle = currentParagraphStyle.charStyle();
595
        }
15288 jghali 596
        if (define == 2)
14472 fschmid 597
                defParagraphStyle.setAlignment(ParagraphStyle::Rightaligned);
598
}
599
 
600
void XtgScanner::setAlignJustify()
601
{
15288 jghali 602
        if (define == 0)
14472 fschmid 603
        {
604
                flushText();
605
                currentParagraphStyle.setAlignment(ParagraphStyle::Justified);
606
                writer->setStyle(currentParagraphStyle);
607
                currentParagraphStyle = writer->getCurrentStyle();
608
                currentCharStyle = currentParagraphStyle.charStyle();
609
        }
15288 jghali 610
        if (define == 2)
14472 fschmid 611
                defParagraphStyle.setAlignment(ParagraphStyle::Justified);
612
}
613
 
614
void XtgScanner::setAlignFJustify()
615
{
15288 jghali 616
        if (define == 0)
14472 fschmid 617
        {
618
                flushText();
619
                currentParagraphStyle.setAlignment(ParagraphStyle::Extended);
620
                writer->setStyle(currentParagraphStyle);
621
                currentParagraphStyle = writer->getCurrentStyle();
622
                currentCharStyle = currentParagraphStyle.charStyle();
623
        }
15288 jghali 624
        if (define == 2)
14472 fschmid 625
                defParagraphStyle.setAlignment(ParagraphStyle::Extended);
626
}
627
 
628
void XtgScanner::setTabStops()
629
{
630
        //tag *t
15288 jghali 631
        //      token = getToken(); // Will contain the position
14472 fschmid 632
 
633
}
634
 
635
void XtgScanner::setPAttributes()
636
{
637
        double leftIndent,firstlineIndent,rightIndent,leading,gapBefore,gapAfter;
638
        leftIndent = getToken().toDouble();
639
        firstlineIndent = getToken().toDouble();
640
        rightIndent = getToken().toDouble();
641
        leading = getToken().toDouble();
642
        gapBefore = getToken().toDouble();
643
        gapAfter = getToken().toDouble();
644
        top = top+1;
645
        token="";
15288 jghali 646
        token.append( nextSymbol() );
14472 fschmid 647
 
15288 jghali 648
        if (token == "g")
14472 fschmid 649
        {
15288 jghali 650
                /* We have to discard (P,S)) since it is not yet supported in Scribus
651
                */
652
                while (lookAhead() != ')' )
14472 fschmid 653
                        top=top+1;
654
        }
15288 jghali 655
        if (define == 0)
14472 fschmid 656
        {
657
                flushText();
658
                currentParagraphStyle.setLeftMargin(leftIndent);
659
                currentParagraphStyle.setRightMargin(rightIndent);
660
                currentParagraphStyle.setFirstIndent(firstlineIndent);
661
                currentParagraphStyle.setLineSpacing(leading);
662
                currentParagraphStyle.setGapBefore(gapBefore);
663
                currentParagraphStyle.setGapAfter(gapAfter);
15288 jghali 664
                if (token == "G")
14472 fschmid 665
                        currentParagraphStyle.setUseBaselineGrid(true);
15288 jghali 666
                if (token == "g")
14472 fschmid 667
                        currentParagraphStyle.setUseBaselineGrid(false);
668
                writer->setStyle(currentParagraphStyle);
669
                currentParagraphStyle = writer->getCurrentStyle();
670
                currentCharStyle = currentParagraphStyle.charStyle();
671
        }
15288 jghali 672
        if (define == 2)
14472 fschmid 673
        {
674
                defParagraphStyle.setLeftMargin(leftIndent);
675
                defParagraphStyle.setRightMargin(rightIndent);
676
                defParagraphStyle.setFirstIndent(firstlineIndent);
677
                defParagraphStyle.setLineSpacing(leading);
678
                defParagraphStyle.setGapBefore(gapBefore);
679
                defParagraphStyle.setGapAfter(gapAfter);
15288 jghali 680
                if (token == "G")
14472 fschmid 681
                        defParagraphStyle.setUseBaselineGrid(true);
15288 jghali 682
                if (token == "g")
14472 fschmid 683
                        defParagraphStyle.setUseBaselineGrid(false);
684
        }      
685
}
686
 
687
void XtgScanner::setHyphenation()
688
{
689
        token=getToken();
690
}
691
 
692
void XtgScanner::setPRuleAbove()
693
{
694
        unSupported.append(token);
15288 jghali 695
        while (lookAhead() != '>')
14472 fschmid 696
                top = top+1;
697
}
698
 
699
void XtgScanner::setPRuleBelow()
700
{
701
        unSupported.append(token);
15288 jghali 702
        while (lookAhead() != '>')
14472 fschmid 703
                top = top+1;
704
}
705
 
706
void XtgScanner::setDropCap()
707
{
15288 jghali 708
        int lineCount;
709
        double charCount;
710
        lineCount = getToken().toInt();
711
        if (lineCount==0) //Specify No rule
712
        {
713
                if (define == 0)
714
                {
715
                        flushText();
716
                        currentParagraphStyle.setHasDropCap(false);
717
                        writer->setStyle(currentParagraphStyle);
718
                        currentParagraphStyle = writer->getCurrentStyle();
719
                        currentCharStyle = currentParagraphStyle.charStyle();
720
                }
721
                if (define == 2)
722
                {
723
                        defParagraphStyle.setHasDropCap(false);
724
                }
725
        }
726
        else
727
        {
728
                charCount = getToken().toDouble();
14472 fschmid 729
 
15288 jghali 730
                if (define == 0)
731
                {
732
                        flushText();
733
                        currentParagraphStyle.setDropCapLines(lineCount);
18047 craig 734
                        currentParagraphStyle.setParEffectOffset(charCount);
15288 jghali 735
                        currentParagraphStyle.setHasDropCap(true);
736
                        writer->setStyle(currentParagraphStyle);
737
                        currentParagraphStyle = writer->getCurrentStyle();
738
                        currentCharStyle = currentParagraphStyle.charStyle();
739
                }
14472 fschmid 740
 
15288 jghali 741
                if (define == 2)
742
                {
743
                        defParagraphStyle.setDropCapLines(lineCount);
18047 craig 744
                        defParagraphStyle.setParEffectOffset(charCount);
15288 jghali 745
                        defParagraphStyle.setHasDropCap(true);
746
                }
747
        }
14472 fschmid 748
}
749
 
750
void XtgScanner::setKeepNextPar()
751
{
752
        token.append(nextSymbol());
753
        unSupported.append(token);
754
}
755
 
756
void XtgScanner::setKeepTogether()
757
{
15288 jghali 758
        if (lookAhead() == '(')
14472 fschmid 759
        {
15288 jghali 760
                while (lookAhead() != ')')
14472 fschmid 761
                        token.append( nextSymbol() );
762
        }
15288 jghali 763
        else
764
                token.append(nextSymbol());
14472 fschmid 765
        unSupported.append(token);
766
}
767
 
768
void XtgScanner::setHangingCSet()
769
{
770
        token.append( getToken() );
771
        unSupported.append(token);
772
}
773
 
774
void XtgScanner::setGlyph()
775
{
776
}
777
 
778
void XtgScanner::setTranscodeSeq()
779
{
780
}
781
 
782
void XtgScanner::setUnencodedGlyph()
783
{
784
}
785
 
786
void XtgScanner::appendSpChar1()
787
{
788
        textToAppend.append("@");
789
}
790
 
791
void XtgScanner::appendSpChar2()
792
{
793
        textToAppend.append("<");
794
}
795
 
796
void XtgScanner::appendSpChar3()
797
{
798
}
799
 
800
void XtgScanner::xFlag()
801
{
802
        xflag = true;
803
}
804
 
805
void XtgScanner::applyCStyle1()
806
{
807
        //apply nostyle character sheet <@>
808
        define = 0;
809
        flushText();
810
        writer->setCharStyle("Default Character Style");
811
        currentCharStyle = writer->getCurrentCharStyle();
812
}
813
 
814
void XtgScanner::applyCStyle2()
815
{
15288 jghali 816
        //apply normal character style sheet <@$>
14472 fschmid 817
        define = 0;
818
        flushText();
819
        writer->setCharStyle("Default Character Style");
820
        currentCharStyle = writer->getCurrentCharStyle();
821
}
822
 
823
void XtgScanner::applyCStyle3()
824
{
825
        //apply paragraph's character stylesheet <@$p>
826
        define = 0;
827
        flushText();
828
        currentCharStyle = currentParagraphStyle.charStyle();
829
        writer->setCharStyle(currentCharStyle);
830
        currentCharStyle = writer->getCurrentCharStyle();
831
}
832
 
833
void XtgScanner::applyCStyle4()
834
{
835
 
836
}
837
 
838
void XtgScanner::applyCStyle5()
839
{
840
        //tag = a$
841
}
842
 
843
void XtgScanner::applyCStyle6()
844
{
845
        //tag = a$$
846
}
847
 
848
void XtgScanner::setTypeStyle()
849
{
850
        //tag = $
851
}
852
 
853
/** Functions corresponding to tokens in textMode
854
*/
855
 
856
void XtgScanner::defNewLine()
857
{
858
        flushText();
15288 jghali 859
        if (lookAhead() == '@')
14472 fschmid 860
                newlineFlag = true;
861
        else
862
                writer->appendText(SpecialChars::PARSEP);
863
}
864
 
865
void XtgScanner::defHardReturn()
866
{
15288 jghali 867
        /* I saw a strange nature in XPress Tags that every hardreturn is followed by a soft return, hence fixing the
868
                new line flag to true */
869
        if (lookAhead() == '\n')
14472 fschmid 870
                newlineFlag = true;
871
        else
872
                writer->appendText(SpecialChars::PARSEP);
873
}
874
 
875
void XtgScanner::defOpen()
876
{
15288 jghali 877
        // token <
14472 fschmid 878
        enterState(tagMode);
879
}
880
 
881
void XtgScanner::defAtRate()
882
{
883
        enterState(nameMode);
884
        sfcName = getToken();
885
}
886
 
887
/** Functions corresponding to tokens in nameMode
888
*/
889
 
890
void XtgScanner::defClose()     //Token >
891
{
15288 jghali 892
        if (usePrefix)
893
                sfcName = docname+"-"+sfcName;
894
        if (define == 1)
14472 fschmid 895
        {
896
                writer->defineCharStyle(sfcName,defCharStyle);
897
                definedCStyles.append(sfcName);
898
                defCharStyle.erase();
899
        }
15288 jghali 900
        if (define == 2)
14472 fschmid 901
        {
902
                writer->defineStyle(sfcName,defParagraphStyle);
903
                definedStyles.append(sfcName);
904
                defParagraphStyle.erase();
905
        }
15288 jghali 906
        if (define != 0)
14472 fschmid 907
        {
908
                define = 0;
909
                dcsFeatures.clear();
910
        }
911
        enterState(textMode);  
912
}
913
 
914
void XtgScanner::defEquals()    //Token =
915
{
916
        //define a character stylesheet with the name in sfcName if the next character is not [
917
        newlineFlag = false;
15288 jghali 918
        if (lookAhead() != '[')
14472 fschmid 919
        {
920
                define = 1;
921
                defCharStyle.setParent("");
922
                enterState(textMode);
923
        }
924
        else
925
                define = 2;
926
}
927
 
928
void XtgScanner::defColon()
929
{
930
        flushText();
15288 jghali 931
        if (sfcName.isEmpty())
14472 fschmid 932
                qDebug()<<"Empty String";
15288 jghali 933
        if (sfcName == "@")
14472 fschmid 934
                sfcName = "Default Paragraph Style";
15288 jghali 935
        if (sfcName == "@$")
14472 fschmid 936
                sfcName = "Default Paragraph Style";
937
        writer->setStyle(sfcName);
938
        currentParagraphStyle = writer->getCurrentStyle();
939
        writer->setCharStyle(currentParagraphStyle.charStyle());
940
        currentCharStyle = writer->getCurrentCharStyle();
15288 jghali 941
        if (newlineFlag)
14472 fschmid 942
                writer->appendText(SpecialChars::PARSEP);
943
        newlineFlag = false;
944
        enterState(textMode);                  
945
        define = 0;
946
}
947
 
948
void XtgScanner::defFontSet()
949
{
950
        unSupported.append("[F]");
15288 jghali 951
        while (lookAhead() != '>' )
14472 fschmid 952
                top = top+1;
953
        top = top-1;
954
}
955
 
956
void XtgScanner::defColor()
957
{
958
        //Define the color using writer->defineColor()
959
 
960
}
961
 
962
void XtgScanner::definePStyles()
963
{
964
        QString s1,s2,s3;
965
        enterState(stringMode);
966
        define = 2;
967
        top=top+1;//skip the inch
968
        s1 = getToken();//will contain the string 1
969
        top=top+2;//we have to skip comma and next inch character
970
        s2 = getToken();
15288 jghali 971
        if (lookAhead() != ']' )
14472 fschmid 972
        {
973
                top = top+2;
974
                s3 = getToken();
975
        }
976
        top++; // to ensure that ] is avoided
977
 
978
        /** Type 1 definition of Paragraph Stylesheet. Refer Documentation for details
979
        */
15288 jghali 980
        if (s1=="" && s2=="" && s3=="")
14472 fschmid 981
        {
982
                //define paragraph stylesheet with default character attributes
983
                defParagraphStyle.setParent("");
984
                defParagraphStyle.charStyle().setParent("Default Character Style");
985
        }
986
 
987
        /** Type 2 definition of Paragraph Stylesheet. Refer Documentation for details
988
        */
15288 jghali 989
        else if (s1=="" && s2=="" && s3!="")
14472 fschmid 990
        {
991
                //define paragraphstyle with character style whose name is in s3
992
                defParagraphStyle.setParent("");
993
                if(styleStatus(definedCStyles,s3))
994
                        defParagraphStyle.charStyle().setParent(s3);
995
                else
996
                {
997
                        showWarning(s3);
998
                        defParagraphStyle.charStyle().setParent("Default Character Style");
999
                }
1000
        }
1001
 
1002
        /** Type 3 definition of Paragraph Stylesheet. Refer Documentation for details
1003
        */
15288 jghali 1004
        else if (s1 != "" && s2 != "" && s3 != "")
14472 fschmid 1005
        {
15288 jghali 1006
                if (styleStatus(definedStyles, s1) )
14472 fschmid 1007
                        defParagraphStyle.setParent(s1);
1008
                else
1009
                {
1010
                        showWarning(s1);
1011
                        defParagraphStyle.setParent("Default Paragraph Style");
1012
                }
15288 jghali 1013
                /** s2 is the next paragraph style which is to be applied, but this cannot be done at moment in Scribus
1014
                */
14472 fschmid 1015
                currentParagraphStyle = writer->getCurrentStyle();
1016
                currentCharStyle = currentParagraphStyle.charStyle();
1017
                defParagraphStyle.charStyle().setParent(s3);
1018
        }
1019
        else
1020
        {
1021
                //generate error : parser error
1022
        }
1023
        enterState(textMode);
1024
}
1025
 
1026
void XtgScanner::defineCStyle()
1027
{
1028
        //token [St
1029
        QString s4;
1030
        top = top+10;
1031
        s4 = getToken();
15288 jghali 1032
        if (styleStatus(definedCStyles,s4))
14472 fschmid 1033
                defCharStyle.setParent(s4);
1034
        else
1035
        {
1036
                showWarning(s4);
1037
                defCharStyle.setParent("Default Character Style");
1038
        }
1039
}
1040
 
1041
void XtgScanner::enterState ( scannerMode mode )
1042
{
1043
        prevMode = Mode;
1044
        Mode = mode;
1045
}
1046
 
1047
QString XtgScanner::sliceString()
1048
{
1049
        QString name;
15288 jghali 1050
        if (Mode == stringMode)
14472 fschmid 1051
        {
15288 jghali 1052
                while (lookAhead() != '\"')
14472 fschmid 1053
                {
1054
                        name.append( nextSymbol() );
1055
                }
1056
                top = top+1;
1057
        }
15288 jghali 1058
        if (Mode == nameMode)
14472 fschmid 1059
        {
15288 jghali 1060
                while (lookAhead() != '=' || lookAhead() != ':')
14472 fschmid 1061
                {
1062
                        name.append( nextSymbol() );
1063
                }
1064
        }
1065
        return name;
1066
}
1067
 
1068
QString XtgScanner::getToken()
1069
{
1070
        QChar temp;
1071
        QString token;
1072
        temp = lookAhead();
15288 jghali 1073
        if (currentState() == textMode)
14472 fschmid 1074
        {
1075
                /**
1076
                This mode should return only '<' or '@' or newline. It also adds the text_to_be_appended to the QString textToAppend
1077
                */
15288 jghali 1078
                if (temp =='<' || temp =='@' || temp == '\n' || temp == '\r')
14472 fschmid 1079
                        token.append( nextSymbol() );
15288 jghali 1080
                else if (temp == '\\')
14472 fschmid 1081
                {
1082
                        /**
1083
                        An escape sequence is occurred, hence we will just append
1084
                        the next character in buffer to the text. This will automatically
1085
                        deal the occurrance of '\@' or '\:' or any other relevant escapes
1086
                        */
1087
                        top = top+1;
1088
                        textToAppend.append( nextSymbol() );
1089
                }
1090
                else
1091
                        textToAppend.append( nextSymbol() );
1092
        }
1093
 
15288 jghali 1094
        if (currentState() == tagMode)
14472 fschmid 1095
        {
1096
                /**
1097
                This mode should return attributes B|I|U|O|....|*L|*C|... and an inch character "
1098
                */
15288 jghali 1099
                if (temp == '@')
14472 fschmid 1100
                {
1101
                        token.append( nextSymbol() ); // this will append @
15288 jghali 1102
                        if (lookAhead() == '$')
14472 fschmid 1103
                        {
1104
                                token.append( nextSymbol() ); //this will result in @$ if $ is found
15288 jghali 1105
                                if (lookAhead() == 'p' )
14472 fschmid 1106
                                        token.append( nextSymbol() ); //this will result in @$p if p is found
1107
                        }
1108
                        else // to get the name of character stylesheet applied as <@stylesheetname>
1109
                        {
15288 jghali 1110
                                while (lookAhead() != '>' )
14472 fschmid 1111
                                        token.append( nextSymbol() );
1112
                                token.append('>');
1113
                        }
1114
                }
15288 jghali 1115
                else if (temp == '*')
14472 fschmid 1116
                {
1117
                        token.append( nextSymbol() );
15288 jghali 1118
                        if (lookAhead() == 'r' || lookAhead() == 'k')
14472 fschmid 1119
                        {
1120
                                token.append( nextSymbol() );
1121
                                token.append( nextSymbol() );
1122
                        }
1123
                        else
1124
                                token.append( nextSymbol() );
1125
                }
15288 jghali 1126
                else if (temp == '\\' )
14472 fschmid 1127
                {
1128
                        /** append the * character and the nextSymbol to token so as to form a paragraph attribute and '\\' character to deal special characters that contain XPress Tags codes.
1129
                        */
1130
                        token.append( nextSymbol() );
1131
                        token.append( nextSymbol() );
1132
                }
15288 jghali 1133
                else if (temp == '\"')
14472 fschmid 1134
                {
1135
                        /**If inch character is found, the scanner should enter the string mode and enter the corresponding string as the token
1136
                        */
1137
                        enterState(stringMode);
1138
                        top = top+1;
1139
                        token = getToken();
1140
                        enterState( previousState() );
1141
                }
15288 jghali 1142
                else if (temp.isDigit())
14472 fschmid 1143
                {
15288 jghali 1144
                        while (lookAhead().isDigit() )
14472 fschmid 1145
                        {
1146
                                token.append( nextSymbol() );
15288 jghali 1147
                                if (lookAhead() == '.' )
14472 fschmid 1148
                                        token.append( nextSymbol() );
1149
                        }
1150
                }
15288 jghali 1151
                else if (temp == 'A')
14472 fschmid 1152
                {
1153
                        token.append(nextSymbol());
1154
                }
15288 jghali 1155
                else if (temp == 'a')
14472 fschmid 1156
                {
1157
                        token.append( nextSymbol() );
1158
                        //look for $ or $$ so as to form the token a$ and a$$
1159
                        token.append( getToken() );
1160
                }
15288 jghali 1161
                else if (temp == '$') //look for tags like $,$$ etc
14472 fschmid 1162
                {
1163
                        token.append( nextSymbol() );
1164
                        //check for existence one more $
15288 jghali 1165
                        if (lookAhead() == '$' )
14472 fschmid 1166
                                token.append( nextSymbol() );
1167
                }
15288 jghali 1168
                else if (temp == '>')
14472 fschmid 1169
                        token.append( nextSymbol() );
15288 jghali 1170
                else if (temp == '(')
14472 fschmid 1171
                {
1172
                        top = top+1;
1173
                        token = getToken();
1174
                }
15288 jghali 1175
                else if (temp == ',')
14472 fschmid 1176
                {
1177
                        top = top+1;
1178
                        token=getToken();
1179
                }
1180
                else
1181
                        token.append( nextSymbol() );
1182
        }
1183
 
15288 jghali 1184
        if (currentState() == nameMode)
14472 fschmid 1185
        {
1186
                /**
1187
                This mode should return the name of stylesheet (or font set or color) or '=' or ':','[' etc. This mode works with the assumption that a character '@' have occurred prior to it.Hence inorder to obtain the tags like '@$:' or '@:' ,we will append @ symbol initially to the token.
1188
                */
15288 jghali 1189
                if ( (input_Buffer.at(top-1)=='@') && (temp == ':') ) // get the simplest token @
14472 fschmid 1190
                {
1191
                        token.append('@');
1192
                }
15288 jghali 1193
                else if ( (input_Buffer.at(top-1)=='@') && (temp == '$') ) //get the token @$
14472 fschmid 1194
                {
1195
                        token.append('@');
1196
                        token.append( nextSymbol() );
1197
                }
15288 jghali 1198
                else if (temp == '\"' )
14472 fschmid 1199
                {
1200
                        enterState(stringMode);
1201
                        top = top+1;
1202
                        token = getToken();
1203
                        enterState( previousState() );
1204
                }
15288 jghali 1205
                else if (temp == ',' )
14472 fschmid 1206
                        top = top+1;
15288 jghali 1207
                else if (temp == '[' )
14472 fschmid 1208
                {
1209
                        //return [F] or [C] or [Sp or [St
1210
                        token.append( nextSymbol() );
15288 jghali 1211
                        if (lookAhead() == 'F' || lookAhead() == 'C' || lookAhead() == 'S')
14472 fschmid 1212
                        {
1213
                                token.append( nextSymbol() );
1214
                                token.append( nextSymbol() ); //append ]
1215
                        }
1216
                }
15288 jghali 1217
                else if (lookAhead() == '=')
14472 fschmid 1218
                        token.append( nextSymbol() );
15288 jghali 1219
                else if (lookAhead() == ':')
14472 fschmid 1220
                        token.append( nextSymbol() );
15288 jghali 1221
                else if (lookAhead() == '<')
14472 fschmid 1222
                {
1223
                        token.append( nextSymbol() );
1224
                }
1225
                else
1226
                { // find the name and return it as a tag
1227
                        while( 1 )
1228
                        {
1229
                                temp = lookAhead();
15288 jghali 1230
                                if (temp == ':' || temp == '=' )
14472 fschmid 1231
                                        break;
1232
                                token.append( input_Buffer.at(top++) );
1233
                        }
1234
                }
1235
        }
1236
 
1237
        if ( currentState() == stringMode )
1238
        {
15288 jghali 1239
                /* This mode should return those strings which are inside an inch character, while in tagMode. Hence this should set the mode to tagMode before returning the string value. This will call a function QString sliceString() which will return the required string and maintains the top correctly
14472 fschmid 1240
                */
1241
                token = sliceString();
1242
        }
1243
        return token;
1244
}
1245
scannerMode XtgScanner::currentState()
1246
{
1247
        return Mode;
1248
}
1249
scannerMode XtgScanner::previousState()
1250
{
1251
        return prevMode;
1252
}
1253
 
1254
QChar XtgScanner::lookAhead()
1255
{
1256
        return input_Buffer.at ( top );
1257
}
1258
 
1259
QChar XtgScanner::nextSymbol()
1260
{
1261
        return input_Buffer.at ( top++ );
1262
}
1263
 
1264
void XtgScanner::flushText()
1265
{
1266
        /* Append any text if exist in textToAppend */
15288 jghali 1267
        if (!textToAppend.isEmpty())
14472 fschmid 1268
        {
1269
                writer->appendText(textToAppend);
1270
                textToAppend="";
1271
        }
1272
}
1273
 
1274
bool XtgScanner::styleStatus(QStringList &name,QString &sfcname)
1275
{
1276
        int i;
15288 jghali 1277
        if (sfcname == "")
14472 fschmid 1278
                return true;
15288 jghali 1279
        for (i = 0; i < name.size(); i++)
14472 fschmid 1280
        {
15288 jghali 1281
                if (name.at(i) == sfcname)
14472 fschmid 1282
                        return true;
1283
        }
1284
        return false;
1285
}
1286
 
1287
void XtgScanner::showWarning(QString &name)
1288
{
1289
        QMessageBox msgBox;
1290
        msgBox.setWindowTitle("Message");
1291
        QString message = "Style " + name + " is not defined, falling back to Scribus Default";
1292
        msgBox.setText(message);
1293
        msgBox.exec();
1294
}
1295
void XtgScanner::applyFeature(const QString &feature)
1296
{
15288 jghali 1297
        if (define == 0)
14472 fschmid 1298
        {
1299
                flushText();
1300
                //checks whether the feature exist in feature list
1301
                if( (featureIndex=ccsFeatures.indexOf(feature,0)) == -1 )
1302
                        ccsFeatures.append(feature);
1303
                else //feature exist in list, so remove it and update the style
1304
                        ccsFeatures.removeAt( featureIndex );
1305
                currentCharStyle.setFeatures(ccsFeatures);     
1306
                currentCharStyle.updateFeatures();
1307
                writer->setCharStyle(currentCharStyle);
1308
        }
15288 jghali 1309
        if (define ==  1)
14472 fschmid 1310
        {
1311
                dcsFeatures.append(feature);
1312
                defCharStyle.setFeatures(dcsFeatures);
1313
        }
15288 jghali 1314
        if (define ==  2)
14472 fschmid 1315
        {
1316
                dcsFeatures.append(feature);
1317
                defParagraphStyle.charStyle().setFeatures(dcsFeatures);
1318
        }
1319
}
1320
 
1321
void XtgScanner::xtgParse()
1322
{
1323
        /* Enter the default mode as textMode */
1324
        enterState(textMode);
1325
        writer->setCharStyle("");
1326
        writer->setStyle("");
1327
        currentCharStyle = writer->getCurrentCharStyle();
1328
        currentParagraphStyle = writer->getCurrentStyle();
15288 jghali 1329
        while (input_Buffer.at(top) != '\0')
14472 fschmid 1330
        {
1331
                token = getToken();
1332
                QHash<QString,void (XtgScanner::*)(void)> *temp = NULL;
15288 jghali 1333
                if (Mode == tagMode)
14472 fschmid 1334
                        temp = &tagModeHash;
15288 jghali 1335
                if (Mode == nameMode)
14472 fschmid 1336
                        temp = &nameModeHash;
15288 jghali 1337
                if (Mode == textMode)
14472 fschmid 1338
                        temp = &textModeHash;
15288 jghali 1339
                if (temp->contains(token) )
14472 fschmid 1340
                {
15288 jghali 1341
                        funPointer = temp->value(token);
1342
                        (this->*funPointer)();
14472 fschmid 1343
                }
1344
 
15288 jghali 1345
                /**
1346
                                Various character Style Applications <@stylesheetname>. We cannot hash this since stylesheetname
1347
                                is not constant
1348
                                */
14472 fschmid 1349
 
15288 jghali 1350
                else if ( (currentState() == tagMode ) && token.startsWith('@') && token.endsWith('>') )
14472 fschmid 1351
                {
1352
                        /*here we receive a token @stylesheetname>, hence we have to slice of token to
1353
                                get the name of character stylesheet to be applied
1354
                        */
1355
                        define = 0;
1356
                        sfcName = token.remove(0,1);
1357
                        sfcName = sfcName.remove(sfcName.size()-1,1);
1358
                        flushText();
15288 jghali 1359
                        if (styleStatus(definedCStyles,sfcName))
14472 fschmid 1360
                                writer->setCharStyle(sfcName);
1361
                        else
1362
                        {
1363
                                showWarning(sfcName);
1364
                                writer->setCharStyle("");
1365
                        }
1366
                        currentCharStyle = writer->getCurrentCharStyle();
1367
                }
1368
        }
1369
        writer->appendText(textToAppend);
1370
        qDebug()<<"Unsupported : "<<unSupported;
1371
}
1372
 
1373
XtgScanner::~XtgScanner()
1374
{
1375
}