Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
102 Franz 7
/***************************************************************************
14273 subik 8
                                                  story.cpp  -  description
9
                                                         -------------------
10
        begin                      : Tue Nov 11 2003
11
        copyright                  : (C) 2003 by Franz Schmid
12
        email                      : Franz.Schmid@altmuehlnet.de
102 Franz 13
 ***************************************************************************/
14
 
15
/***************************************************************************
14273 subik 16
 *                                                                                                                                         *
102 Franz 17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
14273 subik 19
 *   the Free Software Foundation; either version 2 of the License, or   *
20
 *   (at your option) any later version.                                                                   *
21
 *                                                                                                                                         *
102 Franz 22
 ***************************************************************************/
10644 cbradney 23
 
24
#include <QApplication>
25
#include <QCloseEvent>
26
#include <QColorDialog>
10220 cbradney 27
#include <QComboBox>
28
#include <QCursor>
8601 jghali 29
#include <QDesktopWidget>
10644 cbradney 30
#include <QEvent>
8501 cbradney 31
#include <QFocusEvent>
10644 cbradney 32
#include <QFontDialog>
33
#include <QFrame>
34
#include <QGridLayout>
10180 fschmid 35
#include <QHBoxLayout>
8501 cbradney 36
#include <QHideEvent>
10644 cbradney 37
#include <QKeyEvent>
38
#include <QLabel>
39
#include <QList>
12998 fschmid 40
#include <QPair>
10644 cbradney 41
#include <QMouseEvent>
8501 cbradney 42
#include <QPaintEvent>
9525 fschmid 43
#include <QPalette>
10644 cbradney 44
#include <QPixmap>
45
#include <QRegExp>
46
#include <QShowEvent>
47
#include <QTextBlock>
48
#include <QTextCodec>
49
#include <QTextLayout>
50
#include <QToolTip>
3732 cbradney 51
 
4557 cbradney 52
#include "actionmanager.h"
3732 cbradney 53
#include "alignselect.h"
13544 cbradney 54
#include "ui/charselect.h"
10644 cbradney 55
#include "colorcombo.h"
7747 jghali 56
#include "colorlistbox.h"
3732 cbradney 57
#include "commonstrings.h"
13552 cbradney 58
#include "ui/customfdialog.h"
3732 cbradney 59
#include "fontcombo.h"
4550 cbradney 60
#include "menumanager.h"
3732 cbradney 61
#include "pageitem.h"
10601 mrdocs 62
#include "pageitem_textframe.h"
3732 cbradney 63
#include "pluginmanager.h"
415 Franz 64
#include "prefscontext.h"
10644 cbradney 65
#include "prefsfile.h"
3252 craig 66
#include "prefsmanager.h"
10644 cbradney 67
#include "scfonts.h"
3732 cbradney 68
#include "scmessagebox.h"
10644 cbradney 69
#include "scplugin.h"
3732 cbradney 70
#include "scraction.h"
5781 cbradney 71
#include "scribuscore.h"
10644 cbradney 72
#include "scrspinbox.h"
3732 cbradney 73
#include "search.h"
3135 cbradney 74
#include "serializer.h"
3732 cbradney 75
#include "shadebutton.h"
13551 cbradney 76
#include "ui/spalette.h"
12939 jghali 77
#include "storyeditor.h"
8448 jghali 78
#include "styleitem.h"
15448 craig 79
//#include "ui/stylemanager.h"
3252 craig 80
#include "styleselect.h"
10644 cbradney 81
#include "text/nlsconfig.h"
12290 cbradney 82
#include "units.h"
3809 cbradney 83
#include "util.h"
10200 cbradney 84
#include "util_icon.h"
13584 subik 85
#include "loremipsum.h"
10965 fschmid 86
 
13584 subik 87
 
11360 jghali 88
class StyledTextMimeData : public QMimeData
89
{
90
protected:
12832 jghali 91
        StoryText   m_styledText;
92
        ScGuardedPtr<ScribusDoc> m_styledTextDoc;
11360 jghali 93
 
94
public:
12832 jghali 95
        const StoryText&  styledText(void) const { return m_styledText; }
96
        const ScribusDoc* document(void)   const { return m_styledTextDoc; }
97
 
98
        void  setStyledText(const StoryText& text, ScribusDoc* doc)
11360 jghali 99
        {
100
                QByteArray styledTextData (sizeof(void*), 0);
101
                m_styledText.clear();
102
                m_styledText.insert(0, text, true);
12832 jghali 103
                m_styledTextDoc = doc->guardedPtr();
11360 jghali 104
                styledTextData.setNum((quintptr)((quintptr*) &m_styledText));
11361 jghali 105
                setData("application/x-scribus-styledtext", styledTextData);
11360 jghali 106
        };
107
};
108
 
371 Franz 109
SideBar::SideBar(QWidget *pa) : QLabel(pa)
110
{
9525 fschmid 111
        QPalette pal;
112
        pal.setColor(QPalette::Window, QColor(255,255,255));
113
        setAutoFillBackground(true);
114
        setPalette(pal);
371 Franz 115
        offs = 0;
116
        editor = 0;
372 Franz 117
        noUpdt = true;
373 Franz 118
        inRep = false;
9525 fschmid 119
        pmen = new QMenu(this);
373 Franz 120
        setMinimumWidth(fontMetrics().width( tr("No Style") )+30);
371 Franz 121
}
122
 
374 Franz 123
void SideBar::mouseReleaseEvent(QMouseEvent *m)
124
{
11998 jghali 125
        QPoint globalPos = m->globalPos();
126
        QPoint viewPos   = editor->viewport()->mapFromGlobal(globalPos);
12997 jghali 127
        int p = editor->cursorForPosition(QPoint(2, viewPos.y())).position();
10643 fschmid 128
        CurrentPar = editor->StyledText.nrOfParagraph(p);
16809 jghali 129
        int pos = editor->StyledText.startOfParagraph( editor->StyledText.nrOfParagraph(p) );
10643 fschmid 130
 
16809 jghali 131
        QString styleName = "";
7990 cbradney 132
        ParaStyleComboBox* paraStyleCombo = new ParaStyleComboBox(this);
7992 cbradney 133
        paraStyleCombo->setDoc(editor->doc);
6900 avox 134
        if ((CurrentPar < static_cast<int>(editor->StyledText.nrOfParagraphs())) && (editor->StyledText.length() != 0))
374 Franz 135
        {
7087 subik 136
                int len = editor->StyledText.endOfParagraph(CurrentPar) - editor->StyledText.startOfParagraph(CurrentPar);
6900 avox 137
                if (len > 0)
16809 jghali 138
                        styleName = editor->StyledText.paragraphStyle(pos).parent(); //FIXME ParaStyleComboBox and use localized style name
374 Franz 139
        }
16809 jghali 140
        paraStyleCombo->setFormat(styleName);
9067 avox 141
        connect(paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SLOT(setPStyle(const QString&)));
8601 jghali 142
        pmen->clear();
9525 fschmid 143
        paraStyleAct = new QWidgetAction(this);
144
        paraStyleAct->setDefaultWidget(paraStyleCombo);
10643 fschmid 145
        pmen->addAction(paraStyleAct);
16809 jghali 146
        //pmen->addAction( tr("Edit Styles..."), this, SLOT(editStyles()));
10643 fschmid 147
        pmen->exec(QCursor::pos());
374 Franz 148
}
149
 
15448 craig 150
//void SideBar::editStyles()
151
//{
152
//      emit sigEditStyles();
153
//}
1893 subik 154
 
9067 avox 155
void SideBar::setPStyle(const QString& name)
374 Franz 156
{
9067 avox 157
        emit ChangeStyle(CurrentPar, name);
10643 fschmid 158
        pmen->close();
374 Franz 159
}
160
 
371 Franz 161
void SideBar::paintEvent(QPaintEvent *e)
162
{
373 Franz 163
        inRep = true;
371 Franz 164
        QLabel::paintEvent(e);
12998 fschmid 165
        QPair<int, int> paraInfo;
166
        QList< QPair<int,int> > paraList;
12847 cbradney 167
        if (editor != NULL)
10643 fschmid 168
        {
12997 jghali 169
                QRect  edRect = editor->viewport()->rect();
170
                QPoint pt1 = edRect.topLeft(), pt2 = edRect.bottomRight();
171
                QTextCursor cur1 = editor->cursorForPosition(pt1);
172
                QTextCursor cur2 = editor->cursorForPosition(pt2);
173
                int pos1 = cur1.position(), pos2 = cur2.position();
174
                pos1 = editor->StyledText.prevParagraph(pos1);
175
                pos1 = (pos1 == 0) ? 0 : (pos1 + 1);
176
                pos2 = editor->StyledText.nextParagraph(pos2);
177
                while ((pos1 <= pos2) && (pos1 < editor->StyledText.length()))
12847 cbradney 178
                {
12998 fschmid 179
                        paraInfo.first = pos1;
12997 jghali 180
                        if (editor->StyledText.item(pos1)->ch == SpecialChars::PARSEP)
181
                        {
12998 fschmid 182
                                paraInfo.second = pos1;
12997 jghali 183
                                pos1 += 1;
184
                        }
185
                        else
186
                        {
187
                                pos1 = editor->StyledText.nextParagraph(pos1) + 1;
12998 fschmid 188
                                paraInfo.second = qMax(0, qMin(pos1 - 1, editor->StyledText.length() - 1));
12997 jghali 189
                        }
190
                        paraList.append(paraInfo);
12847 cbradney 191
                }
10643 fschmid 192
        }
193
        QPainter p;
371 Franz 194
        p.begin(this);
12847 cbradney 195
        if ((editor != NULL) && (noUpdt))
371 Franz 196
        {
11998 jghali 197
                QString trNoStyle = tr("No Style");
12997 jghali 198
                for (int pa = 0; pa < paraList.count(); ++pa)
371 Franz 199
                {
12998 fschmid 200
                        QPair<int,int> paraInfo = paraList[pa];
12997 jghali 201
                        // Draw paragraph style name first
202
                        QTextCursor cur(editor->document());
12998 fschmid 203
                        cur.setPosition(paraInfo.first);
12997 jghali 204
                        QTextBlock blockStart = cur.block();
12998 fschmid 205
                        QTextLine  lineStart  = blockStart.layout()->lineForTextPosition(paraInfo.first - blockStart.position());
12997 jghali 206
                        if (lineStart.isValid())
371 Franz 207
                        {
12997 jghali 208
                                QPointF blockPos = blockStart.layout()->position();
209
                                QRect re = lineStart.rect().translated(0, blockPos.y()).toRect();
210
                                re.setWidth(width()-5);
211
                                re.setHeight(re.height()-2);
212
                                re.translate(5, 2-offs);
213
                                if ((re.top() < height()) && (re.top() >= 0))
214
                                {
12998 fschmid 215
                                        QString parname = editor->StyledText.paragraphStyle(paraInfo.first).parent();
12997 jghali 216
                                        if (parname.isEmpty())
217
                                                parname = trNoStyle;
218
                                        p.drawText(re, Qt::AlignLeft | Qt::AlignTop, parname);
219
                                }
371 Franz 220
                        }
12997 jghali 221
                        // Draw paragraph separation line
12998 fschmid 222
                        cur.setPosition(paraInfo.second);
12997 jghali 223
                        QTextBlock blockEnd = cur.block();
12998 fschmid 224
                        QTextLine  lineEnd  = blockEnd.layout()->lineForTextPosition(paraInfo.second - blockEnd.position());
12997 jghali 225
                        if (lineEnd.isValid())
226
                        {
227
                                QPointF blockPos = blockEnd.layout()->position();
228
                                QRect re = lineEnd.rect().translated(0, 2 + blockPos.y()).toRect();
229
                                if ((re.bottom() - offs < height()) && (re.bottom() - offs >= 0))
230
                                        p.drawLine(0, re.bottom()-offs, width()-1, re.bottom() - offs);
231
                        }
371 Franz 232
                }
233
        }
10643 fschmid 234
        p.end();
373 Franz 235
        inRep = false;
371 Franz 236
}
237
 
795 fschmid 238
void SideBar::doMove(int, int y)
371 Franz 239
{
10643 fschmid 240
        offs -= y;
373 Franz 241
        if (!inRep)
242
                update();
371 Franz 243
}
244
 
245
void SideBar::doRepaint()
246
{
373 Franz 247
        if (!inRep)
248
                update();
371 Franz 249
}
250
 
372 Franz 251
void SideBar::setRepaint(bool r)
252
{
253
        noUpdt = r;
254
}
10965 fschmid 255
 
10628 fschmid 256
SEditor::SEditor(QWidget* parent, ScribusDoc *docc, StoryEditor* parentSE) : QTextEdit(parent)
102 Franz 257
{
2494 cbradney 258
        setCurrentDocument(docc);
4552 cbradney 259
        parentStoryEditor=parentSE;
353 Franz 260
        wasMod = false;
385 Franz 261
        StoredSel = false;
8239 avox 262
        SelCharStart = 0;
263
        SelParaStart = 0;
351 Franz 264
        StyledText.clear();
10628 fschmid 265
        document()->setUndoRedoEnabled(true);
355 Franz 266
        viewport()->setAcceptDrops(false);
3034 cbradney 267
        unicodeTextEditMode = false;
11501 jghali 268
        blockContentsChangeHook = 0;
10628 fschmid 269
        setAutoFillBackground(true);
376 Franz 270
        connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
11501 jghali 271
        connect(this->document(), SIGNAL(contentsChange(int, int, int)), this, SLOT(handleContentsChange(int, int, int)));
17255 fschmid 272
        SuspendContentsChange = 0;
102 Franz 273
}
274
 
2494 cbradney 275
void SEditor::setCurrentDocument(ScribusDoc *docc)
276
{
277
        doc = docc;
7369 avox 278
        StyledText = StoryText(docc);
2494 cbradney 279
}
280
 
8637 cbradney 281
void SEditor::inputMethodEvent(QInputMethodEvent *event)
2233 fschmid 282
{
8637 cbradney 283
        QString uc = event->commitString();
17255 fschmid 284
        SuspendContentsChange = 1;      // prevent our handler from doing anything
285
        bool changed = false;
286
        int pos;
287
        if(textCursor().hasSelection())
2233 fschmid 288
        {
17255 fschmid 289
                pos =  textCursor().selectionStart();
290
                StyledText.removeChars(pos, textCursor().selectionEnd() - pos);
291
                changed = true;
292
        }
293
        pos = -1;
294
        if(!uc.isEmpty())
295
        {
296
                if ((*doc->AllFonts)[CurrFont].canRender(uc[0]))
297
                {
298
                        pos = textCursor().hasSelection() ? textCursor().selectionStart() : textCursor().position();
299
                        pos = qMin(pos, StyledText.length());
300
                }
301
                else
302
                {
303
                        event->setCommitString("");
304
                }
305
        }
306
        QTextEdit::inputMethodEvent(event);
307
        SuspendContentsChange = 0;
308
        if(pos >= 0)
309
        {
310
                handleContentsChange(pos, 0, uc.length());
311
                changed = true;
312
        }
313
        if(changed)
314
        {
315
                emit SideBarUp(true);
316
                emit SideBarUpdate();
317
        }
318
/*      if ((!uc.isEmpty()) && ((*doc->AllFonts)[CurrFont].canRender(uc[0])))
319
        {
11501 jghali 320
                // Should be processed by the handleContentsChange slot
321
                // insertCharsInternal(event->commitString());
10628 fschmid 322
                QTextEdit::inputMethodEvent(event);
10965 fschmid 323
                emit SideBarUp(true);
324
                emit SideBarUpdate();
17255 fschmid 325
        } */
2233 fschmid 326
}
327
 
351 Franz 328
void SEditor::keyPressEvent(QKeyEvent *k)
113 Franz 329
{
10965 fschmid 330
        emit SideBarUp(false);
12290 cbradney 331
//      int pos = textCursor().position();
2369 cbradney 332
        int keyMod=0;
10390 cbradney 333
        if (k->modifiers() & Qt::ShiftModifier)
8523 cbradney 334
                keyMod |= Qt::SHIFT;
10390 cbradney 335
        if (k->modifiers() & Qt::ControlModifier)
8523 cbradney 336
                keyMod |= Qt::CTRL;
10390 cbradney 337
        if (k->modifiers() & Qt::AltModifier)
8523 cbradney 338
                keyMod |= Qt::ALT;
3767 subik 339
 
12902 jghali 340
        QKeySequence currKeySeq = QKeySequence(k->key() | keyMod);
341
        QKeySequence uniKeySeq  = doc->scMW()->scrActions["specialUnicodeSequenceBegin"]->shortcut();
342
        if(currKeySeq.matches(uniKeySeq)==QKeySequence::ExactMatch)
343
        {
344
                unicodeTextEditMode = true;
345
                unicodeInputCount = 0;
346
                unicodeInputString = "";
347
                return;
348
        }
349
 
926 fschmid 350
        QString uc = k->text();
10390 cbradney 351
        if ((k->modifiers() == Qt::ControlModifier) ||
10918 jghali 352
                (k->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) ||
353
                (k->modifiers() == (Qt::ControlModifier | Qt::KeypadModifier)) ||
354
                (k->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier | Qt::KeypadModifier))
10390 cbradney 355
           )
351 Franz 356
        {
10390 cbradney 357
                switch (k->key())
358
                {
359
                        case Qt::Key_K:
10628 fschmid 360
                                moveCursor(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);
11501 jghali 361
                                textCursor().removeSelectedText();
10390 cbradney 362
                                break;
363
                        case Qt::Key_D:
10628 fschmid 364
                                moveCursor(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
365
                                textCursor().removeSelectedText();
10390 cbradney 366
                                break;
367
                        case Qt::Key_H:
10628 fschmid 368
                                moveCursor(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor);
369
                                textCursor().removeSelectedText();
10390 cbradney 370
                                break;
11501 jghali 371
                        /*case Qt::Key_X:
10390 cbradney 372
                                cut();
373
                                return;
374
                                break;
375
                        case Qt::Key_V:
376
                                paste();
377
                                return;
11501 jghali 378
                                break;*/
10390 cbradney 379
                        case Qt::Key_Y:
380
                        case Qt::Key_Z:
10965 fschmid 381
                                emit SideBarUp(true);
10390 cbradney 382
                                return;
383
                                break;
384
                }
385
        }
386
        if ((k->modifiers() == Qt::NoModifier) ||
387
                (k->modifiers() == Qt::KeypadModifier) ||
388
                (k->modifiers() == Qt::ShiftModifier) ||
10918 jghali 389
                (k->modifiers() == (Qt::ControlModifier | Qt::AltModifier)) ||
390
                (k->modifiers() == (Qt::ControlModifier | Qt::AltModifier | Qt::ShiftModifier)) // Shift + AltGr on Windows for polish characters
10390 cbradney 391
           )
392
        {
393
                if (unicodeTextEditMode)
394
                {
395
                        int conv = 0;
396
                        bool ok = false;
397
                        unicodeInputString += k->text();
398
                        conv = unicodeInputString.toInt(&ok, 16);
399
                        if (!ok)
1866 fschmid 400
                        {
10390 cbradney 401
                                unicodeTextEditMode = false;
402
                                unicodeInputCount = 0;
403
                                unicodeInputString = "";
404
                                return;
405
                        }
406
                        unicodeInputCount++;
407
                        if (unicodeInputCount == 4)
408
                        {
409
                                unicodeTextEditMode = false;
410
                                unicodeInputCount = 0;
411
                                unicodeInputString = "";
412
                                if (ok)
413
                                {
414
                                        if (conv < 31)
415
                                                conv = 32;
10628 fschmid 416
                                        insertPlainText(QString(QChar(conv)));
10965 fschmid 417
                                        emit SideBarUp(true);
418
                                        emit SideBarUpdate();
1866 fschmid 419
                                        return;
10390 cbradney 420
                                }
1866 fschmid 421
                        }
10390 cbradney 422
                        else
351 Franz 423
                        {
10965 fschmid 424
                                emit SideBarUp(true);
425
                                emit SideBarUpdate();
10390 cbradney 426
                                return;
427
                        }
428
                }
429
                wasMod = false;
430
                switch (k->key())
431
                {
432
                        case Qt::Key_Escape:
433
                                k->ignore();
434
                                break;
435
                        case Qt::Key_Shift:
436
                        case Qt::Key_Control:
437
                        case Qt::Key_Alt:
438
                                wasMod = true;
439
                                break;
440
                        case Qt::Key_Return:
441
                        case Qt::Key_Enter:
14273 subik 442
                                if (k->modifiers() == Qt::ShiftModifier)
443
                                        insertChars(SpecialChars::LINEBREAK, k->text());
444
                                else
11501 jghali 445
                                        insertChars(SpecialChars::PARSEP, k->text());
14273 subik 446
                                emit SideBarUp(true);
447
                                emit SideBarUpdate();
448
                                return;
10390 cbradney 449
                                break;
11501 jghali 450
                        case Qt::Key_Delete:
451
                        case Qt::Key_Backspace:
10390 cbradney 452
                        case Qt::Key_Left:
453
                        case Qt::Key_Right:
10581 cbradney 454
                        case Qt::Key_PageUp:
455
                        case Qt::Key_PageDown:
10390 cbradney 456
                        case Qt::Key_Up:
457
                        case Qt::Key_Down:
458
                        case Qt::Key_Home:
459
                        case Qt::Key_End:
460
                                break;
461
                        default:
462
                                if ((!k->text().isEmpty()) && ((*doc->AllFonts)[CurrFont].canRender(uc[0])))
463
                                {
10628 fschmid 464
                                        QTextEdit::keyPressEvent(k);
10965 fschmid 465
                                        emit SideBarUp(true);
466
                                        emit SideBarUpdate();
372 Franz 467
                                }
10390 cbradney 468
                                return;
469
                                break;
470
                }
351 Franz 471
        }
10628 fschmid 472
        QTextEdit::keyPressEvent(k);
10965 fschmid 473
        emit SideBarUp(true);
474
        emit SideBarUpdate();
113 Franz 475
}
476
 
11501 jghali 477
void SEditor::handleContentsChange(int position, int charsRemoved, int charsAdded)
478
{
17255 fschmid 479
        // As of Qt 4.7.4, Cococa-QTextEdit output of input method is broken.
480
        // We need a workaround to avoit the bug.
481
        if(SuspendContentsChange != 0)
482
                return;
11501 jghali 483
        if (blockContentsChangeHook <= 0)
484
        {
11991 jghali 485
                if (charsRemoved > 0 && StyledText.length() > 0)
11501 jghali 486
                        StyledText.removeChars(position, charsRemoved);
487
                if (charsAdded > 0)
488
                {
11510 jghali 489
                        QTextCursor cursor = textCursor();
490
                        cursor.setPosition(position);
491
                        cursor.setPosition(position + charsAdded, QTextCursor::KeepAnchor);
492
                        QString addedChars = cursor.selectedText();
11501 jghali 493
                        if (addedChars.length() > 0)
494
                                StyledText.insertChars(position, addedChars, true);
12369 jghali 495
                        //qDebug("handleContentsChange : - %01d, + %01d, len %01d", charsRemoved, charsAdded, addedChars.length());
11510 jghali 496
                }      
11501 jghali 497
        }
498
}
499
 
385 Franz 500
void SEditor::focusOutEvent(QFocusEvent *e)
501
{
10628 fschmid 502
        if (textCursor().hasSelection())
385 Franz 503
        {
10628 fschmid 504
                SelParaStart = textCursor().selectionStart();
505
                SelParaEnd = textCursor().selectionEnd();
385 Franz 506
                StoredSel = true;
507
        }
10628 fschmid 508
        else
509
        {
510
                SelParaStart = textCursor().position();
385 Franz 511
                StoredSel = false;
7888 avox 512
        }
10628 fschmid 513
        QTextEdit::focusOutEvent(e);
385 Franz 514
}
515
 
7395 fschmid 516
void SEditor::focusInEvent(QFocusEvent *e)
517
{
518
        if (StoredSel)
519
        {
10628 fschmid 520
                textCursor().setPosition(SelParaStart);
10671 fschmid 521
                textCursor().setPosition(SelParaEnd, QTextCursor::KeepAnchor);
7395 fschmid 522
                StoredSel = false;
523
        }
10628 fschmid 524
        else
525
        {
526
                textCursor().setPosition(SelParaStart);
8239 avox 527
                StoredSel = false;
528
        }
529
 
10628 fschmid 530
        QTextEdit::focusInEvent(e);
7395 fschmid 531
}
532
 
11501 jghali 533
void SEditor::insertChars(const QString& text)
102 Franz 534
{
10628 fschmid 535
        if (textCursor().hasSelection())
11501 jghali 536
                textCursor().removeSelectedText();
537
        ++blockContentsChangeHook;
14273 subik 538
        QTextCursor c(textCursor());
539
        int pos = qMin(c.position(), StyledText.length());
11501 jghali 540
        StyledText.insertChars(pos, text, true);
14273 subik 541
//      insertPlainText(text);
542
        insertUpdate(pos, text.length());
543
        c.setPosition(pos + text.length());
544
        setTextCursor(c);
545
        setColor(false); // HACK to force normal edit color
11501 jghali 546
        --blockContentsChangeHook;
547
}
548
 
549
void SEditor::insertChars(const QString& styledText, const QString& editText)
550
{
551
        if ((styledText.length() == editText.length()) && !styledText.isEmpty())
552
        {
14273 subik 553
                if (textCursor().hasSelection())
554
                        textCursor().removeSelectedText();
15804 jghali 555
 
11501 jghali 556
                ++blockContentsChangeHook;
15804 jghali 557
                QTextCursor cursor(textCursor());
558
                int pos = qMin(cursor.position(), StyledText.length());
11501 jghali 559
                StyledText.insertChars(pos, styledText, true);
15804 jghali 560
                insertPlainText(editText);
561
                cursor.setPosition(pos + editText.length());
562
                setTextCursor(cursor);
11501 jghali 563
                --blockContentsChangeHook;
564
        }
565
}
566
 
567
void SEditor::insertCharsInternal(const QString& t)
568
{
569
        if (textCursor().hasSelection())
351 Franz 570
                deleteSel();
12098 jghali 571
        int pos = textCursor().hasSelection() ? textCursor().selectionStart() : textCursor().position();
572
        pos = qMin(pos, StyledText.length());
573
        insertCharsInternal(t, pos);
351 Franz 574
}
575
 
11501 jghali 576
void SEditor::insertCharsInternal(const QString& t, int pos)
11482 jghali 577
{
578
        if (textCursor().hasSelection())
12098 jghali 579
                textCursor().removeSelectedText();
580
        int oldLength = StyledText.length();
11482 jghali 581
        StyledText.insertChars(pos, t, true);
12098 jghali 582
        int newLength = StyledText.length();
583
        insertUpdate(pos, newLength - oldLength);
11482 jghali 584
}
585
 
11501 jghali 586
void SEditor::insertStyledText(const StoryText& styledText)
362 Franz 587
{
11360 jghali 588
        if (styledText.length() == 0)
362 Franz 589
                return;
12098 jghali 590
        int pos = textCursor().hasSelection() ? textCursor().selectionStart() : textCursor().position();
591
        pos = qMin(pos, StyledText.length());
592
        insertStyledText(styledText, pos);
362 Franz 593
}
594
 
11501 jghali 595
void SEditor::insertStyledText(const StoryText& styledText, int pos)
11482 jghali 596
{
597
        if (styledText.length() == 0)
598
                return;
599
        if (textCursor().hasSelection())
12098 jghali 600
                textCursor().removeSelectedText();
601
        int oldLength = StyledText.length();
11482 jghali 602
        StyledText.insert(pos, styledText);
12098 jghali 603
        int newLength = StyledText.length();
604
        insertUpdate(pos, newLength - oldLength);
11482 jghali 605
}
606
 
1957 cbradney 607
void SEditor::saveItemText(PageItem *currItem)
351 Franz 608
{
1957 cbradney 609
        currItem->itemText.clear();
9613 avox 610
        currItem->itemText.setDefaultStyle(StyledText.defaultStyle());
6900 avox 611
        currItem->itemText.append(StyledText);
612
/* uh... FIXME
613
                if (ch == SpecialChars::OBJECT)
253 Franz 614
                        {
5184 avox 615
                                PageItem* embedded = chars->at(c)->cembedded;
5781 cbradney 616
                                currItem->doc()->FrameItems.append(embedded);
5184 avox 617
                                if (embedded->Groups.count() != 0)
2955 fschmid 618
                                {
619
                                        for (uint ga=0; ga<FrameItems.count(); ++ga)
620
                                        {
621
                                                if (FrameItems.at(ga)->Groups.count() != 0)
622
                                                {
5184 avox 623
                                                        if (FrameItems.at(ga)->Groups.top() == embedded->Groups.top())
2955 fschmid 624
                                                        {
5184 avox 625
                                                                if (FrameItems.at(ga)->ItemNr != embedded->ItemNr)
2955 fschmid 626
                                                                {
5781 cbradney 627
                                                                        if (currItem->doc()->FrameItems.find(FrameItems.at(ga)) == -1)
628
                                                                                currItem->doc()->FrameItems.append(FrameItems.at(ga));
2955 fschmid 629
                                                                }
630
                                                        }
631
                                                }
632
                                        }
633
                                }
5184 avox 634
                                currItem->itemText.insertObject(pos, embedded);
2499 fschmid 635
                        }
6900 avox 636
*/
351 Franz 637
}
638
 
6904 avox 639
void SEditor::setAlign(int align)
351 Franz 640
{
16959 jghali 641
        QTextCursor tCursor = this->textCursor();
642
        setAlign(tCursor, align);
643
}
644
 
645
void SEditor::setAlign(QTextCursor& tCursor, int align)
646
{
11508 jghali 647
        ++blockContentsChangeHook;
16959 jghali 648
        QTextBlockFormat blockFormat;
351 Franz 649
        switch (align)
167 Franz 650
        {
351 Franz 651
        case 0:
16959 jghali 652
                blockFormat.setAlignment(Qt::AlignLeft);
351 Franz 653
                break;
654
        case 1:
16959 jghali 655
                blockFormat.setAlignment(Qt::AlignCenter);
351 Franz 656
                break;
657
        case 2:
16959 jghali 658
                blockFormat.setAlignment(Qt::AlignRight);
351 Franz 659
                break;
660
        case 3:
661
        case 4:
16959 jghali 662
                blockFormat.setAlignment(Qt::AlignJustify);
351 Franz 663
                break;
664
        default:
665
                break;
167 Franz 666
        }
16959 jghali 667
        tCursor.setBlockFormat(blockFormat);
11508 jghali 668
        --blockContentsChangeHook;
351 Franz 669
}
670
 
5184 avox 671
 
1957 cbradney 672
void SEditor::loadItemText(PageItem *currItem)
351 Franz 673
{
674
        StyledText.clear();
2499 fschmid 675
        FrameItems.clear();
12688 jghali 676
        StyledText.setDefaultStyle(currItem->itemText.defaultStyle());
6900 avox 677
        StyledText.append(currItem->itemText);
678
        updateAll();
7045 avox 679
        int npars = currItem->itemText.nrOfParagraphs();
8239 avox 680
        SelParaStart = 0;
16626 jghali 681
        while (currItem->itemText.cursorPosition() >= (SelCharStart = currItem->itemText.endOfParagraph(SelParaStart))
8239 avox 682
                   && SelParaStart < npars)
683
                ++SelParaStart;
16626 jghali 684
        if (currItem->itemText.cursorPosition() < SelCharStart)
685
                SelCharStart = currItem->itemText.cursorPosition();
8239 avox 686
        SelCharStart -= currItem->itemText.startOfParagraph(SelParaStart);
687
        StoredSel = false;
13085 jghali 688
        //qDebug() << "SE::loadItemText: cursor";
10628 fschmid 689
//      setCursorPosition(SelParaStart, SelCharStart);
8239 avox 690
        emit setProps(SelParaStart, SelCharStart);
10671 fschmid 691
        SelParaStart = 0;
102 Franz 692
}
693
 
1957 cbradney 694
void SEditor::loadText(QString tx, PageItem *currItem)
102 Franz 695
{
1915 fschmid 696
        setUpdatesEnabled(false);
351 Franz 697
        QString Text = "";
698
        StyledText.clear();
6900 avox 699
        StyledText.setDefaultStyle(currItem->itemText.defaultStyle());
7087 subik 700
        StyledText.insertChars(0, tx);
6900 avox 701
        updateAll();
702
        if (StyledText.length() != 0)
351 Franz 703
                emit setProps(0, 0);
13085 jghali 704
        //qDebug() << "SE::loadText: cursor";
10628 fschmid 705
        textCursor().setPosition(0);
102 Franz 706
}
707
 
366 Franz 708
void SEditor::updateAll()
709
{
12159 jghali 710
        ++blockContentsChangeHook;
6900 avox 711
        clear();
12098 jghali 712
        insertUpdate(0, StyledText.length());
12159 jghali 713
        --blockContentsChangeHook;
12098 jghali 714
}
715
 
716
void SEditor::insertUpdate(int position, int len)
717
{
718
        if (StyledText.length() == 0 || len == 0)
366 Franz 719
                return;
12098 jghali 720
        QString chars, text = "";
721
        ++blockContentsChangeHook;
1915 fschmid 722
        setUpdatesEnabled(false);
11998 jghali 723
        this->blockSignals(true);
13214 jghali 724
        //prevent layout of QTextDocument while updating
725
        this->textCursor().beginEditBlock();
11998 jghali 726
        int cursorPos = textCursor().position();
727
        int scrollPos = verticalScrollBar()->value();
12098 jghali 728
        int end  = qMin(StyledText.length(), position + len);
729
        int cSty = StyledText.charStyle(position).effects();
730
        int pAli = StyledText.paragraphStyle(position).alignment();
731
        setAlign(pAli);
16807 jghali 732
        setEffects(cSty);
12098 jghali 733
        for (int pos = position; pos < end; ++pos)
366 Franz 734
        {
12098 jghali 735
                const CharStyle& cstyle(StyledText.charStyle(pos));
736
                const QChar ch = StyledText.text(pos);
737
                if (ch == SpecialChars::PARSEP)
366 Franz 738
                {
12098 jghali 739
                        text += "\n";
740
                        const ParagraphStyle& pstyle(StyledText.paragraphStyle(pos));
741
                        pAli = pstyle.alignment();
742
                        setAlign(pAli);
16807 jghali 743
                        setEffects(cSty);
12098 jghali 744
                        insertPlainText(text);
745
                        cSty = cstyle.effects();
746
                        text = "";
366 Franz 747
                        continue;
748
                }
12098 jghali 749
                if (cSty != cstyle.effects() ||
6900 avox 750
                                ch == SpecialChars::OBJECT ||
751
                                ch == SpecialChars::PAGENUMBER ||
11713 fschmid 752
                                ch == SpecialChars::PAGECOUNT ||
6900 avox 753
                                ch == SpecialChars::NBSPACE ||
754
                                ch == SpecialChars::FRAMEBREAK ||
755
                                ch == SpecialChars::COLBREAK ||
756
                                ch == SpecialChars::NBHYPHEN ||
757
                                ch == SpecialChars::LINEBREAK)
12098 jghali 758
                {
759
                        setAlign(pAli);
16807 jghali 760
                        setEffects(cSty);
12098 jghali 761
                        insertPlainText(text);
762
                        cSty = cstyle.effects();
763
                        text = "";
366 Franz 764
                }
12098 jghali 765
                if (ch == SpecialChars::OBJECT)
12046 jghali 766
                {
12098 jghali 767
                        setColor(true);
768
                        insertPlainText("@");
769
                        setColor(false);
12046 jghali 770
                }
12098 jghali 771
                else if (ch == SpecialChars::PAGENUMBER)
772
                {
773
                        setColor(true);
774
                        insertPlainText("#");
775
                        setColor(false);
776
                }
777
                else if (ch == SpecialChars::PAGECOUNT)
778
                {
779
                        setColor(true);
780
                        insertPlainText("%");
781
                        setColor(false);
782
                }
783
                else if (ch == SpecialChars::NBSPACE)
784
                {
785
                        setColor(true);
786
                        insertPlainText("_");
787
                        setColor(false);
788
                }
789
                else if (ch == SpecialChars::FRAMEBREAK)
790
                {
791
                        setColor(true);
792
                        insertPlainText("|");
793
                        setColor(false);
794
                }
795
                else if (ch == SpecialChars::COLBREAK)
796
                {
797
                        setColor(true);
798
                        insertPlainText("^");
799
                        setColor(false);
800
                }
801
                else if (ch == SpecialChars::NBHYPHEN)
802
                {
803
                        setColor(true);
804
                        insertPlainText("=");
805
                        setColor(false);
806
                }
807
                else if (ch == SpecialChars::LINEBREAK)
808
                {
809
                        setColor(true);
810
                        insertPlainText("*");
811
                        setColor(false);
812
                }
813
                else
814
                        text += ch;
366 Franz 815
        }
12098 jghali 816
        if (position < end)
817
        {
818
                const ParagraphStyle& pstyle(StyledText.paragraphStyle(end - 1));
819
                setAlign(pstyle.alignment());
820
        }
16807 jghali 821
        setEffects(cSty);
12098 jghali 822
        insertPlainText(text);
11998 jghali 823
        QTextCursor tCursor = textCursor();
824
        tCursor.setPosition(cursorPos);
825
        setTextCursor(tCursor);
826
        verticalScrollBar()->setValue(scrollPos);
13214 jghali 827
        this->textCursor().endEditBlock();
11998 jghali 828
        this->blockSignals(false);
1915 fschmid 829
        setUpdatesEnabled(true);
11501 jghali 830
        --blockContentsChangeHook;
11998 jghali 831
        emit textChanged();
12098 jghali 832
        //CB Removed to fix 2083 setCursorPosition(p, i);       
366 Franz 833
}
834
 
6900 avox 835
 
351 Franz 836
void SEditor::updateFromChars(int pa)
102 Franz 837
{
6900 avox 838
        int start = StyledText.startOfParagraph(pa);
16959 jghali 839
        int end   = StyledText.endOfParagraph(pa);
6900 avox 840
        if (start >= end)
351 Franz 841
                return;
1915 fschmid 842
        setUpdatesEnabled(false);
10628 fschmid 843
        int SelStart = start;
16959 jghali 844
        int SelEnd   = start;
10628 fschmid 845
        int pos = textCursor().position();
846
        textCursor().clearSelection();
16959 jghali 847
        int effects = StyledText.charStyle(start).effects();
6900 avox 848
        for (int a = start; a < end; ++a)
167 Franz 849
        {
16959 jghali 850
                if (effects == StyledText.charStyle(a).effects())
351 Franz 851
                        SelEnd++;
852
                else
167 Franz 853
                {
10628 fschmid 854
                        textCursor().setPosition(SelStart);
855
                        textCursor().setPosition(SelEnd, QTextCursor::KeepAnchor);
16959 jghali 856
                        setEffects(effects);
10628 fschmid 857
                        textCursor().clearSelection();
16959 jghali 858
                        effects = StyledText.charStyle(a).effects();
362 Franz 859
                        SelStart = SelEnd;
351 Franz 860
                        SelEnd++;
167 Franz 861
                }
351 Franz 862
        }
16959 jghali 863
        QTextCursor tCursor = textCursor();
864
        tCursor.setPosition(SelStart);
865
        tCursor.setPosition(SelEnd, QTextCursor::KeepAnchor);
866
        setEffects(tCursor, effects);
867
        setAlign(tCursor, StyledText.paragraphStyle(start).alignment());
868
        tCursor.clearSelection();
1915 fschmid 869
        setUpdatesEnabled(true);
16959 jghali 870
        tCursor = textCursor();
11998 jghali 871
        tCursor.setPosition(pos);
872
        setTextCursor(tCursor);
351 Franz 873
}
874
 
6900 avox 875
/* updates the internal StyledText structure, applies 'newStyle' to the selection */
876
void SEditor::updateSel(const ParagraphStyle& newStyle)
351 Franz 877
{
6900 avox 878
        int PStart, PEnd, SelStart, SelEnd, start;
385 Franz 879
        if (StoredSel)
880
        {
10628 fschmid 881
                textCursor().setPosition(SelParaStart);
882
                textCursor().setPosition(SelParaEnd, QTextCursor::KeepAnchor);
385 Franz 883
                StoredSel = false;
884
        }
10628 fschmid 885
        SelStart = textCursor().selectionStart();
886
        PStart = StyledText.nrOfParagraph(SelStart);
887
        SelEnd = textCursor().selectionEnd();
888
        PEnd = StyledText.nrOfParagraph(SelEnd);
889
        for (int pa = PStart; pa <= PEnd; ++pa)
351 Franz 890
        {
10628 fschmid 891
                start = StyledText.startOfParagraph(pa);
6900 avox 892
                StyledText.applyStyle(start, newStyle);
167 Franz 893
        }
102 Franz 894
}
895
 
6900 avox 896
void SEditor::updateSel(const CharStyle& newStyle)
897
{
898
        if (StoredSel)
899
        {
10628 fschmid 900
                textCursor().setPosition(SelParaStart);
901
                textCursor().setPosition(SelParaEnd, QTextCursor::KeepAnchor);
6900 avox 902
                StoredSel = false;
903
        }
10628 fschmid 904
        int start = textCursor().selectionStart();
905
        int end = textCursor().selectionEnd();
7623 avox 906
        if (start >= 0 && start < end)
907
                StyledText.applyCharStyle(start, end-start, newStyle);
6900 avox 908
}
909
 
910
 
351 Franz 911
void SEditor::deleteSel()
102 Franz 912
{
10628 fschmid 913
        int start = textCursor().selectionStart();
11501 jghali 914
        int end   = textCursor().selectionEnd();
6902 avox 915
        if (end > start)
916
                StyledText.removeChars(start, end-start);
10628 fschmid 917
        textCursor().setPosition(start);
10671 fschmid 918
        StoredSel = false;
102 Franz 919
}
920
 
16959 jghali 921
void SEditor::setEffects(int effects)
102 Franz 922
{
16959 jghali 923
        QTextCursor tCursor = textCursor();
924
        setEffects(tCursor, effects);
925
        //setTextCursor(tCursor);
926
}
927
 
928
void SEditor::setEffects(QTextCursor& tCursor, int effects)
929
{
11508 jghali 930
        ++blockContentsChangeHook;
10628 fschmid 931
        QTextCharFormat charF;
16959 jghali 932
        if (effects & 8)
10628 fschmid 933
                charF.setFontUnderline(true);
351 Franz 934
        else
10628 fschmid 935
                charF.setFontUnderline(false);
16959 jghali 936
        if (effects & 16)
10628 fschmid 937
                charF.setFontStrikeOut(true);
374 Franz 938
        else
10628 fschmid 939
                charF.setFontStrikeOut(false);
16959 jghali 940
        if (effects & 1)
10628 fschmid 941
                charF.setVerticalAlignment(QTextCharFormat::AlignSuperScript);
16959 jghali 942
        else if (effects & 2)
10628 fschmid 943
                charF.setVerticalAlignment(QTextCharFormat::AlignSubScript);
351 Franz 944
        else
10628 fschmid 945
                charF.setVerticalAlignment(QTextCharFormat::AlignNormal);
12046 jghali 946
        tCursor.setCharFormat(charF);
11508 jghali 947
        --blockContentsChangeHook;
351 Franz 948
}
949
 
11333 jghali 950
void SEditor::setColor(bool marker)
351 Franz 951
{
952
        QColor tmp;
2407 fschmid 953
        if (marker)
8522 cbradney 954
                tmp = QColor(Qt::red);
351 Franz 955
        else
8522 cbradney 956
                tmp = QColor(Qt::black);
10671 fschmid 957
        setTextColor(tmp);
351 Franz 958
}
103 Franz 959
 
362 Franz 960
void SEditor::copy()
961
{
10965 fschmid 962
        emit SideBarUp(false);
10628 fschmid 963
        if ((textCursor().hasSelection()) && (!textCursor().selectedText().isEmpty()))
362 Franz 964
        {
376 Franz 965
                disconnect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
11360 jghali 966
                QMimeData* mimeData = createMimeDataFromSelection();
967
                QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
376 Franz 968
                connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(ClipChange()));
969
                emit PasteAvail();
362 Franz 970
        }
10965 fschmid 971
        emit SideBarUp(true);
362 Franz 972
}
973
 
351 Franz 974
void SEditor::cut()
975
{
362 Franz 976
        copy();
10965 fschmid 977
        emit SideBarUp(false);
10628 fschmid 978
        if (textCursor().hasSelection())
979
                textCursor().removeSelectedText();
10965 fschmid 980
        emit SideBarUp(true);
981
        emit SideBarUpdate();
351 Franz 982
}
983
 
984
void SEditor::paste()
985
{
10965 fschmid 986
        emit SideBarUp(false);
12832 jghali 987
        bool useMimeStyledText = false;
988
        int  newParaCount, lengthLastPara, advanceLen = 0;
989
        int  pos = textCursor().hasSelection() ? textCursor().selectionStart() : textCursor().position();
11360 jghali 990
        const QMimeData* mimeData = QApplication::clipboard()->mimeData(QClipboard::Clipboard);
11361 jghali 991
        if (mimeData->hasFormat("application/x-scribus-styledtext"))
7394 fschmid 992
        {
11360 jghali 993
                const StyledTextMimeData* styledData = dynamic_cast<const StyledTextMimeData*>(mimeData);
12095 jghali 994
                if (styledData)
12832 jghali 995
                        useMimeStyledText = (styledData->document() == doc);
996
        }
997
        if (useMimeStyledText)
998
        {
999
                const StyledTextMimeData* styledData = dynamic_cast<const StyledTextMimeData*>(mimeData);
1000
                if (styledData)
11360 jghali 1001
                {
1002
                        const StoryText& styledText = styledData->styledText();
1003
                        advanceLen = styledText.length();
11501 jghali 1004
                        insertStyledText(styledText, pos);
11360 jghali 1005
                }
7394 fschmid 1006
        }
399 Franz 1007
        else
376 Franz 1008
        {
12832 jghali 1009
                QString data = QApplication::clipboard()->text(QClipboard::Clipboard);
11360 jghali 1010
                if (!data.isEmpty())
376 Franz 1011
                {
1012
                        data.replace(QRegExp("\r"), "");
8637 cbradney 1013
                        newParaCount=data.count("\n");
10427 cbradney 1014
                        lengthLastPara=data.length()-data.lastIndexOf("\n");
6900 avox 1015
                        data.replace(QRegExp("\n"), SpecialChars::PARSEP);
7394 fschmid 1016
//                      inserted=true;
11511 jghali 1017
                        advanceLen = data.length() /*- newParaCount*/;
11501 jghali 1018
                        insertCharsInternal(data, pos);
399 Franz 1019
                        emit PasteAvail();
376 Franz 1020
                }
399 Franz 1021
                else
1022
                {
10965 fschmid 1023
                        emit SideBarUp(true);
399 Franz 1024
                        return;
1025
                }
376 Franz 1026
        }
7394 fschmid 1027
        setUpdatesEnabled(false);
13085 jghali 1028
        //qDebug() << "SE::paste: cursor";
10628 fschmid 1029
//      setCursorPosition(currentPara, currentCharPos);
11482 jghali 1030
        QTextCursor tCursor = textCursor();
11511 jghali 1031
        tCursor.setPosition(pos + advanceLen);
11482 jghali 1032
        setTextCursor(tCursor);
11511 jghali 1033
        /*for (int a = 0; a < advanceLen; ++a)
7394 fschmid 1034
        {
10628 fschmid 1035
                moveCursor(QTextCursor::Right, QTextCursor::MoveAnchor);
11511 jghali 1036
        }*/
7394 fschmid 1037
        setUpdatesEnabled(true);
1038
//      if (inserted)
1039
//              setCursorPosition(currentPara+newParaCount,(newParaCount==0?currentCharPos:0)+lengthLastPara-1);
10628 fschmid 1040
        repaint();
10965 fschmid 1041
        emit SideBarUp(true);
1042
        emit SideBarUpdate();
351 Franz 1043
}
11360 jghali 1044
 
1045
bool SEditor::canInsertFromMimeData( const QMimeData * source ) const
1046
{
11361 jghali 1047
        if (source->hasText() || source->hasFormat("application/x-scribus-styledtext"))
11360 jghali 1048
                return true;
1049
        return false;
1050
}
1051
 
1052
QMimeData* SEditor::createMimeDataFromSelection () const
1053
{
1054
        StyledTextMimeData* mimeData = new StyledTextMimeData();
1055
        int start = textCursor().selectionStart();
1056
        int end   = textCursor().selectionEnd();
1057
        if (start < 0 || end <= start)
1058
                return mimeData;
1059
        StoryText* that = const_cast<StoryText*> (&StyledText);
1060
        that->select(start, end-start);
13018 jghali 1061
        QString selectedText = textCursor().selectedText();
1062
        selectedText.replace(QChar(0x2029), QChar('\n'));
1063
        mimeData->setText(selectedText);
12832 jghali 1064
        mimeData->setStyledText(*that, doc);
11360 jghali 1065
        return mimeData;
1066
}
1067
 
1068
void SEditor::insertFromMimeData ( const QMimeData * source )
1069
{
1070
        paste();
1071
}
1072
 
399 Franz 1073
void SEditor::SelClipChange()
1074
{
1075
        emit PasteAvail();
1076
}
1077
 
376 Franz 1078
void SEditor::ClipChange()
1079
{
1080
        emit PasteAvail();
1081
}
1082
 
10643 fschmid 1083
void SEditor::scrollContentsBy(int dx, int dy)
1084
{
1085
        emit contentsMoving(dx, dy);
10965 fschmid 1086
        QTextEdit::scrollContentsBy(dx, dy);
10643 fschmid 1087
}
1088
 
351 Franz 1089
/* Toolbar for Fill Colour */
10172 cbradney 1090
SToolBColorF::SToolBColorF(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Fill Color Settings"), parent)
351 Franz 1091
{
10172 cbradney 1092
        FillIcon = new QLabel(this);
7083 cbradney 1093
        FillIcon->setPixmap(loadIcon("16/color-fill.png"));
351 Franz 1094
        FillIcon->setScaledContents( false );
10172 cbradney 1095
        fillIconAction=addWidget(FillIcon);
1096
        fillIconAction->setVisible(true);
1097
        TxFill = new ColorCombo(false, this);
1098
        txFillAction=addWidget(TxFill);
1099
        txFillAction->setVisible(true);
351 Franz 1100
        PM2 = new ShadeButton(this);
10172 cbradney 1101
        pm2Action=addWidget(PM2);
1102
        pm2Action->setVisible(true);
1103
 
2494 cbradney 1104
        setCurrentDocument(doc);
2504 cbradney 1105
        //TxFill->listBox()->setMinimumWidth(TxFill->listBox()->maxItemWidth()+24);
351 Franz 1106
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1107
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
3767 subik 1108
 
2505 cbradney 1109
        languageChange();
351 Franz 1110
}
1111
 
10859 cbradney 1112
void SToolBColorF::changeEvent(QEvent *e)
1113
{
1114
        if (e->type() == QEvent::LanguageChange)
1115
        {
1116
                languageChange();
1117
        }
10903 cbradney 1118
        else
1119
                QWidget::changeEvent(e);
10859 cbradney 1120
}
1121
 
1122
 
2505 cbradney 1123
void SToolBColorF::languageChange()
1124
{
10397 cbradney 1125
        TxFill->setToolTip("");
1126
        PM2->setToolTip("");
1127
        TxFill->setToolTip( tr( "Color of text fill" ));
1128
        PM2->setToolTip( tr( "Saturation of color of text fill" ));
2505 cbradney 1129
}
1130
 
2494 cbradney 1131
void SToolBColorF::setCurrentDocument(ScribusDoc *doc)
1132
{
1133
        if (doc!=NULL)
10628 fschmid 1134
                TxFill->updateBox(doc->PageColors, ColorCombo::smallPixmaps, true);
1135
        else
1136
        {
1137
                TxFill->clear();
1138
                TxFill->addItem(CommonStrings::tr_NoneColor);
1139
        }
1140
//      if (doc!=NULL)
1141
//              TxFill->insertItems(doc->PageColors, ColorCombo::smallPixmaps);
2504 cbradney 1142
        resize(minimumSizeHint());
2494 cbradney 1143
}
1144
 
351 Franz 1145
void SToolBColorF::SetColor(int c)
1146
{
1147
        disconnect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
10585 fschmid 1148
        TxFill->setCurrentIndex(c);
351 Franz 1149
        connect(TxFill, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1150
}
1151
 
9920 fschmid 1152
void SToolBColorF::SetShade(double s)
351 Franz 1153
{
1154
        disconnect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
9920 fschmid 1155
        PM2->setValue(qRound(s));
351 Franz 1156
        connect(PM2, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1157
}
1158
 
1159
void SToolBColorF::newShadeHandler()
1160
{
10585 fschmid 1161
        emit NewColor(TxFill->currentIndex(), PM2->getValue());
351 Franz 1162
}
1163
 
1164
/* Toolbar for Stroke Colour */
10172 cbradney 1165
SToolBColorS::SToolBColorS(QMainWindow* parent, ScribusDoc *doc) : QToolBar( tr("Stroke Color Settings"), parent)
351 Franz 1166
{
10172 cbradney 1167
        StrokeIcon = new QLabel( "", this );
7083 cbradney 1168
        StrokeIcon->setPixmap(loadIcon("16/color-stroke.png"));
351 Franz 1169
        StrokeIcon->setScaledContents( false );
10172 cbradney 1170
        strokeIconAction=addWidget(StrokeIcon);
1171
        strokeIconAction->setVisible(true);
10469 cbradney 1172
        TxStroke = new ColorCombo(false, this);
10172 cbradney 1173
        txStrokeAction=addWidget(TxStroke);
1174
        txStrokeAction->setVisible(true);
351 Franz 1175
        PM1 = new ShadeButton(this);
10172 cbradney 1176
        pm1Action=addWidget(PM1);
1177
        pm1Action->setVisible(true);
2494 cbradney 1178
        setCurrentDocument(doc);
2504 cbradney 1179
        //TxStroke->listBox()->setMinimumWidth(TxStroke->listBox()->maxItemWidth()+24);
351 Franz 1180
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1181
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
3767 subik 1182
 
2505 cbradney 1183
        languageChange();
351 Franz 1184
}
1185
 
10859 cbradney 1186
void SToolBColorS::changeEvent(QEvent *e)
1187
{
1188
        if (e->type() == QEvent::LanguageChange)
1189
        {
1190
                languageChange();
1191
        }
10903 cbradney 1192
        else
1193
                QWidget::changeEvent(e);
10859 cbradney 1194
}
1195
 
2505 cbradney 1196
void SToolBColorS::languageChange()
1197
{
10397 cbradney 1198
        TxStroke->setToolTip("");
1199
        PM1->setToolTip("");
1200
        TxStroke->setToolTip( tr("Color of text stroke"));
1201
        PM1->setToolTip( tr("Saturation of color of text stroke"));
2505 cbradney 1202
}
1203
 
2494 cbradney 1204
void SToolBColorS::setCurrentDocument(ScribusDoc *doc)
1205
{
1206
        TxStroke->clear();
10585 fschmid 1207
        TxStroke->addItem(CommonStrings::tr_NoneColor);
2494 cbradney 1208
        if (doc!=NULL)
7850 jghali 1209
                TxStroke->insertItems(doc->PageColors, ColorCombo::smallPixmaps);
2504 cbradney 1210
        resize(minimumSizeHint());
2494 cbradney 1211
}
1212
 
351 Franz 1213
void SToolBColorS::SetColor(int c)
1214
{
1215
        disconnect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
10585 fschmid 1216
        TxStroke->setCurrentIndex(c);
351 Franz 1217
        connect(TxStroke, SIGNAL(activated(int)), this, SLOT(newShadeHandler()));
1218
}
1219
 
9920 fschmid 1220
void SToolBColorS::SetShade(double s)
351 Franz 1221
{
1222
        disconnect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
9920 fschmid 1223
        PM1->setValue(qRound(s));
351 Franz 1224
        connect(PM1, SIGNAL(clicked()), this, SLOT(newShadeHandler()));
1225
}
1226
 
1227
void SToolBColorS::newShadeHandler()
1228
{
10585 fschmid 1229
        emit NewColor(TxStroke->currentIndex(), PM1->getValue());
351 Franz 1230
}
1231
 
1232
/* Toolbar for Character Style Settings */
10172 cbradney 1233
SToolBStyle::SToolBStyle(QMainWindow* parent) : QToolBar( tr("Character Settings"), parent)
351 Franz 1234
{
1235
        SeStyle = new StyleSelect(this);
10172 cbradney 1236
        seStyleAction=addWidget(SeStyle);
1237
        seStyleAction->setVisible(true);
1238
        trackingLabel = new QLabel( this );
2500 fschmid 1239
        trackingLabel->setText("");
1240
        trackingLabel->setPixmap(loadIcon("textkern.png"));
10172 cbradney 1241
        trackingLabelAction=addWidget(trackingLabel);
1242
        trackingLabelAction->setVisible(true);
12290 cbradney 1243
        Extra = new ScrSpinBox( this, SC_PERCENT );
9061 cbradney 1244
        Extra->setValues( -300, 300, 2, 0);
12290 cbradney 1245
        Extra->setSuffix( unitGetSuffixFromIndex(SC_PERCENT) );
10172 cbradney 1246
        extraAction=addWidget(Extra);
1247
        extraAction->setVisible(true);
3767 subik 1248
 
716 cbradney 1249
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
8687 cbradney 1250
        connect(Extra, SIGNAL(valueChanged(double)), this, SLOT(newKernHandler()));
1251
        connect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
1252
        connect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
1253
        connect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newOutlineHandler()));
1254
        connect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
1255
        connect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
1256
        connect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
1257
        connect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
3767 subik 1258
 
2505 cbradney 1259
        languageChange();
351 Franz 1260
}
1261
 
10859 cbradney 1262
void SToolBStyle::changeEvent(QEvent *e)
1263
{
1264
        if (e->type() == QEvent::LanguageChange)
1265
        {
1266
                languageChange();
1267
        }
10903 cbradney 1268
        else
1269
                QWidget::changeEvent(e);
10859 cbradney 1270
}
1271
 
2505 cbradney 1272
void SToolBStyle::languageChange()
1273
{
10397 cbradney 1274
        Extra->setToolTip("");
1275
        Extra->setToolTip( tr( "Manual Tracking" ));
2505 cbradney 1276
}
1277
 
2272 fschmid 1278
void SToolBStyle::newStrikeHandler()
1279
{
9920 fschmid 1280
        double x = SeStyle->StrikeVal->LPos->value() * 10.0;
1281
        double y = SeStyle->StrikeVal->LWidth->value() * 10.0;
9202 subik 1282
//      emit newUnderline(x, y);
1283
        emit newStrike(x, y);
2272 fschmid 1284
}
1285
 
2262 fschmid 1286
void SToolBStyle::newUnderlineHandler()
1287
{
9920 fschmid 1288
        double x = SeStyle->UnderlineVal->LPos->value() * 10.0;
1289
        double y = SeStyle->UnderlineVal->LWidth->value() * 10.0;
2262 fschmid 1290
        emit newUnderline(x, y);
1291
}
1292
 
2257 fschmid 1293
void SToolBStyle::newOutlineHandler()
1294
{
9920 fschmid 1295
        double x = SeStyle->OutlineVal->LWidth->value() * 10.0;
2257 fschmid 1296
        emit newOutline(x);
1297
}
1298
 
2254 fschmid 1299
void SToolBStyle::newShadowHandler()
1300
{
9920 fschmid 1301
        double x = SeStyle->ShadowVal->Xoffset->value() * 10.0;
1302
        double y = SeStyle->ShadowVal->Yoffset->value() * 10.0;
2254 fschmid 1303
        emit NewShadow(x, y);
1304
}
1305
 
351 Franz 1306
void SToolBStyle::newKernHandler()
1307
{
9920 fschmid 1308
        emit NewKern(Extra->value() * 10.0);
351 Franz 1309
}
1310
 
9920 fschmid 1311
void SToolBStyle::setOutline(double x)
2257 fschmid 1312
{
8687 cbradney 1313
        disconnect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newOutlineHandler()));
2257 fschmid 1314
        SeStyle->OutlineVal->LWidth->setValue(x / 10.0);
8687 cbradney 1315
        connect(SeStyle->OutlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newOutlineHandler()));
2257 fschmid 1316
}
1317
 
9920 fschmid 1318
void SToolBStyle::setStrike(double p, double w)
2272 fschmid 1319
{
8687 cbradney 1320
        disconnect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
1321
        disconnect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
2272 fschmid 1322
        SeStyle->StrikeVal->LWidth->setValue(w / 10.0);
1323
        SeStyle->StrikeVal->LPos->setValue(p / 10.0);
8687 cbradney 1324
        connect(SeStyle->StrikeVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
1325
        connect(SeStyle->StrikeVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newStrikeHandler()));
2272 fschmid 1326
}
1327
 
9920 fschmid 1328
void SToolBStyle::setUnderline(double p, double w)
2262 fschmid 1329
{
8687 cbradney 1330
        disconnect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
1331
        disconnect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
2262 fschmid 1332
        SeStyle->UnderlineVal->LWidth->setValue(w / 10.0);
1333
        SeStyle->UnderlineVal->LPos->setValue(p / 10.0);
8687 cbradney 1334
        connect(SeStyle->UnderlineVal->LWidth, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
1335
        connect(SeStyle->UnderlineVal->LPos, SIGNAL(valueChanged(double)), this, SLOT(newUnderlineHandler()));
2262 fschmid 1336
}
1337
 
9920 fschmid 1338
void SToolBStyle::SetShadow(double x, double y)
2254 fschmid 1339
{
8687 cbradney 1340
        disconnect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
1341
        disconnect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
2254 fschmid 1342
        SeStyle->ShadowVal->Xoffset->setValue(x / 10.0);
1343
        SeStyle->ShadowVal->Yoffset->setValue(y / 10.0);
8687 cbradney 1344
        connect(SeStyle->ShadowVal->Xoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
1345
        connect(SeStyle->ShadowVal->Yoffset, SIGNAL(valueChanged(double)), this, SLOT(newShadowHandler()));
2254 fschmid 1346
}
1347
 
351 Franz 1348
void SToolBStyle::SetStyle(int s)
1349
{
716 cbradney 1350
        disconnect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
351 Franz 1351
        SeStyle->setStyle(s);
716 cbradney 1352
        connect(SeStyle, SIGNAL(State(int)), this, SIGNAL(newStyle(int)));
351 Franz 1353
}
1354
 
9920 fschmid 1355
void SToolBStyle::SetKern(double k)
351 Franz 1356
{
8687 cbradney 1357
        disconnect(Extra, SIGNAL(valueChanged(double)), this, SLOT(newKernHandler()));
2382 fschmid 1358
        Extra->setValue(k / 10.0);
8687 cbradney 1359
        connect(Extra, SIGNAL(valueChanged(double)), this, SLOT(newKernHandler()));
351 Franz 1360
}
1361
 
1362
/* Toolbar for alignment of Paragraphs */
10172 cbradney 1363
SToolBAlign::SToolBAlign(QMainWindow* parent) : QToolBar( tr("Style Settings"), parent)
351 Franz 1364
{
1365
        GroupAlign = new AlignSelect(this);
10172 cbradney 1366
        groupAlignAction=addWidget(GroupAlign);
1367
        groupAlignAction->setVisible(true);
7990 cbradney 1368
        paraStyleCombo = new ParaStyleComboBox(this);
10172 cbradney 1369
        paraStyleComboAction=addWidget(paraStyleCombo);
1370
        paraStyleComboAction->setVisible(true);
9067 avox 1371
        connect(paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SIGNAL(newParaStyle(const QString& )));
6900 avox 1372
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(newAlign(int )));
3767 subik 1373
 
2505 cbradney 1374
        languageChange();
351 Franz 1375
}
1376
 
10859 cbradney 1377
void SToolBAlign::changeEvent(QEvent *e)
1378
{
1379
        if (e->type() == QEvent::LanguageChange)
1380
        {
1381
                languageChange();
1382
        }
10903 cbradney 1383
        else
1384
                QWidget::changeEvent(e);
10859 cbradney 1385
}
1386
 
2505 cbradney 1387
void SToolBAlign::languageChange()
1388
{
10397 cbradney 1389
        paraStyleCombo->setToolTip("");
1390
        paraStyleCombo->setToolTip( tr("Style of current paragraph"));
2505 cbradney 1391
}
1392
 
6900 avox 1393
 
1394
void SToolBAlign::SetAlign(int s)
351 Franz 1395
{
6900 avox 1396
        disconnect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(newAlign(int )));
1397
        GroupAlign->setStyle(s);
1398
        connect(GroupAlign, SIGNAL(State(int)), this, SIGNAL(newAlign(int )));
351 Franz 1399
}
1400
 
10643 fschmid 1401
void SToolBAlign::SetParaStyle(QString s)
351 Franz 1402
{
9067 avox 1403
        disconnect(paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SIGNAL(newParaStyle(const QString& )));
10643 fschmid 1404
        paraStyleCombo->setFormat(s);
9067 avox 1405
        connect(paraStyleCombo, SIGNAL(newStyle(const QString&)), this, SIGNAL(newParaStyle(const QString& )));
351 Franz 1406
}
1407
 
6900 avox 1408
 
351 Franz 1409
/* Toolbar for Font related Settings */
10172 cbradney 1410
SToolBFont::SToolBFont(QMainWindow* parent) : QToolBar( tr("Font Settings"), parent)
351 Franz 1411
{
2834 cbradney 1412
        Fonts = new FontCombo(this);
351 Franz 1413
        Fonts->setMaximumSize(190, 30);
10172 cbradney 1414
        fontsAction=addWidget(Fonts);
1415
        fontsAction->setVisible(true);
12290 cbradney 1416
        Size = new ScrSpinBox( 0.5, 2048, this, SC_POINTS );
7772 subik 1417
        PrefsManager* prefsManager = PrefsManager::instance();
12290 cbradney 1418
        Size->setSuffix( unitGetSuffixFromIndex(SC_POINTS) );
13996 cbradney 1419
        Size->setValue(prefsManager->appPrefs.itemToolPrefs.textSize / 10.0);
10172 cbradney 1420
        sizeAction=addWidget(Size);
1421
        sizeAction->setVisible(true);
10581 cbradney 1422
        ScaleTxt = new QLabel("", this);
2230 fschmid 1423
        ScaleTxt->setPixmap(loadIcon("textscaleh.png"));
10172 cbradney 1424
        scaleTxtAction=addWidget(ScaleTxt);
1425
        scaleTxtAction->setVisible(true);
12290 cbradney 1426
        ChScale = new ScrSpinBox( 10, 400,  this, SC_PERCENT );
351 Franz 1427
        ChScale->setValue( 100 );
12290 cbradney 1428
        ChScale->setSuffix( unitGetSuffixFromIndex(SC_PERCENT) );
10172 cbradney 1429
        chScaleAction=addWidget(ChScale);
1430
        chScaleAction->setVisible(true);
10581 cbradney 1431
        ScaleTxtV = new QLabel("", this);
2230 fschmid 1432
        ScaleTxtV->setPixmap(loadIcon("textscalev.png"));
10172 cbradney 1433
        scaleTxtVAction=addWidget(ScaleTxtV);
1434
        scaleTxtVAction->setVisible(true);
12290 cbradney 1435
        ChScaleV = new ScrSpinBox( 10, 400, this, SC_PERCENT );
2230 fschmid 1436
        ChScaleV->setValue( 100 );
12290 cbradney 1437
        ChScaleV->setSuffix( unitGetSuffixFromIndex(SC_PERCENT) );
10172 cbradney 1438
        chScaleVAction=addWidget(ChScaleV);
1439
        chScaleVAction->setVisible(true);
2505 cbradney 1440
 
8687 cbradney 1441
        connect(ChScale, SIGNAL(valueChanged(double)), this, SIGNAL(newScale(double)));
1442
        connect(ChScaleV, SIGNAL(valueChanged(double)), this, SIGNAL(newScaleV(double)));
351 Franz 1443
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
9525 fschmid 1444
        connect(Size, SIGNAL(valueChanged(double)), this, SIGNAL(NewSize(double)));
351 Franz 1445
}
1446
 
10859 cbradney 1447
void SToolBFont::changeEvent(QEvent *e)
1448
{
1449
        if (e->type() == QEvent::LanguageChange)
1450
        {
1451
                languageChange();
1452
        }
10903 cbradney 1453
        else
1454
                QWidget::changeEvent(e);
10859 cbradney 1455
}
1456
 
2505 cbradney 1457
void SToolBFont::languageChange()
1458
{
10397 cbradney 1459
        Fonts->setToolTip("");
1460
        Size->setToolTip("");
1461
        ChScale->setToolTip("");
1462
        ChScaleV->setToolTip("");
1463
        Fonts->setToolTip( tr("Font of selected text"));
1464
        Size->setToolTip( tr("Font Size"));
1465
        ChScale->setToolTip( tr("Scaling width of characters"));
1466
        ChScaleV->setToolTip( tr("Scaling height of characters"));
2505 cbradney 1467
}
1468
 
351 Franz 1469
void SToolBFont::SetFont(QString f)
1470
{
1471
        disconnect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
10648 fschmid 1472
        setCurrentComboItem(Fonts, f);
351 Franz 1473
        connect(Fonts, SIGNAL(activated(const QString &)), this, SIGNAL(NewFont(const QString &)));
1474
}
1475
 
1476
void SToolBFont::SetSize(double s)
1477
{
8687 cbradney 1478
        disconnect(Size, SIGNAL(valueChanged(double)), this, SLOT(newSizeHandler()));
2242 fschmid 1479
        Size->setValue(s / 10.0);
8687 cbradney 1480
        connect(Size, SIGNAL(valueChanged(double)), this, SLOT(newSizeHandler()));
351 Franz 1481
}
1482
 
9920 fschmid 1483
void SToolBFont::SetScale(double s)
351 Franz 1484
{
8687 cbradney 1485
        disconnect(ChScale, SIGNAL(valueChanged(double)), this, SIGNAL(newScale(double)));
2242 fschmid 1486
        ChScale->setValue(s / 10.0);
8687 cbradney 1487
        connect(ChScale, SIGNAL(valueChanged(double)), this, SIGNAL(newScale(double)));
351 Franz 1488
}
1489
 
9920 fschmid 1490
void SToolBFont::SetScaleV(double s)
2230 fschmid 1491
{
8687 cbradney 1492
        disconnect(ChScaleV, SIGNAL(valueChanged(double)), this, SIGNAL(newScaleV(double)));
2242 fschmid 1493
        ChScaleV->setValue(s / 10.0);
8687 cbradney 1494
        connect(ChScaleV, SIGNAL(valueChanged(double)), this, SIGNAL(newScaleV(double)));
2230 fschmid 1495
}
1496
 
351 Franz 1497
void SToolBFont::newSizeHandler()
1498
{
1499
        emit NewSize(Size->value());
1500
}
1501
 
1502
/* Main Story Editor Class */
7101 subik 1503
// StoryEditor::StoryEditor(QWidget* parent, ScribusDoc *docc, PageItem *ite)
1504
//      : QMainWindow(parent, "StoryEditor", WType_TopLevel) //  WType_Dialog) //WShowModal |
1505
// {
1506
//      prefsManager=PrefsManager::instance();
1507
//      currDoc = docc;
1508
//      seMenuMgr=NULL;
1509
//      buildGUI();
1510
//      currItem = ite;
1511
// //   charSelect = NULL;
1512
//      firstSet = false;
1513
//      activFromApp = true;
1514
//      Editor->loadItemText(ite);
1515
//      Editor->getCursorPosition(&CurrPara, &CurrChar);
1516
//      EditorBar->setRepaint(true);
1517
//      EditorBar->doRepaint();
1518
//      updateProps(CurrPara, CurrChar);
1519
//      updateStatus();
1520
//      textChanged = false;
1521
//      disconnectSignals();
1522
//      connectSignals();
1523
//      Editor->setFocus();
11333 jghali 1524
//      Editor->setColor(false);
7101 subik 1525
//      blockUpdate = false;
1526
//      loadPrefs();
1527
//      // hack to keep charPalette visible. See destructor too - PV
1528
//      ScCore->primaryMainWindow()->charPalette->reparent(this, QPoint(0, 0));
1529
// }
2494 cbradney 1530
 
2505 cbradney 1531
/* Main Story Editor Class, no current document */
10585 fschmid 1532
StoryEditor::StoryEditor(QWidget* parent) : QMainWindow(parent, Qt::Window), // WType_Dialog) //WShowModal |
8185 subik 1533
        activFromApp(true),
1534
        currDoc(NULL),
1535
        currItem(NULL),
1536
        textChanged(false),
1537
        firstSet(false),
1538
        blockUpdate(false),
1539
        CurrPara(0),
1540
        CurrChar(0),
1541
        charSelect(NULL),
1542
        charSelectUsed(false)
2494 cbradney 1543
{
17501 craig 1544
        m_spellActive=false;
2834 cbradney 1545
        prefsManager=PrefsManager::instance();
8185 subik 1546
#ifdef Q_WS_MAC
4557 cbradney 1547
        noIcon = loadIcon("noicon.xpm");
8185 subik 1548
#endif
2494 cbradney 1549
        buildGUI();
1550
        /*
1551
        //Editor->loadItemText(ite);
1552
        updateProps(0,0);
1553
        updateStatus();
1554
        */
1555
        Editor->setFocus();
11333 jghali 1556
        Editor->setColor(false);
3868 subik 1557
        loadPrefs();
3767 subik 1558
}
2494 cbradney 1559
 
3868 subik 1560
StoryEditor::~StoryEditor()
1561
{
1562
        savePrefs();
1563
}
1564
 
8185 subik 1565
void StoryEditor::showEvent(QShowEvent *)
1566
{
1567
        charSelect = new CharSelect(this);
17278 fschmid 1568
        charSelect->userTableModel()->setCharactersAndFonts(ScCore->primaryMainWindow()->charPalette->userTableModel()->characters(), ScCore->primaryMainWindow()->charPalette->userTableModel()->fonts());
14835 cbradney 1569
        connect(charSelect, SIGNAL(insertSpecialChar()), this, SLOT(slot_insertSpecialChar()));
17277 fschmid 1570
        connect(charSelect, SIGNAL(insertUserSpecialChar(QChar, QString)), this, SLOT(slot_insertUserSpecialChar(QChar, QString)));
14835 cbradney 1571
 
1572
        smartSelection=prefsManager->appPrefs.storyEditorPrefs.smartTextSelection;
1573
        seActions["settingsSmartTextSelection"]->setChecked(smartSelection);
8185 subik 1574
}
1575
 
1576
void StoryEditor::hideEvent(QHideEvent *)
1577
{
13754 jghali 1578
        if (charSelect)
1579
        {
1580
                if (charSelectUsed)
17278 fschmid 1581
                        ScCore->primaryMainWindow()->charPalette->userTableModel()->setCharactersAndFonts(charSelect->userTableModel()->characters(), charSelect->userTableModel()->fonts());
13754 jghali 1582
                if (charSelect->isVisible())
1583
                        charSelect->close();
1584
                disconnect(charSelect, SIGNAL(insertSpecialChar()),
1585
                                        this, SLOT(slot_insertSpecialChar()));
17277 fschmid 1586
                disconnect(charSelect, SIGNAL(insertUserSpecialChar(QChar, QString)),
1587
                                        this, SLOT(slot_insertUserSpecialChar(QChar, QString)));
13754 jghali 1588
                delete charSelect;
1589
                charSelect = NULL;
1590
        }
8185 subik 1591
}
1592
 
3868 subik 1593
void StoryEditor::savePrefs()
1594
{
1595
        // save prefs
4452 cbradney 1596
        QRect geo = geometry();
1597
        prefs->set("left", geo.left());
1598
        prefs->set("top", geo.top());
3868 subik 1599
        prefs->set("width", width());
1600
        prefs->set("height", height());
10965 fschmid 1601
        QList<int> splitted = EdSplit->sizes();
1602
        prefs->set("side", splitted[0]);
1603
        prefs->set("main", splitted[1]);
10257 fschmid 1604
        prefs->set("winstate", QString(saveState().toBase64()));
3868 subik 1605
}
1606
 
1607
void StoryEditor::loadPrefs()
1608
{
1609
        prefs = PrefsManager::instance()->prefsFile->getPluginContext("StoryEditor");
8562 jghali 1610
        int vleft   = qMax(-80, prefs->getInt("left", 10));
10531 avox 1611
#if defined(Q_OS_MAC) || defined(_WIN32)
14273 subik 1612
        int vtop        = qMax(64, prefs->getInt("top", 10));
4452 cbradney 1613
#else
14273 subik 1614
        int vtop        = qMax(-80, prefs->getInt("top", 10));
3868 subik 1615
#endif
8562 jghali 1616
        int vwidth  = qMax(600, prefs->getInt("width", 600));
1617
        int vheight = qMax(400, prefs->getInt("height", 400));
4802 cbradney 1618
        // Check values against current screen size
4803 cbradney 1619
        QRect scr = QApplication::desktop()->screen()->geometry();
4802 cbradney 1620
        QSize gStrut = QApplication::globalStrut();
1621
        if ( vleft >= scr.width() )
1622
                vleft = 0;
1623
        if ( vtop >= scr.height() )
1624
                vtop = 64;
1625
        if ( vwidth >= scr.width() )
8562 jghali 1626
                vwidth = qMax( gStrut.width(), scr.width() - vleft );
4802 cbradney 1627
        if ( vheight >= scr.height() )
8562 jghali 1628
                vheight = qMax( gStrut.height(), scr.height() - vtop );
3868 subik 1629
        setGeometry(vleft, vtop, vwidth, vheight);
10257 fschmid 1630
        QByteArray state = "";
10585 fschmid 1631
        state = prefs->get("winstate","").toAscii();
10257 fschmid 1632
        if (!state.isEmpty())
1633
                restoreState(QByteArray::fromBase64(state));
10965 fschmid 1634
        int side = prefs->getInt("side", -1);
7245 fschmid 1635
        int txtarea = prefs->getInt("main", -1);
1636
        if ((side != -1) && (txtarea != -1))
1637
        {
9803 fschmid 1638
                QList<int> splitted;
7245 fschmid 1639
                splitted.append(side);
1640
                splitted.append(txtarea);
1641
                EdSplit->setSizes(splitted);
10965 fschmid 1642
        }
3868 subik 1643
}
1644
 
4557 cbradney 1645
void StoryEditor::initActions()
4550 cbradney 1646
{
1647
        //File Menu
9857 cbradney 1648
        seActions.insert("fileNew", new ScrAction(loadIcon("16/document-new.png"), loadIcon("22/document-new.png"), "", Qt::CTRL+Qt::Key_N, this));
1649
        seActions.insert("fileRevert", new ScrAction(loadIcon("reload16.png"), loadIcon("reload.png"), "", QKeySequence(), this));
1650
        seActions.insert("fileSaveToFile", new ScrAction(loadIcon("16/document-save.png"), loadIcon("22/document-save.png"), "", QKeySequence(), this));
1651
        seActions.insert("fileLoadFromFile", new ScrAction(loadIcon("16/document-open.png"),  loadIcon("22/document-open.png"), "", QKeySequence(), this));
1652
        seActions.insert("fileSaveDocument", new ScrAction("", Qt::CTRL+Qt::Key_S, this));
1653
        seActions.insert("fileUpdateAndExit", new ScrAction(loadIcon("ok.png"), loadIcon("ok22.png"), "", Qt::CTRL+Qt::Key_W,  this));
1654
        seActions.insert("fileExit", new ScrAction(loadIcon("exit.png"), loadIcon("exit22.png"), "", QKeySequence(),  this));
4729 subik 1655
 
10725 jghali 1656
        connect( seActions["fileNew"], SIGNAL(triggered()), this, SLOT(Do_new()) );
1657
        connect( seActions["fileRevert"], SIGNAL(triggered()), this, SLOT(slotFileRevert()) );
1658
        connect( seActions["fileSaveToFile"], SIGNAL(triggered()), this, SLOT(SaveTextFile()) );
1659
        connect( seActions["fileLoadFromFile"], SIGNAL(triggered()), this, SLOT(LoadTextFile()) );
1660
        connect( seActions["fileSaveDocument"], SIGNAL(triggered()), this, SLOT(Do_saveDocument()) );
1661
        connect( seActions["fileUpdateAndExit"], SIGNAL(triggered()), this, SLOT(Do_leave2()) );
1662
        connect( seActions["fileExit"], SIGNAL(triggered()), this, SLOT(Do_leave()) );
4729 subik 1663
 
4550 cbradney 1664
        //Edit Menu
9857 cbradney 1665
        seActions.insert("editSelectAll", new ScrAction(loadIcon("16/edit-select-all.png"), QPixmap(), "", Qt::CTRL+Qt::Key_A, this));
1666
        seActions.insert("editCut", new ScrAction(loadIcon("16/edit-cut.png"), QPixmap(), "", Qt::CTRL+Qt::Key_X, this));
1667
        seActions.insert("editCopy", new ScrAction(loadIcon("16/edit-copy.png"), QPixmap(), "", Qt::CTRL+Qt::Key_C, this));
1668
        seActions.insert("editPaste", new ScrAction(loadIcon("16/edit-paste.png"), QPixmap(), "", Qt::CTRL+Qt::Key_V, this));
1669
        seActions.insert("editClear", new ScrAction(loadIcon("16/edit-delete.png"), QPixmap(), "", Qt::Key_Delete, this));
1670
        seActions.insert("editSearchReplace", new ScrAction(loadIcon("16/edit-find-replace.png"), QPixmap(), "", QKeySequence(), this));
15452 craig 1671
        //seActions.insert("editEditStyle", new ScrAction("", QKeySequence(), this));
9857 cbradney 1672
        seActions.insert("editFontPreview", new ScrAction("", QKeySequence(), this));
1673
        seActions.insert("editUpdateFrame", new ScrAction(loadIcon("compfile16.png"),loadIcon("compfile.png"), "", Qt::CTRL+Qt::Key_U, this));
4729 subik 1674
 
10725 jghali 1675
        connect( seActions["editSelectAll"], SIGNAL(triggered()), this, SLOT(Do_selectAll()) );
1676
        connect( seActions["editCut"], SIGNAL(triggered()), this, SLOT(Do_cut()) );
1677
        connect( seActions["editCopy"], SIGNAL(triggered()), this, SLOT(Do_copy()) );
1678
        connect( seActions["editPaste"], SIGNAL(triggered()), this, SLOT(Do_paste()) );
1679
        connect( seActions["editClear"], SIGNAL(triggered()), this, SLOT(Do_del()) );
1680
        connect( seActions["editSearchReplace"], SIGNAL(triggered()), this, SLOT(SearchText()) );
15448 craig 1681
        //connect( seActions["editEditStyle"], SIGNAL(triggered()), this, SLOT(slotEditStyles()) );
10725 jghali 1682
        connect( seActions["editFontPreview"], SIGNAL(triggered()), this, SLOT(Do_fontPrev()) );
1683
        connect( seActions["editUpdateFrame"], SIGNAL(triggered()), this, SLOT(updateTextFrame()) );
4729 subik 1684
 
4552 cbradney 1685
        //Insert Menu
9857 cbradney 1686
        seActions.insert("insertGlyph", new ScrAction(QPixmap(), QPixmap(), "", QKeySequence(), this));
10725 jghali 1687
        connect( seActions["insertGlyph"], SIGNAL(triggered()), this, SLOT(Do_insSp()) );
13584 subik 1688
        seActions.insert("insertSampleText", new ScrAction(QPixmap(), QPixmap(), "", QKeySequence(), this));
1689
        connect(seActions["insertSampleText"], SIGNAL(triggered()), this, SLOT(insertSampleText()));
4729 subik 1690
 
4557 cbradney 1691
        //Settings Menu
9857 cbradney 1692
        seActions.insert("settingsBackground", new ScrAction("", QKeySequence(), this));
1693
        seActions.insert("settingsDisplayFont", new ScrAction("", QKeySequence(), this));
1694
        seActions.insert("settingsSmartTextSelection", new ScrAction("", QKeySequence(), this));
14823 cbradney 1695
        seActions["settingsSmartTextSelection"]->setChecked(smartSelection);
4557 cbradney 1696
        seActions["settingsSmartTextSelection"]->setToggleAction(true);
4729 subik 1697
 
10725 jghali 1698
        connect( seActions["settingsBackground"], SIGNAL(triggered()), this, SLOT(setBackPref()) );
1699
        connect( seActions["settingsDisplayFont"], SIGNAL(triggered()), this, SLOT(setFontPref()) );
4557 cbradney 1700
        connect( seActions["settingsSmartTextSelection"], SIGNAL(toggled(bool)), this, SLOT(setSmart(bool)) );
4729 subik 1701
 
1702
 
14509 cbradney 1703
//      seActions["fileRevert"]->setEnabled(false);
1704
//      seActions["editCopy"]->setEnabled(false);
1705
//      seActions["editCut"]->setEnabled(false);
1706
//      seActions["editPaste"]->setEnabled(false);
1707
//      seActions["editClear"]->setEnabled(false);
1708
//      seActions["editUpdateFrame"]->setEnabled(false);
4557 cbradney 1709
}
1710
 
4550 cbradney 1711
void StoryEditor::buildMenus()
1712
{
5781 cbradney 1713
        seMenuMgr = new MenuManager(this->menuBar(), this->menuBar());
4550 cbradney 1714
        seMenuMgr->createMenu("File", tr("&File"));
14509 cbradney 1715
        seMenuMgr->addMenuItem(seActions["fileNew"], "File", true);
1716
        seMenuMgr->addMenuItem(seActions["fileRevert"], "File", false);
4550 cbradney 1717
        seMenuMgr->addMenuSeparator("File");
14509 cbradney 1718
        seMenuMgr->addMenuItem(seActions["fileSaveToFile"], "File", true);
1719
        seMenuMgr->addMenuItem(seActions["fileLoadFromFile"], "File", true);
1720
        seMenuMgr->addMenuItem(seActions["fileSaveDocument"], "File", true);
4550 cbradney 1721
        seMenuMgr->addMenuSeparator("File");
14509 cbradney 1722
        seMenuMgr->addMenuItem(seActions["fileUpdateAndExit"], "File", true);
1723
        seMenuMgr->addMenuItem(seActions["fileExit"], "File", true);
4550 cbradney 1724
        seMenuMgr->createMenu("Edit", tr("&Edit"));
14509 cbradney 1725
        seMenuMgr->addMenuItem(seActions["editSelectAll"], "Edit", true);
1726
        seMenuMgr->addMenuItem(seActions["editCut"], "Edit", false);
1727
        seMenuMgr->addMenuItem(seActions["editCopy"], "Edit", false);
1728
        seMenuMgr->addMenuItem(seActions["editPaste"], "Edit", false);
1729
        seMenuMgr->addMenuItem(seActions["editClear"], "Edit", false);
4550 cbradney 1730
        seMenuMgr->addMenuSeparator("Edit");
14509 cbradney 1731
        seMenuMgr->addMenuItem(seActions["editSearchReplace"], "Edit", true);
4550 cbradney 1732
        seMenuMgr->addMenuSeparator("Edit");
15448 craig 1733
//      seMenuMgr->addMenuItem(seActions["editEditStyle"], "Edit", true);
14509 cbradney 1734
        seMenuMgr->addMenuItem(seActions["editFontPreview"], "Edit", true);
1735
        seMenuMgr->addMenuItem(seActions["editUpdateFrame"], "Edit", false);
14835 cbradney 1736
        seMenuMgr->addMenuSeparator("Edit");
1737
        seMenuMgr->addMenuItem(seActions["settingsSmartTextSelection"], "Edit", true);
4552 cbradney 1738
        seMenuMgr->createMenu("Insert", tr("&Insert"));
14509 cbradney 1739
        seMenuMgr->addMenuItem(seActions["insertGlyph"], "Insert", true);
1740
        seMenuMgr->addMenuItem(seActions["insertSampleText"], "Insert", true);
10558 cbradney 1741
        seMenuMgr->createMenu("InsertChar", tr("Character"), "Insert");
14509 cbradney 1742
        seMenuMgr->addMenuItem(seActions["unicodePageNumber"], "InsertChar", true);
1743
        seMenuMgr->addMenuItem(seActions["unicodePageCount"], "InsertChar", true);
15009 jghali 1744
        //seMenuMgr->addMenuItem(seActions["unicodeSoftHyphen"], "InsertChar", true);
14509 cbradney 1745
        seMenuMgr->addMenuItem(seActions["unicodeNonBreakingHyphen"], "InsertChar", true);
4552 cbradney 1746
        seMenuMgr->addMenuSeparator("InsertChar");
14509 cbradney 1747
        seMenuMgr->addMenuItem(seActions["unicodeCopyRight"], "InsertChar", true);
1748
        seMenuMgr->addMenuItem(seActions["unicodeRegdTM"], "InsertChar", true);
1749
        seMenuMgr->addMenuItem(seActions["unicodeTM"], "InsertChar", true);
1750
        seMenuMgr->addMenuItem(seActions["unicodeSolidus"], "InsertChar", true);
1751
        seMenuMgr->addMenuItem(seActions["unicodeBullet"], "InsertChar", true);
1752
        seMenuMgr->addMenuItem(seActions["unicodeMidpoint"], "InsertChar", true);
4552 cbradney 1753
        seMenuMgr->addMenuSeparator("InsertChar");
14509 cbradney 1754
        seMenuMgr->addMenuItem(seActions["unicodeDashEm"], "InsertChar", true);
1755
        seMenuMgr->addMenuItem(seActions["unicodeDashEn"], "InsertChar", true);
1756
        seMenuMgr->addMenuItem(seActions["unicodeDashFigure"], "InsertChar", true);
1757
        seMenuMgr->addMenuItem(seActions["unicodeDashQuotation"], "InsertChar", true);
10558 cbradney 1758
        seMenuMgr->createMenu("InsertQuote", tr("Quote"), "Insert");
14509 cbradney 1759
        seMenuMgr->addMenuItem(seActions["unicodeQuoteApostrophe"], "InsertQuote", true);
1760
        seMenuMgr->addMenuItem(seActions["unicodeQuoteStraight"], "InsertQuote", true);
4552 cbradney 1761
        seMenuMgr->addMenuSeparator("InsertQuote");
14509 cbradney 1762
        seMenuMgr->addMenuItem(seActions["unicodeQuoteSingleLeft"], "InsertQuote", true);
1763
        seMenuMgr->addMenuItem(seActions["unicodeQuoteSingleRight"], "InsertQuote", true);
1764
        seMenuMgr->addMenuItem(seActions["unicodeQuoteDoubleLeft"], "InsertQuote", true);
1765
        seMenuMgr->addMenuItem(seActions["unicodeQuoteDoubleRight"], "InsertQuote", true);
4552 cbradney 1766
        seMenuMgr->addMenuSeparator("InsertQuote");
14509 cbradney 1767
        seMenuMgr->addMenuItem(seActions["unicodeQuoteSingleReversed"], "InsertQuote", true);
1768
        seMenuMgr->addMenuItem(seActions["unicodeQuoteDoubleReversed"], "InsertQuote", true);
8755 cbradney 1769
        seMenuMgr->addMenuSeparator("InsertQuote");
14509 cbradney 1770
        seMenuMgr->addMenuItem(seActions["unicodeQuoteLowSingleComma"], "InsertQuote", true);
1771
        seMenuMgr->addMenuItem(seActions["unicodeQuoteLowDoubleComma"], "InsertQuote", true);
4552 cbradney 1772
        seMenuMgr->addMenuSeparator("InsertQuote");
14509 cbradney 1773
        seMenuMgr->addMenuItem(seActions["unicodeQuoteSingleLeftGuillemet"], "InsertQuote", true);
1774
        seMenuMgr->addMenuItem(seActions["unicodeQuoteSingleRightGuillemet"], "InsertQuote", true);
1775
        seMenuMgr->addMenuItem(seActions["unicodeQuoteDoubleLeftGuillemet"], "InsertQuote", true);
1776
        seMenuMgr->addMenuItem(seActions["unicodeQuoteDoubleRightGuillemet"], "InsertQuote", true);
4552 cbradney 1777
        seMenuMgr->addMenuSeparator("InsertQuote");
14509 cbradney 1778
        seMenuMgr->addMenuItem(seActions["unicodeQuoteCJKSingleLeft"], "InsertQuote", true);
1779
        seMenuMgr->addMenuItem(seActions["unicodeQuoteCJKSingleRight"], "InsertQuote", true);
1780
        seMenuMgr->addMenuItem(seActions["unicodeQuoteCJKDoubleLeft"], "InsertQuote", true);
1781
        seMenuMgr->addMenuItem(seActions["unicodeQuoteCJKDoubleRight"], "InsertQuote", true);
10558 cbradney 1782
        seMenuMgr->createMenu("InsertSpace", tr("Spaces && Breaks"), "Insert");
14509 cbradney 1783
        seMenuMgr->addMenuItem(seActions["unicodeNonBreakingSpace"], "InsertSpace", true);
1784
        seMenuMgr->addMenuItem(seActions["unicodeSpaceEN"], "InsertSpace", true);
1785
        seMenuMgr->addMenuItem(seActions["unicodeSpaceEM"], "InsertSpace", true);
1786
        seMenuMgr->addMenuItem(seActions["unicodeSpaceThin"], "InsertSpace", true);
1787
        seMenuMgr->addMenuItem(seActions["unicodeSpaceThick"], "InsertSpace", true);
1788
        seMenuMgr->addMenuItem(seActions["unicodeSpaceMid"], "InsertSpace", true);
1789
        seMenuMgr->addMenuItem(seActions["unicodeSpaceHair"], "InsertSpace", true);
4720 cbradney 1790
        seMenuMgr->addMenuSeparator("InsertSpace");
14509 cbradney 1791
        seMenuMgr->addMenuItem(seActions["unicodeNewLine"], "InsertSpace", true);
1792
        seMenuMgr->addMenuItem(seActions["unicodeFrameBreak"], "InsertSpace", true);
1793
        seMenuMgr->addMenuItem(seActions["unicodeColumnBreak"], "InsertSpace", true);
10558 cbradney 1794
        seMenuMgr->createMenu("InsertLigature", tr("Ligature"), "Insert");
14509 cbradney 1795
        seMenuMgr->addMenuItem(seActions["unicodeLigature_ff"], "InsertLigature", true);
1796
        seMenuMgr->addMenuItem(seActions["unicodeLigature_fi"], "InsertLigature", true);
1797
        seMenuMgr->addMenuItem(seActions["unicodeLigature_fl"], "InsertLigature", true);
1798
        seMenuMgr->addMenuItem(seActions["unicodeLigature_ffi"], "InsertLigature", true);
1799
        seMenuMgr->addMenuItem(seActions["unicodeLigature_ffl"], "InsertLigature", true);
1800
        seMenuMgr->addMenuItem(seActions["unicodeLigature_ft"], "InsertLigature", true);
1801
        seMenuMgr->addMenuItem(seActions["unicodeLigature_st"], "InsertLigature", true);
4729 subik 1802
 
4550 cbradney 1803
        seMenuMgr->createMenu("Settings", tr("&Settings"));
16389 fschmid 1804
        seMenuMgr->addMenuItem(seActions["settingsBackground"], "Settings", true);
1805
        seMenuMgr->addMenuItem(seActions["settingsDisplayFont"], "Settings", true);
14824 cbradney 1806
//      seMenuMgr->addMenuItem(seActions["settingsSmartTextSelection"], "Settings", true);
4729 subik 1807
 
4550 cbradney 1808
        seMenuMgr->addMenuToMenuBar("File");
1809
        seMenuMgr->addMenuToMenuBar("Edit");
4552 cbradney 1810
        seMenuMgr->addMenuToMenuBar("Insert");
16389 fschmid 1811
        seMenuMgr->addMenuToMenuBar("Settings");
17501 craig 1812
 
1813
        PluginManager::instance().setupPluginActions(this);
1814
        PluginManager::instance().languageChange();
4550 cbradney 1815
}
1816
 
2494 cbradney 1817
void StoryEditor::buildGUI()
1818
{
4557 cbradney 1819
        unicodeCharActionNames.clear();
1820
        seActions.clear();
14823 cbradney 1821
        smartSelection=prefsManager->appPrefs.storyEditorPrefs.smartTextSelection;
4557 cbradney 1822
        initActions();
1823
        ActionManager::initUnicodeActions(&seActions, this, &unicodeCharActionNames);
15009 jghali 1824
        seActions["unicodeSoftHyphen"]->setEnabled(false);//CB TODO doesnt work in SE yet.
4550 cbradney 1825
        buildMenus();
4729 subik 1826
 
10585 fschmid 1827
        setWindowIcon(loadIcon("AppIcon.png"));
10180 fschmid 1828
        StoryEd2Layout = new QHBoxLayout;
1829
        StoryEd2Layout->setSpacing( 5 );
1830
        StoryEd2Layout->setMargin( 5 );
124 Franz 1831
 
351 Franz 1832
/* Setting up Toolbars */
10172 cbradney 1833
        FileTools = new QToolBar(this);
10691 fschmid 1834
        FileTools->setIconSize(QSize(16,16));
10257 fschmid 1835
        FileTools->setObjectName("File");
9800 cbradney 1836
        FileTools->addAction(seActions["fileNew"]);
1837
        FileTools->addAction(seActions["fileLoadFromFile"]);
1838
        FileTools->addAction(seActions["fileSaveToFile"]);
1839
        FileTools->addAction(seActions["fileUpdateAndExit"]);
1840
        FileTools->addAction(seActions["fileExit"]);
1841
        FileTools->addAction(seActions["fileRevert"]);
1842
        FileTools->addAction(seActions["editUpdateFrame"]);
1843
        FileTools->addAction(seActions["editSearchReplace"]);
4729 subik 1844
 
10172 cbradney 1845
        FileTools->setAllowedAreas(Qt::LeftToolBarArea);
1846
        FileTools->setAllowedAreas(Qt::RightToolBarArea);
1847
        FileTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1848
        FileTools->setAllowedAreas(Qt::TopToolBarArea);
351 Franz 1849
        FontTools = new SToolBFont(this);
10691 fschmid 1850
        FontTools->setIconSize(QSize(16,16));
10257 fschmid 1851
        FontTools->setObjectName("Font");
10172 cbradney 1852
        FontTools->setAllowedAreas(Qt::LeftToolBarArea);
1853
        FontTools->setAllowedAreas(Qt::RightToolBarArea);
1854
        FontTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1855
        FontTools->setAllowedAreas(Qt::TopToolBarArea);
351 Franz 1856
        AlignTools = new SToolBAlign(this);
10691 fschmid 1857
        AlignTools->setIconSize(QSize(16,16));
10257 fschmid 1858
        AlignTools->setObjectName("Align");
10172 cbradney 1859
        AlignTools->setAllowedAreas(Qt::LeftToolBarArea);
1860
        AlignTools->setAllowedAreas(Qt::RightToolBarArea);
1861
        AlignTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1862
        AlignTools->setAllowedAreas(Qt::TopToolBarArea);
7992 cbradney 1863
        AlignTools->paraStyleCombo->setDoc(currDoc);
351 Franz 1864
        StyleTools = new SToolBStyle(this);
10691 fschmid 1865
        StyleTools->setIconSize(QSize(16,16));
10257 fschmid 1866
        StyleTools->setObjectName("Style");
10172 cbradney 1867
        StyleTools->setAllowedAreas(Qt::LeftToolBarArea);
1868
        StyleTools->setAllowedAreas(Qt::RightToolBarArea);
1869
        StyleTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1870
        StyleTools->setAllowedAreas(Qt::TopToolBarArea);
2494 cbradney 1871
        StrokeTools = new SToolBColorS(this, currDoc);
10691 fschmid 1872
        StrokeTools->setIconSize(QSize(16,16));
10257 fschmid 1873
        StrokeTools->setObjectName("Strok");
10172 cbradney 1874
        StrokeTools->setAllowedAreas(Qt::LeftToolBarArea);
1875
        StrokeTools->setAllowedAreas(Qt::RightToolBarArea);
1876
        StrokeTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1877
        StrokeTools->setAllowedAreas(Qt::TopToolBarArea);
352 Franz 1878
        StrokeTools->TxStroke->setEnabled(false);
1879
        StrokeTools->PM1->setEnabled(false);
2494 cbradney 1880
        FillTools = new SToolBColorF(this, currDoc);
10691 fschmid 1881
        FillTools->setIconSize(QSize(16,16));
10257 fschmid 1882
        FillTools->setObjectName("Fill");
10172 cbradney 1883
        FillTools->setAllowedAreas(Qt::LeftToolBarArea);
1884
        FillTools->setAllowedAreas(Qt::RightToolBarArea);
1885
        FillTools->setAllowedAreas(Qt::BottomToolBarArea);
10180 fschmid 1886
        FillTools->setAllowedAreas(Qt::TopToolBarArea);
10172 cbradney 1887
 
1888
        addToolBar(FileTools);
16777 jghali 1889
        addToolBarBreak();
10172 cbradney 1890
        addToolBar(FontTools);
1891
        addToolBar(AlignTools);
16777 jghali 1892
        addToolBarBreak();
10172 cbradney 1893
        addToolBar(StyleTools);
1894
        addToolBar(StrokeTools);
1895
        addToolBar(FillTools);
125 Franz 1896
 
10965 fschmid 1897
        EdSplit = new QSplitter(this);
371 Franz 1898
/* SideBar Widget */
10965 fschmid 1899
        EditorBar = new SideBar(this);
1900
        EdSplit->addWidget(EditorBar);
351 Franz 1901
/* Editor Widget, subclass of QTextEdit */
10671 fschmid 1902
        Editor = new SEditor(this, currDoc, this);
10965 fschmid 1903
        EdSplit->addWidget(Editor);
1904
        StoryEd2Layout->addWidget( EdSplit );
1549 subik 1905
 
351 Franz 1906
/* Setting up Status Bar */
10180 fschmid 1907
        ButtonGroup1 = new QFrame( statusBar() );
1908
        ButtonGroup1->setFrameShape( QFrame::NoFrame );
1909
        ButtonGroup1->setFrameShadow( QFrame::Plain );
1910
        ButtonGroup1Layout = new QGridLayout( ButtonGroup1 );
125 Franz 1911
        ButtonGroup1Layout->setAlignment( Qt::AlignTop );
1912
        ButtonGroup1Layout->setSpacing( 2 );
1913
        ButtonGroup1Layout->setMargin( 0 );
10581 cbradney 1914
        WordCT1 = new QLabel(ButtonGroup1);
10180 fschmid 1915
        ButtonGroup1Layout->addWidget( WordCT1, 0, 0, 1, 3 );
10581 cbradney 1916
        WordCT = new QLabel(ButtonGroup1);
125 Franz 1917
        ButtonGroup1Layout->addWidget( WordCT, 1, 0 );
10581 cbradney 1918
        WordC = new QLabel(ButtonGroup1);
125 Franz 1919
        ButtonGroup1Layout->addWidget( WordC, 1, 1 );
10581 cbradney 1920
        CharCT = new QLabel(ButtonGroup1);
125 Franz 1921
        ButtonGroup1Layout->addWidget( CharCT, 1, 2 );
10581 cbradney 1922
        CharC = new QLabel(ButtonGroup1);
125 Franz 1923
        ButtonGroup1Layout->addWidget( CharC, 1, 3 );
10585 fschmid 1924
        statusBar()->addPermanentWidget(ButtonGroup1, 1);
10581 cbradney 1925
        ButtonGroup2 = new QFrame( statusBar() );
10180 fschmid 1926
        ButtonGroup2->setFrameShape( QFrame::NoFrame );
1927
        ButtonGroup2->setFrameShadow( QFrame::Plain );
1928
        ButtonGroup2Layout = new QGridLayout( ButtonGroup2 );
125 Franz 1929
        ButtonGroup2Layout->setAlignment( Qt::AlignTop );
1930
        ButtonGroup2Layout->setSpacing( 2 );
1931
        ButtonGroup2Layout->setMargin( 0 );
10581 cbradney 1932
        WordCT3 = new QLabel(ButtonGroup2);
10180 fschmid 1933
        ButtonGroup2Layout->addWidget( WordCT3, 0, 0, 1, 5 );
10581 cbradney 1934
        ParCT = new QLabel(ButtonGroup2);
125 Franz 1935
        ButtonGroup2Layout->addWidget( ParCT, 1, 0 );
10581 cbradney 1936
        ParC = new QLabel(ButtonGroup2);
125 Franz 1937
        ButtonGroup2Layout->addWidget( ParC, 1, 1 );
10581 cbradney 1938
        WordCT2 = new QLabel(ButtonGroup2);
125 Franz 1939
        ButtonGroup2Layout->addWidget( WordCT2, 1, 2 );
10581 cbradney 1940
        WordC2 = new QLabel(ButtonGroup2);
125 Franz 1941
        ButtonGroup2Layout->addWidget( WordC2, 1, 3 );
10581 cbradney 1942
        CharCT2 = new QLabel(ButtonGroup2);
125 Franz 1943
        ButtonGroup2Layout->addWidget( CharCT2, 1, 4 );
10581 cbradney 1944
        CharC2 = new QLabel(ButtonGroup2);
125 Franz 1945
        ButtonGroup2Layout->addWidget( CharC2, 1, 5 );
10585 fschmid 1946
        statusBar()->addPermanentWidget(ButtonGroup2, 1);
10965 fschmid 1947
        setCentralWidget( EdSplit );
4551 cbradney 1948
        //Final setup
351 Franz 1949
        resize( QSize(660, 500).expandedTo(minimumSizeHint()) );
2834 cbradney 1950
        if (prefsManager==NULL)
3240 fschmid 1951
                sDebug(QString("%1").arg("prefsmgr null"));
3767 subik 1952
 
10628 fschmid 1953
//      Editor->setPaper(prefsManager->appPrefs.STEcolor);
357 Franz 1954
        QFont fo;
13996 cbradney 1955
        fo.fromString(prefsManager->appPrefs.storyEditorPrefs.guiFont);
357 Franz 1956
        Editor->setFont(fo);
14823 cbradney 1957
        QPalette pal;
1958
        QColor newColor(prefsManager->appPrefs.storyEditorPrefs.guiFontColorBackground);
1959
        pal.setColor(QPalette::Active, QPalette::Base, newColor);
1960
        pal.setColor(QPalette::Inactive, QPalette::Base, newColor);
1961
        pal.setColor(QPalette::Disabled, QPalette::Base, newColor);
1962
        Editor->setPalette(pal);
10965 fschmid 1963
        EditorBar->setFrameStyle(Editor->frameStyle());
1964
        EditorBar->setLineWidth(Editor->lineWidth());
1965
        EditorBar->editor = Editor;
4194 fschmid 1966
        Editor->installEventFilter(this);
2505 cbradney 1967
        languageChange();
2494 cbradney 1968
}
1969
 
10859 cbradney 1970
void StoryEditor::changeEvent(QEvent *e)
1971
{
1972
        if (e->type() == QEvent::LanguageChange)
1973
        {
1974
                languageChange();
1975
        }
10903 cbradney 1976
        else
1977
                QWidget::changeEvent(e);
10859 cbradney 1978
}
1979
 
2505 cbradney 1980
void StoryEditor::languageChange()
1981
{
10180 fschmid 1982
        setWindowTitle( tr( "Story Editor" ) );
4550 cbradney 1983
        //File Menu
10427 cbradney 1984
        seMenuMgr->setText