Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
1111 tsoots 1
/***************************************************************************
2
 *   Copyright (C) 2005 by Riku Leino                                      *
3
 *   tsoots@gmail.com                                                      *
4
 *                                                                         *
5
 *   This program is free software; you can redistribute it and/or modify  *
6
 *   it under the terms of the GNU General Public License as published by  *
7
 *   the Free Software Foundation; either version 2 of the License, or     *
8
 *   (at your option) any later version.                                   *
9
 *                                                                         *
10
 *   This program is distributed in the hope that it will be useful,       *
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13
 *   GNU General Public License for more details.                          *
14
 *                                                                         *
15
 *   You should have received a copy of the GNU General Public License     *
16
 *   along with this program; if not, write to the                         *
17
 *   Free Software Foundation, Inc.,                                       *
18
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19
 ***************************************************************************/
20
 
21
#include <qlayout.h>
22
#include <qpixmap.h>
23
#include <qpushbutton.h>
1142 tsoots 24
#include <qrect.h>
25
#include <qstyle.h>
1111 tsoots 26
#include <qtooltip.h>
27
#include <qcheckbox.h>
1167 tsoots 28
#include <qfont.h>
29
#include <qfontmetrics.h>
1288 cbradney 30
 
31
#include "undogui.h"
32
#include "undogui.moc"
33
#include "prefsfile.h"
34
#include "prefscontext.h"
35
#include "scribus.h"
36
#include "menumanager.h"
1111 tsoots 37
 
38
extern QPixmap loadIcon(QString nam);
1148 tsoots 39
extern PrefsFile* prefsFile;
1288 cbradney 40
extern ScribusApp *ScApp;
1111 tsoots 41
 
42
UndoGui::UndoGui(QWidget* parent, const char* name, WFlags f) : QWidget(parent, name, f)
43
{
44
 
45
}
46
 
47
/*** UndoWidget ***************************************************************/
48
 
49
UndoWidget::UndoWidget(QWidget* parent, const char* name)
50
: UndoGui(parent, name)
51
{
1288 cbradney 52
        /* BnF standard toolbar buttons
1111 tsoots 53
        QHBoxLayout* layout = new QHBoxLayout(this, 0, 0, "layout");
54
 
1288 cbradney 55
 
1111 tsoots 56
        undoButton = new QToolButton(this, "undoButton");
57
        undoButton->setIconSet(loadIcon("u_undo.png"));
58
        undoButton->setUsesTextLabel(false);
59
        QToolTip::add(undoButton, tr("Undo"));
60
        layout->addWidget(undoButton);
61
        undoMenu = new QPopupMenu(undoButton, "undoMenu");
62
        undoButton->setPopup(undoMenu);
63
        undoButton->setPopupDelay(0);
1138 tsoots 64
        undoButton->setAutoRaise(true);
1111 tsoots 65
 
66
        redoButton = new QToolButton(this, "redoButton");
67
        redoButton->setIconSet(loadIcon("u_redo.png"));
68
        redoButton->setUsesTextLabel(false);
69
        QToolTip::add(redoButton, tr("Redo"));
70
        layout->addWidget(redoButton);
71
        redoMenu = new QPopupMenu(redoButton, "redoMenu");
72
        redoButton->setPopup(redoMenu);
73
        redoButton->setPopupDelay(0);
1138 tsoots 74
        redoButton->setAutoRaise(true);
1288 cbradney 75
        */
76
        //Scribus action based toolbar button construction
77
        ScApp->scrActions["editUndoAction"]->addTo(parent);
78
        ScApp->scrActions["editRedoAction"]->addTo(parent);
79
        ScApp->scrMenuMgr->createMenu("undoButtonMenu", "undoButtonMenu");
80
        ScApp->scrMenuMgr->createMenu("redoButtonMenu", "redoButtonMenu");
81
        undoMenu=ScApp->scrMenuMgr->getLocalPopupMenu("undoButtonMenu");
82
        redoMenu=ScApp->scrMenuMgr->getLocalPopupMenu("redoButtonMenu");
83
        ScApp->scrMenuMgr->addMenuToWidgetOfAction("undoButtonMenu", ScApp->scrActions["editUndoAction"]);
84
        ScApp->scrMenuMgr->addMenuToWidgetOfAction("redoButtonMenu", ScApp->scrActions["editRedoAction"]);
85
        QToolButton *undoButton = dynamic_cast<QToolButton*>(ScApp->scrActions["editUndoAction"]->getWidgetAddedTo());
86
        QToolButton *redoButton = dynamic_cast<QToolButton*>(ScApp->scrActions["editRedoAction"]->getWidgetAddedTo());
1337 cbradney 87
        if (undoButton && redoButton)
88
        {
89
                undoButton->setPopupDelay(0);
90
                redoButton->setPopupDelay(0);
91
        }
1288 cbradney 92
 
93
        ScApp->scrActions["editCut"]->addTo(parent);
94
        ScApp->scrActions["editCopy"]->addTo(parent);
95
        ScApp->scrActions["editPaste"]->addTo(parent);
96
 
97
        /* BnF Undo buttons
1111 tsoots 98
        connect(undoButton, SIGNAL(clicked()), this, SLOT(undoClicked()));
99
        connect(redoButton, SIGNAL(clicked()), this, SLOT(redoClicked()));
1288 cbradney 100
        */
1111 tsoots 101
        connect(undoMenu, SIGNAL(activated(int)), this, SLOT(undoMenuClicked(int)));
102
        connect(redoMenu, SIGNAL(activated(int)), this, SLOT(redoMenuClicked(int)));
103
}
104
 
105
void UndoWidget::clear()
106
{
107
        undoMenu->clear();
108
        undoItems.clear();
1288 cbradney 109
        //Scribus disable
110
        ScApp->scrActions["editUndoAction"]->setEnabled(false);
111
        // BnF disable
112
        //undoButton->setEnabled(false);
1111 tsoots 113
        redoMenu->clear();
114
        redoItems.clear();
1288 cbradney 115
        //Scribus disable;
116
        ScApp->scrActions["editRedoAction"]->setEnabled(false);                
117
        // BnF disable
118
        //redoButton->setEnabled(false);
1111 tsoots 119
}
120
 
121
void UndoWidget::undoClicked()
122
{
123
        if (undoItems.size() > 0)
124
                emit undo(1);
125
}
126
 
127
void UndoWidget::redoClicked()
128
{
129
        if (redoItems.size() > 0)
130
                emit redo(1);
131
}
132
 
133
void UndoWidget::undoMenuClicked(int id)
134
{
135
        int steps = undoMenu->indexOf(id) + 1;
136
        emit undo(steps);
137
}
138
 
139
void UndoWidget::redoMenuClicked(int id)
140
{
141
        int steps = redoMenu->indexOf(id) + 1;
142
        emit redo(steps);
143
}
144
 
1336 tsoots 145
void UndoWidget::insertUndoItem(UndoObject* target, UndoState* state)
1111 tsoots 146
{
1336 tsoots 147
        undoItems.insert(undoItems.begin(), QString(tr("%1: %2", "undo target: action (f.e. Text frame: Resize)"))
148
                                        .arg(target->getUName()).arg(state->getName()));
1111 tsoots 149
        clearRedoMenu();
150
        updateUndoMenu();
151
}
152
 
1336 tsoots 153
void UndoWidget::insertRedoItem(UndoObject* target, UndoState* state)
1111 tsoots 154
{
1336 tsoots 155
        redoItems.push_back(QString(tr("%1: %2", "undo target: action (f.e. Text frame: Resize)"))
156
                        .arg(target->getUName()).arg(state->getName()));
1111 tsoots 157
        updateRedoMenu();
158
}
159
 
160
void UndoWidget::clearRedoMenu()
161
{
162
        redoItems.erase(redoItems.begin(), redoItems.end());
163
        updateRedoMenu();
164
}
165
 
166
void UndoWidget::updateUndoMenu()
167
{
168
        undoMenu->clear();
169
        for (uint i = 0; i < MENU_HEIGHT && i < undoItems.size(); ++i)
170
                undoMenu->insertItem(undoItems[i]);
1288 cbradney 171
        //BnF
172
        //undoButton->setEnabled(undoMenu->count() != 0);
173
        //SCribus
174
        ScApp->scrActions["editUndoAction"]->setEnabled(undoMenu->count() != 0);
1111 tsoots 175
}
176
 
177
void UndoWidget::updateRedoMenu()
178
{
179
        redoMenu->clear();
180
        for (uint i = 0; i < MENU_HEIGHT && i < redoItems.size(); ++i)
181
                redoMenu->insertItem(redoItems[i]);
1288 cbradney 182
        //BnF
183
        //redoButton->setEnabled(redoMenu->count() != 0);
184
        //Scribus
185
        ScApp->scrActions["editRedoAction"]->setEnabled(redoMenu->count() != 0);
1111 tsoots 186
}
187
 
188
void UndoWidget::updateUndo(int steps)
189
{
190
        for (int i = 0; i < steps; ++i)
191
        {
192
                redoItems.insert(redoItems.begin(), undoItems[0]);
193
                undoItems.erase(undoItems.begin());    
194
        }
195
        updateUndoMenu();
196
        updateRedoMenu();
197
}
198
 
199
void UndoWidget::updateRedo(int steps)
200
{
201
        for (int i = 0; i < steps; ++i)
202
        {
203
                undoItems.insert(undoItems.begin(), redoItems[0]);
204
                redoItems.erase(redoItems.begin());    
205
        }
206
        updateUndoMenu();
207
        updateRedoMenu();
208
}
209
 
210
void UndoWidget::popBack()
211
{
1197 tsoots 212
        if (undoItems.size() > 0)
213
        {
214
                undoItems.erase(undoItems.end() - 1);
215
                updateUndoMenu();
216
        }
1111 tsoots 217
}
218
 
219
UndoWidget::~UndoWidget()
220
{
221
 
222
}
223
 
224
/*** UndoPalette **************************************************************/
225
 
226
UndoPalette::UndoPalette(QWidget* parent, const char* name)
227
: UndoGui(parent, name, Qt::WType_Dialog)
228
{
229
        currentSelection = 0;
230
        redoItems = 0;
1213 tsoots 231
        setCaption(tr("Action History"));
1111 tsoots 232
        QVBoxLayout* layout = new QVBoxLayout(this, 5, 5, "layout");
233
 
234
        QCheckBox* objectBox = new QCheckBox(tr("Show selected object only"), this, "objectBox");
235
        layout->addWidget(objectBox);
1142 tsoots 236
        objectBox->setEnabled(false);
1111 tsoots 237
 
238
        undoList = new QListBox(this, "undoList");
239
        undoList->setMultiSelection(false);
240
        undoList->setSelectionMode(QListBox::Single);
241
        layout->addWidget(undoList);
1393 cbradney 242
 
1111 tsoots 243
        QHBoxLayout* buttonLayout = new QHBoxLayout(0, 0, 5, "buttonLayout");
244
        undoButton = new QPushButton(loadIcon("u_undo.png"),
245
                                         tr("&Undo"), this,
246
                                         "undoButton");
247
        buttonLayout->addWidget(undoButton);
248
        redoButton = new QPushButton(loadIcon("u_redo.png"),
249
                                         tr("&Redo"), this,
250
                                         "redoButton");
251
        buttonLayout->addWidget(redoButton);
252
        layout->addLayout(buttonLayout);
253
 
1148 tsoots 254
        undoPrefs = prefsFile->getContext("undo");
255
 
1111 tsoots 256
        connect(undoButton, SIGNAL(clicked()), this, SLOT(undoClicked()));
257
        connect(redoButton, SIGNAL(clicked()), this, SLOT(redoClicked()));
258
        connect(undoList, SIGNAL(highlighted(int)), this, SLOT(undoListClicked(int)));
1200 tsoots 259
        connect(undoList, SIGNAL(onItem(QListBoxItem*)), this, SLOT(showToolTip(QListBoxItem*)));
1201 tsoots 260
        connect(undoList, SIGNAL(onViewport()), this, SLOT(removeToolTip()));
1111 tsoots 261
}
262
 
263
void UndoPalette::clear()
264
{
265
        undoList->clear();
266
        undoList->insertItem(tr("Initial State"));
267
        undoButton->setEnabled(false);
268
        redoButton->setEnabled(false);
269
}
270
 
271
void UndoPalette::closeEvent(QCloseEvent* e)
272
{
1294 cbradney 273
        emit closePalette(false);
1111 tsoots 274
        e->ignore();
275
        hide();
276
}
277
 
1148 tsoots 278
void UndoPalette::show()
279
{
280
        QWidget::show();
281
        if (undoPrefs->contains("up_left"))
282
        {
283
                int left   = undoPrefs->getInt("up_left", 100);
284
                int top    = undoPrefs->getInt("up_top", 100);
285
                int width  = undoPrefs->getInt("up_width", 200);
286
                int height = undoPrefs->getInt("up_height", 350);
287
                QRect r(left, top, width, height);
288
                setGeometry(r);
289
        }
290
}
291
 
292
void UndoPalette::hideEvent(QHideEvent*)
293
{
294
        QRect r    = frameGeometry();
295
        int left   = r.left();
296
        int top    = r.top();
297
        int width  = r.width();
298
        int height = r.height();
299
        undoPrefs->set("up_left", left);
300
        undoPrefs->set("up_top", top);
301
        undoPrefs->set("up_width", width);
302
        undoPrefs->set("up_height", height);
303
}
304
 
1366 tsoots 305
void UndoPalette::keyPressEvent(QKeyEvent* e)
306
{
307
        if (e->key() == Key_Escape)
308
                hide();
309
        QWidget::keyPressEvent(e);
310
}
311
 
1111 tsoots 312
void UndoPalette::insertUndoItem(UndoObject* target, UndoState* state)
313
{
314
        removeRedoItems();
1200 tsoots 315
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 316
                         state->getDescription(), target->getUPixmap(),
317
                         state->getPixmap()));
1111 tsoots 318
        currentSelection = undoList->numRows() - 1;
319
        updateList();
320
}
321
 
322
void UndoPalette::insertRedoItem(UndoObject* target, UndoState* state)
323
{
1190 tsoots 324
        if (undoList->count() == 1)
325
                undoList->setSelected(0, true);
1200 tsoots 326
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 327
                         state->getDescription(), target->getUPixmap(),
328
                         state->getPixmap()));
1111 tsoots 329
        updateList();
330
}
331
 
332
void UndoPalette::updateUndo(int steps)
333
{
334
        if (undoList->currentItem() == currentSelection)
335
        {
336
                currentSelection -= steps;
337
                updateList();
338
        }
339
}
340
 
341
void UndoPalette::updateRedo(int steps)
342
{
343
        if (undoList->currentItem() == currentSelection)
344
        {
345
                currentSelection += steps;
346
                updateList();
347
        }
348
}
349
 
350
void UndoPalette::popBack()
351
{
1197 tsoots 352
        if (undoList->count() > 1)
353
        {
354
                undoList->removeItem(0);
355
                currentSelection = undoList->numRows() - 1;
356
        }
1111 tsoots 357
}
358
 
359
void UndoPalette::updateList()
360
{
1167 tsoots 361
        undoList->setCurrentItem(currentSelection);
1111 tsoots 362
        undoList->setSelected(currentSelection, true);
363
        redoButton->setEnabled(currentSelection < undoList->numRows() - 1);
364
        undoButton->setEnabled(currentSelection > 0);
365
        if (!undoList->itemVisible(currentSelection))
366
                undoList->setBottomItem(currentSelection);
367
}
368
 
369
void UndoPalette::removeRedoItems()
370
{
371
        for (int i = (undoList->numRows() - 1); i > currentSelection; --i)
372
                undoList->removeItem(i);
373
}
374
 
375
void UndoPalette::undoClicked()
376
{
377
        emit undo(1);
378
}
379
 
380
void UndoPalette::redoClicked()
381
{
382
        emit redo(1);
383
}
384
 
385
void UndoPalette::undoListClicked(int i)
386
{
1190 tsoots 387
        if (i == currentSelection || (i == 0 && undoList->count() == 1))
1111 tsoots 388
                return;
389
        if (i > currentSelection)
390
                emit redo(i - currentSelection);
391
        else if (i < currentSelection)
392
                emit undo(currentSelection - i);
393
        currentSelection = i;
394
        updateList();
395
}
396
 
1200 tsoots 397
void UndoPalette::showToolTip(QListBoxItem *i)
398
{
399
        UndoItem *item = dynamic_cast<UndoItem*>(i);
400
        if (item)
401
        {
402
                QString tip = item->getDescription();
403
                if (tip != 0)
404
                  QToolTip::add(undoList, tip);
405
        }
406
        else
407
                removeToolTip();
408
}
409
 
410
void UndoPalette::removeToolTip()
411
{
412
        QToolTip::remove(undoList);
413
}
414
 
1111 tsoots 415
UndoPalette::~UndoPalette()
416
{
417
 
418
}
1142 tsoots 419
 
420
/*** UndoPalette::UndoItem ****************************************************/
421
 
422
UndoPalette::UndoItem::UndoItem() : QListBoxItem()
423
{
424
        target = "";
425
        action = "";
1200 tsoots 426
        description = "";
1250 tsoots 427
        targetpixmap = NULL;
428
        actionpixmap = NULL;
1142 tsoots 429
}
430
 
431
UndoPalette::UndoItem::UndoItem(const UndoItem &another) : QListBoxItem()
432
{
433
        target = another.target;
434
        action = another.action;
1200 tsoots 435
        description = another.description;
1250 tsoots 436
        targetpixmap = another.targetpixmap;
437
        actionpixmap = another.actionpixmap;
1142 tsoots 438
}
439
 
1250 tsoots 440
UndoPalette::UndoItem::UndoItem(const QString &targetName,
441
                                const QString &actionName,
442
                                const QString &actionDescription,
443
                                QPixmap *targetPixmap,
444
                                QPixmap *actionPixmap)
1200 tsoots 445
: QListBoxItem()
1142 tsoots 446
{
447
        target = targetName;
448
        action = actionName;
1200 tsoots 449
        description = actionDescription;
1250 tsoots 450
        targetpixmap = targetPixmap;
451
        actionpixmap = actionPixmap;
1142 tsoots 452
}
453
 
454
void UndoPalette::UndoItem::paint(QPainter *painter)
455
{
1250 tsoots 456
        if (targetpixmap)
457
                painter->drawPixmap(5, 5, *targetpixmap);
458
        if (actionpixmap)
459
                painter->drawPixmap(5, 5, *actionpixmap);
1167 tsoots 460
        QFont f = QFont(painter->font());
1173 tsoots 461
        f.setPointSize(f.pointSize() - 2);
462
        painter->setFont(f);
463
        painter->drawText(32, QFontMetrics(f).height(), target);
1167 tsoots 464
        f.setItalic(true);
1174 tsoots 465
        painter->setFont(f);
1167 tsoots 466
        painter->drawText(32, (2 * QFontMetrics(painter->font()).height()), action);
1142 tsoots 467
}
468
 
1167 tsoots 469
int UndoPalette::UndoItem::height(const QListBox *lb) const
1142 tsoots 470
{
1167 tsoots 471
        if (lb)
1204 tsoots 472
        {
473
                int fontHeight = 2 * QFontMetrics(lb->font()).height();
1250 tsoots 474
                if (actionpixmap)
1254 tsoots 475
                        return fontHeight > (10 + actionpixmap->height()) ?
476
                   fontHeight : (10 + actionpixmap->height());
1250 tsoots 477
                else if (targetpixmap)
1254 tsoots 478
                        return fontHeight > (10 + targetpixmap->height()) ?
479
                   fontHeight : (10 + targetpixmap->height());
1204 tsoots 480
                else
481
                        return fontHeight;
482
        }
1167 tsoots 483
        else
484
                return 0;
1142 tsoots 485
}
486
 
1167 tsoots 487
int UndoPalette::UndoItem::width(const QListBox *lb) const
1142 tsoots 488
{
1167 tsoots 489
        if (lb)
490
                return target.length() > action.length() ?
1250 tsoots 491
               39 + QFontMetrics(lb->font()).width(target) :
492
               39 + QFontMetrics(lb->font()).width(action);
1167 tsoots 493
        else
494
                return 0;
1142 tsoots 495
}
496
 
1200 tsoots 497
QString UndoPalette::UndoItem::getDescription()
498
{
499
  return description;
500
}
501
 
1142 tsoots 502
UndoPalette::UndoItem::~UndoItem()
503
{
504
 
505
}