Swing UndoManager hängt beim Redo

[HotWax]

Hallo,

ich bastel an einem Editor mit Syntaxhighlightning und Undo/Redo Operation. Ihc benutze das JTextPane und für Undo & Redo benutze ich den UndoManager von Swing. Das ganze funktioniert eigentlich auch. Nach jeder Eingabe wird der Text geparst und mittels setCharacterAttributes vom DefaulStyledDocument der Text farbig formatiert.

Das stellt auch das Problem dar, dadurch das ich setCharacterAttributes aufrufe wird auch dieses UndoEvent, also die Formatänderung, in der Undo Historie abgelegt. Dazu habe ich mir eine kleine abhilfe gemacht die auch funktioniert ABER wenn das JTextPane ganz leer ist, also z.B. alle Undo's gemacht wurden UND dann wird ein Redo gemacht hängt sich das Programm auf. Nach ca. 2min's geht es wieder.

Meine Abhilfe ist das einafch vor dem Formatieren des Textes wird eine Variable im UndoManager auf false gesetzt, und ab da an werden keine UndoEvent's mehr gespeichert.

Hier mal ein Ausschnit aus meiner ContentPanel Datei, in der auch das JTextPane etc. ist.

public ContentPanel() {
		initialize();
		initializeComponents();
		textPane.getDocument().addUndoableEditListener(undoableEditListener = new MyUndoableEditListener());
	}

public void redo() {
		try {
            undo.redo();
        } catch (CannotRedoException ex) {
            System.out.println("Unable to redo: " + ex);
            ex.printStackTrace();
        }
        updateRedoState();
        updateUndoState();
	}
	
	public void undo() {
		try {
            undo.undo();
        } catch (CannotUndoException ex) {
            System.out.println("Unable to undo: " + ex);
            ex.printStackTrace();
        }
        updateUndoState();
        updateRedoState();
	}
	
	public void highlightDocument() {
		undoableEditListener.setHighlightMode(true);
		
				// Code...
				// ...
		
        		attr = highlighter.getAttributeSet(word);
        		// Hier passiert die Formatänderung
            	document.setCharacterAttributes(offset, length, attr, true);
            	
            	
            }
        } catch (BadLocationException ble) {
            System.err.println("Couldn't insert initial text.");
        }
        
        undoableEditListener.setHighlightMode(false);
    }
	
	public void updateUndoState() {
        if(undo.canUndo()) {
        	UndoAction.getInstance().setEnabled(true);
            //System.out.println(undo.getUndoPresentationName());
        } else {
        	UndoAction.getInstance().setEnabled(false);
        }
    }
	
	public void updateRedoState() {
        if (undo.canRedo()) {
        	RedoAction.getInstance().setEnabled(true);
            //System.out.println(undo.getRedoPresentationName());
        } else {
        	RedoAction.getInstance().setEnabled(false);
        }
    }
    
	class MyUndoableEditListener implements UndoableEditListener {
    	
		private boolean highlightMode = false;
		
        public boolean isHighlightMode() {
			return highlightMode;
		}

		public void setHighlightMode(boolean highlightMode) {
			this.highlightMode = highlightMode;
		}

		public void undoableEditHappened(UndoableEditEvent e) {
			// Hier wenn der HighlightMode aus ist (=false) dann werden die UndoEvent's gespeichert
                        if(isHighlightMode() == false) {
				undo.addEdit(e.getEdit());
            	                updateUndoState();
            	                updateRedoState();
			}
        }
    }

Und hier noch eine Action, die ausgeführt wird wenn STRG-Z gedrückt wird:

private UndoAction(String name, Icon icon) {
		super(name, icon);
		putValue(Action.SHORT_DESCRIPTION, name);
		setEnabled(false);
	}
	
	@Override
	public void actionPerformed(ActionEvent arg0) {
		System.out.println(getValue(NAME));
		MainFrame.getContentPanel().undo();
	}

Ich hoffe mir kann jemand bei diesem Problem helfen! :$

 

[André Uhres]

Hallo HotWax,

herzlich willkommen bei java-forum.org!

Dieses kleine Beispiel scheint gut zu funktionieren:

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.undo.*;

public class UndoManagerTest {

    public static void main(final String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            public void run() {
                new UndoManagerTest().createAndShowGUI();
            }
        });
    }

    private void createAndShowGUI() {
        //  Create a text pane
        final JTextPane textPane = new JTextPane();
        textPane.setPreferredSize(new Dimension(200, 200));
        textPane.setEditorKit(new StyledEditorKit() {

            @Override
            public Document createDefaultDocument() {
                return new HighlightingDocument();
            }
        });
        String text = "public class SomeClass\n{\n\t//  Enter code here\n}";
        textPane.setText(text);
        UndoManagerImpl undoManager = new UndoManagerImpl(textPane);
        //  Create undo/redo items
        JMenu editMenu = new JMenu("Edit");
        JMenuItem undo = new JMenuItem(undoManager.getUndoAction());
        editMenu.add(undo);
        JMenuItem redo = new JMenuItem(undoManager.getRedoAction());
        editMenu.add(redo);
        JMenuBar bar = new JMenuBar();
        bar.add(editMenu);
        //  Add components to the frame
        JPanel main = new JPanel();
        main.setLayout(new BorderLayout());
        main.add(new JScrollPane(textPane), BorderLayout.CENTER);
        JFrame frame = new JFrame("Undo Manager Test");
        frame.setJMenuBar(bar);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(main);
        frame.setSize(450, 240);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    /*
     **  UndoManagerImpl will merge individual edits into a single larger edit.
     **  That is, characters entered sequentially will be grouped together and
     **  undone as a group. Any attribute changes will be considered as part
     **  of the group and will therefore be undone when the group is undone.
     */
    class UndoManagerImpl extends UndoManager implements UndoableEditListener, DocumentListener {

        private CompoundEdit compoundEdit;
        private JTextComponent textComponent;
        private UndoAction undoAction;
        private RedoAction redoAction;
        //  These fields are used to help determine whether the edit is an
        //  incremental edit. The offset and length should increase by 1 for
        //  each character added or decrease by 1 for each character removed.
        private int lastOffset;
        private int lastLength;

        public UndoManagerImpl(final JTextComponent textComponent) {
            this.textComponent = textComponent;
            undoAction = new UndoAction();
            redoAction = new RedoAction();
            textComponent.getDocument().addUndoableEditListener(UndoManagerImpl.this);
        }

        /*
         **  Add a DocumentLister before the undo is done so we can position
         **  the Caret correctly as each edit is undone.
         */
        @Override
        public void undo() {
            textComponent.getDocument().addDocumentListener(this);
            super.undo();
            textComponent.getDocument().removeDocumentListener(this);
        }

        /*
         **  Add a DocumentLister before the redo is done so we can position
         **  the Caret correctly as each edit is redone.
         */
        @Override
        public void redo() {
            textComponent.getDocument().addDocumentListener(this);
            super.redo();
            textComponent.getDocument().removeDocumentListener(this);
        }

        /*
         **  Whenever an UndoableEdit happens the edit will either be absorbed
         **  by the current compound edit or a new compound edit will be started
         */
        @Override
        public void undoableEditHappened(final UndoableEditEvent e) {
            //  Start a new compound edit
            if (compoundEdit == null) {
                compoundEdit = startCompoundEdit(e.getEdit());
                return;
            }
            int offsetChange = textComponent.getCaretPosition() - lastOffset;
            int lengthChange = textComponent.getDocument().getLength() - lastLength;
            //  Check for an attribute change
            AbstractDocument.DefaultDocumentEvent event =
                    (AbstractDocument.DefaultDocumentEvent) e.getEdit();
            if (event.getType().equals(DocumentEvent.EventType.CHANGE)) {
                if (offsetChange == 0) {
                    compoundEdit.addEdit(e.getEdit());
                    return;
                }
            }
            //  Check for an incremental edit or backspace.
            //  The Change in Caret position and Document length should both be
            //  either 1 or -1.
            if (offsetChange == lengthChange
                    && Math.abs(offsetChange) == 1) {
                compoundEdit.addEdit(e.getEdit());
                lastOffset = textComponent.getCaretPosition();
                lastLength = textComponent.getDocument().getLength();
                return;
            }
            //  Not incremental edit, end previous edit and start a new one
            compoundEdit.end();
            compoundEdit = startCompoundEdit(e.getEdit());
        }

        /*
         **  Each CompoundEdit will store a group of related incremental edits
         **  (ie. each character typed or backspaced is an incremental edit)
         */
        private CompoundEdit startCompoundEdit(final UndoableEdit anEdit) {
            //  Track Caret and Document information of this compound edit
            lastOffset = textComponent.getCaretPosition();
            lastLength = textComponent.getDocument().getLength();
            //  The compound edit is used to store incremental edits
            compoundEdit = new CompoundEditImpl();
            compoundEdit.addEdit(anEdit);
            //  The compound edit is added to the UndoManager. All incremental
            //  edits stored in the compound edit will be undone/redone at once
            addEdit(compoundEdit);
            undoAction.updateUndoState();
            redoAction.updateRedoState();
            return compoundEdit;
        }

        /*
         *  The Action to Undo changes to the Document.
         *  The state of the Action is managed by the UndoManagerImpl
         */
        public Action getUndoAction() {
            return undoAction;
        }

        /*
         *  The Action to Redo changes to the Document.
         *  The state of the Action is managed by the UndoManagerImpl
         */
        public Action getRedoAction() {
            return redoAction;
        }

//
//  Implement DocumentListener
//
     /*
         *  Updates to the Document as a result of Undo/Redo will cause the
         *  Caret to be repositioned
         */
        public void insertUpdate(final DocumentEvent e) {
            SwingUtilities.invokeLater(new Runnable() {

                public void run() {
                    int offset = e.getOffset() + e.getLength();
                    offset = Math.min(offset, textComponent.getDocument().getLength());
                    textComponent.setCaretPosition(offset);
                }
            });
        }

        public void removeUpdate(final DocumentEvent e) {
            textComponent.setCaretPosition(e.getOffset());
        }

        public void changedUpdate(DocumentEvent e) {
        }

        class CompoundEditImpl extends CompoundEdit {

            @Override
            public boolean isInProgress() {
                //  in order for the canUndo() and canRedo() methods to work
                //  assume that the compound edit is never in progress
                return false;
            }

            @Override
            public void undo() throws CannotUndoException {
                //  End the edit so future edits don't get absorbed by this edit
                if (compoundEdit != null) {
                    compoundEdit.end();
                }
                super.undo();
                //  Always start a new compound edit after an undo
                compoundEdit = null;
            }
        }

        /*
         *	Perform the Undo and update the state of the undo/redo Actions
         */
        class UndoAction extends AbstractAction {

            public UndoAction() {
                putValue(Action.NAME, "Undo");
                putValue(Action.SHORT_DESCRIPTION, getValue(Action.NAME));
                putValue(Action.MNEMONIC_KEY, new Integer(KeyEvent.VK_U));
                putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke("control Z"));
                setEnabled(false);
            }

            public void actionPerformed(final ActionEvent e) {
                try {
                    undo();
                    textComponent.requestFocusInWindow();
                } catch (final CannotUndoException ex) {
                }

                updateUndoState();
                redoAction.updateRedoState();
            }

            private void updateUndoState() {
                setEnabled(canUndo());
            }
        }

        /*
         *	Perform the Redo and update the state of the undo/redo Actions
         */
        class RedoAction extends AbstractAction {

            public RedoAction() {
                putValue(Action.NAME, "Redo");
                putValue(Action.SHORT_DESCRIPTION, getValue(Action.NAME));
                putValue(Action.MNEMONIC_KEY, new Integer(KeyEvent.VK_R));
                putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke("control Y"));
                setEnabled(false);
            }

            public void actionPerformed(final ActionEvent e) {
                try {
                    redo();
                    textComponent.requestFocusInWindow();
                } catch (CannotRedoException ex) {
                }

                updateRedoState();
                undoAction.updateUndoState();
            }

            protected void updateRedoState() {
                setEnabled(canRedo());
            }
        }
    }

    class HighlightingDocument extends DefaultStyledDocument {

        private Element rootElement;
        private MutableAttributeSet normal;
        private MutableAttributeSet keyword;
        private HashSet keywords;

        public HighlightingDocument() {
            rootElement = getDefaultRootElement();
            putProperty(DefaultEditorKit.EndOfLineStringProperty, "\n");
            normal = new SimpleAttributeSet();
            StyleConstants.setForeground(normal, Color.black);
            keyword = new SimpleAttributeSet();
            StyleConstants.setForeground(keyword, Color.blue);
            keywords = new HashSet();
            keywords.add("boolean");
            keywords.add("catch");
            keywords.add("char");
            keywords.add("class");
            keywords.add("double");
            keywords.add("else");
            keywords.add("extends");
            keywords.add("false");
            keywords.add("final");
            keywords.add("float");
            keywords.add("for");
            keywords.add("if");
            keywords.add("implements");
            keywords.add("import");
            keywords.add("int");
            keywords.add("interface");
            keywords.add("new");
            keywords.add("null");
            keywords.add("package");
            keywords.add("private");
            keywords.add("protected");
            keywords.add("public");
            keywords.add("return");
            keywords.add("static");
            keywords.add("super");
            keywords.add("this");
            keywords.add("throws");
            keywords.add("true");
            keywords.add("try");
            keywords.add("void");
            keywords.add("while");
        }

        @Override
        public void insertString(final int offset, final String str,
                final AttributeSet a) throws BadLocationException {
            super.insertString(offset, str, a);
            processChangedLines(offset, str.length());
        }

        @Override
        public void remove(final int offset, final int length) throws BadLocationException {
            super.remove(offset, length);
            processChangedLines(offset, 0);
        }

        /*
         *  Determine how many lines have been changed,
         *  then apply highlighting to each line
         */
        public void processChangedLines(final int offset, final int length)
                throws BadLocationException {
            String content = getText(0, getLength());
            //  The lines affected by the latest document update
            int startLine = rootElement.getElementIndex(offset);
            int endLine = rootElement.getElementIndex(offset + length);
            //  Do the actual highlighting
            for (int i = startLine; i <= endLine; i++) {
                applyHighlighting(content, i);
            }
        }


        /*
         *  Parse the line to determine the appropriate highlighting
         */
        private void applyHighlighting(final String content, final int line)
                throws BadLocationException {
            int startOffset = rootElement.getElement(line).getStartOffset();
            int endOffset = rootElement.getElement(line).getEndOffset() - 1;
            int lineLength = endOffset - startOffset;
            int contentLength = content.length();
            if (endOffset >= contentLength) {
                endOffset = contentLength - 1;
            }
            //  set normal attributes for the line
            setCharacterAttributes(startOffset, lineLength, normal, true);
            //  check for tokens
            checkForTokens(content, startOffset, endOffset);
        }


        /*
         *	Parse the line for tokens to highlight
         */
        private void checkForTokens(final String content, int startOffset, final int endOffset) {
            while (startOffset <= endOffset) {
                //  skip the delimiters to find the start of a new token
                while (isDelimiter(content.substring(startOffset, startOffset + 1))) {
                    if (startOffset < endOffset) {
                        startOffset++;
                    } else {
                        return;
                    }
                }
                //  Extract and process the entire token
                startOffset = processToken(content, startOffset, endOffset);
            }
        }

        private int processToken(final String content, final int startOffset, final int endOffset) {
            int endOfToken = startOffset + 1;
            while (endOfToken <= endOffset) {
                if (isDelimiter(content.substring(endOfToken, endOfToken + 1))) {
                    break;
                }
                endOfToken++;
            }
            String token = content.substring(startOffset, endOfToken);
            if (isKeyword(token)) {
                setCharacterAttributes(startOffset, endOfToken - startOffset, keyword, false);
            }
            return endOfToken + 1;
        }

        protected boolean isDelimiter(final String character) {
            String operands = ";:{}()[]+-/%<=>!&|^~*";
            if (Character.isWhitespace(character.charAt(0))
                    || operands.indexOf(character) != -1) {
                return true;
            } else {
                return false;
            }
        }

        protected boolean isKeyword(final String token) {
            return keywords.contains(token);
        }
    }
}

Gruß,
André

 

[HotWax]

Hallo!

Danke für die Hilfe!

Dein Beispiel funktioniert perfekt! Jedoch will ich den Code nicht einfach kopieren. Ausserdem fällt es mir ein wenig schwer mich in den Code reinzudenken.


Ich habe auch schon mein Problem ein wenig lokalisieren können. Bei meiner Variante werden nur Edits dem UndoManager hinzugefügt, die Textänderungen sind. Formatänderungen nicht. Und wenn das Dokument jetzt ganz leer ist, also kein Text, und ich ein Redo mache dann hängt sich das Programm für ca. 2 Mins auf. Im Debugger sieht man das er arbeitet, er rechnet durch die ganzen ParagraphView, LabelViews, FlowViews und die Methode getViewIndexCount() etc.

Ich vermute das es daran liegt das der UndoManager eben nur die Textänderungen kennt, und dann beim redo keine Ahnung hat wo es hin muss. Im Dokument sind durch die setCharachterAttributes() verschiedene Views angelegt worden, denke ich zumindest!

 

[André Uhres]

Versuch mal, nur die Klasse UndoManagerImpl zu kopieren und deinen UndoManger zu deaktivieren. UndoManagerImpl kannst du so aktivieren (Auszug aus dem Beispiel):

UndoManagerImpl undoManager = new UndoManagerImpl(textPane);
//  Create undo/redo items
JMenu editMenu = new JMenu("Edit");
JMenuItem undo = new JMenuItem(undoManager.getUndoAction());
editMenu.add(undo);
JMenuItem redo = new JMenuItem(undoManager.getRedoAction());
editMenu.add(redo);

Auf diese Weise können wir das Problem vielleicht noch besser lokalisieren.

Gruß,
André