toolchain/gcc/libjava/javax/swing/undo/UndoManager.java

   1 /* AbstractTableModel.java --
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.undo;
  40
  41 import javax.swing.event.UndoableEditEvent;
  42 import javax.swing.event.UndoableEditListener;
  43
  44 /**
  45  * UndoManager
  46  * @author      Andrew Selkirk
  47  */
  48 public class UndoManager extends CompoundEdit implements UndoableEditListener {
  49
  50         //-------------------------------------------------------------
  51         // Variables --------------------------------------------------
  52         //-------------------------------------------------------------
  53
  54         /**
  55          * indexOfNextAdd
  56          */
  57         int indexOfNextAdd;
  58
  59         /**
  60          * limit
  61          */
  62         int limit;
  63
  64
  65         //-------------------------------------------------------------
  66         // Initialization ---------------------------------------------
  67         //-------------------------------------------------------------
  68
  69         /**
  70          * Constructor UndoManager
  71          */
  72         public UndoManager() {
  73                 // TODO
  74         } // UndoManager()
  75
  76
  77         //-------------------------------------------------------------
  78         // Methods ----------------------------------------------------
  79         //-------------------------------------------------------------
  80
  81         /**
  82          * toString
  83          * @returns String
  84          */
  85         public String toString() {
  86                 return null; // TODO
  87         } // toString()
  88
  89         /**
  90          * end
  91          */
  92         public synchronized void end() {
  93                 // TODO
  94         } // end()
  95
  96         /**
  97          * getLimit
  98          * @returns int
  99          */
 100         public synchronized int getLimit() {
 101                 return 0; // TODO
 102         } // getLimit()
 103
 104         /**
 105          * discardAllEdits
 106          */
 107         public synchronized void discardAllEdits() {
 108                 // TODO
 109         } // discardAllEdits()
 110
 111         /**
 112          * trimForLimit
 113          */
 114         protected void trimForLimit() {
 115                 // TODO
 116         } // trimForLimit()
 117
 118         /**
 119          * trimEdits
 120          * @param value0 TODO
 121          * @param value1 TODO
 122          */
 123         protected void trimEdits(int value0, int value1) {
 124                 // TODO
 125         } // trimEdits()
 126
 127         /**
 128          * setLimit
 129          * @param value0 TODO
 130          */
 131         public synchronized void setLimit(int value0) {
 132                 // TODO
 133         } // setLimit()
 134
 135         /**
 136          * editToBeUndone
 137          * @returns UndoableEdit
 138          */
 139         protected UndoableEdit editToBeUndone() {
 140                 return null; // TODO
 141         } // editToBeUndone()
 142
 143         /**
 144          * editToBeRedone
 145          * @returns UndoableEdit
 146          */
 147         protected UndoableEdit editToBeRedone() {
 148                 return null; // TODO
 149         } // editToBeRedone()
 150
 151         /**
 152          * undoTo
 153          * @param value0 TODO
 154          * @exception CannotUndoException TODO
 155          */
 156         protected void undoTo(UndoableEdit value0) throws CannotUndoException {
 157                 // TODO
 158         } // undoTo()
 159
 160         /**
 161          * redoTo
 162          * @param value0 TODO
 163          * @exception CannotRedoException TODO
 164          */
 165         protected void redoTo(UndoableEdit value0) throws CannotRedoException {
 166                 // TODO
 167         } // redoTo()
 168
 169         /**
 170          * undoOrRedo
 171          * @exception CannotRedoException TODO
 172          * @exception CannotUndoException TODO
 173          */
 174         public synchronized void undoOrRedo() throws CannotRedoException, CannotUndoException {
 175                 // TODO
 176         } // undoOrRedo()
 177
 178         /**
 179          * canUndoOrRedo
 180          * @returns boolean
 181          */
 182         public synchronized boolean canUndoOrRedo() {
 183                 return false; // TODO
 184         } // canUndoOrRedo()
 185
 186         /**
 187          * undo
 188          * @exception CannotUndoException TODO
 189          */
 190         public synchronized void undo() throws CannotUndoException {
 191                 // TODO
 192         } // undo()
 193
 194         /**
 195          * canUndo
 196          * @returns boolean
 197          */
 198         public synchronized boolean canUndo() {
 199                 return false; // TODO
 200         } // canUndo()
 201
 202         /**
 203          * redo
 204          * @exception CannotRedoException TODO
 205          */
 206         public synchronized void redo() throws CannotRedoException {
 207                 // TODO
 208         } // redo()
 209
 210         /**
 211          * canRedo
 212          * @returns boolean
 213          */
 214         public synchronized boolean canRedo() {
 215                 return false; // TODO
 216         } // canRedo()
 217
 218         /**
 219          * addEdit
 220          * @param value0 TODO
 221          * @returns boolean
 222          */
 223         public synchronized boolean addEdit(UndoableEdit value0) {
 224                 return false; // TODO
 225         } // addEdit()
 226
 227         /**
 228          * getUndoOrRedoPresentationName
 229          * @returns String
 230          */
 231         public synchronized String getUndoOrRedoPresentationName() {
 232                 return null; // TODO
 233         } // getUndoOrRedoPresentationName()
 234
 235         /**
 236          * getUndoPresentationName
 237          * @returns String
 238          */
 239         public synchronized String getUndoPresentationName() {
 240                 return null; // TODO
 241         } // getUndoPresentationName()
 242
 243         /**
 244          * getRedoPresentationName
 245          * @returns String
 246          */
 247         public synchronized String getRedoPresentationName() {
 248                 return null; // TODO
 249         } // getRedoPresentationName()
 250
 251         /**
 252          * undoableEditHappened
 253          * @param value0 TODO
 254          */
 255         public void undoableEditHappened(UndoableEditEvent value0) {
 256                 // TODO
 257         } // undoableEditHappened()
 258
 259
 260 } // UndoManager