Attachment #129370 for bug #200020

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





        List<Node> detailNodes = new ArrayList<Node>(textDetails.size());
        for (TextDetail txtDetail : textDetails) {
            detailNodes.add(
                    new TextDetail.DetailNode(txtDetail, false, resultModel));
        }

        return detailNodes.toArray(new Node[detailNodes.size()]);
    }

    public Children getDetailsChildren(boolean replacing) {
        return new DetailsChildren(replacing, resultModel);
    }

    /**

    private class DetailsChildren extends Children.Keys<TextDetail> {

        private boolean replacing;
        private final ResultModel model;

        public DetailsChildren(boolean replacing, ResultModel model) {
            this.replacing = replacing;
            setKeys(getTextDetails());
            this.model = model;
        }

        @Override
        protected Node[] createNodes(TextDetail key) {
            return new Node[]{new TextDetail.DetailNode(key, replacing, model)};
        }
    }


Lines 48-59 Link Here

(-)a/api.search/src/org/netbeans/modules/search/ResultModel.java (-1 / +78 lines)
48	import java.beans.PropertyChangeListener;	48	import java.beans.PropertyChangeListener;
49	import java.beans.PropertyChangeSupport;	49	import java.beans.PropertyChangeSupport;
50	import java.nio.charset.Charset;	50	import java.nio.charset.Charset;
		51	import java.util.ArrayList;
		52	import java.util.Arrays;
51	import java.util.List;	53	import java.util.List;
		54	import java.util.logging.Level;
		55	import java.util.logging.Logger;
52	import javax.swing.event.ChangeEvent;	56	import javax.swing.event.ChangeEvent;
53	import javax.swing.event.ChangeListener;	57	import javax.swing.event.ChangeListener;
54	import org.netbeans.modules.search.Constants.Limit;	58	import org.netbeans.modules.search.Constants.Limit;
55	import org.openide.ErrorManager;	59	import org.openide.ErrorManager;
56	import org.openide.filesystems.FileObject;	60	import org.openide.filesystems.FileObject;
		61	import org.openide.filesystems.FileUtil;
		62	import org.openide.loaders.DataObject;
57	import org.openide.nodes.Node;	63	import org.openide.nodes.Node;
58		64
59		65
Lines 64-70 Link Here
64	* @author Marian Petras	70	* @author Marian Petras
65	*/	71	*/
66	public final class ResultModel {	72	public final class ResultModel {
67		73	private static final Logger LOG =
		74	Logger.getLogger(ResultModel.class.getName());
		75	public static final String PROP_REMOVED = "remove"; //NOI18N
		76	public static final String PROP_REMOVEDDETAIL = "removeDetail"; //NOI18N
68	public static final String PROP_SELECTION = "selection"; //NOI18N	77	public static final String PROP_SELECTION = "selection"; //NOI18N
69	public static final String PROP_VALID = "valid"; //NOI18N	78	public static final String PROP_VALID = "valid"; //NOI18N
70	public static final String PROP_MATCHING_OBJECTS =	79	public static final String PROP_MATCHING_OBJECTS =
Lines 115-120 Link Here
115	isFullText = (basicCriteria != null) && basicCriteria.isFullText();	124	isFullText = (basicCriteria != null) && basicCriteria.isFullText();
116	startTime = -1;	125	startTime = -1;
117	}	126	}
		127
		128	/**
		129	* Remove the {@link MatchingObject} from the model and informs the
		130	* listeners.
		131	*
		132	* @param mo Matching object to remove.
		133	*/
		134	public void remove(MatchingObject mo) {
		135
		136	matchingObjects.remove(mo);
		137	totalDetailsCount -= getDetailsCount(mo);
		138
		139	mo.cleanup();
		140	// inform listeners, old object contains removed object
		141	propertyChangeSupport.firePropertyChange(PROP_REMOVED,
		142	Arrays.asList(mo), null);
		143	}
		144
		145	public void removeDetailMatch(TextDetail txtDetail) {
		146	MatchingObject found = getMatchingObjectFor(txtDetail);
		147	LOG.log(Level.FINE, "Found {0}", found); //NOI18N
		148	if (null != found) {
		149	found.textDetails.remove(txtDetail);
		150	totalDetailsCount--;
		151
		152	if (found.textDetails.isEmpty()) {
		153	remove(found);
		154	} else {
		155	propertyChangeSupport.firePropertyChange(PROP_REMOVEDDETAIL,
		156	Arrays.asList(), null);
		157	}
		158	// inform listeners, old object contains removed object
		159	}
		160	}
		161
		162	public void removeFolder(DataObject folder) {
		163	List<MatchingObject> list = new ArrayList<MatchingObject>();
		164
		165	for (MatchingObject mo : matchingObjects) {
		166	FileObject folderOfFile = mo.getFileObject().getParent();
		167	FileObject folderToRemove = folder.getPrimaryFile();
		168	boolean isInFolder = folderOfFile.equals(folderToRemove);
		169	boolean isInSubFolder = FileUtil.isParentOf(
		170	folderToRemove, folderOfFile);
		171	if (isInFolder \|\| isInSubFolder) {
		172	list.add(mo);
		173	}
		174	}
		175	matchingObjects.removeAll(list);
		176	for (MatchingObject mo : list) {
		177
		178	totalDetailsCount -= getDetailsCount(mo);
		179	mo.cleanup();
		180	}
		181	// inform listeners, old object contains removed objects
		182	propertyChangeSupport.firePropertyChange(PROP_REMOVED, list, null);
		183	}
		184
		185	private MatchingObject getMatchingObjectFor(TextDetail txtDetail) {
		186	for (MatchingObject mo : matchingObjects) {
		187	for (TextDetail textDetail : mo.getTextDetails()) {
		188	if (textDetail == txtDetail) {
		189	return mo;
		190	}
191	}
192	}
193	return null;
194	}
118		195
119	/**	196	/**
120	*/	197	*/




import java.awt.datatransfer.Transferable;
import java.awt.event.ActionEvent;
import java.io.CharConversionException;
import java.io.IOException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

        /** Cached toString value. */
        private String name;
        private String htmlDisplayName;
        private final ResultModel model;
        
        /**
         * Constructs a node representing the specified information about

         *
         * @param txtDetail  information to be represented by this node
         */
        public DetailNode(TextDetail txtDetail, boolean replacing,
                ResultModel model) {
            super(Children.LEAF, Lookups.fixed(txtDetail,
                    new ReplaceCheckableNode(txtDetail, replacing)));
            
            this.txtDetail = txtDetail;
            this.model = model;
            
            setValue(SearchDisplayer.ATTR_OUTPUT_LINE,
                     DetailNode.getFullDesc(txtDetail));

        protected void createPasteTypes(Transferable t, List<PasteType> s) {
        }
        
        @Override
        public boolean canDestroy() {
            return true;
        }

        @Override
        public void destroy() throws IOException {
            this.model.removeDetailMatch(txtDetail);
//            super.destroy();
        }
    } // End of DetailNode class.

    /**

Lines 126-131 Link Here

(-)a/api.search/src/org/netbeans/modules/search/ui/AbstractSearchResultsPanel.java (+6 lines)
126	this.searchProviderPresenter = searchProviderPresenter;	126	this.searchProviderPresenter = searchProviderPresenter;
127	initComponents();	127	initComponents();
128	explorerManager = new ExplorerManager();	128	explorerManager = new ExplorerManager();
		129
		130	ActionMap map = this.getActionMap();
		131	// map delete key to delete action
		132	map.put("delete", //NOI18N
		133	ExplorerUtils.actionDelete(explorerManager, false));
		134
129	lookup = ExplorerUtils.createLookup(explorerManager,	135	lookup = ExplorerUtils.createLookup(explorerManager,
130	ResultView.getInstance().getActionMap());	136	ResultView.getInstance().getActionMap());
131	initActions();	137	initActions();

Lines 45-50 Link Here

(-)a/api.search/src/org/netbeans/modules/search/ui/BasicAbstractResultsPanel.java (-1 / +10 lines)
45	import java.awt.EventQueue;	45	import java.awt.EventQueue;
46	import java.awt.event.ActionEvent;	46	import java.awt.event.ActionEvent;
47	import java.awt.event.ActionListener;	47	import java.awt.event.ActionListener;
		48	import java.beans.PropertyChangeEvent;
		49	import java.beans.PropertyChangeListener;
48	import java.beans.PropertyVetoException;	50	import java.beans.PropertyVetoException;
49	import java.util.ResourceBundle;	51	import java.util.ResourceBundle;
50	import javax.accessibility.AccessibleContext;	52	import javax.accessibility.AccessibleContext;
Lines 74-80 Link Here
74	* @author jhavlin	76	* @author jhavlin
75	*/	77	*/
76	public abstract class BasicAbstractResultsPanel	78	public abstract class BasicAbstractResultsPanel
77	extends AbstractSearchResultsPanel {	79	extends AbstractSearchResultsPanel implements PropertyChangeListener {
78		80
79	@StaticResource	81	@StaticResource
80	private static final String SHOW_DETAILS_ICON =	82	private static final String SHOW_DETAILS_ICON =
Lines 120-127 Link Here
120	setRootDisplayName(NbBundle.getMessage(ResultView.class,	122	setRootDisplayName(NbBundle.getMessage(ResultView.class,
121	"TEXT_SEARCHING___")); //NOI18N	123	"TEXT_SEARCHING___")); //NOI18N
122	initAccessibility();	124	initAccessibility();
		125	this.resultModel.addPropertyChangeListener(
		126	ResultModel.PROP_REMOVED, this);
123	}	127	}
124		128
		129	@Override
		130	public void propertyChange (PropertyChangeEvent evt) {
		131	// update the root node after change in model
		132	setFinalRootNodeText();
		133	}
125		134
126	public void update() {	135	public void update() {
127	if (details && btnExpand.isVisible() && !btnExpand.isEnabled()) {	136	if (details && btnExpand.isVisible() && !btnExpand.isEnabled()) {




import org.netbeans.api.annotations.common.StaticResource;
import org.netbeans.modules.search.MatchingObject;
import org.netbeans.modules.search.MatchingObject.InvalidityStatus;
import org.netbeans.modules.search.ResultModel;
import org.openide.actions.DeleteAction;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;

    private boolean valid = true;
    private PropertyChangeListener validityListener;
    private PropertyChangeListener selectionListener;
    private ResultModel resultModel;
    PropertySet[] propertySets;

    public MatchingObjectNode(Node original,
            org.openide.nodes.Children children, MatchingObject matchingObject,
            final boolean replacing, ResultModel model) {
        this(original, children, matchingObject,
                new ReplaceCheckableNode(matchingObject, replacing), model);
    }

    private MatchingObjectNode(Node original,
            org.openide.nodes.Children children,
            final MatchingObject matchingObject,
            ReplaceCheckableNode checkableNode, ResultModel model) {
        super(children, Lookups.fixed(matchingObject, checkableNode,
                matchingObject.getFileObject()));
        Parameters.notNull("original", original);                       //NOI18N
        this.resultModel = model;
        this.matchingObject = matchingObject;
        if (matchingObject.isObjectValid()) {
            this.original = original;

        if (!context) {
            return new Action[]{
                        SystemAction.get(OpenMatchingObjectsAction.class),
                        new CopyPathAction(),
                        SystemAction.get(DeleteAction.class)
                    };
        } else {
            return new Action[0];


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

    public void clean() {

        return propertySets;
    }

    @Override
    public void destroy () throws IOException {
        // when removing the node, the node's content is removed from model
        resultModel.remove(this.matchingObject);
    }

    /**
     * Check whether the file object is valid and a valid data object can be
     * found for it. It should be checked after original node is destroyed. It




import java.beans.PropertyChangeSupport;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedList;

import org.netbeans.modules.search.MatchingObject;
import org.netbeans.modules.search.ResultModel;
import org.netbeans.modules.search.Selectable;
import org.netbeans.modules.search.TextDetail;
import org.netbeans.modules.search.ui.AbstractSearchResultsPanel.RootNode;
import org.netbeans.swing.etable.ETableColumnModel;
import org.netbeans.swing.outline.Outline;

 *
 * @author jhavlin
 */
public class ResultsOutlineSupport implements PropertyChangeListener {

    @StaticResource
    private static final String ROOT_NODE_ICON =

        this.details = details;
        this.resultModel = resultModel;
        this.basicComposition = basicComposition;
        this.resultsNode = new ResultsNode(resultModel);
        this.infoNode = infoNode;
        this.invisibleRoot = new RootNode(resultsNode, infoNode);
        this.matchingObjectNodes = new LinkedList<MatchingObjectNode>();
        createOutlineView();
        this.resultModel.addPropertyChangeListener(
                ResultModel.PROP_REMOVED, this);
    }

    @Override
    @SuppressWarnings("unchecked")
    public void propertyChange(PropertyChangeEvent evt) {
        List<MatchingObject> items = (List<MatchingObject>) evt.getOldValue();

        //support folders (multiple matching objects) or single matching objects
        for (MatchingObject mo : items) {
            removedMatchingObject(mo);
        }

        // rebuild the tree from the modified model
        this.update();
    }

    private void createOutlineView() {

        private FolderTreeChildren folderTreeChildren;
        private String htmlDisplayName = null;

        public ResultsNode(ResultModel model) {
            super(new FlatChildren());
            this.flatChildren = (FlatChildren) this.getChildren();
            this.folderTreeChildren =
                    new FolderTreeChildren(rootPathItem, model);
        }

        void update() {

        } else {
            children = key.getDetailsChildren(replacing);
        }
        MatchingObjectNode mon = new MatchingObjectNode(
                delegate, children, key, replacing, resultModel);
        synchronized (this) {
            if (!closed) {
                matchingObjectNodes.add(mon);

        }
        return rootFiles;
    }
    public synchronized void removedMatchingObject(MatchingObject mo) {
        if (closed) {
            return;
        }
        removeFilesFromTreeView(rootPathItem, mo);
        removeEmptyFoldersFromTreeView(rootPathItem);
    }

    public synchronized void removedTextDetail(TextDetail detail) {
        if (closed) {
            return;
        }
//        removeFilesFromTreeView(rootPathItem,  mo);
        removeEmptyFoldersFromTreeView(rootPathItem);
    }

    private List<FileObject> getRelativePath(FileObject parent, FileObject fo) {
        List<FileObject> l = new LinkedList<FileObject>();

        return l;
    }

    private void removeFilesFromTreeView(FolderTreeItem parentItem,
            MatchingObject matchingObject) {
        List<FolderTreeItem> removeableItems = new ArrayList<FolderTreeItem>();

        for (FolderTreeItem pi : parentItem.getChildren()) {
            if (!pi.isPathLeaf()) {
                //start recursion for folders
                removeFilesFromTreeView(pi, matchingObject);
            } else {
                if (pi.getMatchingObject().equals(matchingObject)) {
                    // collect all the files which have to be removed
                    removeableItems.add(pi);
                }
            }
        }
        parentItem.removeChildren(removeableItems);
    }

    private void removeEmptyFoldersFromTreeView(FolderTreeItem parentItem) {
        List<FolderTreeItem> emptyFolders = new ArrayList<FolderTreeItem>();

        for (FolderTreeItem pi : parentItem.getChildren()) {
            {
                // start recursion
                removeEmptyFoldersFromTreeView(pi);

                if (pi.getChildren().isEmpty()
                        && null == pi.getMatchingObject()) {
                    // collect all the empty folders which have to be removed
                    emptyFolders.add(pi);
                }
            }
        }
        // remove empty folders
        parentItem.removeChildren(emptyFolders);
    }

    private void addToTreeView(FolderTreeItem parentItem, List<FileObject> path,
            MatchingObject matchingObject) {
        for (FolderTreeItem pi : parentItem.getChildren()) {

            return children;
        }

        public boolean removeChildren (Collection<FolderTreeItem> list) {
            boolean result = children.removeAll(list);
            firePropertyChange(PROP_CHILDREN, null, null);
            return result;
        }

        public MatchingObject getMatchingObject() {
            return matchingObject;
        }

    }

    private class FolderTreeNode extends FilterNode {
        private ResultModel model;

        public FolderTreeNode(FolderTreeItem pathItem, ResultModel model) {
            super(pathItem.getFolder().getNodeDelegate(),
                    new FolderTreeChildren(pathItem, model),
                    Lookups.fixed(pathItem,
                    new ReplaceCheckableNode(pathItem, replacing),
                    pathItem.getFolder().getPrimaryFile()));
            this.model=model;
            pathItem.addPropertyChangeListener(new PropertyChangeListener() {
                @Override
                public void propertyChange(PropertyChangeEvent evt) {

        }

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

        @Override
        public void destroy () throws IOException {
            //FIXME alter the model
            FolderTreeItem folder =
                    this.getLookup().lookup(FolderTreeItem.class);
            this.model.removeFolder(folder.getFolder());
//            this.resultModel.remove(this.getLookup().lookup(FolderTreeItem.class));
        }

        @Override
        public Transferable drag() throws IOException {
            return UiUtils.DISABLE_TRANSFER;
        }

    private class FolderTreeChildren extends Children.Keys<FolderTreeItem> {

        private FolderTreeItem item = null;
        private final ResultModel model;

        public FolderTreeChildren(FolderTreeItem pathItem, ResultModel model) {
            this.item = pathItem;
            pathItem.addPropertyChangeListener(new PropertyChangeListener() {
                @Override

                    }
                }
            });
            this.model = model;
        }

        @Override

            if (key.isPathLeaf()) {
                n = createNodeForMatchingObject(key.getMatchingObject());
            } else {
                n = new FolderTreeNode(key, model);
            }
            return new Node[]{n};
        }

Lines 144-150 Link Here

(-)a/api.search/test/unit/src/org/netbeans/modules/search/TextDetailTest.java (-1 / +1 lines)
144		144
145	public String createHtmlDisplayName(String line, String match) {	145	public String createHtmlDisplayName(String line, String match) {
146	TextDetail td = createMockTextDetail(line, match);	146	TextDetail td = createMockTextDetail(line, match);
147	DetailNode detailNode = new TextDetail.DetailNode(td, false);	147	DetailNode detailNode = new TextDetail.DetailNode(td, false, null);
148	String htmlDisplayName = detailNode.getHtmlDisplayName();	148	String htmlDisplayName = detailNode.getHtmlDisplayName();
149	Pattern p = Pattern.compile("(<html><font .>\\s\\d+: </font>)(.?)(\\s+<font .>\\[.*\\]</font></html>)");	149	Pattern p = Pattern.compile("(<html><font .>\\s\\d+: </font>)(.?)(\\s+<font .>\\[.*\\]</font></html>)");
150	Matcher m = p.matcher(htmlDisplayName);	150	Matcher m = p.matcher(htmlDisplayName);

Lines 85-91 Link Here

(-)a/api.search/test/unit/src/org/netbeans/modules/search/ui/MatchingObjectNodeTest.java (-2 / +2 lines)
85	ResultModel rm = SearchTestUtils.createResultModelWithOneMatch();	85	ResultModel rm = SearchTestUtils.createResultModelWithOneMatch();
86	MatchingObject mo = rm.getMatchingObjects().get(0);	86	MatchingObject mo = rm.getMatchingObjects().get(0);
87	MatchingObjectNode mon = new MatchingObjectNode(n, Children.LEAF, mo,	87	MatchingObjectNode mon = new MatchingObjectNode(n, Children.LEAF, mo,
88	false);	88	false, rm);
89	mon.addNodeListener(new DisplayNameChangeListener(s));	89	mon.addNodeListener(new DisplayNameChangeListener(s));
90	mon.getDisplayName();	90	mon.getDisplayName();
91	mo.getFileObject().delete();	91	mo.getFileObject().delete();
Lines 105-111 Link Here
105	Node original = dob.getNodeDelegate();	105	Node original = dob.getNodeDelegate();
106	fob.delete();	106	fob.delete();
107	// No exception should be thrown from the constructor.	107	// No exception should be thrown from the constructor.
108	Node n = new MatchingObjectNode(original, Children.LEAF, mo, false);	108	Node n = new MatchingObjectNode(original, Children.LEAF, mo, false, rm);
109	assertEquals("test.txt", n.getDisplayName());	109	assertEquals("test.txt", n.getDisplayName());
110	}	110	}
111		111

Return to bug 200020

Lines 535-548 Link Here

(-)a/api.search/src/org/netbeans/modules/search/MatchingObject.java (-4 / +7 lines)
535		535
536	List<Node> detailNodes = new ArrayList<Node>(textDetails.size());	536	List<Node> detailNodes = new ArrayList<Node>(textDetails.size());
537	for (TextDetail txtDetail : textDetails) {	537	for (TextDetail txtDetail : textDetails) {
538	detailNodes.add(new TextDetail.DetailNode(txtDetail, false));	538	detailNodes.add(
		539	new TextDetail.DetailNode(txtDetail, false, resultModel));
539	}	540	}
540		541
541	return detailNodes.toArray(new Node[detailNodes.size()]);	542	return detailNodes.toArray(new Node[detailNodes.size()]);
542	}	543	}
543		544
544	public Children getDetailsChildren(boolean replacing) {	545	public Children getDetailsChildren(boolean replacing) {
545	return new DetailsChildren(replacing);	546	return new DetailsChildren(replacing, resultModel);
546	}	547	}
547		548
548	/**	549	/**
Lines 1032-1046 Link Here
1032	private class DetailsChildren extends Children.Keys<TextDetail> {	1033	private class DetailsChildren extends Children.Keys<TextDetail> {
1033		1034
1034	private boolean replacing;	1035	private boolean replacing;
		1036	private final ResultModel model;
1035		1037
1036	public DetailsChildren(boolean replacing) {	1038	public DetailsChildren(boolean replacing, ResultModel model) {
1037	this.replacing = replacing;	1039	this.replacing = replacing;
1038	setKeys(getTextDetails());	1040	setKeys(getTextDetails());
		1041	this.model = model;
1039	}	1042	}
1040		1043
1041	@Override	1044	@Override
1042	protected Node[] createNodes(TextDetail key) {	1045	protected Node[] createNodes(TextDetail key) {
1043	return new Node[]{new TextDetail.DetailNode(key, replacing)};	1046	return new Node[]{new TextDetail.DetailNode(key, replacing, model)};
1044	}	1047	}
1045	}	1048	}
1046		1049

Lines 50-55 Link Here

(-)a/api.search/src/org/netbeans/modules/search/TextDetail.java (-1 / +15 lines)
50	import java.awt.datatransfer.Transferable;	50	import java.awt.datatransfer.Transferable;
51	import java.awt.event.ActionEvent;	51	import java.awt.event.ActionEvent;
52	import java.io.CharConversionException;	52	import java.io.CharConversionException;
		53	import java.io.IOException;
53	import java.util.List;	54	import java.util.List;
54	import java.util.logging.Level;	55	import java.util.logging.Level;
55	import java.util.logging.Logger;	56	import java.util.logging.Logger;
Lines 451-456 Link Here
451	/** Cached toString value. */	452	/** Cached toString value. */
452	private String name;	453	private String name;
453	private String htmlDisplayName;	454	private String htmlDisplayName;
		455	private final ResultModel model;
454		456
455	/**	457	/**
456	* Constructs a node representing the specified information about	458	* Constructs a node representing the specified information about
Lines 458-468 Link Here
458	*	460	*
459	* @param txtDetail information to be represented by this node	461	* @param txtDetail information to be represented by this node
460	*/	462	*/
461	public DetailNode(TextDetail txtDetail, boolean replacing) {	463	public DetailNode(TextDetail txtDetail, boolean replacing,
		464	ResultModel model) {
462	super(Children.LEAF, Lookups.fixed(txtDetail,	465	super(Children.LEAF, Lookups.fixed(txtDetail,
463	new ReplaceCheckableNode(txtDetail, replacing)));	466	new ReplaceCheckableNode(txtDetail, replacing)));
464		467
465	this.txtDetail = txtDetail;	468	this.txtDetail = txtDetail;
		469	this.model = model;
466		470
467	setValue(SearchDisplayer.ATTR_OUTPUT_LINE,	471	setValue(SearchDisplayer.ATTR_OUTPUT_LINE,
468	DetailNode.getFullDesc(txtDetail));	472	DetailNode.getFullDesc(txtDetail));
Lines 823-828 Link Here
823	protected void createPasteTypes(Transferable t, List<PasteType> s) {	827	protected void createPasteTypes(Transferable t, List<PasteType> s) {
824	}	828	}
825		829
		830	@Override
		831	public boolean canDestroy() {
		832	return true;
		833	}
		834
		835	@Override
		836	public void destroy() throws IOException {
		837	this.model.removeDetailMatch(txtDetail);
		838	// super.destroy();
		839	}
826	} // End of DetailNode class.	840	} // End of DetailNode class.
827		841
828	/**	842	/**

Lines 59-64 Link Here

(-)a/api.search/src/org/netbeans/modules/search/ui/MatchingObjectNode.java (-6 / +17 lines)
59	import org.netbeans.api.annotations.common.StaticResource;	59	import org.netbeans.api.annotations.common.StaticResource;
60	import org.netbeans.modules.search.MatchingObject;	60	import org.netbeans.modules.search.MatchingObject;
61	import org.netbeans.modules.search.MatchingObject.InvalidityStatus;	61	import org.netbeans.modules.search.MatchingObject.InvalidityStatus;
		62	import org.netbeans.modules.search.ResultModel;
		63	import org.openide.actions.DeleteAction;
62	import org.openide.filesystems.FileObject;	64	import org.openide.filesystems.FileObject;
63	import org.openide.filesystems.FileUtil;	65	import org.openide.filesystems.FileUtil;
64	import org.openide.loaders.DataObject;	66	import org.openide.loaders.DataObject;
Lines 100-121 Link Here
100	private boolean valid = true;	102	private boolean valid = true;
101	private PropertyChangeListener validityListener;	103	private PropertyChangeListener validityListener;
102	private PropertyChangeListener selectionListener;	104	private PropertyChangeListener selectionListener;
		105	private ResultModel resultModel;
103	PropertySet[] propertySets;	106	PropertySet[] propertySets;
104		107
105	public MatchingObjectNode(Node original,	108	public MatchingObjectNode(Node original,
106	org.openide.nodes.Children children,	109	org.openide.nodes.Children children, MatchingObject matchingObject,
107	MatchingObject matchingObject, final boolean replacing) {	110	final boolean replacing, ResultModel model) {
108	this(original, children, matchingObject,	111	this(original, children, matchingObject,
109	new ReplaceCheckableNode(matchingObject, replacing));	112	new ReplaceCheckableNode(matchingObject, replacing), model);
110	}	113	}
111		114
112	private MatchingObjectNode(Node original,	115	private MatchingObjectNode(Node original,
113	org.openide.nodes.Children children,	116	org.openide.nodes.Children children,
114	final MatchingObject matchingObject,	117	final MatchingObject matchingObject,
115	ReplaceCheckableNode checkableNode) {	118	ReplaceCheckableNode checkableNode, ResultModel model) {
116	super(children, Lookups.fixed(matchingObject, checkableNode,	119	super(children, Lookups.fixed(matchingObject, checkableNode,
117	matchingObject.getFileObject()));	120	matchingObject.getFileObject()));
118	Parameters.notNull("original", original); //NOI18N	121	Parameters.notNull("original", original); //NOI18N
		122	this.resultModel = model;
119	this.matchingObject = matchingObject;	123	this.matchingObject = matchingObject;
120	if (matchingObject.isObjectValid()) {	124	if (matchingObject.isObjectValid()) {
121	this.original = original;	125	this.original = original;
Lines 165-171 Link Here
165	if (!context) {	169	if (!context) {
166	return new Action[]{	170	return new Action[]{
167	SystemAction.get(OpenMatchingObjectsAction.class),	171	SystemAction.get(OpenMatchingObjectsAction.class),
168	new CopyPathAction()	172	new CopyPathAction(),
		173	SystemAction.get(DeleteAction.class)
169	};	174	};
170	} else {	175	} else {
171	return new Action[0];	176	return new Action[0];
Lines 234-240 Link Here
234		239
235	@Override	240	@Override
236	public boolean canDestroy() {	241	public boolean canDestroy() {
237	return false;	242	return true;
238	}	243	}
239		244
240	public void clean() {	245	public void clean() {
Lines 274-279 Link Here
274	return propertySets;	279	return propertySets;
275	}	280	}
276		281
		282	@Override
		283	public void destroy () throws IOException {
		284	// when removing the node, the node's content is removed from model
		285	resultModel.remove(this.matchingObject);
		286	}
		287
277	/**	288	/**
278	* Check whether the file object is valid and a valid data object can be	289	* Check whether the file object is valid and a valid data object can be
279	* found for it. It should be checked after original node is destroyed. It	290	* found for it. It should be checked after original node is destroyed. It