Attachment #113004 for bug #21237

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 21237
Collapse All | Expand All

Lines 73-78 Link Here

(-)a/editor.lib/src/org/netbeans/editor/BaseDocument.java (-190 / +277 lines)
73	import javax.swing.text.BadLocationException;	73	import javax.swing.text.BadLocationException;
74	import javax.swing.text.DefaultEditorKit;	74	import javax.swing.text.DefaultEditorKit;
75	import javax.swing.text.Document;	75	import javax.swing.text.Document;
		76	import javax.swing.text.DocumentFilter;
76	import javax.swing.text.Position;	77	import javax.swing.text.Position;
77	import javax.swing.text.Element;	78	import javax.swing.text.Element;
78	import javax.swing.text.AttributeSet;	79	import javax.swing.text.AttributeSet;
Lines 336-341 Link Here
336		337
337	private DocumentListener postModificationDocumentListener;	338	private DocumentListener postModificationDocumentListener;
338		339
		340	private DocumentEvent postModificationEvent;
		341
339	private ListenerList<DocumentListener> postModificationDocumentListenerList = new ListenerList<DocumentListener>();	342	private ListenerList<DocumentListener> postModificationDocumentListenerList = new ListenerList<DocumentListener>();
340		343
341	private ListenerList<DocumentListener> updateDocumentListenerList = new ListenerList<DocumentListener>();	344	private ListenerList<DocumentListener> updateDocumentListenerList = new ListenerList<DocumentListener>();
Lines 352-357 Link Here
352		355
353	private UndoableEdit removeUpdateLineUndo;	356	private UndoableEdit removeUpdateLineUndo;
354		357
		358	private DocumentFilter.FilterBypass filterBypass;
		359
355	private Preferences prefs;	360	private Preferences prefs;
356	private final PreferenceChangeListener prefsListener = new PreferenceChangeListener() {	361	private final PreferenceChangeListener prefsListener = new PreferenceChangeListener() {
357	public @Override void preferenceChange(PreferenceChangeEvent evt) {	362	public @Override void preferenceChange(PreferenceChangeEvent evt) {
Lines 724-730 Link Here
724	}	729	}
725		730
726	/** Inserts string into document */	731	/** Inserts string into document */
727	public @Override void insertString(int offset, String text, AttributeSet a)	732	public @Override void insertString(int offset, String text, AttributeSet attrs)
728	throws BadLocationException {	733	throws BadLocationException {
729	if (LOG_EDT.isLoggable(Level.FINE)) { // Only permit operations in EDT	734	if (LOG_EDT.isLoggable(Level.FINE)) { // Only permit operations in EDT
730	if (!SwingUtilities.isEventDispatchThread()) {	735	if (!SwingUtilities.isEventDispatchThread()) {
Lines 733-847 Link Here
733	}	738	}
734	}	739	}
735		740
736	if (text == null \|\| text.length() == 0) {	741	boolean notifyMod = notifyModifyCheckStart(offset, "insertString() vetoed"); // NOI18N
737	return;	742	boolean modFinished = false; // Whether modification succeeded
738	}
739
740	// Check offset correctness
741	if (offset < 0 \|\| offset > getLength()) {
742	throw new BadLocationException("Wrong insert position " + offset, offset); // NOI18N
743	}
744
745	// possible CR-LF conversion
746	text = ReadWriteUtils.convertToNewlines(text);
747
748	// Check whether there is an active postModificationDocumentListener	743	// Check whether there is an active postModificationDocumentListener
749	// and if so then start an atomic transaction.	744	// and if so then start an atomic transaction.
750	boolean activePostModification;	745	boolean activePostModification;
751	DocumentEvent postModificationEvent = null;
752	synchronized (this) {	746	synchronized (this) {
753	activePostModification = (postModificationDocumentListener != null	747	activePostModification = (postModificationDocumentListener != null
754	\|\| postModificationDocumentListenerList.getListenerCount() > 0);	748	\|\| postModificationDocumentListenerList.getListenerCount() > 0);
755	if (activePostModification) {	749	if (activePostModification) {
756	atomicLockImpl ();	750	atomicLockImpl ();
		751	} else {
		752	extWriteLock();
757	}	753	}
758	}	754	}
759	try {	755	try {
760		756	DocumentFilter filter = getDocumentFilter();
761	// Perform the insert	757	if (filter != null) {
762	boolean notifyMod = notifyModifyCheckStart(offset, "insertString() vetoed"); // NOI18N	758	filter.insertString(getFilterBypass(), offset, text, attrs);
763	boolean modFinished = false; // Whether modification succeeded	759	} else {
764	extWriteLock();	760	handleInsertString(offset, text, attrs);
765	try {
766	incrementDocVersion();
767
768	/*
769	boolean checkSpaces = inited && org.netbeans.lib.editor.util.swing.DocumentUtilities.isTypingModification(this);
770	if (checkSpaces) {
771	Position offsPosition = createPosition(offset);
772	checkTrailingSpaces(offset);
773	offset = offsPosition.getOffset();
774	}
775	*/
776
777	preInsertCheck(offset, text, a);
778
779	// Do the real insert into the content
780	UndoableEdit edit = getContent().insertString(offset, text);
781
782	/*
783	if (checkSpaces) {
784	lastPositionEditedByTyping = createPosition(offset);
785	}
786	*/
787
788	if (LOG.isLoggable(Level.FINE)) {
789	String msg = "BaseDocument.insertString(): doc=" + this // NOI18N
790	+ (modified ? "" : " - first modification") // NOI18N
791	+ ", offset=" + Utilities.offsetToLineColumnString(this, offset) // NOI18N
792	+ (debugNoText ? "" : (", text='" + text + "'")); // NOI18N
793
794	if (debugStack) {
795	LOG.log(Level.FINE, msg, new Throwable(msg));
796	} else {
797	LOG.log(Level.FINE, msg);
798	}
799	}
800
801	BaseDocumentEvent evt = getDocumentEvent(offset, text.length(), DocumentEvent.EventType.INSERT, a);
802
803	preInsertUpdate(evt, a);
804
805	if (edit != null) {
806	evt.addEdit(edit);
807
808	lastModifyUndoEdit = edit; // #8692 check last modify undo edit
809	}
810
811	modified = true;
812
813	if (atomicDepth > 0) {
814	ensureAtomicEditsInited();
815	atomicEdits.addEdit(evt); // will be added
816	}
817
818	insertUpdate(evt, a);
819
820	evt.end();
821
822	fireInsertUpdate(evt);
823
824	boolean isComposedText = ((a != null)
825	&& (a.isDefined(StyleConstants.ComposedTextAttribute)));
826
827	if (composedText && !isComposedText)
828	composedText = false;
829	if (!composedText && isComposedText)
830	composedText = true;
831
832	if (atomicDepth == 0 && !isComposedText) { // !!! check
833	fireUndoableEditUpdate(new UndoableEditEvent(this, evt));
834	}	761	}
835	modFinished = true;	762	modFinished = true;
836	postModificationEvent = evt;
837	} finally {
838	extWriteUnlock();
839	// Notify no mod done if notified mod but mod did not succeeded
840	if (notifyMod) {
841	notifyModifyCheckEnd(modFinished);
842	}
843	}
844
845	} finally { // for post modification	763	} finally { // for post modification
846	if (activePostModification) {	764	if (activePostModification) {
847	try {	765	try {
Lines 856-864 Link Here
856	} finally {	774	} finally {
857	atomicUnlockImpl();	775	atomicUnlockImpl();
858	}	776	}
		777	} else {
		778	extWriteUnlock();
		779	}
		780	// Notify no mod done if notified mod but mod did not succeeded
		781	if (notifyMod) {
		782	notifyModifyCheckEnd(modFinished);
859	}	783	}
860	}	784	}
861	}	785	}
		786
		787	void handleInsertString(int offset, String text, AttributeSet attrs) throws BadLocationException {
		788	if (text == null \|\| text.length() == 0) {
		789	return;
		790	}
		791
		792	// Check offset correctness
		793	if (offset < 0 \|\| offset > getLength()) {
		794	throw new BadLocationException("Wrong insert position " + offset, offset); // NOI18N
		795	}
		796
		797	// possible CR-LF to LF conversion
		798	text = ReadWriteUtils.convertToNewlines(text);
		799
		800	postModificationEvent = null;
		801	incrementDocVersion();
		802
		803	preInsertCheck(offset, text, attrs);
		804
		805	UndoableEdit edit = getContent().insertString(offset, text);
		806
		807	if (LOG.isLoggable(Level.FINE)) {
		808	String msg = "BaseDocument.insertString(): doc=" + this // NOI18N
		809	+ (modified ? "" : " - first modification") // NOI18N
		810	+ ", offset=" + Utilities.offsetToLineColumnString(this, offset) // NOI18N
		811	+ (debugNoText ? "" : (", text='" + text + "'")); // NOI18N
		812
		813	if (debugStack) {
		814	LOG.log(Level.FINE, msg, new Throwable(msg));
		815	} else {
		816	LOG.log(Level.FINE, msg);
		817	}
		818	}
		819
		820	BaseDocumentEvent evt = getDocumentEvent(offset, text.length(), DocumentEvent.EventType.INSERT, attrs);
		821
		822	preInsertUpdate(evt, attrs);
		823
		824	if (edit != null) {
		825	evt.addEdit(edit);
		826
		827	lastModifyUndoEdit = edit; // #8692 check last modify undo edit
		828	}
		829
		830	modified = true;
		831
		832	if (atomicDepth > 0) {
		833	ensureAtomicEditsInited();
		834	atomicEdits.addEdit(evt); // will be added
		835	}
		836
		837	insertUpdate(evt, attrs);
		838
		839	evt.end();
		840
		841	fireInsertUpdate(evt);
		842
		843	boolean isComposedText = ((attrs != null)
		844	&& (attrs.isDefined(StyleConstants.ComposedTextAttribute)));
		845
		846	if (composedText && !isComposedText) {
		847	composedText = false;
		848	}
		849	if (!composedText && isComposedText) {
850	composedText = true;
851	}
852
853	if (atomicDepth == 0 && !isComposedText) { // !!! check
854	fireUndoableEditUpdate(new UndoableEditEvent(this, evt));
855	}
856	postModificationEvent = evt;
857	}
862		858
863	public void checkTrailingSpaces(int offset) {	859	public void checkTrailingSpaces(int offset) {
864	try {	860	try {
Lines 896-1001 Link Here
896	}	892	}
897		893
898	/** Removes portion of a document */	894	/** Removes portion of a document */
899	public @Override void remove(int offset, int len) throws BadLocationException {	895	public @Override void remove(int offset, int length) throws BadLocationException {
900	if (LOG_EDT.isLoggable(Level.FINE)) { // Only permit operations in EDT	896	if (LOG_EDT.isLoggable(Level.FINE)) { // Only permit operations in EDT
901	if (!SwingUtilities.isEventDispatchThread()) {	897	if (!SwingUtilities.isEventDispatchThread()) {
902	throw new IllegalStateException("BaseDocument.insertString not in EDT: offset=" + // NOI18N	898	throw new IllegalStateException("BaseDocument.insertString not in EDT: offset=" + // NOI18N
903	offset + ", len=" + len); // NOI18N	899	offset + ", len=" + length); // NOI18N
904	}	900	}
905	}	901	}
906		902
907	if (len > 0) {	903	boolean notifyMod = notifyModifyCheckStart(offset, "remove() vetoed"); // NOI18N
908	if (offset < 0) {	904	boolean modFinished = false; // Whether modification succeeded
909	throw new BadLocationException("Wrong remove position " + offset, offset); // NOI18N	905	// Check whether there is an active postModificationDocumentListener
		906	// and if so then start an atomic transaction.
		907	boolean activePostModification;
		908	synchronized (this) {
		909	activePostModification = (postModificationDocumentListener != null
		910	\|\| postModificationDocumentListenerList.getListenerCount() > 0);
		911	if (activePostModification) {
		912	atomicLockImpl ();
		913	} else {
		914	extWriteLock();
910	}	915	}
911		916	}
912	// Check whether there is an active postModificationDocumentListener	917	try {
913	// and if so then start an atomic transaction.	918	DocumentFilter filter = getDocumentFilter();
914	boolean activePostModification;	919	if (filter != null) {
915	DocumentEvent postModificationEvent = null;	920	filter.remove(getFilterBypass(), offset, length);
916	synchronized (this) {	921	} else {
917	activePostModification = (postModificationDocumentListener != null	922	handleRemove(offset, length);
918	\|\| postModificationDocumentListenerList.getListenerCount() > 0);
919	if (activePostModification) {
920	atomicLockImpl ();
921	}
922	}	923	}
923	try {	924	modFinished = true;
924		925	} finally { // for post modification
925	boolean notifyMod = notifyModifyCheckStart(offset, "remove() vetoed"); // NOI18N	926	if (activePostModification) {
926	boolean modFinished = false; // Whether modification succeeded	927	try {
927	extWriteLock();
928	try {
929	incrementDocVersion();
930
931	int docLen = getLength();
932	if (offset < 0 \|\| offset > docLen) {
933	throw new BadLocationException("Wrong remove position " + offset, offset); // NOI18N
934	}
935	if (offset + len > docLen) {
936	throw new BadLocationException("End offset of removed text " // NOI18N
937	+ (offset + len) + " > getLength()=" + docLen, // NOI18N
938	offset + len
939	); // NOI18N
940	}
941
942	preRemoveCheck(offset, len);
943
944	BaseDocumentEvent evt = getDocumentEvent(offset, len, DocumentEvent.EventType.REMOVE, null);
945	// Store modification text as an event's property
946	org.netbeans.lib.editor.util.swing.DocumentUtilities.addEventPropertyStorage(evt);
947	String removedText = getText(offset, len);
948	org.netbeans.lib.editor.util.swing.DocumentUtilities.putEventProperty(evt, String.class, removedText);
949
950	removeUpdate(evt);
951
952	UndoableEdit edit = ((EditorDocumentContent)getContent()).remove(offset, removedText);
953	if (edit != null) {
954	evt.addEdit(edit);
955
956	lastModifyUndoEdit = edit; // #8692 check last modify undo edit
957	}
958
959	if (LOG.isLoggable(Level.FINE)) {
960	String msg = "BaseDocument.remove(): doc=" + this // NOI18N
961	+ ", origDocLen=" + docLen // NOI18N
962	+ ", offset=" + Utilities.offsetToLineColumnString(this, offset) // NOI18N
963	+ ", len=" + len // NOI18N
964	+ (debugNoText ? "" : (", removedText='" + ((ContentEdit)edit).getText() + "'")); //NOI18N
965
966	if (debugStack) {
967	LOG.log(Level.FINE, msg, new Throwable(msg));
968	} else {
969	LOG.log(Level.FINE, msg);
970	}
971	}
972
973	if (atomicDepth > 0) { // add edits as soon as possible
974	ensureAtomicEditsInited();
975	atomicEdits.addEdit(evt); // will be added
976	}
977
978	postRemoveUpdate(evt);
979
980	evt.end();
981
982	fireRemoveUpdate(evt);
983	if (atomicDepth == 0 && !composedText) {
984	fireUndoableEditUpdate(new UndoableEditEvent(this, evt));
985	}
986
987	modFinished = true;
988	postModificationEvent = evt;
989	} finally {
990	extWriteUnlock();
991	// Notify no mod done if notified mod but mod did not succeeded
992	if (notifyMod) {
993	notifyModifyCheckEnd(modFinished);
994	}
995	}
996
997	} finally { // for post modification
998	if (activePostModification) {
999	if (postModificationEvent != null) { // Modification finished successfully	928	if (postModificationEvent != null) { // Modification finished successfully
1000	if (postModificationDocumentListener != null) {	929	if (postModificationDocumentListener != null) {
1001	postModificationDocumentListener.removeUpdate(postModificationEvent);	930	postModificationDocumentListener.removeUpdate(postModificationEvent);
Lines 1004-1014 Link Here
1004	listener.removeUpdate(postModificationEvent);	933	listener.removeUpdate(postModificationEvent);
1005	}	934	}
1006	}	935	}
		936	} finally {
1007	atomicUnlockImpl ();	937	atomicUnlockImpl ();
1008	}	938	}
		939	} else {
		940	extWriteUnlock();
1009	}	941	}
		942	// Notify no mod done if notified mod but mod did not succeeded
		943	if (notifyMod) {
		944	notifyModifyCheckEnd(modFinished);
		945	}
		946	}
		947	}
		948
		949	void handleRemove(int offset, int length) throws BadLocationException {
		950	if (length == 0) {
		951	return;
		952	}
		953	if (length < 0) {
		954	throw new IllegalArgumentException("len=" + length + " < 0"); // NOI18N
		955	}
		956	if (offset < 0) {
		957	throw new BadLocationException("Wrong remove position " + offset + " < 0", offset); // NOI18N
		958	}
		959	if (offset + length > getLength()) {
		960	throw new BadLocationException("Wrong (offset+length)=" + (offset+length) +
		961	" > getLength()=" + getLength(), offset + length); // NOI18N
		962	}
1010		963
		964	postModificationEvent = null;
		965	incrementDocVersion();
		966
		967	int docLen = getLength();
		968	if (offset < 0 \|\| offset > docLen) {
		969	throw new BadLocationException("Wrong remove position " + offset, offset); // NOI18N
1011	}	970	}
		971	if (offset + length > docLen) {
		972	throw new BadLocationException("End offset of removed text " // NOI18N
		973	+ (offset + length) + " > getLength()=" + docLen, // NOI18N
		974	offset + length); // NOI18N
		975	}
		976
		977	preRemoveCheck(offset, length);
		978
		979	BaseDocumentEvent evt = getDocumentEvent(offset, length, DocumentEvent.EventType.REMOVE, null);
		980	// Store modification text as an event's property
		981	org.netbeans.lib.editor.util.swing.DocumentUtilities.addEventPropertyStorage(evt);
		982	String removedText = getText(offset, length);
		983	org.netbeans.lib.editor.util.swing.DocumentUtilities.putEventProperty(evt, String.class, removedText);
		984
		985	removeUpdate(evt);
		986
		987	UndoableEdit edit = ((EditorDocumentContent) getContent()).remove(offset, removedText);
		988	if (edit != null) {
		989	evt.addEdit(edit);
		990
		991	lastModifyUndoEdit = edit; // #8692 check last modify undo edit
		992	}
		993
		994	if (LOG.isLoggable(Level.FINE)) {
		995	String msg = "BaseDocument.remove(): doc=" + this // NOI18N
		996	+ ", origDocLen=" + docLen // NOI18N
		997	+ ", offset=" + Utilities.offsetToLineColumnString(this, offset) // NOI18N
		998	+ ", len=" + length // NOI18N
		999	+ (debugNoText ? "" : (", removedText='" + ((ContentEdit) edit).getText() + "'")); //NOI18N
		1000
		1001	if (debugStack) {
		1002	LOG.log(Level.FINE, msg, new Throwable(msg));
		1003	} else {
		1004	LOG.log(Level.FINE, msg);
		1005	}
		1006	}
		1007
		1008	if (atomicDepth > 0) { // add edits as soon as possible
		1009	ensureAtomicEditsInited();
		1010	atomicEdits.addEdit(evt); // will be added
		1011	}
		1012
		1013	postRemoveUpdate(evt);
		1014
		1015	evt.end();
		1016
		1017	fireRemoveUpdate(evt);
		1018	if (atomicDepth == 0 && !composedText) {
		1019	fireUndoableEditUpdate(new UndoableEditEvent(this, evt));
		1020	}
		1021	postModificationEvent = evt;
		1022	}
		1023
		1024	public void replace(int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
		1025	boolean notifyMod = notifyModifyCheckStart(offset, "replace() vetoed"); // NOI18N
		1026	boolean modFinished = false; // Whether modification succeeded
		1027	// Check whether there is an active postModificationDocumentListener
		1028	// and if so then start an atomic transaction.
		1029	boolean activePostModification;
		1030	synchronized (this) {
		1031	activePostModification = (postModificationDocumentListener != null
		1032	\|\| postModificationDocumentListenerList.getListenerCount() > 0);
		1033	if (activePostModification) {
		1034	atomicLockImpl ();
1035	} else {
1036	extWriteLock();
1037	}
1038	}
1039	try {
1040	DocumentFilter filter = getDocumentFilter();
1041	if (filter != null) {
1042	filter.replace(getFilterBypass(), offset, length, text, attrs);
1043	} else {
1044	handleRemove(offset, length);
1045	handleInsertString(offset, text, attrs);
1046	}
1047	modFinished = true;
1048	} finally { // for post modification
1049	if (activePostModification) {
1050	try {
1051	if (postModificationEvent != null) { // Modification finished successfully
1052	if (postModificationDocumentListener != null) {
1053	postModificationDocumentListener.insertUpdate(postModificationEvent);
1054	}
1055	for (DocumentListener listener: postModificationDocumentListenerList.getListeners()) {
1056	listener.insertUpdate(postModificationEvent);
1057	}
1058	}
1059	} finally {
1060	atomicUnlockImpl();
1061	}
1062	} else {
1063	extWriteUnlock();
1064	}
1065	// Notify no mod done if notified mod but mod did not succeeded
1066	if (notifyMod) {
1067	notifyModifyCheckEnd(modFinished);
1068	}
1069	}
1070	}
1071
1072	private DocumentFilter.FilterBypass getFilterBypass() {
1073	if (filterBypass == null) {
1074	filterBypass = new FilterBypassImpl();
1075	}
1076	return filterBypass;
1012	}	1077	}
1013		1078
1014	/**	1079	/**
Lines 1672-1677 Link Here
1672	((UndoableEditListener)listeners[i + 1]).undoableEditHappened(e);	1737	((UndoableEditListener)listeners[i + 1]).undoableEditHappened(e);
1673	}	1738	}
1674	}	1739	}
		1740
		1741	// Since UndoManager may only do um.addEdit() the original resetting
		1742	// in AtomicCompoundEdit.replaceEdit() would not be called in such case.
		1743	undoMergeReset = false;
1675	}	1744	}
1676		1745
1677	/** Extended write locking of the document allowing	1746	/** Extended write locking of the document allowing
Lines 2301-2307 Link Here
2301	}	2370	}
2302	}	2371	}
2303	}	2372	}
2304	undoMergeReset = false;
2305	return false;	2373	return false;
2306	}	2374	}
2307		2375
Lines 2538-2541 Link Here
2538	}	2606	}
2539	} // End of PlainEditorKit class	2607	} // End of PlainEditorKit class
2540		2608
		2609	class FilterBypassImpl extends DocumentFilter.FilterBypass {
		2610
		2611	public Document getDocument() {
		2612	return BaseDocument.this;
		2613	}
		2614
		2615	public void remove(int offset, int length) throws BadLocationException {
		2616	handleRemove(offset, length);
		2617	}
		2618
		2619	public void insertString(int offset, String string, AttributeSet attrs) throws BadLocationException {
		2620	handleInsertString(offset, string, attrs);
		2621	}
		2622
		2623	public void replace(int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
		2624	handleRemove(offset, length);
		2625	handleInsertString(offset, text, attrs);
		2626	}
		2627	}
2541	}	2628	}





        private final ChangeSupport cs = new ChangeSupport(this);

        /** vector of Edits to run */
        private final LinkedList<UndoableEditEvent> runus = new LinkedList<UndoableEditEvent>(); // for fix of #8692

        /** Called from undoableEditHappened() inner class */
        private void superUndoableEditHappened(UndoableEditEvent ue) {
            super.undoableEditHappened(ue);
        }

        /** Called from discardAllEdits() inner class */
        private void superDiscardAllEdits() {
            super.discardAllEdits();
        }

        /** Consume an undoable edit.
        * Delegates to superclass and notifies listeners.
        * @param ue the edit
        */
        @Override
        public void undoableEditHappened(final UndoableEditEvent ue) {
            super.undoableEditHappened(ue);
            cs.fireChange();
             * the undoable edit should be avoided this way.
             */
            synchronized (runus) {
                runus.add(ue);
            }

            updateTask();
        }

        /** Discard all the existing edits from the undomanager. */
        @Override
        public void discardAllEdits() {
            super.discardAllEdits();
            cs.fireChange();
            }

            updateTask();
        }

        @Override
        public void undo() throws CannotUndoException {
            super.undo();
            cs.fireChange();
        }

        @Override
        public void redo() throws CannotRedoException {
            super.redo();
            cs.fireChange();
        }

        @Override
        public void undoOrRedo() throws CannotRedoException, CannotUndoException {
            super.undoOrRedo(); // cs.fireChange() either in undo() or redo()
            updateTask();
        }

        private void updateTask() {
            for (;;) {
                UndoableEditEvent ue;

                synchronized (runus) {
                    if (runus.isEmpty()) {
                        break;
                    }

                    ue = runus.removeFirst();
                }

                if (ue == null) {
                    superDiscardAllEdits();
                } else {
                    superUndoableEditHappened(ue);
                }
            }
            cs.fireChange();
        }

        /* Attaches change listener to the this object.
        * The listener is notified everytime the undo/redo
        * ability of this object changes.
        */

        //#32313 - synchronization of this method was removed
        @Override
        public void addChangeListener(ChangeListener l) {
            cs.addChangeListener(l);




    private Listener listener;

    /** the undo/redo manager to use for this document */
    private UndoRedoManager undoRedo;

    /** lines set for this object */
    private Line.Set lineSet;

     * <br>
     * Also set when document is being reloaded.
     */
    private boolean documentReloading;
    private boolean justRevertedToNotModified;
    private volatile int documentStatus = DOCUMENT_NO;
    private Throwable prepareDocumentRuntimeException;


     */
    private Map<Line,Reference<Line>> lineSetWHM;
    private boolean annotationsLoaded;
    
    private DocFilter docFilter;

    /** Classes that have been warned about overriding asynchronousOpen() */
    private static final Set<Class> warnedClasses = new WeakSet<Class>();
    
    /** Creates new CloneableEditorSupport attached to given environment.
    *
    * @param env environment that is source of all actions around the

        }
        
        if (undoRedo == null) {
            UndoRedo.Manager mgr = createUndoRedoManager();
            if (!(mgr instanceof UndoRedoManager)) {
                ERR.info("createUndoRedoManager(): ignoring created instance of class " + // NOI18N
                        mgr.getClass() + " since CloneableEditorSupport requires instance of " + // NOI18N"
                        UndoRedoManager.class.getName() + "\n"); // NOI18N
                mgr = new UndoRedoManager(this);
            }
            undoRedo = (UndoRedoManager) mgr;
        }

        return undoRedo;
    }
    
    UndoRedoManager getUndoRedoManager() {
        return (UndoRedoManager) getUndoRedo();
    }

    /** Provides access to position manager for the document.
    * It maintains a set of positions even the document is in memory

                                                               // atomic action has finished
                                                               // definitively sooner than leaving lock section
                                                               // and notifying al waiters, see #47022
                                                               getUndoRedoManager().markSavepoint();
                                                               getDoc().addUndoableEditListener(getUndoRedo());
                                                               d = getDoc();
                                                           } catch (DelegateIOExc t) {

            } else {
                d.putProperty("modificationListener", null); // NOI18N
            }
        }

        if (add) {
            if (d instanceof AbstractDocument) {
                AbstractDocument aDoc = (AbstractDocument) d;
                DocumentFilter origFilter = aDoc.getDocumentFilter();
                docFilter = new DocFilter(origFilter);
                aDoc.setDocumentFilter(docFilter);
            } else { // Put property for non-AD
                DocumentFilter origFilter = (DocumentFilter) d.getProperty(DocumentFilter.class);
                docFilter = new DocFilter(origFilter);
                d.putProperty(DocumentFilter.class, docFilter);
            }
            d.addDocumentListener(getListener());


        } else { // remove filter
            if (docFilter != null) {
                if (d instanceof AbstractDocument) {
                    AbstractDocument aDoc = (AbstractDocument) d;
                    aDoc.setDocumentFilter(docFilter.origFilter);
                } else { // Put property for non-AD
                    d.putProperty(DocumentFilter.class, docFilter.origFilter);
                }
                docFilter = null;
            }
            d.removeDocumentListener(getListener());
        }
    }


                        }
                    }

                    getUndoRedoManager().markSavepoint();
                    getUndoRedo().undoableEditHappened(new UndoableEditEvent(this, new BeforeSaveEdit(lastSaveTime)));

                    // update cached info about lines
                    updateLineSet(true);

        // Run before-save actions
        Runnable beforeSaveRunnable = (Runnable) myDoc.getProperty("beforeSaveRunnable");
        if (beforeSaveRunnable != null) {
            undoRedo.setPerformingSaveActions(true);
            try {
                beforeSaveRunnable.run();
            } finally {
                undoRedo.setPerformingSaveActions(false);
            }
        }

        SaveAsReader saveAsReader = new SaveAsReader();

    /** Test whether the document is ready.
    * @return <code>true</code> if document is ready
    */
    boolean isDocumentReady() {
        CloneableEditorSupport redirect = CloneableEditorSupportRedirector.findRedirect(this);
        if (redirect != null) {
            return redirect.isDocumentReady();
        }
        return documentStatus == DOCUMENT_READY;
    }
    
    /**
    * Set the MIME type for the document.
    * @param s the new MIME type

    * @return the undo/redo manager
    */
    protected UndoRedo.Manager createUndoRedoManager() {
        return new UndoRedoManager(this);
    }

    /** Returns an InputStream which reads the current data from this editor, taking into

                                                 // XXX do this from AWT???
                                                 ERR.fine("task-discardAllEdits");
                                                 getUndoRedo().discardAllEdits();
                                                 getUndoRedoManager().markSavepoint();
                                                 ERR.fine("task-check already modified");
                                                 // #57104 - if modified previously now it should become unmodified
                                                 if (isAlreadyModified()) {

     * @return true if the modification was allowed, false if it should be prohibited
     */
    final boolean callNotifyModified() {
        if (!isAlreadyModified() && !documentReloading) {
        // to prevent infinite undoing which could happen now due to fix #56963
        // (undoable edit being undone in the document notifies
        // document's modification listener to mark the file as modified).
        // Maybe clearing alreadyModified flag
        // AFTER revertPreviousOrUpcomingUndo() could suffice as well
        // instead of the revertingUndoOrReloading flag.
        // Also notifyModified() is not called during reloadDocument()
        // to prevent situation when output stream is taken from the file
        // (for which CloneableEditorSupport exists) under file's lock
        // and once closed (still under file's lock) the CES is trying to reload
        // the file calling notifyModified() that tries to grab the lock
        // and fails leading to undoing of the file's content to the one
        // before the reload.
        if (!isAlreadyModified() && !revertingUndoOrReloading) {
            setAlreadyModified(true);
            
            if (!notifyModified()) {
                ERR.log(Level.INFO,"callNotifyModified notifyModified returns false this:" + getClass().getName());
                setAlreadyModified(false);
                revertingUndoOrReloading = true;
                revertPreviousOrUpcomingUndo();
                revertingUndoOrReloading = false;

                return false;
            }
        }

        return true;
    }

    /** Resets listening on <code>UndoRedo</code>,
     * and in case next undo edit comes, schedules processesing of it.
     * Used to revert modification e.g. of document of [read-only] env. */
    private void revertPreviousOrUpcomingUndo() {
        UndoRedo.Manager ur = getUndoRedo();
        Listener l = getListener();

        if (Boolean.TRUE.equals(getDocument().getProperty("supportsModificationListener"))) { // NOI18N

            // revert undos now
            SearchBeforeModificationEdit edit = new SearchBeforeModificationEdit();

            try {
                for (;;) {
                    edit.delegate = null;
                    ur.undoableEditHappened(new UndoableEditEvent(getDocument(), edit));

                    if (edit.delegate == null) break; // no previous edit
                    
                    if (edit.delegate instanceof BeforeModificationEdit) {
                        if (edit.delegate != null) {
                            // undo anyway
                            ur.undo();
                        }

                        // and exit
                        break;
                    }

                    if (edit.delegate instanceof BeforeSaveEdit) {
                        break;
                    }

                    // otherwise remove the edit 
                    ur.undo();
                }
            } catch (CannotUndoException ex) {
                // ok, cannot undo, just ignore this
            }
        } else {
            // revert upcomming undo
            l.setUndoTask(new Runnable() {
                    public void run() {
                        undoAll();
                    }
                }
            );
            ur.addChangeListener(l);
        }
    }

    /** Creates <code>Runnable</code> which tries to make one undo. Helper method.
     * @see #revertUpcomingUndo */
    final void undoAll() {
        StyledDocument sd = getDoc();

        if (sd == null) {
            // #20883, doc can be null(!), doCloseDocument was faster.
            return;
        }

        UndoRedo ur = getUndoRedo();
        addRemoveDocListener(sd, false);

        try {
            if (ur.canUndo()) {
                ur.undo();
            }
        } catch (CannotUndoException cne) {
            ERR.log(Level.INFO, null, cne);
        } finally {
            addRemoveDocListener(sd, true);
        }
    }

    /** Method that is called when all components of the support are
    * closed. The default implementation closes the document.
    *

    /** The listener that this support uses to communicate with
     * document, environment and also temporarilly on undoredo.
     */
    private final class Listener extends Object implements PropertyChangeListener, DocumentListener,
        Runnable, java.beans.VetoableChangeListener {

        /** Stores exception from loadDocument, can be set in run method */
        private IOException loadExc;

        /** revert modification if asked */
        private boolean revertModifiedFlag;

        /** Stores exception from loadDocument, can be set in run method */
        private IOException loadExc;

        /** Stores temporarilly undo task for reverting prohibited changes.
         * @see CloneableEditorSupport#createUndoTask */
        private Runnable undoTask;

        Listener() {
        }


            //            loadExc = null;
            return ret;
        }
        
        public void insertUpdate(DocumentEvent evt) {
            callNotifyModified();
            revertModifiedFlag = false;
        }

        public void removeUpdate(DocumentEvent evt) {
            callNotifyModified();
            revertModifiedFlag = false;
        public void stateChanged(ChangeEvent evt) {
            getUndoRedo().removeChangeListener(this);
            undoTask.run();

            //SwingUtilities.invokeLater(undoTask);
            undoTask = null;
        }
        
        public void changedUpdate(DocumentEvent evt) {
        * @param ev event describing the action
        */
        public void changedUpdate(DocumentEvent ev) {
            //modified(); (bugfix #1492)
        }

        public void vetoableChange(PropertyChangeEvent evt)

            }
        }

        /** Gives notification that there was an insert into the document.
        * @param ev event describing the action
        */
        public void insertUpdate(DocumentEvent ev) {
            callNotifyModified();
            revertModifiedFlag = false;
        }

        /** Gives notification that a portion of the document has been removed.
        * @param ev event describing the action
        */
        public void removeUpdate(DocumentEvent ev) {
            callNotifyModified();
            revertModifiedFlag = false;
        }

        /** Listener to changes in the Env.
        */
        public void propertyChange(PropertyChangeEvent ev) {

                                    }

                                    // #57104 - avoid notifyModified() which takes file lock
                                    documentReloading = true;
                                    NbDocument.runAtomic(sd, this);
                                    documentReloading = false; // #57104

                                    return;
                                }


            setLastSaveTime(cesEnv().getTime().getTime());

            // Insert before-save undo event to enable unmodifying undo
            getUndoRedo().undoableEditHappened(new UndoableEditEvent(this, new BeforeSaveEdit(lastSaveTime)));

            // Start listening on changes in document
            addRemoveDocListener(getDoc(), true);
        }

        //        }
    }

    /** Generic undoable edit that delegates to the given undoable edit. */
    private class FilterUndoableEdit
            implements UndoableEdit, UndoGroupManager.SeparateEdit
    {
        protected UndoableEdit delegate;

        FilterUndoableEdit() {
        }

        public void undo() throws CannotUndoException {
            if (delegate != null) {
                delegate.undo();
            }
        }

        public boolean canUndo() {
            if (delegate != null) {
                return delegate.canUndo();
            } else {
                return false;
            }
        }

        public void redo() throws CannotRedoException {
            if (delegate != null) {
                delegate.redo();
            }
        }

        public boolean canRedo() {
            if (delegate != null) {
                return delegate.canRedo();
            } else {
                return false;
            }
        }

        public void die() {
            if (delegate != null) {
                delegate.die();
            }
        }

        public boolean addEdit(UndoableEdit anEdit) {
            if (delegate != null) {
                return delegate.addEdit(anEdit);
            } else {
                return false;
            }
        }

        public boolean replaceEdit(UndoableEdit anEdit) {
            if (delegate != null) {
                return delegate.replaceEdit(anEdit);
            } else {
                return false;
            }
        }

        public boolean isSignificant() {
            if (delegate != null) {
                return delegate.isSignificant();
            } else {
                return true;
            }
        }

        public String getPresentationName() {
            if (delegate != null) {
                return delegate.getPresentationName();
            } else {
                return ""; // NOI18N
            }
        }

        public String getUndoPresentationName() {
            if (delegate != null) {
                return delegate.getUndoPresentationName();
            } else {
                return ""; // NOI18N
            }
        }

        public String getRedoPresentationName() {
            if (delegate != null) {
                return delegate.getRedoPresentationName();
            } else {
                return ""; // NOI18N
            }
        }
    }

    /** Undoable edit that is put before the savepoint. Its replaceEdit()
     * method will consume and wrap the edit that precedes the save.
     * If the edit is added to the begining of the queue then
     * the isSignificant() implementation guarantees that the edit
     * will not be removed from the queue.
     * When redone it marks the document as not modified.
     */
    private class BeforeSaveEdit extends FilterUndoableEdit {
        private long saveTime;

        BeforeSaveEdit(long saveTime) {
            this.saveTime = saveTime;
        }

        @Override
        public boolean replaceEdit(UndoableEdit anEdit) {
            if (delegate == null) {
                delegate = anEdit;

                return true; // signal consumed
            }

            return false;
        }

        @Override
        public boolean addEdit(UndoableEdit anEdit) {
            if (!(anEdit instanceof BeforeModificationEdit) && !(anEdit instanceof SearchBeforeModificationEdit)) {
                /* UndoRedo.addEdit() must not be done lazily
                 * because the edit must be "inserted" before the current one.
                 */
                getUndoRedo().addEdit(new BeforeModificationEdit(saveTime, anEdit));

                return true;
            }

            return false;
        }

        @Override
        public void redo() {
            super.redo();

            if (saveTime == lastSaveTime) {
                justRevertedToNotModified = true;
            }
        }

        @Override
        public boolean isSignificant() {
            return (delegate != null);
        }
    }

    /** Edit that is created by wrapping the given edit.
     * When undone it marks the document as not modified.
     */
    private class BeforeModificationEdit extends FilterUndoableEdit {
        private long saveTime;

        BeforeModificationEdit(long saveTime, UndoableEdit delegate) {
            this.saveTime = saveTime;
            this.delegate = delegate;
            ERR.log(Level.FINEST, null, new Exception("new BeforeModificationEdit(" + saveTime +")")); // NOI18N
        }

        @Override
        public boolean addEdit(UndoableEdit anEdit) {
            if ((delegate == null) && !(anEdit instanceof SearchBeforeModificationEdit)) {
                delegate = anEdit;

                return true;
            }

            return delegate.addEdit(anEdit);
        }

        @Override
        public void undo() {
            super.undo();

            boolean res = saveTime == lastSaveTime;
            ERR.fine("Comparing saveTime and lastSaveTime: " + saveTime + "==" + lastSaveTime + " is " + res); // NOI18N
            if (res) {
                justRevertedToNotModified = true;
            }
        }
    }

    /** This edit is used to search for BeforeModificationEdit in UndoRedo
     * manager. This is not much nice solution, but well, there is not
     * much other chances to get inside UndoRedo.
     */
    private class SearchBeforeModificationEdit extends FilterUndoableEdit {
        SearchBeforeModificationEdit() {
        }

        @Override
        public boolean replaceEdit(UndoableEdit anEdit) {
            if (delegate == null) {
                delegate = anEdit;

                return true; // signal consumed
            }

            return false;
        }
    }

    /** An improved version of UndoRedo manager that locks document before
     * doing any other operations.
     */
    private final static class CESUndoRedoManager extends UndoGroupManager {
        private CloneableEditorSupport support;

        public CESUndoRedoManager(CloneableEditorSupport c) {
            this.support = c;
            super.setLimit(1000);
        }

        @Override
        public void redo() throws javax.swing.undo.CannotRedoException {
            final StyledDocument myDoc = support.getDocument();

            if (myDoc == null) {
                throw new javax.swing.undo.CannotRedoException(); // NOI18N
            }
            
            support.justRevertedToNotModified = false;
            new RenderUndo(0, myDoc);

            if (support.justRevertedToNotModified && support.isAlreadyModified()) {
                support.callNotifyUnmodified();
            }
        }

        @Override
        public void undo() throws javax.swing.undo.CannotUndoException {
            final StyledDocument myDoc = support.getDocument();

            if (myDoc == null) {
                throw new javax.swing.undo.CannotUndoException(); // NOI18N
            }

            support.justRevertedToNotModified = false;
            new RenderUndo(1, myDoc);

            if (support.justRevertedToNotModified && support.isAlreadyModified()) {
                support.callNotifyUnmodified();
            }
        }

        @Override
        public boolean canRedo() {
            final StyledDocument myDoc = support.getDocument();

            return new RenderUndo(2, myDoc, 0, true).booleanResult;
        }

        @Override
        public boolean canUndo() {
            final StyledDocument myDoc = support.getDocument();

            return new RenderUndo(3, myDoc, 0, true).booleanResult;
        }

        @Override
        public int getLimit() {
            final StyledDocument myDoc = support.getDocument();

            return new RenderUndo(4, myDoc).intResult;
        }

        @Override
        public void discardAllEdits() {
            final StyledDocument myDoc = support.getDocument();
            new RenderUndo(5, myDoc);
            // Insert before-save undo event to enable unmodifying undo
            undoableEditHappened(new UndoableEditEvent(support, support.new BeforeSaveEdit(support.lastSaveTime)));
        }

        @Override
        public void setLimit(int l) {
            final StyledDocument myDoc = support.getDocument();
            new RenderUndo(6, myDoc, l);
        }

        @Override
        public boolean canUndoOrRedo() {
            final StyledDocument myDoc = support.getDocument();

            return new RenderUndo(7, myDoc, 0, true).booleanResult;
        }

        @Override
        public java.lang.String getUndoOrRedoPresentationName() {
            if (support.isDocumentReady()) {
                final StyledDocument myDoc = support.getDocument();
                return new RenderUndo(8, myDoc, 0, true).stringResult;
            } else {
                return "";
            }
        }

        @Override
        public java.lang.String getRedoPresentationName() {
            if (support.isDocumentReady()) {
                final StyledDocument myDoc = support.getDocument();
                return new RenderUndo(9, myDoc, 0, true).stringResult;
            } else {
                return "";
            }
        }

        @Override
        public java.lang.String getUndoPresentationName() {
            if (support.isDocumentReady()) {
                final StyledDocument myDoc = support.getDocument();
                return new RenderUndo(10, myDoc, 0, true).stringResult;
            } else {
                return "";
            }
        }

        @Override
        public void undoOrRedo() throws javax.swing.undo.CannotUndoException, javax.swing.undo.CannotRedoException {
            final StyledDocument myDoc = support.getDocument();

            if (myDoc == null) {
                throw new javax.swing.undo.CannotUndoException(); // NOI18N
            }

            support.justRevertedToNotModified = false;
            new RenderUndo(11, myDoc);

            if (support.justRevertedToNotModified && support.isAlreadyModified()) {
                support.callNotifyUnmodified();
            }
        }

        private final class RenderUndo implements Runnable {
            private final int type;
            public boolean booleanResult;
            public int intResult;
            public String stringResult;
            private final boolean readonly;

            public RenderUndo(int type, StyledDocument doc) {
                this(type, doc, 0);
            }

            public RenderUndo(int type, StyledDocument doc, int intValue) {
                this(type, doc, intValue, false);
            }

            public RenderUndo(int type, StyledDocument doc, int intValue, boolean readonly) {
                this.type = type;
                this.intResult = intValue;
                this.readonly = readonly;

                if (!readonly && (doc instanceof NbDocument.WriteLockable)) {
                    ((NbDocument.WriteLockable) doc).runAtomic(this);
                } else {
                    if (readonly && doc != null) {
                        doc.render(this);
                    } else {
                        // if the document is not one of "NetBeans ready"
                        // that supports locking we do not have many
                        // chances to do something. Maybe check for AbstractDocument
                        // and call writeLock using reflection, but better than
                        // that, let's leave this simple for now and wait for
                        // bug reports (if any appear)
                        run();
                    }
                }
            }

            public void run() {
                switch (type) {
                case 0:
                    CESUndoRedoManager.super.redo();

                    break;

                case 1:
                    CESUndoRedoManager.super.undo();

                    break;

                case 2:
                    booleanResult = CESUndoRedoManager.super.canRedo();

                    break;

                case 3:
                    booleanResult = CESUndoRedoManager.super.canUndo();

                    break;

                case 4:
                    intResult = CESUndoRedoManager.super.getLimit();

                    break;

                case 5:
                    CESUndoRedoManager.super.discardAllEdits();

                    break;

                case 6:
                    CESUndoRedoManager.super.setLimit(intResult);

                    break;

                case 7:
                    CESUndoRedoManager.super.canUndoOrRedo();

                    break;

                case 8:
                    stringResult = CESUndoRedoManager.super.getUndoOrRedoPresentationName();

                    break;

                case 9:
                    stringResult = CESUndoRedoManager.super.getRedoPresentationName();

                    break;

                case 10:
                    stringResult = CESUndoRedoManager.super.getUndoPresentationName();

                    break;

                case 11:
                    CESUndoRedoManager.super.undoOrRedo();

                    break;

                default:
                    throw new IllegalArgumentException("Unknown type: " + type);
                }
            }
        }
    }

    /**
     * <tt>UndoGroupManager</tt> extends {@link UndoManager}
     * and allows explicit control of what
     * <tt>UndoableEdit</tt>s are coalesced into compound edits,
     * rather than using the rules defined by the edits themselves.
     * Groups are defined using BEGIN_COMMIT_GROUP and END_COMMIT_GROUP.
     * Send these to UndoableEditListener. These must always be paired.
     * <p>
     * These use cases are supported.
     * </p>
     * <ol>
     * <li> Default behavior is defined by {@link UndoManager}.</li>
     * <li> <tt>UnddoableEdit</tt>s issued between {@link #BEGIN_COMMIT_GROUP}
     * and {@link #END_COMMIT_GROUP} are placed into a single
     * {@link CompoundEdit}.
     * Thus <tt>undo()</tt> and <tt>redo()</tt> treat them 
     * as a single undo/redo.</li>
     * <li>BEGIN/END nest.</li>
     * <li> Issue MARK_COMMIT_GROUP to commit accumulated
     * <tt>UndoableEdit</tt>s into a single <tt>CompoundEdit</tt>
     * and to continue accumulating;
     * an application could do this at strategic points, such as EndOfLine
     * input or cursor movement.</li>
     * </ol>
     * @see UndoManager
     */
    private static class UndoGroupManager extends UndoRedo.Manager {
        /** signals that edits are being accumulated */
        private int buildUndoGroup;
        /** accumulate edits here in undoGroup */
        private CompoundEdit undoGroup;
        /**
         * Signal that nested group started and that current undo group
         * must be committed if edit is added. Then can avoid doing the commit
         * if the nested group turns out to be empty.
         */
        private int needsNestingCommit;

        /**
         * Start a group of edits which will be committed as a single edit
         * for purpose of undo/redo.
         * Nesting semantics are that any BEGIN_COMMIT_GROUP and
         * END_COMMIT_GROUP delimits a commit-group, unless the group is
         * empty in which case the begin/end is ignored.
         * While coalescing edits, any undo/redo/save implicitly delimits
         * a commit-group.
         */
        static final UndoableEdit BEGIN_COMMIT_GROUP = new CommitGroupEdit();
        /** End a group of edits. */
        static final UndoableEdit END_COMMIT_GROUP = new CommitGroupEdit();
        /**
         * Any coalesced edits become a commit-group and a new commit-group
         * is started.
         */
        static final UndoableEdit MARK_COMMIT_GROUP = new CommitGroupEdit();

        /** SeparateEdit tags an UndoableEdit so the
         * UndoGroupManager does not coalesce it.
         */
        interface SeparateEdit {
        }

        private static class CommitGroupEdit extends AbstractUndoableEdit {
            @Override
            public boolean isSignificant() {
                return false;
            }

            @Override
            public boolean canRedo()
            {
                return true;
            }

            @Override
            public boolean canUndo()
            {
                return true;
            }
        }

        @Override
        public void undoableEditHappened(UndoableEditEvent ue)
        {
            if(ue.getEdit() == BEGIN_COMMIT_GROUP) {
                beginUndoGroup();
            } else if(ue.getEdit() == END_COMMIT_GROUP) {
                endUndoGroup();
            } else if(ue.getEdit() == MARK_COMMIT_GROUP) {
                commitUndoGroup();
            } else {
                super.undoableEditHappened(ue);
            }
        }

        /**
         * Direct this <tt>UndoGroupManager</tt> to begin coalescing any
         * <tt>UndoableEdit</tt>s that are added into a <tt>CompoundEdit</tt>.
         * <p>If edits are already being coalesced and some have been 
         * accumulated, they are flagged for commitment as an atomic group and
         * a new group will be started.
         * @see #addEdit
         * @see #endUndoGroup
         */
        private synchronized void beginUndoGroup() {
            if(undoGroup != null)
                needsNestingCommit++;
            ERR.log(Level.FINE, "beginUndoGroup: nesting {0}", buildUndoGroup);
            buildUndoGroup++;
        }

        /**
         * Direct this <tt>UndoGroupManager</tt> to stop coalescing edits.
         * Until <tt>beginUndoGroupManager</tt> is invoked,
         * any received <tt>UndoableEdit</tt>s are added singly.
         * <p>
         * This has no effect if edits are not being coalesced, for example
         * if <tt>beginUndoGroup</tt> has not been called.
         */
        private synchronized void endUndoGroup() {
            buildUndoGroup--;
            ERR.log(Level.FINE, "endUndoGroup: nesting {0}", buildUndoGroup);
            if(buildUndoGroup < 0) {
                ERR.log(Level.INFO, null, new Exception("endUndoGroup without beginUndoGroup"));
                // slam buildUndoGroup to 0 to disable nesting
                buildUndoGroup = 0;
            }
            if(needsNestingCommit <= 0)
                commitUndoGroup();
            if(--needsNestingCommit < 0)
                needsNestingCommit = 0;
        }

        /**
         * Commit any accumulated <tt>UndoableEdit</tt>s as an atomic
         * <tt>undo</tt>/<tt>redo</tt> group. {@link CompoundEdit#end}
         * is invoked on the <tt>CompoundEdit</tt> and it is added as a single
         * <tt>UndoableEdit</tt> to this <tt>UndoManager</tt>.
         * <p>
         * If edits are currently being coalesced, a new undo group is started.
         * This has no effect if edits are not being coalesced, for example
         * <tt>beginUndoGroup</tt> has not been called.
         */
        private synchronized void commitUndoGroup() {
            if(undoGroup == null) {
                return;
            }

            // undoGroup is being set to null,
            // needsNestingCommit has no meaning now
            needsNestingCommit = 0;

            // super.addEdit may end up in this.addEdit,
            // so buildUndoGroup must be false
            int saveBuildUndoGroup = buildUndoGroup;
            buildUndoGroup = 0;

            undoGroup.end();
            super.addEdit(undoGroup);
            undoGroup = null;

            buildUndoGroup = saveBuildUndoGroup;
        }

        /** Add this edit separately, not part of a group.
         * @return super.addEdit
         */
        private boolean commitAddEdit(UndoableEdit anEdit) {
            commitUndoGroup();

            int saveBuildUndoGroup = buildUndoGroup;
            buildUndoGroup = 0;
            boolean f = super.addEdit(anEdit);
            //boolean f = addEdit(undoGroup);
            buildUndoGroup = saveBuildUndoGroup;
            return f;
        }

        /**
         * If there's a pending undo group that needs to be committed
         * then commit it.
         * If this <tt>UndoManager</tt> is coalescing edits then add
         * <tt>anEdit</tt> to the accumulating <tt>CompoundEdit</tt>.
         * Otherwise, add it to this UndoManager. In either case the
         * edit is saved for later <tt>undo</tt> or <tt>redo</tt>.
         * @return {@inheritDoc}
         * @see #beginUndoGroup
         * @see #endUndoGroup
         */
        @Override
        public synchronized boolean addEdit(UndoableEdit anEdit) {
            if(!isInProgress())
                return false;

            if(needsNestingCommit > 0) {
                commitUndoGroup();
            }

            if(buildUndoGroup > 0) {
                if(anEdit instanceof SeparateEdit)
                    return commitAddEdit(anEdit);
                if(undoGroup == null)
                    undoGroup = new CompoundEdit();
                return undoGroup.addEdit(anEdit);
            } else {
                return super.addEdit(anEdit);
            }
        }

        @Override
        public synchronized void discardAllEdits() {
            commitUndoGroup();
            super.discardAllEdits();
        }

        //
        // TODO: limits
        //

        @Override
        public synchronized void undoOrRedo() {
            commitUndoGroup();
            super.undoOrRedo();
        }

        @Override
        public synchronized boolean canUndoOrRedo() {
            if(undoGroup != null)
                return true;
            return super.canUndoOrRedo();
        }

        @Override
        public synchronized void undo() {
            commitUndoGroup();
            super.undo();
        }

        @Override
        public synchronized boolean canUndo() {
            if(undoGroup != null)
                return true;
            return super.canUndo();
        }

        @Override
        public synchronized void redo() {
            if(undoGroup != null)
                throw new CannotRedoException();
            super.redo();
        }

        @Override
        public synchronized boolean canRedo() {
            if(undoGroup != null)
                return false;
            return super.canRedo();
        }

        @Override
        public synchronized void end() {
            commitUndoGroup();
            super.end();
        }

        @Override
        public synchronized String getUndoOrRedoPresentationName() {
            if(undoGroup != null)
                return undoGroup.getUndoPresentationName();
            return super.getUndoOrRedoPresentationName();
        }

        @Override
        public synchronized String getUndoPresentationName() {
            if(undoGroup != null)
                return undoGroup.getUndoPresentationName();
            return super.getUndoPresentationName();
        }

        @Override
        public synchronized String getRedoPresentationName() {
            if(undoGroup != null)
                return undoGroup.getRedoPresentationName();
            return super.getRedoPresentationName();
        }

        @Override
        public boolean isSignificant() {
            if(undoGroup != null && undoGroup.isSignificant()) {
                return true;
            }
            return super.isSignificant();
        }

        @Override
        public synchronized void die() {
            commitUndoGroup();
            super.die();
        }

        @Override
        public String getPresentationName() {
            if(undoGroup != null)
                return undoGroup.getPresentationName();
            return super.getPresentationName();
        }

        // The protected methods are only accessed from
        // synchronized methods that do commitUndoGroup
        // so they do not need to be overridden in this class
    }

    /** Special runtime exception that holds the original I/O failure.
     */
    static final class DelegateIOExc extends IllegalStateException {

        }
    }

    private final class DocFilter extends DocumentFilter {
        
        final DocumentFilter origFilter;
        
        DocFilter(DocumentFilter origFilter) {
            this.origFilter = origFilter;
        }

        @Override
        public void insertString(FilterBypass fb, int offset, String string, AttributeSet attr) throws BadLocationException {
            boolean origModified = checkModificationAllowed(offset);
            boolean success = false;
            try {
                if (origFilter != null) {
                    origFilter.insertString(fb, offset, string, attr);
                } else {
                    super.insertString(fb, offset, string, attr);
                }
                success = true;
            } finally {
                if (!success) {
                    if (!origModified) {
                        callNotifyUnmodified();
                    }
                }
            }
        }

        @Override
        public void remove(FilterBypass fb, int offset, int length) throws BadLocationException {
            boolean origModified = checkModificationAllowed(offset);
            boolean success = false;
            try {
                if (origFilter != null) {
                    origFilter.remove(fb, offset, length);
                } else {
                    super.remove(fb, offset, length);
                }
                success = true;
            } finally {
                if (!success) {
                    if (!origModified) {
                        callNotifyUnmodified();
                    }
                }
            }
        }

        @Override
        public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
            boolean origModified = checkModificationAllowed(offset);
            boolean success = false;
            try {
                if (origFilter != null) {
                    origFilter.replace(fb, offset, length, text, attrs);
                } else {
                    super.replace(fb, offset, length, text, attrs);
                }
                success = true;
            } finally {
                if (!success) {
                    if (!origModified) {
                        callNotifyUnmodified();
                    }
                }
            }
        }
        
        private boolean checkModificationAllowed(int offset) throws BadLocationException {
            boolean alreadyModified = isAlreadyModified();
            if (!callNotifyModified()) {
                throw new BadLocationException("Modification not allowed", offset); // NOI18N
            }
            return alreadyModified;
        }

    }

}

Lines 99-110 Link Here

(-)a/openide.text/src/org/openide/text/FilterDocument.java (-1 / +8 lines)
99		99
100	/* Gets document property by key */	100	/* Gets document property by key */
101	public Object getProperty(Object key) {	101	public Object getProperty(Object key) {
		102	if (key == DocumentFilter.class && original instanceof AbstractDocument) {
		103	return ((AbstractDocument)original).getDocumentFilter();
		104	}
102	return original.getProperty(key);	105	return original.getProperty(key);
103	}	106	}
104		107
105	/* Puts new property of document */	108	/* Puts new property of document */
106	public void putProperty(Object key, Object value) {	109	public void putProperty(Object key, Object value) {
107	original.putProperty(key, value);	110	if (key == DocumentFilter.class && original instanceof AbstractDocument) {
		111	((AbstractDocument)original).setDocumentFilter((DocumentFilter)value);
		112	} else {
		113	original.putProperty(key, value);
		114	}
108	}	115	}
109		116
110	/* Removes portion of a document */	117	/* Removes portion of a document */




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.openide.text;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.event.UndoableEditEvent;
import javax.swing.undo.*;
import org.openide.awt.UndoRedo;


/**
 * <tt>UndoGroupManager</tt> extends {@link UndoManager}
 * and allows explicit control of what
 * <tt>UndoableEdit</tt>s are coalesced into compound edits,
 * rather than using the rules defined by the edits themselves.
 * Groups are defined using BEGIN_COMMIT_GROUP and END_COMMIT_GROUP.
 * Send these to UndoableEditListener. These must always be paired.
 * <p>
 * These use cases are supported.
 * </p>
 * <ol>
 * <li> Default behavior is defined by {@link UndoManager}.</li>
 * <li> <tt>UnddoableEdit</tt>s issued between {@link #BEGIN_COMMIT_GROUP}
 * and {@link #END_COMMIT_GROUP} are placed into a single
 * {@link CompoundEdit}.
 * Thus <tt>undo()</tt> and <tt>redo()</tt> treat them 
 * as a single undo/redo.</li>
 * <li>BEGIN/END nest.</li>
 * <li> Issue MARK_COMMIT_GROUP to commit accumulated
 * <tt>UndoableEdit</tt>s into a single <tt>CompoundEdit</tt>
 * and to continue accumulating;
 * an application could do this at strategic points, such as EndOfLine
 * input or cursor movement.</li>
 * </ol>
 * @see UndoManager
 * @author Ernie Rael
 */
class UndoGroupManager extends UndoRedo.Manager {

    // -J-Dorg.openide.text.UndoGroupManager.level=FINE
    private static final Logger LOG = Logger.getLogger(UndoGroupManager.class.getName());

    /** signals that edits are being accumulated */
    private int buildUndoGroup;

    /** accumulate edits here in undoGroup */
    private CompoundEdit undoGroup;

    /**
     * Signal that nested group started and that current undo group
     * must be committed if edit is added. Then can avoid doing the commit
     * if the nested group turns out to be empty.
     */
    private int needsNestingCommit;

    /**
     * Start a group of edits which will be committed as a single edit
     * for purpose of undo/redo.
     * Nesting semantics are that any BEGIN_COMMIT_GROUP and
     * END_COMMIT_GROUP delimits a commit-group, unless the group is
     * empty in which case the begin/end is ignored.
     * While coalescing edits, any undo/redo/save implicitly delimits
     * a commit-group.
     */
    static final UndoableEdit BEGIN_COMMIT_GROUP = new CommitGroupEdit();

    /** End a group of edits. */
    static final UndoableEdit END_COMMIT_GROUP = new CommitGroupEdit();
    
    /**
     * Any coalesced edits become a commit-group and a new commit-group
     * is started.
     */
    static final UndoableEdit MARK_COMMIT_GROUP = new CommitGroupEdit();

    private static class CommitGroupEdit extends AbstractUndoableEdit {
        @Override
        public boolean isSignificant() {
            return false;
        }

        @Override
        public boolean canRedo()
        {
            return true;
        }

        @Override
        public boolean canUndo()
        {
            return true;
        }
    }

    @Override
    public void undoableEditHappened(UndoableEditEvent ue)
    {
        if(ue.getEdit() == BEGIN_COMMIT_GROUP) {
            beginUndoGroup();
        } else if(ue.getEdit() == END_COMMIT_GROUP) {
            endUndoGroup();
        } else if(ue.getEdit() == MARK_COMMIT_GROUP) {
            commitUndoGroup();
        } else {
            super.undoableEditHappened(ue);
        }
    }

    /**
     * Direct this <tt>UndoGroupManager</tt> to begin coalescing any
     * <tt>UndoableEdit</tt>s that are added into a <tt>CompoundEdit</tt>.
     * <p>If edits are already being coalesced and some have been 
     * accumulated, they are flagged for commitment as an atomic group and
     * a new group will be started.
     * @see #addEdit
     * @see #endUndoGroup
     */
    private synchronized void beginUndoGroup() {
        if(undoGroup != null)
            needsNestingCommit++;
        LOG.log(Level.FINE, "beginUndoGroup: nesting {0}", buildUndoGroup);
        buildUndoGroup++;
    }

    /**
     * Direct this <tt>UndoGroupManager</tt> to stop coalescing edits.
     * Until <tt>beginUndoGroupManager</tt> is invoked,
     * any received <tt>UndoableEdit</tt>s are added singly.
     * <p>
     * This has no effect if edits are not being coalesced, for example
     * if <tt>beginUndoGroup</tt> has not been called.
     */
    private synchronized void endUndoGroup() {
        buildUndoGroup--;
        LOG.log(Level.FINE, "endUndoGroup: nesting {0}", buildUndoGroup);
        if(buildUndoGroup < 0) {
            LOG.log(Level.INFO, null, new Exception("endUndoGroup without beginUndoGroup"));
            // slam buildUndoGroup to 0 to disable nesting
            buildUndoGroup = 0;
        }
        if(needsNestingCommit <= 0)
            commitUndoGroup();
        if(--needsNestingCommit < 0)
            needsNestingCommit = 0;
    }

    /**
     * Commit any accumulated <tt>UndoableEdit</tt>s as an atomic
     * <tt>undo</tt>/<tt>redo</tt> group. {@link CompoundEdit#end}
     * is invoked on the <tt>CompoundEdit</tt> and it is added as a single
     * <tt>UndoableEdit</tt> to this <tt>UndoManager</tt>.
     * <p>
     * If edits are currently being coalesced, a new undo group is started.
     * This has no effect if edits are not being coalesced, for example
     * <tt>beginUndoGroup</tt> has not been called.
     */
    private synchronized void commitUndoGroup() {
        if(undoGroup == null) {
            return;
        }

        // undoGroup is being set to null,
        // needsNestingCommit has no meaning now
        needsNestingCommit = 0;

        // super.addEdit may end up in this.addEdit,
        // so buildUndoGroup must be false
        int saveBuildUndoGroup = buildUndoGroup;
        buildUndoGroup = 0;

        undoGroup.end();
        super.addEdit(undoGroup);
        undoGroup = null;

        buildUndoGroup = saveBuildUndoGroup;
    }

    /** Add this edit separately, not part of a group.
     * @return super.addEdit
     */
    private boolean commitAddEdit(UndoableEdit anEdit) {
        commitUndoGroup();

        int saveBuildUndoGroup = buildUndoGroup;
        buildUndoGroup = 0;
        boolean f = super.addEdit(anEdit);
        //boolean f = addEdit(undoGroup);
        buildUndoGroup = saveBuildUndoGroup;
        return f;
    }

    /**
     * If there's a pending undo group that needs to be committed
     * then commit it.
     * If this <tt>UndoManager</tt> is coalescing edits then add
     * <tt>anEdit</tt> to the accumulating <tt>CompoundEdit</tt>.
     * Otherwise, add it to this UndoManager. In either case the
     * edit is saved for later <tt>undo</tt> or <tt>redo</tt>.
     * @return {@inheritDoc}
     * @see #beginUndoGroup
     * @see #endUndoGroup
     */
    @Override
    public synchronized boolean addEdit(UndoableEdit anEdit) {
        if(!isInProgress())
            return false;

        if(needsNestingCommit > 0) {
            commitUndoGroup();
        }

        if(buildUndoGroup > 0) {
            if(anEdit instanceof WrapUndoEdit)
                return commitAddEdit(anEdit);
            if(undoGroup == null)
                undoGroup = new CompoundEdit();
            return undoGroup.addEdit(anEdit);
        } else {
            return super.addEdit(anEdit);
        }
    }

    @Override
    public synchronized void discardAllEdits() {
        commitUndoGroup();
        super.discardAllEdits();
    }

    //
    // TODO: limits
    //

    @Override
    public synchronized void undoOrRedo() {
        commitUndoGroup();
        super.undoOrRedo();
    }

    @Override
    public synchronized boolean canUndoOrRedo() {
        if(undoGroup != null)
            return true;
        return super.canUndoOrRedo();
    }

    @Override
    public synchronized void undo() {
        commitUndoGroup();
        super.undo();
    }

    @Override
    public synchronized boolean canUndo() {
        if(undoGroup != null)
            return true;
        return super.canUndo();
    }

    @Override
    public synchronized void redo() {
        if(undoGroup != null)
            throw new CannotRedoException();
        super.redo();
    }

    @Override
    public synchronized boolean canRedo() {
        if(undoGroup != null)
            return false;
        return super.canRedo();
    }

    @Override
    public synchronized void end() {
        commitUndoGroup();
        super.end();
    }

    @Override
    public synchronized String getUndoOrRedoPresentationName() {
        if(undoGroup != null)
            return undoGroup.getUndoPresentationName();
        return super.getUndoOrRedoPresentationName();
    }

    @Override
    public synchronized String getUndoPresentationName() {
        if(undoGroup != null)
            return undoGroup.getUndoPresentationName();
        return super.getUndoPresentationName();
    }

    @Override
    public synchronized String getRedoPresentationName() {
        if(undoGroup != null)
            return undoGroup.getRedoPresentationName();
        return super.getRedoPresentationName();
    }

    @Override
    public boolean isSignificant() {
        if(undoGroup != null && undoGroup.isSignificant()) {
            return true;
        }
        return super.isSignificant();
    }

    @Override
    public synchronized void die() {
        commitUndoGroup();
        super.die();
    }

    @Override
    public String getPresentationName() {
        if(undoGroup != null)
            return undoGroup.getPresentationName();
        return super.getPresentationName();
    }

    @Override
    public final WrapUndoEdit lastEdit() { // make lastEdit() accessible
        return (WrapUndoEdit) super.lastEdit();
    }

    // The protected methods are only accessed from
    // synchronized methods that do commitUndoGroup
    // so they do not need to be overridden in this class

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.openide.text;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.text.StyledDocument;
import javax.swing.undo.*;


/**
 * An improved version of UndoRedo manager that locks document before
 * doing any other operations.
 * <br/>
 * It supports grouping of undoable edits by extending UndoGroupManager.
 * <br/>
 * It supports save actions that produce a compound undoable edit.
 * <br/>
 * 
 * <p>
 * Following requirements should be met:
 * <ul>
 *   <li>When saving document extra save actions are performed producing compound saveActionsEdit..</li>
 *   <li>When undoing just performed save the saveActionsEdit should be undone at once with the last
 *     performed edit.</li>
 *   <li>When save of the document was just performed a next edit must not be merged with last edit
 *     so that the savepoint can be retained.</li>
 *   <li></li>
 * </ul>
 * </p>
 * 
 * @author Miloslav Metelka
 * @author Jaroslav Tulach
 */
final class UndoRedoManager extends UndoGroupManager {
    
    // -J-Dorg.openide.text.UndoRedoManager.level=FINE
    private static final Logger LOG = Logger.getLogger(UndoRedoManager.class.getName());

    /**
     * Marker edit for the state when undo manager is right at the savepoint.
     * <br/>
     * Next performed edit will set afterSaveEdit field.
     */
    static final UndoableEdit SAVEPOINT = new CompoundEdit();

    CloneableEditorSupport support;
    
    /**
     * Undo edit that is right after/before "save point" in undo manager's queue.
     * <br/>
     * Subsequent addEdit(), undo() and redo() operations will modify
     * the field to point to neighbor edit of the save point.
     * <br/>
     * The field may be set to SAVEPOINT special value in case the undo manager
     * is set right to the savepoint.
     */
    UndoableEdit savepointEdit;
    
    /**
     * Whether undo manager's undo()/redo() operations currently operate before/after
     * the savepoint (when right at savepoint the value is undefined).
     */
    boolean beforeSavepoint;
    
    /**
     * Edit that was added by last performed operation (undo clears this field).
     */
    UndoableEdit lastAddedOrRedoneEdit;

    /**
     * Undoable edit created as result of running save actions by using
     * "beforeSaveRunnable" document property (See CloneableEditorSupport).
     * <br/>
     * If saving occurs right at UM.edits end (i.e. either UM.addEdit() was just performed
     * or lastAddedEdit.redo() was performed) then the save actions edit
     * is merged with the last added edit.
     * <br/>
     * If UM.edits is empty (it could possibly happen when document is not saved
     * and discardAllEdits() was called for some reason) then the save actions edit
     * is not added to UM.edits (just edit.die() is called).
     * <br/>
     * When the save actions edit is done in any other situation then it must be
     * <ul>
     *   <li>undone when the UM is at savepoint and UM.undo() or UM.redo() is done.</li>
     *   <li>redone when edit right before savepoint is redone.</li>
     *   <li>redone when edit right after savepoint is undone.</li>
     * </ul>
     */
    private CompoundEdit saveActionsEdit;
    
    /**
     * Set to true when the CES gave control to save actions that may produce
     * undoable edits which need to be coallesced into a special compoound edit.
     */
    private boolean performingSaveActions;
    
    /**
     * Flag to check whether support.notifyUnmodified() should be called
     * - it's necessary to do it outside of atomicLock acquired by DocLockedRun.
     */
    private boolean callNotifyUnmodified;


    public UndoRedoManager(CloneableEditorSupport support) {
        this.support = support;
        super.setLimit(1000);
    }
    
    void setPerformingSaveActions(boolean performingSaveActions) {
        if (performingSaveActions != this.performingSaveActions) {
            this.performingSaveActions = performingSaveActions;
            if (performingSaveActions) {
                clearSaveActionsEdit();
                saveActionsEdit = new CompoundEdit();
                checkLogOp("    NEW-saveActionsEdit", saveActionsEdit); // NOI18N
            } else { // Stop performing save actions
                saveActionsEdit.end();
                checkLogOp("    COMPLETED-saveActionsEdit", saveActionsEdit); // NOI18N
                UndoableEdit lastEdit = lastEdit();
                checkLogOp("        lastEdit", lastEdit); // NOI18N
                if (lastAddedOrRedoneEdit == lastEdit) { // At UM.edits end
                    if (lastEdit != null) { // Concatenate with last one
                        WrapUndoEdit lastWrapEdit = (WrapUndoEdit) lastEdit;
                        CompoundEdit compoundEdit = new CompoundEdit();
                        compoundEdit.addEdit(lastWrapEdit.delegate());
                        compoundEdit.addEdit(saveActionsEdit);
                        compoundEdit.end();
                        lastWrapEdit.setDelegate(compoundEdit);
                        checkLogOp("    compoundEdit", compoundEdit); // NOI18N

                    } else { // No edits present in UM.edits
                        // This state might happen when e.g. discardAllEdits() was called
                        // but the document was not at savepoint (otherwise the document
                        // would be saved so no save actions would be performed).
                        // To not make the save actions an extra edit in the UM.edits
                        // the save actions are not added to the queue.
                        saveActionsEdit.die();
                        checkLogOp("    null-lastEdit->saveActionsEdit.die", saveActionsEdit); // NOI18N
                    }
                    saveActionsEdit = null; // Save actions serviced

                } else { // Save occurred somewhere inside existing UM.edits
                    // saveActionsEdit contains changes done before save operation.
                    // To enable redo of existing changes in UM.edits
                    // this extra edit must be undone when doing undo or redo from savepoint
                    // and redone when doing undo or redo to savepoint.
                }
            }
        }
    }
    
    void markSavepoint() {
        savepointEdit = SAVEPOINT;
    }
    
    boolean isAtSavepoint() {
        return (savepointEdit == SAVEPOINT);
    }
    
    private void markSavepointAndUnmodified() {
        savepointEdit = SAVEPOINT;
        callNotifyUnmodified = true;
    }
    
    private void checkCallNotifyUnmodified() {
        if (callNotifyUnmodified) {
            callNotifyUnmodified = false;
            if (support.isAlreadyModified()) {
                support.callNotifyUnmodified();
            }
        }
    }
    
    void beforeUndoCheck(WrapUndoEdit edit) {
        if (isAtSavepoint()) { // Undoing edit right before savepoint.
            checkLogOp("beforeUndoCheck-atSavepoint", edit); // NOI18N
            if (saveActionsEdit != null) {
                checkLogOp("    saveActionsEdit.undo()", saveActionsEdit); // NOI18N
                saveActionsEdit.undo();
            }
        }
    }
    
    void afterUndoCheck(WrapUndoEdit edit) {
        if (isAtSavepoint()) { // Undoing edit right before savepoint.
            checkLogOp("afterUndoCheck-atSavepoint", edit); // NOI18N
            // saveActionsEdit already processed by checkSavepointBeforeUndo()
            beforeSavepoint = true;
            savepointEdit = edit;

        } else if (savepointEdit == edit) { // Undone to savepoint
            if (saveActionsEdit != null) {
                checkLogOp("    saveActionsEdit.redo()", saveActionsEdit); // NOI18N
                saveActionsEdit.redo();
            }
            checkLogOp("afterUndoCheck-becomesSavepoint-markUnmodified", edit); // NOI18N
            assert (!beforeSavepoint) : "Expected to be behind savepoint"; // NOI18N
            markSavepointAndUnmodified();
        }
        lastAddedOrRedoneEdit = null;
    }
    
    void beforeRedoCheck(WrapUndoEdit edit) {
        if (isAtSavepoint()) { // Redoing edit right before savepoint.
            checkLogOp("beforeRedoCheck-atSavepoint", edit); // NOI18N
            if (saveActionsEdit != null) {
                checkLogOp("    saveActionsEdit.undo()", saveActionsEdit); // NOI18N
                saveActionsEdit.undo();
            }
        }
    }

    void afterRedoCheck(WrapUndoEdit edit) {
        if (isAtSavepoint()) { // Redoing edit right before savepoint.
            checkLogOp("afterRedoCheck-atSavepoint", edit); // NOI18N
            // saveActionsEdit already processed by checkSavepointBeforeUndo()
            beforeSavepoint = false;
            savepointEdit = edit;

        } else if (savepointEdit == edit) { // Redone to savepoint
            if (saveActionsEdit != null) {
                checkLogOp("    saveActionsEdit.redo()", saveActionsEdit); // NOI18N
                saveActionsEdit.redo();
            }
            checkLogOp("afterRedoCheck-becomesSavepoint", edit); // NOI18N
            assert (beforeSavepoint) : "Expected to be before savepoint"; // NOI18N
            markSavepointAndUnmodified();
        }
        lastAddedOrRedoneEdit = edit;
    }
    
    void checkReplaceSavepointEdit(WrapUndoEdit origEdit, WrapUndoEdit newEdit) {
        if (savepointEdit == origEdit) {
            checkLogOp("checkReplaceSavepointEdit-replacedSavepointEdit", origEdit); // NOI18N
            savepointEdit = newEdit;
        }
    }
    
    void notifyWrapEditDie(UndoableEdit edit) {
        if (edit == savepointEdit) { // Savepoint neighbour died => no longer a savepoint
            checkLogOp("notifyWrapEditDie-savepoint-die", edit); // NOI18N
            savepointEdit = null;
            clearSaveActionsEdit();
        }
    }
    
    @Override
    public synchronized boolean addEdit(UndoableEdit edit) {
        // This should already be called under document's lock so DocLockedRun not necessary
        assert (edit != null) : "Cannot add null edit"; // NOI18N
        if (performingSaveActions) {
            checkLogOp("addEdit-performingSaveActions", edit); // NOI18N
            boolean added = saveActionsEdit.addEdit(edit);
            if (!added) {
                throw new IllegalStateException("Cannot add to saveActionsEdit"); // NOI18N
            }
            return added;
        }
        WrapUndoEdit wrapEdit = new WrapUndoEdit(this, edit); // Wrap the edit
        boolean added = super.addEdit(wrapEdit);
        if (isAtSavepoint()) {
            checkLogOp("addEdit-atSavepoint", wrapEdit); // NOI18N
            beforeSavepoint = false;
            savepointEdit = wrapEdit;
        } else {
            checkLogOp("addEdit", wrapEdit); // NOI18N
        }
        lastAddedOrRedoneEdit = wrapEdit;
        return added;
    }
    
    // replaceEdit() not overriden - it should return false

    @Override
    public void redo() throws javax.swing.undo.CannotRedoException {
        final StyledDocument doc = support.getDocument();
        if (doc == null) {
            throw new javax.swing.undo.CannotRedoException(); // NOI18N
        }
        new DocLockedRun(0, doc);
        checkCallNotifyUnmodified();
    }

    @Override
    public void undo() throws javax.swing.undo.CannotUndoException {
        final StyledDocument doc = support.getDocument();
        if (doc == null) {
            throw new javax.swing.undo.CannotUndoException(); // NOI18N
        }
        new DocLockedRun(1, doc);
        checkCallNotifyUnmodified();
    }

    @Override
    public boolean canRedo() {
        return new DocLockedRun(2, support.getDocument(), 0, true).booleanResult;
    }

    @Override
    public boolean canUndo() {
        return new DocLockedRun(3, support.getDocument(), 0, true).booleanResult;
    }

    @Override
    public int getLimit() {
        return new DocLockedRun(4, support.getDocument()).intResult;
    }

    @Override
    public void discardAllEdits() {
        new DocLockedRun(5, support.getDocument());
    }
    
    private void clearSaveActionsEdit() {
        if (saveActionsEdit != null) {
            checkLogOp("    saveActionsEdit-die", saveActionsEdit); // NOI18N
            saveActionsEdit.die();
            saveActionsEdit = null;
        }
    }

    @Override
    public void setLimit(int l) {
        new DocLockedRun(6, support.getDocument(), l);
    }

    @Override
    public boolean canUndoOrRedo() {
        return new DocLockedRun(7, support.getDocument(), 0, true).booleanResult;
    }

    @Override
    public java.lang.String getUndoOrRedoPresentationName() {
        if (support.isDocumentReady()) {
            return new DocLockedRun(8, support.getDocument(), 0, true).stringResult;
        } else {
            return "";
        }
    }

    @Override
    public java.lang.String getRedoPresentationName() {
        if (support.isDocumentReady()) {
            return new DocLockedRun(9, support.getDocument(), 0, true).stringResult;
        } else {
            return "";
        }
    }

    @Override
    public java.lang.String getUndoPresentationName() {
        if (support.isDocumentReady()) {
            return new DocLockedRun(10, support.getDocument(), 0, true).stringResult;
        } else {
            return "";
        }
    }

    @Override
    public void undoOrRedo() throws javax.swing.undo.CannotUndoException, javax.swing.undo.CannotRedoException {
        super.undoOrRedo();
    }
    
    static String editToString(UndoableEdit edit) {
        if (edit instanceof WrapUndoEdit) {
            return toStringTerse(edit) + "->" + toStringTerse(((WrapUndoEdit)edit).delegate()); // NOI18N
        } else {
            return toStringTerse(edit);
        }
    }
    
    static String toStringTerse(Object o) {
        if (o != null) {
            String clsName = o.getClass().getName();
            return clsName.substring(clsName.lastIndexOf('.') + 1) + "@" + System.identityHashCode(o); // NOI18N
        } else {
            return "null"; // NOI18N
        }
    }
    
    static void checkLogOp(String op, UndoableEdit edit) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine(op + ": " + editToString(edit) + '\n');
        }
    }

    private final class DocLockedRun implements Runnable {
        
        private final int type;
        
        boolean booleanResult;
        
        int intResult;
        
        String stringResult;

        public DocLockedRun(int type, StyledDocument doc) {
            this(type, doc, 0);
        }

        public DocLockedRun(int type, StyledDocument doc, int intValue) {
            this(type, doc, intValue, false);
        }

        public DocLockedRun(int type, StyledDocument doc, int intValue, boolean readLock) {
            this.type = type;
            this.intResult = intValue;

            if (!readLock && (doc instanceof NbDocument.WriteLockable)) {
                ((NbDocument.WriteLockable) doc).runAtomic(this);
            } else {
                if (readLock && doc != null) {
                    doc.render(this);
                } else {
                    // if the document is not one of "NetBeans ready"
                    // that supports locking we do not have many
                    // chances to do something. Maybe check for AbstractDocument
                    // and call writeLock using reflection, but better than
                    // that, let's leave this simple for now and wait for
                    // bug reports (if any appear)
                    run();
                }
            }
        }

        public void run() {
            switch (type) {
            case 0:
                UndoRedoManager.super.redo();
                break;

            case 1:
                UndoRedoManager.super.undo();
                break;

            case 2:
                booleanResult = UndoRedoManager.super.canRedo();
                break;

            case 3:
                booleanResult = UndoRedoManager.super.canUndo();
                break;

            case 4:
                intResult = UndoRedoManager.super.getLimit();
                break;

            case 5:
                UndoRedoManager.super.discardAllEdits();
                clearSaveActionsEdit();
                lastAddedOrRedoneEdit = null;
                break;

            case 6:
                UndoRedoManager.super.setLimit(intResult);
                break;

            case 7:
                UndoRedoManager.super.canUndoOrRedo();
                break;

            case 8:
                stringResult = UndoRedoManager.super.getUndoOrRedoPresentationName();
                break;

            case 9:
                stringResult = UndoRedoManager.super.getRedoPresentationName();
                break;

            case 10:
                stringResult = UndoRedoManager.super.getUndoPresentationName();
                break;

            case 11:
                UndoRedoManager.super.undoOrRedo();
                break;

            default:
                throw new IllegalArgumentException("Unknown type: " + type);
            }
        }
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development and
 * Distribution License("CDDL") (collectively, the "License"). You may not use
 * this file except in compliance with the License. You can obtain a copy of
 * the License at http://www.netbeans.org/cddl-gplv2.html or
 * nbbuild/licenses/CDDL-GPL-2-CP. See the License for the specific language
 * governing permissions and limitations under the License. When distributing
 * the software, include this License Header Notice in each file and include
 * the License file at nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided by
 * Oracle in the GPL Version 2 section of the License file that accompanied
 * this code. If applicable, add the following below the License Header, with
 * the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license." If you do not indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to its
 * licensees as provided above. However, if you add GPL Version 2 code and
 * therefore, elected the GPL Version 2 license, then the option applies only
 * if the new code is made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.openide.text;

import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.UndoableEdit;

/**
 * Undoable edit that wraps each undoable edit added to CloneableEditorSupport's undo manager.
 * <br/>
 * It is needed to
 * <ul>
 *   <li>Prohibit addEdit() operation on last edit when the undo manager is at savepoint.</li>
 *   <li>Prohibit replaceEdit() operation on last edit when the undo manager is at savepoint.</li>
 *   <li>Identify non-significant edits that are otherwise not reported by editToBeUndone()
 *       and editToBeRedone().</li>
 * </ul>
 * 
 * @author Miloslav Metelka
 * @since
 */
final class WrapUndoEdit implements UndoableEdit {

    /**
     * Support for which this edit is created.
     */
    final UndoRedoManager undoRedoManager; // 8=Object + 4 = 12 bytes

    /**
     * Real undoable edit passed to undoableEditHappened().
     */
    private UndoableEdit delegate; // 12 + 4 = 16 bytes

    WrapUndoEdit(UndoRedoManager undoRedoManager, UndoableEdit delegate) {
        assert (delegate != null) : "Delegate is null"; // NOI18N
        this.undoRedoManager = undoRedoManager;
        this.delegate = delegate;
    }
    
    UndoableEdit delegate() {
        return delegate;
    }

    void setDelegate(UndoableEdit delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public void undo() throws CannotUndoException {
        UndoRedoManager.checkLogOp("WrapUndoEdit.undo", this);
        undoRedoManager.beforeUndoCheck(this);
        delegate.undo();
        // This will only happen if delegate.undo() does not throw CannotUndoException
        undoRedoManager.afterUndoCheck(this);
    }

    @Override
    public boolean canUndo() {
        return delegate.canUndo();
    }

    @Override
    public void redo() throws CannotRedoException {
        UndoRedoManager.checkLogOp("WrapUndoEdit.redo", this);
        undoRedoManager.beforeRedoCheck(this);
        delegate.redo();
        // This will only happen if delegate.redo() does not throw CannotRedoException
        undoRedoManager.afterRedoCheck(this);
    }

    @Override
    public boolean canRedo() {
        return delegate.canRedo();
    }

    @Override
    public void die() {
        UndoRedoManager.checkLogOp("WrapUndoEdit.die", this);
        delegate.die();
        undoRedoManager.notifyWrapEditDie(this);
    }

    @Override
    public boolean addEdit(UndoableEdit anEdit) {
        if (undoRedoManager.isAtSavepoint()) {
            // Prohibit adding to existing edit at savepoint since undo to savepoint could no longer be done
            // when merging with another edit.
            // Since addEdit() will fail the anEdit.replaceEdit() will be attempted; but it will not succeed too
            // (see impl) so anEdit will be added as a fresh edit to end of UM.edits.
            // However undoRedoManager.savepointEdit must be set by undoRedoManager.addEdit() since
            // UM.edits may be empty in which case WUE.addEdit() is not called.
            return false;
        }
        // anEdit is already wrapped for possible regular addition
        WrapUndoEdit wrapEdit = (WrapUndoEdit) anEdit;
        boolean added = delegate.addEdit(wrapEdit.delegate);
        return added;
    }

    @Override
    public boolean replaceEdit(UndoableEdit anEdit) {
        if (undoRedoManager.isAtSavepoint()) { // Prohibit replacing at savepoint
            return false;
        }
        WrapUndoEdit wrapEdit = (WrapUndoEdit) anEdit;
        boolean replaced = delegate.replaceEdit(wrapEdit.delegate);
        UndoRedoManager.checkLogOp("WrapUndoEdit.replaceEdit=" + replaced, anEdit);
        if (replaced) {
            undoRedoManager.checkReplaceSavepointEdit(wrapEdit, this);
        }
        return replaced;
    }

    @Override
    public boolean isSignificant() {
        return delegate.isSignificant();
    }

    @Override
    public String getPresentationName() {
        return delegate.getPresentationName();
    }

    @Override
    public String getUndoPresentationName() {
        return delegate.getUndoPresentationName();
    }

    @Override
    public String getRedoPresentationName() {
        return delegate.getRedoPresentationName();
    }

}





import java.lang.ref.WeakReference;
import java.util.Arrays;
import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import org.netbeans.junit.MockServices;

        assertFalse ("Nothing to undo", red.master.getUndoRedo ().canUndo ());
        
        // this should not be allowed
        try {
            doc.insertString (0, "Kuk", null);
            fail("Modification should not proceed");
        } catch (BadLocationException ex) {
            // Expected
        }
        
        String s = doc.getText (0, doc.getLength ());
        assertEquals ("The document is now the same as at the begining", content, s);




import java.util.Date;
import javax.swing.JEditorPane;
import javax.swing.SwingUtilities;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import junit.framework.AssertionFailedError;

        assertFalse ("Nothing to undo", support.getUndoRedo ().canUndo ());
        
        // this should not be allowed
        try {
            doc.insertString (0, "Kuk", null);
            fail("Modification should not proceed");
        } catch (BadLocationException ex) {
            // Expected
        }
        
        String s = doc.getText (0, doc.getLength ());
        assertEquals ("The document is now the same as at the begining", content, s);

Return to bug 21237

Lines 139-229 Link Here

(-)a/openide.awt/src/org/openide/awt/UndoRedo.java (-58 / +7 lines)
139		139
140	private final ChangeSupport cs = new ChangeSupport(this);	140	private final ChangeSupport cs = new ChangeSupport(this);
141		141
142	/** vector of Edits to run */
143	private final LinkedList<UndoableEditEvent> runus = new LinkedList<UndoableEditEvent>(); // for fix of #8692
144
145	/** Called from undoableEditHappened() inner class */
146	private void superUndoableEditHappened(UndoableEditEvent ue) {
147	super.undoableEditHappened(ue);
148	}
149
150	/** Called from discardAllEdits() inner class */
151	private void superDiscardAllEdits() {
152	super.discardAllEdits();
153	}
154
155	/** Consume an undoable edit.	142	/** Consume an undoable edit.
156	* Delegates to superclass and notifies listeners.	143	* Delegates to superclass and notifies listeners.
157	* @param ue the edit	144	* @param ue the edit
158	*/	145	*/
159	@Override	146	@Override
160	public void undoableEditHappened(final UndoableEditEvent ue) {	147	public void undoableEditHappened(final UndoableEditEvent ue) {
161	/* Edits are posted to request processor and the deadlock	148	super.undoableEditHappened(ue);
162	* in #8692 between undoredo and document that fires	149	cs.fireChange();
163	* the undoable edit should be avoided this way.
164	*/
165	synchronized (runus) {
166	runus.add(ue);
167	}
168
169	updateTask();
170	}	150	}
171		151
172	/** Discard all the existing edits from the undomanager. */	152	/** Discard all the existing edits from the undomanager. */
173	@Override	153	@Override
174	public void discardAllEdits() {	154	public void discardAllEdits() {
175	synchronized (runus) {	155	super.discardAllEdits();
176	runus.add(null);	156	cs.fireChange();
177	}
178
179	updateTask();
180	}	157	}
181		158
182	@Override	159	@Override
183	public void undo() throws CannotUndoException {	160	public void undo() throws CannotUndoException {
184	super.undo();	161	super.undo();
185	updateTask();	162	cs.fireChange();
186	}	163	}
187		164
188	@Override	165	@Override
189	public void redo() throws CannotRedoException {	166	public void redo() throws CannotRedoException {
190	super.redo();	167	super.redo();
191	updateTask();	168	cs.fireChange();
192	}	169	}
193		170
194	@Override	171	@Override
195	public void undoOrRedo() throws CannotRedoException, CannotUndoException {	172	public void undoOrRedo() throws CannotRedoException, CannotUndoException {
196	super.undoOrRedo();	173	super.undoOrRedo(); // cs.fireChange() either in undo() or redo()
197	updateTask();
198	}	174	}
199		175
200	private void updateTask() {
201	for (;;) {
202	UndoableEditEvent ue;
203
204	synchronized (runus) {
205	if (runus.isEmpty()) {
206	break;
207	}
208
209	ue = runus.removeFirst();
210	}
211
212	if (ue == null) {
213	superDiscardAllEdits();
214	} else {
215	superUndoableEditHappened(ue);
216	}
217	}
218	cs.fireChange();
219	}
220
221	/* Attaches change listener to the this object.
222	* The listener is notified everytime the undo/redo
223	* ability of this object changes.
224	*/
225
226	//#32313 - synchronization of this method was removed
227	@Override	176	@Override
228	public void addChangeListener(ChangeListener l) {	177	public void addChangeListener(ChangeListener l) {
229	cs.addChangeListener(l);	178	cs.addChangeListener(l);

Line 0 Link Here

(-)a/openide.text/src/org/openide/text/UndoGroupManager.java (+373 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* Contributor(s):
		28	*
		29	* The Original Software is NetBeans. The Initial Developer of the Original
		30	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
		31	* Microsystems, Inc. All Rights Reserved.
		32	*
		33	* If you wish your version of this file to be governed by only the CDDL
		34	* or only the GPL Version 2, indicate your decision by adding
		35	* "[Contributor] elects to include this software in this distribution
		36	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		37	* single choice of license, a recipient has the option to distribute
		38	* your version of this file under either the CDDL, the GPL Version 2 or
		39	* to extend the choice of license to its licensees as provided above.
		40	* However, if you add GPL Version 2 code and therefore, elected the GPL
		41	* Version 2 license, then the option applies only if the new code is
		42	* made subject to such option by the copyright holder.
		43	*/
		44
		45	package org.openide.text;
		46
		47	import java.util.logging.Level;
		48	import java.util.logging.Logger;
		49	import javax.swing.event.UndoableEditEvent;
		50	import javax.swing.undo.*;
		51	import org.openide.awt.UndoRedo;
		52
		53
		54	/**
		55	* <tt>UndoGroupManager</tt> extends {@link UndoManager}
		56	* and allows explicit control of what
		57	* <tt>UndoableEdit</tt>s are coalesced into compound edits,
		58	* rather than using the rules defined by the edits themselves.
		59	* Groups are defined using BEGIN_COMMIT_GROUP and END_COMMIT_GROUP.
		60	* Send these to UndoableEditListener. These must always be paired.
		61	* <p>
		62	* These use cases are supported.
		63	* </p>
		64	* <ol>
65	* <li> Default behavior is defined by {@link UndoManager}.</li>
66	* <li> <tt>UnddoableEdit</tt>s issued between {@link #BEGIN_COMMIT_GROUP}
67	* and {@link #END_COMMIT_GROUP} are placed into a single
68	* {@link CompoundEdit}.
69	* Thus <tt>undo()</tt> and <tt>redo()</tt> treat them
70	* as a single undo/redo.</li>
71	* <li>BEGIN/END nest.</li>
72	* <li> Issue MARK_COMMIT_GROUP to commit accumulated
73	* <tt>UndoableEdit</tt>s into a single <tt>CompoundEdit</tt>
74	* and to continue accumulating;
75	* an application could do this at strategic points, such as EndOfLine
76	* input or cursor movement.</li>
77	* </ol>
78	* @see UndoManager
79	* @author Ernie Rael
80	*/
81	class UndoGroupManager extends UndoRedo.Manager {
82
83	// -J-Dorg.openide.text.UndoGroupManager.level=FINE
84	private static final Logger LOG = Logger.getLogger(UndoGroupManager.class.getName());
85
86	/** signals that edits are being accumulated */
87	private int buildUndoGroup;
88
89	/** accumulate edits here in undoGroup */
90	private CompoundEdit undoGroup;
91
92	/**
93	* Signal that nested group started and that current undo group
94	* must be committed if edit is added. Then can avoid doing the commit
95	* if the nested group turns out to be empty.
96	*/
97	private int needsNestingCommit;
98
99	/**
100	* Start a group of edits which will be committed as a single edit
101	* for purpose of undo/redo.
102	* Nesting semantics are that any BEGIN_COMMIT_GROUP and
103	* END_COMMIT_GROUP delimits a commit-group, unless the group is
104	* empty in which case the begin/end is ignored.
105	* While coalescing edits, any undo/redo/save implicitly delimits
106	* a commit-group.
107	*/
108	static final UndoableEdit BEGIN_COMMIT_GROUP = new CommitGroupEdit();
109
110	/** End a group of edits. */
111	static final UndoableEdit END_COMMIT_GROUP = new CommitGroupEdit();
112
113	/**
114	* Any coalesced edits become a commit-group and a new commit-group
115	* is started.
116	*/
117	static final UndoableEdit MARK_COMMIT_GROUP = new CommitGroupEdit();
118
119	private static class CommitGroupEdit extends AbstractUndoableEdit {
120	@Override
121	public boolean isSignificant() {
122	return false;
123	}
124
125	@Override
126	public boolean canRedo()
127	{
128	return true;
129	}
130
131	@Override
132	public boolean canUndo()
133	{
134	return true;
135	}
136	}
137
138	@Override
139	public void undoableEditHappened(UndoableEditEvent ue)
140	{
141	if(ue.getEdit() == BEGIN_COMMIT_GROUP) {
142	beginUndoGroup();
143	} else if(ue.getEdit() == END_COMMIT_GROUP) {
144	endUndoGroup();
145	} else if(ue.getEdit() == MARK_COMMIT_GROUP) {
146	commitUndoGroup();
147	} else {
148	super.undoableEditHappened(ue);
149	}
150	}
151
152	/**
153	* Direct this <tt>UndoGroupManager</tt> to begin coalescing any
154	* <tt>UndoableEdit</tt>s that are added into a <tt>CompoundEdit</tt>.
155	* <p>If edits are already being coalesced and some have been
156	* accumulated, they are flagged for commitment as an atomic group and
157	* a new group will be started.
158	* @see #addEdit
159	* @see #endUndoGroup
160	*/
161	private synchronized void beginUndoGroup() {
162	if(undoGroup != null)
163	needsNestingCommit++;
164	LOG.log(Level.FINE, "beginUndoGroup: nesting {0}", buildUndoGroup);
165	buildUndoGroup++;
166	}
167
168	/**
169	* Direct this <tt>UndoGroupManager</tt> to stop coalescing edits.
170	* Until <tt>beginUndoGroupManager</tt> is invoked,
171	* any received <tt>UndoableEdit</tt>s are added singly.
172	* <p>
173	* This has no effect if edits are not being coalesced, for example
174	* if <tt>beginUndoGroup</tt> has not been called.
175	*/
176	private synchronized void endUndoGroup() {
177	buildUndoGroup--;
178	LOG.log(Level.FINE, "endUndoGroup: nesting {0}", buildUndoGroup);
179	if(buildUndoGroup < 0) {
180	LOG.log(Level.INFO, null, new Exception("endUndoGroup without beginUndoGroup"));
181	// slam buildUndoGroup to 0 to disable nesting
182	buildUndoGroup = 0;
183	}
184	if(needsNestingCommit <= 0)
185	commitUndoGroup();
186	if(--needsNestingCommit < 0)
187	needsNestingCommit = 0;
188	}
189
190	/**
191	* Commit any accumulated <tt>UndoableEdit</tt>s as an atomic
192	* <tt>undo</tt>/<tt>redo</tt> group. {@link CompoundEdit#end}
193	* is invoked on the <tt>CompoundEdit</tt> and it is added as a single
194	* <tt>UndoableEdit</tt> to this <tt>UndoManager</tt>.
195	* <p>
196	* If edits are currently being coalesced, a new undo group is started.
197	* This has no effect if edits are not being coalesced, for example
198	* <tt>beginUndoGroup</tt> has not been called.
199	*/
200	private synchronized void commitUndoGroup() {
201	if(undoGroup == null) {
202	return;
203	}
204
205	// undoGroup is being set to null,
206	// needsNestingCommit has no meaning now
207	needsNestingCommit = 0;
208
209	// super.addEdit may end up in this.addEdit,
210	// so buildUndoGroup must be false
211	int saveBuildUndoGroup = buildUndoGroup;
212	buildUndoGroup = 0;
213
214	undoGroup.end();
215	super.addEdit(undoGroup);
216	undoGroup = null;
217
218	buildUndoGroup = saveBuildUndoGroup;
219	}
220
221	/** Add this edit separately, not part of a group.
222	* @return super.addEdit
223	*/
224	private boolean commitAddEdit(UndoableEdit anEdit) {
225	commitUndoGroup();
226
227	int saveBuildUndoGroup = buildUndoGroup;
228	buildUndoGroup = 0;
229	boolean f = super.addEdit(anEdit);
230	//boolean f = addEdit(undoGroup);
231	buildUndoGroup = saveBuildUndoGroup;
232	return f;
233	}
234
235	/**
236	* If there's a pending undo group that needs to be committed
237	* then commit it.
238	* If this <tt>UndoManager</tt> is coalescing edits then add
239	* <tt>anEdit</tt> to the accumulating <tt>CompoundEdit</tt>.
240	* Otherwise, add it to this UndoManager. In either case the
241	* edit is saved for later <tt>undo</tt> or <tt>redo</tt>.
242	* @return {@inheritDoc}
243	* @see #beginUndoGroup
244	* @see #endUndoGroup
245	*/
246	@Override
247	public synchronized boolean addEdit(UndoableEdit anEdit) {
248	if(!isInProgress())
249	return false;
250
251	if(needsNestingCommit > 0) {
252	commitUndoGroup();
253	}
254
255	if(buildUndoGroup > 0) {
256	if(anEdit instanceof WrapUndoEdit)
257	return commitAddEdit(anEdit);
258	if(undoGroup == null)
259	undoGroup = new CompoundEdit();
260	return undoGroup.addEdit(anEdit);
261	} else {
262	return super.addEdit(anEdit);
263	}
264	}
265
266	@Override
267	public synchronized void discardAllEdits() {
268	commitUndoGroup();
269	super.discardAllEdits();
270	}
271
272	//
273	// TODO: limits
274	//
275
276	@Override
277	public synchronized void undoOrRedo() {
278	commitUndoGroup();
279	super.undoOrRedo();
280	}
281
282	@Override
283	public synchronized boolean canUndoOrRedo() {
284	if(undoGroup != null)
285	return true;
286	return super.canUndoOrRedo();
287	}
288
289	@Override
290	public synchronized void undo() {
291	commitUndoGroup();
292	super.undo();
293	}
294
295	@Override
296	public synchronized boolean canUndo() {
297	if(undoGroup != null)
298	return true;
299	return super.canUndo();
300	}
301
302	@Override
303	public synchronized void redo() {
304	if(undoGroup != null)
305	throw new CannotRedoException();
306	super.redo();
307	}
308
309	@Override
310	public synchronized boolean canRedo() {
311	if(undoGroup != null)
312	return false;
313	return super.canRedo();
314	}
315
316	@Override
317	public synchronized void end() {
318	commitUndoGroup();
319	super.end();
320	}
321
322	@Override
323	public synchronized String getUndoOrRedoPresentationName() {
324	if(undoGroup != null)
325	return undoGroup.getUndoPresentationName();
326	return super.getUndoOrRedoPresentationName();
327	}
328
329	@Override
330	public synchronized String getUndoPresentationName() {
331	if(undoGroup != null)
332	return undoGroup.getUndoPresentationName();
333	return super.getUndoPresentationName();
334	}
335
336	@Override
337	public synchronized String getRedoPresentationName() {
338	if(undoGroup != null)
339	return undoGroup.getRedoPresentationName();
340	return super.getRedoPresentationName();
341	}
342
343	@Override
344	public boolean isSignificant() {
345	if(undoGroup != null && undoGroup.isSignificant()) {
346	return true;
347	}
348	return super.isSignificant();
349	}
350
351	@Override
352	public synchronized void die() {
353	commitUndoGroup();
354	super.die();
355	}
356
357	@Override
358	public String getPresentationName() {
359	if(undoGroup != null)
360	return undoGroup.getPresentationName();
361	return super.getPresentationName();
362	}
363
364	@Override
365	public final WrapUndoEdit lastEdit() { // make lastEdit() accessible
366	return (WrapUndoEdit) super.lastEdit();
367	}
368
369	// The protected methods are only accessed from
370	// synchronized methods that do commitUndoGroup
371	// so they do not need to be overridden in this class
372
373	}

Line 0 Link Here

(-)a/openide.text/src/org/openide/text/WrapUndoEdit.java (+171 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common Development and
		11	* Distribution License("CDDL") (collectively, the "License"). You may not use
		12	* this file except in compliance with the License. You can obtain a copy of
		13	* the License at http://www.netbeans.org/cddl-gplv2.html or
		14	* nbbuild/licenses/CDDL-GPL-2-CP. See the License for the specific language
		15	* governing permissions and limitations under the License. When distributing
		16	* the software, include this License Header Notice in each file and include
		17	* the License file at nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		18	* particular file as subject to the "Classpath" exception as provided by
		19	* Oracle in the GPL Version 2 section of the License file that accompanied
		20	* this code. If applicable, add the following below the License Header, with
		21	* the fields enclosed by brackets [] replaced by your own identifying
		22	* information: "Portions Copyrighted [year] [name of copyright owner]"
		23	*
		24	* If you wish your version of this file to be governed by only the CDDL or
		25	* only the GPL Version 2, indicate your decision by adding "[Contributor]
		26	* elects to include this software in this distribution under the [CDDL or GPL
		27	* Version 2] license." If you do not indicate a single choice of license, a
		28	* recipient has the option to distribute your version of this file under
		29	* either the CDDL, the GPL Version 2 or to extend the choice of license to its
		30	* licensees as provided above. However, if you add GPL Version 2 code and
		31	* therefore, elected the GPL Version 2 license, then the option applies only
		32	* if the new code is made subject to such option by the copyright holder.
		33	*
		34	* Contributor(s):
		35	*
		36	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		37	*/
		38	package org.openide.text;
		39
		40	import javax.swing.undo.CannotRedoException;
		41	import javax.swing.undo.CannotUndoException;
		42	import javax.swing.undo.UndoableEdit;
		43
		44	/**
		45	* Undoable edit that wraps each undoable edit added to CloneableEditorSupport's undo manager.
		46	* <br/>
		47	* It is needed to
		48	* <ul>
		49	* <li>Prohibit addEdit() operation on last edit when the undo manager is at savepoint.</li>
		50	* <li>Prohibit replaceEdit() operation on last edit when the undo manager is at savepoint.</li>
		51	* <li>Identify non-significant edits that are otherwise not reported by editToBeUndone()
		52	* and editToBeRedone().</li>
		53	* </ul>
		54	*
		55	* @author Miloslav Metelka
		56	* @since
		57	*/
		58	final class WrapUndoEdit implements UndoableEdit {
		59
		60	/**
		61	* Support for which this edit is created.
		62	*/
		63	final UndoRedoManager undoRedoManager; // 8=Object + 4 = 12 bytes
		64
65	/**
66	* Real undoable edit passed to undoableEditHappened().
67	*/
68	private UndoableEdit delegate; // 12 + 4 = 16 bytes
69
70	WrapUndoEdit(UndoRedoManager undoRedoManager, UndoableEdit delegate) {
71	assert (delegate != null) : "Delegate is null"; // NOI18N
72	this.undoRedoManager = undoRedoManager;
73	this.delegate = delegate;
74	}
75
76	UndoableEdit delegate() {
77	return delegate;
78	}
79
80	void setDelegate(UndoableEdit delegate) {
81	this.delegate = delegate;
82	}
83
84	@Override
85	public void undo() throws CannotUndoException {
86	UndoRedoManager.checkLogOp("WrapUndoEdit.undo", this);
87	undoRedoManager.beforeUndoCheck(this);
88	delegate.undo();
89	// This will only happen if delegate.undo() does not throw CannotUndoException
90	undoRedoManager.afterUndoCheck(this);
91	}
92
93	@Override
94	public boolean canUndo() {
95	return delegate.canUndo();
96	}
97
98	@Override
99	public void redo() throws CannotRedoException {
100	UndoRedoManager.checkLogOp("WrapUndoEdit.redo", this);
101	undoRedoManager.beforeRedoCheck(this);
102	delegate.redo();
103	// This will only happen if delegate.redo() does not throw CannotRedoException
104	undoRedoManager.afterRedoCheck(this);
105	}
106
107	@Override
108	public boolean canRedo() {
109	return delegate.canRedo();
110	}
111
112	@Override
113	public void die() {
114	UndoRedoManager.checkLogOp("WrapUndoEdit.die", this);
115	delegate.die();
116	undoRedoManager.notifyWrapEditDie(this);
117	}
118
119	@Override
120	public boolean addEdit(UndoableEdit anEdit) {
121	if (undoRedoManager.isAtSavepoint()) {
122	// Prohibit adding to existing edit at savepoint since undo to savepoint could no longer be done
123	// when merging with another edit.
124	// Since addEdit() will fail the anEdit.replaceEdit() will be attempted; but it will not succeed too
125	// (see impl) so anEdit will be added as a fresh edit to end of UM.edits.
126	// However undoRedoManager.savepointEdit must be set by undoRedoManager.addEdit() since
127	// UM.edits may be empty in which case WUE.addEdit() is not called.
128	return false;
129	}
130	// anEdit is already wrapped for possible regular addition
131	WrapUndoEdit wrapEdit = (WrapUndoEdit) anEdit;
132	boolean added = delegate.addEdit(wrapEdit.delegate);
133	return added;
134	}
135
136	@Override
137	public boolean replaceEdit(UndoableEdit anEdit) {
138	if (undoRedoManager.isAtSavepoint()) { // Prohibit replacing at savepoint
139	return false;
140	}
141	WrapUndoEdit wrapEdit = (WrapUndoEdit) anEdit;
142	boolean replaced = delegate.replaceEdit(wrapEdit.delegate);
143	UndoRedoManager.checkLogOp("WrapUndoEdit.replaceEdit=" + replaced, anEdit);
144	if (replaced) {
145	undoRedoManager.checkReplaceSavepointEdit(wrapEdit, this);
146	}
147	return replaced;
148	}
149
150	@Override
151	public boolean isSignificant() {
152	return delegate.isSignificant();
153	}
154
155	@Override
156	public String getPresentationName() {
157	return delegate.getPresentationName();
158	}
159
160	@Override
161	public String getUndoPresentationName() {
162	return delegate.getUndoPresentationName();
163	}
164
165	@Override
166	public String getRedoPresentationName() {
167	return delegate.getRedoPresentationName();
168	}
169
170	}
171

Lines 38-43 Link Here

(-)a/openide.text/test/unit/src/org/openide/text/CloneableEditorSupportRedirectorTest.java (-6 / +7 lines)
38	import java.lang.ref.WeakReference;	38	import java.lang.ref.WeakReference;
39	import java.util.Arrays;	39	import java.util.Arrays;
40	import javax.swing.SwingUtilities;	40	import javax.swing.SwingUtilities;
		41	import javax.swing.text.BadLocationException;
41	import javax.swing.text.Document;	42	import javax.swing.text.Document;
42	import javax.swing.text.EditorKit;	43	import javax.swing.text.EditorKit;
43	import org.netbeans.junit.MockServices;	44	import org.netbeans.junit.MockServices;
Lines 157-168 Link Here
157	assertFalse ("Nothing to undo", red.master.getUndoRedo ().canUndo ());	158	assertFalse ("Nothing to undo", red.master.getUndoRedo ().canUndo ());
158		159
159	// this should not be allowed	160	// this should not be allowed
160	doc.insertString (0, "Kuk", null);	161	try {
161		162	doc.insertString (0, "Kuk", null);
162	String modifiedForAWhile = doc.getText (0, 3);	163	fail("Modification should not proceed");
163	//assertEquals ("For a while the test really starts with Kuk", "Kuk", doc.getText (0, 3));	164	} catch (BadLocationException ex) {
164		165	// Expected
165	assertFalse ("The document cannot be modified", red.master.getUndoRedo ().canUndo ());	166	}
166		167
167	String s = doc.getText (0, doc.getLength ());	168	String s = doc.getText (0, doc.getLength ());
168	assertEquals ("The document is now the same as at the begining", content, s);	169	assertEquals ("The document is now the same as at the begining", content, s);

Lines 56-61 Link Here

(-)a/openide.text/test/unit/src/org/openide/text/CloneableEditorSupportTest.java (-6 / +7 lines)
56	import java.util.Date;	56	import java.util.Date;
57	import javax.swing.JEditorPane;	57	import javax.swing.JEditorPane;
58	import javax.swing.SwingUtilities;	58	import javax.swing.SwingUtilities;
		59	import javax.swing.text.BadLocationException;
59	import javax.swing.text.Document;	60	import javax.swing.text.Document;
60	import javax.swing.text.EditorKit;	61	import javax.swing.text.EditorKit;
61	import junit.framework.AssertionFailedError;	62	import junit.framework.AssertionFailedError;
Lines 265-276 Link Here
265	assertFalse ("Nothing to undo", support.getUndoRedo ().canUndo ());	266	assertFalse ("Nothing to undo", support.getUndoRedo ().canUndo ());
266		267
267	// this should not be allowed	268	// this should not be allowed
268	doc.insertString (0, "Kuk", null);	269	try {
269		270	doc.insertString (0, "Kuk", null);
270	String modifiedForAWhile = doc.getText (0, 3);	271	fail("Modification should not proceed");
271	//assertEquals ("For a while the test really starts with Kuk", "Kuk", doc.getText (0, 3));	272	} catch (BadLocationException ex) {
272		273	// Expected
273	assertFalse ("The document cannot be modified", support.getUndoRedo ().canUndo ());	274	}
274		275
275	String s = doc.getText (0, doc.getLength ());	276	String s = doc.getText (0, doc.getLength ());
276	assertEquals ("The document is now the same as at the begining", content, s);	277	assertEquals ("The document is now the same as at the begining", content, s);