Attachment #28810 for bug #112884

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

Lines 90-95 Link Here

(-)plugin.xml (+6 lines)
90	type="preferencepages"	90	type="preferencepages"
91	value="org.eclipse.wst.xsd.ui.internal.preferences.XSDPreferencePage"	91	value="org.eclipse.wst.xsd.ui.internal.preferences.XSDPreferencePage"
92	target="org.eclipse.wst.xsd.ui.internal.XSDEditor.source" />	92	target="org.eclipse.wst.xsd.ui.internal.XSDEditor.source" />
		93	<sourceViewerConfiguration
		94	class="org.eclipse.wst.xsd.ui.internal.StructuredTextViewerConfigurationXSD"
		95	target="org.eclipse.wst.xsd.core.xsdsource" />
		96	<contentOutlineConfiguration
		97	class="org.eclipse.wst.xsd.ui.internal.XSDContentOutlineConfiguration"
		98	target="org.eclipse.wst.xsd.core.xsdsource" />
93	</extension>	99	</extension>
94		100
95	<!-- ==================================================== -->	101	<!-- ==================================================== -->

Lines 201-207 Link Here

(-)src/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

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

Lines 12-17 Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/XSDEditor.java (-554 / +798 lines)
12		12
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.EventObject;	14	import java.util.EventObject;
		15	import java.util.Iterator;
		16	import java.util.List;
15		17
16	import org.eclipse.core.resources.IFile;	18	import org.eclipse.core.resources.IFile;
17	import org.eclipse.core.runtime.IPath;	19	import org.eclipse.core.runtime.IPath;
Lines 21-28 Link Here
21	import org.eclipse.jface.text.IDocument;	23	import org.eclipse.jface.text.IDocument;
22	import org.eclipse.jface.util.IPropertyChangeListener;	24	import org.eclipse.jface.util.IPropertyChangeListener;
23	import org.eclipse.jface.util.PropertyChangeEvent;	25	import org.eclipse.jface.util.PropertyChangeEvent;
		26	import org.eclipse.jface.viewers.DoubleClickEvent;
		27	import org.eclipse.jface.viewers.IDoubleClickListener;
		28	import org.eclipse.jface.viewers.IPostSelectionProvider;
24	import org.eclipse.jface.viewers.ISelection;	29	import org.eclipse.jface.viewers.ISelection;
		30	import org.eclipse.jface.viewers.ISelectionChangedListener;
25	import org.eclipse.jface.viewers.ISelectionProvider;	31	import org.eclipse.jface.viewers.ISelectionProvider;
		32	import org.eclipse.jface.viewers.IStructuredSelection;
26	import org.eclipse.jface.viewers.SelectionChangedEvent;	33	import org.eclipse.jface.viewers.SelectionChangedEvent;
27	import org.eclipse.jface.viewers.StructuredSelection;	34	import org.eclipse.jface.viewers.StructuredSelection;
28	import org.eclipse.swt.widgets.Control;	35	import org.eclipse.swt.widgets.Control;
Lines 37-622 Link Here
37	import org.eclipse.ui.PartInitException;	44	import org.eclipse.ui.PartInitException;
38	import org.eclipse.ui.PlatformUI;	45	import org.eclipse.ui.PlatformUI;
39	import org.eclipse.ui.editors.text.ILocationProvider;	46	import org.eclipse.ui.editors.text.ILocationProvider;
		47	import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
		48	import org.eclipse.ui.views.properties.IPropertySheetPage;
40	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;	49	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;
41	import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;	50	import org.eclipse.wst.sse.core.internal.provisional.INodeNotifier;
42	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;	51	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
		52	import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
43	import org.eclipse.wst.sse.core.internal.provisional.events.IStructuredDocumentListener;	53	import org.eclipse.wst.sse.core.internal.provisional.events.IStructuredDocumentListener;
44	import org.eclipse.wst.sse.core.internal.undo.IStructuredTextUndoManager;	54	import org.eclipse.wst.sse.core.internal.undo.IStructuredTextUndoManager;
45	import org.eclipse.wst.sse.ui.StructuredTextEditor;	55	import org.eclipse.wst.sse.ui.StructuredTextEditor;
		56	import org.eclipse.wst.sse.ui.internal.contentoutline.ConfigurableContentOutlinePage;
46	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;	57	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
		58	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
47	import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphViewer;	59	import org.eclipse.wst.xsd.ui.internal.graph.XSDGraphViewer;
		60	import org.eclipse.wst.xsd.ui.internal.properties.section.XSDTabbedPropertySheetPage;
		61	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
		62	import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;
		63	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
48	import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;	64	import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
49	import org.eclipse.wst.xsd.ui.internal.util.OpenOnSelectionHelper;	65	import org.eclipse.wst.xsd.ui.internal.util.OpenOnSelectionHelper;
		66	import org.eclipse.xsd.XSDComponent;
50	import org.eclipse.xsd.XSDConcreteComponent;	67	import org.eclipse.xsd.XSDConcreteComponent;
51	import org.eclipse.xsd.XSDSchema;	68	import org.eclipse.xsd.XSDSchema;
52	import org.eclipse.xsd.util.XSDConstants;	69	import org.eclipse.xsd.util.XSDConstants;
		70	import org.w3c.dom.Attr;
53	import org.w3c.dom.Document;	71	import org.w3c.dom.Document;
54	import org.w3c.dom.Element;	72	import org.w3c.dom.Element;
		73	import org.w3c.dom.Node;
55	import org.w3c.dom.ProcessingInstruction;	74	import org.w3c.dom.ProcessingInstruction;
56		75
57	// public class XSDEditor extends StructuredTextMultiPageEditorPart	76	// public class XSDEditor extends StructuredTextMultiPageEditorPart
58	public class XSDEditor extends XSDMultiPageEditorPart implements ITabbedPropertySheetPageContributor	77	public class XSDEditor extends XSDMultiPageEditorPart implements ITabbedPropertySheetPageContributor {
59	{	78	protected StructuredTextEditor textEditor;
60	protected XSDTextEditor textEditor;	79	IFile resourceFile;
61	IFile resourceFile;	80	XSDSelectionManager xsdSelectionManager;
62	XSDSelectionManager xsdSelectionManager;	81	XSDModelAdapter schemalNodeAdapter;
63	XSDModelAdapter schemalNodeAdapter;	82
64		83	private IStructuredModel result;
65	private IStructuredModel result;	84
66		85	/**
67	public XSDEditor()	86	* Listener on SSE's outline page's selections that converts DOM
68	{	87	* selections into wsdl selections and notifies WSDL selection manager
69	super();	88	*/
70	xsdSelectionManager = new XSDSelectionManager();	89	class OutlineTreeSelectionChangeListener implements ISelectionChangedListener, IDoubleClickListener {
71	}	90	public OutlineTreeSelectionChangeListener() {
72		91	}
73	InternalPartListener partListener = new InternalPartListener(this);	92
74		93	private ISelection getXSDSelection(ISelection selection) {
75	// show outline view - defect 266116	94	ISelection sel = null;
76	public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException	95	if (selection instanceof IStructuredSelection) {
77	{	96	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
78	super.init(site, editorInput);	97	Object o = structuredSelection.getFirstElement();
79	IWorkbenchWindow dw=PlatformUI.getWorkbench().getActiveWorkbenchWindow();	98	if (o != null)
80	IWorkbenchPage page=dw.getActivePage();	99	sel = new StructuredSelection(o);
81	getSite().getPage().addPartListener(partListener);	100	}
82	try	101	return sel;
83	{	102	}
84	if (page != null)	103
85	{	104	/**
86	// page.showView("org.eclipse.ui.views.ContentOutline");	105	* Determines DOM node based on object (xsd node)
87	page.showView("org.eclipse.ui.views.PropertySheet");	106	*
88	}	107	* @param object
89	} catch (PartInitException e)	108	* @return
90	{	109	*/
91	// e.printStackTrace();	110	private Object getObjectForOtherModel(Object object) {
92	}	111	Node node = null;
93	}	112
94		113	if (object instanceof Node) {
95	// For team support	114	node = (Node) object;
96	// protected PropertyDirtyChangeListener propertyChangeListener;	115	}
97		116	else if (object instanceof XSDComponent) {
98	/**	117	node = ((XSDComponent) object).getElement();
99	* Creates the pages of this multi-page editor.	118	}
100	* <p>	119	else if (object instanceof CategoryAdapter) {
101	* Subclasses of <code>MultiPageEditor</code> must implement this method.	120	node = ((CategoryAdapter) object).getXSDSchema().getElement();
102	* </p>	121	}
103	*/	122
104	protected void createPages()	123	// the text editor can only accept sed nodes!
105	{	124	//
106	try	125	if (!(node instanceof IDOMNode)) {
107	{	126	node = null;
108	if (!loadFile())	127	}
109	return;	128	return node;
110		129	}
111	// source page MUST be created before design page, now	130
112	createSourcePage();	131	public void doubleClick(DoubleClickEvent event) {
113		132	/*
114	addSourcePage();	133	* Selection in outline tree changed so set outline tree's
115	buildXSDModel();	134	* selection into editor's selection and say it came from outline
116		135	* tree
117	// comment this line out to hide the graph page	136	*/
118	//	137	if (getSelectionManager() != null && getSelectionManager().enableNotify) {
119	createAndAddGraphPage();	138	ISelection selection = getXSDSelection(event.getSelection());
120		139	if (selection != null) {
121	int pageIndexToShow = getDefaultPageTypeIndex();	140	getSelectionManager().setSelection(selection, fOutlinePage);
122	setActivePage(pageIndexToShow);	141	}
123		142
124	addCommandStackListener();	143	if (getTextEditor() != null && selection instanceof IStructuredSelection) {
125		144	int start = -1;
126	XSDEditorPlugin.getPlugin().getPreferenceStore().addPropertyChangeListener(preferenceStoreListener);	145	int length = 0;
127	}	146	Object o = ((IStructuredSelection) selection).getFirstElement();
128	catch (PartInitException e)	147	if (o != null)
129	{	148	o = getObjectForOtherModel(o);
130	// log for now, unless we find reason not to	149	if (o instanceof IndexedRegion) {
131	Logger.log(Logger.INFO, e.getMessage());	150	start = ((IndexedRegion) o).getStartOffset();
132	}	151	length = ((IndexedRegion) o).getEndOffset() - start;
133	}	152	}
134		153	if (start > -1) {
135		154	getTextEditor().selectAndReveal(start, length);
136	public void buildXSDModel()	155	}
137	{	156	}
138	try	157	}
139	{	158	}
140	Document document = ((IDOMModel)getModel()).getDocument();	159
141		160	public void selectionChanged(SelectionChangedEvent event) {
142	boolean schemaNodeExists = document.getElementsByTagNameNS(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, "schema").getLength() == 1;	161	/*
143		162	* Selection in outline tree changed so set outline tree's
144	if (document.getChildNodes().getLength() == 0 \|\| !schemaNodeExists)	163	* selection into editor's selection and say it came from outline
145	{	164	* tree
146	createDefaultSchemaNode(document);	165	*/
147	}	166	if (getSelectionManager() != null && getSelectionManager().enableNotify) {
148		167	ISelection selection = getXSDSelection(event.getSelection());
149	if (document instanceof INodeNotifier)	168	if (selection != null) {
150	{	169	getSelectionManager().setSelection(selection, fOutlinePage);
151	INodeNotifier notifier = (INodeNotifier)document;	170	}
152	schemalNodeAdapter = (XSDModelAdapter)notifier.getAdapterFor(XSDModelAdapter.class);	171	}
153	if (schemalNodeAdapter == null)	172	}
154	{	173	}
155	schemalNodeAdapter = new XSDModelAdapter();	174
156	notifier.addAdapter(schemalNodeAdapter);	175	/**
157	schemalNodeAdapter.createSchema(document.getDocumentElement());	176	* Listener on SSE's source editor's selections that converts DOM
158	}	177	* selections into xsd selections and notifies XSD selection manager
159	}	178	*/
160	}	179	private class SourceEditorSelectionListener implements ISelectionChangedListener {
161	catch (Exception e)	180	/**
162	{	181	* Determines XSD node based on object (DOM node)
163	// XSDEditorPlugin.getPlugin().getMsgLogger().write("Failed to create Model");	182	*
164	// XSDEditorPlugin.getPlugin().getMsgLogger().write(e);	183	* @param object
165	// e.printStackTrace();	184	* @return
166	}	185	*/
167		186	private Object getXSDNode(Object object) {
168		187	// get the element node
169		188	Element element = null;
170	// XSDResourceFactoryImpl.validate(xsdSchema, input.getFile().getContents(true));	189	if (object instanceof Node) {
171	}	190	Node node = (Node) object;
172		191	if (node != null) {
173	public String[] getPropertyCategories()	192	if (node.getNodeType() == Node.ELEMENT_NODE) {
174	{	193	element = (Element) node;
175	return new String[] { "general", "namespace", "other", "attributes", "documentation", "facets" }; //$NON-NLS-1$	194	}
176	}	195	else if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
		196	element = ((Attr) node).getOwnerElement();
		197	}
		198	}
		199	}
		200	Object o = element;
		201	if (element != null) {
		202	Object modelObject = getXSDSchema().getCorrespondingComponent(element);
		203	if (modelObject != null) {
		204	o = modelObject;
		205	}
		206	}
		207	return o;
		208	}
		209
		210	public void selectionChanged(SelectionChangedEvent event) {
		211	ISelection selection = event.getSelection();
		212	if (selection instanceof IStructuredSelection) {
		213	List xsdSelections = new ArrayList();
		214	for (Iterator i = ((IStructuredSelection) selection).iterator(); i.hasNext();) {
		215	Object domNode = i.next();
		216	Object xsdNode = getXSDNode(domNode);
		217	if (xsdNode != null) {
		218	xsdSelections.add(xsdNode);
		219	}
		220	}
		221
		222	if (!xsdSelections.isEmpty()) {
		223	StructuredSelection xsdSelection = new StructuredSelection(xsdSelections);
		224	getSelectionManager().setSelection(xsdSelection, getTextEditor().getSelectionProvider());
		225	}
		226	}
		227	}
		228	}
		229
		230	/**
		231	* Listener on XSD's selection manager's selections that converts XSD
		232	* selections into DOM selections and notifies SSE's selection provider
		233	*/
		234	private class XSDSelectionManagerSelectionListener implements ISelectionChangedListener {
		235	/**
		236	* Determines DOM node based on object (xsd node)
		237	*
		238	* @param object
		239	* @return
		240	*/
		241	private Object getObjectForOtherModel(Object object) {
		242	Node node = null;
		243
		244	if (object instanceof Node) {
		245	node = (Node) object;
		246	}
		247	else if (object instanceof XSDComponent) {
		248	node = ((XSDComponent) object).getElement();
		249	}
		250	else if (object instanceof CategoryAdapter) {
		251	node = ((CategoryAdapter) object).getXSDSchema().getElement();
		252	}
		253
		254	// the text editor can only accept sed nodes!
		255	//
		256	if (!(node instanceof IDOMNode)) {
		257	node = null;
		258	}
		259	return node;
260	}
261
262	public void selectionChanged(SelectionChangedEvent event) {
263	// do not fire selection in source editor if selection event came
264	// from source editor
265	if (event.getSource() != getTextEditor().getSelectionProvider()) {
266	ISelection selection = event.getSelection();
267	if (selection instanceof IStructuredSelection) {
268	List otherModelObjectList = new ArrayList();
269	for (Iterator i = ((IStructuredSelection) selection).iterator(); i.hasNext();) {
270	Object modelObject = i.next();
271	Object otherModelObject = getObjectForOtherModel(modelObject);
272	if (otherModelObject != null) {
273	otherModelObjectList.add(otherModelObject);
274	}
275	}
276	if (!otherModelObjectList.isEmpty()) {
277	StructuredSelection nodeSelection = new StructuredSelection(otherModelObjectList);
278	getTextEditor().getSelectionProvider().setSelection(nodeSelection);
279	}
280	}
281	}
282	}
283	}
284
285	public XSDEditor() {
286	super();
287	xsdSelectionManager = new XSDSelectionManager();
288	}
289
290	InternalPartListener partListener = new InternalPartListener(this);
291
292	// show outline view - defect 266116
293	public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException {
294	super.init(site, editorInput);
295	IWorkbenchWindow dw = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
296	IWorkbenchPage page = dw.getActivePage();
297	getSite().getPage().addPartListener(partListener);
298	try {
299	if (page != null) {
300	// page.showView("org.eclipse.ui.views.ContentOutline");
301	page.showView("org.eclipse.ui.views.PropertySheet");
302	}
303	}
304	catch (PartInitException e) {
305	// e.printStackTrace();
306	}
307	}
308
309	// For team support
310	// protected PropertyDirtyChangeListener propertyChangeListener;
311
312	/**
313	* Creates the pages of this multi-page editor.
314	* <p>
315	* Subclasses of <code>MultiPageEditor</code> must implement this
316	* method.
317	* </p>
318	*/
319	protected void createPages() {
320	try {
321	if (!loadFile())
322	return;
323
324	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();
325	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);
326
327	// source page MUST be created before design page, now
328	createSourcePage();
329
330	addSourcePage();
331	buildXSDModel();
332
333	// comment this line out to hide the graph page
334	//
335	createAndAddGraphPage();
336
337	int pageIndexToShow = getDefaultPageTypeIndex();
338	setActivePage(pageIndexToShow);
339
340	openOnSelectionHelper = new OpenOnSelectionHelper(textEditor, getXSDSchema());
341	// added selection listeners after setting selection to avoid
342	// navigation exception
343	ISelectionProvider provider = getTextEditor().getSelectionProvider();
344	fSourceEditorSelectionListener = new SourceEditorSelectionListener();
345	if (provider instanceof IPostSelectionProvider) {
346	((IPostSelectionProvider) provider).addPostSelectionChangedListener(fSourceEditorSelectionListener);
347	}
348	else {
349	provider.addSelectionChangedListener(fSourceEditorSelectionListener);
350	}
351	fXSDSelectionListener = new XSDSelectionManagerSelectionListener();
352	getSelectionManager().addSelectionChangedListener(fXSDSelectionListener);
353
354	addCommandStackListener();
355
356	XSDEditorPlugin.getPlugin().getPreferenceStore().addPropertyChangeListener(preferenceStoreListener);
357	}
358	catch (PartInitException e) {
359	// log for now, unless we find reason not to
360	Logger.log(Logger.INFO, e.getMessage());
361	}
362	}
363
364
365	public void buildXSDModel() {
366	try {
367	Document document = ((IDOMModel) getModel()).getDocument();
368
369	boolean schemaNodeExists = document.getElementsByTagNameNS(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, "schema").getLength() == 1;
370
371	if (document.getChildNodes().getLength() == 0 \|\| !schemaNodeExists) {
372	createDefaultSchemaNode(document);
373	}
374
375	if (document instanceof INodeNotifier) {
376	INodeNotifier notifier = (INodeNotifier) document;
377	schemalNodeAdapter = (XSDModelAdapter) notifier.getAdapterFor(XSDModelAdapter.class);
378	if (schemalNodeAdapter == null) {
379	schemalNodeAdapter = new XSDModelAdapter();
380	notifier.addAdapter(schemalNodeAdapter);
381	schemalNodeAdapter.createSchema(document.getDocumentElement());
382	}
383	}
384	}
385	catch (Exception e) {
386	// XSDEditorPlugin.getPlugin().getMsgLogger().write("Failed to
387	// create Model");
388	// XSDEditorPlugin.getPlugin().getMsgLogger().write(e);
389	// e.printStackTrace();
390	}
391
392
393
394	// XSDResourceFactoryImpl.validate(xsdSchema,
395	// input.getFile().getContents(true));
396	}
397
398	public String[] getPropertyCategories() {
399	return new String[]{"general", "namespace", "other", "attributes", "documentation", "facets"}; //$NON-NLS-1$
400	}
177		401
178	/**	402	/**
179	* @see org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor#getContributorId()	403	* @see org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor#getContributorId()
180	*/	404	*/
181	public String getContributorId()	405	public String getContributorId() {
182	{	406	return "org.eclipse.wst.xsd.ui.internal.XSDEditor";
183	return "org.eclipse.wst.xsd.ui.internal.XSDEditor";	407	// return getSite().getId();
184	//return getSite().getId();	408	}
185	}	409
186		410	protected CommandStackListener commandStackListener;
187	protected CommandStackListener commandStackListener;	411
188	protected void addCommandStackListener()	412	protected void addCommandStackListener() {
189	{	413	if (commandStackListener == null) {
190	if (commandStackListener == null)	414	IStructuredTextUndoManager undoManager = getModel().getUndoManager();
191	{	415	commandStackListener = new CommandStackListener() {
192	IStructuredTextUndoManager undoManager = getModel().getUndoManager();	416	/**
193	commandStackListener = new CommandStackListener()	417	* @see org.eclipse.emf.common.command.CommandStackListener#commandStackChanged(EventObject)
194	{	418	*/
195	/**	419	public void commandStackChanged(EventObject event) {
196	* @see org.eclipse.emf.common.command.CommandStackListener#commandStackChanged(EventObject)	420	Object obj = event.getSource();
197	*/	421	if (obj instanceof BasicCommandStack) {
198	public void commandStackChanged(EventObject event)	422	BasicCommandStack stack = (BasicCommandStack) obj;
199	{	423	Command recentCommand = stack.getMostRecentCommand();
200	Object obj = event.getSource();	424	Command redoCommand = stack.getRedoCommand();
201	if (obj instanceof BasicCommandStack)	425	Command undoCommand = stack.getUndoCommand();
202	{	426	if (recentCommand == redoCommand) {
203	BasicCommandStack stack = (BasicCommandStack) obj;	427	// there must have been an undo reset info tasks
204	Command recentCommand = stack.getMostRecentCommand();	428	resetInformationTasks();
205	Command redoCommand = stack.getRedoCommand();	429	}
206	Command undoCommand = stack.getUndoCommand();	430	}
207	if (recentCommand == redoCommand)	431	}
208	{	432	};
209	// there must have been an undo reset info tasks	433
210	resetInformationTasks();	434	// TODO WTP Port
211	}	435	// undoManager.getCommandStack().addCommandStackListener(commandStackListener);
212	}	436
213	}	437	}
214	};	438	}
215		439
216	//TODO WTP Port undoManager.getCommandStack().addCommandStackListener(commandStackListener);	440	protected void pageChange(int arg) {
217		441	super.pageChange(arg);
218	}	442	}
219	}	443
220		444	protected void removeCommandStackListener() {
221	protected void pageChange(int arg)	445	if (commandStackListener != null) {
222	{	446	IStructuredTextUndoManager undoManager = getModel().getUndoManager();
223	super.pageChange(arg);	447	// TODO WTP Port
224	}	448	// undoManager.getCommandStack().removeCommandStackListener(commandStackListener);
225		449	}
226	protected void removeCommandStackListener()	450	}
227	{	451
228	if (commandStackListener != null)	452	// This is from the IValidateEditEditor interface
229	{	453	/*
230	IStructuredTextUndoManager undoManager = getModel().getUndoManager();	454	* public void undoChange() { StructuredTextUndoManager undoManager =
231	//TODO WTP Port undoManager.getCommandStack().removeCommandStackListener(commandStackListener);	455	* textEditor.getModel().getUndoManager(); undoManager.undo(); // Make the
232	}	456	* editor clean textEditor.getModel().setDirtyState(false); }
233	}	457	*/
234		458
235	// This is from the IValidateEditEditor interface	459	private class PreferenceStoreListener implements IPropertyChangeListener {
236	/* public void undoChange()	460	/**
237	{	461	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(PropertyChangeEvent)
238	StructuredTextUndoManager undoManager = textEditor.getModel().getUndoManager();	462	*/
239	undoManager.undo();	463	public void propertyChange(PropertyChangeEvent event) {
240	// Make the editor clean	464	}
241	textEditor.getModel().setDirtyState(false);	465	}
242	} */	466
243		467	protected IPropertyChangeListener preferenceStoreListener = new PreferenceStoreListener();
244	private class PreferenceStoreListener implements IPropertyChangeListener	468
245	{	469	protected int getDefaultPageTypeIndex() {
246	/**	470	int pageIndex = sourcePageIndex;
247	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(PropertyChangeEvent)	471
248	*/	472	if (XSDEditorPlugin.getPlugin().getDefaultPage().equals(XSDEditorPlugin.GRAPH_PAGE)) {
249	public void propertyChange(PropertyChangeEvent event)	473	if (graphPageIndex != -1)
250	{	474	pageIndex = graphPageIndex;
251	}	475	}
252	}	476
253		477	return pageIndex;
254	protected IPropertyChangeListener preferenceStoreListener = new PreferenceStoreListener();	478	}
255		479
256	protected int getDefaultPageTypeIndex()	480	int currentPage = -1;
257	{	481
258	int pageIndex = sourcePageIndex;	482	public String getCurrentPageType() {
259
260	if (XSDEditorPlugin.getPlugin().getDefaultPage().equals(XSDEditorPlugin.GRAPH_PAGE))
261	{
262	if (graphPageIndex != -1)
263	pageIndex = graphPageIndex;
264	}
265
266	return pageIndex;
267	}
268
269	int currentPage = -1;
270	public String getCurrentPageType()
271	{
272	// should update pref. for valid pages	483	// should update pref. for valid pages
273	if (getActivePage() != -1)	484	if (getActivePage() != -1) {
274	{
275	currentPage = getActivePage();	485	currentPage = getActivePage();
276	}	486	}
277	if (currentPage == graphPageIndex)	487	if (currentPage == graphPageIndex) {
278	{
279	return XSDEditorPlugin.GRAPH_PAGE;	488	return XSDEditorPlugin.GRAPH_PAGE;
280	}	489	}
281	else	490	else {
282	{
283	return XSDEditorPlugin.SOURCE_PAGE;	491	return XSDEditorPlugin.SOURCE_PAGE;
284	}	492	}
		493	}
		494
		495	public Object getActivePart() {
		496	return getSite().getWorkbenchWindow().getActivePage().getActivePart();
		497	}
		498
		499	public void dispose() {
		500	// some things in the configuration need to clean
		501	// up after themselves
		502	if (fOutlinePage != null) {
		503	if (fOutlinePage instanceof ConfigurableContentOutlinePage && fOutlineListener != null) {
		504	((ConfigurableContentOutlinePage) fOutlinePage).removeDoubleClickListener(fOutlineListener);
		505	}
		506	if (fOutlineListener != null) {
		507	fOutlinePage.removeSelectionChangedListener(fOutlineListener);
		508	}
		509	}
		510	ISelectionProvider provider = getTextEditor().getSelectionProvider();
		511	if (provider instanceof IPostSelectionProvider) {
		512	((IPostSelectionProvider) provider).removePostSelectionChangedListener(fSourceEditorSelectionListener);
		513	}
		514	else {
		515	provider.removeSelectionChangedListener(fSourceEditorSelectionListener);
		516	}
		517	getSelectionManager().removeSelectionChangedListener(fXSDSelectionListener);
		518
		519	// propertyChangeListener.dispose();
		520	removeCommandStackListener();
		521
		522	XSDEditorPlugin.getPlugin().setDefaultPage(getCurrentPageType());
		523	XSDEditorPlugin.getPlugin().getPreferenceStore().removePropertyChangeListener(preferenceStoreListener);
		524
		525	getSite().getPage().removePartListener(partListener);
		526
		527	// KB: Temporary solution for bug 99468
		528	IStructuredModel myModel = textEditor.getModel();
		529	if (myModel != null && myModel instanceof IStructuredDocumentListener)
		530	myModel.getStructuredDocument().removeDocumentChangingListener((IStructuredDocumentListener) myModel);
		531
		532	textEditor = null;
		533	resourceFile = null;
		534	xsdSelectionManager = null;
		535	schemalNodeAdapter = null;
		536	result = null;
		537	partListener = null;
		538	commandStackListener = null;
		539	preferenceStoreListener = null;
		540	openOnSelectionHelper = null;
		541	graphViewer = null;
		542
		543	super.dispose();
		544
		545	// release the schema model
		546	//
		547	if (schemalNodeAdapter != null) {
		548	schemalNodeAdapter.clear();
		549	schemalNodeAdapter = null;
		550	}
		551	}
		552
		553	protected boolean loadFile() {
		554	Object input = getEditorInput();
		555
		556	if (input instanceof IFileEditorInput) {
557	resourceFile = ((IFileEditorInput) input).getFile();
558	}
559	else if (input instanceof ILocationProvider) {
560	IPath path = ((ILocationProvider) input).getPath(input);
561	String ext = path.getFileExtension();
562	if (ext != null && ext.equals("xsd")) {
563	return true;
564	}
565	return false;
566	}
567	else {
568	return false;
569	}
570	return true;
571	}
572
573	/**
574	* Method openOnGlobalReference. The comp argument is a resolved xsd
575	* schema object from another file. This is created and called from
576	* another schema model to allow F3 navigation to open a new editor and
577	* choose the referenced object within that editor context
578	*
579	* @param comp
580	*/
581	public void openOnGlobalReference(XSDConcreteComponent comp) {
582	openOnSelectionHelper.openOnGlobalReference(comp);
583	}
584
585	protected OpenOnSelectionHelper openOnSelectionHelper;
586
587	public OpenOnSelectionHelper getOpenOnSelectionHelper() {
588	return openOnSelectionHelper;
589	}
590
591	/**
592	* @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#createTextEditor()
593	*/
594	protected StructuredTextEditor createTextEditor() {
595	textEditor = new StructuredTextEditor();
596	return textEditor;
597	}
598
599	/*
600	* @see StructuredTextMultiPageEditorPart#createSourcePage()
601	*/
602	protected void createSourcePage() throws PartInitException {
603	super.createSourcePage();
604	}
605
606	int sourcePageIndex = -1;
607
608	/**
609	* Adds the source page of the multi-page editor.
610	*/
611	protected void addSourcePage() throws PartInitException {
612
613	sourcePageIndex = addPage(textEditor, getEditorInput());
614	setPageText(sourcePageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_SOURCE"));
615
616	// the update's critical, to get viewer selection manager and
617	// highlighting to work
618	textEditor.update();
619	firePropertyChange(PROP_TITLE);
620	}
621
622	int graphPageIndex = -1;
623	XSDGraphViewer graphViewer;
624
625	/**
626	* Creates the graph page and adds it to the multi-page editor.
627	*/
628	protected void createAndAddGraphPage() throws PartInitException {
629	graphViewer = new XSDGraphViewer(this);
630	graphViewer.setSchema(getXSDSchema());
631	Control graphControl = graphViewer.createControl(getContainer());
632	graphPageIndex = addPage(graphControl);
633	setPageText(graphPageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_GRAPH"));
634
635	// graphViewer.setViewerSelectionManager(textEditor.getViewerSelectionManager());
636	graphViewer.setSelectionManager(getSelectionManager());
637
638	// this forces the editor to initially select the top level schema
639	// object
640	//
641	if (getXSDSchema() != null) {
642	getSelectionManager().setSelection(new StructuredSelection(getXSDSchema()));
643	}
644	}
645
646	protected XSDModelAdapterFactoryImpl xsdModelAdapterFactory;
647	protected XSDAdapterFactoryLabelProvider adapterFactoryLabelProvider;
648	private IPropertySheetPage fPropertySheetPage;
649	private IContentOutlinePage fOutlinePage;
650	private OutlineTreeSelectionChangeListener fOutlineListener;
651	private SourceEditorSelectionListener fSourceEditorSelectionListener;
652	private XSDSelectionManagerSelectionListener fXSDSelectionListener;
653
654	/*
655	* @see IAdaptable#getAdapter(Class)
656	*/
657	public Object getAdapter(Class key) {
658	Object result = null;
659	if (key == ISelectionProvider.class) {
660	result = xsdSelectionManager;
661	}
662	if (IPropertySheetPage.class.equals(key)) {
663	fPropertySheetPage = new XSDTabbedPropertySheetPage(this);
664
665	((XSDTabbedPropertySheetPage) fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);
666	((XSDTabbedPropertySheetPage) fPropertySheetPage).setSelectionManager(getSelectionManager());
667	((XSDTabbedPropertySheetPage) fPropertySheetPage).setXSDSchema(getXSDSchema());
668
669	return fPropertySheetPage;
670	}
671	else if (IContentOutlinePage.class.equals(key)) {
672	if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed()) {
673	IContentOutlinePage page = (IContentOutlinePage) super.getAdapter(key);
674	if (page != null) {
675	fOutlineListener = new OutlineTreeSelectionChangeListener();
676	page.addSelectionChangedListener(fOutlineListener);
677	if (page instanceof ConfigurableContentOutlinePage) {
678	((ConfigurableContentOutlinePage) page).addDoubleClickListener(fOutlineListener);
679	}
680	}
681	fOutlinePage = page;
682	// XSDContentOutlinePage outlinePage = new
683	// XSDContentOutlinePage(this);
684	// XSDContentProvider xsdContentProvider = new
685	// XSDContentProvider(xsdModelAdapterFactory);
686	// xsdContentProvider.setXSDSchema(getXSDSchema());
687	// outlinePage.setContentProvider(xsdContentProvider);
688	// outlinePage.setLabelProvider(adapterFactoryLabelProvider);
689	// outlinePage.setModel(getXSDSchema().getDocument());
690	//
691	// fOutlinePage = outlinePage;
692	}
693	return fOutlinePage;
694	}
695	else {
696	result = super.getAdapter(key);
697	}
698	return result;
699	}
700
701
702	public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory() {
703	return xsdModelAdapterFactory;
704	}
705
706	public XSDAdapterFactoryLabelProvider getLabelProvider() {
707	return adapterFactoryLabelProvider;
708	}
709
710
711	public XSDSelectionManager getSelectionManager() {
712	return xsdSelectionManager;
713	}
714
715	/**
716	* @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#doSaveAs()
717	*/
718	public void doSaveAs() {
719	super.doSaveAs();
720	}
721
722	public void doSave(org.eclipse.core.runtime.IProgressMonitor monitor) {
723	super.doSave(monitor);
724	}
725
726	public void reparseSchema() {
727	// TODO cs : Are there no better ways to make the model
728	// reload it's dependencies? This seems rather extreme.
729	//
730	Document document = ((IDOMModel) getModel()).getDocument();
731	if (schemalNodeAdapter != null) {
732	schemalNodeAdapter.createSchema(document.getDocumentElement());
733	}
734	}
735
736	/**
737	* Returns the xsdSchema.
738	*
739	* @return XSDSchema
740	*/
741	public XSDSchema getXSDSchema() {
742	return schemalNodeAdapter != null ? schemalNodeAdapter.getSchema() : null;
743	}
744
745
746	/**
747	* Returns the resourceFile.
748	*
749	* @return IFile
750	*/
751	public IFile getFileResource() {
752	return resourceFile;
753	}
754
755	/**
756	* Get the IDocument from the text viewer
757	*/
758	public IDocument getEditorIDocument() {
759	IDocument document = textEditor.getTextViewer().getDocument();
760	return document;
761	}
762
763	/**
764	* Create ref integrity tasks in task list
765	*/
766	public void createTasksInTaskList(ArrayList messages) {
767	// DisplayErrorInTaskList tasks = new
768	// DisplayErrorInTaskList(getEditorIDocument(), getFileResource(),
769	// messages);
770	// tasks.run();
771	}
772
773	public void resetInformationTasks() {
774	// DisplayErrorInTaskList.removeInfoMarkers(getFileResource());
775	}
776
777	public XSDGraphViewer getGraphViewer() {
778	return graphViewer;
779	}
780
781	public IEditorPart getActiveEditorPage() {
782	return getActiveEditor();
783	}
784
785	public StructuredTextEditor getTextEditor() {
786	return textEditor;
787	}
788
789	class InternalPartListener implements IPartListener {
790	XSDEditor editor;
791
792	public InternalPartListener(XSDEditor editor) {
793	this.editor = editor;
794	}
795
796	public void partActivated(IWorkbenchPart part) {
797	if (part == editor) {
798	ISelection selection = getSelectionManager().getSelection();
799	if (selection != null) {
800	if (getCurrentPageType().equals(XSDEditorPlugin.GRAPH_PAGE)) {
801	getSelectionManager().selectionChanged(new SelectionChangedEvent(editor.getGraphViewer().getComponentViewer(), selection));
802	}
803	else if (getCurrentPageType().equals(XSDEditorPlugin.SOURCE_PAGE)) {
804	getSelectionManager().setSelection(selection);
805	}
806	}
807	}
808	}
809
810	public void partBroughtToTop(IWorkbenchPart part) {
811	}
812
813	public void partClosed(IWorkbenchPart part) {
814	}
815
816	public void partDeactivated(IWorkbenchPart part) {
817	}
818
819	public void partOpened(IWorkbenchPart part) {
820	}
821	}
822
823
824	/**
825	* Method createDefaultSchemaNode. Should only be called to insert a
826	* schema node into an empty document
827	*/
828	public void createDefaultSchemaNode(Document document) {
829	if (document.getChildNodes().getLength() == 0) {
830	// if it is a completely empty file, then add the encoding and
831	// version processing instruction
832	// TODO String encoding = EncodingHelper.getDefaultEncodingTag();
833	String encoding = "UTF-8";
834	ProcessingInstruction instr = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"" + encoding + "\"");
835	document.appendChild(instr);
836	}
837
838	// Create a default schema tag now
839
840	// String defaultPrefixForTargetNamespace =
841	// getFileResource().getProjectRelativePath().removeFileExtension().lastSegment();
842	String defaultPrefixForTargetNamespace = "tns";
843	String prefixForSchemaNamespace = "";
844	String schemaNamespaceAttribute = "xmlns";
845	if (XSDEditorPlugin.getPlugin().isQualifyXMLSchemaLanguage()) {
846	// Added this if check before disallowing blank prefixes in the
847	// preferences...
848	// Can take this out. See also NewXSDWizard
849	if (XSDEditorPlugin.getPlugin().getXMLSchemaPrefix().trim().length() > 0) {
850	prefixForSchemaNamespace = XSDEditorPlugin.getPlugin().getXMLSchemaPrefix() + ":";
851	schemaNamespaceAttribute += ":" + XSDEditorPlugin.getPlugin().getXMLSchemaPrefix();
852	}
853	}
854
855	document.appendChild(document.createTextNode("\n"));
856	Element element = document.createElement(prefixForSchemaNamespace + XSDConstants.SCHEMA_ELEMENT_TAG);
857
858	element.setAttribute(schemaNamespaceAttribute, "http://www.w3.org/2001/XMLSchema");
859
860	String defaultTargetURI = XSDEditorPlugin.getPlugin().getXMLSchemaTargetNamespace();
861	element.setAttribute(XSDConstants.TARGETNAMESPACE_ATTRIBUTE, defaultTargetURI);
862	element.setAttribute("xmlns:" + defaultPrefixForTargetNamespace, defaultTargetURI);
863
864	document.appendChild(element);
285	}	865	}
286
287	public Object getActivePart()
288	{
289	return getSite().getWorkbenchWindow().getActivePage().getActivePart();
290	}
291
292	public void dispose()
293	{
294	// propertyChangeListener.dispose();
295	removeCommandStackListener();
296
297	XSDEditorPlugin.getPlugin().setDefaultPage(getCurrentPageType());
298	XSDEditorPlugin.getPlugin().getPreferenceStore().removePropertyChangeListener(preferenceStoreListener);
299
300	getSite().getPage().removePartListener(partListener);
301
302	// KB: Temporary solution for bug 99468
303	IStructuredModel myModel = textEditor.getModel();
304	if (myModel != null && myModel instanceof IStructuredDocumentListener)
305	myModel.getStructuredDocument().removeDocumentChangingListener((IStructuredDocumentListener)myModel);
306
307	textEditor = null;
308	resourceFile = null;
309	xsdSelectionManager = null;
310	schemalNodeAdapter = null;
311	result = null;
312	partListener = null;
313	commandStackListener = null;
314	preferenceStoreListener = null;
315	openOnSelectionHelper = null;
316	graphViewer = null;
317
318	super.dispose();
319
320	// release the schema model
321	//
322	if (schemalNodeAdapter != null)
323	{
324	schemalNodeAdapter.clear();
325	schemalNodeAdapter = null;
326	}
327	}
328
329	protected boolean loadFile()
330	{
331	Object input = getEditorInput();
332
333	if (input instanceof IFileEditorInput)
334	{
335	resourceFile = ((IFileEditorInput) input).getFile();
336	}
337	else if (input instanceof ILocationProvider)
338	{
339	IPath path = ((ILocationProvider)input).getPath(input);
340	String ext = path.getFileExtension();
341	if (ext != null && ext.equals("xsd"))
342	{
343	return true;
344	}
345	return false;
346	}
347	else
348	{
349	return false;
350	}
351	return true;
352	}
353
354	/**
355	* Method openOnGlobalReference.
356	* The comp argument is a resolved xsd schema object from another file. This is created and called from another
357	* schema model to allow F3 navigation to open a new editor and choose the referenced object within that editor context
358	* @param comp
359	*/
360	public void openOnGlobalReference(XSDConcreteComponent comp)
361	{
362	openOnSelectionHelper.openOnGlobalReference(comp);
363	}
364
365	protected OpenOnSelectionHelper openOnSelectionHelper;
366
367	public OpenOnSelectionHelper getOpenOnSelectionHelper()
368	{
369	return openOnSelectionHelper;
370	}
371
372	/**
373	* @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#createTextEditor()
374	*/
375	protected StructuredTextEditor createTextEditor()
376	{
377	return new XSDTextEditor(this);
378	}
379
380	/*
381	* @see StructuredTextMultiPageEditorPart#createSourcePage()
382	*/
383	protected void createSourcePage() throws PartInitException
384	{
385	super.createSourcePage();
386
387	textEditor = (XSDTextEditor) getTextEditor();
388
389	openOnSelectionHelper = new OpenOnSelectionHelper(textEditor);
390	}
391
392	int sourcePageIndex = -1;
393	/**
394	* Adds the source page of the multi-page editor.
395	*/
396	protected void addSourcePage() throws PartInitException {
397
398	sourcePageIndex = addPage(textEditor, getEditorInput());
399	setPageText(sourcePageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_SOURCE"));
400
401	// the update's critical, to get viewer selection manager and highlighting to work
402	textEditor.update();
403	firePropertyChange(PROP_TITLE);
404	}
405
406	int graphPageIndex = -1;
407	XSDGraphViewer graphViewer;
408
409	/**
410	* Creates the graph page and adds it to the multi-page editor.
411	*/
412	protected void createAndAddGraphPage() throws PartInitException
413	{
414	graphViewer = new XSDGraphViewer(this);
415	graphViewer.setSchema(getXSDSchema());
416	Control graphControl = graphViewer.createControl(getContainer());
417	graphPageIndex = addPage(graphControl);
418	setPageText(graphPageIndex, XSDEditorPlugin.getXSDString("_UI_TAB_GRAPH"));
419
420	// graphViewer.setViewerSelectionManager(textEditor.getViewerSelectionManager());
421	graphViewer.setSelectionManager(getSelectionManager());
422
423	// this forces the editor to initially select the top level schema object
424	//
425	if (textEditor.getXSDSchema() != null)
426	{
427	getSelectionManager().setSelection(new StructuredSelection(textEditor.getXSDSchema()));
428	}
429	}
430
431	/*
432	* @see IAdaptable#getAdapter(Class)
433	*/
434	public Object getAdapter(Class key)
435	{
436	Object result = null;
437	if (key == ISelectionProvider.class)
438	{
439	result = xsdSelectionManager;
440	}
441	else
442	{
443	result = textEditor.getAdapter(key);
444	}
445	return result;
446	}
447
448	public XSDSelectionManager getSelectionManager()
449	{
450	return xsdSelectionManager;
451	}
452
453	/**
454	* @see org.eclipse.wst.xsd.ui.internal.XSDMultiPageEditorPart#doSaveAs()
455	*/
456	public void doSaveAs()
457	{
458	super.doSaveAs();
459	}
460
461	public void doSave(org.eclipse.core.runtime.IProgressMonitor monitor)
462	{
463	super.doSave(monitor);
464	}
465
466	public void reparseSchema()
467	{
468	// TODO cs : Are there no better ways to make the model
469	// reload it's dependencies? This seems rather extreme.
470	//
471	Document document = ((IDOMModel)getModel()).getDocument();
472	if (schemalNodeAdapter != null)
473	{
474	schemalNodeAdapter.createSchema(document.getDocumentElement());
475	}
476	}
477
478	/**
479	* Returns the xsdSchema.
480	* @return XSDSchema
481	*/
482	public XSDSchema getXSDSchema()
483	{
484	return schemalNodeAdapter != null ? schemalNodeAdapter.getSchema() : null;
485	}
486
487
488	/**
489	* Returns the resourceFile.
490	* @return IFile
491	*/
492	public IFile getFileResource()
493	{
494	return resourceFile;
495	}
496
497	/**
498	* Get the IDocument from the text viewer
499	*/
500	public IDocument getEditorIDocument()
501	{
502	IDocument document = textEditor.getTextViewer().getDocument();
503	return document;
504	}
505
506	/**
507	* Create ref integrity tasks in task list
508	*/
509	public void createTasksInTaskList(ArrayList messages)
510	{
511	// DisplayErrorInTaskList tasks = new DisplayErrorInTaskList(getEditorIDocument(), getFileResource(), messages);
512	// tasks.run();
513	}
514
515	public void resetInformationTasks()
516	{
517	// DisplayErrorInTaskList.removeInfoMarkers(getFileResource());
518	}
519
520	public XSDGraphViewer getGraphViewer()
521	{
522	return graphViewer;
523	}
524
525	public IEditorPart getActiveEditorPage()
526	{
527	return getActiveEditor();
528	}
529
530	public XSDTextEditor getXSDTextEditor()
531	{
532	return textEditor;
533	}
534
535	class InternalPartListener implements IPartListener
536	{
537	XSDEditor editor;
538	public InternalPartListener(XSDEditor editor)
539	{
540	this.editor = editor;
541	}
542
543	public void partActivated(IWorkbenchPart part)
544	{
545	if (part == editor)
546	{
547	ISelection selection = getSelectionManager().getSelection();
548	if (selection != null)
549	{
550	if (getCurrentPageType().equals(XSDEditorPlugin.GRAPH_PAGE))
551	{
552	getSelectionManager().selectionChanged(new SelectionChangedEvent(editor.getGraphViewer().getComponentViewer(), selection));
553	}
554	else if (getCurrentPageType().equals(XSDEditorPlugin.SOURCE_PAGE))
555	{
556	getSelectionManager().setSelection(selection);
557	}
558	}
559	}
560	}
561
562	public void partBroughtToTop(IWorkbenchPart part)
563	{
564	}
565
566	public void partClosed(IWorkbenchPart part)
567	{
568	}
569
570	public void partDeactivated(IWorkbenchPart part)
571	{
572	}
573
574	public void partOpened(IWorkbenchPart part)
575	{
576	}
577	}
578
579
580	/**
581	* Method createDefaultSchemaNode. Should only be called to insert a schema node into an empty document
582	*/
583	public void createDefaultSchemaNode(Document document)
584	{
585	if (document.getChildNodes().getLength() == 0)
586	{
587	// if it is a completely empty file, then add the encoding and version processing instruction
588	//TODO String encoding = EncodingHelper.getDefaultEncodingTag();
589	String encoding = "UTF-8";
590	ProcessingInstruction instr = document.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"" + encoding + "\"");
591	document.appendChild(instr);
592	}
593
594	// Create a default schema tag now
595
596	// String defaultPrefixForTargetNamespace = getFileResource().getProjectRelativePath().removeFileExtension().lastSegment();
597	String defaultPrefixForTargetNamespace = "tns";
598	String prefixForSchemaNamespace = "";
599	String schemaNamespaceAttribute = "xmlns";
600	if (XSDEditorPlugin.getPlugin().isQualifyXMLSchemaLanguage())
601	{
602	// Added this if check before disallowing blank prefixes in the preferences...
603	// Can take this out. See also NewXSDWizard
604	if (XSDEditorPlugin.getPlugin().getXMLSchemaPrefix().trim().length() > 0)
605	{
606	prefixForSchemaNamespace = XSDEditorPlugin.getPlugin().getXMLSchemaPrefix() + ":";
607	schemaNamespaceAttribute += ":" + XSDEditorPlugin.getPlugin().getXMLSchemaPrefix();
608	}
609	}
610
611	document.appendChild(document.createTextNode("\n"));
612	Element element = document.createElement(prefixForSchemaNamespace + XSDConstants.SCHEMA_ELEMENT_TAG);
613
614	element.setAttribute(schemaNamespaceAttribute,"http://www.w3.org/2001/XMLSchema");
615
616	String defaultTargetURI = XSDEditorPlugin.getPlugin().getXMLSchemaTargetNamespace();
617	element.setAttribute(XSDConstants.TARGETNAMESPACE_ATTRIBUTE, defaultTargetURI);
618	element.setAttribute("xmlns:" + defaultPrefixForTargetNamespace, defaultTargetURI);
619
620	document.appendChild(element);
621	}
622	}	866	}




import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;
import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xsd.ui.internal.properties.section.XSDTabbedPropertySheetPage;
import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;
import org.eclipse.wst.xsd.ui.internal.provider.XSDContentProvider;
import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
import org.eclipse.wst.xsd.ui.internal.refactor.actions.RefactorActionGroup;
import org.eclipse.wst.xsd.ui.internal.util.SelectionAdapter;

import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * @deprecated Do not use subclass of StructuredTextEditor
 */
public class XSDTextEditor extends StructuredTextEditor implements INodeSelectionListener, ISelectionChangedListener
{
  protected XSDSelectionManager xsdSelectionManager;

  protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider();
  private IPropertySheetPage fPropertySheetPage;
  private IContentOutlinePage fOutlinePage;
  
  public XSDTextEditor(XSDEditor xsdEditor)
  {
    super();

    xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();
    adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);
  }
  
  public void dispose()
  {
    super.dispose();

    xsdModelAdapterFactory = null;
  }
  
//  public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()
//  {
//    return xsdModelAdapterFactory;
//  }
//
//  public static XSDAdapterFactoryLabelProvider getLabelProvider()
//  {
//    return adapterFactoryLabelProvider;
//  }

//	public Object getAdapter(Class required) {
//	  
//		if (IPropertySheetPage.class.equals(required))
//    {
//	    fPropertySheetPage = new XSDTabbedPropertySheetPage(getXSDEditor());
//      
//	    ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);
//      ((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getXSDEditor().getSelectionManager());
//	    ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());
//
//      return fPropertySheetPage;
//		}
//		else if (IContentOutlinePage.class.equals(required))
//		{
//			if (fOutlinePage == null || fOutlinePage.getControl() == null || fOutlinePage.getControl().isDisposed())
//			{
//				XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(getXSDEditor());
//        XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);
//        xsdContentProvider.setXSDSchema(getXSDSchema());
//	      outlinePage.setContentProvider(xsdContentProvider);
//	      outlinePage.setLabelProvider(adapterFactoryLabelProvider);
//				outlinePage.setModel(getXSDSchema().getDocument());
//				
//				// Update outline selection from source editor selection:
//	      getViewerSelectionManager().addNodeSelectionListener(this);
//	      internalSelectionProvider.addSelectionChangedListener(getViewerSelectionManager());
//	      internalSelectionProvider.setEventSource(outlinePage);
//
//				fOutlinePage = outlinePage;
//			}
//			return fOutlinePage;
//		}
//	
//		return super.getAdapter(required);
//	}
  
 
  protected XSDContentOutlinePage outlinePage;

		fRefactorMenuGroup.setContext(context);
		fRefactorMenuGroup.fillContextMenu(menu);
		fRefactorMenuGroup.setContext(null);
	}
}


Lines 15-23 Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/properties/section/XSDSectionLabelProvider.java (-2 / +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;
21	import org.eclipse.xsd.XSDAttributeDeclaration;	24	import org.eclipse.xsd.XSDAttributeDeclaration;
22	import org.eclipse.xsd.XSDConcreteComponent;	25	import org.eclipse.xsd.XSDConcreteComponent;
23	import org.eclipse.xsd.XSDElementDeclaration;	26	import org.eclipse.xsd.XSDElementDeclaration;
Lines 50-56 Link Here
50		53
51	if (selected instanceof XSDConcreteComponent)	54	if (selected instanceof XSDConcreteComponent)
52	{	55	{
53	return XSDTextEditor.getLabelProvider().getImage((XSDConcreteComponent)selected);	56	IWorkbench workbench = XSDEditorPlugin.getPlugin().getWorkbench();
		57	IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
		58	IEditorPart editorPart = workbenchWindow.getActivePage().getActiveEditor();
		59	if (editorPart instanceof XSDEditor)
		60	{
		61	return ((XSDEditor)editorPart).getLabelProvider().getImage((XSDConcreteComponent)selected);
		62	}
54	}	63	}
55		64
56	// selected = typeMapper.remapObject(selected);	65	// 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.emf.edit.provider.IChangeNotifier;
import org.eclipse.emf.edit.provider.INotifyChangedListener;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDModelGroup;
import org.eclipse.xsd.XSDParticleContent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDWildcard;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

public class XSDContentProvider implements ITreeContentProvider, INotifyChangedListener
{
  XSDModelAdapterFactoryImpl xsdModelAdapterFactory;

  XSDSchema xsdSchema;
  public XSDContentProvider(XSDModelAdapterFactoryImpl xsdModelAdapterFactoryImpl)
  {
    this.xsdModelAdapterFactory = xsdModelAdapterFactoryImpl;

    }
  }
  
  public void setXSDSchema(XSDSchema xsdSchema)
  {
    this.xsdSchema = xsdSchema;
  }
  
  /*
   * @see ITreeContentProvider#getChildren(Object)
   */

  {
    XSDConcreteComponent xsdComp = null;
    List list = null;
    
    // root/input is structuredmodel
    if (parentElement instanceof IDOMModel) {
		IDOMDocument domDoc = ((IDOMModel) parentElement).getDocument();
		if (domDoc != null) {
			XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
			/*
			 * ISSUE: Didn't want to go through initializing
			 * schema if it does not already exist, so just
			 * attempted to get existing adapter. If doesn't
			 * exist, just don't bother working.
			 */
			if (modelAdapter != null)
				xsdComp = modelAdapter.getSchema();
			if (xsdComp != null) {
		      xsdModelAdapterFactory.adapt(xsdComp, xsdModelAdapterFactory);

		      list = new ArrayList();
		      list.add(xsdComp);
		      return list.toArray();
			}
		}
    }
    else if (parentElement instanceof XSDConcreteComponent)
    {

    this.viewer = viewer;
  }
  
	/**
	 * Gets the xsd schema from document
	 * 
	 * @param document
	 * @return XSDSchema or null of one does not exist yet for document
	 */
	private XSDSchema getXSDSchema(IDocument document) {
		XSDSchema schema = null;
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
		if (model != null) {
			try {
				if (model instanceof IDOMModel) {
					IDOMDocument domDoc = ((IDOMModel) model).getDocument();
					if (domDoc != null) {
						XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
						/*
						 * ISSUE: Didn't want to go through initializing
						 * schema if it does not already exist, so just
						 * attempted to get existing adapter. If doesn't
						 * exist, just don't bother working.
						 */
						if (modelAdapter != null)
							schema = modelAdapter.getSchema();
					}
				}
			}
			finally {
				model.releaseFromRead();
			}
		}
		return schema;
	}
}





import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.swt.graphics.Image;

import org.eclipse.xsd.XSDTypeDefinition;


public class XSDSchemaAdapter extends XSDAbstractAdapter {
	protected XSDPackage xsdPackage;

	/**
	 * @param adapterFactory
	 */
	public XSDSchemaAdapter(AdapterFactory adapterFactory) {
		super(adapterFactory);
		xsdPackage = XSDPackage.eINSTANCE;
	}

	public Image getImage(Object element) {
		return XSDEditorPlugin.getXSDImage("icons/XSDFile.gif");
	}

	public String getText(Object element) {
		XSDSchema xsdSchema = (XSDSchema) element;
		String result = xsdSchema.getSchemaLocation();
		if (result == null) {
			return "";
		}
		else {
			return URI.createURI(result).lastSegment();
		}
	}

	List children;
	private CategoryAdapter fDirectivesCategory;
	private CategoryAdapter fElementsCategory;
	private CategoryAdapter fAttributesCategory;
	private CategoryAdapter fAttributeGroupsCategory;
	private CategoryAdapter fTypesCategory;
	private CategoryAdapter fGroupsCategory;
	private CategoryAdapter fNotationsCategory;

	/**
	 * Create all the category adapters
	 * 
	 * @param xsdSchema
	 */
	private void createCategoryAdapters(XSDSchema xsdSchema) {
		List directivesList = getDirectives(xsdSchema);
		List elementsList = getGlobalElements(xsdSchema);
		List attributeGroupList = getAttributeGroupList(xsdSchema);
		List attributesList = getAttributeList(xsdSchema);
		List groups = getGroups(xsdSchema);
		List notations = getNotations(xsdSchema);
		List types = getComplexTypes(xsdSchema);
		types.addAll(getSimpleTypes(xsdSchema));

		fDirectivesCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_Elements_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_DIRECTIVES"), XSDEditorPlugin.getPlugin().getIconImage("obj16/directivesheader"), directivesList, xsdSchema, CategoryAdapter.DIRECTIVES);
		fElementsCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_Elements_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_ELEMENTS"), XSDEditorPlugin.getPlugin().getIconImage("obj16/elementsheader"), elementsList, xsdSchema, CategoryAdapter.ELEMENTS);
		fAttributesCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_Attributes_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_ATTRIBUTES"), XSDEditorPlugin.getPlugin().getIconImage("obj16/attributesheader"), attributesList, xsdSchema, CategoryAdapter.ATTRIBUTES);
		fAttributeGroupsCategory = new CategoryAdapter(// XSDEditPlugin.getString("_UI_AttributeGroups_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_ATTRIBUTE_GROUPS"), XSDEditorPlugin.getPlugin().getIconImage("obj16/attributegroupsheader"), attributeGroupList, xsdSchema, CategoryAdapter.ATTRIBUTE_GROUPS);
		fTypesCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_Types_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_TYPES"), XSDEditorPlugin.getPlugin().getIconImage("obj16/typesheader"), types, xsdSchema, CategoryAdapter.TYPES);
		fGroupsCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_ModelGroups_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_GROUPS"), XSDEditorPlugin.getPlugin().getIconImage("obj16/groupsheader"), groups, xsdSchema, CategoryAdapter.GROUPS);
		fNotationsCategory = new CategoryAdapter( // XSDEditPlugin.getString("_UI_Notations_label"),
					XSDEditorPlugin.getXSDString("_UI_GRAPH_NOTATIONS"), XSDEditorPlugin.getPlugin().getIconImage("obj16/notationsheader"), notations, xsdSchema, CategoryAdapter.NOTATIONS);
	}

	public void setTarget(Notifier newTarget) {
		super.setTarget(newTarget);

		XSDSchema xsdSchema = ((XSDSchema) newTarget);
		createCategoryAdapters(xsdSchema);
	}

	public Object[] getChildren(Object parentElement) {
		XSDSchema xsdSchema = ((XSDSchema) parentElement);

		children = new ArrayList();

		// just set categoryadapters' children if category adapters are
		// already created
		if (fDirectivesCategory != null) {
			List directivesList = getDirectives(xsdSchema);
			List elementsList = getGlobalElements(xsdSchema);
			List attributeGroupList = getAttributeGroupList(xsdSchema);
			List attributesList = getAttributeList(xsdSchema);
			List groups = getGroups(xsdSchema);
			List notations = getNotations(xsdSchema);
			List types = getComplexTypes(xsdSchema);
			types.addAll(getSimpleTypes(xsdSchema));

			fDirectivesCategory.setChildren(directivesList);
			fElementsCategory.setChildren(elementsList);
			fAttributesCategory.setChildren(attributesList);
			fAttributeGroupsCategory.setChildren(attributeGroupList);
			fTypesCategory.setChildren(types);
			fGroupsCategory.setChildren(groups);
			fNotationsCategory.setChildren(notations);

			// children.add
			// (new CategoryAdapter
			// ( //XSDEditPlugin.getString("_UI_IdentityConstraints_label"),
			// "Identity Constraints",
			// XSDEditorPlugin.getPlugin().getIconImage("full/obj16/XSDIdentityConstraintDefinitionKey"),
			// xsdSchema.getIdentityConstraintDefinitions(), xsdSchema,
			// CategoryAdapter.IDENTITY_CONSTRAINTS));
			// children.add
			// (new CategoryAdapter
			// ( // XSDEditPlugin.getString("_UI_Annotations_label"),
			// "Annotations",
			// XSDEditorPlugin.getPlugin().getIconImage("obj16/annotationsheader"),
			// xsdSchema.getAnnotations(), xsdSchema,
			// CategoryAdapter.ANNOTATIONS));
		}
		else {
			createCategoryAdapters(xsdSchema);
		}

		children.add(fDirectivesCategory);
		children.add(fElementsCategory);
		children.add(fAttributesCategory);
		children.add(fAttributeGroupsCategory);
		children.add(fTypesCategory);
		children.add(fGroupsCategory);
		children.add(fNotationsCategory);

		return children.toArray();
	}

	public boolean hasChildren(Object object) {
		return true;
	}

	public Object getParent(Object object) {
		return null;
	}

	public void notifyChanged(final Notification msg) {
		class CategoryNotification extends NotificationImpl {
			protected Object category;

			public CategoryNotification(Object category) {
				super(msg.getEventType(), msg.getOldValue(), msg.getNewValue(), msg.getPosition());
				this.category = category;
			}

			public Object getNotifier() {
				return category;
			}

			public Object getFeature() {
				return msg.getFeature();
			}
		}

		if (children == null) {
			getChildren(target);
		}

		if (msg.getFeature() == xsdPackage.getXSDSchema_Contents()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(0);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getDirectives(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_ElementDeclarations()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(1);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getGlobalElements(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_AttributeDeclarations()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(2);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getAttributeList(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_AttributeGroupDefinitions()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(3);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getAttributeGroupList(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_TypeDefinitions()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(4);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			List types = getComplexTypes(xsdSchema);
			types.addAll(getSimpleTypes(xsdSchema));

			adapter.setChildren(types);
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_ModelGroupDefinitions()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(5);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getGroups(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_NotationDeclarations()) {
			CategoryAdapter adapter = (CategoryAdapter) children.get(6);
			XSDSchema xsdSchema = adapter.getXSDSchema();
			adapter.setChildren(getNotations(xsdSchema));
			this.fireNotifyChanged(new CategoryNotification(adapter));
			return;
		}
		// else if (msg.getFeature() ==
		// xsdPackage.getXSDSchema_IdentityConstraintDefinitions())
		// {
		// this.fireNotifyChanged(new CategoryNotification(children.get(7)));
		// return;
		// }
		else if (msg.getFeature() == xsdPackage.getXSDSchema_Annotations()) {
			// this.fireNotifyChanged(new
			// CategoryNotification(children.get(7)));
			return;
		}
		else if (msg.getFeature() == xsdPackage.getXSDSchema_SchemaLocation()) {
			this.fireNotifyChanged(msg);
			return;
		}

		super.notifyChanged(msg);
	}

	protected List getDirectives(XSDSchema schema) {
		List list = new ArrayList();
		for (Iterator i = schema.getContents().iterator(); i.hasNext();) {
			Object o = i.next();
			if (o instanceof XSDSchemaDirective) {
				list.add(o);
			}
		}
		return list;
	}

	protected List getAttributeGroupList(XSDSchema xsdSchema) {
		List attributeGroupList = new ArrayList();
		for (Iterator i = xsdSchema.getAttributeGroupDefinitions().iterator(); i.hasNext();) {
			XSDAttributeGroupDefinition attrGroup = (XSDAttributeGroupDefinition) i.next();
			if (attrGroup.getRootContainer() == xsdSchema) {
				attributeGroupList.add(attrGroup);
			}
		}
		return attributeGroupList;
	}

	protected List getAttributeList(XSDSchema xsdSchema) {
		List attributesList = new ArrayList();
		for (Iterator iter = xsdSchema.getAttributeDeclarations().iterator(); iter.hasNext();) {
			Object o = iter.next();
			if (o instanceof XSDAttributeDeclaration) {
				XSDAttributeDeclaration attr = (XSDAttributeDeclaration) o;
				if (attr != null) {
					if (attr.getTargetNamespace() != null) {
						if (!(attr.getTargetNamespace().equals("http://www.w3.org/2001/XMLSchema-instance"))) {
							if (attr.getRootContainer() == xsdSchema) {
								attributesList.add(attr);
							}
						}
					}
					else {
						if (attr.getRootContainer() == xsdSchema) {
							attributesList.add(attr);
						}
					}
				}
			}
		}
		return attributesList;
	}

	protected List getGlobalElements(XSDSchema schema) {
		List elements = schema.getElementDeclarations();
		List list = new ArrayList();
		for (Iterator i = elements.iterator(); i.hasNext();) {
			XSDElementDeclaration elem = (XSDElementDeclaration) i.next();
			if (elem.getRootContainer() == schema) {
				list.add(elem);
			}
		}
		return list;
	}

	protected List getComplexTypes(XSDSchema schema) {
		List allTypes = schema.getTypeDefinitions();
		List list = new ArrayList();
		for (Iterator i = allTypes.iterator(); i.hasNext();) {
			XSDTypeDefinition td = (XSDTypeDefinition) i.next();
			if (td instanceof XSDComplexTypeDefinition) {
				XSDComplexTypeDefinition ct = (XSDComplexTypeDefinition) td;
				if (ct.getRootContainer() == schema) {
					list.add(ct);
				}
			}
		}
		return list;
	}

	protected List getSimpleTypes(XSDSchema schema) {
		List allTypes = schema.getTypeDefinitions();
		List list = new ArrayList();
		for (Iterator i = allTypes.iterator(); i.hasNext();) {
			XSDTypeDefinition td = (XSDTypeDefinition) i.next();
			if (td instanceof XSDSimpleTypeDefinition) {
				XSDSimpleTypeDefinition st = (XSDSimpleTypeDefinition) td;
				if (st.getRootContainer() == schema) {
					list.add(st);
				}
			}
		}
		return list;
	}

	protected List getGroups(XSDSchema schema) {
		List groups = schema.getModelGroupDefinitions();
		List list = new ArrayList();
		for (Iterator i = groups.iterator(); i.hasNext();) {
			XSDModelGroupDefinition group = (XSDModelGroupDefinition) i.next();
			if (group.getRootContainer() == schema) {
				list.add(group);
			}
		}
		return list;
	}

	protected List getNotations(XSDSchema schema) {
		List notations = schema.getNotationDeclarations();
		List list = new ArrayList();
		for (Iterator i = notations.iterator(); i.hasNext();) {
			XSDNotationDeclaration notation = (XSDNotationDeclaration) i.next();
			if (notation.getRootContainer() == schema) {
				list.add(notation);
			}
		}
		return list;
	}
    List groups = schema.getModelGroupDefinitions();
    List list = new ArrayList();
    for (Iterator i = groups.iterator(); i.hasNext(); )
    {
      XSDModelGroupDefinition group = (XSDModelGroupDefinition)i.next();
      if (group.getRootContainer() == schema)
      {
        list.add(group);
      }
    }                
    return list;
  }
  
  protected List getNotations(XSDSchema schema)
  {
    List notations = schema.getNotationDeclarations();
    List list = new ArrayList();
    for (Iterator i = notations.iterator(); i.hasNext(); )
    {
      XSDNotationDeclaration notation = (XSDNotationDeclaration)i.next();
      if (notation.getRootContainer() == schema)
      {
        list.add(notation);
      }
    }                
    return list;
  }

}




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);




/*
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   IBM - Initial API and implementation
 *   Jens Lukowski/Innoopract - initial renaming/restructuring
 * 
 */
package org.eclipse.wst.xsd.ui.internal;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
import org.eclipse.wst.xml.ui.StructuredTextViewerConfigurationXML;

/**
 * Configuration for editing XSD content type
 */
public class StructuredTextViewerConfigurationXSD extends StructuredTextViewerConfigurationXML {
	public IHyperlinkDetector[] getHyperlinkDetectors(ISourceViewer sourceViewer) {
		if (sourceViewer == null || !fPreferenceStore.getBoolean(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_HYPERLINKS_ENABLED))
			return null;

		List allDetectors = new ArrayList(0);
		// add XSD Hyperlink detector
		allDetectors.add(new XSDHyperlinkDetector());

		IHyperlinkDetector[] superDetectors = super.getHyperlinkDetectors(sourceViewer);
		for (int m = 0; m < superDetectors.length; m++) {
			IHyperlinkDetector detector = superDetectors[m];
			if (!allDetectors.contains(detector)) {
				allDetectors.add(detector);
			}
		}
		return (IHyperlinkDetector[]) allDetectors.toArray(new IHyperlinkDetector[0]);
	}
}




/*
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   IBM - Initial API and implementation
 *   Jens Lukowski/Innoopract - initial renaming/restructuring
 * 
 */
package org.eclipse.wst.xsd.ui.internal;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.sse.ui.views.contentoutline.ContentOutlineConfiguration;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xsd.ui.internal.actions.OpenSchemaAction;
import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;
import org.eclipse.wst.xsd.ui.internal.provider.XSDContentProvider;
import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaDirective;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * Outline configuration for XSD
 */
public class XSDContentOutlineConfiguration extends ContentOutlineConfiguration {
	private XSDContentProvider fContentProvider;
	private ILabelProvider fLabelProvider;
	private KeyListener[] fKeyListeners = null;
	private IMenuListener fMenuListener = null;
	private XSDEditor fEditor = null;

	public IContentProvider getContentProvider(TreeViewer viewer) {
		if (fContentProvider == null) {
			fContentProvider = new XSDContentProvider(XSDModelAdapterFactoryImpl.getInstance());
		}
		return fContentProvider;
	}

	public ILabelProvider getLabelProvider(TreeViewer viewer) {
		if (fLabelProvider == null) {
			fLabelProvider = new XSDAdapterFactoryLabelProvider(XSDModelAdapterFactoryImpl.getInstance());
		}
		return fLabelProvider;
	}

	public IMenuListener getMenuListener(TreeViewer viewer) {
		if (fMenuListener == null) {
			// ISSUE: what happens if cannot get XSD Editor? (See
			// getXSDEditor comment)
			if (getXSDEditor() != null)
				fMenuListener = new XSDMenuListener(getXSDEditor().getSelectionManager());
		}
		return fMenuListener;
	}

	public KeyListener[] getKeyListeners(TreeViewer viewer) {
		if (fKeyListeners == null) {
			final TreeViewer finalViewer = viewer;
			KeyAdapter keyListener = new KeyAdapter() {
				public void keyReleased(KeyEvent e) {
					if (e.character == SWT.DEL) {
						IMenuListener menuListener = getMenuListener(finalViewer);
						if (menuListener instanceof XSDMenuListener)
							((XSDMenuListener) menuListener).getDeleteAction().run();
					}
					else if (e.keyCode == SWT.F3) // open editor on any
					// include/import/redefine
					{
						if (e.widget instanceof Tree) {
							Tree tree = (Tree) e.widget;
							TreeItem[] selection = tree.getSelection();
							if (selection.length > 0) {
								if (selection[0].getData() instanceof XSDSchemaDirective) {
									XSDSchemaDirective comp = (XSDSchemaDirective) selection[0].getData();
									OpenSchemaAction openSchema = new OpenSchemaAction(XSDEditorPlugin.getXSDString("_UI_ACTION_OPEN_SCHEMA"), comp);
									openSchema.run();
								}
							}
						}
					}
				}
			};
			fKeyListeners = new KeyListener[]{keyListener};
		}

		return fKeyListeners;
	}

	public ISelection getSelection(TreeViewer viewer, ISelection selection) {
		ISelection sel = selection;

		if (selection instanceof IStructuredSelection) {
			List xsdSelections = new ArrayList();
			for (Iterator i = ((IStructuredSelection) selection).iterator(); i.hasNext();) {
				Object domNode = i.next();
				Object xsdNode = getXSDNode(domNode, viewer);
				if (xsdNode != null) {
					xsdSelections.add(xsdNode);
				}
			}

			if (!xsdSelections.isEmpty()) {
				sel = new StructuredSelection(xsdSelections);
			}
		}
		return sel;
	}

	/**
	 * Determines XSD node based on object (DOM node)
	 * 
	 * @param object
	 * @return
	 */
	private Object getXSDNode(Object object, TreeViewer viewer) {
		// get the element node
		Element element = null;
		if (object instanceof Node) {
			Node node = (Node) object;
			if (node != null) {
				if (node.getNodeType() == Node.ELEMENT_NODE) {
					element = (Element) node;
				}
				else if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
					element = ((Attr) node).getOwnerElement();
				}
			}
		}
		Object o = element;
		if (element != null) {
			Object modelObject = getXSDSchema(viewer).getCorrespondingComponent(element);
			if (modelObject != null) {
				o = modelObject;
			}
		}
		return o;
	}

	/**
	 * Gets the xsd schema from treeviewer's input
	 * 
	 * @param model
	 *            (of type Object but really should be IStructuredModel)
	 * @return Definition
	 */
	private XSDSchema getXSDSchema(TreeViewer viewer) {
		XSDSchema xsdSchema = null;
		Object model = null;
		if (viewer != null)
			model = viewer.getInput();

		if (model instanceof IDOMModel) {
			IDOMDocument domDoc = ((IDOMModel) model).getDocument();
			if (domDoc != null) {
				XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
				/*
				 * ISSUE: Didn't want to go through initializing schema if it
				 * does not already exist, so just attempted to get existing
				 * adapter. If doesn't exist, just don't bother working.
				 */
				if (modelAdapter != null)
					xsdSchema = modelAdapter.getSchema();
			}
		}
		return xsdSchema;
	}

	// ISSUE: There are some cases where outline comes up before editor
	private XSDEditor getXSDEditor() {
		if (fEditor == null) {
			IWorkbench workbench = PlatformUI.getWorkbench();
			if (workbench != null) {
				IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
				if (window != null) {
					IWorkbenchPage page = window.getActivePage();
					if (page != null) {
						IEditorPart editor = page.getActiveEditor();
						if (editor instanceof XSDEditor)
							fEditor = (XSDEditor) editor;
					}
				}
			}
		}
		return fEditor;
	}

}




/*
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   IBM - Initial API and implementation
 *   Jens Lukowski/Innoopract - initial renaming/restructuring
 * 
 */
package org.eclipse.wst.xsd.ui.internal;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.IDE;
import org.eclipse.wst.common.uriresolver.internal.util.URIHelper;
import org.eclipse.xsd.XSDConcreteComponent;

/**
 * WSDL Hyperlink that knows how to open links from wsdl files
 */
public class XSDHyperlink implements IHyperlink {
	private IRegion fRegion;
	private XSDConcreteComponent fComponent;

	public XSDHyperlink(IRegion region, XSDConcreteComponent component) {
		fRegion = region;
		fComponent = component;
	}

	public IRegion getHyperlinkRegion() {
		return fRegion;
	}

	public String getTypeLabel() {
		return null;
	}

	public String getHyperlinkText() {
		return null;
	}

	public void open() {
		// if hyperlink points to schema already in editor, select the correct
		// node
		// if (fComponent.getRootContainer().equals(xsdSchema)) {
		// Node element = fComponent.getElement();
		// if (element instanceof IndexedRegion) {
		// IndexedRegion indexNode = (IndexedRegion) element;
		// textEditor.getTextViewer().setRangeIndication(indexNode.getStartOffset(),
		// indexNode.getEndOffset() - indexNode.getStartOffset(), true);
		// }
		// }
		// else {
		if (fComponent.getSchema() != null) {
			String schemaLocation = URIHelper.removePlatformResourceProtocol(fComponent.getSchema().getSchemaLocation());
			IPath schemaPath = new Path(schemaLocation);
			IFile schemaFile = ResourcesPlugin.getWorkspace().getRoot().getFile(schemaPath);
			if (schemaFile != null && schemaFile.exists()) {
				IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
				if (workbenchWindow != null) {
					IWorkbenchPage page = workbenchWindow.getActivePage();
					try {
						IEditorPart editorPart = IDE.openEditor(page, schemaFile, true);
						if (editorPart instanceof XSDEditor) {
							((XSDEditor) editorPart).openOnGlobalReference(fComponent);
						}
					}
					catch (PartInitException pie) {
						Logger.log(Logger.WARNING_DEBUG, pie.getMessage(), pie);
					}
				}
			}
		}
	}
}




/*
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   IBM - Initial API and implementation
 *   Jens Lukowski/Innoopract - initial renaming/restructuring
 * 
 */
package org.eclipse.wst.xsd.ui.internal;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.hyperlink.IHyperlink;
import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDIdentityConstraintDefinition;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaDirective;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;

/**
 * Detects hyperlinks for XSD files
 */
public class XSDHyperlinkDetector implements IHyperlinkDetector {
	/**
	 * Gets the xsd schema from document
	 * 
	 * @param document
	 * @return XSDSchema or null of one does not exist yet for document
	 */
	private XSDSchema getXSDSchema(IDocument document) {
		XSDSchema schema = null;
		IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
		if (model != null) {
			try {
				if (model instanceof IDOMModel) {
					IDOMDocument domDoc = ((IDOMModel) model).getDocument();
					if (domDoc != null) {
						XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
						/*
						 * ISSUE: Didn't want to go through initializing
						 * schema if it does not already exist, so just
						 * attempted to get existing adapter. If doesn't
						 * exist, just don't bother working.
						 */
						if (modelAdapter != null)
							schema = modelAdapter.getSchema();
					}
				}
			}
			finally {
				model.releaseFromRead();
			}
		}
		return schema;
	}

	/**
	 * 
	 * @param xsdSchema
	 *            cannot be null
	 * @param node
	 *            cannot be null
	 * @return XSDConcreteComponent
	 */
	private XSDConcreteComponent getXSDComponent(XSDSchema xsdSchema, Node node) {
		XSDConcreteComponent objectToReveal = null;

		XSDConcreteComponent xsdComp = xsdSchema.getCorrespondingComponent((Node) node);
		if (xsdComp instanceof XSDElementDeclaration) {
			XSDElementDeclaration elementDecl = (XSDElementDeclaration) xsdComp;
			if (elementDecl.isElementDeclarationReference()) {
				objectToReveal = elementDecl.getResolvedElementDeclaration();
			}
			else {
				XSDConcreteComponent typeDef = null;
				if (elementDecl.getAnonymousTypeDefinition() == null) {
					typeDef = elementDecl.getTypeDefinition();
				}

				XSDConcreteComponent subGroupAffiliation = elementDecl.getSubstitutionGroupAffiliation();

				if (typeDef != null && subGroupAffiliation != null) {
					// we have 2 things we can navigate to, if the
					// cursor is anywhere on the substitution
					// attribute
					// then jump to that, otherwise just go to the
					// typeDef.
					if (node instanceof Attr && ((Attr) node).getLocalName().equals(XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE)) {
						objectToReveal = subGroupAffiliation;
					}
					else {
						// try to reveal the type now. On success,
						// then we return true.
						// if we fail, set the substitution group
						// as
						// the object to reveal as a backup plan.
						// ISSUE: how to set backup?
						// if (revealObject(typeDef)) {
						objectToReveal = typeDef;
						// }
						// else {
						// objectToReveal = subGroupAffiliation;
						// }
					}
				}
				else {
					// one or more of these is null. If the
					// typeDef is
					// non-null, use it. Otherwise
					// try and use the substitution group
					objectToReveal = typeDef != null ? typeDef : subGroupAffiliation;
				}
			}
		}
		else if (xsdComp instanceof XSDModelGroupDefinition) {
			XSDModelGroupDefinition elementDecl = (XSDModelGroupDefinition) xsdComp;
			if (elementDecl.isModelGroupDefinitionReference()) {
				objectToReveal = elementDecl.getResolvedModelGroupDefinition();
			}
		}
		else if (xsdComp instanceof XSDAttributeDeclaration) {
			XSDAttributeDeclaration attrDecl = (XSDAttributeDeclaration) xsdComp;
			if (attrDecl.isAttributeDeclarationReference()) {
				objectToReveal = attrDecl.getResolvedAttributeDeclaration();
			}
			else if (attrDecl.getAnonymousTypeDefinition() == null) {
				objectToReveal = attrDecl.getTypeDefinition();
			}
		}
		else if (xsdComp instanceof XSDAttributeGroupDefinition) {
			XSDAttributeGroupDefinition attrGroupDef = (XSDAttributeGroupDefinition) xsdComp;
			if (attrGroupDef.isAttributeGroupDefinitionReference()) {
				objectToReveal = attrGroupDef.getResolvedAttributeGroupDefinition();
			}
		}
		else if (xsdComp instanceof XSDIdentityConstraintDefinition) {
			XSDIdentityConstraintDefinition idConstraintDef = (XSDIdentityConstraintDefinition) xsdComp;
			if (idConstraintDef.getReferencedKey() != null) {
				objectToReveal = idConstraintDef.getReferencedKey();
			}
		}
		else if (xsdComp instanceof XSDSimpleTypeDefinition) {
			XSDSimpleTypeDefinition typeDef = (XSDSimpleTypeDefinition) xsdComp;
			objectToReveal = typeDef.getItemTypeDefinition();
			if (objectToReveal == null) {
				// if itemType attribute is not set, then check
				// for memberType
				List memberTypes = typeDef.getMemberTypeDefinitions();
				if (memberTypes != null && memberTypes.size() > 0) {
					objectToReveal = (XSDConcreteComponent) memberTypes.get(0);
				}
			}
		}
		else if (xsdComp instanceof XSDTypeDefinition) {
			XSDTypeDefinition typeDef = (XSDTypeDefinition) xsdComp;
			objectToReveal = typeDef.getBaseType();
		}
		else if (xsdComp instanceof XSDSchemaDirective) {
			XSDSchemaDirective directive = (XSDSchemaDirective) xsdComp;
			// String schemaLocation =
			// URIHelper.removePlatformResourceProtocol(directive.getResolvedSchema().getSchemaLocation());
			// openXSDEditor(schemaLocation);
			// return false;
			objectToReveal = directive.getResolvedSchema();
		}
		return objectToReveal;
	}

	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) {
		// for now, only capable of creating 1 hyperlink
		List hyperlinks = new ArrayList(0);

		if (region != null && textViewer != null) {
			IDocument document = textViewer.getDocument();
			Node node = getCurrentNode(document, region.getOffset());
			if (node != null) {
				XSDSchema xsdSchema = getXSDSchema(textViewer.getDocument());
				if (xsdSchema != null) {
					XSDConcreteComponent objectToReveal = getXSDComponent(xsdSchema, node);
					// now reveal the object if this isn't null
					if (objectToReveal != null) {
						IRegion nodeRegion = region;
						if (node instanceof IndexedRegion) {
							IndexedRegion indexed = (IndexedRegion) node;
							int start = indexed.getStartOffset();
							int end = indexed.getEndOffset();
							nodeRegion = new Region(start, end - start);
						}
						hyperlinks.add(new XSDHyperlink(nodeRegion, objectToReveal));
					}
				}
			}
		}

		if (hyperlinks.size() == 0)
			return null;
		return (IHyperlink[]) hyperlinks.toArray(new IHyperlink[0]);
	}

	/**
	 * Returns the node the cursor is currently on in the document. null if no
	 * node is selected
	 * 
	 * @param offset
	 * @return Node either element, doctype, text, or null
	 */
	private Node getCurrentNode(IDocument document, int offset) {
		// get the current node at the offset (returns either: element,
		// doctype, text)
		IndexedRegion inode = null;
		IStructuredModel sModel = null;
		try {
			sModel = StructuredModelManager.getModelManager().getExistingModelForRead(document);
			inode = sModel.getIndexedRegion(offset);
			if (inode == null)
				inode = sModel.getIndexedRegion(offset - 1);
		}
		finally {
			if (sModel != null)
				sModel.releaseFromRead();
		}

		if (inode instanceof Node) {
			return (Node) inode;
		}
		return null;
	}
}

Return to bug 112884

Lines 36-45 Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/XSDTextEditor.java (-51 / +50 lines)
36	import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;	36	import org.eclipse.wst.sse.ui.internal.view.events.INodeSelectionListener;
37	import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;	37	import org.eclipse.wst.sse.ui.internal.view.events.NodeSelectionChangedEvent;
38	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;	38	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
39	import org.eclipse.wst.xsd.ui.internal.properties.section.XSDTabbedPropertySheetPage;
40	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;	39	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
41	import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;	40	import org.eclipse.wst.xsd.ui.internal.provider.XSDAdapterFactoryLabelProvider;
42	import org.eclipse.wst.xsd.ui.internal.provider.XSDContentProvider;
43	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;	41	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
44	import org.eclipse.wst.xsd.ui.internal.refactor.actions.RefactorActionGroup;	42	import org.eclipse.wst.xsd.ui.internal.refactor.actions.RefactorActionGroup;
45	import org.eclipse.wst.xsd.ui.internal.util.SelectionAdapter;	43	import org.eclipse.wst.xsd.ui.internal.util.SelectionAdapter;
Lines 49-55 Link Here
49	import org.w3c.dom.Element;	47	import org.w3c.dom.Element;
50	import org.w3c.dom.Node;	48	import org.w3c.dom.Node;
51		49
52		50	/**
		51	* @deprecated Do not use subclass of StructuredTextEditor
		52	*/
53	public class XSDTextEditor extends StructuredTextEditor implements INodeSelectionListener, ISelectionChangedListener	53	public class XSDTextEditor extends StructuredTextEditor implements INodeSelectionListener, ISelectionChangedListener
54	{	54	{
55	protected XSDSelectionManager xsdSelectionManager;	55	protected XSDSelectionManager xsdSelectionManager;
Lines 58-64 Link Here
58	protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider();	58	protected InternalSelectionProvider internalSelectionProvider = new InternalSelectionProvider();
59	private IPropertySheetPage fPropertySheetPage;	59	private IPropertySheetPage fPropertySheetPage;
60	private IContentOutlinePage fOutlinePage;	60	private IContentOutlinePage fOutlinePage;
61		61
62	public XSDTextEditor(XSDEditor xsdEditor)	62	public XSDTextEditor(XSDEditor xsdEditor)
63	{	63	{
64	super();	64	super();
Lines 70-76 Link Here
70	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();	70	xsdModelAdapterFactory = XSDModelAdapterFactoryImpl.getInstance();
71	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);	71	adapterFactoryLabelProvider = new XSDAdapterFactoryLabelProvider(xsdModelAdapterFactory);
72	}	72	}
73
74	public void dispose()	73	public void dispose()
75	{	74	{
76	super.dispose();	75	super.dispose();
Lines 80-130 Link Here
80	xsdModelAdapterFactory = null;	79	xsdModelAdapterFactory = null;
81	}	80	}
82		81
83	public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()	82	// public XSDModelAdapterFactoryImpl getXSDModelAdapterFactory()
84	{	83	// {
85	return xsdModelAdapterFactory;	84	// return xsdModelAdapterFactory;
86	}	85	// }
87		86	//
88	public static XSDAdapterFactoryLabelProvider getLabelProvider()	87	// public static XSDAdapterFactoryLabelProvider getLabelProvider()
89	{	88	// {
90	return adapterFactoryLabelProvider;	89	// return adapterFactoryLabelProvider;
91	}	90	// }
92		91
93	public Object getAdapter(Class required) {	92	// public Object getAdapter(Class required) {
94		93	//
95	if (IPropertySheetPage.class.equals(required))	94	// if (IPropertySheetPage.class.equals(required))
96	{	95	// {
97	fPropertySheetPage = new XSDTabbedPropertySheetPage(getXSDEditor());	96	// fPropertySheetPage = new XSDTabbedPropertySheetPage(getXSDEditor());
98		97	//
99	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);	98	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDModelAdapterFactory(xsdModelAdapterFactory);
100	((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getXSDEditor().getSelectionManager());	99	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setSelectionManager(getXSDEditor().getSelectionManager());
101	((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());	100	// ((XSDTabbedPropertySheetPage)fPropertySheetPage).setXSDSchema(getXSDSchema());
102		101	//
103	return fPropertySheetPage;	102	// return fPropertySheetPage;
104	}	103	// }
105	else if (IContentOutlinePage.class.equals(required))	104	// else if (IContentOutlinePage.class.equals(required))
106	{	105	// {
107	if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed())	106	// if (fOutlinePage == null \|\| fOutlinePage.getControl() == null \|\| fOutlinePage.getControl().isDisposed())
108	{	107	// {
109	XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(this);	108	// XSDContentOutlinePage outlinePage = new XSDContentOutlinePage(getXSDEditor());
110	XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);	109	// XSDContentProvider xsdContentProvider = new XSDContentProvider(xsdModelAdapterFactory);
111	xsdContentProvider.setXSDSchema(getXSDSchema());	110	// xsdContentProvider.setXSDSchema(getXSDSchema());
112	outlinePage.setContentProvider(xsdContentProvider);	111	// outlinePage.setContentProvider(xsdContentProvider);
113	outlinePage.setLabelProvider(adapterFactoryLabelProvider);	112	// outlinePage.setLabelProvider(adapterFactoryLabelProvider);
114	outlinePage.setModel(getXSDSchema().getDocument());	113	// outlinePage.setModel(getXSDSchema().getDocument());
115		114	//
116	// Update outline selection from source editor selection:	115	// // Update outline selection from source editor selection:
117	getViewerSelectionManager().addNodeSelectionListener(this);	116	// getViewerSelectionManager().addNodeSelectionListener(this);
118	internalSelectionProvider.addSelectionChangedListener(getViewerSelectionManager());	117	// internalSelectionProvider.addSelectionChangedListener(getViewerSelectionManager());
119	internalSelectionProvider.setEventSource(outlinePage);	118	// internalSelectionProvider.setEventSource(outlinePage);
120		119	//
121	fOutlinePage = outlinePage;	120	// fOutlinePage = outlinePage;
122	}	121	// }
123	return fOutlinePage;	122	// return fOutlinePage;
124	}	123	// }
125		124	//
126	return super.getAdapter(required);	125	// return super.getAdapter(required);
127	}	126	// }
128		127
129		128
130	protected XSDContentOutlinePage outlinePage;	129	protected XSDContentOutlinePage outlinePage;
Lines 326-331 Link Here
326	fRefactorMenuGroup.setContext(context);	325	fRefactorMenuGroup.setContext(context);
327	fRefactorMenuGroup.fillContextMenu(menu);	326	fRefactorMenuGroup.fillContextMenu(menu);
328	fRefactorMenuGroup.setContext(null);	327	fRefactorMenuGroup.setContext(null);
329	}	328	}
330	}	329	}
331		330

Lines 15-23 Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/properties/section/XSDTabbedPropertySheetPage.java (-6 / +48 lines)
15	import org.eclipse.jface.text.TextSelection;	15	import org.eclipse.jface.text.TextSelection;
16	import org.eclipse.jface.viewers.ISelection;	16	import org.eclipse.jface.viewers.ISelection;
17	import org.eclipse.jface.viewers.ISelectionChangedListener;	17	import org.eclipse.jface.viewers.ISelectionChangedListener;
		18	import org.eclipse.jface.viewers.IStructuredSelection;
18	import org.eclipse.jface.viewers.SelectionChangedEvent;	19	import org.eclipse.jface.viewers.SelectionChangedEvent;
19	import org.eclipse.jface.viewers.StructuredSelection;	20	import org.eclipse.jface.viewers.StructuredSelection;
20	import org.eclipse.ui.IWorkbenchPart;	21	import org.eclipse.ui.IWorkbenchPart;
		22	import org.eclipse.ui.part.IPageSite;
21	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;	23	import org.eclipse.wst.common.ui.properties.internal.provisional.ITabbedPropertySheetPageContributor;
22	import org.eclipse.wst.common.ui.properties.internal.provisional.TabbedPropertySheetPage;	24	import org.eclipse.wst.common.ui.properties.internal.provisional.TabbedPropertySheetPage;
23	import org.eclipse.wst.xsd.ui.internal.XSDSelectionManager;	25	import org.eclipse.wst.xsd.ui.internal.XSDSelectionManager;
Lines 25-34 Link Here
25	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;	27	import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
26	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;	28	import org.eclipse.wst.xsd.ui.internal.provider.XSDModelAdapterFactoryImpl;
27	import org.eclipse.xsd.XSDSchema;	29	import org.eclipse.xsd.XSDSchema;
		30	import org.w3c.dom.Element;
		31	import org.w3c.dom.Node;
		32	import org.w3c.dom.ProcessingInstruction;
		33	import org.w3c.dom.Text;
28		34
29	public class XSDTabbedPropertySheetPage extends TabbedPropertySheetPage	35	public class XSDTabbedPropertySheetPage extends TabbedPropertySheetPage
30	implements ISelectionChangedListener, INotifyChangedListener	36	implements ISelectionChangedListener, INotifyChangedListener
31	{	37	{
		38	XSDSchema xsdSchema;
32	private XSDSelectionManager selectionManager;	39	private XSDSelectionManager selectionManager;
33	private XSDModelAdapterFactoryImpl adapterFactory;	40	private XSDModelAdapterFactoryImpl adapterFactory;
34	/**	41	/**
Lines 39-45 Link Here
39	super(tabbedPropertySheetPageContributor);	46	super(tabbedPropertySheetPageContributor);
40	}	47	}
41		48
42	XSDSchema xsdSchema;	49	public void init(IPageSite pageSite)
		50	{
		51	super.init(pageSite);
		52	getSite().getWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
		53	}
		54
43	public void setXSDSchema(XSDSchema xsdSchema)	55	public void setXSDSchema(XSDSchema xsdSchema)
44	{	56	{
45	this.xsdSchema = xsdSchema;	57	this.xsdSchema = xsdSchema;
Lines 81-102 Link Here
81	// override for category	93	// override for category
82	if (selection != null)	94	if (selection != null)
83	{	95	{
84	if (selection instanceof StructuredSelection)	96	if (selection instanceof IStructuredSelection)
85	{	97	{
86	StructuredSelection structuredSelection = (StructuredSelection)selection;	98	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
87	if (structuredSelection.isEmpty())	99	if (structuredSelection.isEmpty())
88	{	100	{
89	return;	101	return;
90	}	102	}
91	Object obj = structuredSelection.getFirstElement();	103	Object obj = structuredSelection.getFirstElement();
92	if (obj instanceof CategoryAdapter)	104	if (obj instanceof Element)
		105	{
		106	try
		107	{
		108	Object modelObject = xsdSchema.getCorrespondingComponent((Element) obj);
		109	if (modelObject != null)
		110	{
		111	obj = modelObject;
		112	selection = new StructuredSelection(obj);
		113	}
		114	}
		115	catch (Exception e)
		116	{
		117	}
		118	}
		119	else if (obj instanceof Text)
		120	{
		121	Node parent = ((Text)obj).getParentNode();
		122	Object modelObject = xsdSchema.getCorrespondingComponent(parent);
		123	if (modelObject != null)
		124	{
		125	obj = modelObject;
		126	selection = new StructuredSelection(obj);
		127	}
		128	}
		129	else if (obj instanceof CategoryAdapter)
93	{	130	{
94	selection = new StructuredSelection(((CategoryAdapter)obj).getXSDSchema());	131	selection = new StructuredSelection(((CategoryAdapter)obj).getXSDSchema());
95	}	132	}
96	else if (obj instanceof Category)	133	else if (obj instanceof Category)
97	{	134	{
98	selection = new StructuredSelection(((Category)obj).getXSDSchema());	135	selection = new StructuredSelection(((Category)obj).getXSDSchema());
99	}	136	}
		137	else if (obj instanceof ProcessingInstruction)
		138	{
		139	selection = new StructuredSelection(xsdSchema);
		140	}
100	}	141	}
101	else if (selection instanceof TextSelection)	142	else if (selection instanceof TextSelection)
102	{	143	{
Lines 125-130 Link Here
125	{	166	{
126	adapterFactory.removeListener(this);	167	adapterFactory.removeListener(this);
127	}	168	}
		169	getSite().getWorkbenchWindow().getSelectionService().removePostSelectionListener(this);
128	super.dispose();	170	super.dispose();
129	}	171	}
130		172

Lines 20-42 Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/provider/XSDContentProvider.java (-16 / +60 lines)
20	import org.eclipse.emf.edit.provider.IChangeNotifier;	20	import org.eclipse.emf.edit.provider.IChangeNotifier;
21	import org.eclipse.emf.edit.provider.INotifyChangedListener;	21	import org.eclipse.emf.edit.provider.INotifyChangedListener;
22	import org.eclipse.emf.edit.provider.ITreeItemContentProvider;	22	import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
		23	import org.eclipse.jface.text.IDocument;
23	import org.eclipse.jface.viewers.ITreeContentProvider;	24	import org.eclipse.jface.viewers.ITreeContentProvider;
24	import org.eclipse.jface.viewers.StructuredViewer;	25	import org.eclipse.jface.viewers.StructuredViewer;
25	import org.eclipse.jface.viewers.Viewer;	26	import org.eclipse.jface.viewers.Viewer;
		27	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
		28	import org.eclipse.wst.sse.core.internal.provisional.StructuredModelManager;
		29	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
		30	import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
		31	import org.eclipse.wst.xsd.ui.internal.text.XSDModelAdapter;
26	import org.eclipse.xsd.XSDConcreteComponent;	32	import org.eclipse.xsd.XSDConcreteComponent;
27	import org.eclipse.xsd.XSDElementDeclaration;	33	import org.eclipse.xsd.XSDElementDeclaration;
28	import org.eclipse.xsd.XSDModelGroup;	34	import org.eclipse.xsd.XSDModelGroup;
29	import org.eclipse.xsd.XSDParticleContent;	35	import org.eclipse.xsd.XSDParticleContent;
30	import org.eclipse.xsd.XSDSchema;	36	import org.eclipse.xsd.XSDSchema;
31	import org.eclipse.xsd.XSDWildcard;	37	import org.eclipse.xsd.XSDWildcard;
32	import org.w3c.dom.Document;
33	import org.w3c.dom.Node;	38	import org.w3c.dom.Node;
34		39
35	public class XSDContentProvider implements ITreeContentProvider, INotifyChangedListener	40	public class XSDContentProvider implements ITreeContentProvider, INotifyChangedListener
36	{	41	{
37	XSDModelAdapterFactoryImpl xsdModelAdapterFactory;	42	XSDModelAdapterFactoryImpl xsdModelAdapterFactory;
38		43
39	XSDSchema xsdSchema;
40	public XSDContentProvider(XSDModelAdapterFactoryImpl xsdModelAdapterFactoryImpl)	44	public XSDContentProvider(XSDModelAdapterFactoryImpl xsdModelAdapterFactoryImpl)
41	{	45	{
42	this.xsdModelAdapterFactory = xsdModelAdapterFactoryImpl;	46	this.xsdModelAdapterFactory = xsdModelAdapterFactoryImpl;
Lines 47-57 Link Here
47	}	51	}
48	}	52	}
49		53
50	public void setXSDSchema(XSDSchema xsdSchema)
51	{
52	this.xsdSchema = xsdSchema;
53	}
54
55	/*	54	/*
56	* @see ITreeContentProvider#getChildren(Object)	55	* @see ITreeContentProvider#getChildren(Object)
57	*/	56	*/
Lines 59-73 Link Here
59	{	58	{
60	XSDConcreteComponent xsdComp = null;	59	XSDConcreteComponent xsdComp = null;
61	List list = null;	60	List list = null;
62	if (parentElement instanceof Document)	61
63	{	62	// root/input is structuredmodel
64	xsdComp = xsdSchema;	63	if (parentElement instanceof IDOMModel) {
65		64	IDOMDocument domDoc = ((IDOMModel) parentElement).getDocument();
66	xsdModelAdapterFactory.adapt(xsdComp, xsdModelAdapterFactory);	65	if (domDoc != null) {
67		66	XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
68	list = new ArrayList();	67	/*
69	list.add(xsdComp);	68	* ISSUE: Didn't want to go through initializing
70	return list.toArray();	69	* schema if it does not already exist, so just
		70	* attempted to get existing adapter. If doesn't
		71	* exist, just don't bother working.
		72	*/
		73	if (modelAdapter != null)
		74	xsdComp = modelAdapter.getSchema();
		75	if (xsdComp != null) {
		76	xsdModelAdapterFactory.adapt(xsdComp, xsdModelAdapterFactory);
		77
		78	list = new ArrayList();
		79	list.add(xsdComp);
		80	return list.toArray();
		81	}
		82	}
71	}	83	}
72	else if (parentElement instanceof XSDConcreteComponent)	84	else if (parentElement instanceof XSDConcreteComponent)
73	{	85	{
Lines 181-184 Link Here
181	this.viewer = viewer;	193	this.viewer = viewer;
182	}	194	}
183		195
		196	/**
		197	* Gets the xsd schema from document
		198	*
		199	* @param document
		200	* @return XSDSchema or null of one does not exist yet for document
		201	*/
		202	private XSDSchema getXSDSchema(IDocument document) {
		203	XSDSchema schema = null;
		204	IStructuredModel model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
		205	if (model != null) {
		206	try {
		207	if (model instanceof IDOMModel) {
		208	IDOMDocument domDoc = ((IDOMModel) model).getDocument();
		209	if (domDoc != null) {
		210	XSDModelAdapter modelAdapter = (XSDModelAdapter) domDoc.getExistingAdapter(XSDModelAdapter.class);
		211	/*
		212	* ISSUE: Didn't want to go through initializing
		213	* schema if it does not already exist, so just
		214	* attempted to get existing adapter. If doesn't
		215	* exist, just don't bother working.
		216	*/
		217	if (modelAdapter != null)
		218	schema = modelAdapter.getSchema();
		219	}
		220	}
		221	}
		222	finally {
		223	model.releaseFromRead();
		224	}
		225	}
		226	return schema;
		227	}
184	}	228	}

Lines 24-29 Link Here

(-)src/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);

Added Link Here

(-)src/org/eclipse/wst/xsd/ui/internal/StructuredTextViewerConfigurationXSD.java (+44 lines)
1	/*
2	* Copyright (c) 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* IBM - Initial API and implementation
10	* Jens Lukowski/Innoopract - initial renaming/restructuring
11	*
12	*/
13	package org.eclipse.wst.xsd.ui.internal;
14
15	import java.util.ArrayList;
16	import java.util.List;
17
18	import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
19	import org.eclipse.jface.text.source.ISourceViewer;
20	import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
21	import org.eclipse.wst.xml.ui.StructuredTextViewerConfigurationXML;
22
23	/**
24	* Configuration for editing XSD content type
25	*/
26	public class StructuredTextViewerConfigurationXSD extends StructuredTextViewerConfigurationXML {
27	public IHyperlinkDetector[] getHyperlinkDetectors(ISourceViewer sourceViewer) {
28	if (sourceViewer == null \|\| !fPreferenceStore.getBoolean(AbstractDecoratedTextEditorPreferenceConstants.EDITOR_HYPERLINKS_ENABLED))
29	return null;
30
31	List allDetectors = new ArrayList(0);
32	// add XSD Hyperlink detector
33	allDetectors.add(new XSDHyperlinkDetector());
34
35	IHyperlinkDetector[] superDetectors = super.getHyperlinkDetectors(sourceViewer);
36	for (int m = 0; m < superDetectors.length; m++) {
37	IHyperlinkDetector detector = superDetectors[m];
38	if (!allDetectors.contains(detector)) {
39	allDetectors.add(detector);
40	}
41	}
42	return (IHyperlinkDetector[]) allDetectors.toArray(new IHyperlinkDetector[0]);
43	}
44	}