src/Undo.cpp

   1 /**
   2  * \file Undo.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Asger Alstrup
   7  * \author Lars Gullik Bjønnes
   8  * \author John Levon
   9  * \author André Pönitz
  10  * \author Jürgen Vigna
  11  * \author Abdelrazak Younes
  12  *
  13  * Full author contact details are available in file CREDITS.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "Undo.h"
  19
  20 #include "Buffer.h"
  21 #include "BufferParams.h"
  22 #include "buffer_funcs.h"
  23 #include "DocIterator.h"
  24 #include "Paragraph.h"
  25 #include "ParagraphList.h"
  26 #include "Text.h"
  27
  28 #include "mathed/MathSupport.h"
  29 #include "mathed/MathData.h"
  30
  31 #include "insets/Inset.h"
  32
  33 #include "support/lassert.h"
  34 #include "support/debug.h"
  35
  36 #include <algorithm>
  37 #include <deque>
  38
  39 using namespace std;
  40 using namespace lyx::support;
  41
  42
  43 namespace lyx {
  44
  45 /**
  46 These are the elements put on the undo stack. Each object contains
  47 complete paragraphs from some cell and sufficient information to
  48 restore the cursor state.
  49
  50 The cell is given by a DocIterator pointing to this cell, the
  51 'interesting' range of paragraphs by counting them from begin and end
  52 of cell, respectively.
  53
  54 The cursor is also given as DocIterator and should point to some place
  55 in the stored paragraph range. In case of math, we simply store the
  56 whole cell, as there usually is just a simple paragraph in a cell.
  57
  58 The idea is to store the contents of 'interesting' paragraphs in some
  59 structure ('Undo') _before_ it is changed in some edit operation.
  60 Obviously, the stored range should be as small as possible. However,
  61 there is a lower limit: The StableDocIterator stored in the undo class
  62 must be valid after the changes, too, as it will used as a pointer
  63 where to insert the stored bits when performining undo.
  64 */
  65 struct UndoElement
  66 {
  67         ///
  68         UndoElement(UndoKind kin, StableDocIterator const & cb,
  69                     StableDocIterator const & cel,
  70                     pit_type fro, pit_type en, ParagraphList * pl,
  71                     MathData * ar, BufferParams const & bp,
  72                     bool ifb, bool lc, size_t gid) :
  73                 kind(kin), cur_before(cb), cell(cel), from(fro), end(en),
  74                 pars(pl), array(ar), bparams(0), isFullBuffer(ifb),
  75                 lyx_clean(lc), group_id(gid)
  76         {
  77                 if (isFullBuffer)
  78                         bparams = new BufferParams(bp);
  79         }
  80         ///
  81         UndoElement(UndoElement const & ue)
  82         {
  83                 kind = ue.kind;
  84                 cur_before = ue.cur_before;
  85                 cur_after = ue.cur_after;
  86                 cell = ue.cell;
  87                 from = ue.from;
  88                 end = ue.end;
  89                 pars = ue.pars;
  90                 array = ue.array;
  91                 bparams = ue.isFullBuffer
  92                         ? new BufferParams(*ue.bparams) : ue.bparams;
  93                 isFullBuffer = ue.isFullBuffer;
  94                 lyx_clean = ue.lyx_clean;
  95                 group_id = ue.group_id;
  96         }
  97         ///
  98         ~UndoElement()
  99         {
 100                 if (isFullBuffer)
 101                         delete bparams;
 102         }
 103         /// Which kind of operation are we recording for?
 104         UndoKind kind;
 105         /// the position of the cursor before recordUndo
 106         StableDocIterator cur_before;
 107         /// the position of the cursor at the end of the undo group
 108         StableDocIterator cur_after;
 109         /// the position of the cell described
 110         StableDocIterator cell;
 111         /// counted from begin of cell
 112         pit_type from;
 113         /// complement to end of this cell
 114         pit_type end;
 115         /// the contents of the saved Paragraphs (for texted)
 116         ParagraphList * pars;
 117         /// the contents of the saved MathData (for mathed)
 118         MathData * array;
 119         /// Only used in case of full backups
 120         BufferParams const * bparams;
 121         /// Only used in case of full backups
 122         bool isFullBuffer;
 123         /// Was the buffer clean at this point?
 124         bool lyx_clean;
 125         /// the element's group id
 126         size_t group_id;
 127 private:
 128         /// Protect construction
 129         UndoElement();
 130 };
 131
 132
 133 class UndoElementStack
 134 {
 135 public:
 136         /// limit is the maximum size of the stack
 137         UndoElementStack(size_t limit = 100) { limit_ = limit; }
 138         /// limit is the maximum size of the stack
 139         ~UndoElementStack() { clear(); }
 140
 141         /// Return the top element.
 142         UndoElement & top() { return c_.front(); }
 143
 144         /// Pop and throw away the top element.
 145         void pop() { c_.pop_front(); }
 146
 147         /// Return true if the stack is empty.
 148         bool empty() const { return c_.empty(); }
 149
 150         /// Clear all elements, deleting them.
 151         void clear() {
 152                 for (size_t i = 0; i != c_.size(); ++i) {
 153                         delete c_[i].array;
 154                         delete c_[i].pars;
 155                 }
 156                 c_.clear();
 157         }
 158
 159         /// Push an item on to the stack, deleting the bottom group on
 160         /// overflow.
 161         void push(UndoElement const & v) {
 162                 c_.push_front(v);
 163                 if (c_.size() > limit_) {
 164                         // remove a whole group at once.
 165                         const size_t gid = c_.back().group_id;
 166                         while (!c_.empty() && c_.back().group_id == gid)
 167                                 c_.pop_back();
 168                 }
 169         }
 170
 171         /// Mark all the elements of the stack as dirty
 172         void markDirty() {
 173                 for (size_t i = 0; i != c_.size(); ++i)
 174                         c_[i].lyx_clean = false;
 175         }
 176
 177 private:
 178         /// Internal contents.
 179         std::deque<UndoElement> c_;
 180         /// The maximum number elements stored.
 181         size_t limit_;
 182 };
 183
 184
 185 struct Undo::Private
 186 {
 187         Private(Buffer & buffer) : buffer_(buffer), undo_finished_(true),
 188                                    group_id(0), group_level(0) {}
 189
 190         // Do one undo/redo step
 191         void doTextUndoOrRedo(DocIterator & cur, UndoElementStack & stack,
 192                               UndoElementStack & otherStack);
 193         // Apply one undo/redo group. Returns false if no undo possible.
 194         bool textUndoOrRedo(DocIterator & cur, bool isUndoOperation);
 195
 196         ///
 197         void doRecordUndo(UndoKind kind,
 198                 DocIterator const & cell,
 199                 pit_type first_pit,
 200                 pit_type last_pit,
 201                 StableDocIterator const & cur,
 202                 bool isFullBuffer,
 203                 UndoElementStack & stack);
 204         ///
 205         void recordUndo(UndoKind kind,
 206                 DocIterator const & cell,
 207                 pit_type first_pit,
 208                 pit_type last_pit,
 209                 DocIterator const & cur,
 210                 bool isFullBuffer);
 211
 212         ///
 213         Buffer & buffer_;
 214         /// Undo stack.
 215         UndoElementStack undostack_;
 216         /// Redo stack.
 217         UndoElementStack redostack_;
 218
 219         /// The flag used by Undo::finishUndo().
 220         bool undo_finished_;
 221
 222         /// Current group Id.
 223         size_t group_id;
 224         /// Current group nesting nevel.
 225         size_t group_level;
 226 };
 227
 228
 229 /////////////////////////////////////////////////////////////////////
 230 //
 231 // Undo
 232 //
 233 /////////////////////////////////////////////////////////////////////
 234
 235
 236 Undo::Undo(Buffer & buffer)
 237         : d(new Undo::Private(buffer))
 238 {}
 239
 240
 241 Undo::~Undo()
 242 {
 243         delete d;
 244 }
 245
 246
 247 void Undo::clear()
 248 {
 249         d->undostack_.clear();
 250         d->redostack_.clear();
 251         d->undo_finished_ = true;
 252         d->group_id = 0;
 253         d->group_level = 0;
 254 }
 255
 256
 257 bool Undo::hasUndoStack() const
 258 {
 259         return !d->undostack_.empty();
 260 }
 261
 262
 263 bool Undo::hasRedoStack() const
 264 {
 265         return !d->redostack_.empty();
 266 }
 267
 268
 269 void Undo::markDirty()
 270 {
 271         d->undo_finished_ = true;
 272         d->undostack_.markDirty();
 273         d->redostack_.markDirty();
 274 }
 275
 276
 277 /////////////////////////////////////////////////////////////////////
 278 //
 279 // Undo::Private
 280 //
 281 ///////////////////////////////////////////////////////////////////////
 282
 283 static bool samePar(StableDocIterator const & i1, StableDocIterator const & i2)
 284 {
 285         StableDocIterator tmpi2 = i2;
 286         tmpi2.pos() = i1.pos();
 287         return i1 == tmpi2;
 288 }
 289
 290
 291 void Undo::Private::doRecordUndo(UndoKind kind,
 292         DocIterator const & cell,
 293         pit_type first_pit, pit_type last_pit,
 294         StableDocIterator const & cur_before,
 295         bool isFullBuffer,
 296         UndoElementStack & stack)
 297 {
 298         if (!group_level) {
 299                 LYXERR0("There is no group open (creating one)");
 300                 ++group_id;
 301         }
 302
 303         if (first_pit > last_pit)
 304                 swap(first_pit, last_pit);
 305
 306         // Undo::ATOMIC are always recorded (no overlapping there).
 307         // As nobody wants all removed character appear one by one when undoing,
 308         // we want combine 'similar' non-ATOMIC undo recordings to one.
 309         pit_type from = first_pit;
 310         pit_type end = cell.lastpit() - last_pit;
 311         if (!undo_finished_
 312             && kind != ATOMIC_UNDO
 313             && !stack.empty()
 314             && samePar(stack.top().cell, cell)
 315             && stack.top().kind == kind
 316             && stack.top().from == from
 317             && stack.top().end == end) {
 318                 // reset cur_after; it will be filled correctly by endUndoGroup.
 319                 stack.top().cur_after = StableDocIterator();
 320                 return;
 321         }
 322
 323         if (isFullBuffer)
 324                 LYXERR(Debug::UNDO, "Create full buffer undo element of group " << group_id);
 325         else
 326                 LYXERR(Debug::UNDO, "Create undo element of group " << group_id);
 327         // create the position information of the Undo entry
 328         UndoElement undo(kind, cur_before, cell, from, end, 0, 0,
 329                          buffer_.params(), isFullBuffer, buffer_.isClean(), group_id);
 330
 331         // fill in the real data to be saved
 332         if (cell.inMathed()) {
 333                 // simply use the whole cell
 334                 MathData & ar = cell.cell();
 335                 undo.array = new MathData(ar.buffer(), ar.begin(), ar.end());
 336         } else {
 337                 // some more effort needed here as 'the whole cell' of the
 338                 // main Text _is_ the whole document.
 339                 // record the relevant paragraphs
 340                 Text const * text = cell.text();
 341                 LASSERT(text, /**/);
 342                 ParagraphList const & plist = text->paragraphs();
 343                 ParagraphList::const_iterator first = plist.begin();
 344                 advance(first, first_pit);
 345                 ParagraphList::const_iterator last = plist.begin();
 346                 advance(last, last_pit + 1);
 347                 undo.pars = new ParagraphList(first, last);
 348         }
 349
 350         // push the undo entry to undo stack
 351         stack.push(undo);
 352         //lyxerr << "undo record: " << stack.top() << endl;
 353 }
 354
 355
 356 void Undo::Private::recordUndo(UndoKind kind,
 357                                DocIterator const & cell,
 358                                pit_type first_pit, pit_type last_pit,
 359                                DocIterator const & cur,
 360                                bool isFullBuffer)
 361 {
 362         LASSERT(first_pit <= cell.lastpit(), /**/);
 363         LASSERT(last_pit <= cell.lastpit(), /**/);
 364
 365         doRecordUndo(kind, cell, first_pit, last_pit, cur,
 366                 isFullBuffer, undostack_);
 367
 368         // next time we'll try again to combine entries if possible
 369         undo_finished_ = false;
 370
 371         // If we ran recordUndo, it means that we plan to change the buffer
 372         buffer_.markDirty();
 373
 374         redostack_.clear();
 375         //lyxerr << "undostack:\n";
 376         //for (size_t i = 0, n = buf.undostack().size(); i != n && i < 6; ++i)
 377         //      lyxerr << "  " << i << ": " << buf.undostack()[i] << endl;
 378 }
 379
 380
 381 void Undo::Private::doTextUndoOrRedo(DocIterator & cur, UndoElementStack & stack, UndoElementStack & otherstack)
 382 {
 383         // Adjust undo stack and get hold of current undo data.
 384         UndoElement & undo = stack.top();
 385         LYXERR(Debug::UNDO, "Undo element of group " << undo.group_id);
 386         // We'll pop the stack only when we're done with this element. So do NOT
 387         // try to return early.
 388
 389         // We will store in otherstack the part of the document under 'undo'
 390         DocIterator cell_dit = undo.cell.asDocIterator(&buffer_);
 391
 392         doRecordUndo(ATOMIC_UNDO, cell_dit,
 393                 undo.from, cell_dit.lastpit() - undo.end, undo.cur_after,
 394                 undo.isFullBuffer, otherstack);
 395         otherstack.top().cur_after = undo.cur_before;
 396
 397         // This does the actual undo/redo.
 398         //LYXERR0("undo, performing: " << undo);
 399         DocIterator dit = undo.cell.asDocIterator(&buffer_);
 400         if (undo.isFullBuffer) {
 401                 LASSERT(undo.pars, /**/);
 402                 // This is a full document
 403                 delete otherstack.top().bparams;
 404                 otherstack.top().bparams = new BufferParams(buffer_.params());
 405                 buffer_.params() = *undo.bparams;
 406                 swap(buffer_.paragraphs(), *undo.pars);
 407                 delete undo.pars;
 408                 undo.pars = 0;
 409         } else if (dit.inMathed()) {
 410                 // We stored the full cell here as there is not much to be
 411                 // gained by storing just 'a few' paragraphs (most if not
 412                 // all math inset cells have just one paragraph!)
 413                 //LYXERR0("undo.array: " << *undo.array);
 414                 LASSERT(undo.array, /**/);
 415                 dit.cell().swap(*undo.array);
 416                 delete undo.array;
 417                 undo.array = 0;
 418         } else {
 419                 // Some finer machinery is needed here.
 420                 Text * text = dit.text();
 421                 LASSERT(text, /**/);
 422                 LASSERT(undo.pars, /**/);
 423                 ParagraphList & plist = text->paragraphs();
 424
 425                 // remove new stuff between first and last
 426                 ParagraphList::iterator first = plist.begin();
 427                 advance(first, undo.from);
 428                 ParagraphList::iterator last = plist.begin();
 429                 advance(last, plist.size() - undo.end);
 430                 plist.erase(first, last);
 431
 432                 // re-insert old stuff instead
 433                 first = plist.begin();
 434                 advance(first, undo.from);
 435
 436                 // this ugly stuff is needed until we get rid of the
 437                 // inset_owner backpointer
 438                 ParagraphList::iterator pit = undo.pars->begin();
 439                 ParagraphList::iterator const end = undo.pars->end();
 440                 for (; pit != end; ++pit)
 441                         pit->setInsetOwner(dit.realInset());
 442                 plist.insert(first, undo.pars->begin(), undo.pars->end());
 443                 delete undo.pars;
 444                 undo.pars = 0;
 445         }
 446         LASSERT(undo.pars == 0, /**/);
 447         LASSERT(undo.array == 0, /**/);
 448
 449         if (undo.cur_before.size())
 450                 cur = undo.cur_before.asDocIterator(&buffer_);
 451         if (undo.lyx_clean)
 452                 buffer_.markClean();
 453         else
 454                 buffer_.markDirty();
 455         // Now that we're done with undo, we pop it off the stack.
 456         stack.pop();
 457 }
 458
 459
 460 bool Undo::Private::textUndoOrRedo(DocIterator & cur, bool isUndoOperation)
 461 {
 462         undo_finished_ = true;
 463
 464         UndoElementStack & stack = isUndoOperation ?  undostack_ : redostack_;
 465
 466         if (stack.empty())
 467                 // Nothing to do.
 468                 return false;
 469
 470         UndoElementStack & otherstack = isUndoOperation ? redostack_ : undostack_;
 471
 472         const size_t gid = stack.top().group_id;
 473         while (!stack.empty() && stack.top().group_id == gid)
 474                 doTextUndoOrRedo(cur, stack, otherstack);
 475
 476         // Adapt the new material to current buffer.
 477         buffer_.setBuffersForInsets(); // FIXME This shouldn't be here.
 478         return true;
 479 }
 480
 481
 482 void Undo::finishUndo()
 483 {
 484         // Make sure the next operation will be stored.
 485         d->undo_finished_ = true;
 486 }
 487
 488
 489 bool Undo::textUndo(DocIterator & cur)
 490 {
 491         return d->textUndoOrRedo(cur, true);
 492 }
 493
 494
 495 bool Undo::textRedo(DocIterator & cur)
 496 {
 497         return d->textUndoOrRedo(cur, false);
 498 }
 499
 500
 501 void Undo::beginUndoGroup()
 502 {
 503         if (d->group_level == 0) {
 504                 // create a new group
 505                 ++d->group_id;
 506                 LYXERR(Debug::UNDO, "+++++++Creating new group " << d->group_id);
 507         }
 508         ++d->group_level;
 509 }
 510
 511
 512 void Undo::endUndoGroup()
 513 {
 514         if (d->group_level == 0)
 515                 LYXERR0("There is no undo group to end here");
 516         --d->group_level;
 517         if (d->group_level == 0) {
 518                 // real end of the group
 519                 LYXERR(Debug::UNDO, "-------End of group " << d->group_id);
 520         }
 521 }
 522
 523
 524 void Undo::endUndoGroup(DocIterator const & cur)
 525 {
 526         endUndoGroup();
 527         if (!d->undostack_.empty() && !d->undostack_.top().cur_after.size())
 528                 d->undostack_.top().cur_after = cur;
 529 }
 530
 531
 532 // FIXME: remove these convenience functions and make
 533 // Private::recordUndo public as sole interface. The code in the
 534 // convenience functions can move to Cursor.cpp.
 535
 536 void Undo::recordUndo(DocIterator const & cur, UndoKind kind)
 537 {
 538         d->recordUndo(kind, cur, cur.pit(), cur.pit(), cur, false);
 539 }
 540
 541
 542 void Undo::recordUndoInset(DocIterator const & cur, UndoKind kind,
 543                            Inset const * inset)
 544 {
 545         if (!inset || inset == &cur.inset()) {
 546                 DocIterator c = cur;
 547                 c.pop_back();
 548                 d->recordUndo(kind, c, c.pit(), c.pit(), cur, false);
 549         } else if (inset == cur.nextInset())
 550                 recordUndo(cur, kind);
 551         else
 552                 LYXERR0("Inset not found, no undo stack added.");
 553 }
 554
 555
 556 void Undo::recordUndo(DocIterator const & cur, UndoKind kind, pit_type from)
 557 {
 558         d->recordUndo(kind, cur, cur.pit(), from, cur, false);
 559 }
 560
 561
 562 void Undo::recordUndo(DocIterator const & cur, UndoKind kind,
 563         pit_type from, pit_type to)
 564 {
 565         d->recordUndo(kind, cur, from, to, cur, false);
 566 }
 567
 568
 569 void Undo::recordUndoFullDocument(DocIterator const & cur)
 570 {
 571         // This one may happen outside of the main undo group, so we
 572         // put it in its own subgroup to avoid complaints.
 573         beginUndoGroup();
 574         d->recordUndo(ATOMIC_UNDO, doc_iterator_begin(&d->buffer_),
 575                       0, d->buffer_.paragraphs().size() - 1, cur, true);
 576         endUndoGroup();
 577 }
 578
 579
 580 } // namespace lyx