Subversion Repositories Scribus

Rev

Rev 5093 | Rev 9427 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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