Refactory: replaced internal copy of Assert class with org.eclipse.core.runtime.Assert
[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.2 2006-10-21 23:13:54 pombredanne 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 implements
44                 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,
92                  *      Object, Object)
93                  */
94                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
95                         if (oldInput != newInput) {
96                                 if (newInput instanceof ISourceModel) {
97                                         model = (ISourceModel) newInput;
98                                 }
99                         }
100                 }
101
102         }
103
104         /**
105          * This action toggles whether this outline page links its selection to the
106          * active editor.
107          */
108         private class ToggleLinkingAction extends ResourceAction {
109
110                 /**
111                  * Constructs a new action.
112                  */
113                 public ToggleLinkingAction() {
114                         super(WebUIMessages.getResourceBundle(),
115                                         "OutlinePage.linkWithEditor."); //$NON-NLS-1$
116                         if ((preferenceStore != null)
117                                         && (linkWithEditorPreferenceKey != null)) {
118                                 boolean checked = preferenceStore
119                                                 .getBoolean(linkWithEditorPreferenceKey);
120                                 valueChanged(checked, false);
121                         } else {
122                                 setEnabled(false);
123                         }
124                 }
125
126                 /*
127                  * @see org.eclipse.jface.action.Action#run()
128                  */
129                 public void run() {
130                         if ((preferenceStore != null)
131                                         && (linkWithEditorPreferenceKey != null)) {
132                                 valueChanged(isChecked(), true);
133                         }
134                 }
135
136                 // Private Methods -----------------------------------------------------
137
138                 /**
139                  * Updates whether the outline page is linked to the active editor.
140                  * 
141                  * @param checked
142                  *            Whether linking is enabled
143                  * @param store
144                  *            Whether the new state should be written back as a
145                  *            preference
146                  */
147                 private void valueChanged(final boolean checked, boolean store) {
148                         setChecked(checked);
149                         BusyIndicator.showWhile(getTreeViewer().getControl().getDisplay(),
150                                         new Runnable() {
151                                                 public void run() {
152                                                         editor.synchronizeOutlinePage();
153                                                 }
154                                         });
155                         if (store) {
156                                 preferenceStore.setValue(linkWithEditorPreferenceKey, checked);
157                         }
158                 }
159
160         }
161
162         // Instance Variables ------------------------------------------------------
163
164         /**
165          * The associated editor.
166          */
167         private StructuredTextEditor editor;
168
169         /**
170          * The structured source model.
171          */
172         private ISourceModel model;
173
174         /**
175          * The preference store.
176          */
177         private IPreferenceStore preferenceStore;
178
179         /**
180          * The preference key which specifies whether the outline page is linked to
181          * the active editor.
182          */
183         private String linkWithEditorPreferenceKey;
184
185         // Constructors ------------------------------------------------------------
186
187         /**
188          * Constructor.
189          * 
190          * @param editor
191          *            The associated structured text editor
192          */
193         public ModelBasedOutlinePage(StructuredTextEditor editor) {
194                 this.editor = editor;
195         }
196
197         // ContentOutlinePage Implementation ---------------------------------------
198
199         /*
200          * @see org.eclipse.ui.part.IPage#createControl(Composite)
201          */
202         public void createControl(Composite parent) {
203                 super.createControl(parent);
204                 TreeViewer viewer = getTreeViewer();
205                 viewer.setContentProvider(new ContentProvider());
206         }
207
208         /*
209          * @see org.eclipse.ui.part.IPage#dispose()
210          */
211         public void dispose() {
212                 if (editor != null) {
213                         editor.outlinePageClosed();
214                         editor = null;
215                 }
216                 super.dispose();
217         }
218
219         /*
220          * @see org.eclipse.ui.part.Page#makeContributions(IMenuManager,
221          *      IToolBarManager, IStatusLineManager)
222          */
223         public void makeContributions(IMenuManager menuManager,
224                         IToolBarManager toolBarManager, IStatusLineManager statusLineManager) {
225                 if (toolBarManager != null) {
226                         toolBarManager.add(new ToggleLinkingAction());
227                 }
228                 super.makeContributions(menuManager, toolBarManager, statusLineManager);
229         }
230
231         // IUpdate Implementation --------------------------------------------------
232
233         /**
234          * @see IUpdate#update()
235          */
236         public void update() {
237                 ISourceModel model = editor.getSourceModel();
238                 if (model != null) {
239                         TreeViewer viewer = getTreeViewer();
240                         if (viewer != null) {
241                                 Control control = viewer.getControl();
242                                 if ((control != null) && !control.isDisposed()) {
243                                         control.setRedraw(false);
244                                         viewer.setInput(model);
245                                         viewer.expandAll();
246                                         control.setRedraw(true);
247                                 }
248                         }
249                 }
250         }
251
252         // Public Methods ----------------------------------------------------------
253
254         /**
255          * Selects a specific element in the outline page.
256          * 
257          * @param element
258          *            the element to select
259          */
260         public void select(ISourceReference element) {
261                 TreeViewer viewer = getTreeViewer();
262                 if (viewer != null) {
263                         ISelection selection = viewer.getSelection();
264                         if (selection instanceof IStructuredSelection) {
265                                 IStructuredSelection structuredSelection = (IStructuredSelection) selection;
266                                 List elements = structuredSelection.toList();
267                                 if (!elements.contains(element)) {
268                                         if (element == null) {
269                                                 selection = StructuredSelection.EMPTY;
270                                         } else {
271                                                 selection = new StructuredSelection(element);
272                                         }
273                                         viewer.setSelection(selection, true);
274                                 }
275                         }
276                 }
277         }
278
279         // Protected Methods -------------------------------------------------------
280
281         protected final StructuredTextEditor getEditor() {
282                 return editor;
283         }
284
285         protected final void setPreferenceStore(IPreferenceStore store) {
286                 preferenceStore = store;
287         }
288
289         protected final void setLinkWithEditorPreferenceKey(String key) {
290                 linkWithEditorPreferenceKey = key;
291         }
292
293 }