Subversion Repositories Scribus

Rev

Rev 415 | Rev 828 | Go to most recent revision | 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                                      *
3
 *   tsoots@welho.com                                                      *
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>
364 Franz 23
 
24
extern ScribusApp* ScApp;
25
 
26
gtAction::gtAction(bool append)
27
{
28
        textFrame = ScApp->doc->ActPage->SelItem.at(0);
29
        it = textFrame;
30
        lastParagraphStyle = -1;
411 Franz 31
        inPara = false;
418 Franz 32
        isFirstWrite = true;
364 Franz 33
        lastCharWasLineChange = false;
375 Franz 34
        currentFrameStyle = "";
418 Franz 35
        doAppend = append;
411 Franz 36
        updateParagraphStyles = false;
418 Franz 37
        overridePStyleFont = true;
364 Franz 38
}
39
 
40
void gtAction::setProgressInfo()
41
{
42
        ScApp->FMess->setText(QObject::tr("Importing text"));
43
        ScApp->FProg->reset();
44
        ScApp->FProg->setTotalSteps(0);
45
}
46
 
47
void gtAction::setProgressInfoDone()
48
{
49
        ScApp->FMess->setText("");
50
        ScApp->FProg->reset();
51
}
52
 
53
void gtAction::setInfo(QString infoText)
54
{
55
        ScApp->FMess->setText(infoText);
56
}
57
 
58
void gtAction::clearFrame()
59
{
60
        textFrame->Ptext.clear();
61
        textFrame->CPos = 0;
62
}
63
 
411 Franz 64
void gtAction::write(const QString& text, gtStyle *style)
364 Franz 65
{
418 Franz 66
        if (isFirstWrite)
67
        {
68
                if (!doAppend)
69
                {
70
                        if (it->NextBox != 0)
71
                        {
72
                                PageItem *nb = it->NextBox;
73
                                while (nb != 0)
74
                                {
75
                                        nb->Ptext.clear();
76
                                        nb->CPos = 0;
77
                                        nb = nb->NextBox;
78
                                }
79
                        }
80
                        it->Ptext.clear();
81
                        it->CPos = 0;
82
                }
83
        }
411 Franz 84
        int paragraphStyle = -1;
364 Franz 85
        if (style->target() == "paragraph")
86
        {
87
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(style);
88
                paragraphStyle = applyParagraphStyle(pstyle);
418 Franz 89
                if (isFirstWrite)
90
                        inPara = true;
364 Franz 91
        }
92
        else if (style->target() == "frame")
93
        {
94
                gtFrameStyle* fstyle = dynamic_cast<gtFrameStyle*>(style);
95
                applyFrameStyle(fstyle);
96
        }
411 Franz 97
 
98
        if ((inPara) && (!lastCharWasLineChange) && (text.left(1) != "\n") && (lastParagraphStyle != -1))
99
                paragraphStyle = lastParagraphStyle;
100
 
101
 
102
        if (paragraphStyle == -1)
103
                paragraphStyle = ScApp->doc->CurrentABStil;
104
 
364 Franz 105
        gtFont* font = style->getFont();
375 Franz 106
        QString fontName = validateFont(font);
418 Franz 107
        gtFont* font2 = new gtFont(*font);
108
        font2->setName(ScApp->doc->Vorlagen[paragraphStyle].Font);
109
        QString fontName2 = validateFont(font2);
364 Franz 110
        for (uint a = 0; a < text.length(); ++a)
111
        {
112
                if ((text.at(a) == QChar(0)) || (text.at(a) == QChar(13)))
113
                        continue;
114
                struct Pti *hg = new Pti;
115
                hg->ch = text.at(a);
116
                if ((hg->ch == QChar(10)) || (hg->ch == QChar(5)))
117
                        hg->ch = QChar(13);
418 Franz 118
                if ((inPara) && (!overridePStyleFont))
119
                {
120
                        if (ScApp->doc->Vorlagen[paragraphStyle].Font == "")
121
                                hg->cfont = fontName2;
122
                        else
123
                                hg->cfont = ScApp->doc->Vorlagen[paragraphStyle].Font;
124
                        hg->csize = ScApp->doc->Vorlagen[paragraphStyle].FontSize;
125
                        hg->ccolor = ScApp->doc->Vorlagen[paragraphStyle].FColor;
126
                        hg->cshade = ScApp->doc->Vorlagen[paragraphStyle].FShade;
127
                        hg->cstroke = ScApp->doc->Vorlagen[paragraphStyle].SColor;
128
                        hg->cshade2 = ScApp->doc->Vorlagen[paragraphStyle].SShade;
129
                        hg->cstyle = ScApp->doc->Vorlagen[paragraphStyle].FontEffect;
130
                }
131
                else
132
                {
133
                        hg->cfont = fontName;
134
                        hg->csize = font->getSize();
135
                        hg->ccolor = font->getColor();
136
                        hg->cshade = font->getShade();
137
                        hg->cstroke = font->getStrokeColor();
138
                        hg->cshade2 = font->getStrokeShade();
139
                        hg->cstyle = font->getEffectsValue();
140
                }
364 Franz 141
                hg->cscale = font->getHscale();
142
                hg->cextra = font->getKerning();
143
                hg->cselect = false;
411 Franz 144
                hg->cab = paragraphStyle;
364 Franz 145
                hg->xp = 0;
146
                hg->yp = 0;
147
                hg->PtransX = 0;
148
                hg->PtransY = 0;
149
                it->Ptext.append(hg);
150
        }
411 Franz 151
        lastCharWasLineChange = text.right(1) == "\n";
152
        inPara = style->target() == "paragraph";
153
        lastParagraphStyle = paragraphStyle;
418 Franz 154
        if (isFirstWrite)
155
                isFirstWrite = false;
364 Franz 156
}
157
 
158
int gtAction::findParagraphStyle(gtParagraphStyle* pstyle)
159
{
411 Franz 160
        return findParagraphStyle(pstyle->getName());
161
}
162
 
163
int gtAction::findParagraphStyle(const QString& name)
164
{
364 Franz 165
        int pstyleIndex = -1;
166
        for (uint i = 0; i < ScApp->doc->Vorlagen.size(); ++i)
167
        {
411 Franz 168
                if (ScApp->doc->Vorlagen[i].Vname == name)
169
                {
364 Franz 170
                        pstyleIndex = i;
171
                        break;
172
                }
173
        }
174
        return pstyleIndex;
175
}
176
 
177
int gtAction::applyParagraphStyle(gtParagraphStyle* pstyle)
178
{
179
        int pstyleIndex = findParagraphStyle(pstyle);
180
        if (pstyleIndex == -1)
181
        {
182
                createParagraphStyle(pstyle);
183
                pstyleIndex = ScApp->doc->Vorlagen.size() - 1;
184
        }
411 Franz 185
        else if (updateParagraphStyles)
186
        {
187
                updateParagraphStyle(pstyleIndex, pstyle);
188
        }
364 Franz 189
        return pstyleIndex;
190
}
191
 
192
void gtAction::applyFrameStyle(gtFrameStyle* fstyle)
193
{
375 Franz 194
        textFrame->Cols = fstyle->getColumns();
195
        textFrame->ColGap = fstyle->getColumnsGap();
196
        textFrame->Pcolor = fstyle->getBgColor();
197
        textFrame->Shade = fstyle->getBgShade();
387 Franz 198
        textFrame->TabValues = QValueList<double>(*(fstyle->getTabValues()));
375 Franz 199
 
411 Franz 200
//      gtParagraphStyle* pstyle = new gtParagraphStyle(*fstyle);
201
//      int pstyleIndex = findParagraphStyle(pstyle);
202
//      if (pstyleIndex == -1)
203
//              pstyleIndex = 0;
204
//      textFrame->Doc->CurrentABStil = pstyleIndex;
375 Franz 205
 
411 Franz 206
        double linesp;
207
        if (fstyle->getAutoLineSpacing())
208
                linesp = getLineSpacing(fstyle->getFont()->getSize());
209
        else
210
                linesp = fstyle->getLineSpacing();
211
        textFrame->LineSp = linesp;
212
 
375 Franz 213
        gtFont* font = fstyle->getFont();
214
        QString fontName = validateFont(font);
215
        textFrame->IFont = fontName;
216
        textFrame->ISize = font->getSize();
217
        textFrame->TxtFill = font->getColor();
218
        textFrame->ShTxtFill = font->getShade();
219
        textFrame->TxtStroke = font->getStrokeColor();
220
        textFrame->ShTxtStroke = font->getStrokeShade();
221
        textFrame->TxtScale = font->getHscale();
411 Franz 222
        textFrame->ExtraV = font->getKerning();
364 Franz 223
}
224
 
225
void gtAction::getFrameFont(gtFont *font)
226
{
227
        font->setName(textFrame->IFont);
228
        font->setSize(textFrame->ISize);
229
        font->setColor(textFrame->TxtFill);
230
        font->setShade(textFrame->ShTxtFill);
231
        font->setStrokeColor(textFrame->TxtStroke);
232
        font->setStrokeShade(textFrame->ShTxtStroke);
233
        font->setHscale(textFrame->TxtScale);
234
        font->setKerning(0);
235
}
236
 
237
void gtAction::getFrameStyle(gtFrameStyle *fstyle)
238
{
239
        fstyle->setColumns(textFrame->Cols);
240
        fstyle->setColumnsGap(textFrame->ColGap);
241
        fstyle->setBgColor(textFrame->Pcolor);
242
        fstyle->setBgShade(textFrame->Shade);
243
 
244
        struct StVorL vg = textFrame->Doc->Vorlagen[textFrame->Doc->CurrentABStil];
245
        fstyle->setName(vg.Vname);
246
        fstyle->setLineSpacing(vg.LineSpa);
247
        fstyle->setAlignment(vg.Ausri);
248
        fstyle->setIndent(vg.Indent);
249
        fstyle->setFirstLineIndent(vg.First);
250
        fstyle->setSpaceAbove(vg.Avor);
251
        fstyle->setSpaceBelow(vg.Anach);
252
        fstyle->setDropCap(vg.Drop);
253
        fstyle->setDropCapHeight(vg.DropLin);
254
        fstyle->setAdjToBaseline(vg.BaseAdj);
255
 
256
        gtFont font;
257
        getFrameFont(&font);
258
        fstyle->setFont(font);
387 Franz 259
        fstyle->setName("Default frame style");
364 Franz 260
}
261
 
262
void gtAction::createParagraphStyle(gtParagraphStyle* pstyle)
263
{
264
        if (textFrame->Doc->Vorlagen.size() > 5)
265
        {
266
                for (uint i = 5; i < textFrame->Doc->Vorlagen.size(); ++i)
267
                {
268
                        if (textFrame->Doc->Vorlagen[i].Vname == pstyle->getName())
269
                                return;
270
                }
411 Franz 271
        }
364 Franz 272
        gtFont* font = pstyle->getFont();
273
        struct StVorL vg;
274
        vg.Vname = pstyle->getName();
411 Franz 275
        double linesp;
276
        if (pstyle->getAutoLineSpacing())
277
                linesp = getLineSpacing(pstyle->getFont()->getSize());
278
        else
279
                linesp = pstyle->getLineSpacing();
280
        vg.LineSpa = linesp;
364 Franz 281
        vg.Ausri = pstyle->getAlignment();
282
        vg.Indent = pstyle->getIndent();
283
        vg.First = pstyle->getFirstLineIndent();
284
        vg.Avor = pstyle->getSpaceAbove();
285
        vg.Anach = pstyle->getSpaceBelow();
403 Franz 286
        vg.Font = validateFont(font);
364 Franz 287
        vg.FontSize = font->getSize();
288
        vg.TabValues.clear();
375 Franz 289
        QValueList<double> *tabs = pstyle->getTabValues();
290
        for (uint i = 0; i < tabs->size(); ++i)
291
        {
292
                double tmp = (*tabs)[i];
293
                vg.TabValues.append(tmp);
294
        }
364 Franz 295
        vg.Drop = pstyle->hasDropCap();
296
        vg.DropLin = pstyle->getDropCapHeight();
297
        vg.FontEffect = font->getEffectsValue();
298
        vg.FColor = font->getColor();
299
        vg.FShade = font->getShade();
300
        vg.SColor = font->getStrokeColor();
301
        vg.SShade = font->getStrokeShade();
302
        vg.BaseAdj = pstyle->isAdjToBaseline();
303
        textFrame->Doc->Vorlagen.append(vg);
304
        ScApp->Mpal->Spal->updateFList();
305
}
306
 
411 Franz 307
void gtAction::removeParagraphStyle(const QString& name)
308
{
309
        int index = findParagraphStyle(name);
310
        if (index != -1)
311
                removeParagraphStyle(index);
312
}
313
 
314
void gtAction::removeParagraphStyle(int index)
315
{
316
        QValueList<StVorL>::iterator it = ScApp->doc->Vorlagen.at(index);
317
        ScApp->doc->Vorlagen.remove(it);
318
}
319
 
320
void gtAction::updateParagraphStyle(const QString& pstyleName, gtParagraphStyle* pstyle)
321
{
322
        int pstyleIndex = findParagraphStyle(pstyle->getName());
323
        if (pstyleIndex != -1)
324
                updateParagraphStyle(pstyleIndex, pstyle);
325
}
326
 
327
void gtAction::updateParagraphStyle(int pstyleIndex, gtParagraphStyle* pstyle)
328
{
329
        gtFont* font = pstyle->getFont();
330
        struct StVorL vg;
331
        vg.Vname = pstyle->getName();
332
        double linesp;
333
        if (pstyle->getAutoLineSpacing())
334
                linesp = getLineSpacing(pstyle->getFont()->getSize());
335
        else
336
                linesp = pstyle->getLineSpacing();
337
        vg.LineSpa = linesp;
338
        vg.Ausri = pstyle->getAlignment();
339
        vg.Indent = pstyle->getIndent();
340
        vg.First = pstyle->getFirstLineIndent();
341
        vg.Avor = pstyle->getSpaceAbove();
342
        vg.Anach = pstyle->getSpaceBelow();
343
        vg.Font = validateFont(font);
344
        vg.FontSize = font->getSize();
345
        vg.TabValues.clear();
346
        QValueList<double> *tabs = pstyle->getTabValues();
347
        for (uint i = 0; i < tabs->size(); ++i)
348
        {
349
                double tmp = (*tabs)[i];
350
                vg.TabValues.append(tmp);
351
        }
352
        vg.Drop = pstyle->hasDropCap();
353
        vg.DropLin = pstyle->getDropCapHeight();
354
        vg.FontEffect = font->getEffectsValue();
355
        vg.FColor = font->getColor();
356
        vg.FShade = font->getShade();
357
        vg.SColor = font->getStrokeColor();
358
        vg.SShade = font->getStrokeShade();
359
        vg.BaseAdj = pstyle->isAdjToBaseline();
360
        ScApp->doc->Vorlagen[pstyleIndex] = vg;
361
}
362
 
375 Franz 363
QString gtAction::validateFont(gtFont* font)
364 Franz 364
{
411 Franz 365
        // Dirty hack for family Times New Roman
366
        if (font->getFamily() == "Times New")
367
        {
368
                font->setFamily("Times New Roman");
369
                if (font->getWeight() == "Roman")
370
                        font->setWeight("Regular");
371
        }
372
 
375 Franz 373
        QString useFont = font->getName();
374
        if ((useFont == NULL) || (useFont == ""))
375
                useFont = textFrame->IFont;
376
        else if (ScApp->Prefs.AvailFonts[font->getName()] == 0)
364 Franz 377
        {
387 Franz 378
                bool found = false;
411 Franz 379
                useFont == NULL;
387 Franz 380
                QString tmpName = findFontName(font);
381
                if (tmpName != NULL)
375 Franz 382
                {
387 Franz 383
                        useFont = tmpName;
384
                        found = true;
375 Franz 385
                }
387 Franz 386
                if (!found)
387
                {
388
                        if (font->getSlant() == gtFont::fontSlants[ITALIC])
389
                        {
390
                                gtFont* tmp = new gtFont(*font);
391
                                tmp->setSlant(OBLIQUE);
392
                                tmpName = findFontName(tmp);
393
                                if (tmpName != NULL)
394
                                {
395
                                        useFont = tmpName;
396
                                        found = true;
397
                                }
398
                                delete tmp;
399
                        }
400
                        else if (font->getSlant() == gtFont::fontSlants[OBLIQUE])
401
                        {
402
                                gtFont* tmp = new gtFont(*font);
403
                                tmp->setSlant(ITALIC);
404
                                tmpName = findFontName(tmp);
405
                                if (tmpName != NULL)
406
                                {
407
                                        useFont = tmpName;
408
                                        found = true;
409
                                }
410
                                delete tmp;
411
                        }
412
                        if (!found)
413
                        {
414
                                if (!ScApp->Prefs.GFontSub.contains(font->getName()))
415
                                {
416
                                        DmF *dia = new DmF(0, useFont, &ScApp->Prefs);
417
                                        dia->exec();
418
                                        useFont = dia->Ersatz;
419
                                        ScApp->Prefs.GFontSub[font->getName()] = useFont;
420
                                        delete dia;
421
                                }
422
                                else
423
                                        useFont = ScApp->Prefs.GFontSub[font->getName()];
424
                        }
425
                }
364 Franz 426
        }
411 Franz 427
 
375 Franz 428
        if(!ScApp->doc->UsedFonts.contains(useFont))
429
                ScApp->doc->AddFont(useFont, ScApp->Prefs.AvailFonts[useFont]->Font);
430
        return useFont;
364 Franz 431
}
432
 
387 Franz 433
QString gtAction::findFontName(gtFont* font)
434
{
435
        QString ret = NULL;
436
        for (uint i = 0; i < static_cast<uint>(gtFont::NAMECOUNT); ++i)
437
        {
438
                QString nname = font->getName(i);
439
                if (ScApp->Prefs.AvailFonts[nname] != 0)
440
                {
441
                        ret = nname;
442
                        break;
443
                }
444
        }
445
        return ret;
446
}
447
 
411 Franz 448
double gtAction::getLineSpacing(int fontSize)
449
{
450
        return ((fontSize / 10.0) * static_cast<double>(ScApp->doc->AutoLine) / 100) + (fontSize / 10.0);
451
}
452
 
375 Franz 453
double gtAction::getFrameWidth()
454
{
455
        return textFrame->Width;
456
}
457
 
458
QString gtAction::getFrameName()
459
{
460
        return QString(textFrame->AnName);
461
}
462
 
411 Franz 463
bool gtAction::getUpdateParagraphStyles()
464
{
465
        return updateParagraphStyles;
466
}
467
 
468
void gtAction::setUpdateParagraphStyles(bool newUPS)
469
{
470
        updateParagraphStyles = newUPS;
471
}
472
 
418 Franz 473
bool gtAction::getOverridePStyleFont()
474
{
475
        return overridePStyleFont;
476
}
477
void gtAction::setOverridePStyleFont(bool newOPSF)
478
{
479
        overridePStyleFont = newOPSF;
480
}
481
 
364 Franz 482
void gtAction::finalize()
483
{
484
        if (ScApp->doc->Trenner->AutoCheck)
485
                ScApp->doc->Trenner->slotHyphenate(textFrame);
486
        ScApp->doc->ActPage->update();
487
        ScApp->slotDocCh();
488
}
489
 
490
gtAction::~gtAction()
491
{
492
        finalize();
493
}