/**
   * Tell the edits in the given range (inclusive) to die, and remove them from edits. from > to is
   * a no-op.
   */
  protected void trimEdits(int from, int to) {
    if (from <= to) {
      //          System.out.println("Trimming " + from + " " + to + " with index " +
      //                           indexOfNextAdd);
      for (int i = to; from <= i; i--) {
        UndoableEdit e = (UndoableEdit) edits.elementAt(i);
        //              System.out.println("JUM: Discarding " +
        //                                 e.getUndoPresentationName());
        e.die();
        // PENDING(rjrjr) when Vector supports range deletion (JDK
        // 1.2) , we can optimize the next line considerably.
        edits.removeElementAt(i);
      }

      if (indexOfNextAdd > to) {
        //              System.out.print("...right...");
        indexOfNextAdd -= to - from + 1;
      } else if (indexOfNextAdd >= from) {
        //              System.out.println("...mid...");
        indexOfNextAdd = from;
      }

      //          System.out.println("new index " + indexOfNextAdd);
    }
  }
 /**
  * Undo after some positions have been garbage collected.
  *
  * @throws BadLocationException
  */
 public void testUndoGC() throws BadLocationException {
   content.insertString(0, "012345678");
   Vector<WeakReference<Position>> pos = new Vector<WeakReference<Position>>(10);
   ReferenceQueue<Position> rq = new ReferenceQueue<Position>();
   for (int i = 0; i < content.length(); i += 2) {
     pos.add(new WeakReference<Position>(content.createPosition(i), rq));
   }
   int count = 0;
   int i;
   for (i = 0; i < 100; i++) {
     System.gc();
     Reference<?> r;
     if ((r = rq.poll()) != null) {
       pos.remove(r);
       count++;
       if (pos.size() == 0) {
         break;
       }
     }
   }
   // This call causes all the garbage collected positions to be
   // removed from the internal list
   UndoableEdit ue = content.remove(0, 5);
   assertEquals("5678", content.getString(0, content.length() - 1));
   // Test (it shouldn't fail with any NullPointerException)
   ue.undo();
   assertEquals("012345678", content.getString(0, content.length() - 1));
 }
 /** Redoes all changes from indexOfNextAdd to edit. Updates indexOfNextAdd accordingly. */
 protected void redoTo(UndoableEdit edit) throws CannotRedoException {
   boolean done = false;
   while (!done) {
     UndoableEdit next = (UndoableEdit) edits.elementAt(indexOfNextAdd++);
     next.redo();
     done = next == edit;
   }
 }
 public boolean addEdit(UndoableEdit anEdit) {
   final boolean absorbed = super.addEdit(anEdit);
   if (!absorbed && !isInProgress() && anEdit instanceof FormUndoableEdit) {
     final UndoableEdit ledit = lastEdit();
     if (ledit != null && ledit instanceof FormUndoableEdit) return (ledit.addEdit(anEdit));
   }
   return (absorbed);
 }
  /** Returns the the next significant edit to be undone if undo is called. May return null */
  protected UndoableEdit editToBeUndone() {
    int i = indexOfNextAdd;
    while (i > 0) {
      UndoableEdit edit = (UndoableEdit) edits.elementAt(--i);
      if (edit.isSignificant()) {
        return edit;
      }
    }

    return null;
  }
 /** Empty the undo manager, sending each edit a die message in the process. */
 public synchronized void discardAllEdits() {
   Enumeration cursor = edits.elements();
   while (cursor.hasMoreElements()) {
     UndoableEdit e = (UndoableEdit) cursor.nextElement();
     e.die();
   }
   edits = new Vector(limit);
   indexOfNextAdd = 0;
   // PENDING(rjrjr) when vector grows a removeRange() method
   // (expected in JDK 1.2), trimEdits() will be nice and
   // efficient, and this method can call that instead.
 }
  private void localize() {

    LocaleManager localeManager = LocaleManager.getInstance();
    UndoManager undoManager = UndoManager.getInstance();

    UndoableEdit undoableEdit = undoManager.editToBeRedone();

    if (undoableEdit == null) {
      setText(localeManager.getValue(CAPTION_LOCALIZE_KEY));
    } else {
      setText(undoableEdit.getRedoPresentationName());
    }
  }
  /** Returns the the next significant edit to be redone if redo is called. May return null */
  protected UndoableEdit editToBeRedone() {
    int count = edits.size();
    int i = indexOfNextAdd;

    while (i < count) {
      UndoableEdit edit = (UndoableEdit) edits.elementAt(i++);
      if (edit.isSignificant()) {
        return edit;
      }
    }

    return null;
  }
  /**
   * Overridden to preserve usual semantics: returns true if an undo operation would be successful
   * now, false otherwise
   */
  public synchronized boolean canUndo() {

    //            System.out.println("giugiu affichage de edits : ");
    //            for (int i = 0; i < this.edits.size(); i++)
    //                System.out.println("\t" + this.edits.elementAt(i).hashCode());

    if (this.isInProgress()) {
      UndoableEdit edit = editToBeUndone();
      //            System.out.println("canUndo : " + (edit != null && edit.canUndo()));
      //            System.out.println("edit : " + edit.hashCode() + (edit != null ? edit.canUndo()
      // : "beuh"));// + " : " + edit.getClass());
      return edit != null && edit.canUndo();
    } else {
      //            System.out.println("undo aieee");
      return super.canUndo();
    }
  }
Beispiel #10
0
  public void undoableEditHappened(UndoableEditEvent e) {
    UndoableEdit edit = e.getEdit();
    if (edit instanceof AbstractDocument.DefaultDocumentEvent) {
      AbstractDocument.DefaultDocumentEvent event = (AbstractDocument.DefaultDocumentEvent) edit;
      int start = event.getOffset();
      int len = event.getLength();
      Debug.log(9, "undoableEditHappened " + start + "," + len);
      boolean isNeedStart = false;
      if (event.getType().equals(DocumentEvent.EventType.CHANGE)
          || event.getType().equals(DocumentEvent.EventType.INSERT)) {
        try {
          String text = event.getDocument().getText(start, len);
          if (text.contains("\n")) isNeedStart = true;
        } catch (BadLocationException e1) {
          e1.printStackTrace();
        }
      }

      if (current == null) {
        isNeedStart = true;
      } else if (lastEditName == null || !lastEditName.equals(edit.getPresentationName())) {
        isNeedStart = true;
      }

      while (pointer < edits.size() - 1) {
        edits.remove(edits.size() - 1);
        isNeedStart = true;
      }
      if (isNeedStart) {
        createCompoundEdit();
      }

      current.addEdit(edit);
      lastEditName = edit.getPresentationName();

      refreshControls();
    }
  }
  /** add an undoableEdit to the manager */
  public synchronized boolean addEdit(UndoableEdit anEdit) {
    System.out.println("appel à addEdit : " + anEdit);
    //        System.out.println("addEdit .. " + (anEdit != null ? anEdit.getClass() : "") );
    //        System.out.println("\tisInProgress ? " + this.isInProgress());
    //        System.out.println("\tgroup mode   ? " + this.groupActivated);
    //
    //        System.out.println("affichage de edits : ");
    //        for (int i = 0; i < this.edits.size(); i++)
    //            System.out.println("\t" + this.edits.elementAt(i).getClass());

    if (!this.isInProgress()) return false;

    System.out.println("groupActivated : " + this.groupActivated);

    if (this.groupActivated) {
      if (!(this.editToBeUndone() instanceof UndoManager)) {
        System.out.println("\teditToBeUndone is NOT NOT an UndoManager");
        UndoManager newManager = new UndoManager();
        newManager.setLimit(this.limit); // attention, la limite peut poser de graves problemes
        // super.addEdit(newManager);
        this.edits.add(newManager);

        indexOfNextAdd = edits.size();
        System.out.println("\tindexOfNextAdd : " + indexOfNextAdd);
      }

      if (this.editToBeUndone() instanceof UndoManager) {
        System.out.println("\teditToBeUndone is an UndoManager");
        ((UndoManager) this.editToBeUndone()).addEdit(anEdit);
        //                System.out.println("\tindexOfNextAdd : " + indexOfNextAdd);

        //        System.out.println("gaga affichage de edits : ");
        //        for (int i = 0; i < this.edits.size(); i++)
        //            System.out.println("\t" + this.edits.elementAt(i).getClass());

        return true;
      } else {
        //                System.out.println("\teditToBeUndone is NOT an UndoManager");

        if (this.edits.size() > 0) {
          System.out.println("\ta");
          ((UndoManager) this.edits.elementAt(this.edits.size() - 1)).addEdit(anEdit);
        } else {
          System.out.println("\tb");
          this.edits.add(anEdit);
        }
        return true;
      }
      // throw new RuntimeException("gros probleme dans l'undoManager"); }
    } else {
      System.out.println("\tajout simple");
      boolean retVal;

      // Trim from the indexOfNextAdd to the end, as we'll
      // never reach these edits once the new one is added.
      trimEdits(indexOfNextAdd, edits.size() - 1);

      ///////////////
      if (!this.isInProgress()) {
        return false;
      } else {
        UndoableEdit last = lastEdit();

        // If this is the first subedit received, just add it.
        // Otherwise, give the last one a chance to absorb the new
        // one.  If it won't, give the new one a chance to absorb
        // the last one.

        System.out.println("\t\tlast : " + (last == null ? "null" : last.getClass()));
        if (last == null) {
          System.out.println("\t\taddElement");
          edits.addElement(anEdit);
        } else // if (last instanceof UndoManager)//!last.addEdit(anEdit) || )
        {
          System.out.println("\t\ti");
          if (anEdit.replaceEdit(last)) {
            edits.removeElementAt(edits.size() - 1);
            System.out.println("\t\tj");
          }
          System.out.println(
              "il ajoute quand meme ce connard !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
          edits.addElement(anEdit);
        }

        retVal = true;
      }
      ///////////////

      if (this.isInProgress()) {
        retVal = true;
      }

      // Maybe super added this edit, maybe it didn't (perhaps
      // an in progress compound edit took it instead. Or perhaps
      // this UndoManager is no longer in progress). So make sure
      // the indexOfNextAdd is pointed at the right place.
      indexOfNextAdd = edits.size();

      System.out.println("indexofNextAdd : " + indexOfNextAdd);

      // Enforce the limit
      trimForLimit();

      return retVal;
    }
  }