Attachment #116515 for bug #48427

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 48427
Collapse All | Expand All

Lines 62-67 Link Here

(-)diff/src/org/netbeans/api/diff/Difference.java (+6 lines)
62	/** Change type of difference - a portion of a file was changed in the other */	62	/** Change type of difference - a portion of a file was changed in the other */
63	public static final int CHANGE = 2;	63	public static final int CHANGE = 2;
64		64
		65	public static class Kind {
		66
		67	public Kind() {
		68	}
		69	}
		70
65	private int type = 0;	71	private int type = 0;
66	private int firstStart = 0;	72	private int firstStart = 0;
67	private int firstEnd = 0;	73	private int firstEnd = 0;

Lines 202-207 Link Here

(-)editor.lib/nbproject/project.xml (+5 lines)
202	<recursive/>	202	<recursive/>
203	</test-dependency>	203	</test-dependency>
204	<test-dependency>	204	<test-dependency>
		205	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
		206	<compile-dependency/>
		207	<test/>
		208	</test-dependency>
		209	<test-dependency>
205	<code-name-base>org.netbeans.modules.editor.settings.storage</code-name-base>	210	<code-name-base>org.netbeans.modules.editor.settings.storage</code-name-base>
206	<recursive/>	211	<recursive/>
207	<compile-dependency/>	212	<compile-dependency/>




package org.netbeans.editor;

import java.awt.Font;
import java.beans.PropertyVetoException;
import java.beans.VetoableChangeListener;
import java.util.Hashtable;
import java.util.Dictionary;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeSupport;
import java.util.Collection;
import java.util.EventListener;
import java.util.HashSet;
import java.util.Set;

import org.netbeans.modules.editor.lib2.document.ReadWriteBuffer;
import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;
import org.netbeans.modules.editor.lib2.document.StableCompoundEdit;
import org.netbeans.spi.editor.document.UndoableEditWrapper;
import org.netbeans.spi.lexer.MutableTextInput;
import org.netbeans.spi.lexer.TokenHierarchyControl;
import org.openide.filesystems.FileObject;
import org.openide.util.RequestProcessor;
import org.openide.util.RequestProcessor.Task;
import org.openide.util.WeakListeners;

/**

    
    private UndoableEdit removeUpdateLineUndo;

    private Collection<? extends UndoableEditWrapper> undoEditWrappers;

    private DocumentFilter.FilterBypass filterBypass;

    private Preferences prefs;


        TrailingWhitespaceRemove.install(this);

        undoEditWrappers = MimeLookup.getLookup(mimeType).lookupAll(UndoableEditWrapper.class);

        if (weakPrefsListener == null) {
            // the listening could have already been initialized from setMimeType(), which
            // is called by some kits from initDocument()

    }

    protected @Override void fireUndoableEditUpdate(UndoableEditEvent e) {
        // Possibly wrap contained edit
        if (undoEditWrappers != null) {
            UndoableEdit origEdit = e.getEdit();
            UndoableEdit edit = origEdit;
            for (UndoableEditWrapper wrapper : undoEditWrappers) {
                edit = wrapper.wrap(edit, this);
            }
            if (edit != origEdit) {
                e = new UndoableEditEvent(this, edit);
            }
        }
        
	// Fire to the list of listeners that was used before the atomic lock started
        // This fixes issue #47881 and appears to be somewhat more logical
        // than the default approach to fire all the current listeners




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.editor;

import javax.swing.text.Document;
import javax.swing.undo.CompoundEdit;
import javax.swing.undo.UndoableEdit;
import org.netbeans.spi.editor.document.UndoableEditWrapper;

/**
 *
 * @author mmetelka
 */
//@MimeRegistration(mimeType="", service=UndoableEditWrapper.class)
public class TestingUndoableEditWrapper implements UndoableEditWrapper {

    @Override
    public UndoableEdit wrap(UndoableEdit edit, Document doc) {
        WrapCompoundEdit wrapEdit = new WrapCompoundEdit();
        wrapEdit.addEdit(edit);
        wrapEdit.end();
        return wrapEdit;
    }
    
    static final class WrapCompoundEdit extends CompoundEdit {
        
        WrapCompoundEdit() {
        }
        
    }

    
}




/*
 * 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-2006 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.netbeans.editor;

import javax.swing.event.UndoableEditEvent;
import javax.swing.event.UndoableEditListener;
import javax.swing.undo.UndoableEdit;
import org.netbeans.api.editor.mimelookup.MimePath;
import org.netbeans.api.editor.mimelookup.test.MockMimeLookup;
import org.netbeans.junit.NbTestCase;

/**
 *
 * @author Miloslav Metelka
 */
public class UndoableEditWrapperTest extends NbTestCase {
    
    /** Creates a new instance of ZOrderTest */
    public UndoableEditWrapperTest(String name) {
        super(name);
    }
    
    public void testWrapping() throws Exception {
        MimePath mimePath = MimePath.EMPTY;
        MockMimeLookup.setInstances(mimePath, new TestingUndoableEditWrapper());
        BaseDocument bDoc = new BaseDocument(false, "");
        bDoc.addUndoableEditListener(new UndoableEditListener() {
            @Override
            public void undoableEditHappened(UndoableEditEvent e) {
                UndoableEdit edit = e.getEdit();
                assertEquals("Expected WrapCompoundEdit.class",
                        TestingUndoableEditWrapper.WrapCompoundEdit.class, edit.getClass());
            }
        });
        bDoc.insertString(0, "Test", null);
    }

}

Lines 1-6 Link Here

(-)editor.lib2/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.editor.lib2/1	2	OpenIDE-Module: org.netbeans.modules.editor.lib2/1
3	OpenIDE-Module-Implementation-Version: 26	3	OpenIDE-Module-Implementation-Version: 27
4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/lib2/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/lib2/Bundle.properties
5	OpenIDE-Module-Layer: org/netbeans/modules/editor/lib2/resources/layer.xml	5	OpenIDE-Module-Layer: org/netbeans/modules/editor/lib2/resources/layer.xml
6	OpenIDE-Module-Needs: org.netbeans.modules.editor.actions	6	OpenIDE-Module-Needs: org.netbeans.modules.editor.actions

Lines 43-49 Link Here

(-)editor.lib2/nbproject/project.properties (-1 / +1 lines)
43	is.autoload=true	43	is.autoload=true
44	javac.source=1.6	44	javac.source=1.6
45	javac.compilerargs=-Xlint:unchecked	45	javac.compilerargs=-Xlint:unchecked
46	spec.version.base=1.55.0	46	spec.version.base=1.56.0
47		47
48	javadoc.arch=${basedir}/arch.xml	48	javadoc.arch=${basedir}/arch.xml
49	javadoc.apichanges=${basedir}/apichanges.xml	49	javadoc.apichanges=${basedir}/apichanges.xml

Lines 188-193 Link Here

(-)editor.lib2/nbproject/project.xml (+1 lines)
188	<public-packages>	188	<public-packages>
189	<package>org.netbeans.api.editor</package>	189	<package>org.netbeans.api.editor</package>
190	<package>org.netbeans.spi.editor.codegen</package>	190	<package>org.netbeans.spi.editor.codegen</package>
		191	<package>org.netbeans.spi.editor.document</package>
191	<package>org.netbeans.spi.editor.highlighting</package>	192	<package>org.netbeans.spi.editor.highlighting</package>
192	<package>org.netbeans.spi.editor.highlighting.support</package>	193	<package>org.netbeans.spi.editor.highlighting.support</package>
193	<package>org.netbeans.spi.editor.typinghooks</package>	194	<package>org.netbeans.spi.editor.typinghooks</package>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.spi.editor.document;

import javax.swing.text.Document;
import javax.swing.undo.UndoableEdit;
import org.netbeans.api.annotations.common.NonNull;

/**
 * Wrap undoable edits generated by document implementation into a custom undoable edit.
 * <br/>
 * Instances should be registered by using @MimeRegistration.
 *
 * @author Miloslav Metelka
 */
public interface UndoableEditWrapper {
    
    /**
     * Wrap given undoable edit by a custom undoable edit implementation
     * (or leave it as it is).
     *
     * @param edit original undoable edit generated by document (or previous wrapper).
     * @param doc document which generated the original undoable edit.
     * @return wrap edit or original edit.
     * @since 1.56
     */
    @NonNull UndoableEdit wrap(@NonNull UndoableEdit edit, @NonNull Document doc);
    
}

Lines 48-56 Link Here

(-)java.navigation/src/org/netbeans/modules/java/navigation/ClassMemberPanel.java (-1 / +9 lines)
48	import javax.swing.JComponent;	48	import javax.swing.JComponent;
49	import org.netbeans.api.java.source.ElementHandle;	49	import org.netbeans.api.java.source.ElementHandle;
50	import org.netbeans.spi.navigator.NavigatorPanel;	50	import org.netbeans.spi.navigator.NavigatorPanel;
		51	import org.netbeans.spi.navigator.NavigatorPanelWithUndo;
		52	import org.openide.awt.UndoRedo;
51	import org.openide.util.Lookup;	53	import org.openide.util.Lookup;
52	import org.openide.util.NbBundle;	54	import org.openide.util.NbBundle;
53	import org.openide.util.RequestProcessor;	55	import org.openide.util.RequestProcessor;
		56	import org.openide.util.lookup.Lookups;
54		57
55	/**	58	/**
56	*	59	*
Lines 60-66 Link Here
60	@NavigatorPanel.Registration(mimeType="text/x-java", position=100, displayName="#LBL_members"),	63	@NavigatorPanel.Registration(mimeType="text/x-java", position=100, displayName="#LBL_members"),
61	@NavigatorPanel.Registration(mimeType="application/x-class-file", displayName="#LBL_members")	64	@NavigatorPanel.Registration(mimeType="application/x-class-file", displayName="#LBL_members")
62	})	65	})
63	public class ClassMemberPanel implements NavigatorPanel {	66	public class ClassMemberPanel implements NavigatorPanelWithUndo {
64		67
65	private ClassMemberPanelUI component;	68	private ClassMemberPanelUI component;
66		69
Lines 135-138 Link Here
135	public static ClassMemberPanel getInstance() {	138	public static ClassMemberPanel getInstance() {
136	return INSTANCE;	139	return INSTANCE;
137	}	140	}
		141
		142	@Override
		143	public UndoRedo getUndoRedo() {
		144	return Lookups.forPath("org/netbeans/modules/refactoring").lookup(UndoRedo.class);
138	}	145	}
		146	}

Lines 151-153 Link Here

(-)openide.actions/src/org/openide/actions/Bundle.properties (+4 lines)
151	MSG_GC=GC...	151	MSG_GC=GC...
152	CTL_GC=Click to force garbage collection	152	CTL_GC=Click to force garbage collection
153		153
		154	LBL_CannotUndo=Cannot Undo
		155	LBL_CannotRedo=Cannot Redo
		156
		157

Lines 43-49 Link Here

(-)openide.actions/src/org/openide/actions/RedoAction.java (-7 / +8 lines)
43	*/	43	*/
44	package org.openide.actions;	44	package org.openide.actions;
45		45
		46	import java.awt.HeadlessException;
		47	import java.util.MissingResourceException;
46	import javax.swing.Action;	48	import javax.swing.Action;
		49	import javax.swing.JOptionPane;
47	import org.openide.awt.UndoRedo;	50	import org.openide.awt.UndoRedo;
48	import org.openide.util.HelpCtx;	51	import org.openide.util.HelpCtx;
49	import org.openide.util.Lookup;	52	import org.openide.util.Lookup;
Lines 52-67 Link Here
52		55
53	import javax.swing.UIManager;	56	import javax.swing.UIManager;
54	import javax.swing.undo.CannotRedoException;	57	import javax.swing.undo.CannotRedoException;
		58	import javax.swing.undo.CannotUndoException;
55	import org.openide.util.ContextAwareAction;	59	import org.openide.util.ContextAwareAction;
56	import org.openide.util.Exceptions;	60	import org.openide.util.Exceptions;
		61	import org.openide.windows.TopComponent;
		62	import org.openide.windows.WindowManager;
57		63
58		64
59	/** Redo an edit. Since version 6.18 this class	65
60	* implements {@link ContextAwareAction}.
61	*
62	* @see UndoAction
63	* @author Ian Formanek, Jaroslav Tulach
64	*/
65	public class RedoAction extends CallableSystemAction implements ContextAwareAction {	66	public class RedoAction extends CallableSystemAction implements ContextAwareAction {
66	private static String SWING_DEFAULT_LABEL = UIManager.getString("AbstractUndoableEdit.redoText"); //NOI18N	67	private static String SWING_DEFAULT_LABEL = UIManager.getString("AbstractUndoableEdit.redoText"); //NOI18N
67		68
Lines 106-112 Link Here
106	undoRedo.redo();	107	undoRedo.redo();
107	}	108	}
108	} catch (CannotRedoException ex) {	109	} catch (CannotRedoException ex) {
109	Exceptions.printStackTrace(ex);	110	UndoRedoAction.cannotUndoRedo(ex);
110	}	111	}
111		112
112	UndoAction.updateStatus();	113	UndoAction.updateStatus();

Lines 56-61 Link Here

(-)openide.actions/src/org/openide/actions/UndoAction.java (-1 / +2 lines)
56	import java.beans.*;	56	import java.beans.*;
57	import java.util.logging.Logger;	57	import java.util.logging.Logger;
58	import java.util.logging.Level;	58	import java.util.logging.Level;
		59	import javax.swing.JOptionPane;
59		60
60	import javax.swing.SwingUtilities;	61	import javax.swing.SwingUtilities;
61	import javax.swing.UIManager;	62	import javax.swing.UIManager;
Lines 185-191 Link Here
185	undoRedo.undo();	186	undoRedo.undo();
186	}	187	}
187	} catch (CannotUndoException ex) {	188	} catch (CannotUndoException ex) {
188	Exceptions.printStackTrace(ex);	189	UndoRedoAction.cannotUndoRedo(ex);
189	}	190	}
190		191
191	updateStatus();	192	updateStatus();




package org.openide.actions;

import java.awt.EventQueue;
import java.awt.HeadlessException;
import java.awt.event.ActionEvent;
import javax.swing.Action;
import org.openide.awt.UndoRedo;


import java.beans.*;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.swing.AbstractAction;
import javax.swing.JOptionPane;

import javax.swing.UIManager;
import javax.swing.event.*;

                undoRedo.undo();
            }
        } catch (CannotUndoException ex) {
            cannotUndoRedo(ex);
        } else try {
            if (undoRedo.canRedo()) {
                undoRedo.redo();
            }
        } catch (CannotRedoException ex) {
            cannotUndoRedo(ex);
        }
        run();
    }

    static void cannotUndoRedo(RuntimeException ex) throws MissingResourceException, HeadlessException {
        if (ex.getMessage() != null) {
            JOptionPane.showMessageDialog(
                    WindowManager.getDefault().getMainWindow(),
                    ex.getMessage(),
                    NbBundle.getMessage(UndoRedoAction.class, ex instanceof CannotUndoException ? "LBL_CannotUndo" : "LBL_CannotRedo"),
                    JOptionPane.ERROR_MESSAGE);
        }
    }


    @Override
    public void propertyChange(PropertyChangeEvent ev) {
        if (TopComponent.Registry.PROP_ACTIVATED.equals(ev.getPropertyName())) {

Lines 51-56 Link Here

(-)openide.text/src/org/openide/text/NbDocument.java (+25 lines)
51	import javax.swing.JToolBar;	51	import javax.swing.JToolBar;
52	import javax.swing.SwingUtilities;	52	import javax.swing.SwingUtilities;
53	import javax.swing.text.*;	53	import javax.swing.text.*;
		54	import javax.swing.undo.UndoableEdit;
		55	import org.openide.awt.UndoRedo;
54	import org.openide.cookies.EditorCookie;	56	import org.openide.cookies.EditorCookie;
55		57
56		58
Lines 519-524 Link Here
519	((Annotatable) doc).removeAnnotation(annotation);	521	((Annotatable) doc).removeAnnotation(annotation);
520	}	522	}
521		523
		524	public static <T> T getEditToBeUndoneOfType(EditorCookie ec, Class<T> type) {
		525	return getEditToBeUndoneRedoneOfType(ec, type, false);
		526	}
		527
		528	public static <T> T getEditToBeRedoneOfType(EditorCookie ec, Class<T> type) {
		529	return getEditToBeUndoneRedoneOfType(ec, type, true);
		530	}
		531
		532	private static <T> T getEditToBeUndoneRedoneOfType(EditorCookie ec, Class<T> type, boolean redone) {
		533	UndoRedo ur;
		534	if (ec instanceof CloneableEditorSupport &&
		535	((ur = ((CloneableEditorSupport)ec).getUndoRedo()) instanceof UndoRedoManager))
		536	{
		537	UndoRedoManager urManager = (UndoRedoManager) ur;
		538	UndoableEdit edit = urManager.editToBeUndoneRedone(redone);
		539	if (type.isInstance(edit)) {
		540	@SuppressWarnings("unchecked") T inst = (T) edit;
		541	return inst;
		542	}
		543	}
		544	return null;
		545	}
		546
522	/** Specialized version of document that knows how to lock the document	547	/** Specialized version of document that knows how to lock the document
523	* for complex modifications.	548	* for complex modifications.
524	*/	549	*/

Lines 564-569 Link Here

(-)openide.text/src/org/openide/text/UndoRedoManager.java (+5 lines)
564	undoGroup = null;	564	undoGroup = null;
565	}	565	}
566		566
		567	UndoableEdit editToBeUndoneRedone(boolean redone) { // Access for NbDocument
		568	WrapUndoEdit wrapEdit = (WrapUndoEdit) (redone ? editToBeRedone() : editToBeUndone());
		569	return wrapEdit.delegate();
		570	}
		571
567	static String editToString(UndoableEdit edit) {	572	static String editToString(UndoableEdit edit) {
568	if (edit instanceof WrapUndoEdit) {	573	if (edit instanceof WrapUndoEdit) {
569	return toStringTerse(edit) + "->" + toStringTerse(((WrapUndoEdit)edit).delegate()); // NOI18N	574	return toStringTerse(edit) + "->" + toStringTerse(((WrapUndoEdit)edit).delegate()); // NOI18N




/*
 * 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-2006 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.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.beans.VetoableChangeListener;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Date;
import javax.swing.event.UndoableEditEvent;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.Position;
import javax.swing.text.StyledDocument;
import javax.swing.undo.AbstractUndoableEdit;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.CompoundEdit;
import javax.swing.undo.UndoableEdit;
import org.netbeans.junit.NbTestCase;
import org.openide.awt.UndoRedo;
import org.openide.cookies.EditorCookie;
import org.openide.text.CloneableEditorSupport.Env;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;
import org.openide.util.RequestProcessor.Task;
import org.openide.windows.CloneableOpenSupport;
import org.openide.windows.CloneableTopComponent;

/**
 * Deadlock of a thread simulating reloading of document and another thread trying to close the file.
 * 
 * @author Miloslav Metelka
 */
public class EditToBeUndoneRedoneTest extends NbTestCase
implements CloneableEditorSupport.Env {
    static {
        System.setProperty("org.openide.windows.DummyWindowManager.VISIBLE", "false");
    }
    /** the support to work with */
    private transient CES support;

    // Env variables
    private transient String content = "";
    private transient boolean valid = true;
    private transient boolean modified = false;
    /** if not null contains message why this document cannot be modified */
    private transient String cannotBeModified;
    private transient Date date = new Date ();
    private transient final PropertyChangeSupport pcl;
    private transient VetoableChangeListener vetoL;
    
    private transient volatile boolean inReloadBeforeSupportLock;
    private transient volatile boolean closing;
    
    private static EditToBeUndoneRedoneTest RUNNING;
    
    public EditToBeUndoneRedoneTest(String s) {
        super(s);
        pcl = new PropertyChangeSupport(this);
    }
    
    protected void setUp () {
        support = new CES (this, Lookup.EMPTY);
        RUNNING = this;
    }
    
    protected boolean runInEQ() {
        return false;
    }

    @Override
    protected int timeOut() {
        return 15000;
    }
    
    private Object writeReplace () {
        return new Replace ();
    }
    
    public void testUndoRedoEdits() throws Exception {
        Document doc = support.openDocument();
        doc.insertString(0, "a", null);
        UndoRedo.Manager ur = support.getUndoRedo();
        MyEdit myEdit = NbDocument.getEditToBeUndoneOfType(support, MyEdit.class);
        assertNotNull("Expected valid myEdit", myEdit);
        ur.undo();
        myEdit = NbDocument.getEditToBeRedoneOfType(support, MyEdit.class);
        assertNotNull("Expected valid myEdit", myEdit);
    }
    
    //
    // Implementation of the CloneableEditorSupport.Env
    //
    
    public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
        pcl.addPropertyChangeListener(l);
    }    
    public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
        pcl.removePropertyChangeListener(l);
    }
    
    public synchronized void addVetoableChangeListener(VetoableChangeListener l) {
        assertNull ("This is the first veto listener", vetoL);
        vetoL = l;
    }
    public void removeVetoableChangeListener(VetoableChangeListener l) {
        assertEquals ("Removing the right veto one", vetoL, l);
        vetoL = null;
    }
    
    public CloneableOpenSupport findCloneableOpenSupport() {
        return RUNNING.support;
    }
    
    public String getMimeType() {
        return "text/plain";
    }
    
    public Date getTime() {
        return date;
    }
    
    public InputStream inputStream() throws IOException {
        return new ByteArrayInputStream (content.getBytes ());
    }
    public OutputStream outputStream() throws IOException {
        class ContentStream extends ByteArrayOutputStream {
            public void close () throws IOException {
                super.close ();
                content = new String (toByteArray ());
            }
        }
        
        return new ContentStream ();
    }
    
    public boolean isValid() {
        return valid;
    }
    
    public boolean isModified() {
        return modified;
    }

    public void markModified() throws IOException {
        if (cannotBeModified != null) {
            final String notify = cannotBeModified;
            IOException e = new IOException () {
                public String getLocalizedMessage () {
                    return notify;
                }
            };
            Exceptions.attachLocalizedMessage(e, cannotBeModified);
            throw e;
        }
        
        modified = true;
    }
    
    public void unmarkModified() {
        modified = false;
    }
    
    /** Implementation of the CES */
    private static final class CES extends CloneableEditorSupport implements EditorCookie {
        public CES (Env env, Lookup l) {
            super (env, l);
        }
        
        @Override
        protected EditorKit createEditorKit () {
            // Important to use NbLikeEditorKit since otherwise FilterDocument
            // would be created with improper runAtomic()
            return new MyKit ();
        }
        public CloneableTopComponent.Ref getRef () {
            return allEditors;
        }
        
        protected String messageName() {
            return "Name";
        }
        
        protected String messageOpened() {
            return "Opened";
        }
        
        protected String messageOpening() {
            return "Opening";
        }
        
        protected String messageSave() {
            return "Save";
        }
        
        protected String messageToolTip() {
            return "ToolTip";
        }
        
    }

    private static final class Replace implements Serializable {
        public Object readResolve () {
            return RUNNING;
        }
    }

    private static final class MyEdit extends CompoundEdit { // Marker custom undo edit
        
    }
    
    private static final class MyKit extends NbLikeEditorKit {

        @Override
        public Document createDefaultDocument() {
            return new Doc() {

                @Override
                protected void fireUndoableEditUpdate(UndoableEditEvent e) {
                    UndoableEdit edit = e.getEdit();
                    MyEdit wrapEdit = new MyEdit();
                    wrapEdit.addEdit(edit);
                    wrapEdit.end();
                    e = new UndoableEditEvent(e.getSource(), wrapEdit);

                    super.fireUndoableEditUpdate(e);
                }

            };
        }
        
        
    }
}




import org.openide.awt.ActionReferences;
import org.openide.awt.ActionRegistration;
import org.openide.awt.StatusDisplayer;
import org.openide.awt.UndoRedo;
import org.openide.explorer.ExplorerManager;
import org.openide.explorer.ExplorerUtils;
import org.openide.explorer.view.BeanTreeView;

import org.openide.util.RequestProcessor.Task;
import org.openide.util.Utilities;
import org.openide.util.WeakListeners;
import org.openide.util.lookup.Lookups;
import org.openide.windows.TopComponent;
import org.openide.windows.WindowManager;


 * @author Petr Hrebejk
 */
public class ProjectTab extends TopComponent 
                        implements ExplorerManager.Provider, PropertyChangeListener, UndoRedo.Provider {
                
    public static final String ID_LOGICAL = "projectTabLogical_tc"; // NOI18N                            
    public static final String ID_PHYSICAL = "projectTab_tc"; // NOI18N                        

        return manager;
    }
    
    @Override
    public UndoRedo getUndoRedo() {
        return Lookups.forPath("org/netbeans/modules/refactoring").lookup(UndoRedo.class);
    }    
    
    /* Singleton accessor. As ProjectTab is persistent singleton this
     * accessor makes sure that ProjectTab is deserialized by window system.
     * Uses known unique TopComponent ID TC_ID = "projectTab_tc" to get ProjectTab instance




    <apidef name="refactoring">Refactoring API</apidef>
</apidefs>
<changes>
    <change id="RefactoringCommit">
        <api name="refactoring"/>
        <summary>Added RefactoringCommit and ModificationResult SPI classes.</summary>
        <version major="1" minor="23"/>
        <date day="2" month="3" year="2011"/>
        <author login="jbecicka"/>
        <compatibility addition="yes"/>
        <description>
            <p>
                Added RefactoringCommit and ModificationResult SPI classes.
            </p>    
        </description>
        <class package="org.netbeans.modules.refactoring.spi" name="ModificationResult"/>
        <class package="org.netbeans.modules.refactoring.spi" name="RefactoringCommit"/>
        <issue number="209110"/>
    </change>
    <change id="CopyRefactoring">
        <api name="refactoring"/>
        <summary>Added CopyRefactoring to support Copy of multiple files.</summary>

Lines 46-55 Link Here

(-)refactoring.api/nbproject/project.xml (-10 / +19 lines)
46	<compile-dependency/>	46	<compile-dependency/>
47	<run-dependency>	47	<run-dependency>
48	<release-version>3</release-version>	48	<release-version>3</release-version>
49	<specification-version>3.1</specification-version>	49	<specification-version>3.20.1</specification-version>
50	</run-dependency>	50	</run-dependency>
51	</dependency>	51	</dependency>
52	<dependency>	52	<dependency>
		53	<code-name-base>org.netbeans.modules.editor.lib2</code-name-base>
		54	<build-prerequisite/>
		55	<compile-dependency/>
		56	<run-dependency>
		57	<release-version>1</release-version>
		58	<specification-version>1.56</specification-version>
		59	</run-dependency>
		60	</dependency>
		61	<dependency>
53	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>	62	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
54	<build-prerequisite/>	63	<build-prerequisite/>
55	<compile-dependency/>	64	<compile-dependency/>
Lines 59-64 Link Here
59	</run-dependency>	68	</run-dependency>
60	</dependency>	69	</dependency>
61	<dependency>	70	<dependency>
		71	<code-name-base>org.netbeans.modules.parsing.api</code-name-base>
		72	<build-prerequisite/>
		73	<compile-dependency/>
		74	<run-dependency>
		75	<release-version>1</release-version>
		76	<specification-version>1.51</specification-version>
		77	</run-dependency>
		78	</dependency>
		79	<dependency>
62	<code-name-base>org.netbeans.modules.projectapi</code-name-base>	80	<code-name-base>org.netbeans.modules.projectapi</code-name-base>
63	<build-prerequisite/>	81	<build-prerequisite/>
64	<compile-dependency/>	82	<compile-dependency/>
Lines 175-189 Link Here
175	<specification-version>6.6</specification-version>	193	<specification-version>6.6</specification-version>
176	</run-dependency>	194	</run-dependency>
177	</dependency>	195	</dependency>
178	<dependency>
179	<code-name-base>org.netbeans.modules.parsing.api</code-name-base>
180	<build-prerequisite/>
181	<compile-dependency/>
182	<run-dependency>
183	<release-version>1</release-version>
184	<specification-version>1.51</specification-version>
185	</run-dependency>
186	</dependency>
187	</module-dependencies>	196	</module-dependencies>
188	<test-dependencies>	197	<test-dependencies>
189	<test-type>	198	<test-type>

Lines 53-67 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/api/RefactoringSession.java (-2 / +51 lines)
53	import java.util.concurrent.atomic.AtomicBoolean;	53	import java.util.concurrent.atomic.AtomicBoolean;
54	import java.util.logging.Level;	54	import java.util.logging.Level;
55	import java.util.logging.Logger;	55	import java.util.logging.Logger;
		56	import javax.swing.text.Document;
56	import org.netbeans.api.annotations.common.CheckForNull;	57	import org.netbeans.api.annotations.common.CheckForNull;
57	import org.netbeans.api.annotations.common.NonNull;	58	import org.netbeans.api.annotations.common.NonNull;
		59	import org.netbeans.api.editor.mimelookup.MimeLookup;
		60	import org.netbeans.editor.BaseDocument;
58	import org.netbeans.modules.refactoring.api.impl.ProgressSupport;	61	import org.netbeans.modules.refactoring.api.impl.ProgressSupport;
59	import org.netbeans.modules.refactoring.api.impl.SPIAccessor;	62	import org.netbeans.modules.refactoring.api.impl.SPIAccessor;
60	import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation;	63	import org.netbeans.modules.refactoring.spi.RefactoringElementImplementation;
61	import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;	64	import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
		65	import org.netbeans.modules.refactoring.spi.RefactoringCommit;
62	import org.netbeans.modules.refactoring.spi.Transaction;	66	import org.netbeans.modules.refactoring.spi.Transaction;
63	import org.netbeans.modules.refactoring.spi.impl.UndoManager;	67	import org.netbeans.modules.refactoring.spi.impl.UndoManager;
		68	import org.netbeans.modules.refactoring.spi.impl.UndoableWrapper;
		69	import org.netbeans.spi.editor.document.UndoableEditWrapper;
64	import org.openide.LifecycleManager;	70	import org.openide.LifecycleManager;
		71	import org.openide.cookies.EditorCookie;
		72	import org.openide.filesystems.FileObject;
		73	import org.openide.loaders.DataObject;
		74	import org.openide.loaders.DataObjectNotFoundException;
65	import org.openide.util.Exceptions;	75	import org.openide.util.Exceptions;
66	import org.openide.util.Parameters;	76	import org.openide.util.Parameters;
67		77
Lines 128-136 Link Here
128	}	138	}
129	}	139	}
130	} finally {	140	} finally {
		141	UndoableWrapper wrapper = MimeLookup.getLookup("").lookup(UndoableWrapper.class);
131	for (Transaction commit:SPIAccessor.DEFAULT.getCommits(bag)) {	142	for (Transaction commit:SPIAccessor.DEFAULT.getCommits(bag)) {
		143	setWrappers(commit, wrapper);
132	commit.commit();	144	commit.commit();
		145	unsetWrappers(commit, wrapper);
133	}	146	}
		147	wrapper.close();
134	}	148	}
135	if (saveAfterDone) {	149	if (saveAfterDone) {
136	LifecycleManager.getDefault().saveAll();	150	LifecycleManager.getDefault().saveAll();
Lines 175-184 Link Here
175	f.undoChange();	189	f.undoChange();
176	}	190	}
177	}	191	}
		192	UndoableWrapper wrapper = MimeLookup.getLookup("").lookup(UndoableWrapper.class);
178	for (ListIterator<Transaction> commitIterator = commits.listIterator(commits.size()); commitIterator.hasPrevious();) {	193	for (ListIterator<Transaction> commitIterator = commits.listIterator(commits.size()); commitIterator.hasPrevious();) {
179	commitIterator.previous().rollback();	194	final Transaction commit = commitIterator.previous();
		195	setWrappers(commit, wrapper);
		196	commit.rollback();
		197	unsetWrappers(commit, wrapper);
180	}	198	}
181		199	wrapper.close();
182	while (it.hasPrevious()) {	200	while (it.hasPrevious()) {
183	fireProgressListenerStep();	201	fireProgressListenerStep();
184	RefactoringElementImplementation element = (RefactoringElementImplementation) it.previous();	202	RefactoringElementImplementation element = (RefactoringElementImplementation) it.previous();
Lines 254-259 Link Here
254	}	272	}
255	}	273	}
256		274
		275	private void setWrappers(Transaction commit, UndoableWrapper wrap) {
		276	wrap.setActive(true);
		277
		278	// if (!(commit instanceof RefactoringCommit))
		279	// return;
		280	// for (FileObject f:((RefactoringCommit) commit).getModifiedFiles()) {
		281	// Document doc = getDocument(f);
		282	// if (doc!=null)
		283	// doc.putProperty(BaseDocument.UndoableEditWrapper.class, wrap);
		284	// }
		285	}
		286
		287	private void unsetWrappers(Transaction commit, UndoableWrapper wrap) {
		288	wrap.setActive(false);
		289
		290	// setWrappers(commit, null);
		291	}
		292
		293	private Document getDocument(FileObject f) {
		294	try {
		295	DataObject dob = DataObject.find(f);
		296	EditorCookie cookie = dob.getLookup().lookup(EditorCookie.class);
		297	if (cookie == null)
		298	return null;
		299	return cookie.getDocument();
		300	} catch (DataObjectNotFoundException ex) {
		301	return null;
		302	}
		303	}
		304
		305
257	private class ElementsCollection extends AbstractCollection<RefactoringElement> {	306	private class ElementsCollection extends AbstractCollection<RefactoringElement> {
258	@Override	307	@Override
259	public Iterator<RefactoringElement> iterator() {	308	public Iterator<RefactoringElement> iterator() {

Lines 54-64 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/api/resources/layer.xml (-5 / +2 lines)
54	<attr name="position" intvalue="400"/>	54	<attr name="position" intvalue="400"/>
55	<attr name="misplaced.action.allowed" boolvalue="true"/>	55	<attr name="misplaced.action.allowed" boolvalue="true"/>
56	</file>	56	</file>
57	<file name="UndoSeparator.instance">
58	<attr name="instanceClass" stringvalue="javax.swing.JSeparator"/>
59	<attr name="position" intvalue="1900"/>
60	</file>
61
62	</folder>	57	</folder>
63		58
64	<folder name="Window">	59	<folder name="Window">
Lines 82-87 Link Here
82	<file name="RefactoringAll.instance">	77	<file name="RefactoringAll.instance">
83	<attr name="instanceCreate" methodvalue="org.netbeans.modules.refactoring.api.ui.RefactoringActionsFactory.popupSubmenuAction"/>	78	<attr name="instanceCreate" methodvalue="org.netbeans.modules.refactoring.api.ui.RefactoringActionsFactory.popupSubmenuAction"/>
84	</file>	79	</file>
		80	<file name="org-netbeans-modules-refactoring-spi-impl-RedoAction.instance_hidden"/>
		81	<file name="org-netbeans-modules-refactoring-spi-impl-UndoAction.instance_hidden"/>
85	</folder>	82	</folder>
86		83
87	<folder name="Window">	84	<folder name="Window">

Lines 96-102 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/BackupFacility.java (+2 lines)
96	* @see RefactoringElementsBag#addFileChange	96	* @see RefactoringElementsBag#addFileChange
97	* @see BackupFacility.Handle	97	* @see BackupFacility.Handle
98	* @author Jan Becicka	98	* @author Jan Becicka
		99	* @deprecated
99	*/	100	*/
		101	@Deprecated
100	public abstract class BackupFacility {	102	public abstract class BackupFacility {
101		103
102	private BackupFacility() {	104	private BackupFacility() {




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.refactoring.spi;

import java.io.*;
import java.net.MalformedURLException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.logging.Logger;
import org.netbeans.editor.BaseDocument;
import org.netbeans.modules.refactoring.spi.impl.UndoableWrapper;
import org.netbeans.modules.refactoring.spi.impl.UndoableWrapper.UndoableEditDelegate;
import org.openide.cookies.EditorCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.text.CloneableEditorSupport;
import org.openide.text.NbDocument;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import sun.misc.IOUtils;

/**
 * Simple backup facility can be used to backup files and implement undo For
 * instance Java Refactoring module implements undo this way:
 * For instance Java Refactoring module implements undo this way:
 *
 * public Problem prepare(RefactoringElementsBag elements) { . .
 * elements.registerTransaction(new RetoucheCommit(results)); }
 * .
 *   elements.registerTransaction(new RetoucheCommit(results));
 * }
 * 
 * where RetoucheCommit is Transaction:
 * <pre>

 * </pre>
 * 
 * You can register your own implementation via META-INF services.
 *
 * @see Transaction
 * @see RefactoringElementImplementation#performChange
 * @see RefactoringElementImplementation#undoChange

 * @see BackupFacility.Handle
 * @author Jan Becicka
 */
abstract class BackupFacility2 {
    
    private static final Logger LOG = Logger.getLogger("org.netbeans.modules.refactoring.Undo");

    private BackupFacility2() {
    }
    private static BackupFacility2 defaultInstance;
    
    private static BackupFacility defaultInstance;
    
    /**
     * does backup
     *
     * @param file file(s) to backup
     * @return handle which can be used to restore files
     * @throws java.io.IOException if backup failed

    
    /**
     * does backup
     *
     * @param fileObjects FileObjects to backup
     * @return handle which can be used to restore files
     * @throws java.io.IOException 

    }
    
    /**
     * do cleanup all backup files are deleted all internal structures cleared
     * default implemntation
     * all internal structures cleared
     * default implementa
     */
    public abstract void clear();
    

     * class in META-INF services -> this class is returned. Otherwise default 
     * implementation is used.
     */
    public static BackupFacility2 getDefault() {
        BackupFacility2 instance = Lookup.getDefault().lookup(BackupFacility2.class);
        return (instance != null) ? instance : getDefaultInstance();
    }
    
    private static synchronized BackupFacility2 getDefaultInstance() {
        if (defaultInstance == null) {
            defaultInstance = new DefaultImpl();
        }

    }
    
    /**
     * Handle class representing handle to file(s), which were backuped by {@link  org.netbeans.modules.refactoring.spi.BackupFacility#backup()}
     * by
     * {@link  org.netbeans.modules.refactoring.spi.BackupFacility#backup()}
     */
    public interface Handle {

        /**
         * restore file(s), which was stored by {@link  org.netbeans.modules.refactoring.spi.BackupFacility#backup()}
         *
         * @throws java.io.IOException if restore failed.
         */
        public abstract void restore() throws java.io.IOException;

        void storeChecksum() throws IOException;

        public Collection<String> checkChecksum(boolean undo) throws IOException;
    }
    
    private static class DefaultHandle implements Handle {

        private List<Long> handle;
        private DefaultImpl instance;

        private DefaultHandle(DefaultImpl instance, List<Long> handles) {
            this.handle = handles;
            this.instance = instance;
        }

        @Override
        public void restore() throws IOException {
            for (long l : handle) {
                instance.restore(l);
            }
        }

        @Override
        public void storeChecksum() throws IOException {
            for (long l : handle) {
                instance.storeChecksum(l);
    }
        }
    
        @Override
        public Collection<String> checkChecksum(boolean undo) throws IOException {
            Collection<String> result = new LinkedList<String>();
            for (long l : handle) {
                String checkChecksum = instance.checkChecksum(l, undo);
                if (checkChecksum !=null) {
                    result.add(checkChecksum);
                }
            }
            return result;
        
        }
    }

    private static class DefaultImpl extends BackupFacility2 {

        private long currentId = 0;
        private Map<Long, BackupEntry> map = new HashMap<Long, BackupEntry>();
        
        private String MD5toString(byte[] digest) {
            StringBuilder b = new StringBuilder();
            for (int i = 0; i < digest.length; i++) {
                b.append(Integer.toHexString(0xFF & digest[i]));
            }
            return b.toString();
        }

        private void storeChecksum(long l) throws IOException {
            BackupEntry backup = map.get(l);
            File f = new File(backup.path);
            FileObject fo = FileUtil.toFileObject(f);
            DataObject dob = DataObject.find(fo);
            if (dob != null) {
                CloneableEditorSupport ces = dob.getLookup().lookup(CloneableEditorSupport.class);
                final BaseDocument doc = (BaseDocument) ces.getDocument();
                if (doc !=null && doc.isAtomicLock()) {
                    //workaround to avoid deadlock
                    return;
                }
            }
            LOG.fine("Storing MD5 for " + backup.path);
            backup.checkSum = getMD5(getInputStream(backup.path));
            LOG.fine("MD5 is: " + MD5toString(backup.checkSum));
        }

        private String checkChecksum(long l, boolean undo) {

            try {
                BackupEntry backup = map.get(l);
                File f = new File(backup.path);
                FileObject fo = FileUtil.toFileObject(f);
                DataObject dob = DataObject.find(fo);
                if (dob != null) {
                    CloneableEditorSupport ces = dob.getLookup().lookup(CloneableEditorSupport.class);

                    final BaseDocument doc = (BaseDocument) ces.getDocument();
                    if (doc != null && doc.isAtomicLock()) {
                        //workaround to avoid deadlock
                        return null;
                    } else {
                        EditorCookie editor = dob.getLookup().lookup(EditorCookie.class);
                        if (editor != null  && doc!=null && editor.isModified()) {
                            UndoableEditDelegate edit = undo?NbDocument.getEditToBeUndoneOfType(editor, UndoableWrapper.UndoableEditDelegate.class):NbDocument.getEditToBeRedoneOfType(editor, UndoableWrapper.UndoableEditDelegate.class);
                            if (edit == null) {
                                try {
                                    LOG.fine("Editor Undo Different");
                                    return backup.path.toURL().getPath();
                                } catch (MalformedURLException ex) {
                                    Exceptions.printStackTrace(ex);
                                }
                            }
                        }

                    }
                }

                try {
                    LOG.fine("Checking MD5 for " + backup.path);
                    byte[] ts = getMD5(getInputStream(backup.path));
                    if (!Arrays.equals(backup.checkSum, ts)) {
                        LOG.fine("MD5 check failed");
                        return backup.path.toURL().getPath();
                    }
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            } catch (DataObjectNotFoundException ex) {
                Exceptions.printStackTrace(ex);
            }
            return null;
        }

        private InputStream getInputStream(URI path) throws IOException {
            File f = new File(path);
            FileObject fo = FileUtil.toFileObject(f);
            DataObject dob = DataObject.find(fo);
            CloneableEditorSupport ces = dob.getLookup().lookup(CloneableEditorSupport.class);
            if (ces != null && ces.isModified()) {
                LOG.fine("Editor Input Stream");
                return ces.getInputStream();
            }
            LOG.fine("File Input Stream");
            return fo.getInputStream();
        }

        private class BackupEntry {

            private File file;
            private URI path;
            private byte[] checkSum;
            private boolean undo = true;

            public BackupEntry() {
        }
        
            public boolean isUndo() {
                return undo;
            }

            public void setUndo(boolean undo) {
                this.undo = undo;
            }
        }

        /**
         * Creates a new instance of BackupFacility
         */
        private DefaultImpl() {
        }
        
        @Override
        public Handle backup(FileObject... file) throws IOException {
            ArrayList<Long> list = new ArrayList<Long>();
            for (FileObject f : file) {
                list.add(backup(f));
            }
            return new DefaultHandle(this, list);
        }

        /**
         * does backup
         *
         * @param file to backup
         * @return id of backup file
         * @throws java.io.IOException if backup failed

                throw (IOException) new IOException(file.toString()).initCause(ex);
            }
        }

        private byte[] getMD5(InputStream is) throws IOException {
            try {
                MessageDigest md = MessageDigest.getInstance("MD5");
                try {
                    is = new DigestInputStream(is, md);
                    IOUtils.readFully(is, -1, true);
                } finally {
                    is.close();
                }
                return md.digest();
            } catch (NoSuchAlgorithmException ex) {
                throw new IOException(ex);
            }
        }

        private static java.lang.reflect.Field undoRedo;

        static {
            try {
                //obviously hack. See 108616 and 48427
                undoRedo = org.openide.text.CloneableEditorSupport.class.getDeclaredField("undoRedo"); //NOI18N
                undoRedo.setAccessible(true);
            } catch (NoSuchFieldException ex) {
                Exceptions.printStackTrace(ex);
            } catch (SecurityException ex) {
                Exceptions.printStackTrace(ex);
            }
        }

        /**
         * restore file, which was stored by backup(file)
         *
         * @param id identification of backup transaction
         * @throws java.io.IOException if restore failed.
         */
        void restore(long id) throws IOException {
            BackupEntry entry = map.get(id);
            if (entry == null) {
                throw new IllegalArgumentException("Backup with id " + id + "does not exist"); // NOI18N
            }
            File backup = File.createTempFile("nbbackup", null); //NOI18N

            File f = new File(entry.path);
            if (createNewFile(f)) {
                backup.createNewFile();
                copy(f, backup);
            }
            FileObject fileObj = FileUtil.toFileObject(f);

            if (!tryUndoOrRedo(fileObj, entry)) {
                copy(entry.file, fileObj);
            }
            entry.file.delete();
            if (backup.exists()) {
                entry.file = backup;

            }
        }
        
        private boolean tryUndoOrRedo(final FileObject fileObj, final BackupEntry entry) throws DataObjectNotFoundException {
            DataObject dob = DataObject.find(fileObj);
            if (dob != null) {
                CloneableEditorSupport ces = dob.getLookup().lookup(CloneableEditorSupport.class);
                final org.openide.awt.UndoRedo.Manager manager;
                try {
                    manager = (org.openide.awt.UndoRedo.Manager) undoRedo.get(ces);
                    final BaseDocument doc = (BaseDocument) ces.getDocument();
                    if (doc==null) {
                        return false;
                    }
                    if (doc.isAtomicLock()) {
                        //undo already performed
                        if (entry.isUndo()) {
                            entry.setUndo(false);
                        } else {
                            entry.setUndo(true);
                        }
                    } else {
                        if ((entry.isUndo() && manager.canUndo()) || (!entry.isUndo() && manager.canRedo())) {
                            doc.runAtomic(new Runnable() {

                                @Override
                                public void run() {
                                    if (entry.isUndo()) {
                                        manager.undo();
                                        entry.setUndo(false);
                                    } else {
                                        manager.redo();
                                        entry.setUndo(true);
                                    }
                                }
                            });
                        } else {
                            return false;
                        }
                    }
                    return true;
                } catch (IllegalArgumentException ex) {
                    Exceptions.printStackTrace(ex);
                } catch (IllegalAccessException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
            return false;
        }

        /**
         * workaround for #93390
         */
        private boolean createNewFile(File f) throws IOException {
            if (f.exists()) {
                return true;
            }
            File parent = f.getParentFile();
            if (parent != null) {
                createNewFolder(parent);
            }
            FileUtil.createData(f);

        
        @Override
        public void clear() {
            for (BackupEntry entry : map.values()) {
                entry.file.delete();
            }
            map.clear();




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.refactoring.spi;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import org.openide.filesystems.FileObject;

/**
 * Result of changes performed by refactoring plugin.
 * @author Jan Becicka
 * @since 1.23
 */
public interface ModificationResult {

    /**
     * New source text for given file. 
     * 
     * @param file
     * @return new source text
     * @throws IOException
     * @throws IllegalArgumentException
     */
    public String getResultingSource(FileObject file) throws IOException, IllegalArgumentException;
    
    /**
     * FileObjects modified by this ModificationResult.
     * @return
     */
    public Collection<? extends FileObject> getModifiedFileObjects();

    /**
     * New files generated by this ModificationResult.
     * @return 
     */
    public Collection<? extends File> getNewFiles();

    /**
     * Performs commit of changes into files.
     * @throws IOException 
     */
    public void commit() throws IOException;
    
}

Lines 41-55 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/RefactoringCommit.java (-20 / +118 lines)
41	* Version 2 license, then the option applies only if the new code is	41	* Version 2 license, then the option applies only if the new code is
42	* made subject to such option by the copyright holder.	42	* made subject to such option by the copyright holder.
43	*/	43	*/
44	package org.netbeans.modules.refactoring.java.plugins;	44	package org.netbeans.modules.refactoring.spi;
45		45
46	import java.io.File;	46	import java.io.File;
47	import java.io.IOException;	47	import java.io.IOException;
48	import java.util.*;	48	import java.util.ArrayList;
		49	import java.util.Collection;
		50	import java.util.HashSet;
		51	import java.util.List;
		52	import java.util.Set;
49	import java.util.logging.Level;	53	import java.util.logging.Level;
50	import java.util.logging.Logger;	54	import java.util.logging.Logger;
51	import org.netbeans.api.java.source.ModificationResult;	55	import javax.swing.undo.CannotRedoException;
52	import org.netbeans.modules.refactoring.spi.BackupFacility;	56	import javax.swing.undo.CannotUndoException;
		57	import org.netbeans.api.annotations.common.NonNull;
		58	import org.netbeans.modules.refactoring.spi.BackupFacility2;
		59	import org.netbeans.modules.refactoring.spi.BackupFacility2.Handle;
53	import org.netbeans.modules.refactoring.spi.Transaction;	60	import org.netbeans.modules.refactoring.spi.Transaction;
54	import org.openide.cookies.EditorCookie;	61	import org.openide.cookies.EditorCookie;
55	import org.openide.filesystems.FileObject;	62	import org.openide.filesystems.FileObject;
Lines 59-103 Link Here
59	import org.openide.util.Exceptions;	66	import org.openide.util.Exceptions;
60		67
61	/**	68	/**
62	*	69	* Default implementation of {@link Transaction}
63	* @author Jan Becicka	70	* @author Jan Becicka
		71	* @since 1.23
64	*/	72	*/
65		73
66	public class RetoucheCommit implements Transaction {	74	public final class RefactoringCommit implements Transaction {
67	private static final Logger LOG = Logger.getLogger(RetoucheCommit.class.getName());	75
68	List<BackupFacility.Handle> ids = new ArrayList<BackupFacility.Handle>();	76	private static final Logger LOG = Logger.getLogger(RefactoringCommit.class.getName());
		77
		78	/**
		79	* FileObjects modified by this Transaction
		80	*
		81	* @return collection of FileObjects
		82	*/
		83	@NonNull Collection<? extends FileObject> getModifiedFiles() {
		84	ArrayList<FileObject> result = new ArrayList();
		85	for (ModificationResult modification:results) {
		86	result.addAll(modification.getModifiedFileObjects());
		87	}
		88	return result;
		89	}
		90
		91	private static class CannotUndoRefactoring extends CannotUndoException {
		92
		93	private Collection<String> files;
		94
		95	private CannotUndoRefactoring(Collection<String> checkChecksum) {
		96	super();
		97	this.files = checkChecksum;
		98	}
		99
		100	@Override
		101	public String getMessage() {
		102	StringBuilder b = new StringBuilder("Cannot Undo.\nFollowing files were modified:\n");
		103	for (String f:files) {
		104	b.append(f);
		105	b.append('\n');
		106	}
		107	return b.toString();
		108	}
		109
		110
		111
		112	public Collection<String> getFiles() {
		113	return files;
		114	}
		115	}
		116
		117	private static class CannotRedoRefactoring extends CannotRedoException {
		118
		119	private Collection<String> files;
		120
		121	private CannotRedoRefactoring(Collection<String> checkChecksum) {
		122	this.files = checkChecksum;
		123	}
		124
		125	public Collection<String> getFiles() {
		126	return files;
		127	}
		128
		129	@Override
		130	public String getMessage() {
		131	StringBuilder b = new StringBuilder("Cannot Redo.\nFollowing files were modified:\n");
		132	for (String f:files) {
		133	b.append(f);
		134	b.append('\n');
		135	}
		136	return b.toString();
		137	}
		138
		139	}
		140
141
142	List<BackupFacility2.Handle> ids = new ArrayList<BackupFacility2.Handle>();
69	private boolean commited = false;	143	private boolean commited = false;
70	Collection<ModificationResult> results;	144	Collection<? extends ModificationResult> results;
71	private Set<File> newFiles;	145	private Set<File> newFiles;
72		146
73	public RetoucheCommit(Collection<ModificationResult> results) {	147	/**
		148	* RefactoringCommit is just collection of ModificationResults
		149	* @param results
		150	*/
		151	public RefactoringCommit(Collection<? extends ModificationResult> results) {
74	this.results = results;	152	this.results = results;
75	}	153	}
76		154
77	@Override
78	public void commit() {	155	public void commit() {
79	try {	156	try {
80	if (commited) {	157	if (commited) {
81	for (BackupFacility.Handle id:ids) {	158	for (BackupFacility2.Handle id : ids) {
		159	Collection<String> checkChecksum = id.checkChecksum(false);
		160	if (!checkChecksum.isEmpty()) {
		161	throw new CannotRedoRefactoring(checkChecksum);
		162	}
		163	}
		164
		165	for (BackupFacility2.Handle id:ids) {
82	try {	166	try {
83	id.restore();	167	id.restore();
		168	id.storeChecksum();
84	} catch (IOException ex) {	169	} catch (IOException ex) {
85	throw new RuntimeException(ex);	170	throw new RuntimeException(ex);
86	}	171	}
87	}	172	}
88	} else {	173	} else {
89	commited = true;	174	commited = true;
90	for (ModificationResult result:results) {	175	for (ModificationResult result : results) {
91	ids.add(BackupFacility.getDefault().backup(result.getModifiedFileObjects()));	176	Handle backupid = BackupFacility2.getDefault().backup(result.getModifiedFileObjects());
		177	ids.add(backupid);
92	if (newFiles == null) {	178	if (newFiles == null) {
93	newFiles = new HashSet<File>();	179	newFiles = new HashSet<File>();
94	}	180	}
95	newFiles.addAll(result.getNewFiles());	181	newFiles.addAll(result.getNewFiles());
96	result.commit();	182	result.commit();
97	}	183	backupid.storeChecksum();
98		184
99	openNewFiles(newFiles);	185	openNewFiles(newFiles);
100	}	186	}
		187	}
101		188
102	} catch (IOException ex) {	189	} catch (IOException ex) {
103	throw new RuntimeException(ex);	190	throw new RuntimeException(ex);
Lines 105-126 Link Here
105	}	192	}
106		193
107	private boolean newFilesStored = false;	194	private boolean newFilesStored = false;
108	@Override	195
109	public void rollback() {	196	public void rollback() {
110	for (BackupFacility.Handle id:ids) {
111	try {	197	try {
		198	for (BackupFacility2.Handle id : ids) {
		199	Collection<String> checkChecksum = id.checkChecksum(true);
		200	if (!checkChecksum.isEmpty()) {
		201	throw new CannotUndoRefactoring(checkChecksum);
		202	}
		203
		204	try {
112	id.restore();	205	id.restore();
		206	id.storeChecksum();
113	} catch (IOException ex) {	207	} catch (IOException ex) {
114	throw new RuntimeException(ex);	208	throw new RuntimeException(ex);
115	}	209	}
116	}	210	}
117	boolean localStored = false;	211	boolean localStored = false;
118	if (newFiles!=null) {	212	if (newFiles != null) {
119	for (File f:newFiles) {	213	for (File f : newFiles) {
120	try {	214	try {
121	FileObject fo = FileUtil.toFileObject(f);	215	FileObject fo = FileUtil.toFileObject(f);
122	if (!newFilesStored) {	216	if (!newFilesStored) {
123	ids.add(BackupFacility.getDefault().backup(fo));	217	ids.add(BackupFacility2.getDefault().backup(fo));
124	localStored = true;	218	localStored = true;
125	}	219	}
126	fo.delete();	220	fo.delete();
Lines 130-137 Link Here
130	}	224	}
131	newFilesStored \|= localStored;	225	newFilesStored \|= localStored;
132	}	226	}
		227	} catch (IOException ex) {
		228	Exceptions.printStackTrace(ex);
133	}	229	}
134		230
		231	}
		232
135	private static void openNewFiles(Set<File> newFiles) {	233	private static void openNewFiles(Set<File> newFiles) {
136	if (newFiles == null) {	234	if (newFiles == null) {
137	return;	235	return;

Lines 51-56 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/impl/Bundle.properties (+6 lines)
51	LBL_MoveAction=&Move...	51	LBL_MoveAction=&Move...
52	LBL_Undo=U&ndo	52	LBL_Undo=U&ndo
53	LBL_Redo=Red&o	53	LBL_Redo=Red&o
		54	MSG_ReallyUndo=Really undo {0}
		55	MSG_ConfirmUndo=Confirm undo
		56	MSG_ReallyRedo=Really redo {0}
		57	MSG_ConfirmRedo=Confirm redo
		58	MSG_ConfirmRefresh=Do you want to refresh refactoring?
		59	MSG_FileModified=Some files were modified
54		60
55	#Refactoring Preview Window	61	#Refactoring Preview Window
56	LBL_CloseWindow=Close Tab	62	LBL_CloseWindow=Close Tab




/*
 * 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-2006 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.netbeans.modules.refactoring.spi.impl;

import java.util.EventListener;

/**
 *
 * @author Jan Becicka
 */
public interface InvalidationListener extends EventListener {
    void invalidateObject();
}




 *
 * @author Martin Matula, Jan Becicka
 */
public class ParametersPanel extends JPanel implements ProgressListener, ChangeListener {
    
    public static final String JUMP_TO_FIRST_OCCURENCE = "JUMP_TO_FIRST_OCCURENCE"; //NOI18N


                                        null);
                                DialogDisplayer.getDefault().notifyLater(nd);
                            } else {
                                //UndoWatcher.watch(session, ParametersPanel.this);
                                session.addProgressListener(ParametersPanel.this);
                                session.doRefactoring(true);
                                //UndoWatcher.stopWatching(ParametersPanel.this);
                            }
                        }
                    } finally {

        return rui.getHelpCtx();
    }
    
    @Override
    public void invalidateObject() {
    }

    private RefactoringSession getResult() {
        synchronized (RESULT_LOCK) {
            return result;




/*
 * 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-2006 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.netbeans.modules.refactoring.spi.impl;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.Action;
import javax.swing.SwingUtilities;
import org.openide.awt.ActionID;
import org.openide.awt.ActionReference;
import org.openide.awt.ActionRegistration;
import org.openide.util.HelpCtx;
import org.openide.util.NbBundle;
import org.openide.util.actions.CallableSystemAction;

@ActionID(id = "org.netbeans.modules.refactoring.spi.impl.RedoAction", category = "Refactoring")
@ActionRegistration(displayName = "#LBL_Redo")
@ActionReference(path = "Menu/Refactoring" , name = "RedoAction", position = 2100)
public class RedoAction extends CallableSystemAction implements PropertyChangeListener {

    private UndoManager undoManager;

    public RedoAction() {
        putValue(Action.NAME, getString("LBL_Redo")); //NOI18N
        putValue("noIconInMenu", Boolean.TRUE); // NOI18N
        undoManager = UndoManager.getDefault();
        undoManager.addPropertyChangeListener(this);
        updateState();
    }
    
    @Override
    public void propertyChange (PropertyChangeEvent event) {
        updateState();
    }
    
    private void updateState() {
        String desc = undoManager.getRedoDescription();
        String name = getString("LBL_Redo");
        if (desc != null) {
            name += " [" + desc + "]"; //NOI18N
        }
        
        final String n = name;
        final boolean b = undoManager.isRedoAvailable();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                setEnabled(b);
                putValue(Action.NAME, n);
            }
        };

        if (SwingUtilities.isEventDispatchThread()) {
            r.run();
        } else {
            SwingUtilities.invokeLater(r);
        }
    }
    
    private static final String getString(String key) {
        return NbBundle.getMessage(RedoAction.class, key);
    }
    
    @Override
    public void performAction() {
        undoManager.redo();
        undoManager.saveAll();
    }
    
    @Override
    public org.openide.util.HelpCtx getHelpCtx() {
        return HelpCtx.DEFAULT_HELP;
    }
    
    @Override
    public String getName() {
        return (String) getValue(Action.NAME);
    }
    
    @Override
    protected boolean asynchronous() {
        return true;
    }
}

Lines 58-63 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/impl/RefactoringPanel.java (-9 / +67 lines)
58	import java.lang.reflect.InvocationTargetException;	58	import java.lang.reflect.InvocationTargetException;
59	import java.util.*;	59	import java.util.*;
60	import java.util.Collection;	60	import java.util.Collection;
		61	import java.util.Map.Entry;
61	import java.util.prefs.Preferences;	62	import java.util.prefs.Preferences;
62	import javax.swing.*;	63	import javax.swing.*;
63	import javax.swing.border.EmptyBorder;	64	import javax.swing.border.EmptyBorder;
Lines 81-86 Link Here
81	import org.openide.DialogDisplayer;	82	import org.openide.DialogDisplayer;
82	import org.openide.ErrorManager;	83	import org.openide.ErrorManager;
83	import org.openide.awt.Mnemonics;	84	import org.openide.awt.Mnemonics;
		85	import org.openide.filesystems.FileObject;
		86	import org.openide.loaders.DataObject;
84	import org.openide.text.CloneableEditorSupport;	87	import org.openide.text.CloneableEditorSupport;
85	import org.openide.text.PositionBounds;	88	import org.openide.text.PositionBounds;
86	import org.openide.util.*;	89	import org.openide.util.*;
Lines 91-97 Link Here
91	*	94	*
92	* @author Pavel Flaska, Martin Matula	95	* @author Pavel Flaska, Martin Matula
93	*/	96	*/
94	public class RefactoringPanel extends JPanel implements InvalidationListener {	97	public class RefactoringPanel extends JPanel {
95	private static final RequestProcessor RP = new RequestProcessor(RefactoringPanel.class.getName(), 1, false, false);	98	private static final RequestProcessor RP = new RequestProcessor(RefactoringPanel.class.getName(), 1, false, false);
96		99
97	// PRIVATE FIELDS	100	// PRIVATE FIELDS
Lines 502-507 Link Here
502	*/	505	*/
503	private void refactor() {	506	private void refactor() {
504	checkEventThread();	507	checkEventThread();
		508	if (!checkTimeStamps()) {
		509	if (JOptionPane.showConfirmDialog(
		510	this,
		511	NbBundle.getMessage(RefactoringPanel.class, "MSG_ConfirmRefresh"),
		512	NbBundle.getMessage(RefactoringPanel.class, "MSG_FileModified"),
		513	JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION) {
		514	refresh(true);
		515	return;
		516	} else {
		517	return;
		518	}
		519	}
505	disableComponents(RefactoringPanel.this);	520	disableComponents(RefactoringPanel.this);
506	progressListener = new ProgressL();	521	progressListener = new ProgressL();
507	RP.post(new Runnable() {	522	RP.post(new Runnable() {
Lines 603-609 Link Here
603	requestFocus();	618	requestFocus();
604	}	619	}
605		620
606	@Override	621	/**
		622	* TODO: probably useless
		623	* remove
		624	*/
607	public void invalidateObject() {	625	public void invalidateObject() {
608	if (isQuery) {	626	if (isQuery) {
609	return;	627	return;
Lines 681-687 Link Here
681	RP.post(new Runnable() {	699	RP.post(new Runnable() {
682	@Override	700	@Override
683	public void run() {	701	public void run() {
684	Set<CloneableEditorSupport> editorSupports = new HashSet<CloneableEditorSupport>();	702	Set<FileObject> fileObjects = new HashSet<FileObject>();
685	int errorsNum = 0;	703	int errorsNum = 0;
686	if (!isQuery) {	704	if (!isQuery) {
687	for (Iterator iter = elements.iterator(); iter.hasNext(); ) {	705	for (Iterator iter = elements.iterator(); iter.hasNext(); ) {
Lines 748-757 Link Here
748	}	766	}
749	}	767	}
750	PositionBounds pb = e.getPosition();	768	PositionBounds pb = e.getPosition();
751	if (pb != null) {	769	fileObjects.add(e.getParentFile());
752	CloneableEditorSupport ces = pb.getBegin().getCloneableEditorSupport();
753	editorSupports.add(ces);
754	}
755		770
756	if (i % 10 == 0)	771	if (i % 10 == 0)
757	progressHandle.progress(i/10);	772	progressHandle.progress(i/10);
Lines 760-766 Link Here
760	//[retouche] JavaModel.getJavaRepository().endTrans();	775	//[retouche] JavaModel.getJavaRepository().endTrans();
761	}	776	}
762		777
763	UndoManager.getDefault().watch(editorSupports, RefactoringPanel.this);	778	//UndoManager.getDefault().watch(editorSupports, RefactoringPanel.this);
		779	storeTimeStamps(fileObjects);
764	} catch (RuntimeException t) {	780	} catch (RuntimeException t) {
765	cleanupTreeElements();	781	cleanupTreeElements();
766	throw t;	782	throw t;
Lines 857-862 Link Here
857	});	873	});
858	}	874	}
859		875
		876	private Map<FileObject, Long> timeStamps = new HashMap<FileObject, Long>();
		877
		878	private void storeTimeStamps(Set<FileObject> fileObjects) {
		879	timeStamps.clear();
		880	for (FileObject fo:fileObjects) {
		881	timeStamps.put(fo, fo.lastModified().getTime());
		882	}
		883	}
		884
		885	/**
		886	* @return true if timestamps are OK
		887	*/
		888	private boolean checkTimeStamps() {
		889	Set<FileObject> modified = getModifiedFileObjects();
		890	for (Entry<FileObject, Long> entry: timeStamps.entrySet()) {
		891	if (modified.contains(entry.getKey()))
		892	return false;
		893	if (!entry.getKey().isValid())
		894	return false;
		895	if (entry.getKey().lastModified().getTime() != entry.getValue())
		896	return false;
		897	}
		898	return true;
		899	}
		900
		901	private Set<FileObject> getModifiedFileObjects() {
		902	Set<FileObject> result = new HashSet();
		903	for (DataObject dob: DataObject.getRegistry().getModified()) {
		904	result.add(dob.getPrimaryFile());
		905	}
		906	return result;
		907	}
		908
		909	private void clearTimeStamps() {
		910	timeStamps.clear();
		911	}
		912
		913
		914
		915
860	private void createTree(TreeNode root) throws MissingResourceException {	916	private void createTree(TreeNode root) throws MissingResourceException {
861	if (tree == null) {	917	if (tree == null) {
862	// add panel with appropriate content	918	// add panel with appropriate content
Lines 1069-1075 Link Here
1069	} */	1125	} */
1070		1126
1071	protected void closeNotify() {	1127	protected void closeNotify() {
1072	UndoWatcher.stopWatching(this);	1128	clearTimeStamps();
		1129	//UndoWatcher.stopWatching(this);
1073	if (tree!=null) {	1130	if (tree!=null) {
1074	ToolTipManager.sharedInstance().unregisterComponent(tree);	1131	ToolTipManager.sharedInstance().unregisterComponent(tree);
1075	scrollPane.getViewport().remove(tree);	1132	scrollPane.getViewport().remove(tree);
Lines 1126-1131 Link Here
1126	handle.start(event.getCount());	1183	handle.start(event.getCount());
1127	d.setVisible(true);	1184	d.setVisible(true);
1128	}	1185	}
		1186
1129	});	1187	});
1130	}	1188	}
1131		1189




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.refactoring.spi.impl;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import org.openide.awt.UndoRedo;
import org.openide.util.ChangeSupport;
import org.openide.util.lookup.ServiceProvider;

/**
 *
 * @author Jan Becicka
 */
@ServiceProvider(service=UndoRedo.class, path="org/netbeans/modules/refactoring")
public class RefactoringUndoRedo implements UndoRedo {
    
    private UndoManager manager = UndoManager.getDefault();
    
    private ChangeSupport pcs = new ChangeSupport(this);
    
    public RefactoringUndoRedo() {
        manager.addChangeListener(new ChangeListener() {

            @Override
            public void stateChanged(ChangeEvent e) {
                pcs.fireChange();
            }

        });
    }

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

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

    @Override
    public void undo() throws CannotUndoException {
        manager.undo();
    }

    @Override
    public void redo() throws CannotRedoException {
        manager.redo();
    }

    @Override
    public void addChangeListener(final ChangeListener l) {
        pcs.addChangeListener(l);
        
    }

    @Override
    public void removeChangeListener(ChangeListener l) {
        pcs.removeChangeListener(l);
    }

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

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




/*
 * 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-2006 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.netbeans.modules.refactoring.spi.impl;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.Action;
import javax.swing.SwingUtilities;
import org.openide.awt.ActionID;
import org.openide.awt.ActionReference;
import org.openide.awt.ActionRegistration;
import org.openide.util.HelpCtx;
import org.openide.util.NbBundle;
import org.openide.util.actions.CallableSystemAction;

@ActionID(id = "org.netbeans.modules.refactoring.spi.impl.UndoAction", category = "Refactoring")
@ActionRegistration(displayName = "#LBL_Undo")
@ActionReference(path = "Menu/Refactoring" , name = "UndoAction", position = 2000)
public class UndoAction extends CallableSystemAction implements PropertyChangeListener {

    private UndoManager undoManager;

    public UndoAction() {
        putValue(Action.NAME, getString("LBL_Undo")); //NOI18N
        putValue("noIconInMenu", Boolean.TRUE); // NOI18N
        undoManager = UndoManager.getDefault();
        undoManager.addPropertyChangeListener(this);
        updateState();
    }
    
    @Override
    public void propertyChange (PropertyChangeEvent event) {
        updateState();
    }
    
    private void updateState() {
        String desc = undoManager.getUndoDescription();
        String name = getString("LBL_Undo"); //NOI18N
        if (desc != null) {
            name += " [" + desc + "]"; //NOI18N
        }

        final String n = name;
        final boolean b = undoManager.isUndoAvailable();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                setEnabled(b);
                putValue(Action.NAME, n);
            }
        };

        if (SwingUtilities.isEventDispatchThread()) {
            r.run();
        } else {
            SwingUtilities.invokeLater(r);
        }
    }
    
    private static final String getString(String key) {
        return NbBundle.getMessage(UndoAction.class, key);
    }
    
    @Override
    public void performAction() {
        undoManager.undo();
        undoManager.saveAll();
    }
    
    @Override
    public org.openide.util.HelpCtx getHelpCtx() {
        return HelpCtx.DEFAULT_HELP;
    }
    
    @Override
    public String getName() {
        return (String) getValue(Action.NAME);
    }

    @Override
    protected boolean asynchronous() {
        return true;
    }
}




 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.refactoring.spi.impl;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedList;
import javax.swing.JOptionPane;
import javax.swing.event.ChangeListener;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.Document;
import javax.swing.text.StyledDocument;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.refactoring.spi.BackupFacility;
import org.netbeans.modules.refactoring.api.ProgressEvent;
import org.netbeans.modules.refactoring.api.ProgressListener;
import org.netbeans.modules.refactoring.api.RefactoringSession;
import org.netbeans.modules.refactoring.spi.BackupFacility;
import org.openide.util.ChangeSupport;
import org.openide.util.NbBundle;
import org.openide.windows.WindowManager;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileRenameEvent;
import org.openide.loaders.DataObject;
import org.openide.text.CloneableEditorSupport;
import org.openide.text.NbDocument;
import org.openide.util.Exceptions;

/**
 *
 * @author Jan Becicka
 */
public final class UndoManager {
    
    /**
     * stack of undo items
     */
    private LinkedList<LinkedList<UndoItem>> undoList;
    /**
     * stack of redo items
     */
    private LinkedList<LinkedList<UndoItem>> redoList;

    private final ChangeSupport changeSupport = new ChangeSupport(this);
    private final Set<CloneableEditorSupport> allCES = new HashSet<CloneableEditorSupport>();
    
    private final Map<FileObject, CloneableEditorSupport> fileObjectToCES = new HashMap<FileObject, CloneableEditorSupport>();
    
    /** map document -> CloneableEditorSupport */
    private final Map<Document, CloneableEditorSupport> documentToCES = new HashMap<Document, CloneableEditorSupport>();
    
    /** map listener -> CloneableEditorSupport */ 
    private final Map<InvalidationListener, Collection<? extends CloneableEditorSupport>> listenerToCES = new HashMap<InvalidationListener, Collection<? extends CloneableEditorSupport>>();
    private boolean listenersRegistered = false;
    
    public static final String PROP_STATE = "state"; //NOI18N
    
    private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
    
    private boolean wasUndo = false;
    private boolean wasRedo = false;
    private boolean transactionStart;
    private boolean dontDeleteUndo = false;
    
    private IdentityHashMap<LinkedList, String> descriptionMap;
    private String description;
    private ProgressListener progress;
    
    private static UndoManager instance;
    private Set<Project> projects;

    /**
     * Singleton instance
     * @return
     */
    public static synchronized UndoManager getDefault() {
        if (instance == null) {
            instance = new UndoManager();
        }
        return instance;
    }

    /**
     * Creates a new instance of UndoManager
     */
    private UndoManager() {
        undoList = new LinkedList<LinkedList<UndoItem>>();
        redoList = new LinkedList<LinkedList<UndoItem>>();
        descriptionMap = new IdentityHashMap<LinkedList, String>();
        projects = new HashSet<Project>();
    }
    
    private UndoManager(ProgressListener progress) {

        this.progress = progress;
    }
    
    /**
     * Setter for undo description. For instance "Rename"
     * @param desc 
     */
    public void setUndoDescription(String desc) { 
        description = desc;
    }
    
    /**
     * Getter for undo description.
     * @return
     */
    public String getUndoDescription() {
        if (undoList.isEmpty()) {
            return null;
        }
        return descriptionMap.get(undoList.getFirst());
    }
    
    /**
     * Getter for Redo description.
     * @return
     */
    public String getRedoDescription() { 
        if (redoList.isEmpty()) {
            return null;
        }
        return descriptionMap.get(redoList.getFirst());
    }
    
    /**
     * called to mark transaction start
     */
    public void transactionStarted() {
        transactionStart = true;
        unregisterListeners();
        //RepositoryUpdater.getDefault().setListenOnChanges(false);
    }
    
    /**
     * called to mark end of transaction
     */
    public void transactionEnded(boolean fail) {
        try {
            description = null;
        if (fail && !undoList.isEmpty()) {
            //XXX todo 
            //undoList.removeFirst();
        } else {
                // [TODO] (jb) this code disables undos for changes using org.openide.src
                if (isUndoAvailable() && getUndoDescription() == null) {
                    descriptionMap.remove(undoList.removeFirst());
                    dontDeleteUndo = false;
                }
                
            }
        fireChange();
            invalidate(null);
            dontDeleteUndo = false;
        } finally {
            if (SwingUtilities.isEventDispatchThread()) {
                registerListeners();
            } else {
                try {
                    SwingUtilities.invokeAndWait(new Runnable() {

                        @Override
                        public void run() {
                            registerListeners();
                        }
                    });
                } catch (InterruptedException ex) {
                    Exceptions.printStackTrace(ex);
                } catch (InvocationTargetException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
            fireStateChange();
        }
    }
    
    /**
     * undo last transaction
     */
    public void undo() {
        //System.out.println("************* Starting UNDO");
        if (isUndoAvailable()) {
            if (JOptionPane.showConfirmDialog(
                    WindowManager.getDefault().getMainWindow(),
                    NbBundle.getMessage(UndoManager.class, "MSG_ReallyUndo", getUndoDescription()),
                    NbBundle.getMessage(UndoManager.class, "MSG_ConfirmUndo"),
                    JOptionPane.YES_NO_OPTION) != JOptionPane.YES_OPTION) {
                throw new CannotUndoException();
            }

            Runnable run = new Runnable() {

                public void run() {
            boolean fail = true;
            try {
                transactionStarted();
                wasUndo = true;
                        LinkedList undo = (LinkedList) undoList.getFirst();
                fireProgressListenerStart(0, undo.size());
                undoList.removeFirst();
                Iterator undoIterator = undo.iterator();
                UndoItem item;
                redoList.addFirst(new LinkedList<UndoItem>());

                        addItem(item);
                    }
                }
                        undoList.removeFirst();
                fail = false;
            } finally {
                try {

                    transactionEnded(fail);
                } finally {
                    fireProgressListenerStop();
                            fireChange();
                }
            }

        }
            };

//            if (SwingUtilities.isEventDispatchThread()) {
//                ProgressUtils.runOffEventDispatchThread(run,
//                        "Undoing... ",
//                        new AtomicBoolean(),
//                        false);
//            } else {
            run.run();
//            }
    }
    }
    
    /**
     * redo last undo
     */
    public void redo() {
        //System.out.println("************* Starting REDO");
        if (isRedoAvailable()) {
            if (JOptionPane.showConfirmDialog(
                    WindowManager.getDefault().getMainWindow(),
                    NbBundle.getMessage(UndoManager.class, "MSG_ReallyRedo", getRedoDescription()),
                    NbBundle.getMessage(UndoManager.class, "MSG_ConfirmRedo"),
                    JOptionPane.YES_NO_OPTION) != JOptionPane.YES_OPTION) {
                throw new CannotRedoException();
            }
            Runnable run = new Runnable() {

                public void run() {
            boolean fail = true;
            try {
                transactionStarted();
                wasRedo = true;
                LinkedList<UndoItem> redo = redoList.getFirst();
                fireProgressListenerStart(1, redo.size());
                redoList.removeFirst();
                Iterator<UndoItem> redoIterator = redo.iterator();
                UndoItem item;
                description = descriptionMap.remove(redo);

                        addItem(item);
                    }
                }
                        redoList.removeFirst();
                fail = false;
            } finally {
                try {

                    transactionEnded(fail);
                } finally {
                    fireProgressListenerStop();
                            fireChange();
                }
            }
        }
            };

//            if (SwingUtilities.isEventDispatchThread()) {
//                ProgressUtils.runOffEventDispatchThread(run,
//                        "Redoing... ",
//                        new AtomicBoolean(),
//                        false);
//            } else {
            run.run();
//            }
    }
    }
    
    /**
     * clean undo/redo stacks
     */
    public void clear() {
        undoList.clear();
        redoList.clear();
        descriptionMap.clear();
        BackupFacility.getDefault().clear();
        fireChange();
    }
    
    public void addItem(RefactoringSession session) {
        addItem(new SessionUndoItem(session));
    }
    
    /**
     * add new item to undo/redo list
     */
    private void addItem(UndoItem item) {
        if (wasUndo) {
            LinkedList<UndoItem> redo = this.redoList.getFirst();

            LinkedList<UndoItem> undo = this.undoList.getFirst();
            undo.addFirst(item);
        }
        if (!(wasUndo || wasRedo)) {
            redoList.clear();
    }
    }
     
    public boolean isUndoAvailable() {
        return !undoList.isEmpty();

        return !redoList.isEmpty();
    }
    
    public void addChangeListener(ChangeListener cl) {
        changeSupport.addChangeListener(cl);
    }
    
    public void removeChangeListener(ChangeListener cl) {
        changeSupport.removeChangeListener(cl);
    }

    private void fireChange() {
        changeSupport.fireChange();
    }
    
    public void watch(Collection<? extends CloneableEditorSupport> ceSupports, InvalidationListener l) {
        synchronized (allCES) {
            registerListeners();
        }
        for (final CloneableEditorSupport ces : ceSupports) {
            final Document d = ces.getDocument();
            if (d!=null) {
                d.render(new Runnable() {
                    @Override
                    public void run() {
                        synchronized(allCES) {
                            if (allCES.add(ces)) {
                                ces.addPropertyChangeListener(UndoManager.this);
                                d.addDocumentListener(UndoManager.this);
                                documentToCES.put(d, ces);
                                Object o = d.getProperty(Document.StreamDescriptionProperty);
                                if (o instanceof DataObject) {
                                    FileObject file = ((DataObject)o).getPrimaryFile();
                                    fileObjectToCES.put(file, ces);
                                    Project p = FileOwnerQuery.getOwner(file);
                                    if (p!= null) 
                                        projects.add(p);
                                }
                            }
                        }
                    }
                });
            } else {
                synchronized(allCES) {
                    if (allCES.add(ces)) {
                        ces.addPropertyChangeListener(UndoManager.this);
                    }
                }
            }
        }
        synchronized(allCES) {
            if (l != null) {
                listenerToCES.put(l, ceSupports);
            }
        }
    }
    
    public void stopWatching(InvalidationListener l) {
        //synchronized (undoStack) {
            synchronized (allCES) {
                listenerToCES.remove(l);
                clearIfPossible();
            }
        //}
    }
    
    private static java.lang.reflect.Field undoRedo;
    
    static{
        try {
            //obviously hack. See 108616 and 48427
            undoRedo = org.openide.text.CloneableEditorSupport.class.getDeclaredField("undoRedo"); //NOI18N
            undoRedo.setAccessible(true);
        } catch (NoSuchFieldException ex) {
            Exceptions.printStackTrace(ex);
        } catch (SecurityException ex) {
            Exceptions.printStackTrace(ex);
        }
    }

    private void discardAllEdits(InvalidationListener l) {
        for (CloneableEditorSupport s:listenerToCES==null||l==null?allCES:listenerToCES.get(l)) {
            try {
                org.openide.awt.UndoRedo.Manager manager = (org.openide.awt.UndoRedo.Manager) undoRedo.get(s);
                if (manager!=null) {
                    //if manager not initialized - there is nothing to discard
                    //#114485
                    manager.discardAllEdits();
                }
            } catch (SecurityException ex) {
                Exceptions.printStackTrace(ex);
            } catch (IllegalArgumentException ex) {
                Exceptions.printStackTrace(ex);
            } catch (IllegalAccessException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
    }
    
//    TODO: 
//    public void pathsAdded(GlobalPathRegistryEvent event) {
//    }
//
//    public void pathsRemoved(GlobalPathRegistryEvent event) {
//        assert event != null : "event == null"; // NOI18N
//        if (event.getId().equals(ClassPath.SOURCE)) {
//            clear();
//        }
//    }

    private void registerListeners() {
        if (listenersRegistered) return;
        // TODO: 
        // GlobalPathRegistry.getDefault().addGlobalPathRegistryListener(this);
        Util.addFileSystemsListener(this);
        for (CloneableEditorSupport ces:allCES) {
            ces.addPropertyChangeListener(this);
        }
        for (Document doc:documentToCES.keySet()) {
            doc.addDocumentListener(this);
        }
        OpenProjects.getDefault().addPropertyChangeListener(this);
        listenersRegistered = true;
    }
    
    private void unregisterListeners() {
        if (!listenersRegistered) return;
        OpenProjects.getDefault().removePropertyChangeListener(this);
        Util.removeFileSystemsListener(this);
        //TODO: 
        //GlobalPathRegistry.getDefault().removeGlobalPathRegistryListener(this);
        for (CloneableEditorSupport ces:allCES) {
            ces.removePropertyChangeListener(this);
        }
        for (Document doc:documentToCES.keySet()) {
            doc.removeDocumentListener(this);
        }
        listenersRegistered = false;
    }
    
    private void invalidate(CloneableEditorSupport ces) {
        synchronized (undoList) {
            if (!(wasRedo || wasUndo) && !dontDeleteUndo) {
                clear();
            } 
            synchronized (allCES) {
                if (ces == null) {
                    // invalidate all
                    for (InvalidationListener lis:listenerToCES.keySet()) {
                        lis.invalidateObject();
                        discardAllEdits(lis);
                    }
                    listenerToCES.clear();
                } else {
                    for (Iterator<Map.Entry<InvalidationListener, Collection<? extends CloneableEditorSupport>>> it = listenerToCES.entrySet().iterator(); it.hasNext();) {
                        Map.Entry<InvalidationListener, Collection<? extends CloneableEditorSupport>> e = it.next();
                        if ((e.getValue()).contains(ces)) {
                            e.getKey().invalidateObject();
                            it.remove();
                        }
                    }
                    /*ces.removeChangeListener(this);
                    allCES.remove(ces);
                    Document d = ces.getDocument();
                    if (d != null) {
                        d.removeDocumentListener(this);
                        documentToCES.remove(d);
                    }
                     */
                }
                clearIfPossible();
            }
        }
    }
    
    private void clearIfPossible() {
        if (listenerToCES.isEmpty() && undoList.isEmpty() && redoList.isEmpty()) {
            unregisterListeners();
            allCES.clear();
            documentToCES.clear();
            fileObjectToCES.clear();
            projects.clear();
        }
    }        
    
    // FileChangeAdapter ........................................................
    
    @Override
    public void fileChanged(FileEvent fe) {   
        CloneableEditorSupport ces = fileObjectToCES.get(fe.getFile());
        if (ces!=null) {
            invalidate(ces);
        }
    }
    
    @Override
    public void fileDeleted(FileEvent fe) {
        fileChanged(fe);
    }

    @Override
    public void fileRenamed(FileRenameEvent fe) {
        fileChanged(fe);
    }
    
    // DocumentListener .........................................................
    
    @Override
    public void changedUpdate(DocumentEvent e) {
    }

    @Override
    public void insertUpdate(DocumentEvent e) {        
        invalidate(documentToCES.get(e.getDocument()));
    }

    @Override
    public void removeUpdate(DocumentEvent e) {
        invalidate(documentToCES.get(e.getDocument()));
    }
        
    private void documentStateChanged(CloneableEditorSupport ces) {
        synchronized (allCES) {
            Document d = ces.getDocument();
            for (Iterator it = documentToCES.entrySet().iterator(); it.hasNext();) {
                Map.Entry en = (Map.Entry) it.next();
                if (en.getValue() == ces) {
                    ((Document) en.getKey()).removeDocumentListener(this);
                    it.remove();
                    break;
                }
            }
            if (d != null) {
                documentToCES.put(d, ces);
                d.addDocumentListener(this);
            }
        }
    }
    
    public void saveAll() {
        synchronized (allCES) {
            unregisterListeners();
        }
        try {
            LifecycleManager.getDefault().saveAll();
        } finally {
            synchronized (allCES) {
                registerListeners();
            }
        }
    }

    private void fireProgressListenerStart(int type, int count) {
        stepCounter = 0;
        if (progress == null) {
            return;
        }
        progress.start(new ProgressEvent(this, ProgressEvent.START, type, count));
    }
    
    private int stepCounter = 0;

    /**
     * Notifies all registered listeners about the event.
     */
    private void fireProgressListenerStep() {
        if (progress == null) {
            return;
        }
        progress.step(new ProgressEvent(this, ProgressEvent.STEP, 0, ++stepCounter));
    }

    /**
     * Notifies all registered listeners about the event.
     */
    private void fireProgressListenerStop() {
        if (progress == null) {
            return;
        }
        progress.stop(new ProgressEvent(this, ProgressEvent.STOP));
    }
    
    private interface UndoItem {

        void undo();

        void redo();
    }
    

        
         private RefactoringSession change;
        
        public SessionUndoItem(RefactoringSession change) {
            this.change = change;
        }
        

            change.doRefactoring(false);
        }
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        if (OpenProjects.PROPERTY_OPEN_PROJECTS.equals(evt.getPropertyName())) {
            Set<Project> p = new HashSet<Project>(projects);
            p.removeAll(Arrays.asList((Project[])evt.getNewValue()));
            if (!p.isEmpty())
                invalidate(null);
        } else if (EditorCookie.Observable.PROP_DOCUMENT.equals(evt.getPropertyName())) {
            documentStateChanged((CloneableEditorSupport) evt.getSource());
        }
    }
}




/*
 * 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-2006 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.netbeans.modules.refactoring.spi.impl;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import org.netbeans.modules.refactoring.api.RefactoringElement;
import org.netbeans.modules.refactoring.api.RefactoringSession;
import org.netbeans.modules.refactoring.spi.impl.UndoManager;
import org.openide.cookies.EditorCookie;
import org.openide.loaders.DataObject;
import org.openide.text.CloneableEditorSupport;
import org.openide.text.PositionBounds;

/** 
 *
 * @author Martin Matula, Daniel Prusa
 */
public class UndoWatcher {

     private static Collection extractCES(Collection elements) {
        HashSet result = new HashSet();
        for (Iterator it = elements.iterator(); it.hasNext();) {
            RefactoringElement e = (RefactoringElement) it.next();
            PositionBounds pb = e.getPosition();
            if (pb != null) {
                CloneableEditorSupport ces = pb.getBegin().getCloneableEditorSupport();
                result.add(ces);
            }
        }
        return result;
    }

    public static void watch(RefactoringSession session, InvalidationListener l) {
        UndoManager.getDefault().watch(extractCES(session.getRefactoringElements()), l);
    }

    public static void stopWatching(InvalidationListener l) {
        UndoManager.getDefault().stopWatching(l);
    }
    
    public static void watch(DataObject o) {
        EditorCookie ces = o.getCookie(EditorCookie.class);
        assert ces instanceof CloneableEditorSupport;
        UndoManager.getDefault().watch(Collections.singleton((CloneableEditorSupport)ces), null);
    }
}




/*
 * 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.netbeans.modules.refactoring.spi.impl;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.undo.CannotRedoException;
import javax.swing.undo.CannotUndoException;
import javax.swing.undo.CompoundEdit;
import javax.swing.undo.UndoableEdit;
import org.netbeans.api.editor.EditorRegistry;
import org.netbeans.api.editor.mimelookup.MimeRegistration;
import org.netbeans.editor.BaseDocument;
import org.netbeans.spi.editor.document.UndoableEditWrapper;
import org.openide.loaders.DataObject;
import org.openide.text.CloneableEditorSupport;

/**
 *
 * @author Jan Becicka
 */
@MimeRegistration(mimeType="", service=UndoableEditWrapper.class)
public class UndoableWrapper implements UndoableEditWrapper {

    private AtomicBoolean active = new AtomicBoolean();
    private Map<BaseDocument, UndoableEditDelegate> docToFirst = new HashMap();

    public UndoableWrapper() {
    }
    

    @Override
    public UndoableEdit wrap(UndoableEdit ed, Document doc) {
        if (!active.get())
            return ed;
        if (doc.getProperty(BaseDocument.StreamDescriptionProperty) == null) {
            //no dataobject
            return ed;
        } 
        UndoableEditDelegate current = new UndoableEditDelegate(ed, (BaseDocument) doc);
        UndoableEditDelegate first = docToFirst.get(doc);
        if (first == null) {
            docToFirst.put((BaseDocument) doc, current);
        }
        return current;
    }

    public void close() {
        for (UndoableEditDelegate first: docToFirst.values()) {
            first.end();
        }
        docToFirst.clear();
    }

    public void setActive(boolean b) {
        active.set(b);
    }

    public class UndoableEditDelegate implements UndoableEdit {

        private UndoManager undoManager;
        private CloneableEditorSupport ces;
        private UndoableEdit delegate;
        private CompoundEdit inner;

        private UndoableEditDelegate(UndoableEdit ed, BaseDocument doc) {
            undoManager = UndoManager.getDefault();
            DataObject dob = (DataObject) doc.getProperty(BaseDocument.StreamDescriptionProperty);
            ces = dob.getLookup().lookup(CloneableEditorSupport.class);
            //this.delegate = ed;
            this.inner = new CompoundEdit();
            inner.addEdit(ed);
            delegate = ed;
        }

        @Override
        public void undo() throws CannotUndoException {
            JTextComponent focusedComponent = EditorRegistry.focusedComponent();
            if (focusedComponent != null) {
                if (focusedComponent.getDocument() == ces.getDocument()) {
                    //call global undo only for focused component
                    undoManager.undo();
                }
            }
            //delegate.undo();
            inner.undo();
        }

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

        @Override
        public void redo() throws CannotRedoException {
            JTextComponent focusedComponent = EditorRegistry.focusedComponent();
            if (focusedComponent != null) {
                if (focusedComponent.getDocument() == ces.getDocument()) {
                    //call global undo only for focused component
                    undoManager.redo();
                }
            }
            //delegate.redo();
            inner.redo();
        }

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

        @Override
        public void die() {
            //delegate.die();
            inner.die();
        }

        @Override
        public boolean addEdit(UndoableEdit ue) {
            if (ue instanceof UndoableEditDelegate) {
                return inner.addEdit(((UndoableEditDelegate) ue).unwrap());
            }
            return false;
            //return delegate.addEdit(ue);
        }
        
        public UndoableEdit unwrap() {
            return delegate;
        }

        @Override
        public boolean replaceEdit(UndoableEdit ue) {
            return inner.replaceEdit(ue);
            //return delegate.replaceEdit(ue);
        }

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

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

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

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

        private void end() {
            inner.end();
        }
    }
}




/*
 * 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-2006 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.netbeans.modules.refactoring.java.plugins;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.api.java.source.ModificationResult;
import org.netbeans.modules.refactoring.spi.BackupFacility;
import org.netbeans.modules.refactoring.spi.Transaction;
import org.openide.cookies.EditorCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.util.Exceptions;

/**
 *
 * @author Jan Becicka
 */

public class RetoucheCommit implements Transaction {
    private static final Logger LOG = Logger.getLogger(RetoucheCommit.class.getName());
    List<BackupFacility.Handle> ids = new ArrayList<BackupFacility.Handle>();
    private boolean commited = false;
    Collection<ModificationResult> results;
    private Set<File> newFiles;
    
    public RetoucheCommit(Collection<ModificationResult> results) {
        this.results = results;
    }
    
    @Override
    public void commit() {
        try {
            if (commited) {
                for (BackupFacility.Handle id:ids) {
                    try {
                        id.restore();
                    } catch (IOException ex) {
                        throw new RuntimeException(ex);
                    }
                }
            } else {
                commited = true;
                for (ModificationResult result:results) {
                    ids.add(BackupFacility.getDefault().backup(result.getModifiedFileObjects()));
                    if (newFiles == null) {
                        newFiles = new HashSet<File>();
                    }
                    newFiles.addAll(result.getNewFiles());
                    result.commit();
                }

                openNewFiles(newFiles);
            }
            
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    private boolean newFilesStored = false;
    @Override
    public void rollback() {
        for (BackupFacility.Handle id:ids) {
            try {
                id.restore();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        }
        boolean localStored = false;
        if (newFiles!=null) {
            for (File f:newFiles) {
                try {
                    FileObject fo = FileUtil.toFileObject(f);
                    if (!newFilesStored) {
                        ids.add(BackupFacility.getDefault().backup(fo));
                        localStored = true;
                    }
                    fo.delete();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                }
            }
            newFilesStored |= localStored;
        }
    }

    private static void openNewFiles(Set<File> newFiles) {
        if (newFiles == null) {
            return;
        }
        for (File file : newFiles) {
            FileObject fo = FileUtil.toFileObject(file);
            if (fo != null) {
                try {
                    DataObject dobj = DataObject.find(fo);
                    EditorCookie editor = dobj.getLookup().lookup(EditorCookie.class);
                    if (editor != null) {
                        editor.open();
                    }
                } catch (DataObjectNotFoundException ex) {
                    // not harmful
                    LOG.log(Level.INFO, ex.getMessage(), ex);
                }
            }
        }
    }
}
            




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 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 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.refactoring.java.spi;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import org.netbeans.modules.refactoring.spi.ModificationResult;
import org.openide.filesystems.FileObject;

/**
 *
 * @author Jan Becicka
 */
class JavaModificationResult implements ModificationResult {

    private org.netbeans.api.java.source.ModificationResult delegate;
    
    JavaModificationResult(org.netbeans.api.java.source.ModificationResult r) {
        this.delegate = r;
    }

    @Override
    public Collection<? extends FileObject> getModifiedFileObjects() {
        return delegate.getModifiedFileObjects();
    }

    @Override
    public Collection<? extends File> getNewFiles() {
        return delegate.getNewFiles();
    }

    @Override
    public void commit() throws IOException {
        delegate.commit();
    }

    @Override
    public String getResultingSource(FileObject file) throws IOException, IllegalArgumentException {
        return delegate.getResultingSource(file);
    }
}




import org.netbeans.modules.refactoring.java.api.JavaRefactoringUtils;
import org.netbeans.modules.refactoring.java.plugins.FindVisitor;
import org.netbeans.modules.refactoring.java.plugins.JavaPluginUtils;
import org.netbeans.modules.refactoring.spi.RefactoringCommit;
import org.netbeans.modules.refactoring.spi.ProgressProviderAdapter;
import org.netbeans.modules.refactoring.spi.RefactoringElementsBag;
import org.netbeans.modules.refactoring.spi.RefactoringPlugin;

     * @author Jan Becicka
     */
    public static Transaction createTransaction(@NonNull Collection<ModificationResult> modifications) {
        return new RefactoringCommit(createJavaModifications(modifications));
    }

    private static Collection<org.netbeans.modules.refactoring.spi.ModificationResult> createJavaModifications(Collection<ModificationResult> modifications) {
        LinkedList<org.netbeans.modules.refactoring.spi.ModificationResult> result = new LinkedList();
        for (ModificationResult r:modifications) {
            result.add(new JavaModificationResult(r));
        }
        return result;
    }
    
    
    protected Problem preCheck(CompilationController javac) throws IOException {
        return null;
    }

Return to bug 48427

Lines 45-51 Link Here

(-)editor.lib/src/org/netbeans/editor/BaseDocument.java (-3 / +18 lines)
45	package org.netbeans.editor;	45	package org.netbeans.editor;
46		46
47	import java.awt.Font;	47	import java.awt.Font;
48	import java.beans.PropertyVetoException;
49	import java.beans.VetoableChangeListener;	48	import java.beans.VetoableChangeListener;
50	import java.util.Hashtable;	49	import java.util.Hashtable;
51	import java.util.Dictionary;	50	import java.util.Dictionary;
Lines 56-61 Link Here
56	import java.beans.PropertyChangeListener;	55	import java.beans.PropertyChangeListener;
57	import java.beans.PropertyChangeEvent;	56	import java.beans.PropertyChangeEvent;
58	import java.beans.PropertyChangeSupport;	57	import java.beans.PropertyChangeSupport;
		58	import java.util.Collection;
59	import java.util.EventListener;	59	import java.util.EventListener;
60	import java.util.HashSet;	60	import java.util.HashSet;
61	import java.util.Set;	61	import java.util.Set;
Lines 112-122 Link Here
112	import org.netbeans.modules.editor.lib2.document.ReadWriteBuffer;	112	import org.netbeans.modules.editor.lib2.document.ReadWriteBuffer;
113	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;	113	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;
114	import org.netbeans.modules.editor.lib2.document.StableCompoundEdit;	114	import org.netbeans.modules.editor.lib2.document.StableCompoundEdit;
		115	import org.netbeans.spi.editor.document.UndoableEditWrapper;
115	import org.netbeans.spi.lexer.MutableTextInput;	116	import org.netbeans.spi.lexer.MutableTextInput;
116	import org.netbeans.spi.lexer.TokenHierarchyControl;	117	import org.netbeans.spi.lexer.TokenHierarchyControl;
117	import org.openide.filesystems.FileObject;	118	import org.openide.filesystems.FileObject;
118	import org.openide.util.RequestProcessor;
119	import org.openide.util.RequestProcessor.Task;
120	import org.openide.util.WeakListeners;	119	import org.openide.util.WeakListeners;
121		120
122	/**	121	/**
Lines 346-351 Link Here
346		345
347	private UndoableEdit removeUpdateLineUndo;	346	private UndoableEdit removeUpdateLineUndo;
348		347
		348	private Collection<? extends UndoableEditWrapper> undoEditWrappers;
		349
349	private DocumentFilter.FilterBypass filterBypass;	350	private DocumentFilter.FilterBypass filterBypass;
350		351
351	private Preferences prefs;	352	private Preferences prefs;
Lines 565-570 Link Here
565		566
566	TrailingWhitespaceRemove.install(this);	567	TrailingWhitespaceRemove.install(this);
567		568
		569	undoEditWrappers = MimeLookup.getLookup(mimeType).lookupAll(UndoableEditWrapper.class);
		570
568	if (weakPrefsListener == null) {	571	if (weakPrefsListener == null) {
569	// the listening could have already been initialized from setMimeType(), which	572	// the listening could have already been initialized from setMimeType(), which
570	// is called by some kits from initDocument()	573	// is called by some kits from initDocument()
Lines 1571-1576 Link Here
1571	}	1574	}
1572		1575
1573	protected @Override void fireUndoableEditUpdate(UndoableEditEvent e) {	1576	protected @Override void fireUndoableEditUpdate(UndoableEditEvent e) {
		1577	// Possibly wrap contained edit
		1578	if (undoEditWrappers != null) {
		1579	UndoableEdit origEdit = e.getEdit();
		1580	UndoableEdit edit = origEdit;
		1581	for (UndoableEditWrapper wrapper : undoEditWrappers) {
		1582	edit = wrapper.wrap(edit, this);
		1583	}
		1584	if (edit != origEdit) {
		1585	e = new UndoableEditEvent(this, edit);
		1586	}
		1587	}
		1588
1574	// Fire to the list of listeners that was used before the atomic lock started	1589	// Fire to the list of listeners that was used before the atomic lock started
1575	// This fixes issue #47881 and appears to be somewhat more logical	1590	// This fixes issue #47881 and appears to be somewhat more logical
1576	// than the default approach to fire all the current listeners	1591	// than the default approach to fire all the current listeners

Line 0 Link Here

(-)editor.lib/test/unit/src/org/netbeans/editor/TestingUndoableEditWrapper.java (+72 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 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	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.editor;
		43
		44	import javax.swing.text.Document;
		45	import javax.swing.undo.CompoundEdit;
		46	import javax.swing.undo.UndoableEdit;
		47	import org.netbeans.spi.editor.document.UndoableEditWrapper;
		48
		49	/**
		50	*
		51	* @author mmetelka
		52	*/
		53	//@MimeRegistration(mimeType="", service=UndoableEditWrapper.class)
		54	public class TestingUndoableEditWrapper implements UndoableEditWrapper {
		55
		56	@Override
		57	public UndoableEdit wrap(UndoableEdit edit, Document doc) {
		58	WrapCompoundEdit wrapEdit = new WrapCompoundEdit();
		59	wrapEdit.addEdit(edit);
		60	wrapEdit.end();
		61	return wrapEdit;
		62	}
		63
		64	static final class WrapCompoundEdit extends CompoundEdit {
65
66	WrapCompoundEdit() {
67	}
68
69	}
70
71
72	}

Line 0 Link Here

(-)editor.lib/test/unit/src/org/netbeans/editor/UndoableEditWrapperTest.java (+80 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-2006 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.netbeans.editor;
		46
		47	import javax.swing.event.UndoableEditEvent;
		48	import javax.swing.event.UndoableEditListener;
		49	import javax.swing.undo.UndoableEdit;
		50	import org.netbeans.api.editor.mimelookup.MimePath;
		51	import org.netbeans.api.editor.mimelookup.test.MockMimeLookup;
		52	import org.netbeans.junit.NbTestCase;
		53
		54	/**
		55	*
		56	* @author Miloslav Metelka
		57	*/
		58	public class UndoableEditWrapperTest extends NbTestCase {
		59
		60	/** Creates a new instance of ZOrderTest */
		61	public UndoableEditWrapperTest(String name) {
		62	super(name);
		63	}
		64
65	public void testWrapping() throws Exception {
66	MimePath mimePath = MimePath.EMPTY;
67	MockMimeLookup.setInstances(mimePath, new TestingUndoableEditWrapper());
68	BaseDocument bDoc = new BaseDocument(false, "");
69	bDoc.addUndoableEditListener(new UndoableEditListener() {
70	@Override
71	public void undoableEditHappened(UndoableEditEvent e) {
72	UndoableEdit edit = e.getEdit();
73	assertEquals("Expected WrapCompoundEdit.class",
74	TestingUndoableEditWrapper.WrapCompoundEdit.class, edit.getClass());
75	}
76	});
77	bDoc.insertString(0, "Test", null);
78	}
79
80	}

Line 0 Link Here

(-)editor.lib2/src/org/netbeans/spi/editor/document/UndoableEditWrapper.java (+68 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2012 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	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.spi.editor.document;
		43
		44	import javax.swing.text.Document;
		45	import javax.swing.undo.UndoableEdit;
		46	import org.netbeans.api.annotations.common.NonNull;
		47
		48	/**
		49	* Wrap undoable edits generated by document implementation into a custom undoable edit.
		50	* <br/>
		51	* Instances should be registered by using @MimeRegistration.
		52	*
		53	* @author Miloslav Metelka
		54	*/
		55	public interface UndoableEditWrapper {
		56
		57	/**
		58	* Wrap given undoable edit by a custom undoable edit implementation
		59	* (or leave it as it is).
		60	*
		61	* @param edit original undoable edit generated by document (or previous wrapper).
		62	* @param doc document which generated the original undoable edit.
		63	* @return wrap edit or original edit.
		64	* @since 1.56
65	*/
66	@NonNull UndoableEdit wrap(@NonNull UndoableEdit edit, @NonNull Document doc);
67
68	}

Line 0 Link Here

(-)openide.text/test/unit/src/org/openide/text/EditToBeUndoneRedoneTest.java (+285 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-2006 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.beans.PropertyChangeListener;
		48	import java.beans.PropertyChangeSupport;
		49	import java.beans.VetoableChangeListener;
		50	import java.io.ByteArrayInputStream;
		51	import java.io.ByteArrayOutputStream;
		52	import java.io.IOException;
		53	import java.io.InputStream;
		54	import java.io.OutputStream;
		55	import java.io.Serializable;
		56	import java.util.Date;
		57	import javax.swing.event.UndoableEditEvent;
		58	import javax.swing.text.AttributeSet;
		59	import javax.swing.text.BadLocationException;
		60	import javax.swing.text.Document;
		61	import javax.swing.text.EditorKit;
		62	import javax.swing.text.Position;
		63	import javax.swing.text.StyledDocument;
		64	import javax.swing.undo.AbstractUndoableEdit;
65	import javax.swing.undo.CannotRedoException;
66	import javax.swing.undo.CannotUndoException;
67	import javax.swing.undo.CompoundEdit;
68	import javax.swing.undo.UndoableEdit;
69	import org.netbeans.junit.NbTestCase;
70	import org.openide.awt.UndoRedo;
71	import org.openide.cookies.EditorCookie;
72	import org.openide.text.CloneableEditorSupport.Env;
73	import org.openide.util.Exceptions;
74	import org.openide.util.Lookup;
75	import org.openide.util.RequestProcessor;
76	import org.openide.util.RequestProcessor.Task;
77	import org.openide.windows.CloneableOpenSupport;
78	import org.openide.windows.CloneableTopComponent;
79
80	/**
81	* Deadlock of a thread simulating reloading of document and another thread trying to close the file.
82	*
83	* @author Miloslav Metelka
84	*/
85	public class EditToBeUndoneRedoneTest extends NbTestCase
86	implements CloneableEditorSupport.Env {
87	static {
88	System.setProperty("org.openide.windows.DummyWindowManager.VISIBLE", "false");
89	}
90	/** the support to work with */
91	private transient CES support;
92
93	// Env variables
94	private transient String content = "";
95	private transient boolean valid = true;
96	private transient boolean modified = false;
97	/** if not null contains message why this document cannot be modified */
98	private transient String cannotBeModified;
99	private transient Date date = new Date ();
100	private transient final PropertyChangeSupport pcl;
101	private transient VetoableChangeListener vetoL;
102
103	private transient volatile boolean inReloadBeforeSupportLock;
104	private transient volatile boolean closing;
105
106	private static EditToBeUndoneRedoneTest RUNNING;
107
108	public EditToBeUndoneRedoneTest(String s) {
109	super(s);
110	pcl = new PropertyChangeSupport(this);
111	}
112
113	protected void setUp () {
114	support = new CES (this, Lookup.EMPTY);
115	RUNNING = this;
116	}
117
118	protected boolean runInEQ() {
119	return false;
120	}
121
122	@Override
123	protected int timeOut() {
124	return 15000;
125	}
126
127	private Object writeReplace () {
128	return new Replace ();
129	}
130
131	public void testUndoRedoEdits() throws Exception {
132	Document doc = support.openDocument();
133	doc.insertString(0, "a", null);
134	UndoRedo.Manager ur = support.getUndoRedo();
135	MyEdit myEdit = NbDocument.getEditToBeUndoneOfType(support, MyEdit.class);
136	assertNotNull("Expected valid myEdit", myEdit);
137	ur.undo();
138	myEdit = NbDocument.getEditToBeRedoneOfType(support, MyEdit.class);
139	assertNotNull("Expected valid myEdit", myEdit);
140	}
141
142	//
143	// Implementation of the CloneableEditorSupport.Env
144	//
145
146	public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
147	pcl.addPropertyChangeListener(l);
148	}
149	public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
150	pcl.removePropertyChangeListener(l);
151	}
152
153	public synchronized void addVetoableChangeListener(VetoableChangeListener l) {
154	assertNull ("This is the first veto listener", vetoL);
155	vetoL = l;
156	}
157	public void removeVetoableChangeListener(VetoableChangeListener l) {
158	assertEquals ("Removing the right veto one", vetoL, l);
159	vetoL = null;
160	}
161
162	public CloneableOpenSupport findCloneableOpenSupport() {
163	return RUNNING.support;
164	}
165
166	public String getMimeType() {
167	return "text/plain";
168	}
169
170	public Date getTime() {
171	return date;
172	}
173
174	public InputStream inputStream() throws IOException {
175	return new ByteArrayInputStream (content.getBytes ());
176	}
177	public OutputStream outputStream() throws IOException {
178	class ContentStream extends ByteArrayOutputStream {
179	public void close () throws IOException {
180	super.close ();
181	content = new String (toByteArray ());
182	}
183	}
184
185	return new ContentStream ();
186	}
187
188	public boolean isValid() {
189	return valid;
190	}
191
192	public boolean isModified() {
193	return modified;
194	}
195
196	public void markModified() throws IOException {
197	if (cannotBeModified != null) {
198	final String notify = cannotBeModified;
199	IOException e = new IOException () {
200	public String getLocalizedMessage () {
201	return notify;
202	}
203	};
204	Exceptions.attachLocalizedMessage(e, cannotBeModified);
205	throw e;
206	}
207
208	modified = true;
209	}
210
211	public void unmarkModified() {
212	modified = false;
213	}
214
215	/** Implementation of the CES */
216	private static final class CES extends CloneableEditorSupport implements EditorCookie {
217	public CES (Env env, Lookup l) {
218	super (env, l);
219	}
220
221	@Override
222	protected EditorKit createEditorKit () {
223	// Important to use NbLikeEditorKit since otherwise FilterDocument
224	// would be created with improper runAtomic()
225	return new MyKit ();
226	}
227	public CloneableTopComponent.Ref getRef () {
228	return allEditors;
229	}
230
231	protected String messageName() {
232	return "Name";
233	}
234
235	protected String messageOpened() {
236	return "Opened";
237	}
238
239	protected String messageOpening() {
240	return "Opening";
241	}
242
243	protected String messageSave() {
244	return "Save";
245	}
246
247	protected String messageToolTip() {
248	return "ToolTip";
249	}
250
251	}
252
253	private static final class Replace implements Serializable {
254	public Object readResolve () {
255	return RUNNING;
256	}
257	}
258
259	private static final class MyEdit extends CompoundEdit { // Marker custom undo edit
260
261	}
262
263	private static final class MyKit extends NbLikeEditorKit {
264
265	@Override
266	public Document createDefaultDocument() {
267	return new Doc() {
268
269	@Override
270	protected void fireUndoableEditUpdate(UndoableEditEvent e) {
271	UndoableEdit edit = e.getEdit();
272	MyEdit wrapEdit = new MyEdit();
273	wrapEdit.addEdit(edit);
274	wrapEdit.end();
275	e = new UndoableEditEvent(e.getSource(), wrapEdit);
276
277	super.fireUndoableEditUpdate(e);
278	}
279
280	};
281	}
282
283
284	}
285	}

Lines 101-106 Link Here

(-)projectui/src/org/netbeans/modules/project/ui/ProjectTab.java (-1 / +8 lines)
101	import org.openide.awt.ActionReferences;	101	import org.openide.awt.ActionReferences;
102	import org.openide.awt.ActionRegistration;	102	import org.openide.awt.ActionRegistration;
103	import org.openide.awt.StatusDisplayer;	103	import org.openide.awt.StatusDisplayer;
		104	import org.openide.awt.UndoRedo;
104	import org.openide.explorer.ExplorerManager;	105	import org.openide.explorer.ExplorerManager;
105	import org.openide.explorer.ExplorerUtils;	106	import org.openide.explorer.ExplorerUtils;
106	import org.openide.explorer.view.BeanTreeView;	107	import org.openide.explorer.view.BeanTreeView;
Lines 125-130 Link Here
125	import org.openide.util.RequestProcessor.Task;	126	import org.openide.util.RequestProcessor.Task;
126	import org.openide.util.Utilities;	127	import org.openide.util.Utilities;
127	import org.openide.util.WeakListeners;	128	import org.openide.util.WeakListeners;
		129	import org.openide.util.lookup.Lookups;
128	import org.openide.windows.TopComponent;	130	import org.openide.windows.TopComponent;
129	import org.openide.windows.WindowManager;	131	import org.openide.windows.WindowManager;
130		132
Lines 135-141 Link Here
135	* @author Petr Hrebejk	137	* @author Petr Hrebejk
136	*/	138	*/
137	public class ProjectTab extends TopComponent	139	public class ProjectTab extends TopComponent
138	implements ExplorerManager.Provider, PropertyChangeListener {	140	implements ExplorerManager.Provider, PropertyChangeListener, UndoRedo.Provider {
139		141
140	public static final String ID_LOGICAL = "projectTabLogical_tc"; // NOI18N	142	public static final String ID_LOGICAL = "projectTabLogical_tc"; // NOI18N
141	public static final String ID_PHYSICAL = "projectTab_tc"; // NOI18N	143	public static final String ID_PHYSICAL = "projectTab_tc"; // NOI18N
Lines 248-253 Link Here
248	return manager;	250	return manager;
249	}	251	}
250		252
		253	@Override
		254	public UndoRedo getUndoRedo() {
		255	return Lookups.forPath("org/netbeans/modules/refactoring").lookup(UndoRedo.class);
		256	}
		257
251	/* Singleton accessor. As ProjectTab is persistent singleton this	258	/* Singleton accessor. As ProjectTab is persistent singleton this
252	* accessor makes sure that ProjectTab is deserialized by window system.	259	* accessor makes sure that ProjectTab is deserialized by window system.
253	* Uses known unique TopComponent ID TC_ID = "projectTab_tc" to get ProjectTab instance	260	* Uses known unique TopComponent ID TC_ID = "projectTab_tc" to get ProjectTab instance

Lines 49-54 Link Here

(-)refactoring.api/apichanges.xml (+16 lines)
49	<apidef name="refactoring">Refactoring API</apidef>	49	<apidef name="refactoring">Refactoring API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="RefactoringCommit">
		53	<api name="refactoring"/>
		54	<summary>Added RefactoringCommit and ModificationResult SPI classes.</summary>
		55	<version major="1" minor="23"/>
		56	<date day="2" month="3" year="2011"/>
		57	<author login="jbecicka"/>
		58	<compatibility addition="yes"/>
		59	<description>
		60	<p>
		61	Added RefactoringCommit and ModificationResult SPI classes.
		62	</p>
		63	</description>
		64	<class package="org.netbeans.modules.refactoring.spi" name="ModificationResult"/>
		65	<class package="org.netbeans.modules.refactoring.spi" name="RefactoringCommit"/>
		66	<issue number="209110"/>
		67	</change>
52	<change id="CopyRefactoring">	68	<change id="CopyRefactoring">
53	<api name="refactoring"/>	69	<api name="refactoring"/>
54	<summary>Added CopyRefactoring to support Copy of multiple files.</summary>	70	<summary>Added CopyRefactoring to support Copy of multiple files.</summary>

Lines 86-92 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/impl/ParametersPanel.java (-7 / +3 lines)
86	*	86	*
87	* @author Martin Matula, Jan Becicka	87	* @author Martin Matula, Jan Becicka
88	*/	88	*/
89	public class ParametersPanel extends JPanel implements ProgressListener, ChangeListener, InvalidationListener {	89	public class ParametersPanel extends JPanel implements ProgressListener, ChangeListener {
90		90
91	public static final String JUMP_TO_FIRST_OCCURENCE = "JUMP_TO_FIRST_OCCURENCE"; //NOI18N	91	public static final String JUMP_TO_FIRST_OCCURENCE = "JUMP_TO_FIRST_OCCURENCE"; //NOI18N
92		92
Lines 478-487 Link Here
478	null);	478	null);
479	DialogDisplayer.getDefault().notifyLater(nd);	479	DialogDisplayer.getDefault().notifyLater(nd);
480	} else {	480	} else {
481	UndoWatcher.watch(session, ParametersPanel.this);	481	//UndoWatcher.watch(session, ParametersPanel.this);
482	session.addProgressListener(ParametersPanel.this);	482	session.addProgressListener(ParametersPanel.this);
483	session.doRefactoring(true);	483	session.doRefactoring(true);
484	UndoWatcher.stopWatching(ParametersPanel.this);	484	//UndoWatcher.stopWatching(ParametersPanel.this);
485	}	485	}
486	}	486	}
487	} finally {	487	} finally {
Lines 1031-1040 Link Here
1031	return rui.getHelpCtx();	1031	return rui.getHelpCtx();
1032	}	1032	}
1033		1033
1034	@Override
1035	public void invalidateObject() {
1036	}
1037
1038	private RefactoringSession getResult() {	1034	private RefactoringSession getResult() {
1039	synchronized (RESULT_LOCK) {	1035	synchronized (RESULT_LOCK) {
1040	return result;	1036	return result;

Line 0 Link Here

(-)refactoring.api/src/org/netbeans/modules/refactoring/spi/impl/UndoableWrapper.java (+206 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
		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	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.refactoring.spi.impl;
		43
		44	import java.util.HashMap;
		45	import java.util.Map;
		46	import java.util.concurrent.atomic.AtomicBoolean;
		47	import javax.swing.text.Document;
		48	import javax.swing.text.JTextComponent;
		49	import javax.swing.undo.CannotRedoException;
		50	import javax.swing.undo.CannotUndoException;
		51	import javax.swing.undo.CompoundEdit;
		52	import javax.swing.undo.UndoableEdit;
		53	import org.netbeans.api.editor.EditorRegistry;
		54	import org.netbeans.api.editor.mimelookup.MimeRegistration;
		55	import org.netbeans.editor.BaseDocument;
		56	import org.netbeans.spi.editor.document.UndoableEditWrapper;
		57	import org.openide.loaders.DataObject;
		58	import org.openide.text.CloneableEditorSupport;
		59
		60	/**
		61	*
		62	* @author Jan Becicka
		63	*/
		64	@MimeRegistration(mimeType="", service=UndoableEditWrapper.class)
65	public class UndoableWrapper implements UndoableEditWrapper {
66
67	private AtomicBoolean active = new AtomicBoolean();
68	private Map<BaseDocument, UndoableEditDelegate> docToFirst = new HashMap();
69
70	public UndoableWrapper() {
71	}
72
73
74	@Override
75	public UndoableEdit wrap(UndoableEdit ed, Document doc) {
76	if (!active.get())
77	return ed;
78	if (doc.getProperty(BaseDocument.StreamDescriptionProperty) == null) {
79	//no dataobject
80	return ed;
81	}
82	UndoableEditDelegate current = new UndoableEditDelegate(ed, (BaseDocument) doc);
83	UndoableEditDelegate first = docToFirst.get(doc);
84	if (first == null) {
85	docToFirst.put((BaseDocument) doc, current);
86	}
87	return current;
88	}
89
90	public void close() {
91	for (UndoableEditDelegate first: docToFirst.values()) {
92	first.end();
93	}
94	docToFirst.clear();
95	}
96
97	public void setActive(boolean b) {
98	active.set(b);
99	}
100
101	public class UndoableEditDelegate implements UndoableEdit {
102
103	private UndoManager undoManager;
104	private CloneableEditorSupport ces;
105	private UndoableEdit delegate;
106	private CompoundEdit inner;
107
108	private UndoableEditDelegate(UndoableEdit ed, BaseDocument doc) {
109	undoManager = UndoManager.getDefault();
110	DataObject dob = (DataObject) doc.getProperty(BaseDocument.StreamDescriptionProperty);
111	ces = dob.getLookup().lookup(CloneableEditorSupport.class);
112	//this.delegate = ed;
113	this.inner = new CompoundEdit();
114	inner.addEdit(ed);
115	delegate = ed;
116	}
117
118	@Override
119	public void undo() throws CannotUndoException {
120	JTextComponent focusedComponent = EditorRegistry.focusedComponent();
121	if (focusedComponent != null) {
122	if (focusedComponent.getDocument() == ces.getDocument()) {
123	//call global undo only for focused component
124	undoManager.undo();
125	}
126	}
127	//delegate.undo();
128	inner.undo();
129	}
130
131	@Override
132	public boolean canUndo() {
133	//return delegate.canUndo();
134	return inner.canUndo();
135	}
136
137	@Override
138	public void redo() throws CannotRedoException {
139	JTextComponent focusedComponent = EditorRegistry.focusedComponent();
140	if (focusedComponent != null) {
141	if (focusedComponent.getDocument() == ces.getDocument()) {
142	//call global undo only for focused component
143	undoManager.redo();
144	}
145	}
146	//delegate.redo();
147	inner.redo();
148	}
149
150	@Override
151	public boolean canRedo() {
152	//return delegate.canRedo();
153	return inner.canRedo();
154	}
155
156	@Override
157	public void die() {
158	//delegate.die();
159	inner.die();
160	}
161
162	@Override
163	public boolean addEdit(UndoableEdit ue) {
164	if (ue instanceof UndoableEditDelegate) {
165	return inner.addEdit(((UndoableEditDelegate) ue).unwrap());
166	}
167	return false;
168	//return delegate.addEdit(ue);
169	}
170
171	public UndoableEdit unwrap() {
172	return delegate;
173	}
174
175	@Override
176	public boolean replaceEdit(UndoableEdit ue) {
177	return inner.replaceEdit(ue);
178	//return delegate.replaceEdit(ue);
179	}
180
181	@Override
182	public boolean isSignificant() {
183	return inner.isSignificant();
184	//return delegate.isSignificant();
185	}
186
187	@Override
188	public String getPresentationName() {
189	return undoManager.getUndoDescription();
190	}
191
192	@Override
193	public String getUndoPresentationName() {
194	return undoManager.getUndoDescription();
195	}
196
197	@Override
198	public String getRedoPresentationName() {
199	return undoManager.getRedoDescription();
200	}
201
202	private void end() {
203	inner.end();
204	}
205	}
206	}

Lines 1-156 Link Here

(-)refactoring.java/src/org/netbeans/modules/refactoring/java/plugins/RetoucheCommit.java (-156 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-2006 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	package org.netbeans.modules.refactoring.java.plugins;
45
46	import java.io.File;
47	import java.io.IOException;
48	import java.util.*;
49	import java.util.logging.Level;
50	import java.util.logging.Logger;
51	import org.netbeans.api.java.source.ModificationResult;
52	import org.netbeans.modules.refactoring.spi.BackupFacility;
53	import org.netbeans.modules.refactoring.spi.Transaction;
54	import org.openide.cookies.EditorCookie;
55	import org.openide.filesystems.FileObject;
56	import org.openide.filesystems.FileUtil;
57	import org.openide.loaders.DataObject;
58	import org.openide.loaders.DataObjectNotFoundException;
59	import org.openide.util.Exceptions;
60
61	/**
62	*
63	* @author Jan Becicka
64	*/
65
66	public class RetoucheCommit implements Transaction {
67	private static final Logger LOG = Logger.getLogger(RetoucheCommit.class.getName());
68	List<BackupFacility.Handle> ids = new ArrayList<BackupFacility.Handle>();
69	private boolean commited = false;
70	Collection<ModificationResult> results;
71	private Set<File> newFiles;
72
73	public RetoucheCommit(Collection<ModificationResult> results) {
74	this.results = results;
75	}
76
77	@Override
78	public void commit() {
79	try {
80	if (commited) {
81	for (BackupFacility.Handle id:ids) {
82	try {
83	id.restore();
84	} catch (IOException ex) {
85	throw new RuntimeException(ex);
86	}
87	}
88	} else {
89	commited = true;
90	for (ModificationResult result:results) {
91	ids.add(BackupFacility.getDefault().backup(result.getModifiedFileObjects()));
92	if (newFiles == null) {
93	newFiles = new HashSet<File>();
94	}
95	newFiles.addAll(result.getNewFiles());
96	result.commit();
97	}
98
99	openNewFiles(newFiles);
100	}
101
102	} catch (IOException ex) {
103	throw new RuntimeException(ex);
104	}
105	}
106
107	private boolean newFilesStored = false;
108	@Override
109	public void rollback() {
110	for (BackupFacility.Handle id:ids) {
111	try {
112	id.restore();
113	} catch (IOException ex) {
114	throw new RuntimeException(ex);
115	}
116	}
117	boolean localStored = false;
118	if (newFiles!=null) {
119	for (File f:newFiles) {
120	try {
121	FileObject fo = FileUtil.toFileObject(f);
122	if (!newFilesStored) {
123	ids.add(BackupFacility.getDefault().backup(fo));
124	localStored = true;
125	}
126	fo.delete();
127	} catch (IOException ex) {
128	Exceptions.printStackTrace(ex);
129	}
130	}
131	newFilesStored \|= localStored;
132	}
133	}
134
135	private static void openNewFiles(Set<File> newFiles) {
136	if (newFiles == null) {
137	return;
138	}
139	for (File file : newFiles) {
140	FileObject fo = FileUtil.toFileObject(file);
141	if (fo != null) {
142	try {
143	DataObject dobj = DataObject.find(fo);
144	EditorCookie editor = dobj.getLookup().lookup(EditorCookie.class);
145	if (editor != null) {
146	editor.open();
147	}
148	} catch (DataObjectNotFoundException ex) {
149	// not harmful
150	LOG.log(Level.INFO, ex.getMessage(), ex);
151	}
152	}
153	}
154	}
155	}
156