Subversion Repositories Scribus

Rev

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