Subversion Repositories Scribus

Rev

Rev 387 | Rev 411 | 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"
22
 
23
extern ScribusApp* ScApp;
24
 
25
gtAction::gtAction(bool append)
26
{
27
        textFrame = ScApp->doc->ActPage->SelItem.at(0);
28
        it = textFrame;
29
        lastParagraphStyle = -1;
30
        lastCharWasLineChange = false;
375 Franz 31
        currentFrameStyle = "";
32
        if (!append)
364 Franz 33
        {
375 Franz 34
                if (it->NextBox != 0)
364 Franz 35
                {
375 Franz 36
                        PageItem *nb = it->NextBox;
37
                        while (nb != 0)
38
                        {
39
                                nb->Ptext.clear();
40
                                nb->CPos = 0;
41
                                nb = nb->NextBox;
42
                        }
364 Franz 43
                }
375 Franz 44
                it->Ptext.clear();
45
                it->CPos = 0;
364 Franz 46
        }
47
}
48
 
49
void gtAction::setProgressInfo()
50
{
51
        ScApp->FMess->setText(QObject::tr("Importing text"));
52
        ScApp->FProg->reset();
53
        ScApp->FProg->setTotalSteps(0);
54
}
55
 
56
void gtAction::setProgressInfoDone()
57
{
58
        ScApp->FMess->setText("");
59
        ScApp->FProg->reset();
60
}
61
 
62
void gtAction::setInfo(QString infoText)
63
{
64
        ScApp->FMess->setText(infoText);
65
}
66
 
67
void gtAction::clearFrame()
68
{
69
        textFrame->Ptext.clear();
70
        textFrame->CPos = 0;
71
}
72
 
73
void gtAction::write(QString text, gtStyle *style)
74
{
75
        int paragraphStyle = 0;
76
        if (style->target() == "paragraph")
77
        {
78
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(style);
79
                paragraphStyle = applyParagraphStyle(pstyle);
80
        }
81
        else if (style->target() == "frame")
82
        {
83
                gtFrameStyle* fstyle = dynamic_cast<gtFrameStyle*>(style);
84
                applyFrameStyle(fstyle);
85
        }
86
        gtFont* font = style->getFont();
375 Franz 87
        QString fontName = validateFont(font);
364 Franz 88
        for (uint a = 0; a < text.length(); ++a)
89
        {
90
                if ((text.at(a) == QChar(0)) || (text.at(a) == QChar(13)))
91
                        continue;
92
                struct Pti *hg = new Pti;
93
                hg->ch = text.at(a);
94
                if ((hg->ch == QChar(10)) || (hg->ch == QChar(5)))
95
                        hg->ch = QChar(13);
375 Franz 96
                hg->cfont = fontName;
364 Franz 97
                hg->csize = font->getSize();
98
                hg->ccolor = font->getColor();
99
                hg->cshade = font->getShade();
100
                hg->cstroke = font->getStrokeColor();
101
                hg->cshade2 = font->getStrokeShade();
102
                hg->cscale = font->getHscale();
103
                hg->cextra = font->getKerning();
104
                hg->cselect = false;
105
                hg->cstyle = font->getEffectsValue();
106
                if ((paragraphStyle == -1) || ((a == 0) && (text.at(0) == '\n')))
107
                {
108
                        if (lastParagraphStyle == -1)
109
                                hg->cab = ScApp->doc->CurrentABStil;
110
                        else
111
                                hg->cab = lastParagraphStyle;
112
                }
113
                else
114
                        hg->cab = paragraphStyle;
115
                hg->xp = 0;
116
                hg->yp = 0;
117
                hg->PtransX = 0;
118
                hg->PtransY = 0;
119
                it->Ptext.append(hg);
120
                lastParagraphStyle = hg->cab;
121
        }
122
}
123
 
124
int gtAction::findParagraphStyle(gtParagraphStyle* pstyle)
125
{
126
        int pstyleIndex = -1;
127
        for (uint i = 0; i < ScApp->doc->Vorlagen.size(); ++i)
128
        {
129
                if (ScApp->doc->Vorlagen[i].Vname == pstyle->getName())
130
                {      
131
                        pstyleIndex = i;
132
                        break;
133
                }
134
        }
135
        return pstyleIndex;
136
}
137
 
138
int gtAction::applyParagraphStyle(gtParagraphStyle* pstyle)
139
{
140
        int pstyleIndex = findParagraphStyle(pstyle);
141
        if (pstyleIndex == -1)
142
        {
143
                createParagraphStyle(pstyle);
144
                pstyleIndex = ScApp->doc->Vorlagen.size() - 1;
145
        }
146
 
147
        return pstyleIndex;
148
}
149
 
150
void gtAction::applyFrameStyle(gtFrameStyle* fstyle)
151
{
375 Franz 152
        textFrame->Cols = fstyle->getColumns();
153
        textFrame->ColGap = fstyle->getColumnsGap();
154
        textFrame->Pcolor = fstyle->getBgColor();
155
        textFrame->Shade = fstyle->getBgShade();
387 Franz 156
        textFrame->TabValues = QValueList<double>(*(fstyle->getTabValues()));
375 Franz 157
 
158
        gtParagraphStyle* pstyle = new gtParagraphStyle(*fstyle);
159
        int pstyleIndex = findParagraphStyle(pstyle);
160
        if (pstyleIndex == -1)
161
                pstyleIndex = 0;
162
        textFrame->Doc->CurrentABStil = pstyleIndex;
163
 
164
        gtFont* font = fstyle->getFont();
165
        QString fontName = validateFont(font);
166
        textFrame->IFont = fontName;
167
        textFrame->ISize = font->getSize();
168
        textFrame->TxtFill = font->getColor();
169
        textFrame->ShTxtFill = font->getShade();
170
        textFrame->TxtStroke = font->getStrokeColor();
171
        textFrame->ShTxtStroke = font->getStrokeShade();
172
        textFrame->TxtScale = font->getHscale();
364 Franz 173
}
174
 
175
void gtAction::getFrameFont(gtFont *font)
176
{
177
        font->setName(textFrame->IFont);
178
        font->setSize(textFrame->ISize);
179
        font->setColor(textFrame->TxtFill);
180
        font->setShade(textFrame->ShTxtFill);
181
        font->setStrokeColor(textFrame->TxtStroke);
182
        font->setStrokeShade(textFrame->ShTxtStroke);
183
        font->setHscale(textFrame->TxtScale);
184
        font->setKerning(0);
185
}
186
 
187
void gtAction::getFrameStyle(gtFrameStyle *fstyle)
188
{
189
        fstyle->setColumns(textFrame->Cols);
190
        fstyle->setColumnsGap(textFrame->ColGap);
191
        fstyle->setBgColor(textFrame->Pcolor);
192
        fstyle->setBgShade(textFrame->Shade);
193
 
194
        struct StVorL vg = textFrame->Doc->Vorlagen[textFrame->Doc->CurrentABStil];
195
        fstyle->setName(vg.Vname);
196
        fstyle->setLineSpacing(vg.LineSpa);
197
        fstyle->setAlignment(vg.Ausri);
198
        fstyle->setIndent(vg.Indent);
199
        fstyle->setFirstLineIndent(vg.First);
200
        fstyle->setSpaceAbove(vg.Avor);
201
        fstyle->setSpaceBelow(vg.Anach);
202
        fstyle->setDropCap(vg.Drop);
203
        fstyle->setDropCapHeight(vg.DropLin);
204
        fstyle->setAdjToBaseline(vg.BaseAdj);
205
 
206
        gtFont font;
207
        getFrameFont(&font);
208
        fstyle->setFont(font);
387 Franz 209
        fstyle->setName("Default frame style");
364 Franz 210
}
211
 
212
void gtAction::createParagraphStyle(gtParagraphStyle* pstyle)
213
{
214
        if (textFrame->Doc->Vorlagen.size() > 5)
215
        {
216
                for (uint i = 5; i < textFrame->Doc->Vorlagen.size(); ++i)
217
                {
218
                        if (textFrame->Doc->Vorlagen[i].Vname == pstyle->getName())
219
                                return;
220
                }
221
        }
222
        gtFont* font = pstyle->getFont();
223
        struct StVorL vg;
224
        vg.Vname = pstyle->getName();
225
        vg.LineSpa = pstyle->getLineSpacing();
226
        vg.Ausri = pstyle->getAlignment();
227
        vg.Indent = pstyle->getIndent();
228
        vg.First = pstyle->getFirstLineIndent();
229
        vg.Avor = pstyle->getSpaceAbove();
230
        vg.Anach = pstyle->getSpaceBelow();
403 Franz 231
        vg.Font = validateFont(font);
364 Franz 232
        vg.FontSize = font->getSize();
233
        vg.TabValues.clear();
375 Franz 234
        QValueList<double> *tabs = pstyle->getTabValues();
235
        for (uint i = 0; i < tabs->size(); ++i)
236
        {
237
                double tmp = (*tabs)[i];
238
                vg.TabValues.append(tmp);
239
        }
364 Franz 240
        vg.Drop = pstyle->hasDropCap();
241
        vg.DropLin = pstyle->getDropCapHeight();
242
        vg.FontEffect = font->getEffectsValue();
243
        vg.FColor = font->getColor();
244
        vg.FShade = font->getShade();
245
        vg.SColor = font->getStrokeColor();
246
        vg.SShade = font->getStrokeShade();
247
        vg.BaseAdj = pstyle->isAdjToBaseline();
248
        textFrame->Doc->Vorlagen.append(vg);
249
        ScApp->Mpal->Spal->updateFList();
250
}
251
 
375 Franz 252
QString gtAction::validateFont(gtFont* font)
364 Franz 253
{
375 Franz 254
        QString useFont = font->getName();
255
        if ((useFont == NULL) || (useFont == ""))
256
                useFont = textFrame->IFont;
257
        else if (ScApp->Prefs.AvailFonts[font->getName()] == 0)
364 Franz 258
        {
387 Franz 259
                bool found = false;
260
                QString tmpName = findFontName(font);
261
                if (tmpName != NULL)
375 Franz 262
                {
387 Franz 263
                        useFont = tmpName;
264
                        found = true;
375 Franz 265
                }
387 Franz 266
                if (!found)
267
                {
268
                        if (font->getSlant() == gtFont::fontSlants[ITALIC])
269
                        {
270
                                gtFont* tmp = new gtFont(*font);
271
                                tmp->setSlant(OBLIQUE);
272
                                tmpName = findFontName(tmp);
273
                                if (tmpName != NULL)
274
                                {
275
                                        useFont = tmpName;
276
                                        found = true;
277
                                }
278
                                delete tmp;
279
                        }
280
                        else if (font->getSlant() == gtFont::fontSlants[OBLIQUE])
281
                        {
282
                                gtFont* tmp = new gtFont(*font);
283
                                tmp->setSlant(ITALIC);
284
                                tmpName = findFontName(tmp);
285
                                if (tmpName != NULL)
286
                                {
287
                                        useFont = tmpName;
288
                                        found = true;
289
                                }
290
                                delete tmp;
291
                        }
292
                        if (!found)
293
                        {
294
                                if (!ScApp->Prefs.GFontSub.contains(font->getName()))
295
                                {
296
                                        DmF *dia = new DmF(0, useFont, &ScApp->Prefs);
297
                                        dia->exec();
298
                                        useFont = dia->Ersatz;
299
                                        ScApp->Prefs.GFontSub[font->getName()] = useFont;
300
                                        delete dia;
301
                                }
302
                                else
303
                                        useFont = ScApp->Prefs.GFontSub[font->getName()];
304
                        }
305
                }
364 Franz 306
        }
375 Franz 307
        if(!ScApp->doc->UsedFonts.contains(useFont))
308
                ScApp->doc->AddFont(useFont, ScApp->Prefs.AvailFonts[useFont]->Font);
309
        return useFont;
364 Franz 310
}
311
 
387 Franz 312
QString gtAction::findFontName(gtFont* font)
313
{
314
        QString ret = NULL;
315
        for (uint i = 0; i < static_cast<uint>(gtFont::NAMECOUNT); ++i)
316
        {
317
                QString nname = font->getName(i);
318
                if (ScApp->Prefs.AvailFonts[nname] != 0)
319
                {
320
                        ret = nname;
321
                        break;
322
                }
323
        }
324
        return ret;
325
}
326
 
375 Franz 327
double gtAction::getFrameWidth()
328
{
329
        return textFrame->Width;
330
}
331
 
332
QString gtAction::getFrameName()
333
{
334
        return QString(textFrame->AnName);
335
}
336
 
364 Franz 337
void gtAction::finalize()
338
{
339
        if (ScApp->doc->Trenner->AutoCheck)
340
                ScApp->doc->Trenner->slotHyphenate(textFrame);
341
        ScApp->doc->ActPage->update();
342
        ScApp->slotDocCh();
343
}
344
 
345
gtAction::~gtAction()
346
{
347
        finalize();
348
}