Eclipse Views
Working with Views
In eclipse the entire workbench contains one or more workbench windows.
Each workbench window may further contain one or more workbench pages
and each page may contain one or more editor or views. An editor is
typically used to edit/modify a workspace resource whereas Views are
arranged around editors and provide assistance to editors in some way
(though this is not always true). Views are used to display hierarchy of
information, open up an editor or display properties for an active
editor. Classic example of view is Package explorer and outline view.
Package explorer is used to display workspace resources in a hierarchy
and is used to open up associated editor whenever user performs double
click action on the resource. Outline view is used to display
information about the java resource for ex: package declaration, imports
etc. (See figure below)
One of the key difference between editors and view is that editors
are resource based i.e. they work on underlying resources in workspace.
For ex: XML editor requires “.xml” file in workspace. Whereas, views may
not be resource based. They can be used to show any kind of information.
It is also important that we can make views which may display
information irrespective of resources opened up in editor window (that’s
why I said its not always true that view plays role of assistant window
around editor area).
Resource Manager View
In first chapter of this tutorial we created a Resource Manager view
as part of plug-in creation. We have been playing around with our
resource manager view for quite some time for ex: we added this view to
our own customized perspective, added actions to Resource Manager view.
However, Resource Manager view itself does not do anything useful –
every time it is opened it just displays static model as shown below:
Let’s Manage Workspace Property Files
In this chapter, we will create Property File Manager View so that it
does something useful and more meaningful rather then just displaying
static data.
Property File Manager View will search the entire workspace for all the
projects. In each project it will search for "Property Files"
folder, In each such folder it will look out for all the files with ".properties"
extension and display it to the user. This way we will end up with a
view as shown in the figure below. Please note that a property file gets
displayed in the Property File Manager view only when it is created
inside Property Files folder.
Property File Manager View
In order to create a new view, open up manifest editor – click on
extensions tab. Right click on “org.eclipse.ui.views” extension and
click on new > view (See figure below)
It will immediately open up Extension element details page. Edit the
element details as shown below
In order to create “com.myplugin.rmp.views.PropertyManagerView” class
click on the class link to open up Java attribute editor as shown below:
Click finish to generate the Property Manager View class.
Complete Listing of the Property Manager View Class
What follows is the complete listing of Property Manager View class.
However, before we move ahead to show this listing we will need to add
two dependencies (if not already added) in the plug-in manifest editor.
First dependency (org.eclipse.core.resources) is required since
property manager needs to access workspace resources.
Second dependency (org.eclipse.ui.ide) is required since we will
open up associated editor whenever user clicks on listed property files
in property manager view.
In order to add the dependencies, open up manifest editor – click on
dependencies tab and add above two dependencies as shown in fig below:
Once the dependencies have been added following code listing will
compile successfully.
1. package com.myplugin.rmp.views;
2. import java.util.ArrayList;
3. import org.eclipse.core.resources.IFile;
4. import org.eclipse.core.resources.IFolder;
5. import org.eclipse.core.resources.IProject;
6. import org.eclipse.core.resources.IResource;
7. import org.eclipse.core.resources.IWorkspace;
8. import org.eclipse.core.resources.ResourcesPlugin;
9. import org.eclipse.core.runtime.IAdaptable;
10. import org.eclipse.jface.action.Action;
11. import org.eclipse.jface.action.MenuManager;
12. import org.eclipse.jface.dialogs.MessageDialog;
13. import org.eclipse.jface.viewers.DoubleClickEvent;
14. import org.eclipse.jface.viewers.IDoubleClickListener;
15. import org.eclipse.jface.viewers.ISelection;
16. import org.eclipse.jface.viewers.IStructuredContentProvider;
17. import org.eclipse.jface.viewers.IStructuredSelection;
18. import org.eclipse.jface.viewers.ITreeContentProvider;
19. import org.eclipse.jface.viewers.LabelProvider;
20. import org.eclipse.jface.viewers.TreeViewer;
21. import org.eclipse.jface.viewers.Viewer;
22. import org.eclipse.swt.SWT;
23. import org.eclipse.swt.graphics.Image;
24. import org.eclipse.swt.widgets.Composite;
25. import org.eclipse.swt.widgets.Menu;
26. import org.eclipse.ui.ISharedImages;
27. import org.eclipse.ui.IWorkbenchPage;
28. import org.eclipse.ui.PlatformUI;
29. import org.eclipse.ui.ide.IDE;
30. import org.eclipse.ui.part.ViewPart;
31. public class PropertyManagerView extends ViewPart {
32. private TreeViewer viewer;
33. private TreeParent invisibleRoot;
34. class TreeObject implements IAdaptable {
35. private String name;
36. private TreeParent parent;
37. private IResource resouce;
38. public TreeObject(String name) {
39. this.name = name;
40. }
41. public String getName() {
42. return name;
43. }
44. public void setParent(TreeParent parent) {
45. this.parent = parent;
46. }
47. public TreeParent getParent() {
48. return parent;
49. }
50. public String toString() {
51. return getName();
52. }
53. public Object getAdapter(Class key) {
54. return null;
55. }
56. protected IResource getResouce() {
57. return resouce;
58. }
59. protected void setResouce(IResource resouce) {
60. this.resouce = resouce;
61. }
62. }
63. class TreeParent extends TreeObject {
64. private ArrayList children;
65. public TreeParent(String name) {
66. super(name);
67. children = new ArrayList();
68. }
69. public void addChild(TreeObject child) {
70. children.add(child);
71. child.setParent(this);
72. }
73. public void removeChild(TreeObject child) {
74. children.remove(child);
75. child.setParent(null);
76. }
77. public TreeObject[] getChildren() {
78. return (TreeObject[]) children.toArray(new TreeObject[children.size()]);
79. }
80. public boolean hasChildren() {
81. return children.size() > 0;
82. }
83. }
84. class ViewContentProvider implements ITreeContentProvider {
85. public void inputChanged(Viewer v, Object oldInput, Object newInput) {
86. }
87. public void dispose() {
88. }
89. public Object[] getElements(Object parent) {
90. if (parent.equals(getViewSite())) {
91. if (invisibleRoot == null)
92. initialize();
93. return getChildren(invisibleRoot);
94. }
95. return getChildren(parent);
96. }
97. public Object getParent(Object child) {
98. if (child instanceof TreeObject) {
99. return ((TreeObject) child).getParent();
100. }
101. return null;
102. }
103. public Object[] getChildren(Object parent) {
104. if (parent instanceof TreeParent) {
105. return ((TreeParent) parent).getChildren();
106. }
107. return new Object[0];
108. }
109. public boolean hasChildren(Object parent) {
110. if (parent instanceof TreeParent)
111. return ((TreeParent) parent).hasChildren();
112. return false;
113. }
114. }
115. class ViewLabelProvider extends LabelProvider {
116. public String getText(Object obj) {
117. return obj.toString();
118. }
119. public Image getImage(Object obj) {
120. String imageKey = ISharedImages.IMG_OBJ_ELEMENT;
121. if (obj instanceof TreeParent)
122. imageKey = ISharedImages.IMG_OBJ_FOLDER;
123. return PlatformUI.getWorkbench().getSharedImages().getImage(imageKey);
124. }
125. }
126. public void initialize() {
127. TreeParent root = new TreeParent("WorkSpace Property Files");
128. try {
129. IWorkspace workspace = ResourcesPlugin.getWorkspace();
130. IProject[] projects = workspace.getRoot().getProjects();
131. for (int i = 0; i < projects.length; i++) {
132. IResource[] folderResources = projects[i].members();
133. for (int j = 0; j < folderResources.length; j++) {
134. if (folderResources[j] instanceof IFolder) {
135. IFolder resource = (IFolder) folderResources[j];
136. if (resource.getName().equalsIgnoreCase("Property Files")) {
137. IResource[] fileResources = resource.members();
138. for (int k = 0; k < fileResources.length; k++) {
139. if (fileResources[k] instanceof IFile &&
fileResources[k].getName().endsWith(".properties")){
140. TreeObject obj = new TreeObject(fileResources[k]
.getName());
141. obj.setResouce(fileResources[k]);
142. root.addChild(obj);
143. }
144. }
145. }
146. }
147. }
148. }
149. }catch (Exception e) {
// log exception
150. }
151. invisibleRoot = new TreeParent("");
152. invisibleRoot.addChild(root);
153. }
154. public PropertyManagerView() {
155. }
156. public void createPartControl(Composite parent) {
157. viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
158. viewer.setContentProvider(new ViewContentProvider());
159. viewer.setLabelProvider(new ViewLabelProvider());
160. viewer.setInput(getViewSite());
161. hookContextMenu();
162. hookDoubleCLickAction();
163. }
164. private void hookDoubleCLickAction() {
165. viewer.addDoubleClickListener(new IDoubleClickListener() {
166. public void doubleClick(DoubleClickEvent event) {
167. ISelection selection = event.getSelection();
168. Object obj = ((IStructuredSelection) selection).getFirstElement();
169. if (!(obj instanceof TreeObject)) {
170. return;
171. }else {
172. TreeObject tempObj = (TreeObject) obj;
173. IFile ifile = ResourcesPlugin.getWorkspace().getRoot().
getFile(tempObj.getResouce().getFullPath());
174. IWorkbenchPage dpage =
PropertyManagerView.this.getViewSite()
.getWorkbenchWindow().getActivePage();
175. if (dpage != null) {
176. try {
177. IDE.openEditor(dpage, ifile,true);
178. }catch (Exception e) {
179. // log exception
180. }
181. }
182. }
183. };
184. });
185. }
186. private void hookContextMenu() {
187. MenuManager menuMgr = new MenuManager("#PopupMenu");
188. Menu menu = menuMgr.createContextMenu(viewer.getControl());
189. viewer.getControl().setMenu(menu);
190. Action refresh =new Action() {
191. public void run() {
192. initialize();
193. viewer.refresh();
194. }
195. };
196. refresh.setText("Refresh");
197. menuMgr.add(refresh);
198. }
199. public void setFocus() {
200. viewer.getControl().setFocus();
201. }
202. }
|
|
