Subversion Repositories Scribus

Rev

Rev 898 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
364 Franz 1
/***************************************************************************
2
 *   Copyright (C) 2004 by Riku Leino                                      *
898 tsoots 3
 *   riku.leino@gmail.com                                                      *
364 Franz 4
 *                                                                         *
5
 *   This program is free software; you can redistribute it and/or modify  *
6
 *   it under the terms of the GNU General Public License as published by  *
7
 *   the Free Software Foundation; either version 2 of the License, or     *
8
 *   (at your option) any later version.                                   *
9
 *                                                                         *
10
 *   This program is distributed in the hope that it will be useful,       *
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13
 *   GNU General Public License for more details.                          *
14
 *                                                                         *
15
 *   You should have received a copy of the GNU General Public License     *
16
 *   along with this program; if not, write to the                         *
17
 *   Free Software Foundation, Inc.,                                       *
18
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19
 ***************************************************************************/
20
 
21
#include "gtaction.h"
415 Franz 22
#include <qcursor.h>
828 tsoots 23
#include <qstringlist.h>
24
#include "color.h"
364 Franz 25
 
26
extern ScribusApp* ScApp;
27
 
28
gtAction::gtAction(bool append)
29
{
30
        textFrame = ScApp->doc->ActPage->SelItem.at(0);
31
        it = textFrame;
32
        lastParagraphStyle = -1;
411 Franz 33
        inPara = false;
418 Franz 34
        isFirstWrite = true;
364 Franz 35
        lastCharWasLineChange = false;
375 Franz 36
        currentFrameStyle = "";
418 Franz 37
        doAppend = append;
411 Franz 38
        updateParagraphStyles = false;
418 Franz 39
        overridePStyleFont = true;
364 Franz 40
}
41
 
42
void gtAction::setProgressInfo()
43
{
44
        ScApp->FMess->setText(QObject::tr("Importing text"));
45
        ScApp->FProg->reset();
46
        ScApp->FProg->setTotalSteps(0);
47
}
48
 
49
void gtAction::setProgressInfoDone()
50
{
51
        ScApp->FMess->setText("");
52
        ScApp->FProg->reset();
53
}
54
 
55
void gtAction::setInfo(QString infoText)
56
{
57
        ScApp->FMess->setText(infoText);
58
}
59
 
60
void gtAction::clearFrame()
61
{
62
        textFrame->Ptext.clear();
63
        textFrame->CPos = 0;
64
}
65
 
411 Franz 66
void gtAction::write(const QString& text, gtStyle *style)
364 Franz 67
{
418 Franz 68
        if (isFirstWrite)
69
        {
70
                if (!doAppend)
71
                {
72
                        if (it->NextBox != 0)
73
                        {
74
                                PageItem *nb = it->NextBox;
75
                                while (nb != 0)
76
                                {
77
                                        nb->Ptext.clear();
78
                                        nb->CPos = 0;
79
                                        nb = nb->NextBox;
80
                                }
81
                        }
82
                        it->Ptext.clear();
83
                        it->CPos = 0;
84
                }
85
        }
411 Franz 86
        int paragraphStyle = -1;
364 Franz 87
        if (style->target() == "paragraph")
88
        {
89
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(style);
90
                paragraphStyle = applyParagraphStyle(pstyle);
418 Franz 91
                if (isFirstWrite)
92
                        inPara = true;
364 Franz 93
        }
94
        else if (style->target() == "frame")
95
        {
96
                gtFrameStyle* fstyle = dynamic_cast<gtFrameStyle*>(style);
97
                applyFrameStyle(fstyle);
98
        }
411 Franz 99
 
100
        if ((inPara) && (!lastCharWasLineChange) && (text.left(1) != "\n") && (lastParagraphStyle != -1))
101
                paragraphStyle = lastParagraphStyle;
102
 
103
 
104
        if (paragraphStyle == -1)
105
                paragraphStyle = ScApp->doc->CurrentABStil;
106
 
364 Franz 107
        gtFont* font = style->getFont();
375 Franz 108
        QString fontName = validateFont(font);
5264 tsoots 109
        gtFont font2(*font);
110
        font2.setName(ScApp->doc->Vorlagen[paragraphStyle].Font);
111
        QString fontName2 = validateFont(&font2);
364 Franz 112
        for (uint a = 0; a < text.length(); ++a)
113
        {
114
                if ((text.at(a) == QChar(0)) || (text.at(a) == QChar(13)))
115
                        continue;
116
                struct Pti *hg = new Pti;
117
                hg->ch = text.at(a);
118
                if ((hg->ch == QChar(10)) || (hg->ch == QChar(5)))
119
                        hg->ch = QChar(13);
418 Franz 120
                if ((inPara) && (!overridePStyleFont))
121
                {
122
                        if (ScApp->doc->Vorlagen[paragraphStyle].Font == "")
123
                                hg->cfont = fontName2;
124
                        else
125
                                hg->cfont = ScApp->doc->Vorlagen[paragraphStyle].Font;
126
                        hg->csize = ScApp->doc->Vorlagen[paragraphStyle].FontSize;
127
                        hg->ccolor = ScApp->doc->Vorlagen[paragraphStyle].FColor;
128
                        hg->cshade = ScApp->doc->Vorlagen[paragraphStyle].FShade;
129
                        hg->cstroke = ScApp->doc->Vorlagen[paragraphStyle].SColor;
130
                        hg->cshade2 = ScApp->doc->Vorlagen[paragraphStyle].SShade;
131
                        hg->cstyle = ScApp->doc->Vorlagen[paragraphStyle].FontEffect;
132
                }
133
                else
134
                {
135
                        hg->cfont = fontName;
136
                        hg->csize = font->getSize();
828 tsoots 137
                        hg->ccolor = parseColor(font->getColor());
418 Franz 138
                        hg->cshade = font->getShade();
828 tsoots 139
                        hg->cstroke = parseColor(font->getStrokeColor());
418 Franz 140
                        hg->cshade2 = font->getStrokeShade();
141
                        hg->cstyle = font->getEffectsValue();
142
                }
364 Franz 143
                hg->cscale = font->getHscale();
144
                hg->cextra = font->getKerning();
145
                hg->cselect = false;
411 Franz 146
                hg->cab = paragraphStyle;
364 Franz 147
                hg->xp = 0;
148
                hg->yp = 0;
149
                hg->PtransX = 0;
150
                hg->PtransY = 0;
151
                it->Ptext.append(hg);
152
        }
411 Franz 153
        lastCharWasLineChange = text.right(1) == "\n";
154
        inPara = style->target() == "paragraph";
155
        lastParagraphStyle = paragraphStyle;
418 Franz 156
        if (isFirstWrite)
157
                isFirstWrite = false;
364 Franz 158
}
159
 
160
int gtAction::findParagraphStyle(gtParagraphStyle* pstyle)
161
{
411 Franz 162
        return findParagraphStyle(pstyle->getName());
163
}
164
 
165
int gtAction::findParagraphStyle(const QString& name)
166
{
364 Franz 167
        int pstyleIndex = -1;
168
        for (uint i = 0; i < ScApp->doc->Vorlagen.size(); ++i)
169
        {
411 Franz 170
                if (ScApp->doc->Vorlagen[i].Vname == name)
171
                {
364 Franz 172
                        pstyleIndex = i;
173
                        break;
174
                }
175
        }
176
        return pstyleIndex;
177
}
178
 
179
int gtAction::applyParagraphStyle(gtParagraphStyle* pstyle)
180
{
181
        int pstyleIndex = findParagraphStyle(pstyle);
182
        if (pstyleIndex == -1)
183
        {
184
                createParagraphStyle(pstyle);
185
                pstyleIndex = ScApp->doc->Vorlagen.size() - 1;
186
        }
411 Franz 187
        else if (updateParagraphStyles)
188
        {
189
                updateParagraphStyle(pstyleIndex, pstyle);
190
        }
364 Franz 191
        return pstyleIndex;
192
}
193
 
194
void gtAction::applyFrameStyle(gtFrameStyle* fstyle)
195
{
375 Franz 196
        textFrame->Cols = fstyle->getColumns();
197
        textFrame->ColGap = fstyle->getColumnsGap();
828 tsoots 198
        textFrame->Pcolor = parseColor(fstyle->getBgColor());
375 Franz 199
        textFrame->Shade = fstyle->getBgShade();
387 Franz 200
        textFrame->TabValues = QValueList<double>(*(fstyle->getTabValues()));
375 Franz 201
 
411 Franz 202
//      gtParagraphStyle* pstyle = new gtParagraphStyle(*fstyle);
203
//      int pstyleIndex = findParagraphStyle(pstyle);
204
//      if (pstyleIndex == -1)
205
//              pstyleIndex = 0;
206
//      textFrame->Doc->CurrentABStil = pstyleIndex;
375 Franz 207
 
411 Franz 208
        double linesp;
209
        if (fstyle->getAutoLineSpacing())
210
                linesp = getLineSpacing(fstyle->getFont()->getSize());
211
        else
212
                linesp = fstyle->getLineSpacing();
213
        textFrame->LineSp = linesp;
214
 
375 Franz 215
        gtFont* font = fstyle->getFont();
216
        QString fontName = validateFont(font);
217
        textFrame->IFont = fontName;
218
        textFrame->ISize = font->getSize();
828 tsoots 219
        textFrame->TxtFill = parseColor(font->getColor());
375 Franz 220
        textFrame->ShTxtFill = font->getShade();
828 tsoots 221
        textFrame->TxtStroke = parseColor(font->getStrokeColor());
375 Franz 222
        textFrame->ShTxtStroke = font->getStrokeShade();
223
        textFrame->TxtScale = font->getHscale();
411 Franz 224
        textFrame->ExtraV = font->getKerning();
364 Franz 225
}
226
 
227
void gtAction::getFrameFont(gtFont *font)
228
{
229
        font->setName(textFrame->IFont);
230
        font->setSize(textFrame->ISize);
231
        font->setColor(textFrame->TxtFill);
232
        font->setShade(textFrame->ShTxtFill);
233
        font->setStrokeColor(textFrame->TxtStroke);
234
        font->setStrokeShade(textFrame->ShTxtStroke);
235
        font->setHscale(textFrame->TxtScale);
236
        font->setKerning(0);
237
}
238
 
239
void gtAction::getFrameStyle(gtFrameStyle *fstyle)
240
{
241
        fstyle->setColumns(textFrame->Cols);
242
        fstyle->setColumnsGap(textFrame->ColGap);
243
        fstyle->setBgColor(textFrame->Pcolor);
244
        fstyle->setBgShade(textFrame->Shade);
245
 
246
        struct StVorL vg = textFrame->Doc->Vorlagen[textFrame->Doc->CurrentABStil];
247
        fstyle->setName(vg.Vname);
248
        fstyle->setLineSpacing(vg.LineSpa);
249
        fstyle->setAlignment(vg.Ausri);
250
        fstyle->setIndent(vg.Indent);
251
        fstyle->setFirstLineIndent(vg.First);
252
        fstyle->setSpaceAbove(vg.Avor);
253
        fstyle->setSpaceBelow(vg.Anach);
254
        fstyle->setDropCap(vg.Drop);
255
        fstyle->setDropCapHeight(vg.DropLin);
256
        fstyle->setAdjToBaseline(vg.BaseAdj);
257
 
258
        gtFont font;
259
        getFrameFont(&font);
260
        fstyle->setFont(font);
387 Franz 261
        fstyle->setName("Default frame style");
364 Franz 262
}
263
 
264
void gtAction::createParagraphStyle(gtParagraphStyle* pstyle)
265
{
266
        if (textFrame->Doc->Vorlagen.size() > 5)
267
        {
268
                for (uint i = 5; i < textFrame->Doc->Vorlagen.size(); ++i)
269
                {
270
                        if (textFrame->Doc->Vorlagen[i].Vname == pstyle->getName())
271
                                return;
272
                }
411 Franz 273
        }
364 Franz 274
        gtFont* font = pstyle->getFont();
275
        struct StVorL vg;
276
        vg.Vname = pstyle->getName();
411 Franz 277
        double linesp;
278
        if (pstyle->getAutoLineSpacing())
279
                linesp = getLineSpacing(pstyle->getFont()->getSize());
280
        else
281
                linesp = pstyle->getLineSpacing();
282
        vg.LineSpa = linesp;
364 Franz 283
        vg.Ausri = pstyle->getAlignment();
284
        vg.Indent = pstyle->getIndent();
285
        vg.First = pstyle->getFirstLineIndent();
286
        vg.Avor = pstyle->getSpaceAbove();
287
        vg.Anach = pstyle->getSpaceBelow();
403 Franz 288
        vg.Font = validateFont(font);
364 Franz 289
        vg.FontSize = font->getSize();
290
        vg.TabValues.clear();
375 Franz 291
        QValueList<double> *tabs = pstyle->getTabValues();
292
        for (uint i = 0; i < tabs->size(); ++i)
293
        {
294
                double tmp = (*tabs)[i];
295
                vg.TabValues.append(tmp);
296
        }
364 Franz 297
        vg.Drop = pstyle->hasDropCap();
298
        vg.DropLin = pstyle->getDropCapHeight();
299
        vg.FontEffect = font->getEffectsValue();
828 tsoots 300
        vg.FColor = parseColor(font->getColor());
364 Franz 301
        vg.FShade = font->getShade();
828 tsoots 302
        vg.SColor = parseColor(font->getStrokeColor());
364 Franz 303
        vg.SShade = font->getStrokeShade();
304
        vg.BaseAdj = pstyle->isAdjToBaseline();
305
        textFrame->Doc->Vorlagen.append(vg);
306
        ScApp->Mpal->Spal->updateFList();
307
}
308
 
411 Franz 309
void gtAction::removeParagraphStyle(const QString& name)
310
{
311
        int index = findParagraphStyle(name);
312
        if (index != -1)
313
                removeParagraphStyle(index);
314
}
315
 
316
void gtAction::removeParagraphStyle(int index)
317
{
318
        QValueList<StVorL>::iterator it = ScApp->doc->Vorlagen.at(index);
319
        ScApp->doc->Vorlagen.remove(it);
320
}
321
 
322
void gtAction::updateParagraphStyle(const QString& pstyleName, gtParagraphStyle* pstyle)
323
{
324
        int pstyleIndex = findParagraphStyle(pstyle->getName());
325
        if (pstyleIndex != -1)
326
                updateParagraphStyle(pstyleIndex, pstyle);
327
}
328
 
329
void gtAction::updateParagraphStyle(int pstyleIndex, gtParagraphStyle* pstyle)
330
{
331
        gtFont* font = pstyle->getFont();
332
        struct StVorL vg;
333
        vg.Vname = pstyle->getName();
334
        double linesp;
335
        if (pstyle->getAutoLineSpacing())
336
                linesp = getLineSpacing(pstyle->getFont()->getSize());
337
        else
338
                linesp = pstyle->getLineSpacing();
339
        vg.LineSpa = linesp;
340
        vg.Ausri = pstyle->getAlignment();
341
        vg.Indent = pstyle->getIndent();
342
        vg.First = pstyle->getFirstLineIndent();
343
        vg.Avor = pstyle->getSpaceAbove();
344
        vg.Anach = pstyle->getSpaceBelow();
345
        vg.Font = validateFont(font);
346
        vg.FontSize = font->getSize();
347
        vg.TabValues.clear();
348
        QValueList<double> *tabs = pstyle->getTabValues();
349
        for (uint i = 0; i < tabs->size(); ++i)
350
        {
351
                double tmp = (*tabs)[i];
352
                vg.TabValues.append(tmp);
353
        }
354
        vg.Drop = pstyle->hasDropCap();
355
        vg.DropLin = pstyle->getDropCapHeight();
356
        vg.FontEffect = font->getEffectsValue();
828 tsoots 357
        vg.FColor = parseColor(font->getColor());
411 Franz 358
        vg.FShade = font->getShade();
828 tsoots 359
        vg.SColor = parseColor(font->getStrokeColor());
411 Franz 360
        vg.SShade = font->getStrokeShade();
361
        vg.BaseAdj = pstyle->isAdjToBaseline();
362
        ScApp->doc->Vorlagen[pstyleIndex] = vg;
363
}
364
 
375 Franz 365
QString gtAction::validateFont(gtFont* font)
364 Franz 366
{
411 Franz 367
        // Dirty hack for family Times New Roman
368
        if (font->getFamily() == "Times New")
369
        {
370
                font->setFamily("Times New Roman");
371
                if (font->getWeight() == "Roman")
372
                        font->setWeight("Regular");
373
        }
374
 
375 Franz 375
        QString useFont = font->getName();
376
        if ((useFont == NULL) || (useFont == ""))
377
                useFont = textFrame->IFont;
378
        else if (ScApp->Prefs.AvailFonts[font->getName()] == 0)
364 Franz 379
        {
387 Franz 380
                bool found = false;
411 Franz 381
                useFont == NULL;
387 Franz 382
                QString tmpName = findFontName(font);
383
                if (tmpName != NULL)
375 Franz 384
                {
387 Franz 385
                        useFont = tmpName;
386
                        found = true;
375 Franz 387
                }
387 Franz 388
                if (!found)
389
                {
390
                        if (font->getSlant() == gtFont::fontSlants[ITALIC])
391
                        {
392
                                gtFont* tmp = new gtFont(*font);
393
                                tmp->setSlant(OBLIQUE);
394
                                tmpName = findFontName(tmp);
395
                                if (tmpName != NULL)
396
                                {
397
                                        useFont = tmpName;
398
                                        found = true;
399
                                }
400
                                delete tmp;
401
                        }
402
                        else if (font->getSlant() == gtFont::fontSlants[OBLIQUE])
403
                        {
404
                                gtFont* tmp = new gtFont(*font);
405
                                tmp->setSlant(ITALIC);
406
                                tmpName = findFontName(tmp);
407
                                if (tmpName != NULL)
408
                                {
409
                                        useFont = tmpName;
410
                                        found = true;
411
                                }
412
                                delete tmp;
413
                        }
414
                        if (!found)
415
                        {
416
                                if (!ScApp->Prefs.GFontSub.contains(font->getName()))
417
                                {
418
                                        DmF *dia = new DmF(0, useFont, &ScApp->Prefs);
419
                                        dia->exec();
420
                                        useFont = dia->Ersatz;
421
                                        ScApp->Prefs.GFontSub[font->getName()] = useFont;
422
                                        delete dia;
423
                                }
424
                                else
425
                                        useFont = ScApp->Prefs.GFontSub[font->getName()];
426
                        }
427
                }
364 Franz 428
        }
411 Franz 429
 
375 Franz 430
        if(!ScApp->doc->UsedFonts.contains(useFont))
431
                ScApp->doc->AddFont(useFont, ScApp->Prefs.AvailFonts[useFont]->Font);
432
        return useFont;
364 Franz 433
}
434
 
387 Franz 435
QString gtAction::findFontName(gtFont* font)
436
{
437
        QString ret = NULL;
438
        for (uint i = 0; i < static_cast<uint>(gtFont::NAMECOUNT); ++i)
439
        {
440
                QString nname = font->getName(i);
441
                if (ScApp->Prefs.AvailFonts[nname] != 0)
442
                {
443
                        ret = nname;
444
                        break;
445
                }
446
        }
447
        return ret;
448
}
449
 
411 Franz 450
double gtAction::getLineSpacing(int fontSize)
451
{
452
        return ((fontSize / 10.0) * static_cast<double>(ScApp->doc->AutoLine) / 100) + (fontSize / 10.0);
453
}
454
 
375 Franz 455
double gtAction::getFrameWidth()
456
{
457
        return textFrame->Width;
458
}
459
 
460
QString gtAction::getFrameName()
461
{
462
        return QString(textFrame->AnName);
463
}
464
 
411 Franz 465
bool gtAction::getUpdateParagraphStyles()
466
{
467
        return updateParagraphStyles;
468
}
469
 
470
void gtAction::setUpdateParagraphStyles(bool newUPS)
471
{
472
        updateParagraphStyles = newUPS;
473
}
474
 
418 Franz 475
bool gtAction::getOverridePStyleFont()
476
{
477
        return overridePStyleFont;
478
}
479
void gtAction::setOverridePStyleFont(bool newOPSF)
480
{
481
        overridePStyleFont = newOPSF;
482
}
483
 
828 tsoots 484
QString gtAction::parseColor(const QString &s)
485
{
486
        QString ret = "None";
487
        if (s == "None")
488
                return ret; // don't want None to become Black or any color
489
        bool found = false;
490
        CListe::Iterator it;
491
        for (it = ScApp->doc->PageColors.begin(); it != ScApp->doc->PageColors.end(); ++it)
492
        {
493
                if (it.key() == s)
494
                {
495
                        ret = it.key();
496
                        found = true;
497
                }
498
        }
499
        if (!found)
500
        {
501
                QColor c;
502
                if( s.startsWith( "rgb(" ) )
503
                {
504
                        QString parse = s.stripWhiteSpace();
505
                        QStringList colors = QStringList::split( ',', parse );
506
                        QString r = colors[0].right( ( colors[0].length() - 4 ) );
507
                        QString g = colors[1];
508
                        QString b = colors[2].left( ( colors[2].length() - 1 ) );
509
                        if( r.contains( "%" ) )
510
                        {
511
                                r = r.left( r.length() - 1 );
512
                                r = QString::number( static_cast<int>( ( static_cast<double>( 255 * r.toDouble() ) / 100.0 ) ) );
513
                        }
514
                        if( g.contains( "%" ) )
515
                        {
516
                                g = g.left( g.length() - 1 );
517
                                g = QString::number( static_cast<int>( ( static_cast<double>( 255 * g.toDouble() ) / 100.0 ) ) );
518
                        }
519
                        if( b.contains( "%" ) )
520
                        {
521
                                b = b.left( b.length() - 1 );
522
                                b = QString::number( static_cast<int>( ( static_cast<double>( 255 * b.toDouble() ) / 100.0 ) ) );
523
                        }
524
                        c = QColor(r.toInt(), g.toInt(), b.toInt());
525
                }
526
                else
527
                {
528
                        QString rgbColor = s.stripWhiteSpace();
529
                        if( rgbColor.startsWith( "#" ) )
530
                                c.setNamedColor( rgbColor );
531
                        else
532
                                c = parseColorN( rgbColor );
533
                }
534
                found = false;
535
                for (it = ScApp->doc->PageColors.begin(); it != ScApp->doc->PageColors.end(); ++it)
536
                {
537
                        if (c == ScApp->doc->PageColors[it.key()].getRGBColor())
538
                        {
539
                                ret = it.key();
540
                                found = true;
541
                        }
542
                }
543
                if (!found)
544
                {
545
                        CMYKColor tmp;
546
                        tmp.fromQColor(c);
547
                        ScApp->doc->PageColors.insert("FromGetText"+c.name(), tmp);
548
                        ScApp->Mpal->Cpal->SetColors(ScApp->doc->PageColors);
549
                        ret = "FromGetText"+c.name();
550
                }
551
        }
552
        return ret;
553
}
554
 
555
QColor gtAction::parseColorN(const QString &rgbColor)
556
{
557
        int r, g, b;
558
        keywordToRGB( rgbColor, r, g, b );
559
        return QColor( r, g, b );
560
}
561
 
364 Franz 562
void gtAction::finalize()
563
{
564
        if (ScApp->doc->Trenner->AutoCheck)
565
                ScApp->doc->Trenner->slotHyphenate(textFrame);
566
        ScApp->doc->ActPage->update();
567
        ScApp->slotDocCh();
568
}
569
 
570
gtAction::~gtAction()
571
{
572
        finalize();
573
}