Subversion Repositories Scribus

Rev

Rev 3544 | Rev 3934 | 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                                      *
1184 tsoots 3
 *   tsoots@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
 
713 cbradney 21
#include "missing.h"
364 Franz 22
#include "gtaction.h"
759 cbradney 23
#include "mpalette.h"
766 cbradney 24
#include "scribus.h"
415 Franz 25
#include <qcursor.h>
833 tsoots 26
#include <qstringlist.h>
27
#include "color.h"
2834 cbradney 28
#include "prefsmanager.h"
3252 craig 29
#include "hyphenator.h"
364 Franz 30
 
31
 
3205 craig 32
 
364 Franz 33
gtAction::gtAction(bool append)
34
{
2834 cbradney 35
        prefsManager=PrefsManager::instance();
456 fschmid 36
        textFrame = ScApp->view->SelItem.at(0);
364 Franz 37
        it = textFrame;
38
        lastParagraphStyle = -1;
411 Franz 39
        inPara = false;
418 Franz 40
        isFirstWrite = true;
364 Franz 41
        lastCharWasLineChange = false;
375 Franz 42
        currentFrameStyle = "";
418 Franz 43
        doAppend = append;
411 Franz 44
        updateParagraphStyles = false;
418 Franz 45
        overridePStyleFont = true;
364 Franz 46
}
47
 
1702 cbradney 48
gtAction::gtAction(bool append, PageItem* pageitem)
49
{
2950 cbradney 50
        prefsManager=PrefsManager::instance();
1702 cbradney 51
        textFrame = pageitem;
52
        it = textFrame;
53
        lastParagraphStyle = -1;
54
        inPara = false;
55
        isFirstWrite = true;
56
        lastCharWasLineChange = false;
57
        currentFrameStyle = "";
58
        doAppend = append;
59
        updateParagraphStyles = false;
60
        overridePStyleFont = true;
61
}
62
 
364 Franz 63
void gtAction::setProgressInfo()
64
{
2433 cbradney 65
        ScApp->mainWindowStatusLabel->setText(QObject::tr("Importing text"));
66
        ScApp->mainWindowProgressBar->reset();
67
        ScApp->mainWindowProgressBar->setTotalSteps(0);
364 Franz 68
}
69
 
70
void gtAction::setProgressInfoDone()
71
{
2433 cbradney 72
        ScApp->mainWindowStatusLabel->setText("");
73
        ScApp->mainWindowProgressBar->reset();
364 Franz 74
}
75
 
76
void gtAction::setInfo(QString infoText)
77
{
2433 cbradney 78
        ScApp->mainWindowStatusLabel->setText(infoText);
364 Franz 79
}
80
 
81
void gtAction::clearFrame()
82
{
2443 fschmid 83
        for (ScText *it = textFrame->itemText.first(); it != 0; it = textFrame->itemText.next())
84
        {
85
                if ((it->ch == QChar(25)) && (it->cembedded != 0))
2499 fschmid 86
                {
2447 fschmid 87
                        ScApp->doc->FrameItems.remove(it->cembedded);
2499 fschmid 88
                        delete it->cembedded;
89
                }
2443 fschmid 90
        }
1065 cbradney 91
        textFrame->itemText.clear();
364 Franz 92
        textFrame->CPos = 0;
3628 cbradney 93
        ScApp->doc->updateFrameItems();
364 Franz 94
}
95
 
411 Franz 96
void gtAction::write(const QString& text, gtStyle *style)
364 Franz 97
{
418 Franz 98
        if (isFirstWrite)
99
        {
100
                if (!doAppend)
101
                {
102
                        if (it->NextBox != 0)
103
                        {
1957 cbradney 104
                                PageItem *nextItem = it->NextBox;
105
                                while (nextItem != 0)
418 Franz 106
                                {
2443 fschmid 107
                                        for (ScText *itx = nextItem->itemText.first(); itx != 0; itx = nextItem->itemText.next())
108
                                        {
109
                                                if ((itx->ch == QChar(25)) && (itx->cembedded != 0))
2499 fschmid 110
                                                {
2447 fschmid 111
                                                        ScApp->doc->FrameItems.remove(itx->cembedded);
2499 fschmid 112
                                                        delete itx->cembedded;
113
                                                }
2443 fschmid 114
                                        }
1957 cbradney 115
                                        nextItem->itemText.clear();
116
                                        nextItem->CPos = 0;
117
                                        nextItem = nextItem->NextBox;
418 Franz 118
                                }
119
                        }
2443 fschmid 120
                        for (ScText *itx = it->itemText.first(); itx != 0; itx = it->itemText.next())
121
                        {
122
                                if ((itx->ch == QChar(25)) && (itx->cembedded != 0))
2499 fschmid 123
                                {
2447 fschmid 124
                                        ScApp->doc->FrameItems.remove(itx->cembedded);
2499 fschmid 125
                                        delete itx->cembedded;
126
                                }
2443 fschmid 127
                        }
1065 cbradney 128
                        it->itemText.clear();
418 Franz 129
                        it->CPos = 0;
3628 cbradney 130
                        ScApp->doc->updateFrameItems();
418 Franz 131
                }
132
        }
411 Franz 133
        int paragraphStyle = -1;
364 Franz 134
        if (style->target() == "paragraph")
135
        {
136
                gtParagraphStyle* pstyle = dynamic_cast<gtParagraphStyle*>(style);
137
                paragraphStyle = applyParagraphStyle(pstyle);
418 Franz 138
                if (isFirstWrite)
139
                        inPara = true;
364 Franz 140
        }
141
        else if (style->target() == "frame")
142
        {
143
                gtFrameStyle* fstyle = dynamic_cast<gtFrameStyle*>(style);
144
                applyFrameStyle(fstyle);
145
        }
411 Franz 146
 
147
        if ((inPara) && (!lastCharWasLineChange) && (text.left(1) != "\n") && (lastParagraphStyle != -1))
148
                paragraphStyle = lastParagraphStyle;
149
 
150
 
151
        if (paragraphStyle == -1)
1065 cbradney 152
                paragraphStyle = ScApp->doc->currentParaStyle;
411 Franz 153
 
364 Franz 154
        gtFont* font = style->getFont();
375 Franz 155
        QString fontName = validateFont(font);
418 Franz 156
        gtFont* font2 = new gtFont(*font);
1065 cbradney 157
        font2->setName(ScApp->doc->docParagraphStyles[paragraphStyle].Font);
418 Franz 158
        QString fontName2 = validateFont(font2);
364 Franz 159
        for (uint a = 0; a < text.length(); ++a)
160
        {
161
                if ((text.at(a) == QChar(0)) || (text.at(a) == QChar(13)))
162
                        continue;
1065 cbradney 163
                struct ScText *hg = new ScText;
364 Franz 164
                hg->ch = text.at(a);
165
                if ((hg->ch == QChar(10)) || (hg->ch == QChar(5)))
166
                        hg->ch = QChar(13);
418 Franz 167
                if ((inPara) && (!overridePStyleFont))
168
                {
2877 cbradney 169
                        if (ScApp->doc->docParagraphStyles[paragraphStyle].Font.isEmpty())
1789 fschmid 170
                                hg->cfont = (*ScApp->doc->AllFonts)[fontName2];
418 Franz 171
                        else
1789 fschmid 172
                                hg->cfont = (*ScApp->doc->AllFonts)[ScApp->doc->docParagraphStyles[paragraphStyle].Font];
1065 cbradney 173
                        hg->csize = ScApp->doc->docParagraphStyles[paragraphStyle].FontSize;
174
                        hg->ccolor = ScApp->doc->docParagraphStyles[paragraphStyle].FColor;
175
                        hg->cshade = ScApp->doc->docParagraphStyles[paragraphStyle].FShade;
176
                        hg->cstroke = ScApp->doc->docParagraphStyles[paragraphStyle].SColor;
177
                        hg->cshade2 = ScApp->doc->docParagraphStyles[paragraphStyle].SShade;
178
                        hg->cstyle = ScApp->doc->docParagraphStyles[paragraphStyle].FontEffect;
418 Franz 179
                }
180
                else
181
                {
1789 fschmid 182
                        hg->cfont = (*ScApp->doc->AllFonts)[fontName];
418 Franz 183
                        hg->csize = font->getSize();
833 tsoots 184
                        hg->ccolor = parseColor(font->getColor());
418 Franz 185
                        hg->cshade = font->getShade();
833 tsoots 186
                        hg->cstroke = parseColor(font->getStrokeColor());
418 Franz 187
                        hg->cshade2 = font->getStrokeShade();
188
                        hg->cstyle = font->getEffectsValue();
189
                }
2254 fschmid 190
                hg->cscale = font->getHscale();
2242 fschmid 191
                hg->cscalev = 1000;
2234 fschmid 192
                hg->cbase = 0;
2247 fschmid 193
                hg->cshadowx = 50;
194
                hg->cshadowy = -50;
2257 fschmid 195
                hg->coutline = 10;
2262 fschmid 196
                hg->cunderpos = -1;
197
                hg->cunderwidth = -1;
2272 fschmid 198
                hg->cstrikepos = -1;
199
                hg->cstrikewidth = -1;
364 Franz 200
                hg->cextra = font->getKerning();
201
                hg->cselect = false;
411 Franz 202
                hg->cab = paragraphStyle;
364 Franz 203
                hg->xp = 0;
204
                hg->yp = 0;
205
                hg->PtransX = 0;
206
                hg->PtransY = 0;
2434 fschmid 207
                hg->cembedded = 0;
1065 cbradney 208
                it->itemText.append(hg);
364 Franz 209
        }
411 Franz 210
        lastCharWasLineChange = text.right(1) == "\n";
211
        inPara = style->target() == "paragraph";
212
        lastParagraphStyle = paragraphStyle;
418 Franz 213
        if (isFirstWrite)
214
                isFirstWrite = false;
364 Franz 215
}
216
 
217
int gtAction::findParagraphStyle(gtParagraphStyle* pstyle)
218
{
411 Franz 219
        return findParagraphStyle(pstyle->getName());
220
}
221
 
222
int gtAction::findParagraphStyle(const QString& name)
223
{
364 Franz 224
        int pstyleIndex = -1;
1065 cbradney 225
        for (uint i = 0; i < ScApp->doc->docParagraphStyles.size(); ++i)
364 Franz 226
        {
1065 cbradney 227
                if (ScApp->doc->docParagraphStyles[i].Vname == name)
411 Franz 228
                {
364 Franz 229
                        pstyleIndex = i;
230
                        break;
231
                }
232
        }
233
        return pstyleIndex;
234
}
235
 
236
int gtAction::applyParagraphStyle(gtParagraphStyle* pstyle)
237
{
238
        int pstyleIndex = findParagraphStyle(pstyle);
239
        if (pstyleIndex == -1)
240
        {
241
                createParagraphStyle(pstyle);
1065 cbradney 242
                pstyleIndex = ScApp->doc->docParagraphStyles.size() - 1;
364 Franz 243
        }
411 Franz 244
        else if (updateParagraphStyles)
245
        {
246
                updateParagraphStyle(pstyleIndex, pstyle);
247
        }
364 Franz 248
        return pstyleIndex;
249
}
250
 
251
void gtAction::applyFrameStyle(gtFrameStyle* fstyle)
252
{
375 Franz 253
        textFrame->Cols = fstyle->getColumns();
254
        textFrame->ColGap = fstyle->getColumnsGap();
1394 cbradney 255
        textFrame->setFillColor(parseColor(fstyle->getBgColor()));
256
        textFrame->setFillShade(fstyle->getBgShade());
2282 fschmid 257
        textFrame->TabValues = QValueList<PageItem::TabRecord>(*(fstyle->getTabValues()));
375 Franz 258
 
411 Franz 259
//      gtParagraphStyle* pstyle = new gtParagraphStyle(*fstyle);
260
//      int pstyleIndex = findParagraphStyle(pstyle);
261
//      if (pstyleIndex == -1)
262
//              pstyleIndex = 0;
1065 cbradney 263
//      textFrame->Doc->currentParaStyle = pstyleIndex;
375 Franz 264
 
411 Franz 265
        double linesp;
266
        if (fstyle->getAutoLineSpacing())
267
                linesp = getLineSpacing(fstyle->getFont()->getSize());
268
        else
269
                linesp = fstyle->getLineSpacing();
270
        textFrame->LineSp = linesp;
2309 fschmid 271
        textFrame->LineSpMode = 0;
375 Franz 272
        gtFont* font = fstyle->getFont();
273
        QString fontName = validateFont(font);
274
        textFrame->IFont = fontName;
275
        textFrame->ISize = font->getSize();
833 tsoots 276
        textFrame->TxtFill = parseColor(font->getColor());
375 Franz 277
        textFrame->ShTxtFill = font->getShade();
833 tsoots 278
        textFrame->TxtStroke = parseColor(font->getStrokeColor());
375 Franz 279
        textFrame->ShTxtStroke = font->getStrokeShade();
2254 fschmid 280
        textFrame->TxtScale = font->getHscale();
281
        textFrame->TxtScaleV = 1000;
2234 fschmid 282
        textFrame->TxtBase = 0;
2247 fschmid 283
        textFrame->TxtShadowX = 50;
284
        textFrame->TxtShadowY = -50;
2257 fschmid 285
        textFrame->TxtOutline = 10;
2262 fschmid 286
        textFrame->TxtUnderPos = -1;
287
        textFrame->TxtUnderWidth = -1;
2272 fschmid 288
        textFrame->TxtStrikePos = -1;
289
        textFrame->TxtStrikeWidth = -1;
411 Franz 290
        textFrame->ExtraV = font->getKerning();
364 Franz 291
}
292
 
293
void gtAction::getFrameFont(gtFont *font)
294
{
295
        font->setName(textFrame->IFont);
296
        font->setSize(textFrame->ISize);
297
        font->setColor(textFrame->TxtFill);
298
        font->setShade(textFrame->ShTxtFill);
299
        font->setStrokeColor(textFrame->TxtStroke);
300
        font->setStrokeShade(textFrame->ShTxtStroke);
301
        font->setHscale(textFrame->TxtScale);
302
        font->setKerning(0);
303
}
304
 
305
void gtAction::getFrameStyle(gtFrameStyle *fstyle)
306
{
307
        fstyle->setColumns(textFrame->Cols);
308
        fstyle->setColumnsGap(textFrame->ColGap);
1394 cbradney 309
        fstyle->setBgColor(textFrame->fillColor());
310
        fstyle->setBgShade(textFrame->fillShade());
364 Franz 311
 
1065 cbradney 312
        struct ParagraphStyle vg = textFrame->Doc->docParagraphStyles[textFrame->Doc->currentParaStyle];
364 Franz 313
        fstyle->setName(vg.Vname);
314
        fstyle->setLineSpacing(vg.LineSpa);
1065 cbradney 315
        fstyle->setAlignment(vg.textAlignment);
364 Franz 316
        fstyle->setIndent(vg.Indent);
317
        fstyle->setFirstLineIndent(vg.First);
1065 cbradney 318
        fstyle->setSpaceAbove(vg.gapBefore);
319
        fstyle->setSpaceBelow(vg.gapAfter);
364 Franz 320
        fstyle->setDropCap(vg.Drop);
321
        fstyle->setDropCapHeight(vg.DropLin);
322
        fstyle->setAdjToBaseline(vg.BaseAdj);
323
 
324
        gtFont font;
325
        getFrameFont(&font);
326
        fstyle->setFont(font);
387 Franz 327
        fstyle->setName("Default frame style");
364 Franz 328
}
329
 
330
void gtAction::createParagraphStyle(gtParagraphStyle* pstyle)
331
{
1065 cbradney 332
        if (textFrame->Doc->docParagraphStyles.size() > 5)
364 Franz 333
        {
1065 cbradney 334
                for (uint i = 5; i < textFrame->Doc->docParagraphStyles.size(); ++i)
364 Franz 335
                {
1065 cbradney 336
                        if (textFrame->Doc->docParagraphStyles[i].Vname == pstyle->getName())
364 Franz 337
                                return;
338
                }
411 Franz 339
        }
364 Franz 340
        gtFont* font = pstyle->getFont();
1065 cbradney 341
        struct ParagraphStyle vg;
364 Franz 342
        vg.Vname = pstyle->getName();
411 Franz 343
        double linesp;
344
        if (pstyle->getAutoLineSpacing())
345
                linesp = getLineSpacing(pstyle->getFont()->getSize());
346
        else
347
                linesp = pstyle->getLineSpacing();
2309 fschmid 348
        vg.LineSpaMode = 0;
411 Franz 349
        vg.LineSpa = linesp;
1065 cbradney 350
        vg.textAlignment = pstyle->getAlignment();
364 Franz 351
        vg.Indent = pstyle->getIndent();
352
        vg.First = pstyle->getFirstLineIndent();
1065 cbradney 353
        vg.gapBefore = pstyle->getSpaceAbove();
354
        vg.gapAfter = pstyle->getSpaceBelow();
403 Franz 355
        vg.Font = validateFont(font);
364 Franz 356
        vg.FontSize = font->getSize();
357
        vg.TabValues.clear();
2282 fschmid 358
        QValueList<PageItem::TabRecord> *tabs = pstyle->getTabValues();
375 Franz 359
        for (uint i = 0; i < tabs->size(); ++i)
360
        {
2282 fschmid 361
                struct PageItem::TabRecord tmp = (*tabs)[i];
375 Franz 362
                vg.TabValues.append(tmp);
363
        }
364 Franz 364
        vg.Drop = pstyle->hasDropCap();
365
        vg.DropLin = pstyle->getDropCapHeight();
2362 fschmid 366
        vg.DropDist = 0;
364 Franz 367
        vg.FontEffect = font->getEffectsValue();
833 tsoots 368
        vg.FColor = parseColor(font->getColor());
364 Franz 369
        vg.FShade = font->getShade();
833 tsoots 370
        vg.SColor = parseColor(font->getStrokeColor());
364 Franz 371
        vg.SShade = font->getStrokeShade();
372
        vg.BaseAdj = pstyle->isAdjToBaseline();
2273 fschmid 373
        vg.txtShadowX = 50;
374
        vg.txtShadowY = -50;
375
        vg.txtOutline = 10;
2379 fschmid 376
        vg.scaleH = 1000;
377
        vg.scaleV = 1000;
378
        vg.baseOff = 0;
379
        vg.kernVal = 0;
2889 cbradney 380
        vg.txtUnderPos = ScApp->doc->typographicSettings.valueUnderlinePos;
381
        vg.txtUnderWidth = ScApp->doc->typographicSettings.valueUnderlineWidth;
382
        vg.txtStrikePos = ScApp->doc->typographicSettings.valueStrikeThruPos;
383
        vg.txtStrikeWidth = ScApp->doc->typographicSettings.valueStrikeThruPos;
1065 cbradney 384
        textFrame->Doc->docParagraphStyles.append(vg);
1545 cbradney 385
        ScApp->propertiesPalette->Spal->updateFormatList();
364 Franz 386
}
387
 
411 Franz 388
void gtAction::removeParagraphStyle(const QString& name)
389
{
390
        int index = findParagraphStyle(name);
391
        if (index != -1)
392
                removeParagraphStyle(index);
393
}
394
 
395
void gtAction::removeParagraphStyle(int index)
396
{
1065 cbradney 397
        QValueList<ParagraphStyle>::iterator it = ScApp->doc->docParagraphStyles.at(index);
398
        ScApp->doc->docParagraphStyles.remove(it);
411 Franz 399
}
400
 
1185 tsoots 401
void gtAction::updateParagraphStyle(const QString&, gtParagraphStyle* pstyle)
411 Franz 402
{
403
        int pstyleIndex = findParagraphStyle(pstyle->getName());
404
        if (pstyleIndex != -1)
405
                updateParagraphStyle(pstyleIndex, pstyle);
406
}
407
 
408
void gtAction::updateParagraphStyle(int pstyleIndex, gtParagraphStyle* pstyle)
409
{
410
        gtFont* font = pstyle->getFont();
1065 cbradney 411
        struct ParagraphStyle vg;
411 Franz 412
        vg.Vname = pstyle->getName();
413
        double linesp;
414
        if (pstyle->getAutoLineSpacing())
415
                linesp = getLineSpacing(pstyle->getFont()->getSize());
416
        else
417
                linesp = pstyle->getLineSpacing();
2309 fschmid 418
        vg.LineSpaMode = 0;
411 Franz 419
        vg.LineSpa = linesp;
1065 cbradney 420
        vg.textAlignment = pstyle->getAlignment();
411 Franz 421
        vg.Indent = pstyle->getIndent();
422
        vg.First = pstyle->getFirstLineIndent();
1065 cbradney 423
        vg.gapBefore = pstyle->getSpaceAbove();
424
        vg.gapAfter = pstyle->getSpaceBelow();
411 Franz 425
        vg.Font = validateFont(font);
426
        vg.FontSize = font->getSize();
427
        vg.TabValues.clear();
2282 fschmid 428
        QValueList<PageItem::TabRecord> *tabs = pstyle->getTabValues();
411 Franz 429
        for (uint i = 0; i < tabs->size(); ++i)
430
        {
2282 fschmid 431
                struct PageItem::TabRecord tmp = (*tabs)[i];
411 Franz 432
                vg.TabValues.append(tmp);
433
        }
434
        vg.Drop = pstyle->hasDropCap();
435
        vg.DropLin = pstyle->getDropCapHeight();
2362 fschmid 436
        vg.DropDist = 0;
411 Franz 437
        vg.FontEffect = font->getEffectsValue();
833 tsoots 438
        vg.FColor = parseColor(font->getColor());
411 Franz 439
        vg.FShade = font->getShade();
833 tsoots 440
        vg.SColor = parseColor(font->getStrokeColor());
411 Franz 441
        vg.SShade = font->getStrokeShade();
442
        vg.BaseAdj = pstyle->isAdjToBaseline();
2273 fschmid 443
        vg.txtShadowX = 50;
444
        vg.txtShadowY = -50;
445
        vg.txtOutline = 10;
2379 fschmid 446
        vg.scaleH = 1000;
447
        vg.scaleV = 1000;
448
        vg.baseOff = 0;
449
        vg.kernVal = 0;
2889 cbradney 450
        vg.txtUnderPos = ScApp->doc->typographicSettings.valueUnderlinePos;
451
        vg.txtUnderWidth = ScApp->doc->typographicSettings.valueUnderlineWidth;
452
        vg.txtStrikePos = ScApp->doc->typographicSettings.valueStrikeThruPos;
453
        vg.txtStrikeWidth = ScApp->doc->typographicSettings.valueStrikeThruPos;
1065 cbradney 454
        ScApp->doc->docParagraphStyles[pstyleIndex] = vg;
411 Franz 455
}
456
 
375 Franz 457
QString gtAction::validateFont(gtFont* font)
364 Franz 458
{
411 Franz 459
        // Dirty hack for family Times New Roman
460
        if (font->getFamily() == "Times New")
461
        {
462
                font->setFamily("Times New Roman");
463
                if (font->getWeight() == "Roman")
464
                        font->setWeight("Regular");
465
        }
466
 
375 Franz 467
        QString useFont = font->getName();
2877 cbradney 468
        if ((useFont.isNull()) || (useFont.isEmpty()))
375 Franz 469
                useFont = textFrame->IFont;
2834 cbradney 470
        else if (prefsManager->appPrefs.AvailFonts[font->getName()] == 0)
364 Franz 471
        {
387 Franz 472
                bool found = false;
411 Franz 473
                useFont == NULL;
387 Franz 474
                QString tmpName = findFontName(font);
475
                if (tmpName != NULL)
375 Franz 476
                {
387 Franz 477
                        useFont = tmpName;
478
                        found = true;
375 Franz 479
                }
387 Franz 480
                if (!found)
481
                {
482
                        if (font->getSlant() == gtFont::fontSlants[ITALIC])
483
                        {
484
                                gtFont* tmp = new gtFont(*font);
485
                                tmp->setSlant(OBLIQUE);
486
                                tmpName = findFontName(tmp);
487
                                if (tmpName != NULL)
488
                                {
489
                                        useFont = tmpName;
490
                                        found = true;
491
                                }
492
                                delete tmp;
493
                        }
494
                        else if (font->getSlant() == gtFont::fontSlants[OBLIQUE])
495
                        {
496
                                gtFont* tmp = new gtFont(*font);
497
                                tmp->setSlant(ITALIC);
498
                                tmpName = findFontName(tmp);
499
                                if (tmpName != NULL)
500
                                {
501
                                        useFont = tmpName;
502
                                        found = true;
503
                                }
504
                                delete tmp;
505
                        }
506
                        if (!found)
507
                        {
2834 cbradney 508
                                if (!prefsManager->appPrefs.GFontSub.contains(font->getName()))
387 Franz 509
                                {
2834 cbradney 510
                                        MissingFont *dia = new MissingFont(0, useFont, ScApp->doc);
387 Franz 511
                                        dia->exec();
713 cbradney 512
                                        useFont = dia->getReplacementFont();
2834 cbradney 513
                                        prefsManager->appPrefs.GFontSub[font->getName()] = useFont;
387 Franz 514
                                        delete dia;
515
                                }
516
                                else
2834 cbradney 517
                                        useFont = prefsManager->appPrefs.GFontSub[font->getName()];
387 Franz 518
                        }
519
                }
364 Franz 520
        }
411 Franz 521
 
375 Franz 522
        if(!ScApp->doc->UsedFonts.contains(useFont))
3544 avox 523
                ScApp->doc->AddFont(useFont);
375 Franz 524
        return useFont;
364 Franz 525
}
526
 
387 Franz 527
QString gtAction::findFontName(gtFont* font)
528
{
529
        QString ret = NULL;
530
        for (uint i = 0; i < static_cast<uint>(gtFont::NAMECOUNT); ++i)
531
        {
532
                QString nname = font->getName(i);
2834 cbradney 533
                if (prefsManager->appPrefs.AvailFonts[nname] != 0)
387 Franz 534
                {
535
                        ret = nname;
536
                        break;
537
                }
538
        }
539
        return ret;
540
}
541
 
411 Franz 542
double gtAction::getLineSpacing(int fontSize)
543
{
2889 cbradney 544
        return ((fontSize / 10.0) * static_cast<double>(ScApp->doc->typographicSettings.autoLineSpacing) / 100) + (fontSize / 10.0);
411 Franz 545
}
546
 
375 Franz 547
double gtAction::getFrameWidth()
548
{
549
        return textFrame->Width;
550
}
551
 
552
QString gtAction::getFrameName()
553
{
1361 tsoots 554
        return QString(textFrame->itemName());
375 Franz 555
}
556
 
411 Franz 557
bool gtAction::getUpdateParagraphStyles()
558
{
559
        return updateParagraphStyles;
560
}
561
 
562
void gtAction::setUpdateParagraphStyles(bool newUPS)
563
{
564
        updateParagraphStyles = newUPS;
565
}
566
 
418 Franz 567
bool gtAction::getOverridePStyleFont()
568
{
569
        return overridePStyleFont;
570
}
571
void gtAction::setOverridePStyleFont(bool newOPSF)
572
{
573
        overridePStyleFont = newOPSF;
574
}
575
 
833 tsoots 576
QString gtAction::parseColor(const QString &s)
577
{
578
        QString ret = "None";
579
        if (s == "None")
580
                return ret; // don't want None to become Black or any color
581
        bool found = false;
1065 cbradney 582
        ColorList::Iterator it;
833 tsoots 583
        for (it = ScApp->doc->PageColors.begin(); it != ScApp->doc->PageColors.end(); ++it)
584
        {
585
                if (it.key() == s)
586
                {
587
                        ret = it.key();
588
                        found = true;
589
                }
590
        }
591
        if (!found)
592
        {
593
                QColor c;
594
                if( s.startsWith( "rgb(" ) )
595
                {
596
                        QString parse = s.stripWhiteSpace();
597
                        QStringList colors = QStringList::split( ',', parse );
598
                        QString r = colors[0].right( ( colors[0].length() - 4 ) );
599
                        QString g = colors[1];
600
                        QString b = colors[2].left( ( colors[2].length() - 1 ) );
601
                        if( r.contains( "%" ) )
602
                        {
603
                                r = r.left( r.length() - 1 );
604
                                r = QString::number( static_cast<int>( ( static_cast<double>( 255 * r.toDouble() ) / 100.0 ) ) );
605
                        }
606
                        if( g.contains( "%" ) )
607
                        {
608
                                g = g.left( g.length() - 1 );
609
                                g = QString::number( static_cast<int>( ( static_cast<double>( 255 * g.toDouble() ) / 100.0 ) ) );
610
                        }
611
                        if( b.contains( "%" ) )
612
                        {
613
                                b = b.left( b.length() - 1 );
614
                                b = QString::number( static_cast<int>( ( static_cast<double>( 255 * b.toDouble() ) / 100.0 ) ) );
615
                        }
616
                        c = QColor(r.toInt(), g.toInt(), b.toInt());
617
                }
618
                else
619
                {
620
                        QString rgbColor = s.stripWhiteSpace();
621
                        if( rgbColor.startsWith( "#" ) )
622
                                c.setNamedColor( rgbColor );
623
                        else
624
                                c = parseColorN( rgbColor );
625
                }
626
                found = false;
627
                for (it = ScApp->doc->PageColors.begin(); it != ScApp->doc->PageColors.end(); ++it)
628
                {
629
                        if (c == ScApp->doc->PageColors[it.key()].getRGBColor())
630
                        {
631
                                ret = it.key();
632
                                found = true;
633
                        }
634
                }
635
                if (!found)
636
                {
2886 fschmid 637
                        ScColor tmp;
833 tsoots 638
                        tmp.fromQColor(c);
639
                        ScApp->doc->PageColors.insert("FromGetText"+c.name(), tmp);
3540 cbradney 640
                        ScApp->propertiesPalette->updateColorList();
833 tsoots 641
                        ret = "FromGetText"+c.name();
642
                }
643
        }
644
        return ret;
645
}
646
 
647
QColor gtAction::parseColorN(const QString &rgbColor)
648
{
649
        int r, g, b;
650
        keywordToRGB( rgbColor, r, g, b );
651
        return QColor( r, g, b );
652
}
653
 
364 Franz 654
void gtAction::finalize()
655
{
1065 cbradney 656
        if (ScApp->doc->docHyphenator->AutoCheck)
657
                ScApp->doc->docHyphenator->slotHyphenate(textFrame);
456 fschmid 658
        ScApp->view->DrawNew();
364 Franz 659
        ScApp->slotDocCh();
660
}
661
 
662
gtAction::~gtAction()
663
{
664
        finalize();
665
}