Version 21.1 by cds on 2012/10/24 13:33
Show last authors
1 {{warning title="Warning"}}
2 This tutorial isn't complete yet!
3 {{/warning}}
4
5 This tutorial will teach you the basics of writing plugins that run inside the Eclipse framework. You will learn about editors, views, and extension points by creating one of each yourself.
6
7
8
9 {{toc/}}
10
11 = Preliminaries =
12
13 There's a few things to do before we dive into the tutorial itself. For example, to do Eclipse programming, you will have to get your hands on an Eclipse installation first. Read through the following sections to get ready for the tutorial tasks.
14
15 == Required Software ==
16
17 For this tutorial, we need you to have Eclipse and Git installed:
18
19 1. Install Eclipse. For what we do, we recommend installing the Eclipse Modeling Tools, with a few extras. Our [[Wiki page on getting Eclipse>>doc:KIELER.Getting Eclipse]] has the details: simply follow the instructions for downloading and installing Eclipse and you should be set.
20 1. You should already have obtained a working Git installation for the first tutorial.
21
22 == General Remarks ==
23
24 Over the course of this tutorial, you will be writing a bit of code. Here's a few rules we ask you to follow:
25
26 * All your Java code should be in packages with the prefix {{code language="none"}}de.cau.cs.rtprak.login{{/code}}, where {{code language="none"}}login{{/code}} is your login name as used for your email address at the institute. From now on, this rule will apply to all tutorials. Once we start with the actual practical projects, we will choose another package name.
27 * All Java classes, fields, and methods should be thoroughly commented with the standard [[Javadoc>>url:http://download.oracle.com/javase/1.5.0/docs/tooldocs/windows/javadoc.html#javadoctags||shape="rect"]] comment format. Javadoc comments are well supported by Eclipse, providing code completion, syntax highlighting, and further features to help you. The code inside your methods should also be well commented. Try to think about what kinds of information would help someone unfamiliar with your code understand it.
28 * As you will already have noticed during the first tutorial, our tutorials use Turing machines as the underlying theme. This is partly because we're computer scientists and computer scientists are expected to choose computer sciency examples, but mostly because Turing machines work great as examples for the different kinds of topics we will be covering with you. You may thus want to take some time to read up again on the topic. [[Wikipedia>>url:http://en.wikipedia.org/wiki/Turing_machine||shape="rect"]] or the material of your Theoretical Computer Science lecture might be a great start.
29 * During this tutorial, we will be using Git mostly from the command line instead of using Eclipse's built-in Git support. This is because we've found Eclipse's Git support to be too unstable and buggy for us to trust it completely.
30
31 == Finding Documentation ==
32
33 During the tutorial, we will cover each topic only briefly, so it is always a good idea to find more information online. Here's some more resources that will prove helpful:
34
35 * [[Java Platform, Standard Edition 6 API Specification>>url:http://download.oracle.com/javase/6/docs/api/||shape="rect"]]
36 As Java programmers, you will already know this one, but it's so important and helpful that it's worth repeating. The API documentation contains just about everything you need to know about the API provided by Java6.
37 * [[Eclipse Help System>>url:http://help.eclipse.org/juno/index.jsp||shape="rect"]]
38 Eclipse comes with its own help system that contains a wealth of information. You will be spending most of your time in the //Platform Plug-in Developer Guide//, which contains the following three important sections:\\
39 ** Programmer's Guide
40 When you encounter a new topic, such as SWT or JFace, the Programmer's Guide often contains helpful articles to give you a first overview. Recommended reading.
41 ** References -> API Reference
42 One of the two most important parts of the Eclipse Help System, the API Reference contains the Javadoc documentation of all Eclipse framework classes. Extremely helpful.
43 ** References -> Extension Points Reference
44 The other of the two most important parts of the Eclipse Help System, the Extension Point Reference lists all extension points of the Eclipse framework along with information about what they are and how to use them. Also extremely helpful.
45 * [[Eclipsepedia>>url:http://wiki.eclipse.org/Main_Page||shape="rect"]]
46 The official Eclipse Wiki. Contains a wealth of information on Eclipse programming.
47 * [[Eclipse Resources>>url:http://www.eclipse.org/resources/||shape="rect"]]
48 Provides forums, tutorials, articles, presentations, etc. on Eclipse and Eclipse-related topics.
49
50 You will find that despite of all of these resources Eclipse is still not as well commented and documented as we'd like it to be. Finding out how stuff works in the world of Eclipse can thus sometimes be a challenge. However, this does not only apply to you, but also to many people who are conveniently connected by something called //The Internet//. It should go without saying that if all else fails, [[Google>>url:http://www.google.de||shape="rect"]] often turns up great tutorials or solutions to problems you may run into. And if it doesn't, Miro and I will be happy to help you as well.
51
52 == Preparing the Repository ==
53
54 We have created a Git repository for everyone to do his tutorials in. You can access the repository online through our Stash tool [[over here>>url:http://git.rtsys.informatik.uni-kiel.de:7990/projects/PRAK/repos/12ws-eclipse-tutorials/browse||shape="rect"]]. You will first have to configure your Stash account:
55
56 1. Login with your Rtsys account information.
57 1. Through the button in the top right corner, access your profile.
58 1. Switch to the //SSH keys// tab.
59 1. Click //Add Key// and upload a public SSH key that you want to use to access the repository.
60
61 You should now be able to access the repository. Clone it:
62
63 1. Open a console window and navigate to an empty directory that the repository should be placed in.
64 1. Enter the command ssh:~/~/git@git.rtsys.informatik.uni-kiel.de:7999/PRAK/12ws-eclipse-tutorials.git{{code language="none"}} .{{/code}} (including the final dot, which tells git to clone the repository into the current directory instead of a subdirectory).
65 1. You should now have a clone of the repository in the current directory.
66
67 You will use this repository for all your tutorial work, along with everyone else. To make sure that you don't interfere with each other, everyone will work on a different branch. This is not exactly how people usually use Git, but goes to demonstrate Git's flexibility... Add a branch for you to work in:
68
69 1. Enter {{code language="none"}}git checkout -b login_name{{/code}}
70
71 You have just added and checked out a new branch. Everything you commit will go to this branch. To push your local commits to the server (which you will need to do so we can access your results), do the following:
72
73 1. Enter {{code language="none"}}git push origin login_name{{/code}}
74
75 You would usually have to enter {{code language="none"}}git pull{{/code}} first, but since nobody will mess with your branch this won't be necessary. By the way, you only need to mention {{code language="none"}}origin login_name{{/code}} with the first {{code language="none"}}git push{{/code}}, since Git doesn't know where to push the branch yet. After the first time, Git remembers the information and it will be enough to just enter {{code language="none"}}git push{{/code}}.
76
77 = Creating a Simple Text Editor =
78
79 OK, with all the preliminaries out of the way let's get working. Fire up Eclipse, choose an empty workspace, close the Welcome panel it will present you with and follow the following steps.
80
81 == Creating a New Plugin ==
82
83 For our text editor to integrate into Eclipse, we need to create a plug-in project for it:
84
85 1. //New// -> //Project...//
86 1. In the project wizard, choose //Plug-in Project// and click //Next//.
87 1. As the project name, enter {{code language="none"}}de.cau.cs.rtprak.login.simple{{/code}}. Uncheck //Use default location// (which would put the project into your workspace), and put it into your local clone of the Git repository instead (the //Location// should read something like {{code language="none"}}/path/to/git/repository/de.cau.cs.rtprak.login.simple{{/code}}). Click //Next//.
88 1. As the name, enter {{code language="none"}}Simple (login){{/code}}. Also, make sure that //Generate an activator// and //This plug-in will make contributions to the UI// are both checked. Click //Finish//. (Eclipse might ask you whether you want to switch to the //Plug-in Development Perspective//, which configures Eclipse to provide the views that are important for plug-in development. Choose //Yes//. Or //No//. It won't have a big influence on your future...)
89 1. Eclipse has now created your new plug-in and was nice enough to open the //Plug-in Manifest Editor//, which allows you to graphically edit two important files of your plugin: {{code language="none"}}plugin.xml{{/code}} and {{code language="none"}}META-INF/MANIFEST.MF{{/code}}. (By the way, this would be a great time to research the editor and the two files online.) Basically, those two files provide information that tell Eclipse what other plug-ins your plug-in needs and how it works together with other plug-ins by providing extensions and extension points. Our new plug-in will depend on two other plug-ins, so switch to the //Dependencies// tab of the editor and add dependencies to {{code language="none"}}org.eclipse.ui.editors{{/code}} and {{code language="none"}}org.eclipse.jface.text{{/code}}. Save the editor and close it. (You can always reopen it by opening one of the two mentioned files from the //Package Explorer//.)
90 1. Tell Eclipse that the project is inside a Git repository. Right-click on the project, click //Team//, and click //Share Project//. Select Git as the repository type and click //Next//. The repository information should appear and you should be able to simply click //Finish//.
91
92 == Create the Main Editor Class ==
93
94 We will now create the class that implements the simple text editor. There won't be any programming involved here since we're lazy; instead, we will just inherit from an existing simple text editor.
95
96 1. //New// -> //Class//.
97 1. Package: {{code language="none"}}de.cau.cs.rtprak.login.simple.editors{{/code}}. Name: {{code language="none"}}SimpleEditorPart{{/code}}. Superclass: {{code language="none"}}org.eclipse.ui.editors.text.TextEditor{{/code}}. Click //Finish//.
98
99 == Register the Editor ==
100
101 For the editor to be available inside Eclipse, we will have to register it by adding an extension to an extension point.
102
103 1. Copy [[the attached file>>attach:turing-file.gif]] to a new subfolder icons in the plug-in folder (right-click the plug-in folder in the //Package Explorer// and choose //New// -> //Folder...//). You can copy the file by importing it from inside Eclipse (//File// -> //Import...// -> //File System//) or by copying it from outside Eclipse and refreshing the plug-in project afterwards (right-click the plug-in folder in the //Package Explorer// and choose //Refresh).//
104 1. Open the //Plug-in Manifest Editor// again and switch to the //Extensions// tab.
105 1. Click //Add...//, choose the {{code language="none"}}org.eclipse.ui.editors{{/code}} extension point and click //Finish//.
106 1. The extension point is now shown in the list of extensions, along with an //editor// extension. Select that extension and edit its details using the fields on the right. Set the ID to {{code language="none"}}de.cau.cs.rtprak.login.simple.editor{{/code}}, the name to {{code language="none"}}Simple Text Editor{{/code}}, the icon to {{code language="none"}}icons/turing-file.gif{{/code}}, the extensions to {{code language="none"}}simple{{/code}}, the class to {{code language="none"}}de.cau.cs.rtprak.login.simple.editors.SimpleEditorPart{{/code}}, and the default to {{code language="none"}}true{{/code}}.
107 1. Save the manifest editor.
108
109 == Test the Editor ==
110
111 It's time to test your new simple editor in a new Eclipse instance.
112
113 1. Switch back to the //Overview// tab of the //Plug-in Manifest Editor//.
114 1. Click //Launch an Eclipse Application.//\\
115 1*. For future tests, you can now select //Eclipse Application// in the run menu.
116 1*. To enable debug mode for your test instances: open the //Run Configurations// dialog, select the //Arguments// tab of the //Eclipse Application// configuration, and add -debug -consoleLog as program arguments. This dumps all errors and exceptions to the console view, so you can directly see what went wrong.
117 1*. To improve performance, select only the plugins that are necessary: in the //Plug-ins// tab select //Launch with plug-ins selected below only//, deselect //Target Platform//, select //Workspace//, and then //Add Required Plug-ins//.\\
118 1**. Make sure that org.eclipse.ui.ide.application is also selected, else you won't be able to launch Eclipse.
119 1**. The requirements list needs to be updated when the dependencies of your plugins have changed; click //Add Required Plug-ins// again for updating.
120 1. In the new Eclipse instance, click //New -> Project...// -> //General// -> //Project//. Enter {{code language="none"}}test{{/code}} as the project name.
121 1. Right-click the new project and click //New// -> //File...// As the file name, enter {{code language="none"}}test.simple{{/code}}. This will create a new file with that name and open the file in your newly added text editor. (You can see that it is your editor by looking at the editor icon, which should look like the icon you downloaded and put into the icons folder.)
122
123 = Creating a Simple View =
124
125 The next task consists of creating a view that is able to display the state of a Turing Machine. We will do this using a table with one column, where each row represents an entry on the tape of the Turing Machine. The tape shall be infinite to one side, and the position of the read/write head shall be movable by two buttons. The content of the tape shall be determined by the currently active instance of our simple text editor.
126
127 {{info title="Hint"}}
128 In the following, we will be making use of the Standard Widget Toolkit (SWT) and JFace to build a user interface. It might be a good idea now to search for an introduction to SWT and JFace concepts on the Internet before you proceed.
129 {{/info}}
130
131 == Creating the View Class ==
132
133 We will start by creating a class that will define the view.
134
135 1. Create a class {{code language="none"}}TapeViewPart{{/code}} in a new package {{code language="none"}}de.cau.cs.rtprak.login.simple.views{{/code}} that extends the [[ViewPart>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/part/ViewPart.html||shape="rect"]] class. (make sure that in the //New Java Class// wizard, the option //Inherited abstract methods// is checked.)
136 1. Add a private field {{code language="none"}}tableViewer{{/code}} of type [[TableViewer>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/viewers/TableViewer.html||shape="rect"]].
137 1. (((
138 Your {{code language="none"}}TableViewPart{{/code}} contains a still empty method {{code language="none"}}createPartControl{{/code}}. This method will be responsible for creating the user interface components of your view. Add the following code to create the table we want to display:
139
140 {{code language="java"}}
141 Table table = new Table(parent, SWT.BORDER);
142 TableColumn column = new TableColumn(table, SWT.NONE);
143 column.setWidth(80);
144 tableViewer = new TableViewer(table);
145 {{/code}}
146 )))
147 1. (((
148 The {{code language="none"}}setFocus{{/code}} method controls what happens when your part gets the focus. Make sure the focus will then automatically be set to the table by adding the following code:
149
150 {{code}}
151 tableViewer.getControl().setFocus();
152 {{/code}}
153 )))
154
155 == Create the View Extension ==
156
157 We will now have to register our new view with Eclipse so that it can be seamlessly integrated into the workbench.
158
159 1. Copy the three files [[attach:tape_head.gif]], [[attach:head_present.gif]], and [[attach:head_absent.gif]]to the {{code language="none"}}icons{{/code}} subfolder of your plug-in as you did it before. (You might need to refresh your project again if you did the copying outside of Eclipse.)
160 1. Open the {{code language="none"}}plugin.xml{{/code}} file in the //Plugin Manifest Editor// and switch to the //Extensions// tab.
161 1. Click //Add// to add a new extension for the extension point {{code language="none"}}org.eclipse.ui.views{{/code}}. Right-click the newly added extension and add a new {{code language="none"}}view{{/code}} element through the //New// menu.
162 1. Set the view element's properties as follows: ID {{code language="none"}}de.cau.cs.rtprak.login.simple.view{{/code}}, name {{code language="none"}}Tape{{/code}}, class {{code language="none"}}de.cau.cs.rtprak.login.simple.views.TapeViewPart{{/code}}, category {{code language="none"}}org.eclipse.ui{{/code}}, icon {{code language="none"}}icons/tape_head.gif{{/code}}.
163
164 When you start the application, you should now be able to open your view by clicking //Window// -> //Show View// -> //Other//.
165
166 == Add Content and Label Providers ==
167
168 The idea of JFace viewers is to abstract a bit from the underlying widget (in our case, the table) and instead work on data models that are to be viewed. Instead of adding items to the table directly, the table viewer is supplied with an input object, a content provider, and a label provider. The content provider allows the viewer to make sense of the input object and basically allows the viewer to access the input object's data. The label provider translates each item of data into text and icons that can be used to present the item to the user in the table.
169
170 We will now create content and label providers to do just that.
171
172 1. (((
173 Create a class {{code language="none"}}TuringTape{{/code}} in a new package {{code language="none"}}de.cau.cs.rtprak.login.simple.model{{/code}} with the following fields:
174
175 {{code language="java"}}
176 private int headPosition = 1;
177 private StringBuffer text = new StringBuffer();
178 {{/code}}
179
180 Also add corresponding getter and setter methods. (You can simply right-click somewhere in the class and choose //Source// -> //Generate Getters and Setters//.)
181 )))
182 1. (((
183 Add two constants to the class:
184
185 {{code language="java"}}
186 public static final char START_CHAR = '\u25b7';
187 public static final char BLANK_CHAR = '\u25fb';
188 {{/code}}
189 )))
190 1. Add a method {{code language="none"}}getCharacter(int pos){{/code}} that calculates the tape character at position {{code language="none"}}pos{{/code}} as follows:\\
191 1*. For {{code language="none"}}pos == 0{{/code}}, return the character {{code language="none"}}START_CHAR{{/code}}.
192 1*. For {{code language="none"}}pos > text.length(){{/code}}, return the character {{code language="none"}}BLANK_CHAR{{/code}}.
193 1*. Otherwise, return the text character at index {{code language="none"}}pos - 1{{/code}}.
194 1. Add a private field tape of type {{code language="none"}}TuringTape{{/code}} to {{code language="none"}}TapeViewPart{{/code}} and initialize it with a new instance.
195 1. Create a class {{code language="none"}}TapeData{{/code}} in {{code language="none"}}de.cau.cs.rtprak.login.simple.model{{/code}} with two fields {{code language="none"}}int index{{/code}} and {{code language="none"}}char character{{/code}}, and add a constructor for initialization as well as corresponding getter methods.
196 1. Create a class {{code language="none"}}TapeContentProvider{{/code}} in the {{code language="none"}}de.cau.cs.rtprak.login.simple.views{{/code}} package that implements [[IStructuredContentProvider>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/viewers/IStructuredContentProvider.html||shape="rect"]].\\
197 1*. The methods {{code language="none"}}dispose(){{/code}} and {{code language="none"}}inputChanged(){{/code}} may remain empty.
198 1*. The method {{code language="none"}}getElements(){{/code}} must return an array of objects, where each object must contain all necessary data to be displayed in a single row of the table. The number of returned objects corresponds to the number of rows.
199 1*. Suppose the input element is an instance of {{code language="none"}}TuringTape{{/code}}. The result of {{code language="none"}}getElements(){{/code}} shall be an array of {{code language="none"}}TapeData{{/code}} elements. The size of the array shall be one more than the maximum of the tape head position and the length of the tape text. The index and character of each tape data element shall be filled with {{code language="none"}}i{{/code}} and the result of {{code language="none"}}turingTape.getCharacter(i){{/code}}, respectively, where {{code language="none"}}i{{/code}} is the array index of the element.
200 1. Create a class {{code language="none"}}TapeLabelProvider{{/code}} in the {{code language="none"}}de.cau.cs.rtprak.login.simple.views{{/code}} package that extends [[BaseLabelProvider>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/viewers/BaseLabelProvider.html||shape="rect"]] and implements [[ITableLabelProvider>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/viewers/ITableLabelProvider.html||shape="rect"]].\\
201 1*. Add a private field {{code language="none"}}tape{{/code}} of type {{code language="none"}}TuringTape{{/code}} that is initialized from the constructor.
202 1*. Add fields {{code language="none"}}presentImage{{/code}} and {{code language="none"}}absentImage{{/code}} of type [[Image>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/Image.html||shape="rect"]].
203 1*. (((
204 Initialize each image using the following code, where {{code language="none"}}path_to_image{{/code}} is {{code language="none"}}icons/head_present.gif{{/code}} and {{code language="none"}}icons/head_absent.gif{{/code}}, respectively:
205
206 {{code language="java"}}
207 image = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "path_to_image").createImage();
208 {{/code}}
209 )))
210 1*. Override the implementation of {{code language="none"}}dispose(){{/code}} in {{code language="none"}}TapeLabelProvider{{/code}} to dispose both images after calling {{code language="none"}}super.dispose(){{/code}}. (Right-click in the source-code and click //Source// -> //Override/Implement Methods//.)
211 1*. In {{code language="none"}}getColumnImage(){{/code}} and {{code language="none"}}getColumnText(){{/code}}, first check whether the element is an instance of {{code language="none"}}TapeData{{/code}} and the column index is 0, and return {{code language="none"}}null{{/code}} otherwise. If the check passes, return the following:\\
212 1**. {{code language="none"}}getColumnImage(){{/code}}: {{code language="none"}}presentImage{{/code}} if the index given by the tape data element equals the current value of {{code language="none"}}tape.getHeadPosition(){{/code}}, {{code language="none"}}absentImage{{/code}} otherwise.
213 1**. {{code language="none"}}getColumnText(){{/code}}: a {{code language="none"}}String{{/code}} containing the character of the tape data element.
214 1. (((
215 Add the following lines to {{code language="none"}}createPartControl(){{/code}} in {{code language="none"}}TapeViewPart{{/code}}:
216
217 {{code}}
218 tableViewer.setContentProvider(new TapeContentProvider());
219 tableViewer.setLabelProvider(new TapeLabelProvider(tape));
220 tableViewer.setInput(tape);
221 {{/code}}
222 )))
223
224 == Use Simple Text Editor as Tape View Input ==
225
226 We will now add code to make the Tape view display the content of a currently active Simple Text Editor.
227
228 1. (((
229 Add the following methods to {{code language="none"}}SimpleEditorPart{{/code}}:
230
231 {{code language="java"}}
232 /**
233 * Returns the text that is currently displayed in the editor.
234 * @return the currently displayed text
235 */
236 public String getText() {
237 return getDocumentProvider().getDocument(getEditorInput()).get();
238 }
239 /** The listener that is currently registered for this editor. */
240 private IDocumentListener registeredListener;
241 /**
242 * Registers the given runnable as listener for changes to the text
243 * of this editor.
244 * @param runnable a runnable to register as text listener
245 */
246 public void registerTextListener(final Runnable runnable) {
247 registeredListener = new IDocumentListener() {
248 public void documentAboutToBeChanged(DocumentEvent event) {}
249 public void documentChanged(DocumentEvent event) {
250 runnable.run();
251 }
252 };
253 getDocumentProvider().getDocument(getEditorInput())
254 .addDocumentListener(registeredListener);
255 }
256 /**
257 * Removes the last registered text listener.
258 */
259 public void disposeTextListener() {
260 if (registeredListener != null) {
261 if (getDocumentProvider() != null) {
262 getDocumentProvider().getDocument(getEditorInput())
263 .removeDocumentListener(registeredListener);
264 }
265 registeredListener = null;
266 }
267 }
268 {{/code}}
269 )))
270 1. (((
271 Add the following code to {{code language="none"}}TapeViewPart{{/code}}:
272
273 {{code language="java"}}
274 /** The editor part that is currently set as input for the viewer. */
275 private SimpleEditorPart currentInput;
276 /**
277 * Sets the displayed text of the given editor part as input of the
278 * viewer, if the editor part is a SimpleEditorPart.
279 * @param part workbench part to set as input
280 */
281 private void setInput(final IWorkbenchPart part) {
282 if (part instanceof SimpleEditorPart && part != currentInput) {
283 if (currentInput != null) {
284 currentInput.disposeTextListener();
285 }
286 currentInput = (SimpleEditorPart) part;
287 Runnable runnable = new Runnable() {
288 public void run() {
289 tape.setText(new StringBuffer(currentInput.getText()));
290 tableViewer.refresh();
291 }
292 };
293 runnable.run();
294 currentInput.registerTextListener(runnable);
295 }
296 }
297 {{/code}}
298 )))
299 1. (((
300 Add the following code to {{code language="none"}}createPartControl(){{/code}}:
301
302 {{code language="java"}}
303 IWorkbenchWindow workbenchWindow = getSite().getWorkbenchWindow();
304 IWorkbenchPage activePage = workbenchWindow.getActivePage();
305 if (activePage != null) {
306 setInput(activePage.getActivePart());
307 }
308 workbenchWindow.getPartService().addPartListener(new IPartListener() {
309 public void partActivated(final IWorkbenchPart part) {
310 setInput(part);
311 }
312 public void partDeactivated(final IWorkbenchPart part) {}
313 public void partBroughtToTop(final IWorkbenchPart part) {}
314 public void partClosed(final IWorkbenchPart part) {}
315 public void partOpened(final IWorkbenchPart part) {}
316 });
317 {{/code}}
318 )))
319
320 == Create Actions to Move the Tape Head ==
321
322 If we want to add buttons to the view's tool bar, we will have to ask its [[IToolbarManager>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/action/IToolBarManager.html||shape="rect"]] to do that for us:
323
324 1. (((
325 Get the tool bar manager using the following code:
326
327 {{code language="java"}}
328 IToolBarManager toolBarManager = getViewSite().getActionBars().getToolBarManager();
329 {{/code}}
330 )))
331 1. Add two actions to the toolbar manager by extending the class [[Action>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/jface/action/Action.html||shape="rect"]] and implementing the {{code language="none"}}run(){{/code}}method.
332 1*. It is convenient to add actions as anonymous nested classes.
333 1*. The first action shall have the text "L". When it is run, it shall move the head to the left (to the top in the table viewer), if the head is not already at position 0.
334 1*. The second action shall have the text "R". When it is run, it shall move the head to the right.
335 1*. You should call {{code language="none"}}tableViewer.refresh(){{/code}} after any change to the {{code language="none"}}tape.headPosition{{/code}} variable.
336
337 == Test the View ==
338
339 If you open an instance of the simple text editor and open the Tape view, the view should correctly display the editor's text on a tape, and the L and R buttons should move the tape head.
340
341 = Creating an Extension Point =
342
343 WRITE THIS SECTION
344
345
346
347
348
349
350
351

Navigation

Quick Links

KIELER on GitHub
RTSYS Homepage