Subversion Repositories Scribus

Rev

Rev 1247 | Rev 1251 | 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 "undomanager.h"
1119 fschmid 22
#include "undomanager.moc"
1142 tsoots 23
#include "undogui.h"
1190 tsoots 24
#include "config.h"
1197 tsoots 25
#include "prefscontext.h"
26
#include "prefsfile.h"
1111 tsoots 27
#include <qvaluelist.h>
28
 
1197 tsoots 29
extern PrefsFile *prefsFile;
1190 tsoots 30
extern QPixmap loadIcon(QString nam);
31
 
1111 tsoots 32
UndoManager* UndoManager::_instance    = 0;
33
bool         UndoManager::_undoEnabled = true;
34
 
35
UndoManager* UndoManager::instance()
36
{
37
        if (_instance == 0)
38
                _instance = new UndoManager();
39
 
40
        return _instance;
41
}
42
 
43
void UndoManager::setUndoEnabled(bool isEnabled)
44
{
45
        _undoEnabled = isEnabled;
46
        if (isEnabled)
47
                connectGuis();
48
        else
49
                disconnectGuis();
50
}
51
 
52
bool UndoManager::undoEnabled()
53
{
54
        return _undoEnabled;
55
}
56
 
57
UndoManager::UndoManager()
58
{
59
        currentUndoObjectId = -1;
1190 tsoots 60
        if (!UndoManager::IGuides)
61
                initIcons();
1197 tsoots 62
        prefs = prefsFile->getContext("undo");
63
        historyLength = prefs->getInt("historyLength", 10);
64
        if (historyLength < 0)
65
                historyLength = 10;
1213 tsoots 66
        transaction = NULL;
67
        transactionTarget = NULL;
1111 tsoots 68
}
69
 
1213 tsoots 70
void UndoManager::beginTransaction(const QString &targetName,
1250 tsoots 71
                                   QPixmap *targetPixmap,
1213 tsoots 72
                                   const QString &name,
73
                                   const QString &description,
1250 tsoots 74
                                   QPixmap *actionPixmap)
1213 tsoots 75
{
1238 tsoots 76
        if (transaction) // begin a transaction inside transaction
77
                transactions.push_back(
78
                        std::pair<TransactionObject*, TransactionState*>(transactionTarget, transaction));
1213 tsoots 79
        transaction = new TransactionState();
80
        transactionTarget = new TransactionObject();
1228 tsoots 81
        transactionTarget->setUName(targetName); // Name which will be in action history
1250 tsoots 82
        if (targetPixmap)
83
                transactionTarget->setUPixmap(targetPixmap);
1228 tsoots 84
        if (name.length() > 0)          // if left to 0 length action will be fetched from the
85
                transaction->setName(name); // last added UndoState in this transaction
1238 tsoots 86
        if (description.length() > 0)
1228 tsoots 87
                transaction->setDescription(description); // tool tip for action history
1250 tsoots 88
        if (actionPixmap)
89
                transaction->setPixmap(actionPixmap); // for action history
1213 tsoots 90
}
91
 
92
void UndoManager::cancelTransaction()
93
{
94
        delete transaction;
95
        transaction = NULL;
96
        delete transactionTarget;
97
        transactionTarget = NULL;
1238 tsoots 98
        if (!transactions.empty())
99
        {
100
                // fetch the next transaction from the vector
101
                transactionTarget = transactions[transactions.size() - 1].first;
102
                transaction = transactions[transactions.size() - 1].second;
103
//              delete transactions[transactions.size() - 1];
104
                transactions.erase(transactions.end() - 1);
105
        }
1213 tsoots 106
}
107
 
108
void UndoManager::commit(const QString &targetName,
1250 tsoots 109
                         QPixmap *targetPixmap,
1213 tsoots 110
                         const QString &name,
111
                         const QString &description,
1250 tsoots 112
                         QPixmap *actionPixmap)
1213 tsoots 113
{
114
        if (!transaction || !transactionTarget)
115
        {
116
                cancelTransaction();
117
                return;
118
        }
119
        if (targetName.length() > 0)
120
                transactionTarget->setUName(targetName);
1250 tsoots 121
        if (targetPixmap)
122
                transactionTarget->setUPixmap(targetPixmap);
1213 tsoots 123
        if (name.length() > 0)
124
                transaction->setName(name);
125
        if (description.length() > 0)
126
                transaction->setDescription(description);
1250 tsoots 127
        if (actionPixmap)
128
                transaction->setPixmap(actionPixmap);
1213 tsoots 129
 
130
        UndoObject *tmpu = transactionTarget;
131
        TransactionState *tmps = transaction;
1238 tsoots 132
 
133
        if (!transactions.empty())
1226 tsoots 134
        {
1238 tsoots 135
                // fetch the next transaction to be an active transaction
136
                transactionTarget = transactions[transactions.size() - 1].first;
137
                transaction = transactions[transactions.size() - 1].second;
138
//              delete transactions[transactions.size() - 1]
139
                transactions.erase(transactions.end() - 1);
140
        }
141
        else
142
        {
143
                transaction = NULL;
144
                transactionTarget = NULL;
145
        }
146
 
147
        if (tmps->sizet() > 0) // are there any actions inside the commited transaction
148
        {
1226 tsoots 149
                if (tmps->getName() == "")
150
                        tmps->useActionName();
1213 tsoots 151
                action(tmpu, tmps);
1238 tsoots 152
        } // if not just delete objects
1226 tsoots 153
        else
154
        {
155
                delete tmpu;
156
                tmpu = NULL;
157
                delete tmps;
158
                tmps = NULL;
159
        }
1213 tsoots 160
}
161
 
162
bool UndoManager::isTransactionMode()
163
{
164
        return transaction ? true : false;
165
}
166
 
1111 tsoots 167
void UndoManager::registerGui(UndoGui* gui)
168
{
169
        if (gui == NULL)
170
                return;
171
 
172
        bool tmpUndoEnabled = _undoEnabled;
173
        setUndoEnabled(false);
174
        setState(gui);
175
        undoGuis.push_back(gui);
176
        setUndoEnabled(tmpUndoEnabled);
177
}
178
 
179
void UndoManager::setState(UndoGui* gui, int uid)
180
{
181
        gui->clear();
182
        ActionList::iterator it;
183
        for (it = stacks[currentDoc].second.end() - 1; it > stacks[currentDoc].second.begin() - 1; --it)
184
        {
185
                ActionPair pair = *it;
186
                UndoObject* target = pair.first;
187
                UndoState*  state  = pair.second;
188
                if (it > stacks[currentDoc].first - 1)
189
                        gui->insertUndoItem(target, state);
190
                else
191
                        gui->insertRedoItem(target, state);
192
        }
193
}
194
 
195
void UndoManager::connectGuis()
196
{
197
        for (uint i = 0; i < undoGuis.size(); ++i)
198
        {
199
                UndoGui *gui = undoGuis[i];
200
 
201
                connect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
202
                connect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
203
                connect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
204
                gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
205
                connect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
206
                connect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
207
                connect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
208
        }
209
}
210
 
211
void UndoManager::disconnectGuis()
212
{
213
        for (uint i = 0; i < undoGuis.size(); ++i)
214
        {
215
                UndoGui *gui = undoGuis[i];
216
 
217
                disconnect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
218
                disconnect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
219
                disconnect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
220
                   gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
221
                disconnect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
222
                disconnect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
223
                disconnect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
224
        }
225
}
226
 
227
void UndoManager::removeGui(UndoGui* gui)
228
{
229
        std::vector<UndoGui*>::iterator it;
230
        for (it = undoGuis.begin(); it != undoGuis.end(); ++it)
231
                if (*it == gui)
232
                        undoGuis.erase(it);
233
}
234
 
235
void UndoManager::switchStack(const QString& stackName)
236
{
237
        currentDoc = stackName;
238
        if (!stacks.contains(currentDoc))
239
        {
240
                ActionList alist;
241
                ActionList::iterator it = alist.begin();
242
                stacks[currentDoc] = StackPair(it, alist);
243
        }
244
 
245
        for (uint i = 0; i < undoGuis.size(); ++i)
246
                setState(undoGuis[i]);
247
}
248
 
249
void UndoManager::rename(const QString& newName)
250
{
1190 tsoots 251
        if (currentDoc == newName)
252
                return;
1111 tsoots 253
        StackPair tmp = stacks[currentDoc];
254
        stacks.erase(currentDoc);
255
        stacks[newName] = tmp;
256
        currentDoc = newName;
257
}
258
 
259
void UndoManager::remove(const QString& stackName)
260
{
261
        if (stacks.contains(stackName))
262
        {
263
                for (uint i = 0; i < stacks[stackName].second.size(); ++i)
264
                {
265
                        delete stacks[stackName].second[i].second;
266
                        stacks[stackName].second[i].second = NULL;
267
                }
268
                stacks.erase(stackName);
269
                if (currentDoc == stackName)
270
                {
271
                        for (uint i = 0; i < undoGuis.size(); ++i)
272
                                undoGuis[i]->clear();
1190 tsoots 273
                        currentDoc = "__no_name__";
1111 tsoots 274
                }
275
        }
276
}
277
 
278
void UndoManager::action(UndoObject* target, UndoState* state)
279
{
1228 tsoots 280
        if (!_undoEnabled) // if so flush down the state
281
        {
282
                TransactionState *ts = dynamic_cast<TransactionState*>(state);
283
                if (ts) // flush the TransactionObject too
284
                        delete target;
285
                delete state;
286
                return;
287
        }
288
 
1213 tsoots 289
        if ((!transaction) &&
290
        (currentUndoObjectId == -1 || currentUndoObjectId == static_cast<long>(target->getUId())))
1226 tsoots 291
                emit newAction(target, state); // send action to the guis
1111 tsoots 292
 
1228 tsoots 293
        if (stacks[currentDoc].second.size() > 1 && !transaction) // delete redo states
1111 tsoots 294
        {
295
                ActionList::iterator it;
296
                for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].first; ++it)
1226 tsoots 297
                {
298
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
299
                        if (ts)
1228 tsoots 300
                        {
1226 tsoots 301
                                delete (*it).first; // delete TransactionObject
1228 tsoots 302
                                (*it).first = NULL;
303
                        }
1111 tsoots 304
                        delete (*it).second;
1226 tsoots 305
                        (*it).second = NULL;
306
                }
1111 tsoots 307
                stacks[currentDoc].second.erase(stacks[currentDoc].second.begin(), stacks[currentDoc].first);
308
        }
309
 
1213 tsoots 310
        if (transaction)
311
                transaction->pushBack(target, state);
312
        else
313
        {
1226 tsoots 314
                checkStackLength(); // check that history length
1213 tsoots 315
                stacks[currentDoc].second.insert(stacks[currentDoc].second.begin(), ActionPair(target, state));
316
                stacks[currentDoc].first = stacks[currentDoc].second.begin();
317
        }
1111 tsoots 318
}
319
 
320
void UndoManager::undo(int steps)
321
{
322
        if (_undoEnabled);
323
                doUndo(steps);
324
}
325
 
326
void UndoManager::redo(int steps)
327
{
328
        if (_undoEnabled)
329
                doRedo(steps);
330
}
331
 
332
void UndoManager::doUndo(int steps)
333
{
1190 tsoots 334
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 335
        {
336
                bool tmpUndoEnabled = _undoEnabled;
337
                setUndoEnabled(false);
1190 tsoots 338
                UndoState* tmpUndoState = NULL;
1111 tsoots 339
                for (int i = 0; i < steps; ++i)
340
                {
341
                        ActionPair aPair = *stacks[currentDoc].first;
342
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 343
                        tmpUndoState = aPair.second;
1213 tsoots 344
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
345
                        if (tmpUndoState && !ts)
1190 tsoots 346
                                tmpUndoObject->restore(tmpUndoState, true);
1228 tsoots 347
                        else if (tmpUndoState && ts)
1213 tsoots 348
                                doTransactionUndo(ts);
1228 tsoots 349
                        ts = NULL;
1111 tsoots 350
                        ++stacks[currentDoc].first;
351
                }
1228 tsoots 352
 
353
                setUndoEnabled(tmpUndoEnabled);
354
 
1190 tsoots 355
                if (tmpUndoState)
356
                {
357
                        emit undoSignal(steps);
358
                        emit undoRedoDone();
359
                }
1111 tsoots 360
        }
361
}
362
 
1213 tsoots 363
void UndoManager::doTransactionUndo(TransactionState *tstate)
364
{
365
        for (int i = tstate->sizet() - 1; i > -1; --i)
366
        {
367
                ActionPair *pair = tstate->at(i);
368
                if (pair && pair->first && pair->second)
369
                        pair->first->restore(pair->second, true);
370
        }
371
}
372
 
1111 tsoots 373
void UndoManager::doRedo(int steps)
374
{
1190 tsoots 375
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 376
        {
377
                bool tmpUndoEnabled = _undoEnabled;
378
                setUndoEnabled(false);
1190 tsoots 379
                UndoState* tmpUndoState = NULL;
1228 tsoots 380
                for (int i = 0; i < steps; ++i) // TODO compare to stack size too
1111 tsoots 381
                {
382
                        --stacks[currentDoc].first;
383
                        ActionPair aPair = *stacks[currentDoc].first;
384
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 385
                        tmpUndoState = aPair.second;
1213 tsoots 386
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
1247 tsoots 387
                        if (tmpUndoObject && tmpUndoState && !ts)
1190 tsoots 388
                                tmpUndoObject->restore(tmpUndoState, false);
1228 tsoots 389
                        else if (tmpUndoState && ts)
1213 tsoots 390
                                doTransactionRedo(ts);
1228 tsoots 391
                        ts = NULL;
1111 tsoots 392
                }
1228 tsoots 393
 
394
                setUndoEnabled(tmpUndoEnabled);
395
 
1190 tsoots 396
                if (tmpUndoState)
397
                {
398
                        emit redoSignal(steps);
399
                        emit undoRedoDone();
400
                }
1111 tsoots 401
        }
402
}
403
 
1213 tsoots 404
void UndoManager::doTransactionRedo(TransactionState *tstate)
405
{
406
        ActionPair *pair = NULL;
407
        for (uint i = 0; i < tstate->sizet(); ++i)
408
        {
409
                pair = tstate->at(i);
410
                pair->first->restore(pair->second, false);
411
        }
412
}
413
 
1111 tsoots 414
bool UndoManager::hasUndoActions()
415
{
416
        return stacks[currentDoc].first < stacks[currentDoc].second.end();
417
}
418
 
419
bool UndoManager::hasRedoActions()
420
{
421
        return stacks[currentDoc].first > stacks[currentDoc].second.begin();
422
}
423
 
424
void UndoManager::showObject(int uid)
425
{
426
 
427
}
428
 
1238 tsoots 429
void UndoManager::replace(ulong uid, UndoObject *newUndoObject)
430
{
431
        disconnectGuis();
432
        for (uint i = 0; i < stacks[currentDoc].second.size(); ++i)
433
        {
434
                ActionPair &apair = stacks[currentDoc].second[i];
435
                TransactionState *ts = dynamic_cast<TransactionState*>(apair.second);
436
                if (ts)
437
                        ts->replace(uid, newUndoObject);
438
                else if (apair.first->getUId() == uid)
439
                        apair.first = newUndoObject;
440
        }
441
        switchStack(currentDoc);
442
}
443
 
1111 tsoots 444
void UndoManager::setHistoryLength(int steps)
445
{
1197 tsoots 446
        if (steps >= 0)
447
        {
1111 tsoots 448
                historyLength = steps;
1197 tsoots 449
                prefs->set("historyLength", historyLength);
450
                checkStackLength();
451
        }
1111 tsoots 452
}
453
 
454
int UndoManager::getHistoryLength()
455
{
1197 tsoots 456
        if (stacks.size() > 0 && stacks[currentDoc].first != stacks[currentDoc].second.begin())
457
                return -1;
1111 tsoots 458
        return historyLength;
459
}
460
 
1197 tsoots 461
void UndoManager::checkStackLength()
462
{
463
        if ((stacks[currentDoc].second.size() >= static_cast<uint>(historyLength)) && (historyLength != 0))
464
        {
465
                while (stacks[currentDoc].second.size() >= static_cast<uint>(historyLength))
466
                {
467
                        ActionList::iterator it = stacks[currentDoc].second.end() - 1;
468
                        if (stacks[currentDoc].first == it)
469
                                stacks[currentDoc].first = it - 1;
1226 tsoots 470
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
471
                        if (ts)
472
                                delete (*it).first; // delete TransactionObject
1197 tsoots 473
                        delete (*it).second;
474
                        stacks[currentDoc].second.erase(it);
475
                        emit popBack();
476
                }
477
        }
478
}
479
 
1111 tsoots 480
void UndoManager::deleteInstance()
481
{
482
        if (_instance)
483
                delete _instance;
484
        _instance = NULL;
485
}
486
 
487
UndoManager::~UndoManager()
488
{
489
        StackMap::iterator it;
490
        for (it = stacks.begin(); it != stacks.end(); ++it)
491
        {
492
                for (uint i = 0; i < (*it).second.size(); ++i)
493
                {
494
                        delete ((*it).second)[i].second;
495
                        ((*it).second)[i].second = NULL;
496
                }
497
        }
498
}
1190 tsoots 499
 
1213 tsoots 500
/*** UndoManager::TransactionState *****************************************************/
501
 
1226 tsoots 502
UndoManager::TransactionState::TransactionState() : UndoState("")
1213 tsoots 503
{
504
        _size = 0;
505
}
506
 
507
ActionPair* UndoManager::TransactionState::at(int index)
508
{
509
        if (index >= 0 && static_cast<uint>(index) < sizet())
510
                return states[index];
511
        else
512
                return NULL;
513
}
514
 
515
void UndoManager::TransactionState::pushBack(UndoObject *target, UndoState *state)
516
{
517
        if (target && state)
518
        {
519
                states.push_back(new ActionPair(target, state));
520
                ++_size;
521
        }
522
}
523
 
524
uint UndoManager::TransactionState::sizet()
525
{
526
        return _size;
527
}
528
 
1226 tsoots 529
void UndoManager::TransactionState::useActionName()
530
{
531
        if (_size > 0)
532
        {
533
                setName(states[_size - 1]->second->getName());
534
        }
535
}
536
 
1238 tsoots 537
void UndoManager::TransactionState::replace(ulong uid, UndoObject *newUndoObject)
538
{
539
        for (uint i = 0; i < states.size(); ++i)
540
                if (states[i]->first->getUId() == uid)
541
                        states[i]->first = newUndoObject;
542
}
543
 
1213 tsoots 544
UndoManager::TransactionState::~TransactionState()
545
{
546
        for (uint i = 0; i < states.size(); ++i)
547
        {
1226 tsoots 548
                if (states[i])
549
                {
550
                        if (states[i]->second)
551
                        {
552
                                delete states[i]->second;
553
                                states[i]->second = NULL;
554
                        }
555
                        delete states[i];
556
                        states[i] = NULL;
557
                }
1213 tsoots 558
        }
559
}
560
 
561
/*************************************************************************************/
562
 
1190 tsoots 563
void UndoManager::initIcons()
564
{
565
        QString iconDir = ICONDIR;
1247 tsoots 566
 
1250 tsoots 567
/*** Icons for UndoObjects *******************************************/
568
        UndoManager::IImageFrame      = new QPixmap(iconDir + "Bild.xpm");
569
        UndoManager::ITextFrame       = new QPixmap(iconDir + "Text.xpm");
570
        UndoManager::ILine            = new QPixmap(iconDir + "Stift.xpm");
571
        UndoManager::IPolygon         = new QPixmap(iconDir + "spline.png");
572
        UndoManager::IPolyline        = new QPixmap(iconDir + "beziertool.png");
573
//      UndoManager::IPathText        = new QPixmap(iconDir + "?";
574
/*** Icons for actions ***********************************************/
575
        UndoManager::IMove            = new QPixmap(iconDir + "u_move.png");
576
        UndoManager::IResize          = new QPixmap(iconDir + "u_resize.png");
577
        UndoManager::IRotate          = new QPixmap(iconDir + "u_rotate.png");
1247 tsoots 578
        UndoManager::IAlignDistribute = new QPixmap(iconDir + "u_align.png");
1250 tsoots 579
        UndoManager::IGuides          = new QPixmap(iconDir + "u_margins.png");
580
        UndoManager::ILockGuides      = new QPixmap(iconDir + "u_margins_locked.png");
1190 tsoots 581
}
582
 
1247 tsoots 583
const QString UndoManager::AddVGuide         = tr("Add vertical guide");
584
const QString UndoManager::AddHGuide         = tr("Add horizontal guide");
585
const QString UndoManager::DelVGuide         = tr("Remove vertical guide");
586
const QString UndoManager::DelHGuide         = tr("Remove horizontal guide");
587
const QString UndoManager::MoveVGuide        = tr("Move vertical guide");
588
const QString UndoManager::MoveHGuide        = tr("Move horizontal guide");
589
const QString UndoManager::LockGuides        = tr("Lock guides");
590
const QString UndoManager::UnlockGuides      = tr("Unlock guides");
591
const QString UndoManager::Move              = tr("Move");
592
const QString UndoManager::Resize            = tr("Resize");
593
const QString UndoManager::Rotate            = tr("Rotate");
594
const QString UndoManager::MoveFromTo        = tr("X1: %1, Y1: %2, Page %3\nX2: %4, Y2: %5, Page %6");
595
const QString UndoManager::ResizeFromTo      = tr("W1: %1, H1: %2\nW2: %3, H2: %4");
596
const QString UndoManager::RotateFromTo      = tr("From %1 to %2");
597
const QString UndoManager::Selection         = tr("Selection");
598
const QString UndoManager::Group             = tr("Group");
599
const QString UndoManager::Create            = tr("Create");
600
const QString UndoManager::CreateTo          = tr("X: %1, Y: %2\nW: %3, H: %4");
601
const QString UndoManager::AlignDistribute   = tr("Align/Distribute");
602
const QString UndoManager::ItemsInvolved     = tr("Items involved");
603
const QString UndoManager::Cancel            = tr("Cancel");
1190 tsoots 604
 
1250 tsoots 605
/*** Icons for UndoObjects *******************************************/
606
QPixmap *UndoManager::IImageFrame      = NULL;
607
QPixmap *UndoManager::ITextFrame       = NULL;
608
QPixmap *UndoManager::ILine            = NULL;
609
QPixmap *UndoManager::IPolygon         = NULL;
610
QPixmap *UndoManager::IPolyline        = NULL;
611
QPixmap *UndoManager::IPathText        = NULL;
612
/*** Icons for actions ***********************************************/
613
QPixmap *UndoManager::IMove            = NULL;
614
QPixmap *UndoManager::IResize          = NULL;
615
QPixmap *UndoManager::IRotate          = NULL;
1247 tsoots 616
QPixmap *UndoManager::IGuides          = NULL;
617
QPixmap *UndoManager::ILockGuides      = NULL;
618
QPixmap *UndoManager::IAlignDistribute = NULL;