UndoHelper.java

/*
 * Copyright 2003-2017 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package jetbrains.mps.smodel;

import jetbrains.mps.project.Project;
import jetbrains.mps.smodel.undo.UndoContext;
import jetbrains.mps.util.Computable;
import jetbrains.mps.util.annotation.ToRemove;

public class UndoHelper {
  private static final UndoHandler DEFAULT = new DefaultUndoHandler();

  private static UndoHelper ourInstance = new UndoHelper();

  public static UndoHelper getInstance() {
    return ourInstance;
  }

  //-----

  private UndoHandler myHandler = DEFAULT;

  private UndoHelper() {
  }


  public void setUndoHandler(UndoHandler handler) {
    myHandler = handler;
  }

  public void addUndoableAction(SNodeUndoableAction action) {
    myHandler.addUndoableAction(action);
  }

  public void flushCommand(Project p) {
    myHandler.flushCommand(p);
  }

  /**
   * CAUTION: there's no clear contract what this method does and whether there's reason for its existence at all. If you use it,
   * please state your scenario here, so that others know it, too. FWIW, there are no uses in mbeddr.
   * Possible use is for {@link #needRegisterUndo()} to tell false (or for {@link #addUndoableAction(SNodeUndoableAction)} to ignore
   * actions added). However, this is insufficient for a platform to figure out there's a non-undoable action. Check
   * {@code WorkbenchUndoHandler.flushCommand()} implementation - there's nothing done in case list of actions is empty.
   * @deprecated don't use it at all, unless there's solid and sound reason, stated here in the method's javadoc explicitly.
   */
  // FIXME any restriction whether this method is invoked within model read/write action?
  @Deprecated
  public <T> T runNonUndoableAction(Computable<T> t) {
    return myHandler.runNonUndoableAction(t);
  }

  /**
   * @deprecated it's handler-specific implementation detail. It used to be expose likely to optimize and not to instantiate undoable action
   *             unless necessary. Now it's just an extra clutter in the client's code. Just don't use, {@link #addUndoableAction(SNodeUndoableAction)} can
   *             figure out whether it needs to register undo or not.
   */
  @Deprecated
  @ToRemove(version = 0)
  public boolean needRegisterUndo() {
    return myHandler.needRegisterUndo();
  }

  /**
   * Implementation used to respect state imposed by {@link #runNonUndoableAction(Computable)}, effectively blocking modification
   * of a registered/attached model from non-undoable action, which is odd. Either requirement to modify registered models
   * from isInsideUndoableCommand() == true was too much, or implementation of the method shall ignore non-undoable state of
   * {@link #runNonUndoableAction(Computable)}. Since its name bears explicit 'Undoable', I assume its use was incorrect,
   * rather than implementation, and thus replaced the check (see {@link AttachedNodeOwner}) and relaxed to ensure
   * {@link org.jetbrains.mps.openapi.module.ModelAccess#isCommandAction()} only. This method is not in use any more.
   * @deprecated no uses, uncertain contract, any reason to survive?
   */
  @Deprecated
  @ToRemove(version = 0)
  public boolean isInsideUndoableCommand() {
    return myHandler.isInsideUndoableCommand();
  }

  public void startCommand(UndoContext context) {
    myHandler.startCommand(context);
  }
}