Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
2218 cbradney 7
/***************************************************************************
1111 tsoots 8
 *   Copyright (C) 2005 by Riku Leino                                      *
9
 *   tsoots@gmail.com                                                      *
10
 *                                                                         *
11
 *   This program is free software; you can redistribute it and/or modify  *
12
 *   it under the terms of the GNU General Public License as published by  *
13
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 *   (at your option) any later version.                                   *
15
 *                                                                         *
16
 *   This program is distributed in the hope that it will be useful,       *
17
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
18
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
19
 *   GNU General Public License for more details.                          *
20
 *                                                                         *
21
 *   You should have received a copy of the GNU General Public License     *
22
 *   along with this program; if not, write to the                         *
23
 *   Free Software Foundation, Inc.,                                       *
24
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
25
 ***************************************************************************/
26
 
27
#include "undomanager.h"
1119 fschmid 28
#include "undomanager.moc"
1142 tsoots 29
#include "undogui.h"
2688 craig 30
#include "scconfig.h"
2856 cbradney 31
#include "prefsmanager.h"
1197 tsoots 32
#include "prefscontext.h"
33
#include "prefsfile.h"
1111 tsoots 34
#include <qvaluelist.h>
35
 
1693 craig 36
#include "scpaths.h"
37
 
1190 tsoots 38
extern QPixmap loadIcon(QString nam);
39
 
1430 tsoots 40
UndoManager* UndoManager::_instance          = 0;
41
bool         UndoManager::_undoEnabled       = true;
42
int          UndoManager::undoEnabledCounter = 0;
1111 tsoots 43
 
44
UndoManager* UndoManager::instance()
45
{
46
        if (_instance == 0)
47
                _instance = new UndoManager();
48
 
49
        return _instance;
50
}
51
 
52
void UndoManager::setUndoEnabled(bool isEnabled)
53
{
1430 tsoots 54
        if (isEnabled && undoEnabledCounter == 0)
55
                return; // nothing to do undo is already enabled.
56
        else if (isEnabled && undoEnabledCounter > 0)
57
                --undoEnabledCounter;
58
        else if (!isEnabled)
59
                ++undoEnabledCounter;
60
 
61
        _undoEnabled = undoEnabledCounter == 0;
62
        if (_undoEnabled)
1111 tsoots 63
                connectGuis();
1430 tsoots 64
        else if (undoEnabledCounter == 1)
65
                disconnectGuis(); // disconnect only once when setUndoEnabled(false) has been called
66
                                  // no need to call again if next setUndoEnabled() call will also be false.
1111 tsoots 67
}
68
 
69
bool UndoManager::undoEnabled()
70
{
71
        return _undoEnabled;
72
}
73
 
74
UndoManager::UndoManager()
75
{
76
        currentUndoObjectId = -1;
1190 tsoots 77
        if (!UndoManager::IGuides)
78
                initIcons();
2856 cbradney 79
        prefs = PrefsManager::instance()->prefsFile->getContext("undo");
2604 tsoots 80
        historyLength = prefs->getInt("historyLength", 20);
1197 tsoots 81
        if (historyLength < 0)
82
                historyLength = 10;
2604 tsoots 83
        transaction = 0;
84
        transactionTarget = 0;
2198 cbradney 85
        languageChange();
1111 tsoots 86
}
87
 
1213 tsoots 88
void UndoManager::beginTransaction(const QString &targetName,
1250 tsoots 89
                                   QPixmap *targetPixmap,
1213 tsoots 90
                                   const QString &name,
91
                                   const QString &description,
1250 tsoots 92
                                   QPixmap *actionPixmap)
1213 tsoots 93
{
1340 tsoots 94
        if (!_undoEnabled)
95
                return;
1238 tsoots 96
        if (transaction) // begin a transaction inside transaction
97
                transactions.push_back(
98
                        std::pair<TransactionObject*, TransactionState*>(transactionTarget, transaction));
1213 tsoots 99
        transaction = new TransactionState();
100
        transactionTarget = new TransactionObject();
1228 tsoots 101
        transactionTarget->setUName(targetName); // Name which will be in action history
1250 tsoots 102
        if (targetPixmap)
103
                transactionTarget->setUPixmap(targetPixmap);
1228 tsoots 104
        if (name.length() > 0)          // if left to 0 length action will be fetched from the
105
                transaction->setName(name); // last added UndoState in this transaction
1238 tsoots 106
        if (description.length() > 0)
1228 tsoots 107
                transaction->setDescription(description); // tool tip for action history
1250 tsoots 108
        if (actionPixmap)
109
                transaction->setPixmap(actionPixmap); // for action history
1213 tsoots 110
}
111
 
112
void UndoManager::cancelTransaction()
113
{
114
        delete transaction;
2604 tsoots 115
        transaction = 0;
1213 tsoots 116
        delete transactionTarget;
2604 tsoots 117
        transactionTarget = 0;
1238 tsoots 118
        if (!transactions.empty())
119
        {
120
                // fetch the next transaction from the vector
121
                transactionTarget = transactions[transactions.size() - 1].first;
122
                transaction = transactions[transactions.size() - 1].second;
123
//              delete transactions[transactions.size() - 1];
124
                transactions.erase(transactions.end() - 1);
125
        }
1213 tsoots 126
}
127
 
128
void UndoManager::commit(const QString &targetName,
1250 tsoots 129
                         QPixmap *targetPixmap,
1213 tsoots 130
                         const QString &name,
131
                         const QString &description,
1250 tsoots 132
                         QPixmap *actionPixmap)
1213 tsoots 133
{
1340 tsoots 134
        if (!transaction || !transactionTarget || !_undoEnabled)
1213 tsoots 135
        {
136
                cancelTransaction();
137
                return;
138
        }
139
        if (targetName.length() > 0)
140
                transactionTarget->setUName(targetName);
1250 tsoots 141
        if (targetPixmap)
142
                transactionTarget->setUPixmap(targetPixmap);
1213 tsoots 143
        if (name.length() > 0)
144
                transaction->setName(name);
145
        if (description.length() > 0)
146
                transaction->setDescription(description);
1250 tsoots 147
        if (actionPixmap)
148
                transaction->setPixmap(actionPixmap);
1213 tsoots 149
 
150
        UndoObject *tmpu = transactionTarget;
151
        TransactionState *tmps = transaction;
1238 tsoots 152
 
153
        if (!transactions.empty())
1226 tsoots 154
        {
1238 tsoots 155
                // fetch the next transaction to be an active transaction
156
                transactionTarget = transactions[transactions.size() - 1].first;
157
                transaction = transactions[transactions.size() - 1].second;
158
//              delete transactions[transactions.size() - 1]
159
                transactions.erase(transactions.end() - 1);
160
        }
161
        else
162
        {
2604 tsoots 163
                transaction = 0;
164
                transactionTarget = 0;
1238 tsoots 165
        }
166
 
167
        if (tmps->sizet() > 0) // are there any actions inside the commited transaction
168
        {
2877 cbradney 169
                if (tmps->getName().isEmpty())
1226 tsoots 170
                        tmps->useActionName();
1213 tsoots 171
                action(tmpu, tmps);
1238 tsoots 172
        } // if not just delete objects
1226 tsoots 173
        else
174
        {
175
                delete tmpu;
2604 tsoots 176
                tmpu = 0;
1226 tsoots 177
                delete tmps;
2604 tsoots 178
                tmps = 0;
1226 tsoots 179
        }
1213 tsoots 180
}
181
 
182
bool UndoManager::isTransactionMode()
183
{
184
        return transaction ? true : false;
185
}
186
 
1111 tsoots 187
void UndoManager::registerGui(UndoGui* gui)
188
{
2604 tsoots 189
        if (gui == 0)
1111 tsoots 190
                return;
191
 
192
        setUndoEnabled(false);
193
        setState(gui);
194
        undoGuis.push_back(gui);
1431 tsoots 195
        setUndoEnabled(true);
1111 tsoots 196
}
197
 
198
void UndoManager::setState(UndoGui* gui, int uid)
199
{
200
        gui->clear();
1443 tsoots 201
 
4293 mrdocs 202
        ActionList::iterator itstart = stacks[currentDoc].second.begin() - 1;
203
        ActionList::iterator itend   = stacks[currentDoc].second.end() - 1;
204
 
205
        if ( stacks[currentDoc].second.size() == 0 )
206
                return;
207
 
1443 tsoots 208
        if (uid > -1)
1477 tsoots 209
        { // find the range from where actions are added when in obj. spec. mode
1461 tsoots 210
                ActionList::iterator it2;
1477 tsoots 211
                for (it2 = stacks[currentDoc].first - 1; it2 != stacks[currentDoc].second.begin() - 1; --it2)
1443 tsoots 212
                {
213
                        UndoState*  tmp  = (*it2).second;
214
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmp);
215
                        if (ts && ts->contains(uid))
216
                        {
1477 tsoots 217
                                itstart = it2 - 1;
1443 tsoots 218
                                break;
219
                        }
220
                }
1477 tsoots 221
                for (it2 = stacks[currentDoc].first; it2 != stacks[currentDoc].second.end(); ++it2)
222
                {
223
                        UndoState*  tmp  = (*it2).second;
224
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmp);
225
                        if (ts && ts->contains(uid))
226
                        {
227
                                itend = it2 - 1;
228
                                break;
229
                        }
230
                }
1443 tsoots 231
        }
1477 tsoots 232
 
233
        for (; itend > itstart; --itend)
1443 tsoots 234
        {
1477 tsoots 235
                ActionPair pair = *itend;
1111 tsoots 236
                UndoObject* target = pair.first;
237
                UndoState*  state  = pair.second;
1443 tsoots 238
 
239
                if (uid == -1 || target->getUId() == static_cast<uint>(uid))
240
                {
1477 tsoots 241
                        if (itend > stacks[currentDoc].first - 1)
1443 tsoots 242
                                gui->insertUndoItem(target, state);
243
                        else
244
                                gui->insertRedoItem(target, state);
245
                }
1111 tsoots 246
        }
247
}
248
 
249
void UndoManager::connectGuis()
250
{
251
        for (uint i = 0; i < undoGuis.size(); ++i)
252
        {
253
                UndoGui *gui = undoGuis[i];
254
 
255
                connect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
256
                connect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
257
                connect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
258
                gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
259
                connect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
260
                connect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
261
                connect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
1457 tsoots 262
                connect(this, SIGNAL(clearRedo()), gui, SLOT(clearRedo()));
4985 cbradney 263
                gui->setEnabled(true);
264
                gui->updateUndoActions();
1111 tsoots 265
        }
266
}
267
 
268
void UndoManager::disconnectGuis()
269
{
270
        for (uint i = 0; i < undoGuis.size(); ++i)
271
        {
272
                UndoGui *gui = undoGuis[i];
273
 
274
                disconnect(gui, SIGNAL(undo(int)), this, SLOT(doUndo(int)));
275
                disconnect(gui, SIGNAL(redo(int)), this, SLOT(doRedo(int)));
276
                disconnect(this, SIGNAL(newAction(UndoObject*, UndoState*)),
277
                   gui, SLOT(insertUndoItem(UndoObject*, UndoState*)));
278
                disconnect(this, SIGNAL(popBack()), gui, SLOT(popBack()));
279
                disconnect(this, SIGNAL(undoSignal(int)), gui, SLOT(updateUndo(int)));
280
                disconnect(this, SIGNAL(redoSignal(int)), gui, SLOT(updateRedo(int)));
1457 tsoots 281
                disconnect(this, SIGNAL(clearRedo()), gui, SLOT(clearRedo()));
4985 cbradney 282
                gui->setEnabled(false);
1111 tsoots 283
        }
284
}
285
 
286
void UndoManager::removeGui(UndoGui* gui)
287
{
288
        std::vector<UndoGui*>::iterator it;
289
        for (it = undoGuis.begin(); it != undoGuis.end(); ++it)
290
                if (*it == gui)
291
                        undoGuis.erase(it);
292
}
293
 
294
void UndoManager::switchStack(const QString& stackName)
295
{
6724 tsoots 296
        if (stackName == currentDoc)
297
                return; //already current stack
1111 tsoots 298
        currentDoc = stackName;
299
        if (!stacks.contains(currentDoc))
300
        {
301
                ActionList alist;
302
                ActionList::iterator it = alist.begin();
303
                stacks[currentDoc] = StackPair(it, alist);
304
        }
305
 
306
        for (uint i = 0; i < undoGuis.size(); ++i)
307
                setState(undoGuis[i]);
308
}
309
 
1252 tsoots 310
void UndoManager::renameStack(const QString& newName)
1111 tsoots 311
{
1190 tsoots 312
        if (currentDoc == newName)
313
                return;
1829 tsoots 314
 
1880 tsoots 315
        if (stacks[currentDoc].second.empty()) {
316
                currentDoc = newName;
317
                return;
318
        }
319
 
1829 tsoots 320
        ActionPair pair = *(stacks[currentDoc].first);
321
        StackPair tmp(stacks[currentDoc].first, stacks[currentDoc].second);
1111 tsoots 322
        stacks.erase(currentDoc);
323
        stacks[newName] = tmp;
324
        currentDoc = newName;
1829 tsoots 325
        ActionList::iterator it;
326
        for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].second.end(); ++it)
327
        {
328
                if ((*it) == pair)
329
                        break;
330
        }
331
        stacks[currentDoc].first = it;
1111 tsoots 332
}
333
 
1252 tsoots 334
void UndoManager::removeStack(const QString& stackName)
1111 tsoots 335
{
336
        if (stacks.contains(stackName))
337
        {
338
                for (uint i = 0; i < stacks[stackName].second.size(); ++i)
339
                {
340
                        delete stacks[stackName].second[i].second;
2604 tsoots 341
                        stacks[stackName].second[i].second = 0;
1111 tsoots 342
                }
343
                stacks.erase(stackName);
344
                if (currentDoc == stackName)
345
                {
346
                        for (uint i = 0; i < undoGuis.size(); ++i)
347
                                undoGuis[i]->clear();
1190 tsoots 348
                        currentDoc = "__no_name__";
1111 tsoots 349
                }
350
        }
351
}
352
 
1340 tsoots 353
void UndoManager::action(UndoObject* target, UndoState* state, QPixmap *targetPixmap)
1111 tsoots 354
{
2604 tsoots 355
        QPixmap *oldIcon = 0;
1340 tsoots 356
        if (targetPixmap)
357
        {
358
                oldIcon = target->getUPixmap();
359
                target->setUPixmap(targetPixmap);
360
        }
1485 tsoots 361
 
1228 tsoots 362
        if (!_undoEnabled) // if so flush down the state
363
        {
364
                TransactionState *ts = dynamic_cast<TransactionState*>(state);
365
                if (ts) // flush the TransactionObject too
366
                        delete target;
367
                delete state;
368
                return;
369
        }
370
 
1213 tsoots 371
        if ((!transaction) &&
372
        (currentUndoObjectId == -1 || currentUndoObjectId == static_cast<long>(target->getUId())))
1226 tsoots 373
                emit newAction(target, state); // send action to the guis
1457 tsoots 374
        else
375
                emit clearRedo();
1111 tsoots 376
 
1228 tsoots 377
        if (stacks[currentDoc].second.size() > 1 && !transaction) // delete redo states
1111 tsoots 378
        {
379
                ActionList::iterator it;
380
                for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].first; ++it)
1226 tsoots 381
                {
382
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
383
                        if (ts)
1228 tsoots 384
                        {
1226 tsoots 385
                                delete (*it).first; // delete TransactionObject
2604 tsoots 386
                                (*it).first = 0;
1228 tsoots 387
                        }
1111 tsoots 388
                        delete (*it).second;
2604 tsoots 389
                        (*it).second = 0;
1226 tsoots 390
                }
1111 tsoots 391
                stacks[currentDoc].second.erase(stacks[currentDoc].second.begin(), stacks[currentDoc].first);
392
        }
393
 
1213 tsoots 394
        if (transaction)
395
                transaction->pushBack(target, state);
396
        else
397
        {
1226 tsoots 398
                checkStackLength(); // check that history length
1213 tsoots 399
                stacks[currentDoc].second.insert(stacks[currentDoc].second.begin(), ActionPair(target, state));
400
                stacks[currentDoc].first = stacks[currentDoc].second.begin();
401
        }
1340 tsoots 402
        if (targetPixmap)
403
                target->setUPixmap(oldIcon);
1111 tsoots 404
}
1477 tsoots 405
 
1356 tsoots 406
void UndoManager::action(UndoObject* target, UndoState* state,
407
                         const QString &targetName, QPixmap *targetPixmap)
408
{
409
        QString oldName = target->getUName();
2877 cbradney 410
        if (!targetName.isEmpty())
1356 tsoots 411
                target->setUName(targetName);
412
        action(target, state, targetPixmap);
413
        target->setUName(oldName);
414
}
1111 tsoots 415
 
416
void UndoManager::undo(int steps)
417
{
2735 cbradney 418
        if (_undoEnabled)
1111 tsoots 419
                doUndo(steps);
420
}
421
 
422
void UndoManager::redo(int steps)
423
{
424
        if (_undoEnabled)
425
                doRedo(steps);
426
}
427
 
428
void UndoManager::doUndo(int steps)
429
{
1190 tsoots 430
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 431
        {
432
                setUndoEnabled(false);
2604 tsoots 433
                UndoState* tmpUndoState = 0;
1477 tsoots 434
                currentAction = stacks[currentDoc].first;
1111 tsoots 435
                for (int i = 0; i < steps; ++i)
436
                {
1477 tsoots 437
                        ActionPair &aPair = getNextUndoPair();
1111 tsoots 438
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 439
                        tmpUndoState = aPair.second;
1213 tsoots 440
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
1477 tsoots 441
 
1251 tsoots 442
                        if (tmpUndoObject && tmpUndoState && !ts)
1190 tsoots 443
                                tmpUndoObject->restore(tmpUndoState, true);
1228 tsoots 444
                        else if (tmpUndoState && ts)
1213 tsoots 445
                                doTransactionUndo(ts);
2604 tsoots 446
                        ts = 0;
1111 tsoots 447
                }
1477 tsoots 448
                reorderUndoStack(steps);
1431 tsoots 449
                setUndoEnabled(true);
1190 tsoots 450
                if (tmpUndoState)
451
                {
452
                        emit undoSignal(steps);
453
                        emit undoRedoDone();
454
                }
1111 tsoots 455
        }
456
}
457
 
1477 tsoots 458
ActionPair& UndoManager::getNextUndoPair()
459
{
460
        if (currentUndoObjectId == GLOBAL_UNDO_MODE)
461
                ++currentAction;
462
        else
463
                for (; currentAction != stacks[currentDoc].second.end(); ++currentAction)
1485 tsoots 464
                        if ((*currentAction).first->getUId() == static_cast<uint>(currentUndoObjectId))
1477 tsoots 465
                        {
466
                                ++currentAction;
467
                                break;
468
                        }
469
        return *(currentAction - 1);
470
}
471
 
472
void UndoManager::reorderUndoStack(int steps)
473
{
474
        if (currentUndoObjectId == GLOBAL_UNDO_MODE)
475
                stacks[currentDoc].first += steps;
476
        else
477
        {
478
                int pos = -1;
479
                ActionList::iterator it;
480
                for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].first + 1; ++it)
481
                {
482
                        ++pos;
483
                }
484
 
485
                // TODO Move the items around here
486
                for (int i = 0; i < steps; ++i)
487
                {
488
                        ActionList::iterator it = stacks[currentDoc].second.begin() + pos;
1485 tsoots 489
                        while ((*it).first->getUId() != static_cast<uint>(currentUndoObjectId)) ++it;
1477 tsoots 490
                        ActionPair pair = *it;
491
                        stacks[currentDoc].second.erase(it);
492
                        stacks[currentDoc].second.insert(stacks[currentDoc].second.begin() + pos, pair);
493
                        ++pos;
494
                }
495
 
496
                stacks[currentDoc].first = stacks[currentDoc].second.begin() += pos;
497
        }
498
}
499
 
1213 tsoots 500
void UndoManager::doTransactionUndo(TransactionState *tstate)
501
{
502
        for (int i = tstate->sizet() - 1; i > -1; --i)
503
        {
504
                ActionPair *pair = tstate->at(i);
1262 tsoots 505
                TransactionState *ts = dynamic_cast<TransactionState*>(pair->second);
506
                if (pair && pair->first && pair->second && !ts)
1213 tsoots 507
                        pair->first->restore(pair->second, true);
1262 tsoots 508
                else if (pair && pair->second && ts)
509
                        doTransactionUndo(ts);
1213 tsoots 510
        }
511
}
512
 
1111 tsoots 513
void UndoManager::doRedo(int steps)
514
{
1190 tsoots 515
        if (steps > 0 && _undoEnabled && stacks.size() > 0)
1111 tsoots 516
        {
517
                setUndoEnabled(false);
2604 tsoots 518
                UndoState* tmpUndoState = 0;
1477 tsoots 519
                currentAction = stacks[currentDoc].first;
1228 tsoots 520
                for (int i = 0; i < steps; ++i) // TODO compare to stack size too
1111 tsoots 521
                {
1477 tsoots 522
                        ActionPair &aPair = getNextRedoPair();
1111 tsoots 523
                        UndoObject* tmpUndoObject = aPair.first;
1190 tsoots 524
                        tmpUndoState = aPair.second;
1213 tsoots 525
                        TransactionState *ts = dynamic_cast<TransactionState*>(tmpUndoState);
1477 tsoots 526
 
1247 tsoots 527
                        if (tmpUndoObject && tmpUndoState && !ts)
1190 tsoots 528
                                tmpUndoObject->restore(tmpUndoState, false);
1228 tsoots 529
                        else if (tmpUndoState && ts)
1213 tsoots 530
                                doTransactionRedo(ts);
2604 tsoots 531
                        ts = 0;
1111 tsoots 532
                }
1228 tsoots 533
 
1477 tsoots 534
                reorderRedoStack(steps);
1431 tsoots 535
                setUndoEnabled(true);
1228 tsoots 536
 
1190 tsoots 537
                if (tmpUndoState)
538
                {
539
                        emit redoSignal(steps);
540
                        emit undoRedoDone();
541
                }
1111 tsoots 542
        }
543
}
544
 
1477 tsoots 545
ActionPair& UndoManager::getNextRedoPair()
546
{
547
        if (currentUndoObjectId == GLOBAL_UNDO_MODE)
548
                --currentAction;
549
        else
550
                for (--currentAction; currentAction != stacks[currentDoc].second.begin() - 1; --currentAction)
1485 tsoots 551
                        if ((*currentAction).first->getUId() == static_cast<uint>(currentUndoObjectId))
1477 tsoots 552
                                break;
553
 
554
        return *currentAction;
555
}
556
 
557
void UndoManager::reorderRedoStack(int steps)
558
{
559
        if (currentUndoObjectId == GLOBAL_UNDO_MODE)
560
                stacks[currentDoc].first -= steps;
561
        else
562
        {
563
                int pos = -1;
564
                ActionList::iterator it;
565
                for (it = stacks[currentDoc].second.begin(); it != stacks[currentDoc].first + 1; ++it)
566
                        ++pos;
567
                for (int i = 0; i < steps; ++i)
568
                {
569
                        ActionList::iterator it = stacks[currentDoc].second.begin() + pos - 1;
1485 tsoots 570
                        while ((*it).first->getUId() != static_cast<uint>(currentUndoObjectId)) --it;
1477 tsoots 571
                        ActionPair pair = *it;
572
                        stacks[currentDoc].second.erase(it);
573
                        --pos;
574
                        stacks[currentDoc].second.insert(stacks[currentDoc].second.begin() + pos, pair);
575
                }
576
                stacks[currentDoc].first = stacks[currentDoc].second.begin() += pos;
577
        }
578
}
579
 
1213 tsoots 580
void UndoManager::doTransactionRedo(TransactionState *tstate)
581
{
582
        for (uint i = 0; i < tstate->sizet(); ++i)
583
        {
1262 tsoots 584
                ActionPair *pair = tstate->at(i);
585
                TransactionState *ts = dynamic_cast<TransactionState*>(pair->second);
586
                if (pair && pair->first && pair->second && !ts)
587
                        pair->first->restore(pair->second, false);
588
                else if (pair && pair->second && ts)
589
                        doTransactionRedo(ts);
1213 tsoots 590
        }
591
}
592
 
3240 fschmid 593
bool UndoManager::hasUndoActions(int )
1111 tsoots 594
{
1457 tsoots 595
        // TODO Needs to fixed for object specific mode
1111 tsoots 596
        return stacks[currentDoc].first < stacks[currentDoc].second.end();
597
}
598
 
3240 fschmid 599
bool UndoManager::hasRedoActions(int )
1111 tsoots 600
{
1457 tsoots 601
        // TODO Needs to be fixed for object specific mode
1111 tsoots 602
        return stacks[currentDoc].first > stacks[currentDoc].second.begin();
603
}
604
 
605
void UndoManager::showObject(int uid)
606
{
1443 tsoots 607
        if (currentUndoObjectId == uid)
608
                return;
609
        setUndoEnabled(false);
610
        currentUndoObjectId = uid;
611
        for (uint i = 0; i < undoGuis.size(); ++i)
612
        {
613
                if (uid == -2)
614
                        undoGuis[i]->clear();
615
                else
616
                        setState(undoGuis[i], currentUndoObjectId);
617
        }
618
        setUndoEnabled(true);
1111 tsoots 619
}
620
 
1658 tsoots 621
UndoObject* UndoManager::replaceObject(ulong uid, UndoObject *newUndoObject)
1238 tsoots 622
{
2604 tsoots 623
        UndoObject *tmp = 0;
1238 tsoots 624
        for (uint i = 0; i < stacks[currentDoc].second.size(); ++i)
625
        {
626
                ActionPair &apair = stacks[currentDoc].second[i];
627
                TransactionState *ts = dynamic_cast<TransactionState*>(apair.second);
628
                if (ts)
1658 tsoots 629
                        tmp = ts->replace(uid, newUndoObject);
1258 tsoots 630
                else if (apair.first && apair.first->getUId() == uid)
1658 tsoots 631
                {
632
                        tmp = apair.first;
1238 tsoots 633
                        apair.first = newUndoObject;
1658 tsoots 634
                }
1238 tsoots 635
        }
1663 tsoots 636
        if (transaction) // replace also in the currently open transaction
1664 tsoots 637
                tmp = transaction->replace(uid, newUndoObject);
1658 tsoots 638
        return tmp;
1238 tsoots 639
}
640
 
1111 tsoots 641
void UndoManager::setHistoryLength(int steps)
642
{
1197 tsoots 643
        if (steps >= 0)
644
        {
1111 tsoots 645
                historyLength = steps;
1197 tsoots 646
                prefs->set("historyLength", historyLength);
647
                checkStackLength();
648
        }
1111 tsoots 649
}
650
 
651
int UndoManager::getHistoryLength()
652
{
1197 tsoots 653
        if (stacks.size() > 0 && stacks[currentDoc].first != stacks[currentDoc].second.begin())
654
                return -1;
1111 tsoots 655
        return historyLength;
656
}
657
 
1461 tsoots 658
bool UndoManager::isGlobalMode()
659
{
660
        return currentUndoObjectId == -1;
661
}
662
 
1197 tsoots 663
void UndoManager::checkStackLength()
664
{
665
        if ((stacks[currentDoc].second.size() >= static_cast<uint>(historyLength)) && (historyLength != 0))
666
        {
667
                while (stacks[currentDoc].second.size() >= static_cast<uint>(historyLength))
668
                {
669
                        ActionList::iterator it = stacks[currentDoc].second.end() - 1;
670
                        if (stacks[currentDoc].first == it)
671
                                stacks[currentDoc].first = it - 1;
1226 tsoots 672
                        TransactionState *ts = dynamic_cast<TransactionState*>((*it).second);
673
                        if (ts)
674
                                delete (*it).first; // delete TransactionObject
1197 tsoots 675
                        delete (*it).second;
676
                        stacks[currentDoc].second.erase(it);
677
                        emit popBack();
678
                }
679
        }
680
}
681
 
1111 tsoots 682
void UndoManager::deleteInstance()
683
{
684
        if (_instance)
685
                delete _instance;
2604 tsoots 686
        _instance = 0;
1111 tsoots 687
}
688
 
689
UndoManager::~UndoManager()
690
{
691
        StackMap::iterator it;
692
        for (it = stacks.begin(); it != stacks.end(); ++it)
693
        {
694
                for (uint i = 0; i < (*it).second.size(); ++i)
695
                {
696
                        delete ((*it).second)[i].second;
2604 tsoots 697
                        ((*it).second)[i].second = 0;
1111 tsoots 698
                }
699
        }
700
}
1190 tsoots 701
 
2199 cbradney 702
 
2198 cbradney 703
void UndoManager::languageChange()
704
{
2199 cbradney 705
        UndoManager::AddVGuide          = tr("Add vertical guide");
706
        UndoManager::AddHGuide          = tr("Add horizontal guide");
707
        UndoManager::DelVGuide          = tr("Remove vertical guide");
708
        UndoManager::DelHGuide          = tr("Remove horizontal guide");
709
        UndoManager::MoveVGuide         = tr("Move vertical guide");
710
        UndoManager::MoveHGuide         = tr("Move horizontal guide");
711
        UndoManager::LockGuides         = tr("Lock guides");
712
        UndoManager::UnlockGuides       = tr("Unlock guides");
713
        UndoManager::Move               = tr("Move");
714
        UndoManager::Resize             = tr("Resize");
715
        UndoManager::Rotate             = tr("Rotate");
716
        UndoManager::MoveFromTo         = tr("X1: %1, Y1: %2, %3\nX2: %4, Y2: %5, %6");
717
        UndoManager::ResizeFromTo       = tr("W1: %1, H1: %2\nW2: %3, H2: %4");
4821 cbradney 718
        UndoManager::ImageOffset        = tr("Change Image Offset");
719
        UndoManager::ImageScale         = tr("Change Image Scale");
720
        UndoManager::ImageOffsetFromTo  = tr("X1: %1, Y1: %2\nX2: %4, Y2: %5");
721
        UndoManager::ImageScaleFromTo   = tr("X: %1, Y: %2\nX: %4, Y: %5");
2199 cbradney 722
        UndoManager::Selection          = tr("Selection");
723
        UndoManager::Group              = tr("Group");
724
        UndoManager::SelectionGroup     = tr("Selection/Group");
725
        UndoManager::Create             = tr("Create");
726
        UndoManager::CreateTo           = tr("X: %1, Y: %2\nW: %3, H: %4");
727
        UndoManager::AlignDistribute    = tr("Align/Distribute");
728
        UndoManager::ItemsInvolved      = tr("Items involved");
729
        UndoManager::Cancel             = tr("Cancel");
730
        UndoManager::SetFill            = tr("Set fill color");
731
        UndoManager::ColorFromTo        = tr("Color1: %1, Color2: %2");
732
        UndoManager::SetShade           = tr("Set fill color shade");
733
        UndoManager::SetLineColor       = tr("Set line color");
734
        UndoManager::SetLineShade       = tr("Set line color shade");
735
        UndoManager::FlipH              = tr("Flip horizontally");
736
        UndoManager::FlipV              = tr("Flip vertically");
737
        UndoManager::Lock               = tr("Lock");
738
        UndoManager::UnLock             = tr("Unlock");
739
        UndoManager::SizeLock           = tr("Lock size");
740
        UndoManager::SizeUnLock         = tr("Unlock size");
4698 cbradney 741
        UndoManager::EnablePrint        = tr("Enable Item Printing");
742
        UndoManager::DisablePrint       = tr("Disable Item Printing");
2199 cbradney 743
        UndoManager::Ungroup            = tr("Ungroup");
744
        UndoManager::Delete             = tr("Delete");
745
        UndoManager::Rename             = tr("Rename");
746
        UndoManager::FromTo             = tr("From %1\nto %2");
747
        UndoManager::ApplyMasterPage    = tr("Apply Master Page");
748
        UndoManager::Paste              = tr("Paste");
749
        UndoManager::Cut                = tr("Cut");
750
        UndoManager::Transparency       = tr("Set fill color transparency");
751
        UndoManager::LineTransparency   = tr("Set line color transparency");
752
        UndoManager::LineStyle          = tr("Set line style");
753
        UndoManager::LineEnd            = tr("Set the style of line end");
754
        UndoManager::LineJoin           = tr("Set the style of line join");
755
        UndoManager::LineWidth          = tr("Set line width");
756
        UndoManager::NoStyle            = tr("No style");
757
        UndoManager::CustomLineStyle    = tr("Set custom line style");
758
        UndoManager::NoLineStyle        = tr("Do not use custom line style");
759
        UndoManager::StartArrow         = tr("Set start arrow");
760
        UndoManager::EndArrow           = tr("Set end arrow");
761
        UndoManager::CreateTable        = tr("Create table");
762
        UndoManager::RowsCols           = tr("Rows: %1, Cols: %2");
763
        UndoManager::SetFont            = tr("Set font");
764
        UndoManager::SetFontSize        = tr("Set font size");
765
        UndoManager::SetFontWidth       = tr("Set font width");
2230 fschmid 766
        UndoManager::SetFontHeight       = tr("Set font height");
2199 cbradney 767
        UndoManager::SetFontFill        = tr("Set font fill color");
768
        UndoManager::SetFontStroke      = tr("Set font stroke color");
769
        UndoManager::SetFontFillShade   = tr("Set font fill color shade");
770
        UndoManager::SetFontStrokeShade = tr("Set font stroke color shade");
771
        UndoManager::SetKerning         = tr("Set kerning");
772
        UndoManager::SetLineSpacing     = tr("Set line spacing");
773
        UndoManager::SetStyle           = tr("Set paragraph style");
774
        UndoManager::SetLanguage        = tr("Set language");
775
        UndoManager::AlignText          = tr("Align text");
776
        UndoManager::SetFontEffect      = tr("Set font effect");
777
        UndoManager::ImageFrame         = tr("Image frame");
778
        UndoManager::TextFrame          = tr("Text frame");
779
        UndoManager::Polygon            = tr("Polygon");
780
        UndoManager::BezierCurve        = tr("Bezier curve");
781
        UndoManager::Polyline           = tr("Polyline");
3676 cbradney 782
        UndoManager::PathText           = tr("Text on a Path");
2199 cbradney 783
        UndoManager::ConvertTo          = tr("Convert to");
784
        UndoManager::ImportSVG          = tr("Import SVG image");
785
        UndoManager::ImportEPS          = tr("Import EPS image");
2217 cbradney 786
        UndoManager::ImportOOoDraw      = tr("Import OpenOffice.org Draw image");
2199 cbradney 787
        UndoManager::ScratchSpace       = tr("Scratch space");
788
        UndoManager::TextFlow           = tr("Text flows around the frame");
789
        UndoManager::BoundingBox        = tr("Text flows around bounding box");
790
        UndoManager::ContourLine        = tr("Text flows around contour line");
791
        UndoManager::NoTextFlow         = tr("No text flow");
792
        UndoManager::NoBoundingBox      = tr("No bounding box");
793
        UndoManager::NoContourLine      = tr("No contour line");
794
        UndoManager::PageNmbr           = tr("Page %1");
795
        UndoManager::ImageScaling       = tr("Set image scaling");
796
        UndoManager::FrameSize          = tr("Frame size");
797
        UndoManager::FreeScaling        = tr("Free scaling");
798
        UndoManager::KeepRatio          = tr("Keep aspect ratio");
799
        UndoManager::BreakRatio         = tr("Break aspect ratio");
800
        UndoManager::EditContourLine    = tr("Edit contour line");
801
        UndoManager::EditShape          = tr("Edit shape");
802
        UndoManager::ResetContourLine   = tr("Reset contour line");
803
        UndoManager::AddPage            = tr("Add page");
804
        UndoManager::AddPages           = tr("Add pages");
805
        UndoManager::DeletePage         = tr("Delete page");
806
        UndoManager::DeletePages        = tr("Delete pages");
807
        UndoManager::AddLayer           = tr("Add layer");
808
        UndoManager::DeleteLayer        = tr("Delete layer");
809
        UndoManager::RenameLayer        = tr("Rename layer");
810
        UndoManager::RaiseLayer         = tr("Raise layer");
811
        UndoManager::LowerLayer         = tr("Lower layer");
812
        UndoManager::SendToLayer        = tr("Send to layer");
813
        UndoManager::PrintLayer         = tr("Enable printing of layer");
814
        UndoManager::DoNotPrintLayer    = tr("Disable printing of layer");
815
        UndoManager::SetLayerName       = tr("Change name of the layer");
816
        UndoManager::GetImage           = tr("Get image");
4739 tsoots 817
        UndoManager::MultipleDuplicate  = tr("Multiple duplicate");
6146 tsoots 818
        UndoManager::EditContour        = tr("Edit contour line");
6264 tsoots 819
        UndoManager::ResetControlPoint  = tr("Reset control point");
820
        UndoManager::ResetControlPoints = tr("Reset control points");
6267 tsoots 821
        UndoManager::ImageEffects       = tr("Modify image effects");
2198 cbradney 822
}
823
 
1213 tsoots 824
/*** UndoManager::TransactionState *****************************************************/
825
 
1226 tsoots 826
UndoManager::TransactionState::TransactionState() : UndoState("")
1213 tsoots 827
{
828
        _size = 0;
829
}
830
 
831
ActionPair* UndoManager::TransactionState::at(int index)
832
{
833
        if (index >= 0 && static_cast<uint>(index) < sizet())
834
                return states[index];
835
        else
2604 tsoots 836
                return 0;
1213 tsoots 837
}
838
 
1443 tsoots 839
bool UndoManager::TransactionState::contains(int uid)
840
{
841
        bool ret = false;
842
        for (uint i = 0; i < states.size(); ++i)
843
        {
844
                if (states[i]->first->getUId() == static_cast<uint>(uid))
845
                {
846
                        ret = true;
847
                        break;
848
                }
849
        }
850
        return ret;
851
}
852
 
1213 tsoots 853
void UndoManager::TransactionState::pushBack(UndoObject *target, UndoState *state)
854
{
855
        if (target && state)
856
        {
857
                states.push_back(new ActionPair(target, state));
858
                ++_size;
859
        }
860
}
861
 
862
uint UndoManager::TransactionState::sizet()
863
{
864
        return _size;
865
}
866
 
1226 tsoots 867
void UndoManager::TransactionState::useActionName()
868
{
869
        if (_size > 0)
870
        {
871
                setName(states[_size - 1]->second->getName());
872
        }
873
}
874
 
1658 tsoots 875
UndoObject* UndoManager::TransactionState::replace(ulong uid, UndoObject *newUndoObject)
1238 tsoots 876
{
2604 tsoots 877
        UndoObject *tmp = 0;
1238 tsoots 878
        for (uint i = 0; i < states.size(); ++i)
1658 tsoots 879
        {
1663 tsoots 880
                TransactionState *ts = dynamic_cast<TransactionState*>(states[i]->second);
881
                if (ts) // are we having a transaction inside a transaction
882
                        ts->replace(uid, newUndoObject);
883
                else if (states[i]->first && states[i]->first->getUId() == uid)
1658 tsoots 884
                {
885
                        tmp = states[i]->first;
1238 tsoots 886
                        states[i]->first = newUndoObject;
1658 tsoots 887
                }
888
        }
889
        return tmp;
1238 tsoots 890
}
891
 
1213 tsoots 892
UndoManager::TransactionState::~TransactionState()
893
{
894
        for (uint i = 0; i < states.size(); ++i)
895
        {
1226 tsoots 896
                if (states[i])
897
                {
898
                        if (states[i]->second)
899
                        {
900
                                delete states[i]->second;
2604 tsoots 901
                                states[i]->second = 0;
1226 tsoots 902
                        }
903
                        delete states[i];
2604 tsoots 904
                        states[i] = 0;
1226 tsoots 905
                }
1213 tsoots 906
        }
907
}
908
 
909
/*************************************************************************************/
910
 
1190 tsoots 911
void UndoManager::initIcons()
912
{
1693 craig 913
        QString iconDir = ScPaths::instance().iconDir();
1247 tsoots 914
 
1250 tsoots 915
/*** Icons for UndoObjects *******************************************/
916
        UndoManager::IImageFrame      = new QPixmap(iconDir + "Bild.xpm");
917
        UndoManager::ITextFrame       = new QPixmap(iconDir + "Text.xpm");
918
        UndoManager::ILine            = new QPixmap(iconDir + "Stift.xpm");
919
        UndoManager::IPolygon         = new QPixmap(iconDir + "spline.png");
920
        UndoManager::IPolyline        = new QPixmap(iconDir + "beziertool.png");
921
//      UndoManager::IPathText        = new QPixmap(iconDir + "?";
1254 tsoots 922
        UndoManager::IGroup           = new QPixmap(iconDir + "u_group.png");
1250 tsoots 923
/*** Icons for actions ***********************************************/
924
        UndoManager::IMove            = new QPixmap(iconDir + "u_move.png");
925
        UndoManager::IResize          = new QPixmap(iconDir + "u_resize.png");
926
        UndoManager::IRotate          = new QPixmap(iconDir + "u_rotate.png");
1247 tsoots 927
        UndoManager::IAlignDistribute = new QPixmap(iconDir + "u_align.png");
1250 tsoots 928
        UndoManager::IGuides          = new QPixmap(iconDir + "u_margins.png");
929
        UndoManager::ILockGuides      = new QPixmap(iconDir + "u_margins_locked.png");
1286 tsoots 930
        UndoManager::IFill            = new QPixmap(iconDir + "u_fill.png");
931
        UndoManager::IShade           = new QPixmap(iconDir + "u_shade.png");
1340 tsoots 932
        UndoManager::IFlipH           = new QPixmap(iconDir + "u_fliph.png");
933
        UndoManager::IFlipV           = new QPixmap(iconDir + "u_flipv.png");
1290 tsoots 934
        UndoManager::ILock            = new QPixmap(iconDir + "u_lock.png");
935
        UndoManager::IUnLock          = new QPixmap(iconDir + "u_unlock.png");
4698 cbradney 936
        UndoManager::IEnablePrint     = new QPixmap(iconDir + "u_enableprint.png");
937
        UndoManager::IDisablePrint    = new QPixmap(iconDir + "u_disableprint.png");
1340 tsoots 938
        UndoManager::IDelete          = new QPixmap(iconDir + "u_delete.png");
939
        UndoManager::ICreate          = new QPixmap(iconDir + "u_create.png");
1369 tsoots 940
        UndoManager::IPaste           = new QPixmap(iconDir + "editpaste.png");
941
        UndoManager::ICut             = new QPixmap(iconDir + "u_cut.png");
1371 tsoots 942
        UndoManager::ITransparency    = new QPixmap(iconDir + "u_transp.png");
1383 tsoots 943
        UndoManager::ILineStyle       = new QPixmap(iconDir + "u_line.png");
1391 tsoots 944
        UndoManager::IArrow           = new QPixmap(iconDir + "u_arrow.png");
1396 tsoots 945
        UndoManager::ITable           = new QPixmap(iconDir + "frame_table.png");
1399 tsoots 946
        UndoManager::IFont            = new QPixmap(iconDir + "u_font.png");
1440 tsoots 947
        UndoManager::IImportOOoDraw   = new QPixmap(iconDir + "ooo_draw.png");
948
        UndoManager::ISVG             = new QPixmap(iconDir + "u_svg.png");
949
        UndoManager::IEPS             = new QPixmap(iconDir + "u_eps.png");
1495 tsoots 950
        UndoManager::IImageScaling    = new QPixmap(iconDir + "u_scale_image.png");
1509 tsoots 951
        UndoManager::IBorder          = new QPixmap(iconDir + "u_shape.png");
1664 tsoots 952
        UndoManager::IDocument        = new QPixmap(iconDir + "DateiNeu.xpm");
1688 tsoots 953
//      UndoManager::ILayer           = new QPixmap(iconDir + "u_layer.png");
954
//      UndoManager::ILayerAction     = new QPixmap(iconDir + "u_layer_action.png");
1697 tsoots 955
//      UndoManager::IUp              = new QPixmap(iconDir + "u_up.png");
956
//      UndoManager::IDown            = new QPixmap(iconDir + "u_down.png");
1832 tsoots 957
//      UndoManager::IGetImage        = new QPixmap(iconDir + "u_get_image.png");
4739 tsoots 958
        UndoManager::IMultipleDuplicate = new QPixmap(iconDir + "u_multiple.png");
1190 tsoots 959
}
2199 cbradney 960
QString UndoManager::AddVGuide          = "";
961
QString UndoManager::AddHGuide          = "";
962
QString UndoManager::DelVGuide          = "";
963
QString UndoManager::DelHGuide          = "";
964
QString UndoManager::MoveVGuide         = "";
965
QString UndoManager::MoveHGuide         = "";
966
QString UndoManager::LockGuides         = "";
967
QString UndoManager::UnlockGuides       = "";
968
QString UndoManager::Move               = "";
969
QString UndoManager::Resize             = "";
970
QString UndoManager::Rotate             = "";
971
QString UndoManager::MoveFromTo         = "";
4821 cbradney 972
QString UndoManager::ImageOffset        = "";
973
QString UndoManager::ImageScale         = "";
974
QString UndoManager::ImageOffsetFromTo  = "";
975
QString UndoManager::ImageScaleFromTo   = "";
2199 cbradney 976
QString UndoManager::ResizeFromTo       = "";
977
QString UndoManager::Selection          = "";
978
QString UndoManager::Group              = "";
979
QString UndoManager::SelectionGroup     = "";
980
QString UndoManager::Create             = "";
981
QString UndoManager::CreateTo           = "";
982
QString UndoManager::AlignDistribute    = "";
983
QString UndoManager::ItemsInvolved      = "";
984
QString UndoManager::Cancel             = "";
985
QString UndoManager::SetFill            = "";
986
QString UndoManager::ColorFromTo        = "";
987
QString UndoManager::SetShade           = "";
988
QString UndoManager::SetLineColor       = "";
989
QString UndoManager::SetLineShade       = "";
990
QString UndoManager::FlipH              = "";
991
QString UndoManager::FlipV              = "";
992
QString UndoManager::Lock               = "";
993
QString UndoManager::UnLock             = "";
994
QString UndoManager::SizeLock           = "";
995
QString UndoManager::SizeUnLock         = "";
4698 cbradney 996
QString UndoManager::EnablePrint        = "";
997
QString UndoManager::DisablePrint       = "";
2199 cbradney 998
QString UndoManager::Ungroup            = "";
999
QString UndoManager::Delete             = "";
1000
QString UndoManager::Rename             = "";
1001
QString UndoManager::FromTo             = "";
1002
QString UndoManager::ApplyMasterPage    = "";
1003
QString UndoManager::Paste              = "";
1004
QString UndoManager::Cut                = "";
1005
QString UndoManager::Transparency       = "";
1006
QString UndoManager::LineTransparency   = "";
1007
QString UndoManager::LineStyle          = "";
1008
QString UndoManager::LineEnd            = "";
1009
QString UndoManager::LineJoin           = "";
1010
QString UndoManager::LineWidth          = "";
1011
QString UndoManager::NoStyle            = "";
1012
QString UndoManager::CustomLineStyle    = "";
1013
QString UndoManager::NoLineStyle        = "";
1014
QString UndoManager::StartArrow         = "";
1015
QString UndoManager::EndArrow           = "";
1016
QString UndoManager::CreateTable        = "";
1017
QString UndoManager::RowsCols           = "";
1018
QString UndoManager::SetFont            = "";
1019
QString UndoManager::SetFontSize        = "";
1020
QString UndoManager::SetFontWidth       = "";
3676 cbradney 1021
QString UndoManager::SetFontHeight      = "";
2199 cbradney 1022
QString UndoManager::SetFontFill        = "";
1023
QString UndoManager::SetFontStroke      = "";
1024
QString UndoManager::SetFontFillShade   = "";
1025
QString UndoManager::SetFontStrokeShade = "";
1026
QString UndoManager::SetKerning         = "";
1027
QString UndoManager::SetLineSpacing     = "";
1028
QString UndoManager::SetStyle           = "";
1029
QString UndoManager::SetLanguage        = "";
1030
QString UndoManager::AlignText          = "";
1031
QString UndoManager::SetFontEffect      = "";
1032
QString UndoManager::ImageFrame         = "";
1033
QString UndoManager::TextFrame          = "";
1034
QString UndoManager::Polygon            = "";
1035
QString UndoManager::BezierCurve        = "";
1036
QString UndoManager::Polyline           = "";
3676 cbradney 1037
QString UndoManager::PathText           = "";
2199 cbradney 1038
QString UndoManager::ConvertTo          = "";
1039
QString UndoManager::ImportSVG          = "";
1040
QString UndoManager::ImportEPS          = "";
1041
QString UndoManager::ImportOOoDraw      = "";
1042
QString UndoManager::ScratchSpace       = "";
1043
QString UndoManager::TextFlow           = "";
1044
QString UndoManager::BoundingBox        = "";
1045
QString UndoManager::ContourLine        = "";
1046
QString UndoManager::NoTextFlow         = "";
1047
QString UndoManager::NoBoundingBox      = "";
1048
QString UndoManager::NoContourLine      = "";
1049
QString UndoManager::PageNmbr           = "";
1050
QString UndoManager::ImageScaling       = "";
1051
QString UndoManager::FrameSize          = "";
1052
QString UndoManager::FreeScaling        = "";
1053
QString UndoManager::KeepRatio          = "";
1054
QString UndoManager::BreakRatio         = "";
1055
QString UndoManager::EditContourLine    = "";
1056
QString UndoManager::EditShape          = "";
1057
QString UndoManager::ResetContourLine   = "";
1058
QString UndoManager::AddPage            = "";
1059
QString UndoManager::AddPages           = "";
1060
QString UndoManager::DeletePage         = "";
1061
QString UndoManager::DeletePages        = "";
1062
QString UndoManager::AddLayer           = "";
1063
QString UndoManager::DeleteLayer        = "";
1064
QString UndoManager::RenameLayer        = "";
1065
QString UndoManager::RaiseLayer         = "";
1066
QString UndoManager::LowerLayer         = "";
1067
QString UndoManager::SendToLayer        = "";
1068
QString UndoManager::PrintLayer         = "";
1069
QString UndoManager::DoNotPrintLayer    = "";
1070
QString UndoManager::SetLayerName       = "";
1071
QString UndoManager::GetImage           = "";
4739 tsoots 1072
QString UndoManager::MultipleDuplicate  = "";
6146 tsoots 1073
QString UndoManager::EditContour        = "";
6264 tsoots 1074
QString UndoManager::ResetControlPoint  = "";
1075
QString UndoManager::ResetControlPoints = "";
6267 tsoots 1076
QString UndoManager::ImageEffects       = "";
6264 tsoots 1077
 
1250 tsoots 1078
/*** Icons for UndoObjects *******************************************/
2604 tsoots 1079
QPixmap *UndoManager::IImageFrame      = 0;
1080
QPixmap *UndoManager::ITextFrame       = 0;
1081
QPixmap *UndoManager::ILine            = 0;
1082
QPixmap *UndoManager::IPolygon         = 0;
1083
QPixmap *UndoManager::IPolyline        = 0;
1084
QPixmap *UndoManager::IPathText        = 0;
1085
QPixmap *UndoManager::IGroup           = 0;
1086
QPixmap *UndoManager::ITable           = 0;
1250 tsoots 1087
/*** Icons for actions ***********************************************/
2604 tsoots 1088
QPixmap *UndoManager::IMove            = 0;
1089
QPixmap *UndoManager::IResize          = 0;
1090
QPixmap *UndoManager::IRotate          = 0;
1091
QPixmap *UndoManager::IGuides          = 0;
1092
QPixmap *UndoManager::ILockGuides      = 0;
1093
QPixmap *UndoManager::IAlignDistribute = 0;
1094
QPixmap *UndoManager::IFill            = 0;
1095
QPixmap *UndoManager::IShade           = 0;
1096
QPixmap *UndoManager::IFlipH           = 0;
1097
QPixmap *UndoManager::IFlipV           = 0;
1098
QPixmap *UndoManager::ILock            = 0;
1099
QPixmap *UndoManager::IUnLock          = 0;
4698 cbradney 1100
QPixmap *UndoManager::IEnablePrint     = 0;
1101
QPixmap *UndoManager::IDisablePrint    = 0;
2604 tsoots 1102
QPixmap *UndoManager::IDelete          = 0;
1103
QPixmap *UndoManager::ICreate          = 0;
1104
QPixmap *UndoManager::IPaste           = 0;
1105
QPixmap *UndoManager::ICut             = 0;
1106
QPixmap *UndoManager::ITransparency    = 0;
1107
QPixmap *UndoManager::ILineStyle       = 0;
1108
QPixmap *UndoManager::IArrow           = 0;
1109
QPixmap *UndoManager::IFont            = 0;
1110
QPixmap *UndoManager::ISVG             = 0;
1111
QPixmap *UndoManager::IEPS             = 0;
1112
QPixmap *UndoManager::IImportOOoDraw   = 0;
1113
QPixmap *UndoManager::IImageScaling    = 0;
1114
QPixmap *UndoManager::IBorder          = 0;
1115
QPixmap *UndoManager::IDocument        = 0;
1116
QPixmap *UndoManager::ILayer           = 0;
1117
QPixmap *UndoManager::ILayerAction     = 0;
1118
QPixmap *UndoManager::IUp              = 0;
1119
QPixmap *UndoManager::IDown            = 0;
1120
QPixmap *UndoManager::IPrint           = 0;
1121
QPixmap *UndoManager::IGetImage        = 0;
4739 tsoots 1122
QPixmap *UndoManager::IMultipleDuplicate = 0;
1658 tsoots 1123