Quelle undo.h Sprache: C

// -*- C++ -*-
/* This file is part of
* ======================================================
*
*           LyX, The Document Processor
*
*     Copyright (C) 1995 Matthias Ettrich, 1995, 1996 LyX Team
*
*======================================================*/
#ifndef _UNDO_H
#define _UNDO_H

#ifdef __GNUG__
#pragma interface
#endif

#include "definitions.h"
#include "lyxparagraph.h"

///
class Undo {
public:
/// The undo kinds
enum undo_kind {
  ///
  INSERT,
  ///
  DELETE,
  ///
  EDIT,
  ///
  FINISH
};
///
undo_kind kind;
///
int number_of_before_par;
///
int number_of_behind_par;
///
int number_of_cursor_par;
///
int cursor_pos; // valid if >= 0
///
LyXParagraph* par;
///
Undo(undo_kind kind_arg,
      int number_before_arg, int number_behind_arg,
      int cursor_par_arg, int cursor_pos_arg,
      LyXParagraph* par_arg)
{
  kind = kind_arg;
  number_of_before_par = number_before_arg;
  number_of_behind_par = number_behind_arg;
  number_of_cursor_par = cursor_par_arg;
  cursor_pos = cursor_pos_arg;
  par = par_arg;
}
///
~Undo(){
  LyXParagraph* tmppar;
  while (par) {
   tmppar = par;
   par = par->next;
   delete tmppar;
  }
}
};

/// A limited Stack for the undo informations. Matthias 290496
class UndoStack{
private:
///
struct StackAtom{
  ///
  StackAtom* previous;
  ///
  Undo* undo;
};
///
StackAtom* current;
///
StackAtom *tmp;
///
int size;
///
int limit;
public:
///
UndoStack(){
  current = NULL;
  // size must be initialised (thornley)
  size = 0;
  limit = 100; // the maximum number of undo steps stored. 0 means NO LIMIT.
  // Limit can be changed with UndoStack::SetStackLimit(int)
}
///
Undo *Pop(){
  Undo* result = NULL;
  if (current){
   result = current->undo;
   tmp = current;
   current = current->previous;
   delete tmp;
   size--;
  }
  else {
   size = 0; // for safety...
  }
  return result;
}
///
Undo* Top(){
  if (current)
   return current->undo;
  else
   return NULL;
}
///
~UndoStack(){
  Clear();
}
///
void Clear(){
  Undo* tmp_undo = Pop();
  while (tmp_undo){
   delete tmp_undo;
   tmp_undo = Pop();
  }
}
///
void SetStackLimit(int limit_arg) {
  limit = limit_arg;
}

///
void Push(Undo* undo_arg){
  int i;
  StackAtom* tmp2;
  if (undo_arg){
   tmp = new StackAtom;
   tmp->undo = undo_arg;
   tmp->previous = current;
   current = tmp;
   size++;
   if (limit && size > limit){
    for (i=0; i<limit && tmp; i++)
     tmp = tmp->previous;
    while(tmp && tmp->previous){
     tmp2 = tmp->previous->previous;
     delete tmp->previous;
     size--;
     tmp->previous = tmp2;
    }
   }
  }
}
};

#endif

quality95%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.