Attachment #91769 for bug #177506

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




        <class package="org.netbeans.spi.viewmodel" name="AsynchronousModelFilter" />
        <issue number="172694"/>
    </change>
    <change>
        <api name="ViewModelAPI"/>
        <summary>Drag and Drop support.</summary>
        <version major="1" minor="24"/>
        <date day="4" month="12" year="2009"/>
        <author login="mentlicher"/>
        <compatibility binary="compatible" source="compatible" deletion="no" addition="yes" modification="no"/>
        <description>
            This API introduce DnDNodeModel and DnDNodeModelFilter that
            can be used by clients to implement Drag and Drop.
        </description>
        <class package="org.netbeans.spi.viewmodel" name="DnDNodeModel" />
        <class package="org.netbeans.spi.viewmodel" name="DnDNodeModelFilter" />
        <issue number="177506"/>
    </change>


</changes>

Lines 1-5 Link Here

(-)a/spi.viewmodel/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.spi.viewmodel/2	2	OpenIDE-Module: org.netbeans.spi.viewmodel/2
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/viewmodel/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/viewmodel/Bundle.properties
4	OpenIDE-Module-Specification-Version: 1.23	4	OpenIDE-Module-Specification-Version: 1.24
5		5

Lines 43-51 Link Here

(-)a/spi.viewmodel/src/org/netbeans/modules/viewmodel/OutlineTable.java (+27 lines)
43		43
44	import java.awt.BorderLayout;	44	import java.awt.BorderLayout;
45	import java.awt.Rectangle;	45	import java.awt.Rectangle;
		46	import java.awt.datatransfer.Transferable;
		47	import java.awt.dnd.DnDConstants;
46	import java.awt.event.KeyEvent;	48	import java.awt.event.KeyEvent;
47	import java.beans.PropertyChangeEvent;	49	import java.beans.PropertyChangeEvent;
48	import java.beans.PropertyChangeListener;	50	import java.beans.PropertyChangeListener;
		51	import java.lang.ref.Reference;
		52	import java.lang.ref.WeakReference;
49	import java.util.*;	53	import java.util.*;
50	import java.util.logging.Level;	54	import java.util.logging.Level;
51	import java.util.logging.Logger;	55	import java.util.logging.Logger;
Lines 71-76 Link Here
71	import org.netbeans.spi.viewmodel.Models;	75	import org.netbeans.spi.viewmodel.Models;
72	import org.netbeans.spi.viewmodel.ColumnModel;	76	import org.netbeans.spi.viewmodel.ColumnModel;
73		77
		78	import org.netbeans.spi.viewmodel.DnDNodeModel;
74	import org.netbeans.swing.etable.ETableColumn;	79	import org.netbeans.swing.etable.ETableColumn;
75	import org.netbeans.swing.etable.ETableColumnModel;	80	import org.netbeans.swing.etable.ETableColumnModel;
76	import org.netbeans.swing.outline.DefaultOutlineModel;	81	import org.netbeans.swing.outline.DefaultOutlineModel;
Lines 353-358 Link Here
353	// The root node must be ready when setting the columns	358	// The root node must be ready when setting the columns
354	treeTable.setProperties (columnsToSet);	359	treeTable.setProperties (columnsToSet);
355	updateTableColumns(columnsToSet);	360	updateTableColumns(columnsToSet);
		361	treeTable.setAllowedDragActions(model.getAllowedDragActions());
		362	treeTable.setAllowedDropActions(model.getAllowedDropActions(null));
		363	treeTable.setDynamicDropActions(model);
		364
356	//treeTable.getTable().tableChanged(new TableModelEvent(treeTable.getOutline().getModel()));	365	//treeTable.getTable().tableChanged(new TableModelEvent(treeTable.getOutline().getModel()));
357	//getExplorerManager ().setRootContext (rootNode);	366	//getExplorerManager ().setRootContext (rootNode);
358		367
Lines 855-860 Link Here
855	}	864	}
856		865
857	private static class MyTreeTable extends OutlineView {	866	private static class MyTreeTable extends OutlineView {
		867
		868	private Reference<DnDNodeModel> dndModelRef = new WeakReference<DnDNodeModel>(null);
		869
858	MyTreeTable () {	870	MyTreeTable () {
859	super ();	871	super ();
860	Outline outline = getOutline();	872	Outline outline = getOutline();
Lines 942-947 Link Here
942	return null;	954	return null;
943	}	955	}
944	}	956	}
		957
		958	void setDynamicDropActions(DnDNodeModel model) {
		959	dndModelRef = new WeakReference<DnDNodeModel>(model);
		960	}
		961
		962	@Override
		963	protected int getAllowedDropActions(Transferable t) {
		964	DnDNodeModel model = dndModelRef.get();
		965	if (model != null) {
		966	return model.getAllowedDropActions(t);
		967	} else {
		968	return super.getAllowedDropActions();
		969	}
		970	}
		971
945	}	972	}
946		973
947	private static final class F8FilterComponentInputMap extends ComponentInputMap {	974	private static final class F8FilterComponentInputMap extends ComponentInputMap {




        }
    }
    
    @Override
    public Transferable drag() throws IOException {
        Transferable t;
        try {

            return t;
        }
    }
     */
    
    @Override
    public void createPasteTypes(Transferable t, List<PasteType> l) {

        }
    }
    
    @Override
    public PasteType getDropType(Transferable t, int action, int index) {
        PasteType p;
        try {

            return p;
        }
    }
     */
    
    private final void expandIfSetToExpanded() {
        try {

Lines 42-47 Link Here

(-)a/spi.viewmodel/src/org/netbeans/spi/viewmodel/Models.java (-54 / +102 lines)
42	package org.netbeans.spi.viewmodel;	42	package org.netbeans.spi.viewmodel;
43		43
44	import java.awt.datatransfer.Transferable;	44	import java.awt.datatransfer.Transferable;
		45	import java.awt.dnd.DnDConstants;
45	import java.awt.event.ActionEvent;	46	import java.awt.event.ActionEvent;
46	import java.io.IOException;	47	import java.io.IOException;
47	import java.lang.ref.Reference;	48	import java.lang.ref.Reference;
Lines 101-106 Link Here
101	public static int MULTISELECTION_TYPE_EXACTLY_ONE = 1;	102	public static int MULTISELECTION_TYPE_EXACTLY_ONE = 1;
102	public static int MULTISELECTION_TYPE_ALL = 2;	103	public static int MULTISELECTION_TYPE_ALL = 2;
103	public static int MULTISELECTION_TYPE_ANY = 3;	104	public static int MULTISELECTION_TYPE_ANY = 3;
		105
		106	private static final int DEFAULT_DRAG_DROP_ALLOWED_ACTIONS = DnDConstants.ACTION_NONE;
104		107
105	private static boolean verbose =	108	private static boolean verbose =
106	System.getProperty ("netbeans.debugger.models") != null;	109	System.getProperty ("netbeans.debugger.models") != null;
Lines 470-480 Link Here
470	*	473	*
471	* @returns compund tree model	474	* @returns compund tree model
472	*/	475	*/
473	private static ExtendedNodeModel createCompoundNodeModel (	476	private static SuperNodeModel createCompoundNodeModel (
474	ExtendedNodeModel originalNodeModel,	477	SuperNodeModel originalNodeModel,
475	List treeNodeModelFilters	478	List treeNodeModelFilters
476	) {	479	) {
477	ExtendedNodeModel nm = originalNodeModel;	480	SuperNodeModel nm = originalNodeModel;
478	int i, k = treeNodeModelFilters.size ();	481	int i, k = treeNodeModelFilters.size ();
479	for (i = 0; i < k; i++)	482	for (i = 0; i < k; i++)
480	nm = new CompoundNodeModel (	483	nm = new CompoundNodeModel (
Lines 843-855 Link Here
843	*	846	*
844	* @author Jan Jancura	847	* @author Jan Jancura
845	*/	848	*/
846	private final static class CompoundNodeModel implements ExtendedNodeModel, CheckNodeModel, ModelListener {	849	private final static class CompoundNodeModel implements SuperNodeModel,
		850	ModelListener {
847		851
848		852
849	private ExtendedNodeModel model;	853	private SuperNodeModel model;
850	private NodeModelFilter filter;	854	private NodeModelFilter filter;
851	private CheckNodeModel cmodel;
852	private CheckNodeModelFilter cfilter;	855	private CheckNodeModelFilter cfilter;
		856	private DnDNodeModelFilter dndfilter;
853		857
854	private final Collection<ModelListener> modelListeners = new HashSet<ModelListener>();	858	private final Collection<ModelListener> modelListeners = new HashSet<ModelListener>();
855		859
Lines 858-871 Link Here
858	* Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and	862	* Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and
859	* {@link org.netbeans.spi.viewmodel.TreeModelFilter}.	863	* {@link org.netbeans.spi.viewmodel.TreeModelFilter}.
860	*/	864	*/
861	CompoundNodeModel (ExtendedNodeModel model, NodeModelFilter filter) {	865	CompoundNodeModel (SuperNodeModel model, NodeModelFilter filter) {
862	this.model = model;	866	this.model = model;
863	this.filter = filter;	867	this.filter = filter;
864	if (model instanceof CheckNodeModel) {
865	this.cmodel = (CheckNodeModel) model;
866	}
867	if (filter instanceof CheckNodeModelFilter) {	868	if (filter instanceof CheckNodeModelFilter) {
868	this.cfilter = (CheckNodeModelFilter) filter;	869	this.cfilter = (CheckNodeModelFilter) filter;
		870	}
		871	if (filter instanceof DnDNodeModelFilter) {
		872	this.dndfilter = (DnDNodeModelFilter) filter;
869	}	873	}
870	}	874	}
871		875
Lines 1015-1028 Link Here
1015	}	1019	}
1016	}	1020	}
1017		1021
1018	/*public Transferable drag(Object node) throws IOException,	1022	public int getAllowedDragActions() {
		1023	if (dndfilter != null) {
		1024	return dndfilter.getAllowedDragActions(model);
		1025	} else {
		1026	return model.getAllowedDragActions();
		1027	}
		1028	}
		1029
		1030	public int getAllowedDropActions(Transferable t) {
		1031	if (dndfilter != null) {
		1032	return dndfilter.getAllowedDropActions(model, t);
		1033	} else {
		1034	return model.getAllowedDropActions(t);
		1035	}
		1036	}
		1037
		1038	public Transferable drag(Object node) throws IOException,
1019	UnknownTypeException {	1039	UnknownTypeException {
1020	if (filter instanceof ExtendedNodeModelFilter) {	1040	if (dndfilter != null) {
1021	return ((ExtendedNodeModelFilter) filter).drag(model, node);	1041	return dndfilter.drag(model, node);
1022	} else {	1042	} else {
1023	return model.drag(node);	1043	return model.drag(node);
1024	}	1044	}
1025	}*/	1045	}
1026		1046
1027	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {	1047	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {
1028	if (filter instanceof ExtendedNodeModelFilter) {	1048	if (filter instanceof ExtendedNodeModelFilter) {
Lines 1032-1045 Link Here
1032	}	1052	}
1033	}	1053	}
1034		1054
1035	/*public PasteType getDropType(Object node, Transferable t, int action,	1055	public PasteType getDropType(Object node, Transferable t, int action,
1036	int index) throws UnknownTypeException {	1056	int index) throws UnknownTypeException {
1037	if (filter instanceof ExtendedNodeModelFilter) {	1057	if (dndfilter != null) {
1038	return ((ExtendedNodeModelFilter) filter).getDropType(model, node, t, action, index);	1058	return dndfilter.getDropType(model, node, t, action, index);
1039	} else {	1059	} else {
1040	return model.getDropType(node, t, action, index);	1060	return model.getDropType(node, t, action, index);
1041	}	1061	}
1042	}*/	1062	}
1043		1063
1044	public void setName(Object node, String name) throws UnknownTypeException {	1064	public void setName(Object node, String name) throws UnknownTypeException {
1045	if (filter instanceof ExtendedNodeModelFilter) {	1065	if (filter instanceof ExtendedNodeModelFilter) {
Lines 1076-1115 Link Here
1076	public boolean isCheckable(Object node) throws UnknownTypeException {	1096	public boolean isCheckable(Object node) throws UnknownTypeException {
1077	if (cfilter != null) {	1097	if (cfilter != null) {
1078	return cfilter.isCheckable(model, node);	1098	return cfilter.isCheckable(model, node);
1079	} else if (cmodel != null) {
1080	return cmodel.isCheckable(node);
1081	} else {	1099	} else {
1082	return false;	1100	return model.isCheckable(node);
1083	}	1101	}
1084	}	1102	}
1085		1103
1086	public boolean isCheckEnabled(Object node) throws UnknownTypeException {	1104	public boolean isCheckEnabled(Object node) throws UnknownTypeException {
1087	if (cfilter != null) {	1105	if (cfilter != null) {
1088	return cfilter.isCheckEnabled(model, node);	1106	return cfilter.isCheckEnabled(model, node);
1089	} else if (cmodel != null) {
1090	return cmodel.isCheckEnabled(node);
1091	} else {	1107	} else {
1092	return true;	1108	return model.isCheckEnabled(node);
1093	}	1109	}
1094	}	1110	}
1095		1111
1096	public Boolean isSelected(Object node) throws UnknownTypeException {	1112	public Boolean isSelected(Object node) throws UnknownTypeException {
1097	if (cfilter != null) {	1113	if (cfilter != null) {
1098	return cfilter.isSelected(model, node);	1114	return cfilter.isSelected(model, node);
1099	} else if (cmodel != null) {
1100	return cmodel.isSelected(node);
1101	} else {	1115	} else {
1102	return false;	1116	return model.isSelected(node);
1103	}	1117	}
1104	}	1118	}
1105		1119
1106	public void setSelected(Object node, Boolean selected) throws UnknownTypeException {	1120	public void setSelected(Object node, Boolean selected) throws UnknownTypeException {
1107	if (cfilter != null) {	1121	if (cfilter != null) {
1108	cfilter.setSelected(model, node, selected);	1122	cfilter.setSelected(model, node, selected);
1109	} else if (cmodel != null) {
1110	cmodel.setSelected(node, selected);
1111	} else {	1123	} else {
1112	Exceptions.printStackTrace(new IllegalStateException("Can not set selected state to model "+this));	1124	model.setSelected(node, selected);
1113	}	1125	}
1114	}	1126	}
1115		1127
Lines 2023-2029 Link Here
2023	*	2035	*
2024	* @author Jan Jancura	2036	* @author Jan Jancura
2025	*/	2037	*/
2026	private static final class DelegatingNodeModel implements ExtendedNodeModel, CheckNodeModel {	2038	private static final class DelegatingNodeModel implements SuperNodeModel {
2027		2039
2028	private NodeModel[] models;	2040	private NodeModel[] models;
2029	private HashMap<String, NodeModel> classNameToModel = new HashMap<String, NodeModel>();	2041	private HashMap<String, NodeModel> classNameToModel = new HashMap<String, NodeModel>();
Lines 2233-2254 Link Here
2233	return null;	2245	return null;
2234	}	2246	}
2235		2247
2236	/*
2237	private Transferable defaultDrag() throws IOException {	2248	private Transferable defaultDrag() throws IOException {
2238	return null;	2249	return null;
2239	}	2250	}
2240	*/
2241		2251
2242	private PasteType[] defaultGetPasteTypes(Transferable t) {	2252	private PasteType[] defaultGetPasteTypes(Transferable t) {
2243	return null;	2253	return null;
2244	}	2254	}
2245		2255
2246	/*
2247	private PasteType defaultGetDropType(Transferable t, int action,	2256	private PasteType defaultGetDropType(Transferable t, int action,
2248	int index) {	2257	int index) {
2249	return null;	2258	return null;
2250	}	2259	}
2251	*/
2252		2260
2253	private void defaultSetName(String name) {	2261	private void defaultSetName(String name) {
2254	// nothing	2262	// nothing
Lines 2456-2462 Link Here
2456	}	2464	}
2457	}	2465	}
2458		2466
2459	/*	2467	public int getAllowedDragActions() {
		2468	int i, k = models.length;
		2469	for (i = 0; i < k; i++) {
		2470	if (models[i] instanceof DnDNodeModel) {
		2471	return ((DnDNodeModel) models[i]).getAllowedDragActions();
		2472	}
		2473	}
		2474	return DEFAULT_DRAG_DROP_ALLOWED_ACTIONS;
		2475	}
		2476
		2477	public int getAllowedDropActions(Transferable t) {
		2478	int i, k = models.length;
		2479	for (i = 0; i < k; i++) {
		2480	if (models[i] instanceof DnDNodeModel) {
		2481	return ((DnDNodeModel) models[i]).getAllowedDropActions(t);
		2482	}
		2483	}
		2484	return DEFAULT_DRAG_DROP_ALLOWED_ACTIONS;
		2485	}
		2486
2460	public Transferable drag(Object node) throws IOException,	2487	public Transferable drag(Object node) throws IOException,
2461	UnknownTypeException {	2488	UnknownTypeException {
2462	UnknownTypeException uex = null;	2489	UnknownTypeException uex = null;
Lines 2464-2472 Link Here
2464	node.getClass ().getName ()	2491	node.getClass ().getName ()
2465	);	2492	);
2466	if (model != null) {	2493	if (model != null) {
2467	if (model instanceof ExtendedNodeModel) {	2494	if (model instanceof DnDNodeModel) {
2468	try {	2495	try {
2469	return ((ExtendedNodeModel) model).drag (node);	2496	return ((DnDNodeModel) model).drag (node);
2470	} catch (UnknownTypeException e) {	2497	} catch (UnknownTypeException e) {
2471	uex = e;	2498	uex = e;
2472	}	2499	}
Lines 2477-2485 Link Here
2477	int i, k = models.length;	2504	int i, k = models.length;
2478	boolean isExtended = false;	2505	boolean isExtended = false;
2479	for (i = 0; i < k; i++) {	2506	for (i = 0; i < k; i++) {
2480	if (models[i] instanceof ExtendedNodeModel) {	2507	if (models[i] instanceof DnDNodeModel) {
2481	try {	2508	try {
2482	Transferable t = ((ExtendedNodeModel) models [i]).drag (node);	2509	Transferable t = ((DnDNodeModel) models [i]).drag (node);
2483	classNameToModel.put (node.getClass ().getName (), models [i]);	2510	classNameToModel.put (node.getClass ().getName (), models [i]);
2484	return t;	2511	return t;
2485	} catch (UnknownTypeException e) {	2512	} catch (UnknownTypeException e) {
Lines 2497-2503 Link Here
2497	throw new UnknownTypeException (node);	2524	throw new UnknownTypeException (node);
2498	}	2525	}
2499	}	2526	}
2500	*/
2501		2527
2502	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {	2528	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {
2503	UnknownTypeException uex = null;	2529	UnknownTypeException uex = null;
Lines 2539-2545 Link Here
2539	}	2565	}
2540	}	2566	}
2541		2567
2542	/*
2543	public PasteType getDropType(Object node, Transferable t, int action,	2568	public PasteType getDropType(Object node, Transferable t, int action,
2544	int index) throws UnknownTypeException {	2569	int index) throws UnknownTypeException {
2545	UnknownTypeException uex = null;	2570	UnknownTypeException uex = null;
Lines 2547-2555 Link Here
2547	node.getClass ().getName ()	2572	node.getClass ().getName ()
2548	);	2573	);
2549	if (model != null) {	2574	if (model != null) {
2550	if (model instanceof ExtendedNodeModel) {	2575	if (model instanceof DnDNodeModel) {
2551	try {	2576	try {
2552	return ((ExtendedNodeModel) model).getDropType (node, t, action, index);	2577	return ((DnDNodeModel) model).getDropType (node, t, action, index);
2553	} catch (UnknownTypeException e) {	2578	} catch (UnknownTypeException e) {
2554	uex = e;	2579	uex = e;
2555	}	2580	}
Lines 2560-2568 Link Here
2560	int i, k = models.length;	2585	int i, k = models.length;
2561	boolean isExtended = false;	2586	boolean isExtended = false;
2562	for (i = 0; i < k; i++) {	2587	for (i = 0; i < k; i++) {
2563	if (models[i] instanceof ExtendedNodeModel) {	2588	if (models[i] instanceof DnDNodeModel) {
2564	try {	2589	try {
2565	PasteType p = ((ExtendedNodeModel) models [i]).getDropType (node, t, action, index);	2590	PasteType p = ((DnDNodeModel) models [i]).getDropType (node, t, action, index);
2566	classNameToModel.put (node.getClass ().getName (), models [i]);	2591	classNameToModel.put (node.getClass ().getName (), models [i]);
2567	return p;	2592	return p;
2568	} catch (UnknownTypeException e) {	2593	} catch (UnknownTypeException e) {
Lines 2580-2586 Link Here
2580	throw new UnknownTypeException (node);	2605	throw new UnknownTypeException (node);
2581	}	2606	}
2582	}	2607	}
2583	*/
2584		2608
2585	public void setName(Object node, String name) throws UnknownTypeException {	2609	public void setName(Object node, String name) throws UnknownTypeException {
2586	UnknownTypeException uex = null;	2610	UnknownTypeException uex = null;
Lines 3213-3223 Link Here
3213	* @author Jan Jancura	3237	* @author Jan Jancura
3214	*/	3238	*/
3215	public static final class CompoundModel implements TreeModel,	3239	public static final class CompoundModel implements TreeModel,
3216	ExtendedNodeModel, CheckNodeModel, NodeActionsProvider, TableModel, TreeExpansionModel {	3240	ExtendedNodeModel, CheckNodeModel, DnDNodeModel, NodeActionsProvider, TableModel, TreeExpansionModel {
3217		3241
3218	private TreeModel treeModel;	3242	private TreeModel treeModel;
3219	private ExtendedNodeModel nodeModel;	3243	private ExtendedNodeModel nodeModel;
3220	private CheckNodeModel cnodeModel;	3244	private CheckNodeModel cnodeModel;
		3245	private DnDNodeModel dndNodeModel;
3221	private NodeActionsProvider nodeActionsProvider;	3246	private NodeActionsProvider nodeActionsProvider;
3222	private ColumnModel[] columnModels;	3247	private ColumnModel[] columnModels;
3223	private TableModel tableModel;	3248	private TableModel tableModel;
Lines 3265-3270 Link Here
3265	this.nodeModel = nodeModel;	3290	this.nodeModel = nodeModel;
3266	if (nodeModel instanceof CheckNodeModel) {	3291	if (nodeModel instanceof CheckNodeModel) {
3267	this.cnodeModel = (CheckNodeModel) nodeModel;	3292	this.cnodeModel = (CheckNodeModel) nodeModel;
		3293	}
		3294	if (nodeModel instanceof DnDNodeModel) {
		3295	this.dndNodeModel = (DnDNodeModel) nodeModel;
3268	}	3296	}
3269	this.tableModel = tableModel;	3297	this.tableModel = tableModel;
3270	this.nodeActionsProvider = nodeActionsProvider;	3298	this.nodeActionsProvider = nodeActionsProvider;
Lines 3635-3657 Link Here
3635	return nodeModel.clipboardCut(node);	3663	return nodeModel.clipboardCut(node);
3636	}	3664	}
3637		3665
3638	/*	3666	public int getAllowedDragActions() {
		3667	if (dndNodeModel != null) {
		3668	return dndNodeModel.getAllowedDragActions();
		3669	} else {
		3670	return DEFAULT_DRAG_DROP_ALLOWED_ACTIONS;
		3671	}
		3672	}
		3673
		3674	public int getAllowedDropActions(Transferable t) {
		3675	if (dndNodeModel != null) {
		3676	return dndNodeModel.getAllowedDropActions(t);
		3677	} else {
		3678	return DEFAULT_DRAG_DROP_ALLOWED_ACTIONS;
		3679	}
		3680	}
		3681
3639	public Transferable drag(Object node) throws IOException,	3682	public Transferable drag(Object node) throws IOException,
3640	UnknownTypeException {	3683	UnknownTypeException {
3641	return nodeModel.drag(node);	3684	if (dndNodeModel != null) {
		3685	return dndNodeModel.drag(node);
		3686	} else {
		3687	return null;
		3688	}
3642	}	3689	}
3643	*/
3644		3690
3645	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {	3691	public PasteType[] getPasteTypes(Object node, Transferable t) throws UnknownTypeException {
3646	return nodeModel.getPasteTypes(node, t);	3692	return nodeModel.getPasteTypes(node, t);
3647	}	3693	}
3648		3694
3649	/*
3650	public PasteType getDropType(Object node, Transferable t, int action,	3695	public PasteType getDropType(Object node, Transferable t, int action,
3651	int index) throws UnknownTypeException {	3696	int index) throws UnknownTypeException {
3652	return nodeModel.getDropType(node, t, action, index);	3697	if (dndNodeModel != null) {
		3698	return dndNodeModel.getDropType(node, t, action, index);
		3699	} else {
		3700	return null;
		3701	}
3653	}	3702	}
3654	*/
3655		3703
3656	public void setName(Object node, String name) throws UnknownTypeException {	3704	public void setName(Object node, String name) throws UnknownTypeException {
3657	nodeModel.setName(node, name);	3705	nodeModel.setName(node, name);

Return to bug 177506

Lines 764-770 Link Here

(-)a/spi.viewmodel/src/org/netbeans/modules/viewmodel/TreeModelNode.java (-4 / +2 lines)
764	}	764	}
765	}	765	}
766		766
767	/*	767	@Override
768	public Transferable drag() throws IOException {	768	public Transferable drag() throws IOException {
769	Transferable t;	769	Transferable t;
770	try {	770	try {
Lines 779-785 Link Here
779	return t;	779	return t;
780	}	780	}
781	}	781	}
782	*/
783		782
784	@Override	783	@Override
785	public void createPasteTypes(Transferable t, List<PasteType> l) {	784	public void createPasteTypes(Transferable t, List<PasteType> l) {
Lines 797-803 Link Here
797	}	796	}
798	}	797	}
799		798
800	/*	799	@Override
801	public PasteType getDropType(Transferable t, int action, int index) {	800	public PasteType getDropType(Transferable t, int action, int index) {
802	PasteType p;	801	PasteType p;
803	try {	802	try {
Lines 812-818 Link Here
812	return p;	811	return p;
813	}	812	}
814	}	813	}
815	*/
816		814
817	private final void expandIfSetToExpanded() {	815	private final void expandIfSetToExpanded() {
818	try {	816	try {

Lines 351-356 Link Here

(-)a/spi.viewmodel/apichanges.xml (+15 lines)
351	<class package="org.netbeans.spi.viewmodel" name="AsynchronousModelFilter" />	351	<class package="org.netbeans.spi.viewmodel" name="AsynchronousModelFilter" />
352	<issue number="172694"/>	352	<issue number="172694"/>
353	</change>	353	</change>
		354	<change>
		355	<api name="ViewModelAPI"/>
		356	<summary>Drag and Drop support.</summary>
		357	<version major="1" minor="24"/>
		358	<date day="4" month="12" year="2009"/>
		359	<author login="mentlicher"/>
		360	<compatibility binary="compatible" source="compatible" deletion="no" addition="yes" modification="no"/>
		361	<description>
		362	This API introduce DnDNodeModel and DnDNodeModelFilter that
		363	can be used by clients to implement Drag and Drop.
		364	</description>
		365	<class package="org.netbeans.spi.viewmodel" name="DnDNodeModel" />
		366	<class package="org.netbeans.spi.viewmodel" name="DnDNodeModelFilter" />
		367	<issue number="177506"/>
		368	</change>
354		369
355		370
356	</changes>	371	</changes>