Attachment #26158 for bug #106620

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.







import org.eclipse.jface.text.IDocument;
import org.eclipse.swt.widgets.Control;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;




	String getTitle();

	void setDocument(IDocument document);

	void setViewerSelectionManager(ViewerSelectionManager viewerSelectionManager);
}




	protected Color tableLineColor;
	protected int controlWidth;
	protected DelayedDrawTimer delayedDrawTimer;
	private boolean fisUnsupportedInput = false;

	public TreeExtension(Tree tree) {
		this.tree = tree;

		//			}
		//		}
		//
		if (!fisUnsupportedInput) {
			TreeItem[] items = tree.getItems();
			if (items.length > 0) {
				gc.setForeground(tableLineColor);
				gc.setBackground(bg);

				gc.fillRectangle(columnPosition, treeBounds.x, treeBounds.width, treeBounds.height);

				Rectangle itemBounds = items[0].getBounds();
				int height = computeTreeItemHeight();

				if (itemBounds != null) {
					int startY = itemBounds.y < treeBounds.y ? itemBounds.y : treeBounds.y + ((treeBounds.y - itemBounds.y) % height);

					for (int i = startY; i < treeBounds.height; i += height) {
						if (i >= treeBounds.y) {
							gc.drawLine(0, i, treeBounds.width, i);
						}
					}
				}
				gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
				paintItems(gc, items, treeBounds);

			}
			else {
				addEmptyTreeMessage(gc);
			}
			gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
		} else {
			addEmptyTreeMessage(gc);
		}
		else {
			addUnableToPopulateTreeMessage(gc);
		}
	}

	protected int computeTreeItemHeight() {

	protected void addEmptyTreeMessage(GC gc) {
	}

	private void addUnableToPopulateTreeMessage(GC gc) {
		// here we print a message when the document cannot be displayed just
		// to give the
		// user a visual cue
		// so that they know how to proceed to edit the blank view
		gc.setForeground(tree.getDisplay().getSystemColor(SWT.COLOR_BLACK));
		gc.setBackground(tree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
		gc.drawString(XMLEditorMessages.TreeExtension_0, 10, 10);
	}

	void setIsUnsupportedInput(boolean isUnsupported) {
		fisUnsupportedInput = isUnsupported;
	}

	public void paintItems(GC gc, TreeItem[] items, Rectangle treeBounds) {
		if (items != null) {
			for (int i = 0; i < items.length; i++) {

Lines 37-42 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/XMLEditorMessages.java (+1 lines)
37	public static String An_error_has_occurred_when1_ERROR_;	37	public static String An_error_has_occurred_when1_ERROR_;
38	public static String Resource__does_not_exist;	38	public static String Resource__does_not_exist;
39	public static String Editor_could_not_be_open;	39	public static String Editor_could_not_be_open;
		40	public static String TreeExtension_0;
40		41
41	static {	42	static {
42	// load message values from bundle file	43	// load message values from bundle file

Lines 26-29 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/XMLEditorResources.properties (-1 / +2 lines)
26	##	26	##
27	An_error_has_occurred_when1_ERROR_=An error has occurred when initializing the input for the the editor's source page.	27	An_error_has_occurred_when1_ERROR_=An error has occurred when initializing the input for the the editor's source page.
28	Resource__does_not_exist=Resource {0} does not exist.	28	Resource__does_not_exist=Resource {0} does not exist.
29	Editor_could_not_be_open=Editor could not be open on {0}	29	Editor_could_not_be_open=Editor could not be open on {0}
		30	TreeExtension_0=Cannot display document contents.




import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.part.MultiPageEditorPart;
import org.eclipse.ui.part.MultiPageEditorSite;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.exceptions.SourceEditingRuntimeException;
import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
import org.eclipse.wst.xml.core.internal.provisional.IXMLPreferenceNames;


		public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
			if (fDesignViewer != null && newInput != null)
				fDesignViewer.setDocument(newInput);
		}
	}


	private void connectDesignPage() {
		if (fDesignViewer != null) {
			fDesignViewer.setViewerSelectionManager(fTextEditor.getViewerSelectionManager());
			fDesignViewer.setDocument(getDocument());
		}
	}



	private void disconnectDesignPage() {
		if (fDesignViewer != null) {
			fDesignViewer.setDocument(null);
			fDesignViewer.setViewerSelectionManager(null);
		}
	}

		}
		return result;
	}
	
	private IDocument getDocument() {
		IDocument document = null;
		if (fTextEditor != null)
			document = fTextEditor.getDocumentProvider().getDocument(fTextEditor.getEditorInput());
		return document;
	}

	private IPreferenceStore getPreferenceStore() {

		// TextViewer to set us straight
		super.setInput(input);
		if (fDesignViewer != null)
			fDesignViewer.setDocument(getDocument());
		setPartName(input.getName());
	}
}




import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.sse.core.internal.provisional.IModelStateListener;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;
import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;
import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;


	class NodeActionMenuListener implements IMenuListener {
		public void menuAboutToShow(IMenuManager menuManager) {
			if (fModel != null) {
				// used to disable NodeSelection listening while running
				// NodeAction
				XMLNodeActionManager nodeActionManager = new XMLNodeActionManager(fModel, XMLTableTreeViewer.this) {
					public void beginNodeAction(NodeAction action) {
						super.beginNodeAction(action);
					}
	
					public void endNodeAction(NodeAction action) {
						super.endNodeAction(action);
					}
				};
				nodeActionManager.fillContextMenu(menuManager, getSelection());
			}
		}
	}


	protected void handleDispose(DisposeEvent event) {
		super.handleDispose(event);
		treeExtension.dispose();
		setDocument(null);
		setViewerSelectionManager(null);
	}


		}
	}

	public void setDocument(IDocument document) {
		// remove
		if (fModel != null) {
			fModel.removeModelStateListener(fInternalModelStateListener);
			fModel.releaseFromEdit();
		}

		// get model for read and allow text editor to be the one that getmodelforedit
		IStructuredModel model = null;
		model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);

		if (model != null && model instanceof IDOMModel) {
			Document domDoc = null;
			model.addModelStateListener(fInternalModelStateListener);
			ModelQuery mq = ModelQueryUtil.getModelQuery(model);
			treeExtension.setModelQuery(mq);
			domDoc = ((IDOMModel) model).getDocument();
			setInput(domDoc);
			treeExtension.setIsUnsupportedInput(false);
		} else {
			treeExtension.setIsUnsupportedInput(true);
		}
		
		fModel = model;
	}

	// the following methods implement the IDesignViewer interface

Return to bug 106620

Lines 10-17 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/IDesignViewer.java (-2 / +2 lines)
10		10
11		11
12		12
		13	import org.eclipse.jface.text.IDocument;
13	import org.eclipse.swt.widgets.Control;	14	import org.eclipse.swt.widgets.Control;
14	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
15	import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;	15	import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;
16		16
17		17
Lines 20-26 Link Here
20		20
21	String getTitle();	21	String getTitle();
22		22
23	void setModel(IStructuredModel model);	23	void setDocument(IDocument document);
24		24
25	void setViewerSelectionManager(ViewerSelectionManager viewerSelectionManager);	25	void setViewerSelectionManager(ViewerSelectionManager viewerSelectionManager);
26	}	26	}

Lines 56-61 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/TreeExtension.java (-21 / +42 lines)
56	protected Color tableLineColor;	56	protected Color tableLineColor;
57	protected int controlWidth;	57	protected int controlWidth;
58	protected DelayedDrawTimer delayedDrawTimer;	58	protected DelayedDrawTimer delayedDrawTimer;
		59	private boolean fisUnsupportedInput = false;
59		60
60	public TreeExtension(Tree tree) {	61	public TreeExtension(Tree tree) {
61	this.tree = tree;	62	this.tree = tree;
Lines 204-234 Link Here
204	// }	205	// }
205	// }	206	// }
206	//	207	//
207	TreeItem[] items = tree.getItems();	208	if (!fisUnsupportedInput) {
208	if (items.length > 0) {	209	TreeItem[] items = tree.getItems();
209	gc.setForeground(tableLineColor);	210	if (items.length > 0) {
210	gc.setBackground(bg);	211	gc.setForeground(tableLineColor);
211		212	gc.setBackground(bg);
212	gc.fillRectangle(columnPosition, treeBounds.x, treeBounds.width, treeBounds.height);	213
213		214	gc.fillRectangle(columnPosition, treeBounds.x, treeBounds.width, treeBounds.height);
214	Rectangle itemBounds = items[0].getBounds();	215
215	int height = computeTreeItemHeight();	216	Rectangle itemBounds = items[0].getBounds();
216		217	int height = computeTreeItemHeight();
217	if (itemBounds != null) {	218
218	int startY = itemBounds.y < treeBounds.y ? itemBounds.y : treeBounds.y + ((treeBounds.y - itemBounds.y) % height);	219	if (itemBounds != null) {
219		220	int startY = itemBounds.y < treeBounds.y ? itemBounds.y : treeBounds.y + ((treeBounds.y - itemBounds.y) % height);
220	for (int i = startY; i < treeBounds.height; i += height) {	221
221	if (i >= treeBounds.y) {	222	for (int i = startY; i < treeBounds.height; i += height) {
222	gc.drawLine(0, i, treeBounds.width, i);	223	if (i >= treeBounds.y) {
		224	gc.drawLine(0, i, treeBounds.width, i);
		225	}
223	}	226	}
224	}	227	}
		228	gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
		229	paintItems(gc, items, treeBounds);
		230
		231	}
		232	else {
		233	addEmptyTreeMessage(gc);
225	}	234	}
226	gc.drawLine(columnPosition, 0, columnPosition, treeBounds.height);
227	} else {
228	addEmptyTreeMessage(gc);
229	}	235	}
230		236	else {
231	paintItems(gc, items, treeBounds);	237	addUnableToPopulateTreeMessage(gc);
		238	}
232	}	239	}
233		240
234	protected int computeTreeItemHeight() {	241	protected int computeTreeItemHeight() {
Lines 264-269 Link Here
264	protected void addEmptyTreeMessage(GC gc) {	271	protected void addEmptyTreeMessage(GC gc) {
265	}	272	}
266		273
		274	private void addUnableToPopulateTreeMessage(GC gc) {
		275	// here we print a message when the document cannot be displayed just
		276	// to give the
		277	// user a visual cue
		278	// so that they know how to proceed to edit the blank view
		279	gc.setForeground(tree.getDisplay().getSystemColor(SWT.COLOR_BLACK));
		280	gc.setBackground(tree.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
		281	gc.drawString(XMLEditorMessages.TreeExtension_0, 10, 10);
		282	}
		283
		284	void setIsUnsupportedInput(boolean isUnsupported) {
		285	fisUnsupportedInput = isUnsupported;
		286	}
		287
267	public void paintItems(GC gc, TreeItem[] items, Rectangle treeBounds) {	288	public void paintItems(GC gc, TreeItem[] items, Rectangle treeBounds) {
268	if (items != null) {	289	if (items != null) {
269	for (int i = 0; i < items.length; i++) {	290	for (int i = 0; i < items.length; i++) {

Lines 31-37 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/XMLMultiPageEditorPart.java (-10 / +9 lines)
31	import org.eclipse.ui.ide.IGotoMarker;	31	import org.eclipse.ui.ide.IGotoMarker;
32	import org.eclipse.ui.part.MultiPageEditorPart;	32	import org.eclipse.ui.part.MultiPageEditorPart;
33	import org.eclipse.ui.part.MultiPageEditorSite;	33	import org.eclipse.ui.part.MultiPageEditorSite;
34	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
35	import org.eclipse.wst.sse.core.internal.provisional.exceptions.SourceEditingRuntimeException;	34	import org.eclipse.wst.sse.core.internal.provisional.exceptions.SourceEditingRuntimeException;
36	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;	35	import org.eclipse.wst.sse.ui.internal.StructuredTextEditor;
37	import org.eclipse.wst.xml.core.internal.provisional.IXMLPreferenceNames;	36	import org.eclipse.wst.xml.core.internal.provisional.IXMLPreferenceNames;
Lines 167-173 Link Here
167		166
168	public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {	167	public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
169	if (fDesignViewer != null && newInput != null)	168	if (fDesignViewer != null && newInput != null)
170	fDesignViewer.setModel(getModel());	169	fDesignViewer.setDocument(newInput);
171	}	170	}
172	}	171	}
173		172
Lines 237-243 Link Here
237	private void connectDesignPage() {	236	private void connectDesignPage() {
238	if (fDesignViewer != null) {	237	if (fDesignViewer != null) {
239	fDesignViewer.setViewerSelectionManager(fTextEditor.getViewerSelectionManager());	238	fDesignViewer.setViewerSelectionManager(fTextEditor.getViewerSelectionManager());
240	fDesignViewer.setModel(getModel());	239	fDesignViewer.setDocument(getDocument());
241	}	240	}
242	}	241	}
243		242
Lines 339-345 Link Here
339		338
340	private void disconnectDesignPage() {	339	private void disconnectDesignPage() {
341	if (fDesignViewer != null) {	340	if (fDesignViewer != null) {
342	fDesignViewer.setModel(null);	341	fDesignViewer.setDocument(null);
343	fDesignViewer.setViewerSelectionManager(null);	342	fDesignViewer.setViewerSelectionManager(null);
344	}	343	}
345	}	344	}
Lines 413-424 Link Here
413	}	412	}
414	return result;	413	return result;
415	}	414	}
416		415
417	private IStructuredModel getModel() {	416	private IDocument getDocument() {
418	IStructuredModel model = null;	417	IDocument document = null;
419	if (fTextEditor != null)	418	if (fTextEditor != null)
420	model = fTextEditor.getModel();	419	document = fTextEditor.getDocumentProvider().getDocument(fTextEditor.getEditorInput());
421	return model;	420	return document;
422	}	421	}
423		422
424	private IPreferenceStore getPreferenceStore() {	423	private IPreferenceStore getPreferenceStore() {
Lines 548-554 Link Here
548	// TextViewer to set us straight	547	// TextViewer to set us straight
549	super.setInput(input);	548	super.setInput(input);
550	if (fDesignViewer != null)	549	if (fDesignViewer != null)
551	fDesignViewer.setModel(getModel());	550	fDesignViewer.setDocument(getDocument());
552	setPartName(input.getName());	551	setPartName(input.getName());
553	}	552	}
554	}	553	}

Lines 14-19 Link Here

(-)src-multipage/org/eclipse/wst/xml/ui/internal/tabletree/XMLTableTreeViewer.java (-18 / +30 lines)
14	import org.eclipse.jface.action.IMenuManager;	14	import org.eclipse.jface.action.IMenuManager;
15	import org.eclipse.jface.action.MenuManager;	15	import org.eclipse.jface.action.MenuManager;
16	import org.eclipse.jface.action.Separator;	16	import org.eclipse.jface.action.Separator;
		17	import org.eclipse.jface.text.IDocument;
17	import org.eclipse.jface.viewers.CellEditor;	18	import org.eclipse.jface.viewers.CellEditor;
18	import org.eclipse.jface.viewers.ISelection;	19	import org.eclipse.jface.viewers.ISelection;
19	import org.eclipse.jface.viewers.SelectionChangedEvent;	20	import org.eclipse.jface.viewers.SelectionChangedEvent;
Lines 27-32 Link Here
27	import org.eclipse.ui.PlatformUI;	28	import org.eclipse.ui.PlatformUI;
28	import org.eclipse.wst.sse.core.internal.provisional.IModelStateListener;	29	import org.eclipse.wst.sse.core.internal.provisional.IModelStateListener;
29	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;	30	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
		31	import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
30	import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;	32	import org.eclipse.wst.sse.ui.internal.ViewerSelectionManager;
31	import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;	33	import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;
32	import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;	34	import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;
Lines 152-169 Link Here
152		154
153	class NodeActionMenuListener implements IMenuListener {	155	class NodeActionMenuListener implements IMenuListener {
154	public void menuAboutToShow(IMenuManager menuManager) {	156	public void menuAboutToShow(IMenuManager menuManager) {
155	// used to disable NodeSelection listening while running	157	if (fModel != null) {
156	// NodeAction	158	// used to disable NodeSelection listening while running
157	XMLNodeActionManager nodeActionManager = new XMLNodeActionManager(fModel, XMLTableTreeViewer.this) {	159	// NodeAction
158	public void beginNodeAction(NodeAction action) {	160	XMLNodeActionManager nodeActionManager = new XMLNodeActionManager(fModel, XMLTableTreeViewer.this) {
159	super.beginNodeAction(action);	161	public void beginNodeAction(NodeAction action) {
160	}	162	super.beginNodeAction(action);
161		163	}
162	public void endNodeAction(NodeAction action) {	164
163	super.endNodeAction(action);	165	public void endNodeAction(NodeAction action) {
164	}	166	super.endNodeAction(action);
165	};	167	}
166	nodeActionManager.fillContextMenu(menuManager, getSelection());	168	};
		169	nodeActionManager.fillContextMenu(menuManager, getSelection());
		170	}
167	}	171	}
168	}	172	}
169		173
Lines 258-264 Link Here
258	protected void handleDispose(DisposeEvent event) {	262	protected void handleDispose(DisposeEvent event) {
259	super.handleDispose(event);	263	super.handleDispose(event);
260	treeExtension.dispose();	264	treeExtension.dispose();
261	setModel(null);	265	setDocument(null);
262	setViewerSelectionManager(null);	266	setViewerSelectionManager(null);
263	}	267	}
264		268
Lines 317-338 Link Here
317	}	321	}
318	}	322	}
319		323
320	public void setModel(IStructuredModel model) {	324	public void setDocument(IDocument document) {
321	// remove	325	// remove
322	if (fModel != null) {	326	if (fModel != null) {
323	fModel.removeModelStateListener(fInternalModelStateListener);	327	fModel.removeModelStateListener(fInternalModelStateListener);
		328	fModel.releaseFromEdit();
324	}	329	}
325		330
326	fModel = model;	331	// get model for read and allow text editor to be the one that getmodelforedit
327	Document domDoc = null;	332	IStructuredModel model = null;
		333	model = StructuredModelManager.getModelManager().getExistingModelForEdit(document);
328		334
329	if (fModel != null && fModel instanceof IDOMModel) {	335	if (model != null && model instanceof IDOMModel) {
		336	Document domDoc = null;
330	model.addModelStateListener(fInternalModelStateListener);	337	model.addModelStateListener(fInternalModelStateListener);
331	ModelQuery mq = ModelQueryUtil.getModelQuery(model);	338	ModelQuery mq = ModelQueryUtil.getModelQuery(model);
332	treeExtension.setModelQuery(mq);	339	treeExtension.setModelQuery(mq);
333	domDoc = ((IDOMModel) fModel).getDocument();	340	domDoc = ((IDOMModel) model).getDocument();
334	setInput(domDoc);	341	setInput(domDoc);
		342	treeExtension.setIsUnsupportedInput(false);
		343	} else {
		344	treeExtension.setIsUnsupportedInput(true);
335	}	345	}
		346
		347	fModel = model;
336	}	348	}
337		349
338	// the following methods implement the IDesignViewer interface	350	// the following methods implement the IDesignViewer interface