Subversion Repositories Scribus

Rev

Rev 1213 | Rev 1254 | 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 "undogui.h"
1119 fschmid 22
#include "undogui.moc"
1148 tsoots 23
#include "prefsfile.h"
24
#include "prefscontext.h"
1111 tsoots 25
#include <qlayout.h>
26
#include <qpixmap.h>
27
#include <qpushbutton.h>
1142 tsoots 28
#include <qrect.h>
29
#include <qstyle.h>
1111 tsoots 30
#include <qtooltip.h>
31
#include <qcheckbox.h>
1167 tsoots 32
#include <qfont.h>
33
#include <qfontmetrics.h>
1111 tsoots 34
 
35
extern QPixmap loadIcon(QString nam);
1148 tsoots 36
extern PrefsFile* prefsFile;
1111 tsoots 37
 
38
UndoGui::UndoGui(QWidget* parent, const char* name, WFlags f) : QWidget(parent, name, f)
39
{
40
 
41
}
42
 
43
/*** UndoWidget ***************************************************************/
44
 
45
UndoWidget::UndoWidget(QWidget* parent, const char* name)
46
: UndoGui(parent, name)
47
{
48
        QHBoxLayout* layout = new QHBoxLayout(this, 0, 0, "layout");
49
 
50
        undoButton = new QToolButton(this, "undoButton");
51
        undoButton->setIconSet(loadIcon("u_undo.png"));
52
        undoButton->setUsesTextLabel(false);
53
        QToolTip::add(undoButton, tr("Undo"));
54
        layout->addWidget(undoButton);
55
        undoMenu = new QPopupMenu(undoButton, "undoMenu");
56
        undoButton->setPopup(undoMenu);
57
        undoButton->setPopupDelay(0);
1138 tsoots 58
        undoButton->setAutoRaise(true);
1111 tsoots 59
 
60
        redoButton = new QToolButton(this, "redoButton");
61
        redoButton->setIconSet(loadIcon("u_redo.png"));
62
        redoButton->setUsesTextLabel(false);
63
        QToolTip::add(redoButton, tr("Redo"));
64
        layout->addWidget(redoButton);
65
        redoMenu = new QPopupMenu(redoButton, "redoMenu");
66
        redoButton->setPopup(redoMenu);
67
        redoButton->setPopupDelay(0);
1138 tsoots 68
        redoButton->setAutoRaise(true);
69
 
1111 tsoots 70
        connect(undoButton, SIGNAL(clicked()), this, SLOT(undoClicked()));
71
        connect(redoButton, SIGNAL(clicked()), this, SLOT(redoClicked()));
72
        connect(undoMenu, SIGNAL(activated(int)), this, SLOT(undoMenuClicked(int)));
73
        connect(redoMenu, SIGNAL(activated(int)), this, SLOT(redoMenuClicked(int)));
74
}
75
 
76
void UndoWidget::clear()
77
{
78
        undoMenu->clear();
79
        undoItems.clear();
80
        undoButton->setEnabled(false);
81
        redoMenu->clear();
82
        redoItems.clear();
83
        redoButton->setEnabled(false);
84
}
85
 
86
void UndoWidget::undoClicked()
87
{
88
        if (undoItems.size() > 0)
89
                emit undo(1);
90
}
91
 
92
void UndoWidget::redoClicked()
93
{
94
        if (redoItems.size() > 0)
95
                emit redo(1);
96
}
97
 
98
void UndoWidget::undoMenuClicked(int id)
99
{
100
        int steps = undoMenu->indexOf(id) + 1;
101
        emit undo(steps);
102
}
103
 
104
void UndoWidget::redoMenuClicked(int id)
105
{
106
        int steps = redoMenu->indexOf(id) + 1;
107
        emit redo(steps);
108
}
109
 
1142 tsoots 110
void UndoWidget::insertUndoItem(UndoObject*, UndoState* state)
1111 tsoots 111
{
112
        undoItems.insert(undoItems.begin(), state->getName());
113
        clearRedoMenu();
114
        updateUndoMenu();
115
}
116
 
1142 tsoots 117
void UndoWidget::insertRedoItem(UndoObject*, UndoState* state)
1111 tsoots 118
{
119
        redoItems.push_back(state->getName());
120
        updateRedoMenu();
121
}
122
 
123
void UndoWidget::clearRedoMenu()
124
{
125
        redoItems.erase(redoItems.begin(), redoItems.end());
126
        updateRedoMenu();
127
}
128
 
129
void UndoWidget::updateUndoMenu()
130
{
131
        undoMenu->clear();
132
        for (uint i = 0; i < MENU_HEIGHT && i < undoItems.size(); ++i)
133
                undoMenu->insertItem(undoItems[i]);
134
        undoButton->setEnabled(undoMenu->count() != 0);
135
}
136
 
137
void UndoWidget::updateRedoMenu()
138
{
139
        redoMenu->clear();
140
        for (uint i = 0; i < MENU_HEIGHT && i < redoItems.size(); ++i)
141
                redoMenu->insertItem(redoItems[i]);
142
        redoButton->setEnabled(redoMenu->count() != 0);
143
}
144
 
145
void UndoWidget::updateUndo(int steps)
146
{
147
        for (int i = 0; i < steps; ++i)
148
        {
149
                redoItems.insert(redoItems.begin(), undoItems[0]);
150
                undoItems.erase(undoItems.begin());    
151
        }
152
        updateUndoMenu();
153
        updateRedoMenu();
154
}
155
 
156
void UndoWidget::updateRedo(int steps)
157
{
158
        for (int i = 0; i < steps; ++i)
159
        {
160
                undoItems.insert(undoItems.begin(), redoItems[0]);
161
                redoItems.erase(redoItems.begin());    
162
        }
163
        updateUndoMenu();
164
        updateRedoMenu();
165
}
166
 
167
void UndoWidget::popBack()
168
{
1197 tsoots 169
        if (undoItems.size() > 0)
170
        {
171
                undoItems.erase(undoItems.end() - 1);
172
                updateUndoMenu();
173
        }
1111 tsoots 174
}
175
 
176
UndoWidget::~UndoWidget()
177
{
178
 
179
}
180
 
181
/*** UndoPalette **************************************************************/
182
 
183
UndoPalette::UndoPalette(QWidget* parent, const char* name)
184
: UndoGui(parent, name, Qt::WType_Dialog)
185
{
186
        currentSelection = 0;
187
        redoItems = 0;
1213 tsoots 188
        setCaption(tr("Action History"));
1111 tsoots 189
        QVBoxLayout* layout = new QVBoxLayout(this, 5, 5, "layout");
190
 
191
        QCheckBox* objectBox = new QCheckBox(tr("Show selected object only"), this, "objectBox");
192
        layout->addWidget(objectBox);
1142 tsoots 193
        objectBox->setEnabled(false);
1111 tsoots 194
 
195
        undoList = new QListBox(this, "undoList");
196
        undoList->setMultiSelection(false);
197
        undoList->setSelectionMode(QListBox::Single);
198
        layout->addWidget(undoList);
199
 
200
        QHBoxLayout* buttonLayout = new QHBoxLayout(0, 0, 5, "buttonLayout");
201
        undoButton = new QPushButton(loadIcon("u_undo.png"),
202
                                         tr("&Undo"), this,
203
                                         "undoButton");
204
        buttonLayout->addWidget(undoButton);
205
        redoButton = new QPushButton(loadIcon("u_redo.png"),
206
                                         tr("&Redo"), this,
207
                                         "redoButton");
208
        buttonLayout->addWidget(redoButton);
209
        layout->addLayout(buttonLayout);
210
 
1148 tsoots 211
        undoPrefs = prefsFile->getContext("undo");
212
 
1111 tsoots 213
        connect(undoButton, SIGNAL(clicked()), this, SLOT(undoClicked()));
214
        connect(redoButton, SIGNAL(clicked()), this, SLOT(redoClicked()));
215
        connect(undoList, SIGNAL(highlighted(int)), this, SLOT(undoListClicked(int)));
1200 tsoots 216
        connect(undoList, SIGNAL(onItem(QListBoxItem*)), this, SLOT(showToolTip(QListBoxItem*)));
1201 tsoots 217
        connect(undoList, SIGNAL(onViewport()), this, SLOT(removeToolTip()));
1111 tsoots 218
}
219
 
220
void UndoPalette::clear()
221
{
222
        undoList->clear();
223
        undoList->insertItem(tr("Initial State"));
224
        undoButton->setEnabled(false);
225
        redoButton->setEnabled(false);
226
}
227
 
228
void UndoPalette::closeEvent(QCloseEvent* e)
229
{
230
        e->ignore();
231
        hide();
232
}
233
 
1148 tsoots 234
void UndoPalette::show()
235
{
236
        QWidget::show();
237
        if (undoPrefs->contains("up_left"))
238
        {
239
                int left   = undoPrefs->getInt("up_left", 100);
240
                int top    = undoPrefs->getInt("up_top", 100);
241
                int width  = undoPrefs->getInt("up_width", 200);
242
                int height = undoPrefs->getInt("up_height", 350);
243
                QRect r(left, top, width, height);
244
                setGeometry(r);
245
        }
246
}
247
 
248
void UndoPalette::hideEvent(QHideEvent*)
249
{
250
        QRect r    = frameGeometry();
251
        int left   = r.left();
252
        int top    = r.top();
253
        int width  = r.width();
254
        int height = r.height();
255
        undoPrefs->set("up_left", left);
256
        undoPrefs->set("up_top", top);
257
        undoPrefs->set("up_width", width);
258
        undoPrefs->set("up_height", height);
259
}
260
 
1111 tsoots 261
void UndoPalette::insertUndoItem(UndoObject* target, UndoState* state)
262
{
263
        removeRedoItems();
1200 tsoots 264
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 265
                         state->getDescription(), target->getUPixmap(),
266
                         state->getPixmap()));
1111 tsoots 267
        currentSelection = undoList->numRows() - 1;
268
        updateList();
269
}
270
 
271
void UndoPalette::insertRedoItem(UndoObject* target, UndoState* state)
272
{
1190 tsoots 273
        if (undoList->count() == 1)
274
                undoList->setSelected(0, true);
1200 tsoots 275
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 276
                         state->getDescription(), target->getUPixmap(),
277
                         state->getPixmap()));
1111 tsoots 278
        updateList();
279
}
280
 
281
void UndoPalette::updateUndo(int steps)
282
{
283
        if (undoList->currentItem() == currentSelection)
284
        {
285
                currentSelection -= steps;
286
                updateList();
287
        }
288
}
289
 
290
void UndoPalette::updateRedo(int steps)
291
{
292
        if (undoList->currentItem() == currentSelection)
293
        {
294
                currentSelection += steps;
295
                updateList();
296
        }
297
}
298
 
299
void UndoPalette::popBack()
300
{
1197 tsoots 301
        if (undoList->count() > 1)
302
        {
303
                undoList->removeItem(0);
304
                currentSelection = undoList->numRows() - 1;
305
        }
1111 tsoots 306
}
307
 
308
void UndoPalette::updateList()
309
{
1167 tsoots 310
        undoList->setCurrentItem(currentSelection);
1111 tsoots 311
        undoList->setSelected(currentSelection, true);
312
        redoButton->setEnabled(currentSelection < undoList->numRows() - 1);
313
        undoButton->setEnabled(currentSelection > 0);
314
        if (!undoList->itemVisible(currentSelection))
315
                undoList->setBottomItem(currentSelection);
316
}
317
 
318
void UndoPalette::removeRedoItems()
319
{
320
        for (int i = (undoList->numRows() - 1); i > currentSelection; --i)
321
                undoList->removeItem(i);
322
}
323
 
324
void UndoPalette::undoClicked()
325
{
326
        emit undo(1);
327
}
328
 
329
void UndoPalette::redoClicked()
330
{
331
        emit redo(1);
332
}
333
 
334
void UndoPalette::undoListClicked(int i)
335
{
1190 tsoots 336
        if (i == currentSelection || (i == 0 && undoList->count() == 1))
1111 tsoots 337
                return;
338
        if (i > currentSelection)
339
                emit redo(i - currentSelection);
340
        else if (i < currentSelection)
341
                emit undo(currentSelection - i);
342
        currentSelection = i;
343
        updateList();
344
}
345
 
1200 tsoots 346
void UndoPalette::showToolTip(QListBoxItem *i)
347
{
348
        UndoItem *item = dynamic_cast<UndoItem*>(i);
349
        if (item)
350
        {
351
                QString tip = item->getDescription();
352
                if (tip != 0)
353
                  QToolTip::add(undoList, tip);
354
        }
355
        else
356
                removeToolTip();
357
}
358
 
359
void UndoPalette::removeToolTip()
360
{
361
        QToolTip::remove(undoList);
362
}
363
 
1111 tsoots 364
UndoPalette::~UndoPalette()
365
{
366
 
367
}
1142 tsoots 368
 
369
/*** UndoPalette::UndoItem ****************************************************/
370
 
371
UndoPalette::UndoItem::UndoItem() : QListBoxItem()
372
{
373
        target = "";
374
        action = "";
1200 tsoots 375
        description = "";
1250 tsoots 376
        targetpixmap = NULL;
377
        actionpixmap = NULL;
1142 tsoots 378
}
379
 
380
UndoPalette::UndoItem::UndoItem(const UndoItem &another) : QListBoxItem()
381
{
382
        target = another.target;
383
        action = another.action;
1200 tsoots 384
        description = another.description;
1250 tsoots 385
        targetpixmap = another.targetpixmap;
386
        actionpixmap = another.actionpixmap;
1142 tsoots 387
}
388
 
1250 tsoots 389
UndoPalette::UndoItem::UndoItem(const QString &targetName,
390
                                const QString &actionName,
391
                                const QString &actionDescription,
392
                                QPixmap *targetPixmap,
393
                                QPixmap *actionPixmap)
1200 tsoots 394
: QListBoxItem()
1142 tsoots 395
{
396
        target = targetName;
397
        action = actionName;
1200 tsoots 398
        description = actionDescription;
1250 tsoots 399
        targetpixmap = targetPixmap;
400
        actionpixmap = actionPixmap;
1142 tsoots 401
}
402
 
403
void UndoPalette::UndoItem::paint(QPainter *painter)
404
{
1250 tsoots 405
        if (targetpixmap)
406
                painter->drawPixmap(5, 5, *targetpixmap);
407
        if (actionpixmap)
408
                painter->drawPixmap(5, 5, *actionpixmap);
1167 tsoots 409
        QFont f = QFont(painter->font());
1173 tsoots 410
        f.setPointSize(f.pointSize() - 2);
411
        painter->setFont(f);
412
        painter->drawText(32, QFontMetrics(f).height(), target);
1167 tsoots 413
        f.setItalic(true);
1174 tsoots 414
        painter->setFont(f);
1167 tsoots 415
        painter->drawText(32, (2 * QFontMetrics(painter->font()).height()), action);
1142 tsoots 416
}
417
 
1167 tsoots 418
int UndoPalette::UndoItem::height(const QListBox *lb) const
1142 tsoots 419
{
1167 tsoots 420
        if (lb)
1204 tsoots 421
        {
422
                int fontHeight = 2 * QFontMetrics(lb->font()).height();
1250 tsoots 423
                if (actionpixmap)
424
                        return fontHeight > (13 + actionpixmap->height()) ?
425
                   fontHeight : (13 + actionpixmap->height());
426
                else if (targetpixmap)
427
                        return fontHeight > (13 + targetpixmap->height()) ?
428
                   fontHeight : (13 + targetpixmap->height());
1204 tsoots 429
                else
430
                        return fontHeight;
431
        }
1167 tsoots 432
        else
433
                return 0;
1142 tsoots 434
}
435
 
1167 tsoots 436
int UndoPalette::UndoItem::width(const QListBox *lb) const
1142 tsoots 437
{
1167 tsoots 438
        if (lb)
439
                return target.length() > action.length() ?
1250 tsoots 440
               39 + QFontMetrics(lb->font()).width(target) :
441
               39 + QFontMetrics(lb->font()).width(action);
1167 tsoots 442
        else
443
                return 0;
1142 tsoots 444
}
445
 
1200 tsoots 446
QString UndoPalette::UndoItem::getDescription()
447
{
448
  return description;
449
}
450
 
1142 tsoots 451
UndoPalette::UndoItem::~UndoItem()
452
{
453
 
454
}