Attachment #28524 for bug #112884

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

Lines 201-207 Link Here

(-)org/eclipse/wst/xsd/ui/internal/XSDActionBarContributor.java (-1 / +1 lines)
201	xsdEditor = (XSDEditor) targetEditor;	201	xsdEditor = (XSDEditor) targetEditor;
202	reloadDependenciesAction.setEditor((XSDEditor)targetEditor);	202	reloadDependenciesAction.setEditor((XSDEditor)targetEditor);
203		203
204	textEditor = ((XSDEditor)targetEditor).getXSDTextEditor();	204	textEditor = ((XSDEditor)targetEditor).getTextEditor();
205	if (textEditor != null)	205	if (textEditor != null)
206	{	206	{
207		207

Lines 10-20 Link Here

(-)org/eclipse/wst/xsd/ui/internal/XSDContentOutlinePage.java (-21 / +197 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.wst.xsd.ui.internal;	11	package org.eclipse.wst.xsd.ui.internal;
12		12
		13	import org.eclipse.core.runtime.Platform;
13	import org.eclipse.jface.action.Action;	14	import org.eclipse.jface.action.Action;
14	import org.eclipse.jface.action.IMenuManager;	15	import org.eclipse.jface.action.IMenuManager;
15	import org.eclipse.jface.action.MenuManager;	16	import org.eclipse.jface.action.MenuManager;
16	import org.eclipse.jface.resource.ImageDescriptor;	17	import org.eclipse.jface.resource.ImageDescriptor;
		18	import org.eclipse.jface.util.ListenerList;
		19	import org.eclipse.jface.util.SafeRunnable;
17	import org.eclipse.jface.viewers.ILabelProvider;	20	import org.eclipse.jface.viewers.ILabelProvider;
		21	import org.eclipse.jface.viewers.IPostSelectionProvider;
18	import org.eclipse.jface.viewers.ISelection;	22	import org.eclipse.jface.viewers.ISelection;
19	import org.eclipse.jface.viewers.ISelectionChangedListener;	23	import org.eclipse.jface.viewers.ISelectionChangedListener;
20	import org.eclipse.jface.viewers.IStructuredSelection;	24	import org.eclipse.jface.viewers.IStructuredSelection;
Lines 34-39 Link Here
34	import org.eclipse.swt.widgets.Tree;	38	import org.eclipse.swt.widgets.Tree;
35	import org.eclipse.swt.widgets.TreeItem;	39	import org.eclipse.swt.widgets.TreeItem;
36	import org.eclipse.ui.IActionBars;	40	import org.eclipse.ui.IActionBars;
		41	import org.eclipse.ui.ISelectionListener;
		42	import org.eclipse.ui.IWorkbenchPart;
		43	import org.eclipse.ui.part.IPageSite;
37	import org.eclipse.ui.views.contentoutline.ContentOutlinePage;	44	import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
38	import org.eclipse.wst.xsd.ui.internal.actions.OpenSchemaAction;	45	import org.eclipse.wst.xsd.ui.internal.actions.OpenSchemaAction;
39	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;	46	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
Lines 42-48 Link Here
42	import org.eclipse.xsd.XSDSchemaDirective;	49	import org.eclipse.xsd.XSDSchemaDirective;
43	import org.w3c.dom.Element;	50	import org.w3c.dom.Element;
44		51
45	public class XSDContentOutlinePage extends ContentOutlinePage	52	public class XSDContentOutlinePage extends ContentOutlinePage implements ISelectionListener
46	{	53	{
47	protected XSDEditor xsdEditor;	54	protected XSDEditor xsdEditor;
48	protected int level = 0;	55	protected int level = 0;
Lines 52-69 Link Here
52	protected XSDSelectionManager selectionManager;	59	protected XSDSelectionManager selectionManager;
53	protected SelectionManagerSelectionChangeListener selectionManagerSelectionChangeListener = new SelectionManagerSelectionChangeListener();	60	protected SelectionManagerSelectionChangeListener selectionManagerSelectionChangeListener = new SelectionManagerSelectionChangeListener();
54	protected TreeSelectionChangeListener treeSelectionChangeListener = new TreeSelectionChangeListener();	61	protected TreeSelectionChangeListener treeSelectionChangeListener = new TreeSelectionChangeListener();
55	XSDTextEditor xsdTextEditor;	62	XSDEditor xsdTextEditor;
56	XSDMenuListener menuListener;	63	XSDMenuListener menuListener;
57		64	SelectionProvider fSelectionProvider = null;
		65
58	/**	66	/**
59	*	67	*
60	*/	68	*/
61	public XSDContentOutlinePage(XSDTextEditor xsdTextEditor)	69	public XSDContentOutlinePage(XSDEditor xsdTextEditor)
62	{	70	{
63	super();	71	super();
64	this.xsdTextEditor = xsdTextEditor;	72	this.xsdTextEditor = xsdTextEditor;
		73	fSelectionProvider = new SelectionProvider();
65	}	74	}
66		75
		76	public void init(IPageSite pageSite)
		77	{
		78	super.init(pageSite);
		79	getSite().getWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
		80	getSite().setSelectionProvider(fSelectionProvider);
		81	}
		82
		83	public void dispose()
		84	{
		85	super.dispose();
		86	getSite().getWorkbenchWindow().getSelectionService().removePostSelectionListener(this);
		87	}
		88
67	public void setModel(Object newModel)	89	public void setModel(Object newModel)
68	{	90	{
69	model = newModel;	91	model = newModel;
Lines 91-109 Link Here
91	getTreeViewer().setContentProvider(contentProvider);	113	getTreeViewer().setContentProvider(contentProvider);
92	getTreeViewer().setLabelProvider(labelProvider);	114	getTreeViewer().setLabelProvider(labelProvider);
93	getTreeViewer().setInput(model);	115	getTreeViewer().setInput(model);
94	getTreeViewer().addSelectionChangedListener(this);	116	// getTreeViewer().addSelectionChangedListener(this);
95	MenuManager menuManager = new MenuManager("#popup");//$NON-NLS-1$	117	MenuManager menuManager = new MenuManager("#popup");//$NON-NLS-1$
96	menuManager.setRemoveAllWhenShown(true);	118	menuManager.setRemoveAllWhenShown(true);
97	Menu menu = menuManager.createContextMenu(getTreeViewer().getControl());	119	Menu menu = menuManager.createContextMenu(getTreeViewer().getControl());
98	getTreeViewer().getControl().setMenu(menu);	120	getTreeViewer().getControl().setMenu(menu);
99	menuListener = new XSDMenuListener(xsdTextEditor.getXSDEditor().getSelectionManager());	121	menuListener = new XSDMenuListener(xsdTextEditor.getSelectionManager());
100	// menuListener.setSelectionProvider(getTreeViewer());	122	// menuListener.setSelectionProvider(getTreeViewer());
101	menuManager.addMenuListener(menuListener);	123	menuManager.addMenuListener(menuListener);
102		124
103	// enable popupMenus extension	125	// enable popupMenus extension
104	getSite().registerContextMenu("org.eclipse.wst.xsd.ui.popup.outline", menuManager, xsdTextEditor.getXSDEditor().getSelectionManager());	126	getSite().registerContextMenu("org.eclipse.wst.xsd.ui.popup.outline", menuManager, xsdTextEditor.getSelectionManager());
105		127
106	setSelectionManager(xsdTextEditor.getXSDEditor().getSelectionManager());	128	setSelectionManager(xsdTextEditor.getSelectionManager());
107	// cs... why are we doing this from the outline view?	129	// cs... why are we doing this from the outline view?
108	//	130	//
109	//xsdTextEditor.getXSDEditor().getSelectionManager().setSelection(new	131	//xsdTextEditor.getXSDEditor().getSelectionManager().setSelection(new
Lines 125-137 Link Here
125	XSDConcreteComponent comp = (XSDConcreteComponent)obj;	147	XSDConcreteComponent comp = (XSDConcreteComponent)obj;
126	if (comp.getContainer() instanceof XSDSchema)	148	if (comp.getContainer() instanceof XSDSchema)
127	{	149	{
128	xsdTextEditor.getXSDEditor().getGraphViewer().setInput(obj);	150	xsdTextEditor.getGraphViewer().setInput(obj);
129	}	151	}
130	}	152	}
131	}	153	}
132		154
133	}	155	}
134	});	156	});
		157
		158
		159	getTreeViewer().addPostSelectionChangedListener(fSelectionProvider.getPostSelectionChangedListener());
		160	getTreeViewer().addSelectionChangedListener(fSelectionProvider.getSelectionChangedListener());
		161
135	}	162	}
136	class XSDKeyListener extends KeyAdapter	163	class XSDKeyListener extends KeyAdapter
137	{	164	{
Lines 186-197 Link Here
186	getTreeViewer().expandToLevel(level);	213	getTreeViewer().expandToLevel(level);
187	}	214	}
188		215
189	// public ISelection getSelection()	216	public void selectionChanged(IWorkbenchPart part, ISelection selection)
190	// {	217	{
191	// if (getTreeViewer() == null)	218	if (selectionManager != null)
192	// return StructuredSelection.EMPTY;	219	{
193	// return getTreeViewer().getSelection();	220	if (selection instanceof IStructuredSelection)
194	// }	221	{
		222	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
		223	Object o = structuredSelection.getFirstElement();
		224	// TODO ...
		225	// we need to implement a selectionManagerMapping extension point
		226	// so that extensions can specify how they'd like to map view objects
		227	// to selection objects
		228	//
		229	if (o instanceof Element)
		230	{
		231	try
		232	{
		233	Object modelObject = xsdTextEditor.getXSDSchema().getCorrespondingComponent((Element) o);
		234	if (modelObject != null)
		235	{
		236	o = modelObject;
		237	}
		238	}
		239	catch (Exception e)
		240	{
		241	}
		242	}
		243	else if (o instanceof CategoryAdapter)
		244	{
		245	// todo... we need to ensure we eliminate the propagation
		246	// of 'view' specific objects into the SelectionManager.
		247	// We need to do some work to ensure all views utilize the 'Category' model object
		248	// so we can get rid of this CategoryAdapter class.
		249	// CategoryAdapter adapter = (CategoryAdapter) o;
		250	// o = adapter.getXSDSchema();
		251	}
		252	if (o != null)
		253	{
		254	if (getControl() != null && !getControl().isDisposed() && !getControl().isFocusControl() && getControl().isVisible()) {
		255	/*
		256	* Do not allow selection from other parts to affect selection
		257	* in the tree widget if it has focus. Selection events
		258	* "bouncing" off of other parts are all that we can receive
		259	* if we have focus (since we forward selection to the
		260	* service), and only the user should affect selection if we
		261	* have focus.
		262	*/
		263	getTreeViewer().setSelection(new StructuredSelection(o), true);
		264	}
		265	selectionManager.setSelection(new StructuredSelection(o), getTreeViewer());
		266	// selectionManager.selectionChanged(new SelectionChangedEvent(getTreeViewer(),new StructuredSelection(o)));
		267	}
		268	else
		269	{
		270	// selectionManager.setSelection(new StructuredSelection(),
		271	// getTreeViewer());
		272	}
		273	}
		274	}
		275	}
		276
195	public void setSelectionManager(XSDSelectionManager newSelectionManager)	277	public void setSelectionManager(XSDSelectionManager newSelectionManager)
196	{	278	{
197	TreeViewer treeViewer = getTreeViewer();	279	TreeViewer treeViewer = getTreeViewer();
Lines 209-214 Link Here
209	treeViewer.addSelectionChangedListener(treeSelectionChangeListener);	291	treeViewer.addSelectionChangedListener(treeSelectionChangeListener);
210	}	292	}
211	}	293	}
		294
212	class SelectionManagerSelectionChangeListener implements ISelectionChangedListener	295	class SelectionManagerSelectionChangeListener implements ISelectionChangedListener
213	{	296	{
214	public void selectionChanged(SelectionChangedEvent event)	297	public void selectionChanged(SelectionChangedEvent event)
Lines 263-273 Link Here
263	selectionManager.setSelection(new StructuredSelection(o), getTreeViewer());	346	selectionManager.setSelection(new StructuredSelection(o), getTreeViewer());
264	// selectionManager.selectionChanged(new SelectionChangedEvent(getTreeViewer(),new StructuredSelection(o)));	347	// selectionManager.selectionChanged(new SelectionChangedEvent(getTreeViewer(),new StructuredSelection(o)));
265	}	348	}
266	else
267	{
268	// selectionManager.setSelection(new StructuredSelection(),
269	// getTreeViewer());
270	}
271	}	349	}
272	}	350	}
273	}	351	}
Lines 378-381 Link Here
378	return true;	456	return true;
379	}	457	}
380	}	458	}
		459
		460	/**
		461	* Forwards post-selection from the tree viewer to the listeners while
		462	* acting as this page's selection provider.
		463	*/
		464	private class SelectionProvider implements IPostSelectionProvider {
		465	private class PostSelectionChangedListener implements ISelectionChangedListener {
		466	public void selectionChanged(SelectionChangedEvent event) {
		467	if (!isFiringSelection()) {
		468	fireSelectionChanged(event, postListeners);
		469	}
		470	}
		471	}
		472
		473	private class SelectionChangedListener implements ISelectionChangedListener {
		474	public void selectionChanged(SelectionChangedEvent event) {
		475	if (!isFiringSelection()) {
		476	fireSelectionChanged(event, listeners);
		477	}
		478	}
		479	}
		480
		481	private boolean isFiringSelection = false;
		482	private ListenerList listeners = new ListenerList();
		483	private ListenerList postListeners = new ListenerList();
		484	private ISelectionChangedListener postSelectionChangedListener = new PostSelectionChangedListener();
		485	private ISelectionChangedListener selectionChangedListener = new SelectionChangedListener();
		486
		487	public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
		488	postListeners.add(listener);
		489	}
		490
		491	public void addSelectionChangedListener(ISelectionChangedListener listener) {
		492	listeners.add(listener);
		493	}
		494
		495	public void fireSelectionChanged(final SelectionChangedEvent event, ListenerList listenerList) {
		496	isFiringSelection = true;
		497	Object[] listeners = listenerList.getListeners();
		498	for (int i = 0; i < listeners.length; ++i) {
		499	final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
		500	Platform.run(new SafeRunnable() {
		501	public void run() {
		502	l.selectionChanged(event);
		503	}
		504	});
		505	}
		506	isFiringSelection = false;
		507	}
		508
		509	public void fireSelectionChanged(final SelectionChangedEvent event) {
		510	isFiringSelection = true;
		511	Object[] listeners = postListeners.getListeners();
		512	for (int i = 0; i < listeners.length; ++i) {
		513	final ISelectionChangedListener l = (ISelectionChangedListener) listeners[i];
		514	Platform.run(new SafeRunnable() {
		515	public void run() {
		516	l.selectionChanged(event);
		517	}
		518	});
		519	}
		520	isFiringSelection = false;
		521	}
		522
523	public ISelectionChangedListener getPostSelectionChangedListener() {
524	return postSelectionChangedListener;
525	}
526
527	public ISelection getSelection() {
528	if (getTreeViewer() != null) {
529	return getTreeViewer().getSelection();
530	}
531	return StructuredSelection.EMPTY;
532	}
533
534	public ISelectionChangedListener getSelectionChangedListener() {
535	return selectionChangedListener;
536	}
537
538	public boolean isFiringSelection() {
539	return isFiringSelection;
540	}
541
542	public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
543	postListeners.remove(listener);
544	}
545
546	public void removeSelectionChangedListener(ISelectionChangedListener listener) {
547	listeners.remove(listener);
548	};
549
550	public void setSelection(ISelection selection) {
551	if (isFiringSelection) {
552	getTreeViewer().setSelection(selection);
553	}
554	};
555	}
556
381	}	557	}

Lines 37-42 Link Here

(-)org/eclipse/wst/xsd/ui/internal/XSDEditor.java (-9 / +59 lines)
37	import org.eclipse.ui.PartInitException;	37	import org.eclipse.ui.PartInitException;
38	import org.eclipse.ui.PlatformUI;	38	import org.eclipse.ui.PlatformUI;
39	import org.eclipse.ui.editors.text.ILocationProvider;	39	import org.eclipse.ui.editors.text.ILocationProvider;
		40	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
		41	import org.eclipse.ui.views.properties.IPropertySheetPage;
40	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;	42	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;
41	import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;	43	import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
42	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;	44	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
Lines 45-50 Link Here
45	import org.eclipse.wst.sse.ui.StructuredTextEditor;	47	import org.eclipse.wst.sse.ui.StructuredTextEditor;
46	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;	48	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
47	import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphViewer;	49	import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphViewer;
		50	import org.eclipse.wst.xsd.ui.internal.properties.section.XSDTabbedPropertySheetPage;
		51	import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;
		52	import org.eclipse.wst.xsd.ui.internal.provider.XSDContentProvider;
		53	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
48	import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;	54	import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
49	import org.eclipse.wst.xsd.ui.internal.util.OpenOnSelectionHelper;	55	import org.eclipse.wst.xsd.ui.internal.util.OpenOnSelectionHelper;
50	import org.eclipse.xsd.XSDConcreteComponent;	56	import org.eclipse.xsd.XSDConcreteComponent;
Lines 57-63 Link Here
57	// public class XSDEditor extends StructuredTextMultiPageEditorPart	63	// public class XSDEditor extends StructuredTextMultiPageEditorPart
58	public class XSDEditor extends XSDMultiPageEditorPart implements ITabbedPropertySheetPageContributor	64	public class XSDEditor extends XSDMultiPageEditorPart implements ITabbedPropertySheetPageContributor
59	{	65	{
60	protected XSDTextEditor textEditor;	66	protected StructuredTextEditor textEditor;
61	IFile resourceFile;	67	IFile resourceFile;
62	XSDSelectionManager xsdSelectionManager;	68	XSDSelectionManager xsdSelectionManager;
63	XSDModelAdapter schemalNodeAdapter;	69	XSDModelAdapter schemalNodeAdapter;
Lines 107-112 Link Here
107	{	113	{
108	if (!loadFile())	114	if (!loadFile())
109	return;	115	return;
		116
		117	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();
		118	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);
110		119
111	// source page MUST be created before design page, now	120	// source page MUST be created before design page, now
112	createSourcePage();	121	createSourcePage();
Lines 374-380 Link Here
374	*/	383	*/
375	protected StructuredTextEditor createTextEditor()	384	protected StructuredTextEditor createTextEditor()
376	{	385	{
377	return new XSDTextEditor(this);	386	textEditor = new StructuredTextEditor();
		387	return textEditor;
378	}	388	}
379		389
380	/*	390	/*
Lines 383-392 Link Here
383	protected void createSourcePage() throws PartInitException	393	protected void createSourcePage() throws PartInitException
384	{	394	{
385	super.createSourcePage();	395	super.createSourcePage();
386
387	textEditor = (XSDTextEditor) getTextEditor();
388		396
389	openOnSelectionHelper = new OpenOnSelectionHelper(textEditor);	397	openOnSelectionHelper = new OpenOnSelectionHelper(textEditor, getXSDSchema());
390	}	398	}
391		399
392	int sourcePageIndex = -1;	400	int sourcePageIndex = -1;
Lines 422-432 Link Here
422		430
423	// this forces the editor to initially select the top level schema object	431	// this forces the editor to initially select the top level schema object
424	//	432	//
425	if (textEditor.getXSDSchema() != null)	433	if (getXSDSchema() != null)
426	{	434	{
427	getSelectionManager().setSelection(new StructuredSelection(textEditor.getXSDSchema()));	435	getSelectionManager().setSelection(new StructuredSelection(getXSDSchema()));
428	}	436	}
429	}	437	}
		438
		439	protected XSDModelAdapterFactoryImpl xsdModelAdapterFactory;
		440	protected XSDAdapterFactoryLabelProvider adapterFactoryLabelProvider;
		441	private IPropertySheetPage fPropertySheetPage;
		442	private IContentOutlinePage fOutlinePage;
430		443
431	/*	444	/*
432	* @see IAdaptable#getAdapter(Class)	445	* @see IAdaptable#getAdapter(Class)
Lines 438-449 Link Here
438	{	451	{
439	result = xsdSelectionManager;	452	result = xsdSelectionManager;
440	}	453	}
		454	if (IPropertySheetPage.class.equals(key))
		455	{
		456	fPropertySheetPage = new XSDTabbedPropertySheetPage(this);
		457
		458	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);
		459	((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getSelectionManager());
		460	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());
		461
		462	return fPropertySheetPage;
		463	}
		464	else if (IContentOutlinePage.class.equals(key))
		465	{
		466	if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed())
		467	{
		468	XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(this);
		469	XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);
		470	xsdContentProvider.setXSDSchema(getXSDSchema());
		471	outlinePage.setContentProvider(xsdContentProvider);
		472	outlinePage.setLabelProvider(adapterFactoryLabelProvider);
		473	outlinePage.setModel(getXSDSchema().getDocument());
		474
		475	fOutlinePage = outlinePage;
		476	}
		477	return fOutlinePage;
		478	}
441	else	479	else
442	{	480	{
443	result = textEditor.getAdapter(key);	481	result = super.getAdapter(key);
444	}	482	}
445	return result;	483	return result;
446	}	484	}
		485
		486
		487	public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()
		488	{
		489	return xsdModelAdapterFactory;
		490	}
		491
		492	public XSDAdapterFactoryLabelProvider getLabelProvider()
		493	{
		494	return adapterFactoryLabelProvider;
		495	}
		496
447		497
448	public XSDSelectionManager getSelectionManager()	498	public XSDSelectionManager getSelectionManager()
449	{	499	{
Lines 527-533 Link Here
527	return getActiveEditor();	577	return getActiveEditor();
528	}	578	}
529		579
530	public XSDTextEditor getXSDTextEditor()	580	public StructuredTextEditor getTextEditor()
531	{	581	{
532	return textEditor;	582	return textEditor;
533	}	583	}

Lines 10-15 Link Here

(-)org/eclipse/wst/xsd/ui/internal/XSDTextEditor.java (-49 / +66 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.wst.xsd.ui.internal;	11	package org.eclipse.wst.xsd.ui.internal;
12		12
		13	import java.util.ArrayList;
		14	import java.util.Arrays;
13	import java.util.Iterator;	15	import java.util.Iterator;
14	import java.util.List;	16	import java.util.List;
15	import java.util.ResourceBundle;	17	import java.util.ResourceBundle;
Lines 17-23 Link Here
17	import org.eclipse.core.resources.IFile;	19	import org.eclipse.core.resources.IFile;
18	import org.eclipse.core.runtime.Platform;	20	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.jface.action.IMenuManager;	21	import org.eclipse.jface.action.IMenuManager;
		22	import org.eclipse.jface.text.ISelectionValidator;
		23	import org.eclipse.jface.text.ITextSelection;
		24	import org.eclipse.jface.text.TextSelection;
		25	import org.eclipse.jface.util.ListenerList;
		26	import org.eclipse.jface.util.SafeRunnable;
		27	import org.eclipse.jface.viewers.DoubleClickEvent;
		28	import org.eclipse.jface.viewers.IDoubleClickListener;
		29	import org.eclipse.jface.viewers.IPostSelectionProvider;
		30	import org.eclipse.jface.viewers.ISelection;
20	import org.eclipse.jface.viewers.ISelectionChangedListener;	31	import org.eclipse.jface.viewers.ISelectionChangedListener;
		32	import org.eclipse.jface.viewers.ISelectionProvider;
		33	import org.eclipse.jface.viewers.IStructuredSelection;
21	import org.eclipse.jface.viewers.SelectionChangedEvent;	34	import org.eclipse.jface.viewers.SelectionChangedEvent;
22	import org.eclipse.jface.viewers.StructuredSelection;	35	import org.eclipse.jface.viewers.StructuredSelection;
23	import org.eclipse.swt.SWT;	36	import org.eclipse.swt.SWT;
Lines 30-35 Link Here
30	import org.eclipse.ui.texteditor.ITextEditorActionConstants;	43	import org.eclipse.ui.texteditor.ITextEditorActionConstants;
31	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;	44	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
32	import org.eclipse.ui.views.properties.IPropertySheetPage;	45	import org.eclipse.ui.views.properties.IPropertySheetPage;
		46	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
		47	import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
		48	import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
33	import org.eclipse.wst.sse.ui.StructuredTextEditor;	49	import org.eclipse.wst.sse.ui.StructuredTextEditor;
34	import org.eclipse.wst.sse.ui.internal.actions.StructuredTextEditorActionConstants;	50	import org.eclipse.wst.sse.ui.internal.actions.StructuredTextEditorActionConstants;
35	import org.eclipse.wst.sse.ui.internal.openon.OpenOnAction;	51	import org.eclipse.wst.sse.ui.internal.openon.OpenOnAction;
Lines 49-55 Link Here
49	import org.w3c.dom.Element;	65	import org.w3c.dom.Element;
50	import org.w3c.dom.Node;	66	import org.w3c.dom.Node;
51		67
52		68	/**
		69	* @deprecated Do not use subclass of StructuredTextEditor
		70	*/
53	public class XSDTextEditor extends StructuredTextEditor implements INodeSelectionListener, ISelectionChangedListener	71	public class XSDTextEditor extends StructuredTextEditor implements INodeSelectionListener, ISelectionChangedListener
54	{	72	{
55	protected XSDSelectionManager xsdSelectionManager;	73	protected XSDSelectionManager xsdSelectionManager;
Lines 58-64 Link Here
58	protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider();	76	protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider();
59	private IPropertySheetPage fPropertySheetPage;	77	private IPropertySheetPage fPropertySheetPage;
60	private IContentOutlinePage fOutlinePage;	78	private IContentOutlinePage fOutlinePage;
61		79
62	public XSDTextEditor(XSDEditor xsdEditor)	80	public XSDTextEditor(XSDEditor xsdEditor)
63	{	81	{
64	super();	82	super();
Lines 70-76 Link Here
70	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();	88	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();
71	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);	89	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);
72	}	90	}
73
74	public void dispose()	91	public void dispose()
75	{	92	{
76	super.dispose();	93	super.dispose();
Lines 80-130 Link Here
80	xsdModelAdapterFactory = null;	97	xsdModelAdapterFactory = null;
81	}	98	}
82		99
83	public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()	100	// public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()
84	{	101	// {
85	return xsdModelAdapterFactory;	102	// return xsdModelAdapterFactory;
86	}	103	// }
87		104	//
88	public static XSDAdapterFactoryLabelProvider getLabelProvider()	105	// public static XSDAdapterFactoryLabelProvider getLabelProvider()
89	{	106	// {
90	return adapterFactoryLabelProvider;	107	// return adapterFactoryLabelProvider;
91	}	108	// }
92		109
93	public Object getAdapter(Class required) {	110	// public Object getAdapter(Class required) {
94		111	//
95	if (IPropertySheetPage.class.equals(required))	112	// if (IPropertySheetPage.class.equals(required))
96	{	113	// {
97	fPropertySheetPage = new XSDTabbedPropertySheetPage(getXSDEditor());	114	// fPropertySheetPage = new XSDTabbedPropertySheetPage(getXSDEditor());
98		115	//
99	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);	116	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);
100	((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getXSDEditor().getSelectionManager());	117	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getXSDEditor().getSelectionManager());
101	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());	118	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());
102		119	//
103	return fPropertySheetPage;	120	// return fPropertySheetPage;
104	}	121	// }
105	else if (IContentOutlinePage.class.equals(required))	122	// else if (IContentOutlinePage.class.equals(required))
106	{	123	// {
107	if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed())	124	// if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed())
108	{	125	// {
109	XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(this);	126	// XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(getXSDEditor());
110	XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);	127	// XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);
111	xsdContentProvider.setXSDSchema(getXSDSchema());	128	// xsdContentProvider.setXSDSchema(getXSDSchema());
112	outlinePage.setContentProvider(xsdContentProvider);	129	// outlinePage.setContentProvider(xsdContentProvider);
113	outlinePage.setLabelProvider(adapterFactoryLabelProvider);	130	// outlinePage.setLabelProvider(adapterFactoryLabelProvider);
114	outlinePage.setModel(getXSDSchema().getDocument());	131	// outlinePage.setModel(getXSDSchema().getDocument());
115		132	//
116	// Update outline selection from source editor selection:	133	// // Update outline selection from source editor selection:
117	getViewerSelectionManager().addNodeSelectionListener(this);	134	// getViewerSelectionManager().addNodeSelectionListener(this);
118	internalSelectionProvider.addSelectionChangedListener(getViewerSelectionManager());	135	// internalSelectionProvider.addSelectionChangedListener(getViewerSelectionManager());
119	internalSelectionProvider.setEventSource(outlinePage);	136	// internalSelectionProvider.setEventSource(outlinePage);
120		137	//
121	fOutlinePage = outlinePage;	138	// fOutlinePage = outlinePage;
122	}	139	// }
123	return fOutlinePage;	140	// return fOutlinePage;
124	}	141	// }
125		142	//
126	return super.getAdapter(required);	143	// return super.getAdapter(required);
127	}	144	// }
128		145
129		146
130	protected XSDContentOutlinePage outlinePage;	147	protected XSDContentOutlinePage outlinePage;
Lines 326-331 Link Here
326	fRefactorMenuGroup.setContext(context);	343	fRefactorMenuGroup.setContext(context);
327	fRefactorMenuGroup.fillContextMenu(menu);	344	fRefactorMenuGroup.fillContextMenu(menu);
328	fRefactorMenuGroup.setContext(null);	345	fRefactorMenuGroup.setContext(null);
329	}	346	}
330	}	347	}
331		348

Lines 15-21 Link Here

(-)org/eclipse/wst/xsd/ui/internal/properties/section/XSDSectionLabelProvider.java (-1 / +11 lines)
15	import org.eclipse.jface.viewers.LabelProvider;	15	import org.eclipse.jface.viewers.LabelProvider;
16	import org.eclipse.jface.viewers.StructuredSelection;	16	import org.eclipse.jface.viewers.StructuredSelection;
17	import org.eclipse.swt.graphics.Image;	17	import org.eclipse.swt.graphics.Image;
		18	import org.eclipse.ui.IEditorPart;
		19	import org.eclipse.ui.IWorkbench;
		20	import org.eclipse.ui.IWorkbenchWindow;
18	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;	21	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
		22	import org.eclipse.wst.xsd.ui.internal.XSDEditor;
19	import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;	23	import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;
20	import org.eclipse.wst.xsd.ui.internal.XSDTextEditor;	24	import org.eclipse.wst.xsd.ui.internal.XSDTextEditor;
21	import org.eclipse.xsd.XSDAttributeDeclaration;	25	import org.eclipse.xsd.XSDAttributeDeclaration;
Lines 50-56 Link Here
50		54
51	if (selected instanceof XSDConcreteComponent)	55	if (selected instanceof XSDConcreteComponent)
52	{	56	{
53	return XSDTextEditor.getLabelProvider().getImage((XSDConcreteComponent)selected);	57	IWorkbench workbench = XSDEditorPlugin.getPlugin().getWorkbench();
		58	IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
		59	IEditorPart editorPart = workbenchWindow.getActivePage().getActiveEditor();
		60	if (editorPart instanceof XSDEditor)
		61	{
		62	return ((XSDEditor)editorPart).getLabelProvider().getImage((XSDConcreteComponent)selected);
		63	}
54	}	64	}
55		65
56	// selected = typeMapper.remapObject(selected);	66	// selected = typeMapper.remapObject(selected);




import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.IPageSite;
import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;
import org.eclipse.wst.common.ui.properties.internal.provisional.TabbedPropertySheetPage;
import org.eclipse.wst.xsd.ui.internal.XSDSelectionManager;

import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
import org.eclipse.xsd.XSDSchema;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;

public class XSDTabbedPropertySheetPage extends TabbedPropertySheetPage
  implements ISelectionChangedListener, INotifyChangedListener 
{
  XSDSchema xsdSchema;
  private XSDSelectionManager selectionManager;
  private XSDModelAdapterFactoryImpl adapterFactory;
  /**

    super(tabbedPropertySheetPageContributor);
  }
  
  public void init(IPageSite pageSite)
  {
  	super.init(pageSite);
  	getSite().getWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
  }

  public void setXSDSchema(XSDSchema xsdSchema)
  {
    this.xsdSchema = xsdSchema;

    // override for category
    if (selection != null)
    {
      if (selection instanceof IStructuredSelection)
      {
        IStructuredSelection structuredSelection = (IStructuredSelection) selection;
        if (structuredSelection.isEmpty())
        {
          return;
        }
        Object obj = structuredSelection.getFirstElement();
        if (obj instanceof Element)
        {
          try
          {
            Object modelObject = xsdSchema.getCorrespondingComponent((Element) obj);
            if (modelObject != null)
            {
              obj = modelObject;
              selection = new StructuredSelection(obj);
            }
          }
          catch (Exception e)
          {
          }
        }
        else if (obj instanceof Text)
        {
        	Node parent = ((Text)obj).getParentNode();
          Object modelObject = xsdSchema.getCorrespondingComponent(parent);
          if (modelObject != null)
          {
            obj = modelObject;
            selection = new StructuredSelection(obj);
          }
        }
        else if (obj instanceof CategoryAdapter)
        {
          selection = new StructuredSelection(((CategoryAdapter)obj).getXSDSchema());
        }
        else if (obj instanceof Category)
        {
          selection = new StructuredSelection(((Category)obj).getXSDSchema());
        }
        else if (obj instanceof ProcessingInstruction)
        {
        	selection = new StructuredSelection(xsdSchema);
        }
      }
      else if (selection instanceof TextSelection)
      {

    {
      adapterFactory.removeListener(this);
    }
    getSite().getWorkbenchWindow().getSelectionService().removePostSelectionListener(this);
    super.dispose();
  }
  




import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.wst.common.uriresolver.internal.util.URIHelper;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.ui.StructuredTextEditor;
import org.eclipse.wst.xsd.ui.internal.XSDEditor;
import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.XSDTextEditor;

public class OpenOnSelectionHelper
{
  
  protected StructuredTextEditor textEditor;
  protected XSDSchema xsdSchema;

  /**
   * @deprecated Constructor for OpenOnSelectionHelper.
   */
  public OpenOnSelectionHelper(XSDTextEditor textEditor)
  {
    this.textEditor = textEditor;
  }
  
  public OpenOnSelectionHelper(StructuredTextEditor textEditor, XSDSchema xsdSchema)
  {
  	this.textEditor = textEditor;
  	this.xsdSchema = xsdSchema;
  }
  

  boolean lastResult;
  

  
  protected boolean revealObject(final XSDConcreteComponent component)
  {
    if (component.getRootContainer().equals(xsdSchema))
    {
      Node element = component.getElement();
      if (element instanceof IndexedRegion)

		        {
							try
							{
							  // IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), textEditor.getXSDEditor().getEditorSite().getId());
								IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), XSDEditorPlugin.getPlugin().PLUGIN_ID);
								if (editorPart instanceof XSDEditor)
								{
									((XSDEditor)editorPart).openOnGlobalReference(component);

  
  public void openOnGlobalReference(XSDConcreteComponent comp)
  {
    XSDSchema schema = xsdSchema;
    String name = null;
    if (comp instanceof XSDNamedComponent)
    {

      for (Iterator i = selectedNodes.iterator(); i.hasNext();)
      {
        Object obj = i.next();
        XSDSchema xsdSchema = textEditor.getXSDSchema();
        if (xsdSchema != null)
        {
          XSDConcreteComponent xsdComp = xsdSchema.getCorrespondingComponent((Node)obj);

Return to bug 112884

Lines 24-29 Link Here

(-)org/eclipse/wst/xsd/ui/internal/util/OpenOnSelectionHelper.java (-8 / +16 lines)
24	import org.eclipse.ui.part.FileEditorInput;	24	import org.eclipse.ui.part.FileEditorInput;
25	import org.eclipse.wst.common.uriresolver.internal.util.URIHelper;	25	import org.eclipse.wst.common.uriresolver.internal.util.URIHelper;
26	import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;	26	import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
		27	import org.eclipse.wst.sse.ui.StructuredTextEditor;
27	import org.eclipse.wst.xsd.ui.internal.XSDEditor;	28	import org.eclipse.wst.xsd.ui.internal.XSDEditor;
28	import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;	29	import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;
29	import org.eclipse.wst.xsd.ui.internal.XSDTextEditor;	30	import org.eclipse.wst.xsd.ui.internal.XSDTextEditor;
Lines 46-60 Link Here
46	public class OpenOnSelectionHelper	47	public class OpenOnSelectionHelper
47	{	48	{
48		49
49	protected XSDTextEditor textEditor;	50	protected StructuredTextEditor textEditor;
50		51	protected XSDSchema xsdSchema;
		52
51	/**	53	/**
52	* Constructor for OpenOnSelectionHelper.	54	* @deprecated Constructor for OpenOnSelectionHelper.
53	*/	55	*/
54	public OpenOnSelectionHelper(XSDTextEditor textEditor)	56	public OpenOnSelectionHelper(XSDTextEditor textEditor)
55	{	57	{
56	this.textEditor = textEditor;
57	}	58	}
		59
		60	public OpenOnSelectionHelper(StructuredTextEditor textEditor, XSDSchema xsdSchema)
		61	{
		62	this.textEditor = textEditor;
		63	this.xsdSchema = xsdSchema;
		64	}
		65
58		66
59	boolean lastResult;	67	boolean lastResult;
60		68
Lines 94-100 Link Here
94		102
95	protected boolean revealObject(final XSDConcreteComponent component)	103	protected boolean revealObject(final XSDConcreteComponent component)
96	{	104	{
97	if (component.getRootContainer().equals(textEditor.getXSDSchema()))	105	if (component.getRootContainer().equals(xsdSchema))
98	{	106	{
99	Node element = component.getElement();	107	Node element = component.getElement();
100	if (element instanceof IndexedRegion)	108	if (element instanceof IndexedRegion)
Lines 125-131 Link Here
125	{	133	{
126	try	134	try
127	{	135	{
128	IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), textEditor.getXSDEditor().getEditorSite().getId());	136	// IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), textEditor.getXSDEditor().getEditorSite().getId());
		137	IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), XSDEditorPlugin.getPlugin().PLUGIN_ID);
129	if (editorPart instanceof XSDEditor)	138	if (editorPart instanceof XSDEditor)
130	{	139	{
131	((XSDEditor)editorPart).openOnGlobalReference(component);	140	((XSDEditor)editorPart).openOnGlobalReference(component);
Lines 146-152 Link Here
146		155
147	public void openOnGlobalReference(XSDConcreteComponent comp)	156	public void openOnGlobalReference(XSDConcreteComponent comp)
148	{	157	{
149	XSDSchema schema = textEditor.getXSDSchema();	158	XSDSchema schema = xsdSchema;
150	String name = null;	159	String name = null;
151	if (comp instanceof XSDNamedComponent)	160	if (comp instanceof XSDNamedComponent)
152	{	161	{
Lines 191-197 Link Here
191	for (Iterator i = selectedNodes.iterator(); i.hasNext();)	200	for (Iterator i = selectedNodes.iterator(); i.hasNext();)
192	{	201	{
193	Object obj = i.next();	202	Object obj = i.next();
194	XSDSchema xsdSchema = textEditor.getXSDSchema();
195	if (xsdSchema != null)	203	if (xsdSchema != null)
196	{	204	{
197	XSDConcreteComponent xsdComp = xsdSchema.getCorrespondingComponent((Node)obj);	205	XSDConcreteComponent xsdComp = xsdSchema.getCorrespondingComponent((Node)obj);