Subversion Repositories Scribus

Rev

Rev 390 | 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
 ***************************************************************************/
17
#include "story.h"
18
#include "story.moc"
19
#include <qtooltip.h>
20
#include <qpixmap.h>
21
#include <qcombobox.h>
103 Franz 22
#include <qmessagebox.h>
124 Franz 23
#include <qregexp.h>
351 Franz 24
#include <qhbox.h>
357 Franz 25
#include <qcolordialog.h>
26
#include <qfontdialog.h>
374 Franz 27
#include <qcursor.h>
102 Franz 28
#include "serializer.h"
162 Franz 29
#include "customfdialog.h"
189 Franz 30
#include "search.h"
253 Franz 31
#include "scribus.h"
32
extern ScribusApp* ScApp;
189 Franz 33
 
102 Franz 34
extern QPixmap loadIcon(QString nam);
35
 
371 Franz 36
SideBar::SideBar(QWidget *pa) : QLabel(pa)
37
{
38
        setEraseColor(QColor(255,255,255));
39
        offs = 0;
40
        editor = 0;
372 Franz 41
        noUpdt = true;
373 Franz 42
        inRep = false;
43
        setMinimumWidth(fontMetrics().width( tr("No Style") )+30);
371 Franz 44
}
45
 
374 Franz 46
void SideBar::mouseReleaseEvent(QMouseEvent *m)
47
{
48
        CurrentPar = editor->paragraphAt(QPoint(2, m->y()+offs));
49
        pmen = new QPopupMenu();
50
        Spalette* Spal = new Spalette(this);
51
        Spal->SetFormats(editor->doc);
52
        if ((CurrentPar < static_cast<int>(editor->StyledText.count())) && (editor->StyledText.count() != 0))
53
        {
54
                if (editor->StyledText.at(CurrentPar)->count() > 0)
55
                        Spal->setFormat(editor->StyledText.at(CurrentPar)->at(0)->cab);
56
                else
57
                        Spal->setFormat(0);
58
        }
59
        else
60
                Spal->setFormat(0);
61
        connect(Spal, SIGNAL(NewStyle(int)), this, SLOT(setPStyle(int)));
62
        pmen->insertItem(Spal);
63
        pmen->exec(QCursor::pos());
64
        delete pmen;
65
}
66
 
67
void SideBar::setPStyle(int s)
68
{
69
        emit ChangeStyle(CurrentPar, s);
70
        pmen->activateItemAt(0);
71
}
72
 
371 Franz 73
void SideBar::paintEvent(QPaintEvent *e)
74
{
373 Franz 75
        inRep = true;
371 Franz 76
        QLabel::paintEvent(e);
77
        QPainter p;
78
        p.begin(this);
372 Franz 79
        if ((editor != 0) && (noUpdt))
371 Franz 80
        {
374 Franz 81
                int st = editor->CurrentABStil;
371 Franz 82
                for (int pa = 0; pa < editor->paragraphs(); ++pa)
83
                {
84
                        QRect re = editor->paragraphRect(pa);
373 Franz 85
                        if (!re.isValid())
86
                                break;
371 Franz 87
                        re.setWidth(width()-5);
88
                        re.moveBy(5, 0);
373 Franz 89
                        if (((re.y()+re.height())-offs < height()) && ((re.y()+re.height())-offs > 0))
371 Franz 90
                                p.drawLine(0, (re.y()+re.height())-offs, width()-1, (re.y()+re.height())-offs);
373 Franz 91
                        if ((re.y()-offs < height()) && (re.y()-offs > 0))
371 Franz 92
                        {
372 Franz 93
                                re.setY(re.y()-offs);
371 Franz 94
                                if ((pa < static_cast<int>(editor->StyledText.count())) && (editor->StyledText.count() != 0))
95
                                {
96
                                        if (editor->StyledText.at(pa)->count() > 0)
97
                                        {
98
                                                st = editor->StyledText.at(pa)->at(0)->cab;
99
                                                if (st < 5)
373 Franz 100
                                                        p.drawText(re, Qt::AlignLeft | Qt::AlignTop, tr("No Style"));
371 Franz 101
                                                else
102
                                                        p.drawText(re, Qt::AlignLeft | Qt::AlignTop, editor->doc->Vorlagen[st].Vname);
103
                                        }
104
                                        else
105
                                        {
373 Franz 106
                                                st = editor->ParagStyles[pa];
371 Franz 107
                                                if (st < 5)
373 Franz 108
                                                        p.drawText(re, Qt::AlignLeft | Qt::AlignTop, tr("No Style"));
371 Franz 109
                                                else
373 Franz 110
                                                        p.drawText(re, Qt::AlignLeft | Qt::AlignTop, editor->doc->Vorlagen[st].Vname);
371 Franz 111
                                        }
112
                                }
113
                                else
114
                                {
115
                                        st = editor->CurrentABStil;
116
                                        if (st < 5)
373 Franz 117
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, tr("No Style"));
371 Franz 118
                                        else
373 Franz 119
                                                p.drawText(re, Qt::AlignLeft | Qt::AlignTop, editor->doc->Vorlagen[st].Vname);
371 Franz 120
                                }
121
                        }
122
                }
123
        }
124
        p.end();
373 Franz 125
        inRep = false;
371 Franz 126
}
127
 
128
void SideBar::doMove(int x, int y)
129
{
130
        offs = y;
373 Franz 131
        if (!inRep)
132
                update();
371 Franz 133
}
134
 
135
void SideBar::doRepaint()
136
{
373 Franz 137
        if (!inRep)
138
                update();
371 Franz 139
}
140
 
372 Franz 141
void SideBar::setRepaint(bool r)
142
{
143
        noUpdt = r;
144
}
145
 
351 Franz 146
SEditor::SEditor(QWidget* parent, ScribusDoc *docc) : QTextEdit(parent)
102 Franz 147
{
351 Franz 148
        doc = docc;
353 Franz 149
        wasMod = false;
385 Franz 150
        StoredSel = false;
351 Franz 151
        StyledText.clear();
152
        StyledText.setAutoDelete(true);
373 Franz 153
        ParagStyles.clear();
362 Franz 154
        cBuffer.setAutoDelete(true);
155
        cBuffer.clear();
113 Franz 156
        setUndoRedoEnabled(true);
351 Franz 157
        setUndoDepth(0);
158
        setTextFormat(Qt::PlainText);
355 Franz 159
        viewport()->setAcceptDrops(false);
376 Franz 160
        ClipData = 0;
161
        connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
102 Franz 162
}
163
 
351 Franz 164
void SEditor::keyPressEvent(QKeyEvent *k)
113 Franz 165
{
372 Franz 166
        emit SideBarUp(false);
351 Franz 167
        int p, i;
168
        getCursorPosition(&p, &i);
169
        int KeyMod;
170
        switch (k->state())
171
        {
172
        case ShiftButton:
173
                KeyMod = 0x00200000;
174
                break;
175
        case AltButton:
176
                KeyMod = 0x00800000;
177
                break;
178
        case ControlButton:
179
                KeyMod = 0x00400000;
180
                break;
181
        default:
182
                KeyMod = 0;
183
                break;
184
        }
185
        if ((k->key() + KeyMod) == ScApp->Prefs.KeyActions[60].KeyID)
186
        {
187
                insChars(QString(QChar(30)));
188
                insert("#");
372 Franz 189
                emit SideBarUp(true);
351 Franz 190
                return;
191
        }
192
        switch (k->state())
193
        {
194
                case ControlButton:
195
                case ControlButton|ShiftButton:
196
                case ControlButton|Keypad:
197
                case ControlButton|ShiftButton|Keypad:
198
                        break;
199
                case NoButton:
200
                case Keypad:
201
                case ShiftButton:
202
                        if (UniCinp)
203
                        {
204
                                int conv = 0;
205
                                bool ok = false;
206
                                UniCinS += k->text();
207
                                conv = UniCinS.toInt(&ok, 16);
208
                                if (!ok)
209
                                {
210
                                        UniCinp = false;
211
                                        UniCinC = 0;
212
                                        UniCinS = "";
213
                                        return;
214
                                }
215
                                UniCinC++;
216
                                if (UniCinC == 4)
217
                                {
218
                                        UniCinp = false;
219
                                        UniCinC = 0;
220
                                        UniCinS = "";
221
                                        if (ok)
222
                                        {
223
                                                if (conv < 31)
224
                                                        conv = 32;
225
                                                insChars(QString(QChar(conv)));
226
                                                insert(QString(QChar(conv)));
372 Franz 227
                                                emit SideBarUp(true);
351 Franz 228
                                                return;
229
                                        }
230
                                }
231
                                else
372 Franz 232
                                {
233
                                        emit SideBarUp(true);
351 Franz 234
                                        return;
372 Franz 235
                                }
351 Franz 236
                        }
353 Franz 237
                        wasMod = false;
351 Franz 238
                        switch (k->key())
239
                        {
353 Franz 240
                                case Key_Shift:
241
                                case Key_Control:
242
                                case Key_Alt:
243
                                        wasMod = true;
244
                                        break;
351 Franz 245
                                case Key_F12:
246
                                        UniCinp = true;
247
                                        UniCinC = 0;
248
                                        UniCinS = "";
249
                                        return;
250
                                        break;
251
                                case Key_Delete:
252
                                        if (!hasSelectedText())
253
                                        {
254
                                                ChList *chars = StyledText.at(p);
255
                                                if (i < static_cast<int>(chars->count()))
256
                                                        chars->remove(i);
257
                                                else
258
                                                {
259
                                                        if (p < static_cast<int>(StyledText.count()-1))
260
                                                        {
261
                                                                struct PtiSmall *hg;
262
                                                                ChList *chars2 = StyledText.at(p+1);
263
                                                                int a = static_cast<int>(chars2->count());
264
                                                                if (a > 0)
265
                                                                {
266
                                                                        int ca;
267
                                                                        if (chars->count() > 0)
268
                                                                                ca = chars->at(0)->cab;
269
                                                                        else
270
                                                                                ca = CurrentABStil;
271
                                                                        for (int s = 0; s < a; ++s)
272
                                                                        {
273
                                                                                hg = chars2->take(0);
274
                                                                                hg->cab = ca;
275
                                                                                chars->append(hg);
276
                                                                        }
277
                                                                }
278
                                                                StyledText.remove(p+1);
373 Franz 279
                                                                ParagStyles.remove(ParagStyles.at(p+1));
351 Franz 280
                                                        }
281
                                                }
282
                                        }
283
                                        else
284
                                                deleteSel();
285
                                        break;
286
                                case Key_Backspace:
287
                                        if (!hasSelectedText())
288
                                        {
353 Franz 289
                                                if (p >= static_cast<int>(StyledText.count()))
290
                                                        break;
351 Franz 291
                                                ChList *chars = StyledText.at(p);
292
                                                if (i > 0)
293
                                                        chars->remove(i-1);
294
                                                else
295
                                                {
296
                                                        if (p > 0)
297
                                                        {
298
                                                                struct PtiSmall *hg;
299
                                                                ChList *chars2 = StyledText.at(p-1);
300
                                                                int a = static_cast<int>(chars->count());
301
                                                                if (a > 0)
302
                                                                {
303
                                                                        int ca;
304
                                                                        if (chars2->count() > 0)
305
                                                                                ca = chars2->at(0)->cab;
306
                                                                        else
307
                                                                                ca = chars->at(0)->cab;
308
                                                                        for (int s = 0; s < a; ++s)
309
                                                                        {
310
                                                                                hg = chars->take(0);
311
                                                                                hg->cab = ca;
312
                                                                                chars2->append(hg);
313
                                                                        }
314
                                                                }
315
                                                                StyledText.remove(p);
373 Franz 316
                                                                ParagStyles.remove(ParagStyles.at(p));
351 Franz 317
                                                        }
318
                                                }
319
                                        }
320
                                        else
321
                                                deleteSel();
322
                                        break;
323
                                case Key_Return:
324
                                case Key_Enter:
325
                                        {
326
                                                if (hasSelectedText())
327
                                                        deleteSel();
328
                                                ChList *chars;
329
                                                chars = new ChList;
330
                                                chars->setAutoDelete(true);
331
                                                chars->clear();
332
                                                if (StyledText.count() != 0)
333
                                                {
353 Franz 334
                                                        if (p >= static_cast<int>(StyledText.count()))
373 Franz 335
                                                        {
353 Franz 336
                                                                StyledText.append(chars);
373 Franz 337
                                                                ParagStyles.append(CurrentABStil);
338
                                                        }
353 Franz 339
                                                        else
340
                                                        {
351 Franz 341
                                                        ChList *chars2 = StyledText.at(p);
342
                                                        int a = static_cast<int>(chars2->count());
343
                                                        for (int s = i; s < a; ++s)
344
                                                        {
345
                                                                chars->append(chars2->take(i));
346
                                                        }
347
                                                        StyledText.insert(p+1, chars);
373 Franz 348
                                                        ParagStyles.insert(ParagStyles.at(p+1), CurrentABStil);
353 Franz 349
                                                        }
351 Franz 350
                                                }
351
                                                else
373 Franz 352
                                                {
351 Franz 353
                                                        StyledText.append(chars);
373 Franz 354
                                                        ParagStyles.append(CurrentABStil);
355
                                                }
351 Franz 356
                                        }
357
                                        break;
358
                                case Key_Left:
359
                                case Key_Right:
360
                                case Key_Prior:
361
                                case Key_Next:
362
                                case Key_Up:
363
                                case Key_Down:
364
                                case Key_Home:
365
                                case Key_End:
366
                                        break;
367
                                default:
368
                                        if (k->text() != "")
369
                                                insChars(k->text());
370
                                        break;
371
                        }
372
                        break;
373
                default:
374
                        break;
375
        }
376
        QTextEdit::keyPressEvent(k);
372 Franz 377
        emit SideBarUp(true);
378
        emit SideBarUpdate();
113 Franz 379
}
380
 
385 Franz 381
void SEditor::focusOutEvent(QFocusEvent *e)
382
{
383
        if (hasSelectedText())
384
        {
385
                getSelection(&SelParaStart, &SelCharStart, &SelParaEnd, &SelCharEnd);
386
                StoredSel = true;
387
        }
388
        else
389
                StoredSel = false;
390
        QTextEdit::focusOutEvent(e);
391
}
392
 
351 Franz 393
void SEditor::insChars(QString t)
102 Franz 394
{
376 Franz 395
        int p, i, p2, ccab;
351 Franz 396
        if (hasSelectedText())
397
                deleteSel();
357 Franz 398
        getCursorPosition(&p, &i);
351 Franz 399
        ChList *chars;
376 Franz 400
        p2 = p;
351 Franz 401
        if ((p >= static_cast<int>(StyledText.count())) || (StyledText.count() == 0))
253 Franz 402
        {
351 Franz 403
                chars = new ChList;
404
                chars->setAutoDelete(true);
405
                chars->clear();
376 Franz 406
                p2 = static_cast<int>(StyledText.count());
382 Franz 407
                StyledText.append(chars);
408
                ParagStyles.append(CurrentABStil);
351 Franz 409
        }
410
        else
411
                chars = StyledText.at(p);
376 Franz 412
        if (chars->count() != 0)
413
                ccab = chars->at(0)->cab;
414
        else
415
                ccab = CurrentABStil;
351 Franz 416
        for (uint a = 0; a < t.length(); ++a)
417
        {
376 Franz 418
                if (t[a] == QChar(13))
419
                {
420
                        ChList *chars2;
421
                        chars2 = new ChList;
422
                        chars2->setAutoDelete(true);
423
                        chars2->clear();
424
                        if (p2 >= static_cast<int>(StyledText.count()))
425
                        {
426
                                StyledText.append(chars2);
427
                                ParagStyles.append(ccab);
428
                        }
429
                        else
430
                        {
431
                                int a = static_cast<int>(chars->count());
432
                                for (int s = i; s < a; ++s)
433
                                {
434
                                        chars2->append(chars->take(i));
435
                                }
436
                                StyledText.insert(p2+1, chars2);
437
                                ParagStyles.insert(ParagStyles.at(p2+1), ccab);
438
                        }
439
                        p2++;
440
                        chars = StyledText.at(p2);
441
                        i = 0;
442
                }
443
                else
444
                {
445
                        struct PtiSmall *hg;
446
                        hg = new PtiSmall;
447
                        hg->ch = t[a];
448
                        hg->ccolor = CurrTextFill;
449
                        hg->cshade = CurrTextFillSh;
450
                        hg->cstroke = CurrTextStroke;
451
                        hg->cshade2 = CurrTextStrokeSh;
452
                        hg->cfont = CurrFont;
453
                        hg->csize = CurrFontSize;
454
                        hg->cstyle = CurrentStyle;
455
                        hg->cab = ccab;
456
                        hg->cextra = CurrTextKern;
457
                        hg->cscale = CurrTextScale;
458
                        chars->insert(i, hg);
459
                        i++;
460
                }
351 Franz 461
        }
462
}
463
 
362 Franz 464
void SEditor::insStyledText()
465
{
466
        if (cBuffer.count() == 0)
467
                return;
468
        int p, i, p2, ccab;
469
        if (hasSelectedText())
470
                deleteSel();
471
        getCursorPosition(&p, &i);
472
        ChList *chars;
473
        p2 = p;
474
        if ((p >= static_cast<int>(StyledText.count())) || (StyledText.count() == 0))
475
        {
476
                chars = new ChList;
477
                chars->setAutoDelete(true);
478
                chars->clear();
479
                p2 = static_cast<int>(StyledText.count());
382 Franz 480
                StyledText.append(chars);
481
                ParagStyles.append(CurrentABStil);
362 Franz 482
        }
483
        else
484
                chars = StyledText.at(p);
485
        if (chars->count() != 0)
486
                ccab = chars->at(0)->cab;
487
        else
488
                ccab = CurrentABStil;
489
        for (uint a = 0; a < cBuffer.count()-1; ++a)
490
        {
491
                struct PtiSmall *hg;
492
                if (cBuffer.at(a)->ch == QChar(13))
493
                {
494
                        ChList *chars2;
495
                        chars2 = new ChList;
496
                        chars2->setAutoDelete(true);
497
                        chars2->clear();
498
                        if (p2 >= static_cast<int>(StyledText.count()))
373 Franz 499
                        {
362 Franz 500
                                StyledText.append(chars2);
373 Franz 501
                                ParagStyles.append(ccab);
502
                        }
362 Franz 503
                        else
504
                        {
505
                                int a = static_cast<int>(chars->count());
506
                                for (int s = i; s < a; ++s)
507
                                {
508
                                        chars2->append(chars->take(i));
509
                                }
510
                                StyledText.insert(p2+1, chars2);
373 Franz 511
                                ParagStyles.insert(ParagStyles.at(p2+1), ccab);
362 Franz 512
                        }
513
                        p2++;
514
                        chars = StyledText.at(p2);
515
                        i = 0;
516
                }
517
                else
518
                {
519
                        hg = new PtiSmall;
520
                        hg->ch = cBuffer.at(a)->ch;
521
                        hg->ccolor = cBuffer.at(a)->ccolor;
522
                        hg->cshade = cBuffer.at(a)->cshade;
523
                        hg->cstroke = cBuffer.at(a)->cstroke;
524
                        hg->cshade2 = cBuffer.at(a)->cshade2;
525
                        hg->cfont = cBuffer.at(a)->cfont;
526
                        hg->csize = cBuffer.at(a)->csize;
527
                        hg->cstyle = cBuffer.at(a)->cstyle;
528
                        hg->cab = ccab;
529
                        hg->cextra = cBuffer.at(a)->cextra;
530
                        hg->cscale = cBuffer.at(a)->cscale;
531
                        chars->insert(i, hg);
532
                        i++;
533
                }
534
        }
535
}
536
 
537
void SEditor::copyStyledText()
538
{
539
        int PStart, PEnd, SelStart, SelEnd, start, end;
540
        ChList *chars;
541
        struct PtiSmall *hg;
542
        cBuffer.clear();
543
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
544
        for (int pa = PStart; pa < PEnd+1; ++pa)
545
        {
546
                chars = StyledText.at(pa);
547
                if (pa == PStart)
548
                        start = SelStart;
549
                else
550
                        start = 0;
551
                if (pa == PEnd)
552
                        end = SelEnd;
553
                else
554
                        end = chars->count();
555
                for (int ca = start; ca < end; ++ca)
556
                {
557
                        hg = new PtiSmall;
558
                        hg->ch = chars->at(ca)->ch;
559
                        hg->cfont = chars->at(ca)->cfont;
560
                        hg->csize = chars->at(ca)->csize;
561
                        hg->ccolor = chars->at(ca)->ccolor;
562
                        hg->cshade = chars->at(ca)->cshade;
563
                        hg->cstroke = chars->at(ca)->cstroke;
564
                        hg->cshade2 = chars->at(ca)->cshade2;
565
                        hg->cscale = chars->at(ca)->cscale;
566
                        hg->cstyle = chars->at(ca)->cstyle;
567
                        hg->cab = chars->at(ca)->cab;
568
                        hg->cextra = chars->at(ca)->cextra;
569
                        cBuffer.append(hg);
570
                }
571
                hg = new PtiSmall;
572
                hg->ch = QChar(13);
573
                hg->cfont = "";
574
                hg->csize = 1;
575
                hg->ccolor = "";
576
                hg->cshade = 1;
577
                hg->cstroke = "";
578
                hg->cshade2 = 1;
579
                hg->cscale = 0;
580
                hg->cstyle = 0;
581
                hg->cab = 0;
582
                hg->cextra = 0;
583
                cBuffer.append(hg);
584
        }
585
}
586
 
351 Franz 587
void SEditor::saveItemText(PageItem* b)
588
{
589
        ChList *chars;
590
        b->CPos = 0;
591
        b->Ptext.clear();
592
        uint c = 0;
593
        for (uint p = 0; p < StyledText.count(); ++p)
594
        {
595
                if (p != 0)
253 Franz 596
                {
351 Franz 597
                        c = StyledText.at(p-1)->count()-1;
598
                        struct Pti *hg;
599
                        hg = new Pti;
600
                        hg->ch = QChar(13);
392 Franz 601
                        chars = StyledText.at(p-1);
351 Franz 602
                        if (chars->count() != 0)
253 Franz 603
                        {
351 Franz 604
                                hg->cfont = chars->at(c)->cfont;
605
                                hg->csize = chars->at(c)->csize;
606
                                hg->ccolor = chars->at(c)->ccolor;
607
                                hg->cshade = chars->at(c)->cshade;
608
                                hg->cstroke = chars->at(c)->cstroke;
609
                                hg->cshade2 = chars->at(c)->cshade2;
610
                                hg->cscale = chars->at(c)->cscale;
611
                                hg->cstyle = chars->at(c)->cstyle;
612
                                hg->cextra = chars->at(c)->cextra;
253 Franz 613
                        }
351 Franz 614
                        else
615
                        {
616
                                hg->ccolor = CurrTextFill;
617
                                hg->cshade = CurrTextFillSh;
618
                                hg->cstroke = CurrTextStroke;
619
                                hg->cshade2 = CurrTextStrokeSh;
620
                                hg->cfont = CurrFont;
621
                                hg->csize = CurrFontSize;
622
                                hg->cstyle = CurrentStyle;
623
                                hg->cextra = CurrTextKern;
624
                                hg->cscale = CurrTextScale;
392 Franz 625
                                if (doc->Vorlagen[ParagStyles[p-1]].Font != "")
351 Franz 626
                                {
392 Franz 627
                                        hg->cfont = doc->Vorlagen[ParagStyles[p-1]].Font;
628
                                        hg->csize = doc->Vorlagen[ParagStyles[p-1]].FontSize;
351 Franz 629
                                }
630
                        }
392 Franz 631
                        hg->cab = ParagStyles[p-1];
351 Franz 632
                        hg->cselect = false;
633
                        hg->xp = 0;
634
                        hg->yp = 0;
635
                        hg->PRot = 0;
636
                        hg->PtransX = 0;
637
                        hg->PtransY = 0;
638
                        b->Ptext.append(hg);
253 Franz 639
                }
351 Franz 640
                chars = StyledText.at(p);
641
                for (uint c = 0; c < chars->count(); ++c)
642
                {
643
                        struct Pti *hg;
644
                        hg = new Pti;
645
                        hg->ch = chars->at(c)->ch;
646
                        hg->cfont = chars->at(c)->cfont;
647
                        hg->csize = chars->at(c)->csize;
648
                        hg->ccolor = chars->at(c)->ccolor;
649
                        hg->cshade = chars->at(c)->cshade;
650
                        hg->cstroke = chars->at(c)->cstroke;
651
                        hg->cshade2 = chars->at(c)->cshade2;
652
                        hg->cscale = chars->at(c)->cscale;
653
                        hg->cstyle = chars->at(c)->cstyle;
654
                        hg->cab = chars->at(c)->cab;
655
                        hg->cextra = chars->at(c)->cextra;
656
                        hg->cselect = false;
657
                        hg->xp = 0;
658
                        hg->yp = 0;
659
                        hg->PRot = 0;
660
                        hg->PtransX = 0;
661
                        hg->PtransY = 0;
662
                        b->Ptext.append(hg);
663
                }
253 Franz 664
        }
351 Franz 665
}
666
 
667
void SEditor::setAlign(int style)
668
{
669
        int align = 0;
670
        if (style > 4)
671
                align = doc->Vorlagen[style].Ausri;
672
        else
673
                align = style;
674
        switch (align)
167 Franz 675
        {
351 Franz 676
        case 0:
677
                setAlignment(Qt::AlignLeft);
678
                break;
679
        case 1:
680
                setAlignment(Qt::AlignCenter);
681
                break;
682
        case 2:
683
                setAlignment(Qt::AlignRight);
684
                break;
685
        case 3:
686
        case 4:
687
                setAlignment(Qt::AlignJustify);
688
                break;
689
        default:
690
                break;
167 Franz 691
        }
351 Franz 692
}
693
 
694
void SEditor::loadItemText(PageItem* b)
695
{
696
        struct PtiSmall *hg;
697
        QString Text = "";
698
        QString Ccol = "";
699
        int Csha;
700
        int Csty;
701
        int Ali = 0;
702
        PageItem *nb = b;
703
        StyledText.clear();
373 Franz 704
        ParagStyles.clear();
351 Franz 705
        ChList *chars;
706
        chars = new ChList;
707
        chars->setAutoDelete(true);
708
        chars->clear();
709
        while (nb != 0)
167 Franz 710
        {
351 Franz 711
                if (nb->BackBox != 0)
712
                        nb = nb->BackBox;
713
                else
714
                        break;
167 Franz 715
        }
351 Franz 716
        if (nb != 0)
253 Franz 717
        {
351 Franz 718
                if (nb->Ptext.count() != 0)
719
                {
720
                        Ccol = nb->Ptext.at(0)->ccolor;
721
                        Csha = nb->Ptext.at(0)->cshade;
722
                        Csty = nb->Ptext.at(0)->cstyle;
723
                        Ali = nb->Ptext.at(0)->cab;
724
                }
725
                else
726
                {
727
                        Ccol = b->TxtFill;
728
                        Csha = b->ShTxtFill;
729
                        Csha = b->TxTStyle;
730
                        Ali = b->Ausrich;
731
                }
732
                setAlign(Ali);
733
                setFarbe(Ccol, Csha);
734
                setStyle(Csty);
253 Franz 735
        }
351 Franz 736
        while (nb != 0)
737
        {
738
                for (uint a = 0; a < nb->Ptext.count(); ++a)
739
                {
740
                        if (nb->Ptext.at(a)->ch == QChar(13))
741
                        {
742
                                StyledText.append(chars);
373 Franz 743
                                ParagStyles.append(Ali);
351 Franz 744
                                chars = new ChList;
745
                                chars->setAutoDelete(true);
746
                                chars->clear();
747
                                Text += "\n";
748
                        }
749
                        else
750
                        {
751
                                hg = new PtiSmall;
752
                                hg->ch = nb->Ptext.at(a)->ch;
753
                                hg->cfont = nb->Ptext.at(a)->cfont;
754
                                hg->csize = nb->Ptext.at(a)->csize;
755
                                hg->ccolor = nb->Ptext.at(a)->ccolor;
756
                                hg->cshade = nb->Ptext.at(a)->cshade;
757
                                hg->cstroke = nb->Ptext.at(a)->cstroke;
758
                                hg->cshade2 = nb->Ptext.at(a)->cshade2;
759
                                hg->cscale = nb->Ptext.at(a)->cscale;
760
                                hg->cstyle = nb->Ptext.at(a)->cstyle;
761
                                hg->cab = nb->Ptext.at(a)->cab;
762
                                hg->cextra = nb->Ptext.at(a)->cextra;
763
                                if ((Ccol == hg->ccolor) && (Ali == hg->cab) && (Csha == hg->cshade) && (Csty == hg->cstyle))
764
                                {
765
                                        if (hg->ch == QChar(30))
766
                                        {
767
                                                setFarbe(Ccol, Csha);
768
                                                setAlign(Ali);
769
                                                setStyle(Csty);
770
                                                insert(Text);
771
                                                insert("#");
772
                                                Text = "";
773
                                                chars->append(hg);
774
                                                continue;
775
                                        }
776
                                        else
777
                                                Text += hg->ch;
778
                                }
779
                                else
780
                                {
781
                                        setFarbe(Ccol, Csha);
782
                                        setAlign(Ali);
783
                                        setStyle(Csty);
784
                                        insert(Text);
785
                                        Text = hg->ch;
786
                                        Ccol = hg->ccolor;
787
                                        Csha = hg->cshade;
788
                                        Csty = hg->cstyle;
789
                                        Ali = hg->cab;
790
                                }
791
                                chars->append(hg);
792
                        }
793
                }
794
                nb = nb->NextBox;
795
        }
796
        setAlign(Ali);
797
        setFarbe(Ccol, Csha);
798
        setStyle(Csty);
799
        insert(Text);
800
        if (chars->count() != 0)
373 Franz 801
        {
351 Franz 802
                StyledText.append(chars);
373 Franz 803
                ParagStyles.append(Ali);
804
        }
351 Franz 805
        if (StyledText.count() != 0)
806
                emit setProps(0, 0);
807
        setCursorPosition(0, 0);
102 Franz 808
}
809
 
351 Franz 810
void SEditor::loadText(QString tx, PageItem* b)
102 Franz 811
{
351 Franz 812
        struct PtiSmall *hg;
813
        QString Text = "";
814
        StyledText.clear();
373 Franz 815
        ParagStyles.clear();
351 Franz 816
        ChList *chars;
817
        chars = new ChList;
818
        chars->setAutoDelete(true);
819
        chars->clear();
820
        setAlign(b->Ausrich);
821
        setFarbe(b->TxtFill, b->ShTxtFill);
822
        setStyle(b->TxTStyle);
823
        for (uint a = 0; a < tx.length(); ++a)
824
        {
825
                if (tx[a] == QChar(13))
826
                {
827
                        StyledText.append(chars);
373 Franz 828
                        ParagStyles.append(b->Ausrich);
351 Franz 829
                        chars = new ChList;
830
                        chars->setAutoDelete(true);
831
                        chars->clear();
832
                        Text += "\n";
833
                }
834
                else
835
                {
836
                        hg = new PtiSmall;
837
                        hg->ch = tx[a];
838
                        hg->cfont = b->IFont;
839
                        hg->csize = b->ISize;
840
                        hg->ccolor = b->TxtFill;
841
                        hg->cshade = b->ShTxtFill;
842
                        hg->cstroke = b->TxtStroke;
843
                        hg->cshade2 = b->ShTxtStroke;
844
                        hg->cscale = b->TxtScale;
845
                        hg->cstyle = b->TxTStyle;
846
                        hg->cab = b->Ausrich;
847
                        hg->cextra = 0;
848
                        Text += hg->ch;
849
                        chars->append(hg);
850
                }
851
        }
852
        insert(Text);
853
        if (chars->count() != 0)
373 Franz 854
        {
351 Franz 855
                StyledText.append(chars);
373 Franz 856
                ParagStyles.append(b->Ausrich);
857
        }
351 Franz 858
        if (StyledText.count() != 0)
859
                emit setProps(0, 0);
860
        setCursorPosition(0, 0);
102 Franz 861
}
862
 
366 Franz 863
void SEditor::updateAll()
864
{
865
        if (StyledText.count() == 0)
866
                return;
867
        int p, i;
868
        getCursorPosition(&p, &i);
869
        clear();
870
        struct PtiSmall *hg;
871
        QString Text = "";
872
        QString Ccol = "";
873
        int Csha;
874
        int Csty;
875
        int Ali = 0;
876
        ChList *chars = StyledText.at(0);
877
        if (chars->count() != 0)
878
        {
879
                Ccol = chars->at(0)->ccolor;
880
                Csha = chars->at(0)->cshade;
881
                Csty = chars->at(0)->cstyle;
882
                Ali = chars->at(0)->cab;
883
        }
884
        else
885
        {
886
                Ccol = CurrTextFill;
887
                Csha = CurrTextFillSh;
888
                Csty = CurrentStyle;
889
                Ali = CurrentABStil;
890
        }
891
        setAlign(Ali);
892
        setFarbe(Ccol, Csha);
893
        setStyle(Csty);
894
        for (uint pa = 0; pa < StyledText.count(); ++pa)
895
        {
896
                chars = StyledText.at(pa);
897
                if ((chars->count() == 0) && (pa < StyledText.count()-1))
898
                {
899
                        Text += "\n";
900
                        continue;
901
                }
902
                for (uint a = 0; a < chars->count(); ++a)
903
                {
904
                        hg = chars->at(a);
905
                        if ((Ccol == hg->ccolor) && (Ali == hg->cab) && (Csha == hg->cshade) && (Csty == hg->cstyle))
906
                        {
907
                                if (hg->ch == QChar(30))
908
                                {
909
                                        setFarbe(Ccol, Csha);
910
                                        setAlign(Ali);
911
                                        setStyle(Csty);
912
                                        insert(Text);
913
                                        insert("#");
914
                                        Text = "";
915
                                        continue;
916
                                }
917
                                else
918
                                        Text += hg->ch;
919
                        }
920
                        else
921
                        {
922
                                setFarbe(Ccol, Csha);
923
                                setAlign(Ali);
924
                                setStyle(Csty);
925
                                insert(Text);
926
                                Text = hg->ch;
927
                                Ccol = hg->ccolor;
928
                                Csha = hg->cshade;
929
                                Csty = hg->cstyle;
930
                                Ali = hg->cab;
931
                        }
932
                }
933
                if (pa < StyledText.count()-1)
934
                        Text += "\n";
935
        }
936
        setAlign(Ali);
937
        setFarbe(Ccol, Csha);
938
        setStyle(Csty);
939
        insert(Text);
940
        setCursorPosition(p, i);
941
}
942
 
351 Franz 943
void SEditor::updateFromChars(int pa)
102 Franz 944
{
351 Franz 945
        ChList *chars = StyledText.at(pa);
946
        if (chars->count() == 0)
947
                return;
948
        int SelStart = 0;
949
        int SelEnd = 0;
950
        int p, i;
951
        getCursorPosition(&p, &i);
952
        removeSelection();
953
        QString Ccol = chars->at(0)->ccolor;
954
        int Csha = chars->at(0)->cshade;
955
        int Csty = chars->at(0)->cstyle;
956
        for (uint a = 0; a < chars->count(); ++a)
167 Franz 957
        {
351 Franz 958
                if ((Ccol == chars->at(a)->ccolor) && (Csha == chars->at(a)->cshade) && (Csty == chars->at(a)->cstyle))
959
                        SelEnd++;
960
                else
167 Franz 961
                {
351 Franz 962
                        setSelection(pa, SelStart, pa, SelEnd);
963
                        setFarbe(Ccol, Csha);
964
                        setStyle(Csty);
965
                        removeSelection();
966
                        Ccol = chars->at(a)->ccolor;
967
                        Csha = chars->at(a)->cshade;
968
                        Csty = chars->at(a)->cstyle;
362 Franz 969
                        SelStart = SelEnd;
351 Franz 970
                        SelEnd++;
167 Franz 971
                }
351 Franz 972
        }
973
        setSelection(pa, SelStart, pa, SelEnd);
974
        setFarbe(Ccol, Csha);
975
        setStyle(Csty);
976
        removeSelection();
362 Franz 977
        setAlign(chars->at(0)->cab);
351 Franz 978
        setCursorPosition(p, i);
979
}
980
 
981
/* updates the internal PtiSmall structure, to be useable for all members of the PtiSmall struct
982
   there is a code as first parameter to indicate which member should be updated.
983
 
984
        1 = Stroke Colour and Stroke Shade
985
        2 = Font
986
        3 = Font Size
987
        4 = Character Style
988
        5 = Character Scaling
989
        6 = Kerning
990
 */
991
void SEditor::updateSel(int code, struct PtiSmall *hg)
992
{
993
        int PStart, PEnd, SelStart, SelEnd, start, end;
994
        ChList *chars;
385 Franz 995
        if (StoredSel)
996
        {
997
                setSelection(SelParaStart, SelCharStart, SelParaEnd, SelCharEnd);
998
                StoredSel = false;
999
        }
351 Franz 1000
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
1001
        for (int pa = PStart; pa < PEnd+1; ++pa)
1002
        {
1003
                chars = StyledText.at(pa);
1004
                if (pa == PStart)
1005
                        start = SelStart;
1006
                else
1007
                        start = 0;
1008
                if (pa == PEnd)
1009
                        end = SelEnd;
1010
                else
1011
                        end = chars->count();
1012
                for (int ca = start; ca < end; ++ca)
167 Franz 1013
                {
351 Franz 1014
                        switch (code)
167 Franz 1015
                        {
351 Franz 1016
                                case 0:
1017
                                        chars->at(ca)->ccolor = hg->ccolor;
1018
                                        chars->at(ca)->cshade = hg->cshade;
1019
                                        break;
217 Franz 1020
                                case 1:
351 Franz 1021
                                        chars->at(ca)->cstroke = hg->cstroke;
1022
                                        chars->at(ca)->cshade2 = hg->cshade2;
111 Franz 1023
                                        break;
217 Franz 1024
                                case 2:
351 Franz 1025
                                        chars->at(ca)->cfont = hg->cfont;
217 Franz 1026
                                        break;
1027
                                case 3:
351 Franz 1028
                                        chars->at(ca)->csize = hg->csize;
111 Franz 1029
                                        break;
351 Franz 1030
                                case 4:
1031
                                        chars->at(ca)->cstyle &= ~127;
1032
                                        chars->at(ca)->cstyle |= hg->cstyle;
102 Franz 1033
                                        break;
351 Franz 1034
                                case 5:
1035
                                        chars->at(ca)->cscale = hg->cscale;
102 Franz 1036
                                        break;
351 Franz 1037
                                case 6:
1038
                                        chars->at(ca)->cextra = hg->cextra;
102 Franz 1039
                                        break;
351 Franz 1040
                                default:
1041
                                        break;
167 Franz 1042
                        }
102 Franz 1043
                }
167 Franz 1044
        }
102 Franz 1045
}
1046
 
351 Franz 1047
void SEditor::deleteSel()
102 Franz 1048
{
351 Franz 1049
        int PStart, PEnd, SelStart, SelEnd, start, end;
1050
        ChList *chars;
1051
        getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
1052
        if (PStart == PEnd)
1053
        {
1054
                chars = StyledText.at(PStart);
1055
                for (int a = 0; a < SelEnd-SelStart; ++a)
1056
                {
1057
                        chars->remove(SelStart);
1058
                }
1059
        }
1060
        else
1061
        {
1062
                for (int pa = PStart; pa < PEnd+1; ++pa)
1063
                {
367 Franz 1064
                        bool noChar = false;
1065
                        if (pa >= static_cast<int>(StyledText.count()))
1066
                                noChar = true;
1067
                        else
1068
                                chars = StyledText.at(pa);
351 Franz 1069
                        if (pa == PStart)
1070
                                start = SelStart;
1071
                        else
1072
                                start = 0;
1073
                        if (pa == PEnd)
1074
                                end = SelEnd;
1075
                        else
1076
                        {
367 Franz 1077
                                if (noChar)
1078
                                        end = 0;
1079
                                else
1080
                                        end = chars->count();
351 Franz 1081
                        }
367 Franz 1082
                        if (!noChar)
1083
                        {
1084
                                for (int ca = 0; ca < end-start; ++ca)
1085
                                {
1086
                                        chars->remove(start);
1087
                                }
1088
                        }
351 Franz 1089
                }
1090
                if (PEnd-PStart > 1)
1091
                {
1092
                        for (int pa2 = 0; pa2 < PEnd - PStart - 1; ++pa2)
1093
                        {
367 Franz 1094
                                if (PStart+1 < static_cast<int>(StyledText.count()))
373 Franz 1095
                                {
367 Franz 1096
                                        StyledText.remove(PStart+1);
373 Franz 1097
                                        ParagStyles.remove(ParagStyles.at(PStart+1));
1098
                                }
351 Franz 1099
                        }
1100
                }
367 Franz 1101
                if (PStart+1 < static_cast<int>(StyledText.count()))
351 Franz 1102
                {
367 Franz 1103
                        struct PtiSmall *hg;
1104
                        ChList *chars2 = StyledText.at(PStart+1);
1105
                        chars = StyledText.at(PStart);
1106
                        int a = static_cast<int>(chars2->count());
1107
                        if (a > 0)
351 Franz 1108
                        {
367 Franz 1109
                                int ca;
1110
                                if (chars->count() > 0)
1111
                                        ca = chars->at(0)->cab;
1112
                                else
1113
                                        ca = CurrentABStil;
1114
                                for (int s = 0; s < a; ++s)
1115
                                {
1116
                                        hg = chars2->take(0);
1117
                                        hg->cab = ca;
1118
                                        chars->append(hg);
1119
                                }
351 Franz 1120
                        }
367 Franz 1121
                        StyledText.remove(PStart+1);
373 Franz 1122
                        ParagStyles.remove(ParagStyles.at(PStart+1));
351 Franz 1123
                }
1124
        }
1125
        setCursorPosition(PStart, SelStart);
102 Franz 1126
}
1127
 
351 Franz 1128
void SEditor::setStyle(int Csty)
102 Franz 1129
{
351 Franz 1130
        if (Csty & 8)
1131
                setUnderline(true);
1132
        else
1133
                setUnderline(false);
374 Franz 1134
        QFont f = currentFont();
1135
        if (Csty & 16)
1136
                f.setStrikeOut(true);
1137
        else
1138
                f.setStrikeOut(false);
1139
        setCurrentFont(f);
351 Franz 1140
        if (Csty & 1)
1141
                setVerticalAlignment(AlignSuperScript);
1142
        else if (Csty & 2)
1143
                setVerticalAlignment(AlignSubScript);
1144
        else
1145
                setVerticalAlignment(AlignNormal);
1146
}
1147
 
1148
void SEditor::setFarbe(QString farbe, int shad)
1149
{
1150
        int h, s, v, sneu;
1151
        QColor tmp;
1152
        doc->PageColors[farbe].getRGBColor().rgb(&h, &s, &v);
1153
        if ((h == s) && (s == v))
191 Franz 1154
        {
351 Franz 1155
                doc->PageColors[farbe].getRGBColor().hsv(&h, &s, &v);
1156
                sneu = 255 - ((255 - v) * shad / 100);
1157
                tmp.setHsv(h, s, sneu);
191 Franz 1158
        }
351 Franz 1159
        else
1160
        {
1161
                doc->PageColors[farbe].getRGBColor().hsv(&h, &s, &v);
1162
                sneu = s * shad / 100;
1163
                tmp.setHsv(h, sneu, v);
1164
        }
1165
        setColor(tmp);
1166
}
103 Franz 1167
 
362 Franz 1168
void SEditor::copy()
1169
{
372 Franz 1170
        emit SideBarUp(false);
362 Franz 1171
        if ((hasSelectedText()) && (selectedText() != ""))
1172
        {
376 Franz 1173
                disconnect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
362 Franz 1174
                tBuffer = selectedText();
1175
                copyStyledText();
376 Franz 1176
                QApplication::clipboard()->setText(tBuffer, QClipboard::Clipboard);
1177
                ClipData = 1;
1178
                connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
1179
                emit PasteAvail();
362 Franz 1180
        }
372 Franz 1181
        emit SideBarUp(true);
362 Franz 1182
}
1183
 
351 Franz 1184
void SEditor::cut()
1185
{
362 Franz 1186
        copy();
372 Franz 1187
        emit SideBarUp(false);
362 Franz 1188
        if (hasSelectedText())
1189
        {
1190
                deleteSel();
1191
                removeSelectedText();
1192
        }
372 Franz 1193
        emit SideBarUp(true);
1194
        emit SideBarUpdate();
351 Franz 1195
}
1196
 
1197
void SEditor::paste()
1198
{
372 Franz 1199
        emit SideBarUp(false);
362 Franz 1200
        int p, i;
1201
        getCursorPosition(&p, &i);
376 Franz 1202
        if (ClipData == 2)
1203
        {
1204
                QString data = QApplication::clipboard()->text(QClipboard::Clipboard);
1205
                if (!data.isNull())
1206
                {
1207
                        data.replace(QRegExp("\r"), "");
1208
                        data.replace(QRegExp("\n"), QChar(13));
1209
                        insChars(data);
1210
                }
1211
        }
1212
        else
1213
                insStyledText();
374 Franz 1214
        updateAll();
372 Franz 1215
        emit SideBarUp(true);
1216
        emit SideBarUpdate();
351 Franz 1217
}
1218
 
374 Franz 1219
QPopupMenu* SEditor::createPopupMenu(const QPoint & pos)
1220
{
1221
        QPopupMenu *p = QTextEdit::createPopupMenu(pos);
1222
        p->removeItemAt(0);
1223
        p->removeItemAt(0);
1224
        p->removeItemAt(0);
1225
        p->removeItemAt(3);
1226
        return p;
1227
}
1228
 
376 Franz 1229
void SEditor::ClipChange()
1230
{
1231
        ClipData = 2;
1232
        emit PasteAvail();
1233
}
1234
 
351 Franz 1235
/* Toolbar for Fill Colour */
352 Franz 1236
SToolBColorF::SToolBColorF(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Fill Color Settings"), parent)
351 Franz 1237
{
1238
        FillIcon = new QLabel( "", this, "FillIcon" );
1239
        FillIcon->setPixmap(loadIcon("fill.png"));
1240
        FillIcon->setScaledContents( false );
1241
        TxFill = new QComboBox( true, this, "TxFill" );
1242
        TxFill->setEditable(false);
1243
        PM2 = new ShadeButton(this);
1244
        TxFill->clear();
1245
        CListe::Iterator it;
1246
        QPixmap pm = QPixmap(15, 15);
1247
        TxFill->insertItem( tr("None"));
1248
        for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1249
        {
1250
                pm.fill(doc->PageColors[it.key()].getRGBColor());
1251
                TxFill->insertItem(pm, it.key());
1252
        }
1253
        TxFill->listBox()->setMinimumWidth(TxFill->listBox()->maxItemWidth()+24);
1254
        QToolTip::add( TxFill, tr( "Color of text fill" ) );
1255
        QToolTip::add( PM2, tr( "Saturation of color of text fill" ) );
1256
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1257
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1258
}
1259
 
1260
void SToolBColorF::SetColor(int c)
1261
{
1262
        disconnect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1263
        TxFill->setCurrentItem(c);
1264
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1265
}
1266
 
1267
void SToolBColorF::SetShade(int s)
1268
{
1269
        disconnect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1270
        PM2->setValue(s);
1271
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1272
}
1273
 
1274
void SToolBColorF::newShadeHandler()
1275
{
1276
        emit NewColor(TxFill->currentItem(), PM2->getValue());
1277
}
1278
 
1279
/* Toolbar for Stroke Colour */
352 Franz 1280
SToolBColorS::SToolBColorS(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Stroke Color Settings"), parent)
351 Franz 1281
{
1282
        StrokeIcon = new QLabel( "", this, "StrokeIcon" );
1283
        StrokeIcon->setPixmap(loadIcon("Stiftalt.xpm"));
1284
        StrokeIcon->setScaledContents( false );
1285
        TxStroke = new QComboBox( true, this, "TxStroke" );
1286
        TxStroke->setEditable(false);
1287
        PM1 = new ShadeButton(this);
1288
        TxStroke->clear();
1289
        CListe::Iterator it;
1290
        QPixmap pm = QPixmap(15, 15);
1291
        TxStroke->insertItem( tr("None"));
1292
        for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1293
        {
1294
                pm.fill(doc->PageColors[it.key()].getRGBColor());
1295
                TxStroke->insertItem(pm, it.key());
1296
        }
1297
        TxStroke->listBox()->setMinimumWidth(TxStroke->listBox()->maxItemWidth()+24);
1298
        QToolTip::add( TxStroke, tr( "Color of text stroke" ) );
1299
        QToolTip::add( PM1, tr( "Saturation of color of text stroke" ) );
1300
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1301
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1302
}
1303
 
1304
void SToolBColorS::SetColor(int c)
1305
{
1306
        disconnect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1307
        TxStroke->setCurrentItem(c);
1308
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1309
}
1310
 
1311
void SToolBColorS::SetShade(int s)
1312
{
1313
        disconnect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1314
        PM1->setValue(s);
1315
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1316
}
1317
 
1318
void SToolBColorS::newShadeHandler()
1319
{
1320
        emit NewColor(TxStroke->currentItem(), PM1->getValue());
1321
}
1322
 
1323
/* Toolbar for Character Style Settings */
352 Franz 1324
SToolBStyle::SToolBStyle(QMainWindow* parent) : QToolBar( tr("Character Settings"), parent)
351 Franz 1325
{
1326
        SeStyle = new StyleSelect(this);
1327
        kerningLabel = new QLabel( tr( "Kerning:" ), this, "kerningLabel" );
1328
        Extra = new MSpinBox( this, 1 );
1329
        Extra->setValues( -300, 300, 10, 0);
1330
        Extra->setSuffix( tr( " pt" ) );
1331
        QToolTip::add( Extra, tr( "Manual Kerning" ) );
1332
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(NewStyle(int)));
1333
        connect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
1334
}
1335
 
1336
void SToolBStyle::newKernHandler()
1337
{
1338
        emit NewKern(Extra->value());
1339
}
1340
 
1341
void SToolBStyle::SetStyle(int s)
1342
{
1343
        disconnect(SeStyle, SIGNAL(State(int)), this, SIGNAL(NewStyle(int)));
1344
        SeStyle->setStyle(s);
1345
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(NewStyle(int)));
1346
}
1347
 
1348
void SToolBStyle::SetKern(double k)
1349
{
1350
        disconnect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
1351
        Extra->setValue(k);
1352
        connect(Extra, SIGNAL(valueChanged(int)), this, SLOT(newKernHandler()));
1353
}
1354
 
1355
/* Toolbar for alignment of Paragraphs */
352 Franz 1356
SToolBAlign::SToolBAlign(QMainWindow* parent) : QToolBar( tr("Style Settings"), parent)
351 Franz 1357
{
1358
        GroupAlign = new AlignSelect(this);
1359
        Spal = new Spalette(this);
1360
        QToolTip::add( Spal, tr( "Style of current paragraph" ) );
355 Franz 1361
        connect(Spal, SIGNAL(NewStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1362
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
1363
}
1364
 
1365
void SToolBAlign::newStyleHandler(int s)
1366
{
1367
        if (s != 0)
1368
                GroupAlign->setEnabled(false);
1369
        else
1370
                GroupAlign->setEnabled(true);
1371
        emit NewStyle(s);
1372
}
1373
 
1374
void SToolBAlign::SetAlign(int s)
1375
{
355 Franz 1376
        disconnect(Spal, SIGNAL(NewStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1377
        disconnect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
1378
        if (s < 5)
1379
        {
1380
                GroupAlign->setEnabled(true);
1381
                GroupAlign->setStyle(s);
1382
        }
1383
        else
1384
                GroupAlign->setEnabled(false);
1385
        Spal->setFormat(s);
1386
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(NewAlign(int )));
355 Franz 1387
        connect(Spal, SIGNAL(NewStyle(int)), this, SLOT(newStyleHandler(int )));
351 Franz 1388
}
1389
 
1390
/* Toolbar for Font related Settings */
352 Franz 1391
SToolBFont::SToolBFont(QMainWindow* parent) : QToolBar( tr("Font Settings"), parent)
351 Franz 1392
{
1393
        Fonts = new FontCombo(this, &ScApp->Prefs);
1394
        Fonts->setMaximumSize(190, 30);
1395
        Size = new MSpinBox( 1, 1024, this, 1 );
1396
        Size->setPrefix( "" );
1397
        Size->setSuffix( tr( " pt" ) );
1398
        ChScale = new QSpinBox( this, "ChScale" );
1399
        ChScale->setMaxValue( 400 );
1400
        ChScale->setMinValue( 25 );
1401
        ChScale->setValue( 100 );
1402
        ChScale->setSuffix( tr( " %" ) );
1403
        QToolTip::add( Fonts, tr( "Font of selected text" ) );
1404
        QToolTip::add( Size, tr( "Font Size" ) );
1405
        QToolTip::add( ChScale, tr( "Scaling width of characters" ) );
1406
        connect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
1407
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1408
        connect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
1409
}
1410
 
1411
void SToolBFont::SetFont(QString f)
1412
{
1413
        disconnect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1414
        Fonts->setCurrentText(f);
1415
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1416
}
1417
 
1418
void SToolBFont::SetSize(double s)
1419
{
1420
        disconnect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
1421
        Size->setValue(s);
1422
        connect(Size, SIGNAL(valueChanged(int)), this, SLOT(newSizeHandler()));
1423
}
1424
 
1425
void SToolBFont::SetScale(int s)
1426
{
1427
        disconnect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
1428
        ChScale->setValue(s);
1429
        connect(ChScale, SIGNAL(valueChanged(int)), this, SIGNAL(NewScale(int)));
1430
}
1431
 
1432
void SToolBFont::newSizeHandler()
1433
{
1434
        emit NewSize(Size->value());
1435
}
1436
 
1437
/* Main Story Editor Class */
1438
StoryEditor::StoryEditor(QWidget* parent, ScribusDoc *docc, PageItem *ite)
1439
                                                                        : QMainWindow(parent, "StoryEditor", WShowModal | WType_Dialog)
1440
{
1441
        setCaption( tr( "Story Editor" ) );
1442
        setIcon(loadIcon("AppIcon.png"));
1443
        doc = docc;
1444
        QHBox* vb = new QHBox( this );
1445
        StoryEd2Layout = new QHBoxLayout( 0, 5, 5, "StoryEd2Layout");
1446
/* Setting up Menu Bar */
217 Franz 1447
        fmenu = new QPopupMenu();
351 Franz 1448
        fmenu->insertItem(loadIcon("DateiNeu16.png"), tr("&New"), this, SLOT(Do_new()), CTRL+Key_N);
353 Franz 1449
        fid52 = fmenu->insertItem(loadIcon("reload16.png"),  tr("&Reload Text from Frame"), this, SLOT(slotFileRevert()));
162 Franz 1450
        fmenu->insertSeparator();
351 Franz 1451
        fmenu->insertItem(loadIcon("DateiSave16.png"), tr("&Save to File..."), this, SLOT(SaveTextFile()));
1452
        fmenu->insertItem(loadIcon("DateiOpen16.png"), tr("&Load from File..."), this, SLOT(LoadTextFile()));
1453
        fmenu->insertItem(tr("Save &Document"), this, SLOT(Do_saveDocument()), CTRL+Key_S);
162 Franz 1454
        fmenu->insertSeparator();
295 Franz 1455
        /* changes to fit the #662 bug 05/28/04 petr vanek */
353 Franz 1456
        fmenu->insertItem(loadIcon("DateiClos16.png"),  tr("&Update Text Frame and Exit"), this, SLOT(Do_leave2()));
1457
        fmenu->insertItem(loadIcon("exit.png"),  tr("&Exit Without Updating Text Frame"), this, SLOT(Do_leave()));
295 Franz 1458
        /* end of changes */
217 Franz 1459
        emenu = new QPopupMenu();
352 Franz 1460
        emenu->insertItem( tr("Select &All"), this, SLOT(Do_selectAll()), CTRL+Key_A);
351 Franz 1461
        Mcopy = emenu->insertItem(loadIcon("editcut.png"), tr("Cu&t"), this, SLOT(Do_cut()), CTRL+Key_X);
1462
        Mcut = emenu->insertItem(loadIcon("editcopy.png"), tr("&Copy"), this, SLOT(Do_copy()), CTRL+Key_C);
1463
        Mpaste = emenu->insertItem(loadIcon("editpaste.png"), tr("&Paste"), this, SLOT(Do_paste()), CTRL+Key_V);
360 Franz 1464
        Mdel = emenu->insertItem(loadIcon("editdelete.png"), tr("C&lear"), this, SLOT(Do_del()), Key_Delete);
103 Franz 1465
        emenu->insertSeparator();
357 Franz 1466
        emenu->insertItem(loadIcon("find16.png"),  tr("&Search/Replace..."), this, SLOT(SearchText()));
351 Franz 1467
        emenu->insertItem( tr("&Insert Special..."), this , SLOT(Do_insSp()));
189 Franz 1468
        emenu->insertSeparator();
355 Franz 1469
        emenu->insertItem( tr("&Edit Styles..."), this , SLOT(slotEditStyles()));
364 Franz 1470
        emenu->insertItem( tr("&Fonts Preview..."), this , SLOT(Do_fontPrev()));
353 Franz 1471
        Mupdt = emenu->insertItem(loadIcon("compfile16.png"),  tr("&Update Text Frame"), this, SLOT(updateTextFrame()), CTRL+Key_U);
357 Franz 1472
        settingsMenu = new QPopupMenu();
1473
        settingsMenu->insertItem( tr("&Background..."), this , SLOT(setBackPref()));
1474
        settingsMenu->insertItem( tr("&Display Font..."), this , SLOT(setFontPref()));
351 Franz 1475
        menuBar()->insertItem( tr("&File"), fmenu);
1476
        menuBar()->insertItem( tr("&Edit"), emenu);
357 Franz 1477
        menuBar()->insertItem( tr("&Settings"), settingsMenu );
124 Franz 1478
 
351 Franz 1479
/* Setting up Toolbars */
353 Franz 1480
        FileTools = new QToolBar( tr("File"), this);
364 Franz 1481
        DatNeu = new QToolButton(loadIcon("DateiNeu.xpm"), tr("Clear all Text"), QString::null, this, SLOT(Do_new()), FileTools);
353 Franz 1482
        DatOpe = new QToolButton(loadIcon("DateiOpen.xpm"), tr("Load Text from File"), QString::null, this, SLOT(LoadTextFile()), FileTools);
1483
        DatSav = new QToolButton(loadIcon("DateiSave2.png"), tr("Save Text to File"), QString::null, this, SLOT(SaveTextFile()), FileTools);
1484
        DatClo = new QToolButton(loadIcon("DateiClose.png"), tr("Update Text Frame and Exit"), QString::null, this, SLOT(Do_leave2()), FileTools);
1485
        DatCan = new QToolButton(loadIcon("exit22.png"), tr("Exit Without Updating Text Frame"), QString::null, this, SLOT(Do_leave()), FileTools);
1486
        DatRel = new QToolButton(loadIcon("reload.png"), tr("Reload Text from Frame"), QString::null, this, SLOT(slotFileRevert()), FileTools);
1487
        DatUpdt = new QToolButton(loadIcon("compfile.png"), tr("Update Text Frame"), QString::null, this, SLOT(updateTextFrame()), FileTools);
357 Franz 1488
        DatFin = new QToolButton(loadIcon("find.png"), tr("Search/Replace"), QString::null, this, SLOT(SearchText()), FileTools);
353 Franz 1489
        DatUpdt->setEnabled(false);
1490
        DatRel->setEnabled(false);
1491
        setDockEnabled(FileTools, DockLeft, false);
1492
        setDockEnabled(FileTools, DockRight, false);
1493
        setDockEnabled(FileTools, DockBottom, false);
351 Franz 1494
        FontTools = new SToolBFont(this);
1495
        setDockEnabled(FontTools, DockLeft, false);
1496
        setDockEnabled(FontTools, DockRight, false);
1497
        setDockEnabled(FontTools, DockBottom, false);
1498
        AlignTools = new SToolBAlign(this);
1499
        setDockEnabled(AlignTools, DockLeft, false);
1500
        setDockEnabled(AlignTools, DockRight, false);
1501
        setDockEnabled(AlignTools, DockBottom, false);
1502
        AlignTools->Spal->SetFormats(doc);
1503
        StyleTools = new SToolBStyle(this);
1504
        setDockEnabled(StyleTools, DockLeft, false);
1505
        setDockEnabled(StyleTools, DockRight, false);
1506
        setDockEnabled(StyleTools, DockBottom, false);
1507
        StrokeTools = new SToolBColorS(this, doc);
1508
        setDockEnabled(StrokeTools, DockLeft, false);
1509
        setDockEnabled(StrokeTools, DockRight, false);
1510
        setDockEnabled(StrokeTools, DockBottom, false);
352 Franz 1511
        StrokeTools->TxStroke->setEnabled(false);
1512
        StrokeTools->PM1->setEnabled(false);
351 Franz 1513
        FillTools = new SToolBColorF(this, doc);
1514
        setDockEnabled(FillTools, DockLeft, false);
1515
        setDockEnabled(FillTools, DockRight, false);
1516
        setDockEnabled(FillTools, DockBottom, false);
125 Franz 1517
 
371 Franz 1518
        EdSplit = new QSplitter(vb);
1519
/* SideBar Widget */
1520
        EditorBar = new SideBar(EdSplit);
351 Franz 1521
/* Editor Widget, subclass of QTextEdit */
371 Franz 1522
        Editor = new SEditor(EdSplit, docc);
1523
        StoryEd2Layout->addWidget( EdSplit );
351 Franz 1524
 
1525
/* Setting up Status Bar */
1526
        ButtonGroup1 = new QButtonGroup( statusBar(), "ButtonGroup1" );
125 Franz 1527
        ButtonGroup1->setFrameShape( QButtonGroup::NoFrame );
1528
        ButtonGroup1->setFrameShadow( QButtonGroup::Plain );
1529
        ButtonGroup1->setTitle("");
1530
        ButtonGroup1->setExclusive( true );
1531
        ButtonGroup1->setColumnLayout(0, Qt::Vertical );
1532
        ButtonGroup1->layout()->setSpacing( 0 );
1533
        ButtonGroup1->layout()->setMargin( 0 );
1534
        ButtonGroup1Layout = new QGridLayout( ButtonGroup1->layout() );
1535
        ButtonGroup1Layout->setAlignment( Qt::AlignTop );
1536
        ButtonGroup1Layout->setSpacing( 2 );
1537
        ButtonGroup1Layout->setMargin( 0 );
1538
        WordCT1 = new QLabel(ButtonGroup1, "wt");
1539
        WordCT1->setText( tr("Current Paragraph:"));
1540
        ButtonGroup1Layout->addMultiCellWidget( WordCT1, 0, 0, 0, 3 );
1541
        WordCT = new QLabel(ButtonGroup1, "wt");
124 Franz 1542
        WordCT->setText( tr("Words: "));
125 Franz 1543
        ButtonGroup1Layout->addWidget( WordCT, 1, 0 );
1544
        WordC = new QLabel(ButtonGroup1, "wc");
1545
        ButtonGroup1Layout->addWidget( WordC, 1, 1 );
1546
        CharCT = new QLabel(ButtonGroup1, "ct");
124 Franz 1547
        CharCT->setText( tr("Chars: "));
125 Franz 1548
        ButtonGroup1Layout->addWidget( CharCT, 1, 2 );
1549
        CharC = new QLabel(ButtonGroup1, "cc");
1550
        ButtonGroup1Layout->addWidget( CharC, 1, 3 );
351 Franz 1551
        statusBar()->addWidget(ButtonGroup1, 1, true);
1552
        ButtonGroup2 = new QButtonGroup( statusBar(), "ButtonGroup2" );
125 Franz 1553
        ButtonGroup2->setFrameShape( QButtonGroup::NoFrame );
1554
        ButtonGroup2->setFrameShadow( QButtonGroup::Plain );
1555
        ButtonGroup2->setTitle("");
1556
        ButtonGroup2->setExclusive( true );
1557
        ButtonGroup2->setColumnLayout(0, Qt::Vertical );
1558
        ButtonGroup2->layout()->setSpacing( 0 );
1559
        ButtonGroup2->layout()->setMargin( 0 );
1560
        ButtonGroup2Layout = new QGridLayout( ButtonGroup2->layout() );
1561
        ButtonGroup2Layout->setAlignment( Qt::AlignTop );
1562
        ButtonGroup2Layout->setSpacing( 2 );
1563
        ButtonGroup2Layout->setMargin( 0 );
1564
        WordCT3 = new QLabel(ButtonGroup2, "wt");
1565
        WordCT3->setText( tr("Totals:"));
1566
        ButtonGroup2Layout->addMultiCellWidget( WordCT3, 0, 0, 0, 5 );
1567
        ParCT = new QLabel(ButtonGroup2, "pt");
1568
        ParCT->setText( tr("Paragraphs: "));
1569
        ButtonGroup2Layout->addWidget( ParCT, 1, 0 );
1570
        ParC = new QLabel(ButtonGroup2, "pc");
1571
        ButtonGroup2Layout->addWidget( ParC, 1, 1 );
1572
        WordCT2 = new QLabel(ButtonGroup2, "wt");
124 Franz 1573
        WordCT2->setText( tr("Words: "));
125 Franz 1574
        ButtonGroup2Layout->addWidget( WordCT2, 1, 2 );
1575
        WordC2 = new QLabel(ButtonGroup2, "wc");
1576
        ButtonGroup2Layout->addWidget( WordC2, 1, 3 );
1577
        CharCT2 = new QLabel(ButtonGroup2, "ct");
124 Franz 1578
        CharCT2->setText( tr("Chars: "));
125 Franz 1579
        ButtonGroup2Layout->addWidget( CharCT2, 1, 4 );
1580
        CharC2 = new QLabel(ButtonGroup2, "cc");
1581
        ButtonGroup2Layout->addWidget( CharC2, 1, 5 );
351 Franz 1582
        statusBar()->addWidget(ButtonGroup2, 1, true);
1583
        setCentralWidget( vb );
1584
/* Final polishment */
1585
        fmenu->setItemEnabled(fid52, 0);
1586
        emenu->setItemEnabled(Mcopy, 0);
1587
        emenu->setItemEnabled(Mcut, 0);
1588
        emenu->setItemEnabled(Mpaste, 0);
1589
        emenu->setItemEnabled(Mdel, 0);
1590
        emenu->setItemEnabled(Mupdt, 0);
1591
        resize( QSize(660, 500).expandedTo(minimumSizeHint()) );
357 Franz 1592
        Editor->setPaper(ScApp->Prefs.STEcolor);
1593
        QFont fo;
1594
        fo.fromString(ScApp->Prefs.STEfont);
1595
        Editor->setFont(fo);
351 Franz 1596
        CurrItem = ite;
353 Franz 1597
        firstSet = false;
351 Franz 1598
        Editor->loadItemText(ite);
1599
        updateProps(0,0);
1600
        updateStatus();
1601
        TextChanged = false;
371 Franz 1602
        EditorBar->setFrameStyle(Editor->frameStyle());
1603
        EditorBar->setLineWidth(Editor->lineWidth());
1604
        EditorBar->editor = Editor;
351 Franz 1605
        connect(Editor, SIGNAL(textChanged()), this, SLOT(modifiedText()));
364 Franz 1606
        connect(Editor, SIGNAL(clicked(int, int)), this, SLOT(updateProps(int, int)));
351 Franz 1607
        connect(Editor, SIGNAL(setProps(int, int)), this, SLOT(updateProps(int, int)));
1608
        connect(Editor, SIGNAL(cursorPositionChanged(int, int)), this, SLOT(updateProps(int, int)));
360 Franz 1609
        connect(Editor, SIGNAL(copyAvailable(bool)), this, SLOT(CopyAvail(bool )));
376 Franz 1610
        connect(Editor, SIGNAL(PasteAvail()), this, SLOT(PasteAvail()));
373 Franz 1611
        connect(Editor, SIGNAL(contentsMoving(int, int)), EditorBar, SLOT(doMove(int, int )));
371 Franz 1612
        connect(Editor, SIGNAL(textChanged()), EditorBar, SLOT(doRepaint()));
372 Franz 1613
        connect(Editor, SIGNAL(SideBarUp(bool )), EditorBar, SLOT(setRepaint(bool )));
1614
        connect(Editor, SIGNAL(SideBarUpdate( )), EditorBar, SLOT(doRepaint()));
374 Franz 1615
        connect(EditorBar, SIGNAL(ChangeStyle(int, int )), this, SLOT(changeAlignSB(int, int )));
355 Franz 1616
        connect(AlignTools, SIGNAL(NewStyle(int)), this, SLOT(newAlign(int)));
351 Franz 1617
        connect(AlignTools, SIGNAL(NewAlign(int)), this, SLOT(newAlign(int)));
1618
        connect(FillTools, SIGNAL(NewColor(int, int)), this, SLOT(newTxFill(int, int)));
1619
        connect(StrokeTools, SIGNAL(NewColor(int, int)), this, SLOT(newTxStroke(int, int)));
1620
        connect(FontTools, SIGNAL(NewSize(double )), this, SLOT(newTxSize(double)));
1621
        connect(FontTools, SIGNAL(NewFont(const QString& )), this, SLOT(newTxFont(const QString& )));
1622
        connect(FontTools, SIGNAL(NewScale(int )), this, SLOT(newTxScale(int )));
1623
        connect(StyleTools, SIGNAL(NewKern(double )), this, SLOT(newTxKern(double )));
1624
        connect(StyleTools, SIGNAL(NewStyle(int )), this, SLOT(newTxStyle(int )));
392 Franz 1625
        Editor->setFocus();
351 Franz 1626
}
125 Franz 1627
 
351 Franz 1628
int StoryEditor::exec()
1629
{
1630
        clearWFlags( WDestructiveClose );
1631
        setWFlags( WShowModal );
1632
        result = 0;
1633
        show();
392 Franz 1634
        Editor->setFocus();
351 Franz 1635
        qApp->enter_loop();
1636
        clearWFlags( WShowModal );
1637
        return result;
1638
}
124 Franz 1639
 
351 Franz 1640
void StoryEditor::closeEvent(QCloseEvent *event)
1641
{
1642
        if (TextChanged)
167 Franz 1643
        {
351 Franz 1644
                int t = QMessageBox::warning(this, tr("Warning"),
1645
                                                                        tr("Do you want to save your changes?"),
1646
                                                                        QMessageBox::Yes, QMessageBox::No, QMessageBox::Cancel);
1647
                if (t == QMessageBox::Yes)
1648
                        result = QDialog::Accepted;
1649
                else if (t == QMessageBox::Cancel)
1650
                        return;
1651
                else if (t == QMessageBox::No)
1652
                        result = QDialog::Rejected;
167 Franz 1653
        }
351 Franz 1654
        else
1655
                result = QDialog::Rejected;
1656
        hide();
1657
        qApp->exit_loop();
1658
}
1659
 
357 Franz 1660
void StoryEditor::setBackPref()
1661
{
1662
        QColor neu = QColor();
1663
        neu = QColorDialog::getColor(Editor->paper().color(), this);
1664
        if (neu.isValid())
1665
        {
1666
                Editor->setPaper(neu);
1667
                ScApp->Prefs.STEcolor = neu;
1668
        }
1669
}
1670
 
1671
void StoryEditor::setFontPref()
1672
{
1673
        Editor->setFont( QFontDialog::getFont( 0, Editor->font() ) );
1674
        ScApp->Prefs.STEfont = Editor->font().toString();
373 Franz 1675
        EditorBar->doRepaint();
357 Franz 1676
}
1677
 
351 Franz 1678
void StoryEditor::newTxFill(int c, int s)
1679
{
357 Franz 1680
        if (c != -1)
1681
                Editor->CurrTextFill = FillTools->TxFill->text(c);
1682
        if (s != -1)
1683
                Editor->CurrTextFillSh = s;
351 Franz 1684
        Editor->setFarbe(Editor->CurrTextFill, Editor->CurrTextFillSh);
1685
        struct PtiSmall hg;
1686
        hg.ccolor = Editor->CurrTextFill;
1687
        hg.cshade = Editor->CurrTextFillSh;
1688
        Editor->updateSel(0, &hg);
1689
        modifiedText();
1690
        Editor->setFocus();
1691
}
1692
 
1693
void StoryEditor::newTxStroke(int c, int s)
1694
{
357 Franz 1695
        if (c != -1)
1696
                Editor->CurrTextStroke = StrokeTools->TxStroke->text(c);
1697
        if (s != -1)
1698
                Editor->CurrTextStrokeSh = s;
351 Franz 1699
        struct PtiSmall hg;
1700
        hg.cstroke = Editor->CurrTextStroke;
1701
        hg.cshade2 = Editor->CurrTextStrokeSh;
1702
        Editor->updateSel(1, &hg);
1703
        modifiedText();
1704
        Editor->setFocus();
1705
}
1706
 
1707
void StoryEditor::newTxFont(const QString &f)
1708
{
1709
        Editor->CurrFont = f;
1710
        struct PtiSmall hg;
1711
        hg.cfont = Editor->CurrFont;
1712
        Editor->updateSel(2, &hg);
1713
        if(!doc->UsedFonts.contains(Editor->CurrFont))
1714
                doc->AddFont(Editor->CurrFont, ScApp->Prefs.AvailFonts[Editor->CurrFont]->Font);
1715
        modifiedText();
1716
        Editor->setFocus();
1717
}
1718
 
1719
void StoryEditor::newTxSize(double s)
1720
{
1721
        Editor->CurrFontSize = qRound(s * 10.0);
1722
        struct PtiSmall hg;
1723
        hg.csize = Editor->CurrFontSize;
1724
        Editor->updateSel(3, &hg);
1725
        modifiedText();
1726
        Editor->setFocus();
1727
}
1728
 
1729
void StoryEditor::newTxStyle(int s)
1730
{
1731
        Editor->CurrentStyle = s;
1732
        struct PtiSmall hg;
1733
        hg.cstyle = Editor->CurrentStyle;
1734
        Editor->updateSel(4, &hg);
1735
        Editor->setStyle(s);
1736
        if (s & 4)
352 Franz 1737
        {
1738
                StrokeTools->TxStroke->setEnabled(true);
1739
                StrokeTools->PM1->setEnabled(true);
1740
        }
351 Franz 1741
        else
352 Franz 1742
        {
1743
                StrokeTools->TxStroke->setEnabled(false);
1744
                StrokeTools->PM1->setEnabled(false);
1745
        }
351 Franz 1746
        modifiedText();
1747
        Editor->setFocus();
1748
}
1749
 
1750
void StoryEditor::newTxScale(int s)
1751
{
1752
        Editor->CurrTextScale = s;
1753
        struct PtiSmall hg;
1754
        hg.cscale = Editor->CurrTextScale;
1755
        Editor->updateSel(5, &hg);
1756
        modifiedText();
1757
        Editor->setFocus();
1758
}
1759
 
1760
void StoryEditor::newTxKern(double s)
1761
{
1762
        Editor->CurrTextKern = s;
1763
        struct PtiSmall hg;
1764
        hg.cextra = Editor->CurrTextKern;
1765
        Editor->updateSel(6, &hg);
1766
        modifiedText();
1767
        Editor->setFocus();
1768
}
1769
 
1770
void StoryEditor::updateProps(int p, int ch)
1771
{
1772
        CListe::Iterator it;
1773
        int c = 0;
373 Franz 1774
        struct PtiSmall *hg;
351 Franz 1775
        SEditor::ChList *chars;
353 Franz 1776
        if (Editor->wasMod)
1777
                return;
351 Franz 1778
        if ((p >= static_cast<int>(Editor->StyledText.count())) || (Editor->StyledText.count() == 0))
167 Franz 1779
        {
353 Franz 1780
                if (!firstSet)
217 Franz 1781
                {
353 Franz 1782
                        Editor->CurrTextFill = CurrItem->TxtFill;
1783
                        Editor->CurrTextFillSh = CurrItem->ShTxtFill;
1784
                        Editor->CurrTextStroke = CurrItem->TxtStroke;
1785
                        Editor->CurrTextStrokeSh = CurrItem->ShTxtStroke;
1786
                        Editor->CurrFont = CurrItem->IFont;
1787
                        Editor->CurrFontSize = CurrItem->ISize;
1788
                        Editor->CurrentStyle = CurrItem->TxTStyle;
1789
                        Editor->CurrentABStil = CurrItem->Ausrich;
1790
                        Editor->CurrTextKern = CurrItem->ExtraV;
1791
                        Editor->CurrTextScale = CurrItem->TxtScale;
1792
                        c = 0;
1793
                        StrokeTools->SetShade(CurrItem->ShTxtStroke);
1794
                        FillTools->SetShade(CurrItem->ShTxtFill);
1795
                        QString b = CurrItem->TxtFill;
1796
                        if ((b != "None") && (b != ""))
167 Franz 1797
                        {
351 Franz 1798
                                c++;
353 Franz 1799
                                for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1800
                                {
1801
                                        if (it.key() == b)
1802
                                                break;
1803
                                        c++;
1804
                                }
167 Franz 1805
                        }
353 Franz 1806
                        FillTools->SetColor(c);
1807
                        c = 0;
1808
                        b = CurrItem->TxtStroke;
1809
                        if ((b != "None") && (b != ""))
351 Franz 1810
                        {
1811
                                c++;
353 Franz 1812
                                for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1813
                                {
1814
                                        if (it.key() == b)
1815
                                                break;
1816
                                        c++;
1817
                                }
351 Franz 1818
                        }
353 Franz 1819
                        StrokeTools->SetColor(c);
1820
                        AlignTools->SetAlign(CurrItem->Ausrich);
1821
                        StyleTools->SetKern(CurrItem->ExtraV);
1822
                        StyleTools->SetStyle(CurrItem->TxTStyle);
1823
                        FontTools->SetSize(CurrItem->ISize / 10.0);
1824
                        FontTools->SetFont(CurrItem->IFont);
1825
                        FontTools->SetScale(CurrItem->TxtScale);
351 Franz 1826
                }
353 Franz 1827
                if (Editor->CurrentStyle & 4)
352 Franz 1828
                {
1829
                        StrokeTools->TxStroke->setEnabled(true);
1830
                        StrokeTools->PM1->setEnabled(true);
1831
                }
351 Franz 1832
                else
352 Franz 1833
                {
1834
                        StrokeTools->TxStroke->setEnabled(false);
1835
                        StrokeTools->PM1->setEnabled(false);
1836
                }
353 Franz 1837
                Editor->setAlign(Editor->CurrentABStil);
352 Franz 1838
                Editor->setStyle(Editor->CurrentStyle);
1839
                Editor->setFarbe(Editor->CurrTextFill, Editor->CurrTextFillSh);
355 Franz 1840
                firstSet = true;
351 Franz 1841
                return;
167 Franz 1842
        }
351 Franz 1843
        chars = Editor->StyledText.at(p);
373 Franz 1844
        Editor->CurrentABStil = Editor->ParagStyles[p];
351 Franz 1845
        if (chars->count() == 0)
167 Franz 1846
        {
373 Franz 1847
                if (Editor->CurrentABStil > 4)
1848
                {
1849
                        Editor->CurrFont = doc->Vorlagen[Editor->CurrentABStil].Font;
1850
                        Editor->CurrFontSize = doc->Vorlagen[Editor->CurrentABStil].FontSize;
1851
                        Editor->CurrentStyle = doc->Vorlagen[Editor->CurrentABStil].FontEffect;
1852
                        Editor->CurrTextFill = doc->Vorlagen[Editor->CurrentABStil].FColor;
1853
                        Editor->CurrTextFillSh = doc->Vorlagen[Editor->CurrentABStil].FShade;
1854
                        Editor->CurrTextStroke = doc->Vorlagen[Editor->CurrentABStil].SColor;
1855
                        Editor->CurrTextStrokeSh = doc->Vorlagen[Editor->CurrentABStil].SShade;
1856
                }
353 Franz 1857
                Editor->setAlign(Editor->CurrentABStil);
1858
                Editor->setStyle(Editor->CurrentStyle);
1859
                Editor->setFarbe(Editor->CurrTextFill, Editor->CurrTextFillSh);
167 Franz 1860
        }
373 Franz 1861
        else
351 Franz 1862
        {
373 Franz 1863
                if (Editor->hasSelectedText())
1864
                {
1865
                        int PStart, PEnd, SelStart, SelEnd;
1866
                        Editor->getSelection(&PStart, &SelStart, &PEnd, &SelEnd);
1867
                        if ((SelStart > -1) && (SelStart < static_cast<int>(chars->count())))
1868
                                hg = chars->at(SelStart);
1869
                        else
1870
                                hg = chars->at(QMIN(QMAX(ch-1, 0), static_cast<int>(chars->count())-1));
1871
                }
351 Franz 1872
                else
352 Franz 1873
                        hg = chars->at(QMIN(QMAX(ch-1, 0), static_cast<int>(chars->count())-1));
373 Franz 1874
                Editor->CurrTextFill = hg->ccolor;
1875
                Editor->CurrTextFillSh = hg->cshade;
1876
                Editor->CurrTextStroke = hg->cstroke;
1877
                Editor->CurrTextStrokeSh = hg->cshade2;
1878
                Editor->CurrFont = hg->cfont;
1879
                Editor->CurrFontSize = hg->csize;
1880
                Editor->CurrentStyle = hg->cstyle & 127;
1881
                Editor->CurrTextKern = hg->cextra;
1882
                Editor->CurrTextScale = hg->cscale;
351 Franz 1883
        }
373 Franz 1884
        StrokeTools->SetShade(Editor->CurrTextStrokeSh);
1885
        FillTools->SetShade(Editor->CurrTextFillSh);
1886
        QString b = Editor->CurrTextFill;
351 Franz 1887
        if ((b != "None") && (b != ""))
1888
        {
1889
                c++;
1890
                for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1891
                {
1892
                        if (it.key() == b)
1893
                                break;
1894
                        c++;
1895
                }
1896
        }
1897
        FillTools->SetColor(c);
1898
        c = 0;
373 Franz 1899
        b = Editor->CurrTextStroke;
351 Franz 1900
        if ((b != "None") && (b != ""))
1901
        {
1902
                c++;
1903
                for (it = doc->PageColors.begin(); it != doc->PageColors.end(); ++it)
1904
                {
1905
                        if (it.key() == b)
1906
                                break;
1907
                        c++;
1908
                }
1909
        }
1910
        StrokeTools->SetColor(c);
373 Franz 1911
        if (Editor->CurrentStyle & 4)
352 Franz 1912
        {
1913
                StrokeTools->TxStroke->setEnabled(true);
1914
                StrokeTools->PM1->setEnabled(true);
1915
        }
351 Franz 1916
        else
352 Franz 1917
        {
1918
                StrokeTools->TxStroke->setEnabled(false);
1919
                StrokeTools->PM1->setEnabled(false);
1920
        }
373 Franz 1921
        StyleTools->SetKern(Editor->CurrTextKern);
1922
        StyleTools->SetStyle(Editor->CurrentStyle);
1923
        FontTools->SetSize(Editor->CurrFontSize / 10.0);
1924
        FontTools->SetFont(Editor->CurrFont);
1925
        FontTools->SetScale(Editor->CurrTextScale);
1926
        AlignTools->SetAlign(Editor->CurrentABStil);
124 Franz 1927
        updateStatus();
102 Franz 1928
}
1929
 
124 Franz 1930
void StoryEditor::updateStatus()
1931
{
1932
        QString tmp;
351 Franz 1933
        int p, i;
1934
        Editor->getCursorPosition(&p, &i);
1935
        ParC->setText(tmp.setNum(Editor->StyledText.count()));
124 Franz 1936
        QRegExp rx( "(\\w+)\\b" );
1937
        int pos = 0;
1938
        int counter = 0;
1939
        int counter1 = 0;
1940
        int counter2 = 0;
167 Franz 1941
        while ( pos >= 0 )
1942
        {
351 Franz 1943
                pos = rx.search( Editor->text(p), pos );
217 Franz 1944
                if ( pos > -1 )
124 Franz 1945
                {
1946
                        counter++;
1947
                        pos += rx.matchedLength();
1948
                }
167 Franz 1949
        }
124 Franz 1950
        WordC->setText(tmp.setNum(counter));
351 Franz 1951
        CharC->setText(tmp.setNum(Editor->text(p).length()-1));
1952
        for (uint a = 0; a < Editor->StyledText.count(); ++a)
167 Franz 1953
        {
124 Franz 1954
                int pos = 0;
217 Franz 1955
                while ( pos >= 0 )
167 Franz 1956
                {
351 Franz 1957
                        pos = rx.search( Editor->text(a), pos );
217 Franz 1958
                        if ( pos > -1 )
124 Franz 1959
                        {
1960
                                counter2++;
1961
                                pos += rx.matchedLength();
1962
                        }
167 Franz 1963
                }
351 Franz 1964
                counter1 += Editor->text(a).length();
167 Franz 1965
        }
124 Franz 1966
        WordC2->setText(tmp.setNum(counter2));
351 Franz 1967
        CharC2->setText(tmp.setNum(Editor->length()));
124 Franz 1968
}
1969
 
253 Franz 1970
void StoryEditor::Do_insSp()
1971
{
351 Franz 1972
        ScApp->DLLinput = Editor->CurrFont;
253 Franz 1973
        ScApp->DLLReturn = "";
316 Franz 1974
        ScApp->CallDLL( tr("&Insert Special") );
351 Franz 1975
        Editor->insChars(ScApp->DLLReturn);
1976
        Editor->insert(ScApp->DLLReturn);
253 Franz 1977
        ScApp->DLLinput = "";
1978
        ScApp->DLLReturn = "";
1979
}
1980
 
357 Franz 1981
void StoryEditor::Do_fontPrev()
1982
{
1983
        ScApp->DLLinput = Editor->CurrFont;
1984
        ScApp->DLLReturn = "";
1985
        ScApp->CallDLL( tr("&Fonts Preview") );
1986
        if (ScApp->DLLReturn != "")
1987
        {
1988
                newTxFont(ScApp->DLLReturn);
1989
                FontTools->SetFont(ScApp->DLLReturn);
1990
        }
1991
        ScApp->DLLinput = "";
1992
        ScApp->DLLReturn = "";
1993
}
1994
 
351 Franz 1995
void StoryEditor::Do_leave2()
1996
{
1997
        result = QDialog::Accepted;
1998
        hide();
1999
        qApp->exit_loop();
2000
}
2001
 
103 Franz 2002
void StoryEditor::Do_leave()
2003
{
2004
        if (TextChanged)
167 Franz 2005
        {
103 Franz 2006
                int t = QMessageBox::warning(this, tr("Warning"),
217 Franz 2007
                                             tr("Do you really want to lose all your Changes?"),
2008
                                             QMessageBox::No, QMessageBox::Yes, QMessageBox::NoButton);
2009
                if (t == QMessageBox::No)
103 Franz 2010
                        return;
167 Franz 2011
        }
351 Franz 2012
        result = QDialog::Rejected;
2013
        hide();
2014
        qApp->exit_loop();
103 Franz 2015
}
295 Franz 2016
 
2017
/*! Saves the document with editation continued. Signal called from menu.
2018
  05/28/04 petr vanek
2019
  */
2020
void StoryEditor::Do_saveDocument()
2021
{
2022
        updateTextFrame();
2023
        ScApp->slotFileSave();
2024
}
103 Franz 2025
 
351 Franz 2026
bool StoryEditor::Do_new()
103 Franz 2027
{
360 Franz 2028
        if (Editor->length() != 0)
2029
        {
2030
                int t = QMessageBox::warning(this, tr("Warning"),
217 Franz 2031
                                     tr("Do you really want to clear all your Text?"),
2032
                                     QMessageBox::No, QMessageBox::Yes, QMessageBox::NoButton);
360 Franz 2033
                if (t == QMessageBox::No)
2034
                        return false;
2035
        }
351 Franz 2036
        Editor->StyledText.clear();
373 Franz 2037
        Editor->ParagStyles.clear();
351 Franz 2038
        Editor->clear();
2039
        Editor->setUndoRedoEnabled(false);
2040
        Editor->setUndoRedoEnabled(true);
2041
        Editor->setCursorPosition(0, 0);
113 Franz 2042
        emenu->setItemEnabled(Mcopy, 0);
2043
        emenu->setItemEnabled(Mcut, 0);
2044
        emenu->setItemEnabled(Mdel, 0);
351 Franz 2045
        fmenu->setItemEnabled(fid52, 0);
2046
        TextChanged = false;
2047
        updateProps(0, 0);
124 Franz 2048
        updateStatus();
351 Franz 2049
        return true;
103 Franz 2050
}
2051
 
351 Franz 2052
void StoryEditor::slotFileRevert()
103 Franz 2053
{
351 Franz 2054
        if (Do_new())
2055
        {
2056
                Editor->loadItemText(CurrItem);
2057
                updateStatus();
2058
        }
103 Franz 2059
}
2060
 
352 Franz 2061
void StoryEditor::Do_selectAll()
2062
{
2063
        if (Editor->StyledText.count() == 0)
2064
                return;
2065
        if (Editor->StyledText.count() > 1)
2066
                Editor->setSelection(0, 0, Editor->StyledText.count()-1, Editor->StyledText.at(Editor->StyledText.count()-1)->count());
2067
        else
2068
                Editor->setSelection(0, 0, 0, Editor->StyledText.at(0)->count());
2069
}
2070
 
103 Franz 2071
void StoryEditor::Do_copy()
2072
{
362 Franz 2073
        Editor->copy();
103 Franz 2074
}
2075
 
2076
void StoryEditor::Do_paste()
2077
{
362 Franz 2078
        Editor->paste();
103 Franz 2079
}
2080
 
2081
void StoryEditor::Do_cut()
2082
{
362 Franz 2083
        Editor->cut();
103 Franz 2084
}
2085
 
2086
void StoryEditor::Do_del()
2087
{
360 Franz 2088
        if (Editor->StyledText.count() == 0)
2089
                return;
372 Franz 2090
        EditorBar->setRepaint(false);
360 Franz 2091
        if (Editor->hasSelectedText())
2092
        {
2093
                Editor->deleteSel();
2094
                Editor->removeSelectedText();
2095
        }
372 Franz 2096
        EditorBar->setRepaint(true);
373 Franz 2097
        EditorBar->doRepaint();
103 Franz 2098
}
2099
 
113 Franz 2100
void StoryEditor::CopyAvail(bool u)
2101
{
362 Franz 2102
        emenu->setItemEnabled(Mcopy, u);
2103
        emenu->setItemEnabled(Mcut, u);
113 Franz 2104
        emenu->setItemEnabled(Mdel, u);
362 Franz 2105
        if (Editor->tBuffer.length() != 0)
2106
                emenu->setItemEnabled(Mpaste, 1);
2107
        else
2108
                emenu->setItemEnabled(Mpaste, 0);
113 Franz 2109
}
2110
 
376 Franz 2111
void StoryEditor::PasteAvail()
2112
{
2113
        emenu->setItemEnabled(Mpaste, 1);
2114
}
2115
 
102 Franz 2116
void StoryEditor::updateTextFrame()
2117
{
107 Franz 2118
        PageItem *nb = CurrItem;
2119
        while (nb != 0)
167 Franz 2120
        {
107 Franz 2121
                if (nb->BackBox != 0)
2122
                        nb = nb->BackBox;
2123
                else
2124
                        break;
167 Franz 2125
        }
354 Franz 2126
        PageItem* nb2 = nb;
2127
        while (nb2 != 0)
2128
        {
2129
                nb2->Ptext.clear();
2130
                nb2->CPos = 0;
385 Franz 2131
                nb2->Dirty = false;
354 Franz 2132
                nb2 = nb2->NextBox;
2133
        }
351 Franz 2134
        Editor->saveItemText(nb);
356 Franz 2135
        if (doc->Trenner->AutoCheck)
2136
        {
2137
                if (doc->Trenner->Language != nb->Language)
2138
                        doc->Trenner->slotNewDict(nb->Language);
2139
                doc->Trenner->slotHyphenate(nb);
2140
        }
390 Franz 2141
        bool rep = doc->RePos;
2142
        doc->RePos = true;
2143
        QPixmap pgPix(1, 1);
2144
        ScPainter *painter = new ScPainter(&pgPix, 1, 1);
2145
        painter->translate(0.5, 0.5);
2146
        nb->DrawObj(painter, QRect(0, 0, 1, 1));
2147
        painter->end();
2148
        delete painter;
2149
        doc->RePos = rep;
2150
        nb2 = nb;
2151
        while (nb2 != 0)
2152
        {
2153
                nb2->Dirty = false;
2154
                nb2 = nb2->NextBox;
2155
        }
387 Franz 2156
        doc->ActPage->update();
102 Franz 2157
        TextChanged = false;
113 Franz 2158
        emenu->setItemEnabled(Mupdt, 0);
351