Subversion Repositories Scribus

Rev

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