Added "Navigate->Show In->Navigator" and "Navigate->Show In->PHP Browser" actions.
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpeclipse / ui / views / outline / ModelBasedOutlinePage.java
1 /*
2  * Copyright (c) 2004 Christopher Lenz 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  *     Christopher Lenz - initial implementation
10  * 
11  * $Id: ModelBasedOutlinePage.java,v 1.1 2004-09-02 18:26:28 jsurfer Exp $
12  */
13
14 package net.sourceforge.phpeclipse.ui.views.outline;
15
16 import java.util.List;
17
18 import net.sourceforge.phpeclipse.core.model.ISourceModel;
19 import net.sourceforge.phpeclipse.core.model.ISourceReference;
20 import net.sourceforge.phpeclipse.ui.editor.StructuredTextEditor;
21 import net.sourceforge.phpeclipse.ui.internal.WebUIMessages;
22
23 import org.eclipse.jface.action.IMenuManager;
24 import org.eclipse.jface.action.IStatusLineManager;
25 import org.eclipse.jface.action.IToolBarManager;
26 import org.eclipse.jface.preference.IPreferenceStore;
27 import org.eclipse.jface.viewers.ISelection;
28 import org.eclipse.jface.viewers.IStructuredSelection;
29 import org.eclipse.jface.viewers.ITreeContentProvider;
30 import org.eclipse.jface.viewers.StructuredSelection;
31 import org.eclipse.jface.viewers.TreeViewer;
32 import org.eclipse.jface.viewers.Viewer;
33 import org.eclipse.swt.custom.BusyIndicator;
34 import org.eclipse.swt.widgets.Composite;
35 import org.eclipse.swt.widgets.Control;
36 import org.eclipse.ui.texteditor.IUpdate;
37 import org.eclipse.ui.texteditor.ResourceAction;
38 import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
39
40 /**
41  * 
42  */
43 public class ModelBasedOutlinePage extends ContentOutlinePage
44         implements IUpdate {
45
46         // Inner Classes -----------------------------------------------------------
47
48         public class ContentProvider implements ITreeContentProvider {
49
50                 /*
51                  * ITreeContentProvider#getChildren(Object)
52                  */
53                 public Object[] getChildren(Object parentElement) {
54                         if (parentElement instanceof ISourceReference) {
55                                 return model.getChildren((ISourceReference) parentElement);
56                         }
57                         return new Object[0];
58                 }
59
60                 /*
61                  * @see ITreeContentProvider#getParent(Object)
62                  */
63                 public Object getParent(Object element) {
64                         if (element instanceof ISourceReference) {
65                                 return model.getParent((ISourceReference) element);
66                         }
67                         return null;
68                 }
69
70                 /*
71                  * @see ITreeContentProvider#hasChildren(Object)
72                  */
73                 public boolean hasChildren(Object element) {
74                         return getChildren(element).length > 0;
75                 }
76
77                 /*
78                  * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(Object)
79                  */
80                 public Object[] getElements(Object inputElement) {
81                         return model.getElements();
82                 }
83
84                 /* 
85                  * @see org.eclipse.jface.viewers.IContentProvider#dispose()
86                  */
87                 public void dispose() {
88                 }
89
90                 /*
91                  * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(Viewer, Object, Object)
92                  */
93                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
94                         if (oldInput != newInput) {
95                                 if (newInput instanceof ISourceModel) {
96                                         model = (ISourceModel) newInput;
97                                 }          
98                         }
99                 }
100
101         }
102
103         /**
104          * This action toggles whether this outline page links its selection
105          * to the active editor.
106          */
107         private class ToggleLinkingAction extends ResourceAction {
108                 
109                 /**
110                  * Constructs a new action.
111                  */
112                 public ToggleLinkingAction() {
113                         super(WebUIMessages.getResourceBundle(),
114                                 "OutlinePage.linkWithEditor."); //$NON-NLS-1$
115                         if ((preferenceStore != null)
116                          && (linkWithEditorPreferenceKey != null)) {
117                                 boolean checked = preferenceStore.getBoolean(
118                                                 linkWithEditorPreferenceKey);
119                                 valueChanged(checked, false);
120                         } else {
121                                 setEnabled(false);
122                         }
123                 }
124
125                 /*
126                  * @see org.eclipse.jface.action.Action#run()
127                  */
128                 public void run() {
129                         if ((preferenceStore != null)
130                          && (linkWithEditorPreferenceKey != null)) {
131                                 valueChanged(isChecked(), true);
132                         }
133                 }
134         
135                 // Private Methods -----------------------------------------------------
136
137                 /**
138                  * Updates whether the outline page is linked to the active editor.
139                  * 
140                  * @param checked Whether linking is enabled
141                  * @param store Whether the new state should be written back as a 
142                  *        preference
143                  */
144                 private void valueChanged(final boolean checked, boolean store) {
145                         setChecked(checked);
146                         BusyIndicator.showWhile(getTreeViewer().getControl().getDisplay(),
147                                 new Runnable() {
148                                         public void run() {
149                                                 editor.synchronizeOutlinePage();
150                                         }
151                                 });
152                         if (store) {
153                                 preferenceStore.setValue(
154                                         linkWithEditorPreferenceKey, checked);
155                         }
156                 }
157
158         }
159
160         // Instance Variables ------------------------------------------------------
161
162         /**
163          * The associated editor.
164          */
165         private StructuredTextEditor editor;
166
167         /**
168          * The structured source model.
169          */
170         private ISourceModel model;
171
172         /**
173          * The preference store.
174          */
175         private IPreferenceStore preferenceStore;
176
177         /**
178          * The preference key which specifies whether the outline page is linked to
179          * the active editor.
180          */
181         private String linkWithEditorPreferenceKey;
182
183         // Constructors ------------------------------------------------------------
184
185         /**
186          * Constructor.
187          * 
188          * @param editor The associated structured text editor
189          */
190         public ModelBasedOutlinePage(StructuredTextEditor editor) {
191                 this.editor = editor;
192         }
193
194         // ContentOutlinePage Implementation ---------------------------------------
195
196         /*
197          * @see org.eclipse.ui.part.IPage#createControl(Composite)
198          */
199         public void createControl(Composite parent) {
200                 super.createControl(parent);
201                 TreeViewer viewer = getTreeViewer();
202                 viewer.setContentProvider(new ContentProvider());
203         }
204
205         /*
206          * @see org.eclipse.ui.part.IPage#dispose()
207          */
208         public void dispose() {
209                 if (editor != null) {
210                         editor.outlinePageClosed();
211                         editor = null;
212                 }
213                 super.dispose();
214         }
215
216         /*
217          * @see org.eclipse.ui.part.Page#makeContributions(IMenuManager, IToolBarManager, IStatusLineManager)
218          */
219         public void makeContributions(IMenuManager menuManager,
220                 IToolBarManager toolBarManager, IStatusLineManager statusLineManager) {
221                 if (toolBarManager != null) {
222                         toolBarManager.add(new ToggleLinkingAction());
223                 }
224                 super.makeContributions(menuManager, toolBarManager, statusLineManager);
225         }
226
227         // IUpdate Implementation --------------------------------------------------
228
229         /**
230          * @see IUpdate#update()
231          */
232         public void update() {
233                 ISourceModel model = editor.getSourceModel();
234                 if (model != null) {
235                         TreeViewer viewer = getTreeViewer();
236                         if (viewer != null) {
237                                 Control control = viewer.getControl();
238                                 if ((control != null) && !control.isDisposed()) {
239                                         control.setRedraw(false);
240                                         viewer.setInput(model);
241                                         viewer.expandAll();
242                                         control.setRedraw(true);
243                                 }
244                         }
245                 }
246         }
247
248         // Public Methods ----------------------------------------------------------
249
250         /**
251          * Selects a specific element in the outline page.
252          * 
253          * @param element the element to select
254          */
255         public void select(ISourceReference element) {
256                 TreeViewer viewer = getTreeViewer();
257                 if (viewer != null) {
258                         ISelection selection = viewer.getSelection();
259                         if (selection instanceof IStructuredSelection) {
260                                 IStructuredSelection structuredSelection =
261                                         (IStructuredSelection) selection;
262                                 List elements = structuredSelection.toList();
263                                 if (!elements.contains(element)) {
264                                         if (element == null) {
265                                                 selection = StructuredSelection.EMPTY;
266                                         } else {
267                                                 selection = new StructuredSelection(element);
268                                         }
269                                         viewer.setSelection(selection, true);
270                                 }
271                         }
272                 }
273         }
274
275         // Protected Methods -------------------------------------------------------
276
277         protected final StructuredTextEditor getEditor() {
278                 return editor;
279         }
280
281         protected final void setPreferenceStore(IPreferenceStore store) {
282                 preferenceStore = store;
283         }
284
285         protected final void setLinkWithEditorPreferenceKey(String key) {
286                 linkWithEditorPreferenceKey = key;
287         }
288
289 }