Subversion Repositories Scribus

Rev

Rev 1254 | Rev 1288 | 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);
1255 cbradney 259
        emit closePalette(false);
1148 tsoots 260
}
261
 
1111 tsoots 262
void UndoPalette::insertUndoItem(UndoObject* target, UndoState* state)
263
{
264
        removeRedoItems();
1200 tsoots 265
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 266
                         state->getDescription(), target->getUPixmap(),
267
                         state->getPixmap()));
1111 tsoots 268
        currentSelection = undoList->numRows() - 1;
269
        updateList();
270
}
271
 
272
void UndoPalette::insertRedoItem(UndoObject* target, UndoState* state)
273
{
1190 tsoots 274
        if (undoList->count() == 1)
275
                undoList->setSelected(0, true);
1200 tsoots 276
        undoList->insertItem(new UndoItem(target->getUName(), state->getName(),
1250 tsoots 277
                         state->getDescription(), target->getUPixmap(),
278
                         state->getPixmap()));
1111 tsoots 279
        updateList();
280
}
281
 
282
void UndoPalette::updateUndo(int steps)
283
{
284
        if (undoList->currentItem() == currentSelection)
285
        {
286
                currentSelection -= steps;
287
                updateList();
288
        }
289
}
290
 
291
void UndoPalette::updateRedo(int steps)
292
{
293
        if (undoList->currentItem() == currentSelection)
294
        {
295
                currentSelection += steps;
296
                updateList();
297
        }
298
}
299
 
300
void UndoPalette::popBack()
301
{
1197 tsoots 302
        if (undoList->count() > 1)
303
        {
304
                undoList->removeItem(0);
305
                currentSelection = undoList->numRows() - 1;
306
        }
1111 tsoots 307
}
308
 
309
void UndoPalette::updateList()
310
{
1167 tsoots 311
        undoList->setCurrentItem(currentSelection);
1111 tsoots 312
        undoList->setSelected(currentSelection, true);
313
        redoButton->setEnabled(currentSelection < undoList->numRows() - 1);
314
        undoButton->setEnabled(currentSelection > 0);
315
        if (!undoList->itemVisible(currentSelection))
316
                undoList->setBottomItem(currentSelection);
317
}
318
 
319
void UndoPalette::removeRedoItems()
320
{
321
        for (int i = (undoList->numRows() - 1); i > currentSelection; --i)
322
                undoList->removeItem(i);
323
}
324
 
325
void UndoPalette::undoClicked()
326
{
327
        emit undo(1);
328
}
329
 
330
void UndoPalette::redoClicked()
331
{
332
        emit redo(1);
333
}
334
 
335
void UndoPalette::undoListClicked(int i)
336
{
1190 tsoots 337
        if (i == currentSelection || (i == 0 && undoList->count() == 1))
1111 tsoots 338
                return;
339
        if (i > currentSelection)
340
                emit redo(i - currentSelection);
341
        else if (i < currentSelection)
342
                emit undo(currentSelection - i);
343
        currentSelection = i;
344
        updateList();
345
}
346
 
1200 tsoots 347
void UndoPalette::showToolTip(QListBoxItem *i)
348
{
349
        UndoItem *item = dynamic_cast<UndoItem*>(i);
350
        if (item)
351
        {
352
                QString tip = item->getDescription();
353
                if (tip != 0)
354
                  QToolTip::add(undoList, tip);
355
        }
356
        else
357
                removeToolTip();
358
}
359
 
360
void UndoPalette::removeToolTip()
361
{
362
        QToolTip::remove(undoList);
363
}
364
 
1111 tsoots 365
UndoPalette::~UndoPalette()
366
{
367
 
368
}
1142 tsoots 369
 
370
/*** UndoPalette::UndoItem ****************************************************/
371
 
372
UndoPalette::UndoItem::UndoItem() : QListBoxItem()
373
{
374
        target = "";
375
        action = "";
1200 tsoots 376
        description = "";
1250 tsoots 377
        targetpixmap = NULL;
378
        actionpixmap = NULL;
1142 tsoots 379
}
380
 
381
UndoPalette::UndoItem::UndoItem(const UndoItem &another) : QListBoxItem()
382
{
383
        target = another.target;
384
        action = another.action;
1200 tsoots 385
        description = another.description;
1250 tsoots 386
        targetpixmap = another.targetpixmap;
387
        actionpixmap = another.actionpixmap;
1142 tsoots 388
}
389
 
1250 tsoots 390
UndoPalette::UndoItem::UndoItem(const QString &targetName,
391
                                const QString &actionName,
392
                                const QString &actionDescription,
393
                                QPixmap *targetPixmap,
394
                                QPixmap *actionPixmap)
1200 tsoots 395
: QListBoxItem()
1142 tsoots 396
{
397
        target = targetName;
398
        action = actionName;
1200 tsoots 399
        description = actionDescription;
1250 tsoots 400
        targetpixmap = targetPixmap;
401
        actionpixmap = actionPixmap;
1142 tsoots 402
}
403
 
404
void UndoPalette::UndoItem::paint(QPainter *painter)
405
{
1250 tsoots 406
        if (targetpixmap)
407
                painter->drawPixmap(5, 5, *targetpixmap);
408
        if (actionpixmap)
409
                painter->drawPixmap(5, 5, *actionpixmap);
1167 tsoots 410
        QFont f = QFont(painter->font());
1173 tsoots 411
        f.setPointSize(f.pointSize() - 2);
412
        painter->setFont(f);
413
        painter->drawText(32, QFontMetrics(f).height(), target);
1167 tsoots 414
        f.setItalic(true);
1174 tsoots 415
        painter->setFont(f);
1167 tsoots 416
        painter->drawText(32, (2 * QFontMetrics(painter->font()).height()), action);
1142 tsoots 417
}
418
 
1167 tsoots 419
int UndoPalette::UndoItem::height(const QListBox *lb) const
1142 tsoots 420
{
1167 tsoots 421
        if (lb)
1204 tsoots 422
        {
423
                int fontHeight = 2 * QFontMetrics(lb->font()).height();
1250 tsoots 424
                if (actionpixmap)
1254 tsoots 425
                        return fontHeight > (10 + actionpixmap->height()) ?
426
                   fontHeight : (10 + actionpixmap->height());
1250 tsoots 427
                else if (targetpixmap)
1254 tsoots 428
                        return fontHeight > (10 + targetpixmap->height()) ?
429
                   fontHeight : (10 + targetpixmap->height());
1204 tsoots 430
                else
431
                        return fontHeight;
432
        }
1167 tsoots 433
        else
434
                return 0;
1142 tsoots 435
}
436
 
1167 tsoots 437
int UndoPalette::UndoItem::width(const QListBox *lb) const
1142 tsoots 438
{
1167 tsoots 439
        if (lb)
440
                return target.length() > action.length() ?
1250 tsoots 441
               39 + QFontMetrics(lb->font()).width(target) :
442
               39 + QFontMetrics(lb->font()).width(action);
1167 tsoots 443
        else
444
                return 0;
1142 tsoots 445
}
446
 
1200 tsoots 447
QString UndoPalette::UndoItem::getDescription()
448
{
449
  return description;
450
}
451
 
1142 tsoots 452
UndoPalette::UndoItem::~UndoItem()
453
{
454
 
455
}