src/undo/katemodifiedundo.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2011 Dominik Haumann <dhaumann@kde.org>
0003
0004     SPDX-License-Identifier: LGPL-2.0-or-later
0005 */
0006
0007 #include "katemodifiedundo.h"
0008
0009 #include "katedocument.h"
0010 #include "kateundomanager.h"
0011
0012 #include <ktexteditor/cursor.h>
0013 #include <ktexteditor/view.h>
0014
0015 KateModifiedInsertText::KateModifiedInsertText(KTextEditor::DocumentPrivate *document, int line, int col, const QString &text)
0016     : KateEditInsertTextUndo(document, line, col, text)
0017 {
0018     setFlag(RedoLine1Modified);
0019     Kate::TextLine tl = document->plainKateTextLine(line);
0020     Q_ASSERT(tl);
0021     if (tl->markedAsModified()) {
0022         setFlag(UndoLine1Modified);
0023     } else {
0024         setFlag(UndoLine1Saved);
0025     }
0026 }
0027
0028 KateModifiedRemoveText::KateModifiedRemoveText(KTextEditor::DocumentPrivate *document, int line, int col, const QString &text)
0029     : KateEditRemoveTextUndo(document, line, col, text)
0030 {
0031     setFlag(RedoLine1Modified);
0032     Kate::TextLine tl = document->plainKateTextLine(line);
0033     Q_ASSERT(tl);
0034     if (tl->markedAsModified()) {
0035         setFlag(UndoLine1Modified);
0036     } else {
0037         setFlag(UndoLine1Saved);
0038     }
0039 }
0040
0041 KateModifiedWrapLine::KateModifiedWrapLine(KTextEditor::DocumentPrivate *document, int line, int col, int len, bool newLine)
0042     : KateEditWrapLineUndo(document, line, col, len, newLine)
0043 {
0044     Kate::TextLine tl = document->plainKateTextLine(line);
0045     Q_ASSERT(tl);
0046     if (len > 0 || tl->markedAsModified()) {
0047         setFlag(RedoLine1Modified);
0048     } else if (tl->markedAsSavedOnDisk()) {
0049         setFlag(RedoLine1Saved);
0050     }
0051
0052     if (col > 0 || len == 0 || tl->markedAsModified()) {
0053         setFlag(RedoLine2Modified);
0054     } else if (tl->markedAsSavedOnDisk()) {
0055         setFlag(RedoLine2Saved);
0056     }
0057
0058     if (tl->markedAsModified()) {
0059         setFlag(UndoLine1Modified);
0060     } else if ((len > 0 && col > 0) || tl->markedAsSavedOnDisk()) {
0061         setFlag(UndoLine1Saved);
0062     }
0063 }
0064
0065 KateModifiedUnWrapLine::KateModifiedUnWrapLine(KTextEditor::DocumentPrivate *document, int line, int col, int len, bool removeLine)
0066     : KateEditUnWrapLineUndo(document, line, col, len, removeLine)
0067 {
0068     Kate::TextLine tl = document->plainKateTextLine(line);
0069     Kate::TextLine nextLine = document->plainKateTextLine(line + 1);
0070     Q_ASSERT(tl);
0071     Q_ASSERT(nextLine);
0072
0073     const int len1 = tl->length();
0074     const int len2 = nextLine->length();
0075
0076     if (len1 > 0 && len2 > 0) {
0077         setFlag(RedoLine1Modified);
0078
0079         if (tl->markedAsModified()) {
0080             setFlag(UndoLine1Modified);
0081         } else {
0082             setFlag(UndoLine1Saved);
0083         }
0084
0085         if (nextLine->markedAsModified()) {
0086             setFlag(UndoLine2Modified);
0087         } else {
0088             setFlag(UndoLine2Saved);
0089         }
0090     } else if (len1 == 0) {
0091         if (nextLine->markedAsModified()) {
0092             setFlag(RedoLine1Modified);
0093         } else if (nextLine->markedAsSavedOnDisk()) {
0094             setFlag(RedoLine1Saved);
0095         }
0096
0097         if (tl->markedAsModified()) {
0098             setFlag(UndoLine1Modified);
0099         } else {
0100             setFlag(UndoLine1Saved);
0101         }
0102
0103         if (nextLine->markedAsModified()) {
0104             setFlag(UndoLine2Modified);
0105         } else if (nextLine->markedAsSavedOnDisk()) {
0106             setFlag(UndoLine2Saved);
0107         }
0108     } else { // len2 == 0
0109         if (nextLine->markedAsModified()) {
0110             setFlag(RedoLine1Modified);
0111         } else if (nextLine->markedAsSavedOnDisk()) {
0112             setFlag(RedoLine1Saved);
0113         }
0114
0115         if (tl->markedAsModified()) {
0116             setFlag(UndoLine1Modified);
0117         } else if (tl->markedAsSavedOnDisk()) {
0118             setFlag(UndoLine1Saved);
0119         }
0120
0121         if (nextLine->markedAsModified()) {
0122             setFlag(UndoLine2Modified);
0123         } else {
0124             setFlag(UndoLine2Saved);
0125         }
0126     }
0127 }
0128
0129 KateModifiedInsertLine::KateModifiedInsertLine(KTextEditor::DocumentPrivate *document, int line, const QString &text)
0130     : KateEditInsertLineUndo(document, line, text)
0131 {
0132     setFlag(RedoLine1Modified);
0133 }
0134
0135 KateModifiedRemoveLine::KateModifiedRemoveLine(KTextEditor::DocumentPrivate *document, int line, const QString &text)
0136     : KateEditRemoveLineUndo(document, line, text)
0137 {
0138     Kate::TextLine tl = document->plainKateTextLine(line);
0139     Q_ASSERT(tl);
0140     if (tl->markedAsModified()) {
0141         setFlag(UndoLine1Modified);
0142     } else {
0143         setFlag(UndoLine1Saved);
0144     }
0145 }
0146
0147 void KateModifiedInsertText::undo()
0148 {
0149     KateEditInsertTextUndo::undo();
0150
0151     KTextEditor::DocumentPrivate *doc = document();
0152     Kate::TextLine tl = doc->plainKateTextLine(line());
0153     Q_ASSERT(tl);
0154
0155     tl->markAsModified(isFlagSet(UndoLine1Modified));
0156     tl->markAsSavedOnDisk(isFlagSet(UndoLine1Saved));
0157 }
0158
0159 void KateModifiedRemoveText::undo()
0160 {
0161     KateEditRemoveTextUndo::undo();
0162
0163     KTextEditor::DocumentPrivate *doc = document();
0164     Kate::TextLine tl = doc->plainKateTextLine(line());
0165     Q_ASSERT(tl);
0166
0167     tl->markAsModified(isFlagSet(UndoLine1Modified));
0168     tl->markAsSavedOnDisk(isFlagSet(UndoLine1Saved));
0169 }
0170
0171 void KateModifiedWrapLine::undo()
0172 {
0173     KateEditWrapLineUndo::undo();
0174
0175     KTextEditor::DocumentPrivate *doc = document();
0176     Kate::TextLine tl = doc->plainKateTextLine(line());
0177     Q_ASSERT(tl);
0178
0179     tl->markAsModified(isFlagSet(UndoLine1Modified));
0180     tl->markAsSavedOnDisk(isFlagSet(UndoLine1Saved));
0181 }
0182
0183 void KateModifiedUnWrapLine::undo()
0184 {
0185     KateEditUnWrapLineUndo::undo();
0186
0187     KTextEditor::DocumentPrivate *doc = document();
0188     Kate::TextLine tl = doc->plainKateTextLine(line());
0189     Q_ASSERT(tl);
0190
0191     tl->markAsModified(isFlagSet(UndoLine1Modified));
0192     tl->markAsSavedOnDisk(isFlagSet(UndoLine1Saved));
0193
0194     Kate::TextLine nextLine = doc->plainKateTextLine(line() + 1);
0195     Q_ASSERT(nextLine);
0196     nextLine->markAsModified(isFlagSet(UndoLine2Modified));
0197     nextLine->markAsSavedOnDisk(isFlagSet(UndoLine2Saved));
0198 }
0199
0200 void KateModifiedInsertLine::undo()
0201 {
0202     KateEditInsertLineUndo::undo();
0203
0204     // no line modification needed, since the line is removed
0205 }
0206
0207 void KateModifiedRemoveLine::undo()
0208 {
0209     KateEditRemoveLineUndo::undo();
0210
0211     KTextEditor::DocumentPrivate *doc = document();
0212     Kate::TextLine tl = doc->plainKateTextLine(line());
0213     Q_ASSERT(tl);
0214
0215     tl->markAsModified(isFlagSet(UndoLine1Modified));
0216     tl->markAsSavedOnDisk(isFlagSet(UndoLine1Saved));
0217 }
0218
0219 void KateModifiedRemoveText::redo()
0220 {
0221     KateEditRemoveTextUndo::redo();
0222
0223     KTextEditor::DocumentPrivate *doc = document();
0224     Kate::TextLine tl = doc->plainKateTextLine(line());
0225     Q_ASSERT(tl);
0226
0227     tl->markAsModified(isFlagSet(RedoLine1Modified));
0228     tl->markAsSavedOnDisk(isFlagSet(RedoLine1Saved));
0229 }
0230
0231 void KateModifiedInsertText::redo()
0232 {
0233     KateEditInsertTextUndo::redo();
0234
0235     KTextEditor::DocumentPrivate *doc = document();
0236     Kate::TextLine tl = doc->plainKateTextLine(line());
0237     Q_ASSERT(tl);
0238
0239     tl->markAsModified(isFlagSet(RedoLine1Modified));
0240     tl->markAsSavedOnDisk(isFlagSet(RedoLine1Saved));
0241 }
0242
0243 void KateModifiedUnWrapLine::redo()
0244 {
0245     KateEditUnWrapLineUndo::redo();
0246
0247     KTextEditor::DocumentPrivate *doc = document();
0248     Kate::TextLine tl = doc->plainKateTextLine(line());
0249     Q_ASSERT(tl);
0250
0251     tl->markAsModified(isFlagSet(RedoLine1Modified));
0252     tl->markAsSavedOnDisk(isFlagSet(RedoLine1Saved));
0253 }
0254
0255 void KateModifiedWrapLine::redo()
0256 {
0257     KateEditWrapLineUndo::redo();
0258
0259     KTextEditor::DocumentPrivate *doc = document();
0260     Kate::TextLine tl = doc->plainKateTextLine(line());
0261     Q_ASSERT(tl);
0262
0263     tl->markAsModified(isFlagSet(RedoLine1Modified));
0264     tl->markAsSavedOnDisk(isFlagSet(RedoLine1Saved));
0265
0266     Kate::TextLine nextLine = doc->plainKateTextLine(line() + 1);
0267     Q_ASSERT(nextLine);
0268
0269     nextLine->markAsModified(isFlagSet(RedoLine2Modified));
0270     nextLine->markAsSavedOnDisk(isFlagSet(RedoLine2Saved));
0271 }
0272
0273 void KateModifiedRemoveLine::redo()
0274 {
0275     KateEditRemoveLineUndo::redo();
0276
0277     // no line modification needed, since the line is removed
0278 }
0279
0280 void KateModifiedInsertLine::redo()
0281 {
0282     KateEditInsertLineUndo::redo();
0283
0284     KTextEditor::DocumentPrivate *doc = document();
0285     Kate::TextLine tl = doc->plainKateTextLine(line());
0286     Q_ASSERT(tl);
0287
0288     tl->markAsModified(isFlagSet(RedoLine1Modified));
0289     tl->markAsSavedOnDisk(isFlagSet(RedoLine1Saved));
0290 }
0291
0292 void KateModifiedInsertText::updateRedoSavedOnDiskFlag(QBitArray &lines)
0293 {
0294     if (line() >= lines.size()) {
0295         lines.resize(line() + 1);
0296     }
0297
0298     if (!lines.testBit(line())) {
0299         lines.setBit(line());
0300
0301         unsetFlag(RedoLine1Modified);
0302         setFlag(RedoLine1Saved);
0303     }
0304 }
0305
0306 void KateModifiedInsertText::updateUndoSavedOnDiskFlag(QBitArray &lines)
0307 {
0308     if (line() >= lines.size()) {
0309         lines.resize(line() + 1);
0310     }
0311
0312     if (!lines.testBit(line())) {
0313         lines.setBit(line());
0314
0315         unsetFlag(UndoLine1Modified);
0316         setFlag(UndoLine1Saved);
0317     }
0318 }
0319
0320 void KateModifiedRemoveText::updateRedoSavedOnDiskFlag(QBitArray &lines)
0321 {
0322     if (line() >= lines.size()) {
0323         lines.resize(line() + 1);
0324     }
0325
0326     if (!lines.testBit(line())) {
0327         lines.setBit(line());
0328
0329         unsetFlag(RedoLine1Modified);
0330         setFlag(RedoLine1Saved);
0331     }
0332 }
0333
0334 void KateModifiedRemoveText::updateUndoSavedOnDiskFlag(QBitArray &lines)
0335 {
0336     if (line() >= lines.size()) {
0337         lines.resize(line() + 1);
0338     }
0339
0340     if (!lines.testBit(line())) {
0341         lines.setBit(line());
0342
0343         unsetFlag(UndoLine1Modified);
0344         setFlag(UndoLine1Saved);
0345     }
0346 }
0347
0348 void KateModifiedWrapLine::updateRedoSavedOnDiskFlag(QBitArray &lines)
0349 {
0350     if (line() + 1 >= lines.size()) {
0351         lines.resize(line() + 2);
0352     }
0353
0354     if (isFlagSet(RedoLine1Modified) && !lines.testBit(line())) {
0355         lines.setBit(line());
0356
0357         unsetFlag(RedoLine1Modified);
0358         setFlag(RedoLine1Saved);
0359     }
0360
0361     if (isFlagSet(RedoLine2Modified) && !lines.testBit(line() + 1)) {
0362         lines.setBit(line() + 1);
0363
0364         unsetFlag(RedoLine2Modified);
0365         setFlag(RedoLine2Saved);
0366     }
0367 }
0368
0369 void KateModifiedWrapLine::updateUndoSavedOnDiskFlag(QBitArray &lines)
0370 {
0371     if (line() >= lines.size()) {
0372         lines.resize(line() + 1);
0373     }
0374
0375     if (isFlagSet(UndoLine1Modified) && !lines.testBit(line())) {
0376         lines.setBit(line());
0377
0378         unsetFlag(UndoLine1Modified);
0379         setFlag(UndoLine1Saved);
0380     }
0381 }
0382
0383 void KateModifiedUnWrapLine::updateRedoSavedOnDiskFlag(QBitArray &lines)
0384 {
0385     if (line() >= lines.size()) {
0386         lines.resize(line() + 1);
0387     }
0388
0389     if (isFlagSet(RedoLine1Modified) && !lines.testBit(line())) {
0390         lines.setBit(line());
0391
0392         unsetFlag(RedoLine1Modified);
0393         setFlag(RedoLine1Saved);
0394     }
0395 }
0396
0397 void KateModifiedUnWrapLine::updateUndoSavedOnDiskFlag(QBitArray &lines)
0398 {
0399     if (line() + 1 >= lines.size()) {
0400         lines.resize(line() + 2);
0401     }
0402
0403     if (isFlagSet(UndoLine1Modified) && !lines.testBit(line())) {
0404         lines.setBit(line());
0405
0406         unsetFlag(UndoLine1Modified);
0407         setFlag(UndoLine1Saved);
0408     }
0409
0410     if (isFlagSet(UndoLine2Modified) && !lines.testBit(line() + 1)) {
0411         lines.setBit(line() + 1);
0412
0413         unsetFlag(UndoLine2Modified);
0414         setFlag(UndoLine2Saved);
0415     }
0416 }
0417
0418 void KateModifiedInsertLine::updateRedoSavedOnDiskFlag(QBitArray &lines)
0419 {
0420     if (line() >= lines.size()) {
0421         lines.resize(line() + 1);
0422     }
0423
0424     if (!lines.testBit(line())) {
0425         lines.setBit(line());
0426
0427         unsetFlag(RedoLine1Modified);
0428         setFlag(RedoLine1Saved);
0429     }
0430 }
0431
0432 void KateModifiedRemoveLine::updateUndoSavedOnDiskFlag(QBitArray &lines)
0433 {
0434     if (line() >= lines.size()) {
0435         lines.resize(line() + 1);
0436     }
0437
0438     if (!lines.testBit(line())) {
0439         lines.setBit(line());
0440
0441         unsetFlag(UndoLine1Modified);
0442         setFlag(UndoLine1Saved);
0443     }
0444 }