Subversion Repositories Scribus

Rev

Rev 1371 | Rev 1385 | 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
{
1340 tsoots 76
        if (!_undoEnabled)
77
                return;
1238 tsoots 78
        if (transaction) // begin a transaction inside transaction
79
                transactions.push_back(
80
                        std::pair<TransactionObject*, TransactionState*>(transactionTarget, transaction));
1213 tsoots 81
        transaction = new TransactionState();
82
        transactionTarget = new TransactionObject();
1228 tsoots 83
        transactionTarget->setUName(targetName); // Name which will be in action history
1250 tsoots 84
        if (targetPixmap)
85
                transactionTarget->setUPixmap(targetPixmap);
1228 tsoots 86
        if (name.length() > 0)          // if left to 0 length action will be fetched from the
87
                transaction->setName(name); // last added UndoState in this transaction
1238 tsoots 88
        if (description.length() > 0)
1228 tsoots 89
                transaction->setDescription(description); // tool tip for action history
1250 tsoots 90
        if (actionPixmap)
91
                transaction->setPixmap(actionPixmap); // for action history
1213 tsoots 92
}
93
 
94
void UndoManager::cancelTransaction()
95
{
96
        delete transaction;
97
        transaction = NULL;
98
        delete transactionTarget;
99
        transactionTarget = NULL;
1238 tsoots 100
        if (!transactions.empty())
101
        {
102
                // fetch the next transaction from the vector
103
                transactionTarget = transactions[transactions.size() - 1].first;
104
                transaction = transactions[transactions.size() - 1].second;
105
//              delete transactions[transactions.size() - 1];
106
                transactions.erase(transactions.end() - 1);
107
        }
1213 tsoots 108
}
109
 
110
void UndoManager::commit(const QString &targetName,
1250 tsoots 111
                         QPixmap *targetPixmap,
1213 tsoots 112
                         const QString &name,
113
                         const QString &description,
1250 tsoots 114
                         QPixmap *actionPixmap)
1213 tsoots 115
{
1340 tsoots 116
        if (!transaction || !transactionTarget || !_undoEnabled)
1213 tsoots 117
        {
118
                cancelTransaction();
119
                return;
120
        }
121
        if (targetName.length() > 0)
122
                transactionTarget->setUName(targetName);
1250 tsoots 123
        if (targetPixmap)
124
                transactionTarget->setUPixmap(targetPixmap);
1213 tsoots 125
        if (name.length() > 0)
126
                transaction->setName(name);
127
        if (description.length() > 0)
128
                transaction->setDescription(description);
1250 tsoots 129
        if (actionPixmap)
130
                transaction->setPixmap(actionPixmap);
1213 tsoots 131
 
132
        UndoObject *tmpu = transactionTarget;
133
        TransactionState *tmps = transaction;
1238 tsoots 134
 
135
        if (!transactions.empty())
1226 tsoots 136
        {
1238 tsoots 137
                // fetch the next transaction to be an active transaction
138
                transactionTarget = transactions[transactions.size() - 1].first;
139
                transaction = transactions[transactions.size() - 1].second;
140
//              delete transactions[transactions.size() - 1]
141
                transactions.erase(transactions.end() - 1);
142
        }
143
        else
144
        {
145
                transaction = NULL;
146
                transactionTarget = NULL;
147
        }
148
 
149
        if (tmps->sizet() > 0) // are there any actions inside the commited transaction
150
        {
1226 tsoots 151
                if (tmps->getName() == "")
152
                        tmps->useActionName();
1213 tsoots 153
                action(tmpu, tmps);
1238 tsoots 154
        } // if not just delete objects
1226 tsoots 155
        else
156
        {
157
                delete tmpu;
158
                tmpu = NULL;
159
                delete tmps;
160
                tmps = NULL;
161
        }
1213 tsoots 162
}
163
 
164
bool UndoManager::isTransactionMode()
165
{
166
        return transaction ? true : false;
167
}
168
 
1111 tsoots 169
void UndoManager::registerGui(UndoGui* gui)
170
{
171
        if (gui == NULL)
172
                return;
173
 
174
        bool tmpUndoEnabled = _undoEnabled;
175
        setUndoEnabled(false);
176
        setState(gui);
177
        undoGuis.push_back(gui);
178
        setUndoEnabled(tmpUndoEnabled);
179
}
180
 
181
void UndoManager::setState(UndoGui* gui, int uid)
182
{
183
        gui->clear();
184
        ActionList::iterator it;
185
        for (it = stacks[currentDoc].second.end() - 1; it > stacks[currentDoc].second.begin() - 1; --it)
186
        {
187
                ActionPair pair = *it;
188
                UndoObject* target = pair.first;
189
                UndoState*  state  = pair.second;
190
                if (it > stacks[currentDoc].first - 1)
191
                        gui->insertUndoItem(target, state);
192
                else
193
                        gui->insertRedoItem(target, state);
194
        }
195
}
196
 
197
void UndoManager::connectGuis()
198
{
199
        for (uint i = 0; i < undoGuis.size(); ++i)
200
        {
201
                UndoGui *gui = undoGuis[i];
202
 
203
                connect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
204
                connect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
205
                connect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
206
                gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
207
                connect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
208
                connect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
209
                connect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
210
        }
211
}
212
 
213
void UndoManager::disconnectGuis()
214
{
215
        for (uint i = 0; i < undoGuis.size(); ++i)
216
        {
217
                UndoGui *gui = undoGuis[i];
218
 
219
                disconnect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
220
                disconnect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
221
                disconnect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
222
                   gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
223
                disconnect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
224
                disconnect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
225
                disconnect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
226
        }
227
}
228
 
229
void UndoManager::removeGui(UndoGui* gui)
230
{
231
        std::vector<UndoGui*>::iterator it;
232
        for (it = undoGuis.begin(); it != undoGuis.end(); ++it)
233
                if (*it == gui)
234
                        undoGuis.erase(it);
235
}
236
 
237
void UndoManager::switchStack(const QString& stackName)
238
{
239
        currentDoc = stackName;
240
        if (!stacks.contains(currentDoc))
241
        {
242
                ActionList alist;
243
                ActionList::iterator it = alist.begin();
244
                stacks[currentDoc] = StackPair(it, alist);
245
        }
246
 
247
        for (uint i = 0; i < undoGuis.size(); ++i)
248
                setState(undoGuis[i]);
249
}
250
 
1252 tsoots 251
void UndoManager::renameStack(const QString& newName)
1111 tsoots 252
{
1190 tsoots 253
        if (currentDoc == newName)
254
                return;
1111 tsoots 255
        StackPair tmp = stacks[currentDoc];
256
        stacks.erase(currentDoc);
257
        stacks[newName] = tmp;
258
        currentDoc = newName;
259
}
260
 
1252 tsoots 261
void UndoManager::removeStack(const QString& stackName)
1111 tsoots 262
{
263
        if (stacks.contains(stackName))
264
        {
265
                for (uint i = 0; i < stacks[stackName].second.size(); ++i)
266
                {
267
                        delete stacks[stackName].second[i].second;
268
                        stacks[stackName].second[i].second = NULL;
269
                }
270
                stacks.erase(stackName);
271
                if (currentDoc == stackName)
272
                {
273
                        for (uint i = 0; i < undoGuis.size(); ++i)
274
                                undoGuis[i]->clear();
1190 tsoots 275
                        currentDoc = "__no_name__";
1111 tsoots 276
                }
277
        }
278
}
279
 
1340 tsoots 280
void UndoManager::action(UndoObject* target, UndoState* state, QPixmap *targetPixmap)
1111 tsoots 281
{
1340 tsoots 282
        QPixmap *oldIcon = NULL;
283
        if (targetPixmap)
284
        {
285
                oldIcon = target->getUPixmap();
286
                target->setUPixmap(targetPixmap);
287
        }
288
        if (targetPixmap)
1228 tsoots 289
        if (!_undoEnabled) // if so flush down the state
290
        {
291
                TransactionState *ts = dynamic_cast<TransactionState*>(state);
292
                if (ts) // flush the TransactionObject too
293
                        delete target;
294
                delete state;
295
                return;
296
        }
297
 
1213 tsoots 298
        if ((!transaction) &&
299
        (currentUndoObjectId == -1 || currentUndoObjectId == static_cast<long>(target->getUId())))
1226 tsoots 300
                emit newAction(target, state); // send action to the guis
1111 tsoots 301
 
1228 tsoots 302
        if (stacks[currentDoc].second.size() > 1 && !transaction) // delete redo states
1111 tsoots 303
        {
304
                ActionList::iterator it;
305
                for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].first; ++it)
1226 tsoots 306
                {
307
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
308
                        if (ts)
1228 tsoots 309
                        {
1226 tsoots 310
                                delete (*it).first; // delete TransactionObject
1228 tsoots 311
                                (*it).first = NULL;
312
                        }
1111 tsoots 313
                        delete (*it).second;
1226 tsoots 314
                        (*it).second = NULL;
315
                }
1111 tsoots 316
                stacks[currentDoc].second.erase(stacks[currentDoc].second.begin(), stacks[currentDoc].first);
317
        }
318
 
1213 tsoots 319
        if (transaction)
320
                transaction->pushBack(target, state);
321
        else
322
        {
1226 tsoots 323
                checkStackLength(); // check that history length
1213 tsoots 324
                stacks[currentDoc].second.insert(stacks[currentDoc].second.begin(), ActionPair(target, state));
325
                stacks[currentDoc].first = stacks[currentDoc].second.begin();
326
        }
1340 tsoots 327
        if (targetPixmap)
328
                target->setUPixmap(oldIcon);
1111 tsoots 329
}
1356 tsoots 330
void UndoManager::action(UndoObject* target, UndoState* state,
331
                         const QString &targetName, QPixmap *targetPixmap)
332
{
333
        QString oldName = target->getUName();
334
        if (targetName != "")
335
                target->setUName(targetName);
336
        action(target, state, targetPixmap);
337
        target->setUName(oldName);
338
}
1111 tsoots 339
 
340
void UndoManager::undo(int steps)
341
{
342
        if (_undoEnabled);
343
                doUndo(steps);
344
}
345
 
346
void UndoManager::redo(int steps)
347
{
348
        if (_undoEnabled)
349
                doRedo(steps);
350
}
351
 
352
void UndoManager::doUndo(int steps)
353
{
1190 tsoots 354
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 355
        {
356
                bool tmpUndoEnabled = _undoEnabled;
357
                setUndoEnabled(false);
1190 tsoots 358
                UndoState* tmpUndoState = NULL;
1111 tsoots 359
                for (int i = 0; i < steps; ++i)
360
                {
361
                        ActionPair aPair = *stacks[currentDoc].first;
362
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 363
                        tmpUndoState = aPair.second;
1213 tsoots 364
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
1251 tsoots 365
                        if (tmpUndoObject && tmpUndoState && !ts)
1190 tsoots 366
                                tmpUndoObject->restore(tmpUndoState, true);
1228 tsoots 367
                        else if (tmpUndoState && ts)
1213 tsoots 368
                                doTransactionUndo(ts);
1228 tsoots 369
                        ts = NULL;
1111 tsoots 370
                        ++stacks[currentDoc].first;
371
                }
1228 tsoots 372
 
373
                setUndoEnabled(tmpUndoEnabled);
374
 
1190 tsoots 375
                if (tmpUndoState)
376
                {
377
                        emit undoSignal(steps);
378
                        emit undoRedoDone();
379
                }
1111 tsoots 380
        }
381
}
382
 
1213 tsoots 383
void UndoManager::doTransactionUndo(TransactionState *tstate)
384
{
385
        for (int i = tstate->sizet() - 1; i > -1; --i)
386
        {
387
                ActionPair *pair = tstate->at(i);
1262 tsoots 388
                TransactionState *ts = dynamic_cast<TransactionState*>(pair->second);
389
                if (pair && pair->first && pair->second && !ts)
1213 tsoots 390
                        pair->first->restore(pair->second, true);
1262 tsoots 391
                else if (pair && pair->second && ts)
392
                        doTransactionUndo(ts);
1213 tsoots 393
        }
394
}
395
 
1111 tsoots 396
void UndoManager::doRedo(int steps)
397
{
1190 tsoots 398
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 399
        {
400
                bool tmpUndoEnabled = _undoEnabled;
401
                setUndoEnabled(false);
1190 tsoots 402
                UndoState* tmpUndoState = NULL;
1228 tsoots 403
                for (int i = 0; i < steps; ++i) // TODO compare to stack size too
1111 tsoots 404
                {
405
                        --stacks[currentDoc].first;
406
                        ActionPair aPair = *stacks[currentDoc].first;
407
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 408
                        tmpUndoState = aPair.second;
1213 tsoots 409
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
1247 tsoots 410
                        if (tmpUndoObject && tmpUndoState && !ts)
1190 tsoots 411
                                tmpUndoObject->restore(tmpUndoState, false);
1228 tsoots 412
                        else if (tmpUndoState && ts)
1213 tsoots 413
                                doTransactionRedo(ts);
1228 tsoots 414
                        ts = NULL;
1111 tsoots 415
                }
1228 tsoots 416
 
417
                setUndoEnabled(tmpUndoEnabled);
418
 
1190 tsoots 419
                if (tmpUndoState)
420
                {
421
                        emit redoSignal(steps);
422
                        emit undoRedoDone();
423
                }
1111 tsoots 424
        }
425
}
426
 
1213 tsoots 427
void UndoManager::doTransactionRedo(TransactionState *tstate)
428
{
429
        for (uint i = 0; i < tstate->sizet(); ++i)
430
        {
1262 tsoots 431
                ActionPair *pair = tstate->at(i);
432
                TransactionState *ts = dynamic_cast<TransactionState*>(pair->second);
433
                if (pair && pair->first && pair->second && !ts)
434
                        pair->first->restore(pair->second, false);
435
                else if (pair && pair->second && ts)
436
                        doTransactionRedo(ts);
1213 tsoots 437
        }
438
}
439
 
1111 tsoots 440
bool UndoManager::hasUndoActions()
441
{
442
        return stacks[currentDoc].first < stacks[currentDoc].second.end();
443
}
444
 
445
bool UndoManager::hasRedoActions()
446
{
447
        return stacks[currentDoc].first > stacks[currentDoc].second.begin();
448
}
449
 
450
void UndoManager::showObject(int uid)
451
{
452
 
453
}
454
 
1252 tsoots 455
void UndoManager::replaceObject(ulong uid, UndoObject *newUndoObject)
1238 tsoots 456
{
457
        for (uint i = 0; i < stacks[currentDoc].second.size(); ++i)
458
        {
459
                ActionPair &apair = stacks[currentDoc].second[i];
460
                TransactionState *ts = dynamic_cast<TransactionState*>(apair.second);
461
                if (ts)
462
                        ts->replace(uid, newUndoObject);
1258 tsoots 463
                else if (apair.first && apair.first->getUId() == uid)
1238 tsoots 464
                        apair.first = newUndoObject;
465
        }
466
}
467
 
1111 tsoots 468
void UndoManager::setHistoryLength(int steps)
469
{
1197 tsoots 470
        if (steps >= 0)
471
        {
1111 tsoots 472
                historyLength = steps;
1197 tsoots 473
                prefs->set("historyLength", historyLength);
474
                checkStackLength();
475
        }
1111 tsoots 476
}
477
 
478
int UndoManager::getHistoryLength()
479
{
1197 tsoots 480
        if (stacks.size() > 0 && stacks[currentDoc].first != stacks[currentDoc].second.begin())
481
                return -1;
1111 tsoots 482
        return historyLength;
483
}
484
 
1197 tsoots 485
void UndoManager::checkStackLength()
486
{
487
        if ((stacks[currentDoc].second.size() >= static_cast<uint>(historyLength)) && (historyLength != 0))
488
        {
489
                while (stacks[currentDoc].second.size() >= static_cast<uint>(historyLength))
490
                {
491
                        ActionList::iterator it = stacks[currentDoc].second.end() - 1;
492
                        if (stacks[currentDoc].first == it)
493
                                stacks[currentDoc].first = it - 1;
1226 tsoots 494
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
495
                        if (ts)
496
                                delete (*it).first; // delete TransactionObject
1197 tsoots 497
                        delete (*it).second;
498
                        stacks[currentDoc].second.erase(it);
499
                        emit popBack();
500
                }
501
        }
502
}
503
 
1111 tsoots 504
void UndoManager::deleteInstance()
505
{
506
        if (_instance)
507
                delete _instance;
508
        _instance = NULL;
509
}
510
 
511
UndoManager::~UndoManager()
512
{
513
        StackMap::iterator it;
514
        for (it = stacks.begin(); it != stacks.end(); ++it)
515
        {
516
                for (uint i = 0; i < (*it).second.size(); ++i)
517
                {
518
                        delete ((*it).second)[i].second;
519
                        ((*it).second)[i].second = NULL;
520
                }
521
        }
522
}
1190 tsoots 523
 
1213 tsoots 524
/*** UndoManager::TransactionState *****************************************************/
525
 
1226 tsoots 526
UndoManager::TransactionState::TransactionState() : UndoState("")
1213 tsoots 527
{
528
        _size = 0;
529
}
530
 
531
ActionPair* UndoManager::TransactionState::at(int index)
532
{
533
        if (index >= 0 && static_cast<uint>(index) < sizet())
534
                return states[index];
535
        else
536
                return NULL;
537
}
538
 
539
void UndoManager::TransactionState::pushBack(UndoObject *target, UndoState *state)
540
{
541
        if (target && state)
542
        {
543
                states.push_back(new ActionPair(target, state));
544
                ++_size;
545
        }
546
}
547
 
548
uint UndoManager::TransactionState::sizet()
549
{
550
        return _size;
551
}
552
 
1226 tsoots 553
void UndoManager::TransactionState::useActionName()
554
{
555
        if (_size > 0)
556
        {
557
                setName(states[_size - 1]->second->getName());
558
        }
559
}
560
 
1238 tsoots 561
void UndoManager::TransactionState::replace(ulong uid, UndoObject *newUndoObject)
562
{
563
        for (uint i = 0; i < states.size(); ++i)
564
                if (states[i]->first->getUId() == uid)
565
                        states[i]->first = newUndoObject;
566
}
567
 
1213 tsoots 568
UndoManager::TransactionState::~TransactionState()
569
{
570
        for (uint i = 0; i < states.size(); ++i)
571
        {
1226 tsoots 572
                if (states[i])
573
                {
574
                        if (states[i]->second)
575
                        {
576
                                delete states[i]->second;
577
                                states[i]->second = NULL;
578
                        }
579
                        delete states[i];
580
                        states[i] = NULL;
581
                }
1213 tsoots 582
        }
583
}
584
 
585
/*************************************************************************************/
586
 
1190 tsoots 587
void UndoManager::initIcons()
588
{
589
        QString iconDir = ICONDIR;
1247 tsoots 590
 
1250 tsoots 591
/*** Icons for UndoObjects *******************************************/
592
        UndoManager::IImageFrame      = new QPixmap(iconDir + "Bild.xpm");
593
        UndoManager::ITextFrame       = new QPixmap(iconDir + "Text.xpm");
594
        UndoManager::ILine            = new QPixmap(iconDir + "Stift.xpm");
595
        UndoManager::IPolygon         = new QPixmap(iconDir + "spline.png");
596
        UndoManager::IPolyline        = new QPixmap(iconDir + "beziertool.png");
597
//      UndoManager::IPathText        = new QPixmap(iconDir + "?";
1254 tsoots 598
        UndoManager::IGroup           = new QPixmap(iconDir + "u_group.png");
1250 tsoots 599
/*** Icons for actions ***********************************************/
600
        UndoManager::IMove            = new QPixmap(iconDir + "u_move.png");
601
        UndoManager::IResize          = new QPixmap(iconDir + "u_resize.png");
602
        UndoManager::IRotate          = new QPixmap(iconDir + "u_rotate.png");
1247 tsoots 603
        UndoManager::IAlignDistribute = new QPixmap(iconDir + "u_align.png");
1250 tsoots 604
        UndoManager::IGuides          = new QPixmap(iconDir + "u_margins.png");
605
        UndoManager::ILockGuides      = new QPixmap(iconDir + "u_margins_locked.png");
1286 tsoots 606
        UndoManager::IFill            = new QPixmap(iconDir + "u_fill.png");
607
        UndoManager::IShade           = new QPixmap(iconDir + "u_shade.png");
1340 tsoots 608
        UndoManager::IFlipH           = new QPixmap(iconDir + "u_fliph.png");
609
        UndoManager::IFlipV           = new QPixmap(iconDir + "u_flipv.png");
1290 tsoots 610
        UndoManager::ILock            = new QPixmap(iconDir + "u_lock.png");
611
        UndoManager::IUnLock          = new QPixmap(iconDir + "u_unlock.png");
1340 tsoots 612
        UndoManager::IDelete          = new QPixmap(iconDir + "u_delete.png");
613
        UndoManager::ICreate          = new QPixmap(iconDir + "u_create.png");
1369 tsoots 614
        UndoManager::IPaste           = new QPixmap(iconDir + "editpaste.png");
615
        UndoManager::ICut             = new QPixmap(iconDir + "u_cut.png");
1371 tsoots 616
        UndoManager::ITransparency    = new QPixmap(iconDir + "u_transp.png");
1383 tsoots 617
        UndoManager::ILineStyle       = new QPixmap(iconDir + "u_line.png");
1190 tsoots 618
}
619
 
1247 tsoots 620
const QString UndoManager::AddVGuide         = tr("Add vertical guide");
621
const QString UndoManager::AddHGuide         = tr("Add horizontal guide");
622
const QString UndoManager::DelVGuide         = tr("Remove vertical guide");
623
const QString UndoManager::DelHGuide         = tr("Remove horizontal guide");
624
const QString UndoManager::MoveVGuide        = tr("Move vertical guide");
625
const QString UndoManager::MoveHGuide        = tr("Move horizontal guide");
626
const QString UndoManager::LockGuides        = tr("Lock guides");
627
const QString UndoManager::UnlockGuides      = tr("Unlock guides");
628
const QString UndoManager::Move              = tr("Move");
629
const QString UndoManager::Resize            = tr("Resize");
630
const QString UndoManager::Rotate            = tr("Rotate");
631
const QString UndoManager::MoveFromTo        = tr("X1: %1, Y1: %2, Page %3\nX2: %4, Y2: %5, Page %6");
632
const QString UndoManager::ResizeFromTo      = tr("W1: %1, H1: %2\nW2: %3, H2: %4");
633
const QString UndoManager::RotateFromTo      = tr("From %1 to %2");
634
const QString UndoManager::Selection         = tr("Selection");
635
const QString UndoManager::Group             = tr("Group");
1355 tsoots 636
const QString UndoManager::SelectionGroup    = tr("Selection/Group");
1247 tsoots 637
const QString UndoManager::Create            = tr("Create");
638
const QString UndoManager::CreateTo          = tr("X: %1, Y: %2\nW: %3, H: %4");
639
const QString UndoManager::AlignDistribute   = tr("Align/Distribute");
640
const QString UndoManager::ItemsInvolved     = tr("Items involved");
641
const QString UndoManager::Cancel            = tr("Cancel");
1286 tsoots 642
const QString UndoManager::SetFill           = tr("Set fill color");
643
const QString UndoManager::ColorFromTo       = tr("Color1: %1, Color2: %2");
644
const QString UndoManager::SetShade          = tr("Set fill color shade");
645
const QString UndoManager::ShadeFromTo       = tr("Shade1: %1, Shade2: %2");
646
const QString UndoManager::SetLineColor      = tr("Set line color");
647
const QString UndoManager::SetLineShade      = tr("Set line color shade");
1287 tsoots 648
const QString UndoManager::FlipH             = tr("Flip horizontally");
649
const QString UndoManager::FlipV             = tr("Flip vertically");
1290 tsoots 650
const QString UndoManager::Lock              = tr("Lock");
651
const QString UndoManager::UnLock            = tr("Unlock");
652
const QString UndoManager::SizeLock          = tr("Lock size");
653
const QString UndoManager::SizeUnLock        = tr("Unlock size");
1293 tsoots 654
const QString UndoManager::Ungroup           = tr("Ungroup");
1340 tsoots 655
const QString UndoManager::Delete            = tr("Delete");
1357 tsoots 656
const QString UndoManager::Rename            = tr("Rename");
657
const QString UndoManager::FromTo            = tr("From %1 to %2");
658
const QString UndoManager::ApplyTemplate     = tr("Apply template");
1369 tsoots 659
const QString UndoManager::Paste             = tr("Paste");
660
const QString UndoManager::Cut               = tr("Cut");
1371 tsoots 661
const QString UndoManager::Transparency      = tr("Set fill color transparency");
662
const QString UndoManager::LineTransparency  = tr("Set line color transparency");
1383 tsoots 663
const QString UndoManager::LineStyle         = tr("Set line style");
1190 tsoots 664
 
1250 tsoots 665
/*** Icons for UndoObjects *******************************************/
666
QPixmap *UndoManager::IImageFrame      = NULL;
667
QPixmap *UndoManager::ITextFrame       = NULL;
668
QPixmap *UndoManager::ILine            = NULL;
669
QPixmap *UndoManager::IPolygon         = NULL;
670
QPixmap *UndoManager::IPolyline        = NULL;
671
QPixmap *UndoManager::IPathText        = NULL;
1254 tsoots 672
QPixmap *UndoManager::IGroup           = NULL;
1250 tsoots 673
/*** Icons for actions ***********************************************/
674
QPixmap *UndoManager::IMove            = NULL;
675
QPixmap *UndoManager::IResize          = NULL;
676
QPixmap *UndoManager::IRotate          = NULL;
1247 tsoots 677
QPixmap *UndoManager::IGuides          = NULL;
678
QPixmap *UndoManager::ILockGuides      = NULL;
679
QPixmap *UndoManager::IAlignDistribute = NULL;
1286 tsoots 680
QPixmap *UndoManager::IFill            = NULL;
681
QPixmap *UndoManager::IShade           = NULL;
1287 tsoots 682
QPixmap *UndoManager::IFlipH           = NULL;
683
QPixmap *UndoManager::IFlipV           = NULL;
1290 tsoots 684
QPixmap *UndoManager::ILock            = NULL;
685
QPixmap *UndoManager::IUnLock          = NULL;
1340 tsoots 686
QPixmap *UndoManager::IDelete          = NULL;
687
QPixmap *UndoManager::ICreate          = NULL;
1369 tsoots 688
QPixmap *UndoManager::IPaste           = NULL;
689
QPixmap *UndoManager::ICut             = NULL;
1371 tsoots 690
QPixmap *UndoManager::ITransparency    = NULL;
1383 tsoots 691
QPixmap *UndoManager::ILineStyle       = NULL;