Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
102 Franz 1
/***************************************************************************
2
                          story.cpp  -  description
3
                             -------------------
4
    begin                : Tue Nov 11 2003
5
    copyright            : (C) 2003 by Franz Schmid
6
    email                : Franz.Schmid@altmuehlnet.de
7
 ***************************************************************************/
8
 
9
/***************************************************************************
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
 ***************************************************************************/
3457 avox 17
#include "sccombobox.h"
1789 fschmid 18
#include "scfonts.h"
102 Franz 19
#include "story.h"
20
#include "story.moc"
21
#include <qtooltip.h>
22
#include <qpixmap.h>
23
#include <qcombobox.h>
124 Franz 24
#include <qregexp.h>
351 Franz 25
#include <qhbox.h>
357 Franz 26
#include <qcolordialog.h>
27
#include <qfontdialog.h>
374 Franz 28
#include <qcursor.h>
2233 fschmid 29
#include <qtextcodec.h>
3732 cbradney 30
 
31
#include "alignselect.h"
32
#include "charselect.h"
33
#include "commonstrings.h"
162 Franz 34
#include "customfdialog.h"
3135 cbradney 35
#include "editformats.h"
3732 cbradney 36
#include "fontcombo.h"
37
#include "mspinbox.h"
38
#include "pageitem.h"
39
#include "pluginmanager.h"
415 Franz 40
#include "prefscontext.h"
3252 craig 41
#include "prefsmanager.h"
415 Franz 42
#include "prefsfile.h"
3732 cbradney 43
#include "scmessagebox.h"
44
#include "scraction.h"
45
#include "scribus.h"
46
#include "search.h"
3135 cbradney 47
#include "serializer.h"
3732 cbradney 48
#include "shadebutton.h"
3252 craig 49
#include "spalette.h"
50
#include "styleselect.h"
189 Franz 51
 
102 Franz 52
extern QPixmap loadIcon(QString nam);
53
 
3205 craig 54
 
371 Franz 55
SideBar::SideBar(QWidget *pa) : QLabel(pa)
56
{
57
        setEraseColor(QColor(255,255,255));
58
        offs = 0;
59
        editor = 0;
372 Franz 60
        noUpdt = true;
373 Franz 61
        inRep = false;
62
        setMinimumWidth(fontMetrics().width( tr("No Style") )+30);
371 Franz 63
}
64
 
374 Franz 65
void SideBar::mouseReleaseEvent(QMouseEvent *m)
66
{
67
        CurrentPar = editor->paragraphAt(QPoint(2, m->y()+offs));
68
        pmen = new QPopupMenu();
69
        Spalette* Spal = new Spalette(this);
716 cbradney 70
        Spal->setFormats(editor->doc);
374 Franz 71
        if ((CurrentPar < static_cast<int>(editor->StyledText.count())) && (editor->StyledText.count() != 0))
72
        {
73
                if (editor->StyledText.at(CurrentPar)->count() > 0)
74
                        Spal->setFormat(editor->StyledText.at(CurrentPar)->at(0)->cab);
75
                else
76
                        Spal->setFormat(0);
77
        }
78
        else
79
                Spal->setFormat(0);
716 cbradney 80
        connect(Spal, SIGNAL(newStyle(int)), this, SLOT(setPStyle(int)));
374 Franz 81
        pmen->insertItem(Spal);
2397 cbradney 82
        pmen->insertItem( tr("Edit Styles..."), this, SLOT(editStyles()));
374 Franz 83
        pmen->exec(QCursor::pos());
84
        delete pmen;
85
}
86
 
1893 subik 87
void SideBar::editStyles()
88
{
89
        emit sigEditStyles();
90
}
91
 
374 Franz 92
void SideBar::setPStyle(int s)
93
{
94
        emit ChangeStyle(CurrentPar, s);
95
        pmen->activateItemAt(0);
96
}
97
 
371 Franz 98
void SideBar::paintEvent(QPaintEvent *e)
99
{
373 Franz 100
        inRep = true;
371 Franz 101
        QLabel::paintEvent(e);
102
        QPainter p;
103
        p.begin(this);
372 Franz 104
        if ((editor != 0) && (noUpdt))
371 Franz 105
        {
1065 cbradney 106
                int st = editor->currentParaStyle;
371 Franz 107
                for (int pa = 0; pa < editor->paragraphs(); ++pa)
108
                {
109
                        QRect re = editor->paragraphRect(pa);
373 Franz 110
                        if (!re.isValid())
111
                                break;
371 Franz 112
                        re.setWidth(width()-5);
113
                        re.moveBy(5, 0);
373 Franz 114
                        if (((re.y()+re.height())-offs < height()) && ((re.y()+re.height())-offs > 0))
371 Franz 115
                                p.drawLine(0, (re.y()+re.height())-offs, width()-1, (re.y()+re.height())-offs);
373 Franz 116
                        if ((re.y()-offs < height()) && (re.y()-offs > 0))
371 Franz 117
                        {
372 Franz 118
                                re.setY(re.y()-offs);
371 Franz 119
                                if ((pa < static_cast<int>(editor->StyledText.count())) && (editor->StyledText.count() != 0))
120
                                {
121
                                        if (editor->StyledText.at(pa)->count() > 0)
122
                                                st = editor->StyledText.at(pa)->at(0)->cab;
123
                                        else
373 Franz 124
                                                st = editor->ParagStyles[pa];
3135 cbradney 125
                                        if (st < 5)
126
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, tr("No Style"));
127
                                        else
128
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, editor->doc->docParagraphStyles[st].Vname);
371 Franz 129
                                }
130
                                else
131
                                {
1065 cbradney 132
                                        st = editor->currentParaStyle;
371 Franz 133
                                        if (st < 5)
373 Franz 134
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, tr("No Style"));
371 Franz 135
                                        else
1065 cbradney 136
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, editor->doc->docParagraphStyles[st].Vname);
371 Franz 137
                                }
138
                        }
139
                }
140
        }
141
        p.end();
373 Franz 142
        inRep = false;
371 Franz 143
}
144
 
795 fschmid 145
void SideBar::doMove(int, int y)
371 Franz 146
{
147
        offs = y;
373 Franz 148
        if (!inRep)
149
                update();
371 Franz 150
}
151
 
152
void SideBar::doRepaint()
153
{
373 Franz 154
        if (!inRep)
155
                update();
371 Franz 156
}
157
 
372 Franz 158
void SideBar::setRepaint(bool r)
159
{
160
        noUpdt = r;
161
}
162
 
351 Franz 163
SEditor::SEditor(QWidget* parent, ScribusDoc *docc) : QTextEdit(parent)
102 Franz 164
{
2494 cbradney 165
        setCurrentDocument(docc);
353 Franz 166
        wasMod = false;
385 Franz 167
        StoredSel = false;
351 Franz 168
        StyledText.clear();
169
        StyledText.setAutoDelete(true);
373 Franz 170
        ParagStyles.clear();
362 Franz 171
        cBuffer.setAutoDelete(true);
172
        cBuffer.clear();
113 Franz 173
        setUndoRedoEnabled(true);
351 Franz 174
        setUndoDepth(0);
175
        setTextFormat(Qt::PlainText);
355 Franz 176
        viewport()->setAcceptDrops(false);
376 Franz 177
        ClipData = 0;
3034 cbradney 178
        unicodeTextEditMode = false;
376 Franz 179
        connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
399 Franz 180
        connect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(SelClipChange()));
102 Franz 181
}
182
 
2494 cbradney 183
void SEditor::setCurrentDocument(ScribusDoc *docc)
184
{
185
        doc = docc;
186
}
187
 
2233 fschmid 188
void SEditor::imEndEvent(QIMEvent *e)
189
{
190
        QString uc = e->text();
2877 cbradney 191
        if ((!uc.isEmpty()) && ((*doc->AllFonts)[CurrFont]->CharWidth.contains(uc[0].unicode())))
2233 fschmid 192
        {
193
                insChars(e->text());
194
                QTextEdit::imEndEvent(e);
195
                emit SideBarUp(true);
196
                emit SideBarUpdate();
197
        }
198
}
199
 
351 Franz 200
void SEditor::keyPressEvent(QKeyEvent *k)
113 Franz 201
{
372 Franz 202
        emit SideBarUp(false);
351 Franz 203
        int p, i;
204
        getCursorPosition(&p, &i);
2369 cbradney 205
        int keyMod=0;
206
        if (k->state() & ShiftButton)
207
                keyMod |= SHIFT;
208
        if (k->state() & ControlButton)
209
                keyMod |= CTRL;
210
        if (k->state() & AltButton)
211
                keyMod |= ALT;
212
 
926 fschmid 213
        QString uc = k->text();
2369 cbradney 214
        QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
215
        if (currKeySeq == ScApp->scrActions["specialPageNumber"]->accel())
351 Franz 216
        {
2319 cbradney 217
                insChars(QString(QChar(ScApp->scrActions["specialPageNumber"]->actionInt())));
2407 fschmid 218
                setFarbe(true);
351 Franz 219
                insert("#");
2407 fschmid 220
                setFarbe(false);
372 Franz 221
                emit SideBarUp(true);
2677 fschmid 222
                emit SideBarUpdate();
351 Franz 223
                return;
224
        }
2369 cbradney 225
        if (currKeySeq == ScApp->scrActions["specialNonBreakingSpace"]->accel())
2318 fschmid 226
        {
2319 cbradney 227
                insChars(QString(QChar(ScApp->scrActions["specialNonBreakingSpace"]->actionInt())));
2407 fschmid 228
                setFarbe(true);
2318 fschmid 229
                insert("_");
2407 fschmid 230
                setFarbe(false);
2318 fschmid 231
                emit SideBarUp(true);
2677 fschmid 232
                emit SideBarUpdate();
2318 fschmid 233
                return;
234
        }
2369 cbradney 235
        if (currKeySeq == ScApp->scrActions["specialFrameBreak"]->accel())
2352 fschmid 236
        {
237
                insChars(QString(QChar(ScApp->scrActions["specialFrameBreak"]->actionInt())));
2407 fschmid 238
                setFarbe(true);
2352 fschmid 239
                insert("|");
2407 fschmid 240
                setFarbe(false);
2352 fschmid 241
                emit SideBarUp(true);
2677 fschmid 242
                emit SideBarUpdate();
2352 fschmid 243
                return;
244
        }
2369 cbradney 245
        if (currKeySeq == ScApp->scrActions["specialNewLine"]->accel())
2352 fschmid 246
        {
247
                insChars(QString(QChar(ScApp->scrActions["specialNewLine"]->actionInt())));
2407 fschmid 248
                setFarbe(true);
2352 fschmid 249
                insert("*");
2407 fschmid 250
                setFarbe(false);
2352 fschmid 251
                emit SideBarUp(true);
2677 fschmid 252
                emit SideBarUpdate();
2352 fschmid 253
                return;
254
        }
2384 fschmid 255
        if (currKeySeq == ScApp->scrActions["specialColumnBreak"]->accel())
256
        {
257
                insChars(QString(QChar(ScApp->scrActions["specialColumnBreak"]->actionInt())));
2407 fschmid 258
                setFarbe(true);
2389 fschmid 259
                insert("^");
2407 fschmid 260
                setFarbe(false);
2384 fschmid 261
                emit SideBarUp(true);
2677 fschmid 262
                emit SideBarUpdate();
2384 fschmid 263
                return;
264
        }
2407 fschmid 265
        if (currKeySeq == ScApp->scrActions["specialNonBreakingHyphen"]->accel())
266
        {
267
                insChars(QString(QChar(ScApp->scrActions["specialNonBreakingHyphen"]->actionInt())));
268
                setFarbe(true);
269
                insert("=");
270
                setFarbe(false);
271
                emit SideBarUp(true);
2677 fschmid 272
                emit SideBarUpdate();
2407 fschmid 273
                return;
274
        }
2319 cbradney 275
 
351 Franz 276
        switch (k->state())
277
        {
278
                case ControlButton:
279
                case ControlButton|ShiftButton:
280
                case ControlButton|Keypad:
281
                case ControlButton|ShiftButton|Keypad:
1866 fschmid 282
                        switch (k->key())
283
                        {
284
                                case Key_Delete:
285
                                        moveCursor(QTextEdit::MoveWordForward, true);
286
                                        deleteSel();
287
                                        break;
288
                                case Key_Backspace:
289
                                        moveCursor(QTextEdit::MoveWordBackward, true);
290
                                        deleteSel();
291
                                        break;
292
                                case Key_K:
293
                                        moveCursor(QTextEdit::MoveLineEnd, true);
294
                                        deleteSel();
295
                                        break;
296
                                case Key_D:
297
                                        moveCursor(QTextEdit::MoveForward, true);
298
                                        deleteSel();
299
                                        break;
300
                                case Key_H:
301
                                        moveCursor(QTextEdit::MoveBackward, true);
302
                                        deleteSel();
303
                                        break;
304
                                case Key_X:
2404 cbradney 305
                                        cut();
306
                                        return;
307
                                        break;
308
                                case Key_V:
309
                                        paste();
310
                                        return;
311
                                        break;
1866 fschmid 312
                                case Key_Y:
313
                                case Key_Z:
314
                                        emit SideBarUp(true);
315
                                        return;
316
                                        break;
317
                                case Key_C:
318
                                        copyStyledText();
319
                                        break;
320
                        }
351 Franz 321
                        break;
322
                case NoButton:
323
                case Keypad:
324
                case ShiftButton:
3034 cbradney 325
                        if (unicodeTextEditMode)
351 Franz 326
                        {
327
                                int conv = 0;
328
                                bool ok = false;
3034 cbradney 329
                                unicodeInputString += k->text();
330
                                conv = unicodeInputString.toInt(&ok, 16);
351 Franz 331
                                if (!ok)
332
                                {
3034 cbradney 333
                                        unicodeTextEditMode = false;
334
                                        unicodeInputCount = 0;
335
                                        unicodeInputString = "";
351 Franz 336
                                        return;
337
                                }
3034 cbradney 338
                                unicodeInputCount++;
339
                                if (unicodeInputCount == 4)
351 Franz 340
                                {
3034 cbradney 341
                                        unicodeTextEditMode = false;
342
                                        unicodeInputCount = 0;
343
                                        unicodeInputString = "";
351 Franz 344
                                        if (ok)
345
                                        {
346
                                                if (conv < 31)
347
                                                        conv = 32;
348
                                                insChars(QString(QChar(conv)));
349
                                                insert(QString(QChar(conv)));
372 Franz 350
                                                emit SideBarUp(true);
2677 fschmid 351
                                                emit SideBarUpdate();
351 Franz 352
                                                return;
353
                                        }
354
                                }
355
                                else
372 Franz 356
                                {
357
                                        emit SideBarUp(true);
2677 fschmid 358
                                        emit SideBarUpdate();
351 Franz 359
                                        return;
372 Franz 360
                                }
351 Franz 361
                        }
353 Franz 362
                        wasMod = false;
351 Franz 363
                        switch (k->key())
364
                        {
1945 craig 365
                                case Key_Escape:
366
                                        k->ignore();
367
                                        break;
353 Franz 368
                                case Key_Shift:
369
                                case Key_Control:
370
                                case Key_Alt:
371
                                        wasMod = true;
372
                                        break;
351 Franz 373
                                case Key_F12:
3034 cbradney 374
                                        unicodeTextEditMode = true;
375
                                        unicodeInputCount = 0;
376
                                        unicodeInputString = "";
351 Franz 377
                                        return;
378
                                        break;
379
                                case Key_Delete:
380
                                        if (!hasSelectedText())
381
                                        {
382
                                                ChList *chars = StyledText.at(p);
383
                                                if (i < static_cast<int>(chars->count()))
384
                                                        chars->remove(i);
385
                                                else
386
                                                {
387
                                                        if (p < static_cast<int>(StyledText.count()-1))
388
                                                        {
389
                                                                struct PtiSmall *hg;
390
                                                                ChList *chars2 = StyledText.at(p+1);
391
                                                                int a = static_cast<int>(chars2->count());
392
                                                                if (a > 0)
393
                                                                {
394
                                                                        int ca;
395
                                                                        if (chars->count() > 0)
396
                                                                                ca = chars->at(0)->cab;
397
                                                                        else
1065 cbradney 398
                                                                                ca = currentParaStyle;
351 Franz 399
                                                                        for (int s = 0; s < a; ++s)
400
                                                                        {
401
                                                                                hg = chars2->take(0);
402
                                                                                hg->cab = ca;
403
                                                                                chars->append(hg);
404
                                                                        }
405
                                                                }
406
                                                                StyledText.remove(p+1);
373 Franz 407
                                                                ParagStyles.remove(ParagStyles.at(p+1));
351 Franz 408
                                                        }
409
                                                }
410
                                        }
411
                                        else
412
                                                deleteSel();
413
                                        break;
414
                                case Key_Backspace:
415
                                        if (!hasSelectedText())
416
                                        {
353 Franz 417
                                                if (p >= static_cast<int>(StyledText.count()))
418
                                                        break;
351 Franz 419
                                                ChList *chars = StyledText.at(p);
420
                                                if (i > 0)
421
                                                        chars->remove(i-1);
422
                                                else
423
                                                {
424
                                                        if (p > 0)
425
                                                        {
426
                                                                struct PtiSmall *hg;
427
                                                                ChList *chars2 = StyledText.at(p-1);
428
                                                                int a = static_cast<int>(chars->count());
429
                                                                if (a > 0)
430
                                                                {
431
                                                                        int ca;
432
                                                                        if (chars2->count() > 0)
433
                                                                                ca = chars2->at(0)->cab;
434
                                                                        else
435
                                                                                ca = chars->at(0)->cab;
436
                                                                        for (int s = 0; s < a; ++s)
437
                                                                        {
438
                                                                                hg = chars->take(0);
439
                                                                                hg->cab = ca;
440
                                                                                chars2->append(hg);
441
                                                                        }
442
                                                                }
443
                                                                StyledText.remove(p);
373 Franz 444
                                                                ParagStyles.remove(ParagStyles.at(p));
351 Franz 445
                                                        }
446
                                                }
447
                                        }
448
                                        else
449
                                                deleteSel();
450
                                        break;
451
                                case Key_Return:
452
                                case Key_Enter:
453
                                        {
454
                                                if (hasSelectedText())
455
                                                        deleteSel();
456
                                                ChList *chars;
457
                                                chars = new ChList;
458
                                                chars->setAutoDelete(true);
459
                                                chars->clear();
460
                                                if (StyledText.count() != 0)
461
                                                {
353 Franz 462
                                                        if (p >= static_cast<int>(StyledText.count()))
373 Franz 463
                                                        {
353 Franz 464
                                                                StyledText.append(chars);
1065 cbradney 465
                                                                ParagStyles.append(currentParaStyle);
373 Franz 466
                                                        }
353 Franz 467
                                                        else
468
                                                        {
351 Franz 469
                                                        ChList *chars2 = StyledText.at(p);
470
                                                        int a = static_cast<int>(chars2->count());
471
                                                        for (int s = i; s < a; ++s)
472
                                                        {
473
                                                                chars->append(chars2->take(i));
474
                                                        }
475
                                                        StyledText.insert(p+1, chars);
1065 cbradney 476
                                                        ParagStyles.insert(ParagStyles.at(p+1), currentParaStyle);
353 Franz 477
                                                        }
351 Franz 478
                                                }
479
                                                else
373 Franz 480
                                                {
351 Franz 481
                                                        StyledText.append(chars);
1065 cbradney 482
                                                        ParagStyles.append(currentParaStyle);
373 Franz 483
                                                }
351 Franz 484
                                        }
485
                                        break;
486
                                case Key_Left:
487
                                case Key_Right:
488
                                case Key_Prior:
489
                                case Key_Next:
490
                                case Key_Up:
491
                                case Key_Down:
492
                                case Key_Home:
493
                                case Key_End:
494
                                        break;
495
                                default:
2877 cbradney 496
                                        if ((!k->text().isEmpty()) && ((*doc->AllFonts)[CurrFont]->CharWidth.contains(uc[0].unicode())))
926 fschmid 497
                                        {
351 Franz 498
                                                insChars(k->text());
926 fschmid 499
                                                QTextEdit::keyPressEvent(k);
500
                                                emit SideBarUp(true);
501
                                                emit SideBarUpdate();
502
                                        }
972 fschmid 503
                                        return;
351 Franz 504
                                        break;
505
                        }
506
                        break;
507
                default:
508
                        break;
509
        }
510
        QTextEdit::keyPressEvent(k);
372 Franz 511
        emit SideBarUp(true);
512
        emit SideBarUpdate();
113 Franz 513
}
514
 
385 Franz 515
void SEditor::focusOutEvent(QFocusEvent *e)
516
{
517
        if (hasSelectedText())
518
        {
519
                getSelection(&SelParaStart, &SelCharStart, &SelParaEnd, &SelCharEnd);
520
                StoredSel = true;
521
        }
522
        else
523
                StoredSel = false;
524
        QTextEdit::focusOutEvent(e);
525
}
526
 
351 Franz 527
void SEditor::insChars(QString t)
102 Franz 528
{
376 Franz 529
        int p, i, p2, ccab;
351 Franz 530
        if (hasSelectedText())
531
                deleteSel();
357 Franz 532
        getCursorPosition(&p, &i);
351 Franz 533
        ChList *chars;
376 Franz 534
        p2 = p;
351 Franz 535
        if ((p >= static_cast<int>(StyledText.count())) || (StyledText.count() == 0))
253 Franz 536
        {
351 Franz 537
                chars = new ChList;
538
                chars->setAutoDelete(true);
539
                chars->clear();
376 Franz 540
                p2 = static_cast<int>(StyledText.count());
382 Franz 541
                StyledText.append(chars);
1065 cbradney 542
                ParagStyles.append(currentParaStyle);
351 Franz 543
        }
544
        else
545
                chars = StyledText.at(p);
376 Franz 546
        if (chars->count() != 0)
547
                ccab = chars->at(0)->cab;
548
        else
1065 cbradney 549
                ccab = currentParaStyle;
351 Franz 550
        for (uint a = 0; a < t.length(); ++a)
551
        {
376 Franz 552
                if (t[a] == QChar(13))
553
                {
554
                        ChList *chars2;
555
                        chars2 = new ChList;
556
                        chars2->setAutoDelete(true);
557
                        chars2->clear();
558
                        if (p2 >= static_cast<int>(StyledText.count()))
559
                        {
560
                                StyledText.append(chars2);
561
                                ParagStyles.append(ccab);
562
                        }
563
                        else
564
                        {
565
                                int a = static_cast<int>(chars->count());
566
                                for (int s = i; s < a; ++s)
567
                                {
568
                                        chars2->append(chars->take(i));
569
                                }
570
                                StyledText.insert(p2+1, chars2);
571
                                ParagStyles.insert(ParagStyles.at(p2+1), ccab);
572
                        }
573
                        p2++;
574
                        chars = StyledText.at(p2);
575
                        i = 0;
576
                }
577
                else
578
                {
579
                        struct PtiSmall *hg;
580
                        hg = new PtiSmall;
581
                        hg->ch = t[a];
582
                        hg->ccolor = CurrTextFill;
583
                        hg->cshade = CurrTextFillSh;
584
                        hg->cstroke = CurrTextStroke;
585
                        hg->cshade2 = CurrTextStrokeSh;
586
                        hg->cfont = CurrFont;
587
                        hg->csize = CurrFontSize;
588
                        hg->cstyle = CurrentStyle;
589
                        hg->cab = ccab;
590
                        hg->cextra = CurrTextKern;
591
                        hg->cscale = CurrTextScale;
2230 fschmid 592
                        hg->cscalev = CurrTextScaleV;
2234 fschmid 593
                        hg->cbase = CurrTextBase;
2247 fschmid 594
                        hg->cshadowx = CurrTextShadowX;
595
                        hg->cshadowy = CurrTextShadowY;
2257 fschmid 596
                        hg->coutline = CurrTextOutline;
2262 fschmid 597
                        hg->cunderpos = CurrTextUnderPos;
598
                        hg->cunderwidth =CurrTextUnderWidth;
2272 fschmid 599
                        hg->cstrikepos = CurrTextStrikePos;
600
                        hg->cstrikewidth =CurrTextStrikeWidth;
2499 fschmid 601
                        hg->cembedded = 0;
376 Franz 602
                        chars->insert(i, hg);
603
                        i++;
604
                }
351 Franz 605
        }
606
}
607
 
362 Franz 608
void SEditor::insStyledText()
609
{
610
        if (cBuffer.count() == 0)
611
                return;
612
        int p, i, p2, ccab;
613
        if (hasSelectedText())
614
                deleteSel();
615
        getCursorPosition(&p, &i);
616
        ChList *chars;
617
        p2 = p;
618
        if ((p >= static_cast<int>(StyledText.count())) || (StyledText.count() == 0))
619
        {
620
                chars = new ChList;
621
                chars->setAutoDelete(true);
622
                chars->clear();
623
                p2 = static_cast<int>(StyledText.count());
382 Franz 624
                StyledText.append(chars);
1065 cbradney 625
                ParagStyles.append(currentParaStyle);
362 Franz 626
        }
627
        else
628
                chars = StyledText.at(p);
629
        if (chars->count() != 0)
630
                ccab = chars->at(0)->cab;
631
        else
1065 cbradney 632
                ccab = currentParaStyle;
362 Franz 633
        for (uint a = 0; a < cBuffer.count()-1; ++a)
634
        {
635
                struct PtiSmall *hg;
2499 fschmid 636
                if (cBuffer.at(a)->ch == QChar(25))
637
                        continue;
362 Franz 638
                if (cBuffer.at(a)->ch == QChar(13))
639
                {
640
                        ChList *chars2;
641
                        chars2 = new ChList;
642
                        chars2->setAutoDelete(true);
643
                        chars2->clear();
644
                        if (p2 >= static_cast<int>(StyledText.count()))
373 Franz 645
                        {
362 Franz 646
                                StyledText.append(chars2);
373 Franz 647
                                ParagStyles.append(ccab);
648
                        }
362 Franz 649
                        else
650
                        {
651
                                int a = static_cast<int>(chars->count());
652
                                for (int s = i; s < a; ++s)
653
                                {
654
                                        chars2->append(chars->take(i));
655
                                }
656
                                StyledText.insert(p2+1, chars2);
373 Franz 657
                                ParagStyles.insert(ParagStyles.at(p2+1), ccab);
362 Franz 658
                        }
659
                        p2++;
660
                        chars = StyledText.at(p2);
661
                        i = 0;
662
                }
663
                else
664
                {
665
                        hg = new PtiSmall;
666
                        hg->ch = cBuffer.at(a)->ch;
667
                        hg->ccolor = cBuffer.at(a)->ccolor;
668
                        hg->cshade = cBuffer.at(a)->cshade;
669
                        hg->cstroke = cBuffer.at(a)->cstroke;
670
                        hg->cshade2 = cBuffer.at(a)->cshade2;
671
                        hg->cfont = cBuffer.at(a)->cfont;
672
                        hg->csize = cBuffer.at(a)->csize;
673
                        hg->cstyle = cBuffer.at(a)->cstyle;
674
                        hg->cab = ccab;
675
                        hg->cextra = cBuffer.at(a)->cextra;
676
                        hg->cscale = cBuffer.at(a)->cscale;
2230 fschmid 677
                        hg->cscalev = cBuffer.at(a)->cscalev;
2234 fschmid 678
                        hg->cbase = cBuffer.at(a)->cbase;
2247 fschmid 679
                        hg->cshadowx = cBuffer.at(a)->cshadowx;
680
                        hg->cshadowy = cBuffer.at(a)->cshadowy;
2257 fschmid 681
                        hg->coutline = cBuffer.at(a)->coutline;
2262 fschmid 682
                        hg->cunderpos = cBuffer.at(a)->cunderpos;
683
                        hg->cunderwidth = cBuffer.at(a)->cunderwidth;
2272 fschmid 684
                        hg->cstrikepos = cBuffer.at(a)->cstrikepos;
685
                        hg->cstrikewidth = cBuffer.at(a)->cstrikewidth;
2499 fschmid 686
                        hg->cembedded = 0;
362 Franz 687
                        chars->insert(i, hg);
688
                        i++;
689
                }
690
        }
691
}
692
 
693
void SEditor::copyStyledText()
694
{
695
        int PStart, PEnd, SelStart, SelEnd, start, end;
696
        ChList *chars;
697
        struct PtiSmall *hg;
698
        cBuffer.clear();
3382 fschmid 699
        tBuffer = "";
362 Franz 700
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
701
        for (int pa = PStart; pa < PEnd+1; ++pa)
702
        {
703
                chars = StyledText.at(pa);
704
                if (pa == PStart)
705
                        start = SelStart;
706
                else
707
                        start = 0;
708
                if (pa == PEnd)
709
                        end = SelEnd;
710
                else
711
                        end = chars->count();
712
                for (int ca = start; ca < end; ++ca)
713
                {
714
                        hg = new PtiSmall;
715
                        hg->ch = chars->at(ca)->ch;
3382 fschmid 716
                        tBuffer += chars->at(ca)->ch;
362 Franz 717
                        hg->cfont = chars->at(ca)->cfont;
718
                        hg->csize = chars->at(ca)->csize;
719
                        hg->ccolor = chars->at(ca)->ccolor;
720
                        hg->cshade = chars->at(ca)->cshade;
721
                        hg->cstroke = chars->at(ca)->cstroke;
722
                        hg->cshade2 = chars->at(ca)->cshade2;
723
                        hg->cscale = chars->at(ca)->cscale;
2230 fschmid 724
                        hg->cscalev = chars->at(ca)->cscalev;
362 Franz 725
                        hg->cstyle = chars->at(ca)->cstyle;
726
                        hg->cab = chars->at(ca)->cab;
727
                        hg->cextra = chars->at(ca)->cextra;
2234 fschmid 728
                        hg->cbase = chars->at(ca)->cbase;
2247 fschmid 729
                        hg->cshadowx = chars->at(ca)->cshadowx;
730
                        hg->cshadowy = chars->at(ca)->cshadowy;
2257 fschmid 731
                        hg->coutline = chars->at(ca)->coutline;
2262 fschmid 732
                        hg->cunderpos = chars->at(ca)->cunderpos;
733
                        hg->cunderwidth = chars->at(ca)->cunderwidth;
2272 fschmid 734
                        hg->cstrikepos = chars->at(ca)->cstrikepos;
735
                        hg->cstrikewidth = chars->at(ca)->cstrikewidth;
2499 fschmid 736
                        hg->cembedded = 0;
362 Franz 737
                        cBuffer.append(hg);
738
                }
739
                hg = new PtiSmall;
740
                hg->ch = QChar(13);
3393 fschmid 741
                tBuffer += QChar(13);
362 Franz 742
                hg->cfont = "";
743
                hg->csize = 1;
744
                hg->ccolor = "";
745
                hg->cshade = 1;
746
                hg->cstroke = "";
747
                hg->cshade2 = 1;
2242 fschmid 748
                hg->cscale = 10;
749
                hg->cscalev = 10;
362 Franz 750
                hg->cstyle = 0;
751
                hg->cab = 0;
752
                hg->cextra = 0;
2234 fschmid 753
                hg->cbase = 0;
2247 fschmid 754
                hg->cshadowx = 50;
755
                hg->cshadowy = -50;
2257 fschmid 756
                hg->coutline = 10;
2262 fschmid 757
                hg->cunderpos = -1;
758
                hg->cunderwidth = -1;
2272 fschmid 759
                hg->cstrikepos = -1;
760
                hg->cstrikewidth = -1;
2499 fschmid 761
                hg->cembedded = 0;
362 Franz 762
                cBuffer.append(hg);
763
        }
764
}
765
 
1957 cbradney 766
void SEditor::saveItemText(PageItem *currItem)
351 Franz 767
{
768
        ChList *chars;
1957 cbradney 769
        currItem->CPos = 0;
770
        currItem->itemText.clear();
351 Franz 771
        uint c = 0;
772
        for (uint p = 0; p < StyledText.count(); ++p)
773
        {
774
                if (p != 0)
253 Franz 775
                {
351 Franz 776
                        c = StyledText.at(p-1)->count()-1;
1065 cbradney 777
                        struct ScText *hg;
778
                        hg = new ScText;
351 Franz 779
                        hg->ch = QChar(13);
392 Franz 780
                        chars = StyledText.at(p-1);
351 Franz 781
                        if (chars->count() != 0)
253 Franz 782
                        {
1789 fschmid 783
                                hg->cfont = (*doc->AllFonts)[chars->at(c)->cfont];
351 Franz 784
                                hg->csize = chars->at(c)->csize;
785
                                hg->ccolor = chars->at(c)->ccolor;
786
                                hg->cshade = chars->at(c)->cshade;
787
                                hg->cstroke = chars->at(c)->cstroke;
788
                                hg->cshade2 = chars->at(c)->cshade2;
789
                                hg->cscale = chars->at(c)->cscale;
2230 fschmid 790
                                hg->cscalev = chars->at(c)->cscalev;
351 Franz 791
                                hg->cstyle = chars->at(c)->cstyle;
792
                                hg->cextra = chars->at(c)->cextra;
2234 fschmid 793
                                hg->cbase = chars->at(c)->cbase;
2247 fschmid 794
                                hg->cshadowx = chars->at(c)->cshadowx;
795
                                hg->cshadowy = chars->at(c)->cshadowy;
2257 fschmid 796
                                hg->coutline = chars->at(c)->coutline;
2262 fschmid 797
                                hg->cunderpos = chars->at(c)->cunderpos;
798
                                hg->cunderwidth = chars->at(c)->cunderwidth;
2272 fschmid 799
                                hg->cstrikepos = chars->at(c)->cstrikepos;
800
                                hg->cstrikewidth = chars->at(c)->cstrikewidth;
253 Franz 801
                        }
351 Franz 802
                        else
803
                        {
804
                                hg->ccolor = CurrTextFill;
805
                                hg->cshade = CurrTextFillSh;
806
                                hg->cstroke = CurrTextStroke;
807
                                hg->cshade2 = CurrTextStrokeSh;
1789 fschmid 808
                                hg->cfont = (*doc->AllFonts)[CurrFont];
351 Franz 809
                                hg->csize = CurrFontSize;
810
                                hg->cstyle = CurrentStyle;
811
                                hg->cextra = CurrTextKern;
812
                                hg->cscale = CurrTextScale;
2230 fschmid 813
                                hg->cscalev = CurrTextScaleV;
2234 fschmid 814
                                hg->cbase = CurrTextBase;
2247 fschmid 815
                                hg->cshadowx = CurrTextShadowX;
816
                                hg->cshadowy = CurrTextShadowY;
2257 fschmid 817
                                hg->coutline = CurrTextOutline;
2262 fschmid 818
                                hg->cunderpos = CurrTextUnderPos;
819
                                hg->cunderwidth = CurrTextUnderWidth;
2272 fschmid 820
                                hg->cstrikepos = CurrTextStrikePos;
821
                                hg->cstrikewidth = CurrTextStrikeWidth;
2877 cbradney 822
                                if (!doc->docParagraphStyles[ParagStyles[p-1]].Font.isEmpty())
351 Franz 823
                                {
1789 fschmid 824
                                        hg->cfont = (*doc->AllFonts)[doc->docParagraphStyles[ParagStyles[p-1]].Font];
1065 cbradney 825
                                        hg->csize = doc->docParagraphStyles[ParagStyles[p-1]].FontSize;
351 Franz 826
                                }
827
                        }
392 Franz 828
                        hg->cab = ParagStyles[p-1];
351 Franz 829
                        hg->cselect = false;
830
                        hg->xp = 0;
831
                        hg->yp = 0;
832
                        hg->PRot = 0;
833
                        hg->PtransX = 0;
834
                        hg->PtransY = 0;
2434 fschmid 835
                        hg->cembedded = 0;
1957 cbradney 836
                        currItem->itemText.append(hg);
253 Franz 837
                }
351 Franz 838
                chars = StyledText.at(p);
839
                for (uint c = 0; c < chars->count(); ++c)
840
                {
1065 cbradney 841
                        struct ScText *hg;
842
                        hg = new ScText;
351 Franz 843
                        hg->ch = chars->at(c)->ch;
1789 fschmid 844
                        hg->cfont = (*doc->AllFonts)[chars->at(c)->cfont];
351 Franz 845
                        hg->csize = chars->at(c)->csize;
846
                        hg->ccolor = chars->at(c)->ccolor;
847
                        hg->cshade = chars->at(c)->cshade;
848
                        hg->cstroke = chars->at(c)->cstroke;
849
                        hg->cshade2 = chars->at(c)->cshade2;
850
                        hg->cscale = chars->at(c)->cscale;
2230 fschmid 851
                        hg->cscalev = chars->at(c)->cscalev;
351 Franz 852
                        hg->cstyle = chars->at(c)->cstyle;
853
                        hg->cab = chars->at(c)->cab;
854
                        hg->cextra = chars->at(c)->cextra;
2234 fschmid 855
                        hg->cbase = chars->at(c)->cbase;
2247 fschmid 856
                        hg->cshadowx = chars->at(c)->cshadowx;
857
                        hg->cshadowy = chars->at(c)->cshadowy;
2257 fschmid 858
                        hg->coutline = chars->at(c)->coutline;
2262 fschmid 859
                        hg->cunderpos = chars->at(c)->cunderpos;
860
                        hg->cunderwidth = chars->at(c)->cunderwidth;
2272 fschmid 861
                        hg->cstrikepos = chars->at(c)->cstrikepos;
862
                        hg->cstrikewidth = chars->at(c)->cstrikewidth;
351 Franz 863
                        hg->cselect = false;
864
                        hg->xp = 0;
865
                        hg->yp = 0;
866
                        hg->PRot = 0;
867
                        hg->PtransX = 0;
868
                        hg->PtransY = 0;
2499 fschmid 869
                        if (hg->ch == QChar(25))
870
                        {
871
                                hg->cembedded = chars->at(c)->cembedded;
872
                                currItem->Doc->FrameItems.append(hg->cembedded);
2955 fschmid 873
                                if (hg->cembedded->Groups.count() != 0)
874
                                {
875
                                        for (uint ga=0; ga<FrameItems.count(); ++ga)
876
                                        {
877
                                                if (FrameItems.at(ga)->Groups.count() != 0)
878
                                                {
879
                                                        if (FrameItems.at(ga)->Groups.top() == hg->cembedded->Groups.top())
880
                                                        {
881
                                                                if (FrameItems.at(ga)->ItemNr != hg->cembedded->ItemNr)
882
                                                                {
883
                                                                        if (currItem->Doc->FrameItems.find(FrameItems.at(ga)) == -1)
884
                                                                                currItem->Doc->FrameItems.append(FrameItems.at(ga));
885
                                                                }
886
                                                        }
887
                                                }
888
                                        }
889
                                }
2499 fschmid 890
                        }
891
                        else
892
                                hg->cembedded = 0;
1957 cbradney 893
                        currItem->itemText.append(hg);
351 Franz 894
                }
253 Franz 895
        }
351 Franz 896
}
897
 
898
void SEditor::setAlign(int style)
899
{
900
        int align = 0;
901
        if (style > 4)
1065 cbradney 902
                align = doc->docParagraphStyles[style].textAlignment;
351 Franz 903
        else
904
                align = style;
905
        switch (align)
167 Franz 906
        {
351 Franz 907
        case 0:
908
                setAlignment(Qt::AlignLeft);
909
                break;
910
        case 1:
911
                setAlignment(Qt::AlignCenter);
912
                break;
913
        case 2:
914
                setAlignment(Qt::AlignRight);
915
                break;
916
        case 3:
917
        case 4:
918
                setAlignment(Qt::AlignJustify);
919
                break;
920
        default:
921
                break;
167 Franz 922
        }
351 Franz 923
}
924
 
1957 cbradney 925
void SEditor::loadItemText(PageItem *currItem)
351 Franz 926
{
1915 fschmid 927
        setUpdatesEnabled(false);
351 Franz 928
        struct PtiSmall *hg;
929
        QString Text = "";
795 fschmid 930
        int Csty = 0;
351 Franz 931
        int Ali = 0;
2500 fschmid 932
        clear();
1957 cbradney 933
        PageItem *nextItem = currItem;
351 Franz 934
        StyledText.clear();
373 Franz 935
        ParagStyles.clear();
2499 fschmid 936
        FrameItems.clear();
351 Franz 937
        ChList *chars;
938
        chars = new ChList;
939
        chars->setAutoDelete(true);
940
        chars->clear();
1957 cbradney 941
        while (nextItem != 0)
167 Franz 942
        {
1957 cbradney 943
                if (nextItem->BackBox != 0)
944
                        nextItem = nextItem->BackBox;
351 Franz 945
                else
946
                        break;
167 Franz 947
        }
1957 cbradney 948
        if (nextItem != 0)
253 Franz 949
        {
1957 cbradney 950
                if (nextItem->itemText.count() != 0)
351 Franz 951
                {
1957 cbradney 952
                        Csty = nextItem->itemText.at(0)->cstyle;
953
                        Ali = nextItem->itemText.at(0)->cab;
351 Franz 954
                }
955
                else
956
                {
2407 fschmid 957
                        Csty = currItem->TxTStyle;
1957 cbradney 958
                        Ali = currItem->textAlignment;
351 Franz 959
                }
960
                setAlign(Ali);
961
                setStyle(Csty);
253 Franz 962
        }
1957 cbradney 963
        while (nextItem != 0)
351 Franz 964
        {
1957 cbradney 965
                for (uint a = 0; a < nextItem->itemText.count(); ++a)
351 Franz 966
                {
1957 cbradney 967
                        if (nextItem->itemText.at(a)->ch == QChar(13))
351 Franz 968
                        {
969
                                StyledText.append(chars);
1957 cbradney 970
                                ParagStyles.append(nextItem->itemText.at(a)->cab);
971
                                Ali = nextItem->itemText.at(a)->cab;
351 Franz 972
                                chars = new ChList;
973
                                chars->setAutoDelete(true);
974
                                chars->clear();
975
                                Text += "\n";
976
                        }
977
                        else
978
                        {
979
                                hg = new PtiSmall;
1957 cbradney 980
                                hg->ch = nextItem->itemText.at(a)->ch;
3544 avox 981
                                hg->cfont = nextItem->itemText.at(a)->cfont->scName();
1957 cbradney 982
                                hg->csize = nextItem->itemText.at(a)->csize;
983
                                hg->ccolor = nextItem->itemText.at(a)->ccolor;
984
                                hg->cshade = nextItem->itemText.at(a)->cshade;
985
                                hg->cstroke = nextItem->itemText.at(a)->cstroke;
986
                                hg->cshade2 = nextItem->itemText.at(a)->cshade2;
987
                                hg->cscale = nextItem->itemText.at(a)->cscale;
2230 fschmid 988
                                hg->cscalev = nextItem->itemText.at(a)->cscalev;
1957 cbradney 989
                                hg->cstyle = nextItem->itemText.at(a)->cstyle;
990
                                hg->cab = nextItem->itemText.at(a)->cab;
991
                                hg->cextra = nextItem->itemText.at(a)->cextra;
2234 fschmid 992
                                hg->cbase = nextItem->itemText.at(a)->cbase;
2247 fschmid 993
                                hg->cshadowx = nextItem->itemText.at(a)->cshadowx;
994
                                hg->cshadowy = nextItem->itemText.at(a)->cshadowy;
2257 fschmid 995
                                hg->coutline = nextItem->itemText.at(a)->coutline;
2262 fschmid 996
                                hg->cunderpos = nextItem->itemText.at(a)->cunderpos;
997
                                hg->cunderwidth = nextItem->itemText.at(a)->cunderwidth;
2272 fschmid 998
                                hg->cstrikepos = nextItem->itemText.at(a)->cstrikepos;
999
                                hg->cstrikewidth = nextItem->itemText.at(a)->cstrikewidth;
2499 fschmid 1000
                                if (hg->ch == QChar(25))
1001
                                {
1002
                                        hg->cembedded = nextItem->itemText.at(a)->cembedded;
1003
                                        FrameItems.append(hg->cembedded);
2955 fschmid 1004
                                        if (hg->cembedded->Groups.count() != 0)
1005
                                        {
1006
                                                for (uint ga=0; ga < doc->FrameItems.count(); ++ga)
1007
                                                {
1008
                                                        if (doc->FrameItems.at(ga)->Groups.count() != 0)
1009
                                                        {
1010
                                                                if (doc->FrameItems.at(ga)->Groups.top() == hg->cembedded->Groups.top())
1011
                                                                {
1012
                                                                        if (doc->FrameItems.at(ga)->ItemNr != hg->cembedded->ItemNr)
1013
                                                                        {
1014
                                                                                if (FrameItems.find(doc->FrameItems.at(ga)) == -1)
1015
                                                                                        FrameItems.append(doc->FrameItems.at(ga));
1016
                                                                        }
1017
                                                                }
1018
                                                        }
1019
                                                }
1020
                                        }
2499 fschmid 1021
                                        setAlign(Ali);
1022
                                        setStyle(Csty);
1023
                                        insert(Text);
1024
                                        setFarbe(true);
1025
                                        insert("@");
1026
                                        setFarbe(false);
1027
                                        Text = "";
1028
                                        chars->append(hg);
1029
                                        continue;
1030
                                }
2407 fschmid 1031
                                if ((Ali == hg->cab) && (Csty == hg->cstyle))
351 Franz 1032
                                {
2319 cbradney 1033
                                        if (hg->ch == QChar(ScApp->scrActions["specialPageNumber"]->actionInt()))
351 Franz 1034
                                        {
1035
                                                setAlign(Ali);
1036
                                                setStyle(Csty);
1037
                                                insert(Text);
2407 fschmid 1038
                                                setFarbe(true);
351 Franz 1039
                                                insert("#");
2407 fschmid 1040
                                                setFarbe(false);
351 Franz 1041
                                                Text = "";
1042
                                                chars->append(hg);
1043
                                                continue;
1044
                                        }
2319 cbradney 1045
                                        else if (hg->ch == QChar(ScApp->scrActions["specialNonBreakingSpace"]->actionInt()))
2318 fschmid 1046
                                        {
1047
                                                setAlign(Ali);
1048
                                                setStyle(Csty);
1049
                                                insert(Text);
2407 fschmid 1050
                                                setFarbe(true);
2318 fschmid 1051
                                                insert("_");
2407 fschmid 1052
                                                setFarbe(false);
2318 fschmid 1053
                                                Text = "";
1054
                                                chars->append(hg);
1055
                                                continue;
1056
                                        }
2352 fschmid 1057
                                        else if (hg->ch == QChar(ScApp->scrActions["specialFrameBreak"]->actionInt()))
1058
                                        {
1059
                                                setAlign(Ali);
1060
                                                setStyle(Csty);
1061
                                                insert(Text);
2407 fschmid 1062
                                                setFarbe(true);
2352 fschmid 1063
                                                insert("|");
2407 fschmid 1064
                                                setFarbe(false);
2352 fschmid 1065
                                                Text = "";
1066
                                                chars->append(hg);
1067
                                                continue;
1068
                                        }
2389 fschmid 1069
                                        else if (hg->ch == QChar(ScApp->scrActions["specialColumnBreak"]->actionInt()))
1070
                                        {
1071
                                                setAlign(Ali);
1072
                                                setStyle(Csty);
1073
                                                insert(Text);
2407 fschmid 1074
                                                setFarbe(true);
2389 fschmid 1075
                                                insert("^");
2407 fschmid 1076
                                                setFarbe(false);
2389 fschmid 1077
                                                Text = "";
1078
                                                chars->append(hg);
1079
                                                continue;
1080
                                        }
2407 fschmid 1081
                                        else if (hg->ch == QChar(ScApp->scrActions["specialNonBreakingHyphen"]->actionInt()))
1082
                                        {
1083
                                                setAlign(Ali);
1084
                                                setStyle(Csty);
1085
                                                insert(Text);
1086
                                                setFarbe(true);
1087
                                                insert("=");
1088
                                                setFarbe(false);
1089
                                                Text = "";
1090
                                                chars->append(hg);
1091
                                                continue;
1092
                                        }
2352 fschmid 1093
                                        else if (hg->ch == QChar(ScApp->scrActions["specialNewLine"]->actionInt()))
1094
                                        {
1095
                                                setAlign(Ali);
1096
                                                setStyle(Csty);
1097
                                                insert(Text);
2407 fschmid 1098
                                                setFarbe(true);
2352 fschmid 1099
                                                insert("*");
2407 fschmid 1100
                                                setFarbe(false);
2352 fschmid 1101
                                                Text = "";
1102
                                                chars->append(hg);
1103
                                                continue;
1104
                                        }
351 Franz 1105
                                        else
1106
                                                Text += hg->ch;
1107
                                }
1108
                                else
1109
                                {
1110
                                        setAlign(Ali);
1111
                                        setStyle(Csty);
1112
                                        insert(Text);
1113
                                        Text = hg->ch;
1114
                                        Csty = hg->cstyle;
1115
                                        Ali = hg->cab;
1116
                                }
1117
                                chars->append(hg);
1118
                        }
1119
                }
1957 cbradney 1120
                nextItem = nextItem->NextBox;
351 Franz 1121
        }
1122
        setAlign(Ali);
1123
        setStyle(Csty);
1124
        insert(Text);
876 fschmid 1125
        StyledText.append(chars);
1126
        ParagStyles.append(Ali);
351 Franz 1127
        if (StyledText.count() != 0)
1128
                emit setProps(0, 0);
1915 fschmid 1129
        setUpdatesEnabled(true);
351 Franz 1130
        setCursorPosition(0, 0);
102 Franz 1131
}
1132
 
1957 cbradney 1133
void SEditor::loadText(QString tx, PageItem *currItem)
102 Franz 1134
{
1915 fschmid 1135
        setUpdatesEnabled(false);
351 Franz 1136
        struct PtiSmall *hg;
1137
        QString Text = "";
1138
        StyledText.clear();
373 Franz 1139
        ParagStyles.clear();
351 Franz 1140
        ChList *chars;
1141
        chars = new ChList;
1142
        chars->setAutoDelete(true);
1143
        chars->clear();
1957 cbradney 1144
        setAlign(currItem->textAlignment);
1145
        setStyle(currItem->TxTStyle);
351 Franz 1146
        for (uint a = 0; a < tx.length(); ++a)
1147
        {
1148
                if (tx[a] == QChar(13))
1149
                {
1150
                        StyledText.append(chars);
1957 cbradney 1151
                        ParagStyles.append(currItem->textAlignment);
351 Franz 1152
                        chars = new ChList;
1153
                        chars->setAutoDelete(true);
1154
                        chars->clear();
1155
                        Text += "\n";
1156
                }
1157
                else
1158
                {
1159
                        hg = new PtiSmall;
1160
                        hg->ch = tx[a];
1957 cbradney 1161
                        hg->cfont = currItem->IFont;
1162
                        hg->csize = currItem->ISize;
1163
                        hg->ccolor = currItem->TxtFill;
1164
                        hg->cshade = currItem->ShTxtFill;
1165
                        hg->cstroke = currItem->TxtStroke;
1166
                        hg->cshade2 = currItem->ShTxtStroke;
1167
                        hg->cscale = currItem->TxtScale;
2230 fschmid 1168
                        hg->cscalev = currItem->TxtScaleV;
2234 fschmid 1169
                        hg->cbase = currItem->TxtBase;
2247 fschmid 1170
                        hg->cshadowx = currItem->TxtShadowX;
1171
                        hg->cshadowy = currItem->TxtShadowY;
2257 fschmid 1172
                        hg->coutline = currItem->TxtOutline;
2262 fschmid 1173
                        hg->cunderpos = currItem->TxtUnderPos;
1174
                        hg->cunderwidth = currItem->TxtUnderWidth;
2272 fschmid 1175
                        hg->cstrikepos = currItem->TxtStrikePos;
1176
                        hg->cstrikewidth = currItem->TxtStrikeWidth;
1957 cbradney 1177
                        hg->cstyle = currItem->TxTStyle;
1178
                        hg->cab = currItem->textAlignment;
351 Franz 1179
                        hg->cextra = 0;
2499 fschmid 1180
                        hg->cembedded = 0;
351 Franz 1181
                        Text += hg->ch;
1182
                        chars->append(hg);
1183
                }
1184
        }
1185
        insert(Text);
876 fschmid 1186
        StyledText.append(chars);
1957 cbradney 1187
        ParagStyles.append(currItem->textAlignment);
351 Franz 1188
        if (StyledText.count() != 0)
1189
                emit setProps(0, 0);
1915 fschmid 1190
        setUpdatesEnabled(true);
351 Franz 1191
        setCursorPosition(0, 0);
102 Franz 1192
}
1193
 
366 Franz 1194
void SEditor::updateAll()
1195
{
1196
        if (StyledText.count() == 0)
1197
                return;
1915 fschmid 1198
        setUpdatesEnabled(false);
366 Franz 1199
        int p, i;
1200
        getCursorPosition(&p, &i);
1201
        clear();
1202
        struct PtiSmall *hg;
1203
        QString Text = "";
1204
        int Csty;
1205
        int Ali = 0;
1206
        ChList *chars = StyledText.at(0);
1207
        if (chars->count() != 0)
1208
        {
1209
                Csty = chars->at(0)->cstyle;
1210
                Ali = chars->at(0)->cab;
1211
        }
1212
        else
1213
        {
1214
                Csty = CurrentStyle;
1065 cbradney 1215
                Ali = currentParaStyle;
366 Franz 1216
        }
1217
        setAlign(Ali);
1218
        setStyle(Csty);
1219
        for (uint pa = 0; pa < StyledText.count(); ++pa)
1220
        {
1221
                chars = StyledText.at(pa);
1222
                if ((chars->count() == 0) && (pa < StyledText.count()-1))
1223
                {
1224
                        Text += "\n";
1225
                        continue;
1226
                }
1227
                for (uint a = 0; a < chars->count(); ++a)
1228
                {
1229
                        hg = chars->at(a);
2499 fschmid 1230
                        if (hg->ch == QChar(25))
1231
                        {
1232
                                setAlign(Ali);
1233
                                setStyle(Csty);
1234
                                insert(Text);
1235
                                setFarbe(true);
1236
                                insert("@");
1237
                                setFarbe(false);
1238
                                Text = "";
1239
                                continue;
1240
                        }
2407 fschmid 1241
                        if ((Ali == hg->cab) && (Csty == hg->cstyle))
366 Franz 1242
                        {
2352 fschmid 1243
                                if (hg->ch == QChar(ScApp->scrActions["specialPageNumber"]->actionInt()))
366 Franz 1244
                                {
1245
                                        setAlign(Ali);
1246
                                        setStyle(Csty);
1247
                                        insert(Text);
2407 fschmid 1248
                                        setFarbe(true);
366 Franz 1249
                                        insert("#");
2407 fschmid 1250
                                        setFarbe(false);
366 Franz 1251
                                        Text = "";
1252
                                        continue;
1253
                                }
2352 fschmid 1254
                                else if (hg->ch == QChar(ScApp->scrActions["specialNonBreakingSpace"]->actionInt()))
1255
                                {
1256
                                        setAlign(Ali);
1257
                                        setStyle(Csty);
1258
                                        insert(Text);
2407 fschmid 1259
                                        setFarbe(true);
2352 fschmid 1260
                                        insert("_");
2407 fschmid 1261
                                        setFarbe(false);
2352 fschmid 1262
                                        Text = "";
1263
                                        continue;
1264
                                }
1265
                                else if (hg->ch == QChar(ScApp->scrActions["specialFrameBreak"]->actionInt()))
1266
                                {
1267
                                        setAlign(Ali);
1268
                                        setStyle(Csty);
1269
                                        insert(Text);
2407 fschmid 1270
                                        setFarbe(true);
2352 fschmid 1271
                                        insert("|");
2407 fschmid 1272
                                        setFarbe(false);
2352 fschmid 1273
                                        Text = "";
1274
                                        continue;
1275
                                }
2389 fschmid 1276
                                else if (hg->ch == QChar(ScApp->scrActions["specialColumnBreak"]->actionInt()))
1277
                                {
1278
                                        setAlign(Ali);
1279
                                        setStyle(Csty);
1280
                                        insert(Text);
2407 fschmid 1281
                                        setFarbe(true);
2389 fschmid 1282
                                        insert("^");
2407 fschmid 1283
                                        setFarbe(false);
2389 fschmid 1284
                                        Text = "";
1285
                                        chars->append(hg);
1286
                                        continue;
1287
                                }
2407 fschmid 1288
                                else if (hg->ch == QChar(ScApp->scrActions["specialNonBreakingHyphen"]->actionInt()))
1289
                                {
1290
                                        setAlign(Ali);
1291
                                        setStyle(Csty);
1292
                                        insert(Text);
1293
                                        setFarbe(true);
1294
                                        insert("=");
1295
                                        setFarbe(false);
1296
                                        Text = "";
1297
                                        chars->append(hg);
1298
                                        continue;
1299
                                }
2352 fschmid 1300
                                else if (hg->ch == QChar(ScApp->scrActions["specialNewLine"]->actionInt()))
1301
                                {
1302
                                        setAlign(Ali);
1303
                                        setStyle(Csty);
1304
                                        insert(Text);
2407 fschmid 1305
                                        setFarbe(true);
2352 fschmid 1306
                                        insert("*");
2407 fschmid 1307
                                        setFarbe(false);
2352 fschmid 1308
                                        Text = "";
1309
                                        continue;
1310
                                }
366 Franz 1311
                                else
1312
                                        Text += hg->ch;
1313
                        }
1314
                        else
1315
                        {
1316
                                setAlign(Ali);
1317
                                setStyle(Csty);
1318
                                insert(Text);
1319
                                Text = hg->ch;
1320
                                Csty = hg->cstyle;
1321
                                Ali = hg->cab;
1322
                        }
1323
                }
1324
                if (pa < StyledText.count()-1)
1325
                        Text += "\n";
1326
        }
1327
        setAlign(Ali);
1328
        setStyle(Csty);
1329
        insert(Text);
1915 fschmid 1330
        setUpdatesEnabled(true);
3608 cbradney 1331
        //CB Removed to fix 2083 setCursorPosition(p, i);
366 Franz 1332
}
1333
 
351 Franz 1334
void SEditor::updateFromChars(int pa)
102 Franz 1335
{
351 Franz 1336
        ChList *chars = StyledText.at(pa);
1337
        if (chars->count() == 0)
1338
                return;
1915 fschmid 1339
        setUpdatesEnabled(false);
351 Franz 1340
        int SelStart = 0;
1341
        int SelEnd = 0;
1342
        int p, i;
1343
        getCursorPosition(&p, &i);
1344
        removeSelection();
1345
        int Csty = chars->at(0)->cstyle;
1346
        for (uint a = 0; a < chars->count(); ++a)
167 Franz 1347
        {
2407 fschmid 1348
                if (Csty == chars->at(a)->cstyle)
351 Franz 1349
                        SelEnd++;
1350
                else
167 Franz 1351
                {
351 Franz 1352
                        setSelection(pa, SelStart, pa, SelEnd);
1353
                        setStyle(Csty);
1354
                        removeSelection();
1355
                        Csty = chars->at(a)->cstyle;
362 Franz 1356
                        SelStart = SelEnd;
351 Franz 1357
                        SelEnd++;
167 Franz 1358
                }
351 Franz 1359
        }
1360
        setSelection(pa, SelStart, pa, SelEnd);
1361
        setStyle(Csty);
1362
        removeSelection();
362 Franz 1363
        setAlign(chars->at(0)->cab);
1915 fschmid 1364
        setUpdatesEnabled(true);
351 Franz 1365
        setCursorPosition(p, i);
1366
}
1367
 
1368
/* updates the internal PtiSmall structure, to be useable for all members of the PtiSmall struct
1369
   there is a code as first parameter to indicate which member should be updated.
1370
 
1371
        1 = Stroke Colour and Stroke Shade
1372
        2 = Font
1373
        3 = Font Size
1374
        4 = Character Style
1375
        5 = Character Scaling
1376
        6 = Kerning
2230 fschmid 1377
        7 = Character Scaling Vertical
2257 fschmid 1378
        8 = Character Shadow
1379
        9 = Character Outline
2262 fschmid 1380
        10 = Character Underline
2272 fschmid 1381
        11 = Character Strikethru
351 Franz 1382
 */
1383
void SEditor::updateSel(int code, struct PtiSmall *hg)
1384
{
1385
        int PStart, PEnd, SelStart, SelEnd, start, end;
1386
        ChList *chars;
385 Franz 1387
        if (StoredSel)
1388
        {
1389
                setSelection(SelParaStart, SelCharStart, SelParaEnd, SelCharEnd);
1390
                StoredSel = false;
1391
        }
351 Franz 1392
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
1393
        for (int pa = PStart; pa < PEnd+1; ++pa)
1394
        {
1395
                chars = StyledText.at(pa);
1396
                if (pa == PStart)
1397
                        start = SelStart;
1398
                else
1399
                        start = 0;
1400
                if (pa == PEnd)
1401
                        end = SelEnd;
1402
                else
1403
                        end = chars->count();
1404
                for (int ca = start; ca < end; ++ca)
167 Franz 1405
                {
351 Franz 1406
                        switch (code)
167 Franz 1407
                        {
351 Franz 1408
                                case 0:
1409
                                        chars->at(ca)->ccolor = hg->ccolor;
1410
                                        chars->at(ca)->cshade = hg->cshade;
1411
                                        break;
217 Franz 1412
                                case 1:
351 Franz 1413
                                        chars->at(ca)->cstroke = hg->cstroke;
1414
                                        chars->at(ca)->cshade2 = hg->cshade2;
111 Franz 1415
                                        break;
217 Franz 1416
                                case 2:
351 Franz 1417
                                        chars->at(ca)->cfont = hg->cfont;
217 Franz 1418
                                        break;
1419
                                case 3:
351 Franz 1420
                                        chars->at(ca)->csize = hg->csize;
111 Franz 1421
                                        break;
351 Franz 1422
                                case 4:
2188 fschmid 1423
                                        chars->at(ca)->cstyle &= ~1919;
351 Franz 1424
                                        chars->at(ca)->cstyle |= hg->cstyle;
102 Franz 1425
                                        break;
351 Franz 1426
                                case 5:
1427
                                        chars->at(ca)->cscale = hg->cscale;
102 Franz 1428
                                        break;
351 Franz 1429
                                case 6:
1430
                                        chars->at(ca)->cextra = hg->cextra;
102 Franz 1431
                                        break;
2230 fschmid 1432
                                case 7:
1433
                                        chars->at(ca)->cscalev = hg->cscalev;
1434
                                        break;
2254 fschmid 1435
                                case 8:
1436
                                        chars->at(ca)->cshadowx = hg->cshadowx;
1437
                                        chars->at(ca)->cshadowy = hg->cshadowy;
1438
                                        break;
2257 fschmid 1439
                                case 9:
1440
                                        chars->at(ca)->coutline = hg->coutline;
1441
                                        break;
2262 fschmid 1442
                                case 10:
1443
                                        chars->at(ca)->cunderpos = hg->cunderpos;
1444
                                        chars->at(ca)->cunderwidth = hg->cunderwidth;
1445
                                        break;
2272 fschmid 1446
                                case 11:
1447
                                        chars->at(ca)->cstrikepos = hg->cstrikepos;
1448
                                        chars->at(ca)->cstrikewidth = hg->cstrikewidth;
1449
                                        break;
351 Franz 1450
                                default:
1451
                                        break;
167 Franz 1452
                        }
102 Franz 1453
                }
167 Franz 1454
        }
102 Franz 1455
}
1456
 
351 Franz 1457
void SEditor::deleteSel()
102 Franz 1458
{
351 Franz 1459
        int PStart, PEnd, SelStart, SelEnd, start, end;
800 fschmid 1460
        ChList *chars = NULL;
351 Franz 1461
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
1462
        if (PStart == PEnd)
1463
        {
1464
                chars = StyledText.at(PStart);
1465
                for (int a = 0; a < SelEnd-SelStart; ++a)
1466
                {
1467
                        chars->remove(SelStart);
1468
                }
1469
        }
1470
        else
1471
        {
1472
                for (int pa = PStart; pa < PEnd+1; ++pa)
1473
                {
367 Franz 1474
                        bool noChar = false;
1475
                        if (pa >= static_cast<int>(StyledText.count()))
1476
                                noChar = true;
1477
                        else
1478
                                chars = StyledText.at(pa);
351 Franz 1479
                        if (pa == PStart)
1480
                                start = SelStart;
1481
                        else
1482
                                start = 0;
1483
                        if (pa == PEnd)
1484
                                end = SelEnd;
1485
                        else
1486
                        {
367 Franz 1487
                                if (noChar)
1488
                                        end = 0;
1489
                                else
1490
                                        end = chars->count();
351 Franz 1491
                        }
367 Franz 1492
                        if (!noChar)
1493
                        {
1494
                                for (int ca = 0; ca < end-start; ++ca)
1495
                                {
1496
                                        chars->remove(start);
1497
                                }
1498
                        }
351 Franz 1499
                }
1500
                if (PEnd-PStart > 1)
1501
                {
1502
                        for (int pa2 = 0; pa2 < PEnd - PStart - 1; ++pa2)
1503
                        {
367 Franz 1504
                                if (PStart+1 < static_cast<int>(StyledText.count()))
373 Franz 1505
                                {
367 Franz 1506
                                        StyledText.remove(PStart+1);
373 Franz 1507
                                        ParagStyles.remove(ParagStyles.at(PStart+1));
1508
                                }
351 Franz 1509
                        }
1510
                }
367 Franz 1511
                if (PStart+1 < static_cast<int>(StyledText.count()))
351 Franz 1512
                {
367 Franz 1513
                        struct PtiSmall *hg;
1514
                        ChList *chars2 = StyledText.at(PStart+1);
1515
                        chars = StyledText.at(PStart);
1516
                        int a = static_cast<int>(chars2->count());
1517
                        if (a > 0)
351 Franz 1518
                        {
367 Franz 1519
                                int ca;
1520
                                if (chars->count() > 0)
1521
                                        ca = chars->at(0)->cab;
1522
                                else
1065 cbradney 1523
                                        ca = currentParaStyle;
367 Franz 1524
                                for (int s = 0; s < a; ++s)
1525
                                {
1526
                                        hg = chars2->take(0);
1527
                                        hg->cab = ca;
1528
                                        chars->append(hg);
1529
                                }
351 Franz 1530
                        }
367 Franz 1531
                        StyledText.remove(PStart+1);
373 Franz 1532
                        ParagStyles.remove(ParagStyles.at(PStart+1));
351 Franz 1533
                }
1534
        }
1535
        setCursorPosition(PStart, SelStart);
102 Franz 1536
}
1537
 
351 Franz 1538
void SEditor::setStyle(int Csty)
102 Franz 1539
{
351 Franz 1540
        if (Csty & 8)
1541
                setUnderline(true);
1542
        else
1543
                setUnderline(false);
374 Franz 1544
        QFont f = currentFont();
1545
        if (Csty & 16)
1546
                f.setStrikeOut(true);
1547
        else
1548
                f.setStrikeOut(false);
1549
        setCurrentFont(f);
351 Franz 1550
        if (Csty & 1)
1551
                setVerticalAlignment(AlignSuperScript);
1552
        else if (Csty & 2)
1553
                setVerticalAlignment(AlignSubScript);
1554
        else
1555
                setVerticalAlignment(AlignNormal);
1556
}
1557
 
2407 fschmid 1558
void SEditor::setFarbe(bool marker)
351 Franz 1559
{
1560
        QColor tmp;
2407 fschmid 1561
        if (marker)
1562
                tmp = QColor(red);
351 Franz 1563
        else
2407 fschmid 1564
                tmp = QColor(black);
351 Franz 1565
        setColor(tmp);
1566
}
103 Franz 1567
 
362 Franz 1568
void SEditor::copy()
1569
{
372 Franz 1570
        emit SideBarUp(false);
2877 cbradney 1571
        if ((hasSelectedText()) && (!selectedText().isEmpty()))
362 Franz 1572
        {
376 Franz 1573
                disconnect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
399 Franz 1574
                disconnect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(SelClipChange()));
362 Franz 1575
                copyStyledText();
376 Franz 1576
                QApplication::clipboard()->setText(tBuffer, QClipboard::Clipboard);
1577
                ClipData = 1;
1578
                connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
399 Franz 1579
                connect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(SelClipChange()));
376 Franz 1580
                emit PasteAvail();
362 Franz 1581
        }
372 Franz 1582
        emit SideBarUp(true);
362 Franz 1583
}
1584
 
351 Franz 1585
void SEditor::cut()
1586
{
362 Franz 1587
        copy();
372 Franz 1588
        emit SideBarUp(false);
362 Franz 1589
        if (hasSelectedText())
1590
        {
1591
                deleteSel();
1592
                removeSelectedText();
1593
        }
372 Franz 1594
        emit SideBarUp(true);
1595
        emit SideBarUpdate();
351 Franz 1596
}
1597
 
1598
void SEditor::paste()
1599
{
372 Franz 1600
        emit SideBarUp(false);
3605 cbradney 1601
        int currentPara, currentCharPos;
399 Franz 1602
        QString data = "";
3605 cbradney 1603
        int newParaCount, lengthLastPara;
1604
        bool inserted=false;
1605
        getCursorPosition(&currentPara, &currentCharPos);
399 Franz 1606
        if (ClipData == 1)
1607
                insStyledText();
1608
        else
376 Franz 1609
        {
399 Franz 1610
                QString data = QApplication::clipboard()->text(QClipboard::Selection);
1611
                if (data.isNull())
1612
                        data = QApplication::clipboard()->text(QClipboard::Clipboard);
376 Franz 1613
                if (!data.isNull())
1614
                {
1615
                        data.replace(QRegExp("\r"), "");
3605 cbradney 1616
                        newParaCount=data.contains("\n");
1617
                        lengthLastPara=data.length()-data.findRev("\n");
376 Franz 1618
                        data.replace(QRegExp("\n"), QChar(13));
3605 cbradney 1619
                        inserted=true;
376 Franz 1620
                        insChars(data);
399 Franz 1621
                        ClipData = 2;
1622
                        emit PasteAvail();
376 Franz 1623
                }
399 Franz 1624
                else
1625
                {
1626
                        emit SideBarUp(true);
1627
                        return;
1628
                }
376 Franz 1629
        }
374 Franz 1630
        updateAll();
3605 cbradney 1631
        if (inserted)
1632
                setCursorPosition(currentPara+newParaCount,(newParaCount==0?currentCharPos:0)+lengthLastPara-1);
1915 fschmid 1633
        sync();
1634
        repaintContents();
372 Franz 1635
        emit SideBarUp(true);
1636
        emit SideBarUpdate();
351 Franz 1637
}
1638
 
374 Franz 1639
QPopupMenu* SEditor::createPopupMenu(const QPoint & pos)
1640
{
1641
        QPopupMenu *p = QTextEdit::createPopupMenu(pos);
1642
        p->removeItemAt(0);
1643
        p->removeItemAt(0);
1644
        p->removeItemAt(0);
1645
        p->removeItemAt(3);
1646
        return p;
1647
}
1648
 
399 Franz 1649
void SEditor::SelClipChange()
1650
{
1651
        ClipData = 3;
1652
        emit PasteAvail();
1653
}
1654
 
376 Franz 1655
void SEditor::ClipChange()
1656
{
1657
        ClipData = 2;
1658
        emit PasteAvail();
1659
}
1660
 
351 Franz 1661
/* Toolbar for Fill Colour */
352 Franz 1662
SToolBColorF::SToolBColorF(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Fill Color Settings"), parent)
351 Franz 1663
{
1664
        FillIcon = new QLabel( "", this, "FillIcon" );
1665
        FillIcon->setPixmap(loadIcon("fill.png"));
1666
        FillIcon->setScaledContents( false );
3680 cbradney 1667
        TxFill = new ScComboBox( false, this, "TxFill" );
351 Franz 1668
        PM2 = new ShadeButton(this);
2494 cbradney 1669
        setCurrentDocument(doc);
2504 cbradney 1670
        //TxFill->listBox()->setMinimumWidth(TxFill->listBox()->maxItemWidth()+24);
351 Franz 1671
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1672
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
2505 cbradney 1673
 
1674
        languageChange();
351 Franz 1675
}
1676
 
2505 cbradney 1677
void SToolBColorF::languageChange()
1678
{
1679
        QToolTip::remove(TxFill);
1680
        QToolTip::remove(PM2);
1681
        QToolTip::add(TxFill, tr( "Color of text fill" ));
1682
        QToolTip::add(PM2, tr( "Saturation of color of text fill" ));
1683
}
1684
 
2494 cbradney 1685
void SToolBColorF::setCurrentDocument(ScribusDoc *doc)
1686
{
1687
        TxFill->clear();
1688
        TxFill->insertItem( tr("None"));
1689
        if (doc!=NULL)
1690
        {
3333 avox 1691
                QPixmap * pm;
2494 cbradney 1692
                for (ColorList::Iterator it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1693
                {
3333 avox 1694
                        pm = getSmallPixmap(doc->PageColors[it.key()].getRawRGBColor());
1695
                        TxFill->insertItem(*pm, it.key());
2494 cbradney 1696
                }
1697
        }
2504 cbradney 1698
        resize(minimumSizeHint());
2494 cbradney 1699
}
1700
 
351 Franz 1701
void SToolBColorF::SetColor(int c)
1702
{
1703
        disconnect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1704
        TxFill->setCurrentItem(c);
1705
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1706
}
1707
 
1708
void SToolBColorF::SetShade(int s)
1709
{
1710
        disconnect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1711
        PM2->setValue(s);
1712
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1713
}
1714
 
1715
void SToolBColorF::newShadeHandler()
1716
{
1717
        emit NewColor(TxFill->currentItem(), PM2->getValue());
1718
}
1719
 
1720
/* Toolbar for Stroke Colour */
352 Franz 1721
SToolBColorS::SToolBColorS(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Stroke Color Settings"), parent)
351 Franz 1722
{
1723
        StrokeIcon = new QLabel( "", this, "StrokeIcon" );
1724
        StrokeIcon->setPixmap(loadIcon("Stiftalt.xpm"));
1725
        StrokeIcon->setScaledContents( false );
3680 cbradney 1726
        TxStroke = new ScComboBox( false, this, "TxStroke" );
351 Franz 1727
        PM1 = new ShadeButton(this);
2494 cbradney 1728
        setCurrentDocument(doc);
2504 cbradney 1729
        //TxStroke->listBox()->setMinimumWidth(TxStroke->listBox()->maxItemWidth()+24);
351 Franz 1730
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1731
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
2505 cbradney 1732
 
1733
        languageChange();
351 Franz 1734
}
1735
 
2505 cbradney 1736
void SToolBColorS::languageChange()
1737
{
1738
        QToolTip::remove(TxStroke);
1739
        QToolTip::remove(PM1);
1740
        QToolTip::add(TxStroke, tr("Color of text stroke"));
1741
        QToolTip::add(PM1, tr("Saturation of color of text stroke"));
1742
}
1743
 
2494 cbradney 1744
void SToolBColorS::setCurrentDocument(ScribusDoc *doc)
1745
{
1746
        TxStroke->clear();
1747
        TxStroke->insertItem( tr("None"));
1748
        if (doc!=NULL)
1749
        {
3333 avox 1750
                QPixmap * pm;
2494 cbradney 1751
                for (ColorList::Iterator it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1752
                {
3333 avox 1753
                        pm = getSmallPixmap(doc->PageColors[it.key()].getRawRGBColor());
1754
                        TxStroke->insertItem(*pm, it.key());
2494 cbradney 1755
                }
1756
        }
2504 cbradney 1757
        resize(minimumSizeHint());
2494 cbradney 1758
}
1759
 
351 Franz 1760
void SToolBColorS::SetColor(int c)
1761
{
1762
        disconnect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1763
        TxStroke->setCurrentItem(c);
1764
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1765
}
1766
 
1767
void SToolBColorS::SetShade(int s)
1768
{
1769
        disconnect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1770
        PM1->setValue(s);
1771
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1772
}
1773
 
1774
void SToolBColorS::newShadeHandler()
1775
{
1776
        emit NewColor(TxStroke->currentItem(), PM1->getValue());
1777
}
1778
 
1779
/* Toolbar for Character Style Settings */
352 Franz 1780
SToolBStyle::SToolBStyle(QMainWindow* parent) : QToolBar( tr("Character Settings"), parent)
351 Franz 1781
{
1782
        SeStyle = new StyleSelect(this);
2500 fschmid 1783
        trackingLabel = new QLabel( this, "trackingLabel" );
1784
        trackingLabel->setText("");
1785
        trackingLabel->setPixmap(loadIcon("textkern.png"));
351 Franz 1786
        Extra = new MSpinBox( this, 1 );
1787
        Extra->setValues( -300, 300, 10, 0);
2382 fschmid 1788
        Extra->setSuffix( tr( " %" ) );
2505 cbradney 1789
 
716 cbradney 1790
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
351 Franz 1791
        connect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
2254 fschmid 1792
        connect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
1793
        connect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
2257 fschmid 1794
        connect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newOutlineHandler()));
2262 fschmid 1795
        connect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
1796
        connect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
2272 fschmid 1797
        connect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
1798
        connect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
2505 cbradney 1799
 
1800
        languageChange();
351 Franz 1801
}
1802
 
2505 cbradney 1803
void SToolBStyle::languageChange()
1804
{
1805
        QToolTip::remove(Extra);
1806
        QToolTip::add(Extra, tr( "Manual Tracking" ));
1807
}
1808
 
2272 fschmid 1809
void SToolBStyle::newStrikeHandler()
1810
{
1811
        int x = qRound(SeStyle->StrikeVal->LPos->value() * 10.0);
1812
        int y = qRound(SeStyle->StrikeVal->LWidth->value() * 10.0);
1813
        emit newUnderline(x, y);
1814
}
1815
 
2262 fschmid 1816
void SToolBStyle::newUnderlineHandler()
1817
{
1818
        int x = qRound(SeStyle->UnderlineVal->LPos->value() * 10.0);
1819
        int y = qRound(SeStyle->UnderlineVal->LWidth->value() * 10.0);
1820
        emit newUnderline(x, y);
1821
}
1822
 
2257 fschmid 1823
void SToolBStyle::newOutlineHandler()
1824
{
1825
        int x = qRound(SeStyle->OutlineVal->LWidth->value() * 10.0);
1826
        emit newOutline(x);
1827
}
1828
 
2254 fschmid 1829
void SToolBStyle::newShadowHandler()
1830
{
1831
        int x = qRound(SeStyle->ShadowVal->Xoffset->value() * 10.0);
1832
        int y = qRound(SeStyle->ShadowVal->Yoffset->value() * 10.0);
1833
        emit NewShadow(x, y);
1834
}
1835
 
351 Franz 1836
void SToolBStyle::newKernHandler()
1837
{
2382 fschmid 1838
        emit NewKern(qRound(Extra->value() * 10.0));
351 Franz 1839
}
1840
 
2257 fschmid 1841
void SToolBStyle::setOutline(int x)
1842
{
1843
        disconnect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newOutlineHandler()));
1844
        SeStyle->OutlineVal->LWidth->setValue(x / 10.0);
1845
        connect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newOutlineHandler()));
1846
}
1847
 
2272 fschmid 1848
void SToolBStyle::setStrike(int p, int w)
1849
{
1850
        disconnect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
1851
        disconnect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
1852
        SeStyle->StrikeVal->LWidth->setValue(w / 10.0);
1853
        SeStyle->StrikeVal->LPos->setValue(p / 10.0);
1854
        connect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
1855
        connect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newStrikeHandler()));
1856
}
1857
 
2262 fschmid 1858
void SToolBStyle::setUnderline(int p, int w)
1859
{
1860
        disconnect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
1861
        disconnect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
1862
        SeStyle->UnderlineVal->LWidth->setValue(w / 10.0);
1863
        SeStyle->UnderlineVal->LPos->setValue(p / 10.0);
1864
        connect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
1865
        connect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(int)), this, SLOT(newUnderlineHandler()));
1866
}
1867
 
2254 fschmid 1868
void SToolBStyle::SetShadow(int x, int y)
1869
{
1870
        disconnect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
1871
        disconnect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
1872
        SeStyle->ShadowVal->Xoffset->setValue(x / 10.0);
1873
        SeStyle->ShadowVal->Yoffset->setValue(y / 10.0);
1874
        connect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
1875
        connect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(int)), this, SLOT(newShadowHandler()));
1876
}
1877
 
351 Franz 1878
void SToolBStyle::SetStyle(int s)
1879
{
716 cbradney 1880
        disconnect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
351 Franz 1881
        SeStyle->setStyle(s);
716 cbradney 1882
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
351 Franz 1883
}
1884
 
2382 fschmid 1885
void SToolBStyle::SetKern(int k)
351 Franz 1886
{
1887
        disconnect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
2382 fschmid 1888
        Extra->setValue(k / 10.0);
351 Franz 1889
        connect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
1890
}
1891
 
1892
/* Toolbar for alignment of Paragraphs */
352 Franz 1893
SToolBAlign::SToolBAlign(QMainWindow* parent) : QToolBar( tr("Style Settings"), parent)
351 Franz 1894
{
1895
        GroupAlign = new AlignSelect(this);
1896
        Spal = new Spalette(this);
716 cbradney 1897
        connect(Spal, SIGNAL(newStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1898
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
2505 cbradney 1899
 
1900
        languageChange();
351 Franz 1901
}
1902
 
2505 cbradney 1903
void SToolBAlign::languageChange()
1904
{
1905
        QToolTip::remove(Spal);
1906
        QToolTip::add(Spal, tr("Style of current paragraph"));
1907
}
1908
 
351 Franz 1909
void SToolBAlign::newStyleHandler(int s)
1910
{
1911
        if (s != 0)
1912
                GroupAlign->setEnabled(false);
1913
        else
1914
                GroupAlign->setEnabled(true);
716 cbradney 1915
        emit newStyle(s);
351 Franz 1916
}
1917
 
1918
void SToolBAlign::SetAlign(int s)
1919
{
716 cbradney 1920
        disconnect(Spal, SIGNAL(newStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1921
        disconnect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
1922
        if (s < 5)
1923
        {
1924
                GroupAlign->setEnabled(true);
1925
                GroupAlign->setStyle(s);
1926
        }
1927
        else
1928
                GroupAlign->setEnabled(false);
1929
        Spal->setFormat(s);
1930
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
716 cbradney 1931
        connect(Spal, SIGNAL(newStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1932
}
1933
 
1934
/* Toolbar for Font related Settings */
352 Franz 1935
SToolBFont::SToolBFont(QMainWindow* parent) : QToolBar( tr("Font Settings"), parent)
351 Franz 1936
{
2834 cbradney 1937
        Fonts = new FontCombo(this);
351 Franz 1938
        Fonts->setMaximumSize(190, 30);
2247 fschmid 1939
        Size = new MSpinBox( 0.5, 2048, this, 1 );
351 Franz 1940
        Size->setPrefix( "" );
1941
        Size->setSuffix( tr( " pt" ) );
2230 fschmid 1942
        ScaleTxt = new QLabel("", this, "ScaleTxt" );
1943
        ScaleTxt->setPixmap(loadIcon("textscaleh.png"));
2242 fschmid 1944
        ChScale = new MSpinBox( 10, 400,  this, 1 );
351 Franz 1945
        ChScale->setValue( 100 );
1946
        ChScale->setSuffix( tr( " %" ) );
2230 fschmid 1947
        ScaleTxtV = new QLabel("", this, "ScaleTxtV" );
1948
        ScaleTxtV->setPixmap(loadIcon("textscalev.png"));
2242 fschmid 1949
        ChScaleV = new MSpinBox( 10, 400, this, 1 );
2230 fschmid 1950
        ChScaleV->setValue( 100 );
1951
        ChScaleV->setSuffix( tr( " %" ) );
2505 cbradney 1952
 
351 Franz 1953
        connect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
2230 fschmid 1954
        connect(ChScaleV, SIGNAL(valueChanged(int)), this, SIGNAL(NewScaleV(int)));
351 Franz 1955
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1956
        connect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
1957
}
1958
 
2505 cbradney 1959
void SToolBFont::languageChange()
1960
{
1961
        QToolTip::remove(Fonts);
1962
        QToolTip::remove(Size);
1963
        QToolTip::remove(ChScale);
1964
        QToolTip::remove(ChScaleV);
1965
        QToolTip::add(Fonts, tr("Font of selected text"));
1966
        QToolTip::add(Size, tr("Font Size"));
1967
        QToolTip::add(ChScale, tr("Scaling width of characters"));
1968
        QToolTip::add(ChScaleV, tr("Scaling height of characters"));
1969
}
1970
 
351 Franz 1971
void SToolBFont::SetFont(QString f)
1972
{
1973
        disconnect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1974
        Fonts->setCurrentText(f);
1975
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1976
}
1977
 
1978
void SToolBFont::SetSize(double s)
1979
{
1980
        disconnect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
2242 fschmid 1981
        Size->setValue(s / 10.0);
351 Franz 1982
        connect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
1983
}
1984
 
1985
void SToolBFont::SetScale(int s)
1986
{
1987
        disconnect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
2242 fschmid 1988
        ChScale->setValue(s / 10.0);
351 Franz 1989
        connect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
1990
}
1991
 
2230 fschmid 1992
void SToolBFont::SetScaleV(int s)
1993
{
1994
        disconnect(ChScaleV, SIGNAL(valueChanged(int)), this, SIGNAL(NewScaleV(int)));
2242 fschmid 1995
        ChScaleV->setValue(s / 10.0);
2230 fschmid 1996
        connect(ChScaleV, SIGNAL(valueChanged(int)), this, SIGNAL(NewScaleV(int)));
1997
}
1998
 
351 Franz 1999
void SToolBFont::newSizeHandler()
2000
{
2001
        emit NewSize(Size->value());
2002
}
2003
 
2004
/* Main Story Editor Class */
2494 cbradney 2005
StoryEditor::StoryEditor(QWidget* parent, ScribusDoc *docc, PageItem *ite)
2498 fschmid 2006
        : QMainWindow(parent, "StoryEditor&q