← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to krita/image/tiles3/kis_memento_manager.cc

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-09-21 15:36:35 UTC
  • mfrom: (1.4.1 upstream) (60.2.11 maverick)
  • Revision ID: james.westby@ubuntu.com-20100921153635-6tejqkiro2u21ydi
Tags: 1:2.2.2-0ubuntu3
Add kubuntu_03_fix-crash-on-closing-sqlite-connection-2.2.2.diff and
kubuntu_04_support-large-memo-values-for-msaccess-2.2.2.diff as
recommended by upstream http://kexi-
project.org/wiki/wikiview/index.php@Kexi2.2_Patches.html#sqlite_stab
ility

Show diffs side-by-side

added added

removed removed

Lines of Context:
krita/image/tiles3/kis_memento_manager.cc
48
48
 
49
49
 
50
50
KisMementoManager::KisMementoManager()
51
 
        : m_headsHashTable(0),
52
 
        m_currentMemento(0)
 
51
        : m_headsHashTable(0)
53
52
{
 
53
    /**
 
54
     * Get an initial memento to show we want history for ALL the devices.
 
55
     * If we don't do it, we won't be able to start history later,
 
56
     * as we don't have any special api for this.
 
57
     * It shouldn't create much overhead for unversioned devices as
 
58
     * no tile-duplication accurs without calling a commit()
 
59
     * method regularily.
 
60
     */
 
61
    (void) getMemento();
54
62
}
55
63
 
56
64
KisMementoManager::KisMementoManager(const KisMementoManager& rhs)
58
66
        m_revisions(rhs.m_revisions),
59
67
        m_cancelledRevisions(rhs.m_cancelledRevisions),
60
68
        m_headsHashTable(rhs.m_headsHashTable, 0),
61
 
        m_currentMemento(0)
 
69
        m_currentMemento(rhs.m_currentMemento)
62
70
{
 
71
    Q_ASSERT_X(m_currentMemento,
 
72
               "KisMementoManager", "(impossible happened) "
 
73
               "Seems like a device was created without history support");
63
74
}
64
75
 
65
76
KisMementoManager::~KisMementoManager()
101
112
}
102
113
void KisMementoManager::commit()
103
114
{
104
 
    if (!m_index.size()) return;
 
115
    if (m_index.isEmpty()) return;
105
116
 
106
117
    KisMementoItemSP mi;
 
118
    KisMementoItemSP parentMI;
107
119
    bool newTile;
108
120
    foreach(mi, m_index) {
109
 
        mi->setParent(m_headsHashTable.getTileLazy(mi->col(), mi->row(), newTile));
 
121
        parentMI = m_headsHashTable.getTileLazy(mi->col(), mi->row(), newTile);
 
122
        if(newTile)
 
123
            parentMI->commit();
 
124
 
 
125
        mi->setParent(parentMI);
110
126
        mi->commit();
111
 
 
112
127
        m_headsHashTable.deleteTile(mi->col(), mi->row());
113
128
        m_headsHashTable.addTile(mi);
114
129
    }
115
 
    m_revisions.append(m_index);
 
130
    KisHistoryItem hItem;
 
131
    hItem.itemList = m_index;
 
132
    hItem.memento = m_currentMemento.data();
 
133
    
 
134
    m_revisions.append(hItem);
116
135
    m_index.clear();
117
136
 
118
 
    // Waking up pooler to make copies for us
 
137
    // Waking up pooler to prepare copies for us
119
138
    globalTileDataStore.kickPooler();
120
139
}
121
140
 
127
146
     * but data manager  will make all work on  getting current tile for
128
147
     * us
129
148
     */
 
149
    if(!m_currentMemento || !m_currentMemento->valid())
 
150
        return 0;
 
151
 
130
152
    KisMementoItemSP mi = m_headsHashTable.getExistedTile(col, row);
131
153
    return mi ? mi->tile(0) : 0;
132
154
}
141
163
    return m_currentMemento;
142
164
}
143
165
 
 
166
#define forEachReversed(iter, list) \
 
167
        for(iter=list.end(); iter-- != list.begin();)
 
168
 
144
169
#define saveAndClearMemento(memento) KisMementoSP _mem = (memento); memento=0
145
170
#define restoreMemento(memento) (memento) = _mem
146
171
 
150
175
 
151
176
    if (! m_revisions.size()) return;
152
177
 
153
 
    KisMementoItemList changeList = m_revisions.takeLast();
 
178
    KisHistoryItem changeList = m_revisions.takeLast();
154
179
 
155
180
    KisMementoItemSP mi;
156
181
    KisMementoItemSP parentMI;
 
182
    KisMementoItemList::iterator iter;
157
183
 
158
184
    saveAndClearMemento(m_currentMemento);
159
 
    foreach(mi, changeList) {
 
185
    forEachReversed(iter, changeList.itemList) {
 
186
        mi=*iter;
160
187
        parentMI = mi->parent();
161
188
 
162
189
        if (mi->type() == KisMementoItem::CHANGED)
195
222
 
196
223
    if (! m_cancelledRevisions.size()) return;
197
224
 
198
 
    KisMementoItemList changeList = m_cancelledRevisions.takeFirst();
 
225
    KisHistoryItem changeList = m_cancelledRevisions.takeFirst();
199
226
 
200
227
    KisMementoItemSP mi;
201
228
 
202
229
    saveAndClearMemento(m_currentMemento);
203
 
    foreach(mi, changeList) {
 
230
    foreach(mi, changeList.itemList) {
204
231
        if (mi->parent()->type() == KisMementoItem::CHANGED)
205
232
            ht->deleteTile(mi->col(), mi->row());
206
233
        if (mi->type() == KisMementoItem::CHANGED)
219
246
     * m_currentMemento. All dead tiles are going to /dev/null :)
220
247
     */
221
248
    //m_index.clear();
222
 
    restoreMemento(m_currentMemento);
223
249
 
224
 
    m_index = changeList;
 
250
    m_index = changeList.itemList;
 
251
    m_currentMemento = changeList.memento;
225
252
    commit();
 
253
    restoreMemento(m_currentMemento);
226
254
    DEBUG_DUMP_MESSAGE("REDONE");
227
255
}
228
256
 
236
264
{
237
265
    printf("KisMementoManager stats:\n");
238
266
    printf("Index list\n");
239
 
    KisMementoItemList changeList;
 
267
    KisHistoryItem changeList;
240
268
    KisMementoItemSP mi;
241
269
    foreach(mi, m_index) {
242
270
        mi->debugPrintInfo();
246
274
    qint32 i = 0;
247
275
    foreach(changeList, m_revisions) {
248
276
        printf("--- revision #%d ---\n", i++);
249
 
        foreach(mi, changeList) {
 
277
        foreach(mi, changeList.itemList) {
250
278
            mi->debugPrintInfo();
251
279
        }
252
280
    }
255
283
    i = 0;
256
284
    foreach(changeList, m_cancelledRevisions) {
257
285
        printf("--- revision #%d ---\n", m_revisions.size() + i++);
258
 
        foreach(mi, changeList) {
 
286
        foreach(mi, changeList.itemList) {
259
287
            mi->debugPrintInfo();
260
288
        }
261
289
    }
264
292
    m_headsHashTable.debugPrintInfo();
265
293
}
266
294
 
267
 
 
 
295
void KisMementoManager::removeMemento(KisMemento* memento)
 
296
{
 
297
    if (memento == m_currentMemento) { // This happen when a memento is not put on the stack
 
298
        commit();
 
299
    }
 
300
    int lastIndex = -1;
 
301
    for (int i = 0; i < m_revisions.size(); ++i) {
 
302
        if (m_revisions[i].memento == memento) {
 
303
          lastIndex = i + 1;
 
304
          break;
 
305
        }
 
306
    }
 
307
    Q_ASSERT(lastIndex <= 2);
 
308
    for (int i = 0; i < lastIndex; ++i) {
 
309
        foreach(KisMementoItemSP item, m_revisions[0].itemList)
 
310
        {
 
311
            item->setParent(0);
 
312
        }
 
313
        m_revisions.takeAt(0);
 
314
    }
 
315
}