Subversion Repositories Scribus

Rev

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