1
edit
Changes
no edit summary
==Prerequisites==
*Download [http://www.eclipse.org/downloads/packages/eclipse-rcp-and-rap-developers/heliossr2 Eclipse RCP & RAP Developer]
*Install RCP plug-in
=Create a RCP Application=
==Run a RCP Application==
*Select/Enter your preferred workspace in the text box provided and click okay
[[File:RcpwT2.png]]
*After Eclipse has completed loaded, create a plug-in project by clicking on "File" on the menu bar then scroll to New->Project->Other. A wizard should pop-up in which you should progress to click on the "PluginPlug-in Development" tree, select "Plug-in Project", and click next.
[[File:WizwT2.png]]
*Enter the following information that is seen in the image below
[[File:Classl3T2.png]]
*Copy and paste the following to their respective file.
'''Weather.java'''
<source lang=java>
package ecl.team2.lab3.weathermodel;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Random;
public class Weather {
private float windspeedInKM;
private char windDirection;
private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
public Weather()
{
}
public Weather(String cit)
{
city=cit;
Random randomGenerator = new Random();
tempInCelcius = randomGenerator.nextFloat()+35;
rainInMM = randomGenerator.nextFloat()+10;
snowInMM = randomGenerator.nextFloat()+10;
windspeedInKM = randomGenerator.nextFloat()+50;
int r = randomGenerator.nextInt(4);
switch(r){
case 0:
windDirection = 'E';
break;
case 1:
windDirection = 'W';
break;
case 2:
windDirection = 'N';
break;
case 3:
windDirection = 'S';
break;
}
}
public Weather(String pcity, float ptemp, float prain, float psnow, float pwspeed, char pwdirection){
public void setWindDirection(char windDirection) {
propertyChangeSupport.firePropertyChange("", this.windDirection, this.windDirection = windDirection);
}
public void setWindspeedInKM(float windspeedInKM) {
propertyChangeSupport.firePropertyChange("", this.windspeedInKM, this.windspeedInKM = windspeedInKM);
}
public void setSnowInMM(float snowInMM) {
propertyChangeSupport.firePropertyChange("", this.snowInMM, this.snowInMM = snowInMM);
}
public void setRainInMM(float rainInMM) {
propertyChangeSupport.firePropertyChange("", this.rainInMM, this.rainInMM = rainInMM);
}
public void setTempInCelcius(float tempInCelcius) {
propertyChangeSupport.firePropertyChange("", this.tempInCelcius, this.tempInCelcius = tempInCelcius);
}
public void setCity(String city) {
propertyChangeSupport.firePropertyChange("", this.city, this.city = city);
}
public String getCity() {
return city;
}
public void addPropertyChangeListener(String name, PropertyChangeListener listener)
{
propertyChangeSupport.addPropertyChangeListener(name,listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener)
{
propertyChangeSupport.addPropertyChangeListener(listener);
}
public String toString()
{
return city + " " + tempInCelcius + " " + rainInMM + " " + snowInMM + " "
+ windspeedInKM + " " + windDirection;
}
}
</source>
'''SimpleWeatherSystem.java'''
<source lang=java>
package ecl.team2.lab3.weathermodel;
import java.util.Random;
public class enum SimpleWeatherSystem { INSTANCE;
ArrayList<Weather> weathers = new ArrayList<Weather>();
ArrayList<String> cities = new ArrayList<String>();
cities.add("Toronto");
}
}
public Weather getWeather(String city) throws Exception {
// TODO Auto-generated method stub
return found;
}
public void addCity(String nCity)
{
Random randomGenerator = new Random();
float temp = randomGenerator.nextFloat()+35;
float rain = randomGenerator.nextFloat()+10;
float snow = randomGenerator.nextFloat()+10;
float windspeed = randomGenerator.nextFloat()+50;
char winddirection = '.';
int r = randomGenerator.nextInt(4);
switch(r){
case 0:
winddirection = 'E';
break;
case 1:
winddirection = 'W';
break;
case 2:
winddirection = 'N';
break;
case 3:
winddirection = 'S';
break;
}
Weather w = new Weather(nCity, temp, rain, snow, windspeed, winddirection);
this.weathers.add(w);
System.out.println(w.toString());
}
public void removeCity(String oCity)
{
this.weathers.remove(oCity);
}
public ArrayList<Weather> getAllWeather()
{
return weathers;
}
}
</source>
*You will notice that we used a public "enum" type instead of a class. This would make the object in our program a global point for the whole application to access. It's a singleton (static class).
*These classes will be used later on into the tutorial.
==Creating and Using Commands/Views==
===Commands===
*Commands are in the most laymen terms, actions. What we mean by action is that we are insisting through some physical representation, whether it be a button or plain-typed text, we are calling an event. That event can be to exit the program or even perform a feature within the application.
*Let's create our first menu for the menu bar that will contain a command to exit the application.
*First open the file plugin.xml, click on the tab "Extensions", and then click on the "Add" button.
[[File:PluginT2.png]]
*Now search for "org.eclipse.ui.menus", click it to ensure it's selected, then finish it by clicking on the finish button.
[[File:ExtT2.png]]
*You should notice the plug-in was added to your extension.
*From your current display, right-click the recently added extension->New->menuContribution. After the item has been added, change the "locationUri" to "menu:org.eclipse.ui.main.menu" (this informs the application to attach it the main ui window that Eclipse makes. Afterwords, right-click that item and perform the following actions New->menu.
*Fill in the necessary based on the picture below
[[File:MenuT2.png]]
*Before we progress any further with menu, we must create a "Command". We'll first develop the "exit" command. Perform the exact same series of steps done earlier to add a new extension, except this time search for "org.eclipse.ui.commands". Add an item, "Commands", and add the following information based on the picture below.
[[File:ExtT2.png]]
*As you may recall, I made mention that commands are akin to basically doing an action, which is based on an occurrence of an event. Well, just like an event, you must develop a class that extends a type of handler to inform the application of what actions to take place. That is why you must now create package called "ecl.team2.lab3.commands" and a java file named "ExitHandler".
*Copy and paste this code into the ExitHandler
<source lang=java>
package ecl.team2.lab3.commands;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.handlers.HandlerUtil;
public class ExitHandler extends AbstractHandler {
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
HandlerUtil.getActiveWorkbenchWindow(event).close();
return null;
}
}
</source>
*Return back to File menu and add a command file to it.
*Enter what is shown in the picture below.
[[File:Ext3T2.png]]
*Save the MANIFEST file and run the application as we've done previously (Overview tab)
*You should see this window pop-up
[[File:FWindowpop3T2.png]]
*Now click on "File" within the menu bar and click "Exit", this will close the program based on the small application we created for that command.
'''Pre-emptive work for later on'''
*Given that you now have context of how to create a command, we will now progress to creating commands that will be used later within our application. Please create the following commands along with the required items:
'''AddCityHandler'''
For Commmand
<pre>
id: ecl.team2.lab3.rcpExample.AddCity
name: Add City
defaultHandler: ecl.team2.lab3.commands.AddCityHandler
</pre>
For Menu Command
<pre>
commandId: ecl.team2.lab3.rcpExample.AddCity
label: Add City
tooltip: Adds a city to list
</pre>
For AddCityHandler.java
<source lang=java>
package ecl.team2.lab3.commands;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
//This will allow us to edit the content using the editor window
import ecl.team2.lab3.editor.WeatherEditor;
import ecl.team2.lab3.editor.WeatherInput;
public class AddCityHandler extends AbstractHandler implements IHandler {
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();
WeatherInput input = new WeatherInput("-1");
try
{
page.openEditor(input, WeatherEditor.ID);
}
catch (PartInitException e)
{
System.out.println(e.getMessage());
}
return null;
}
}
</source>
<br/>
<br/>
'''RemoveCityHandler'''
For Commmand
<pre>
id: ecl.team2.lab3.rcpExample.RemoveCity
name: Add City
defaultHandler: ecl.team2.lab3.commands.RemoveCityHandler
</pre>
For Menu Command
<pre>
commandId: ecl.team2.lab3.rcpExample.RemoveCity
label: Remove City
tooltip: Removes a city or multiple cities based on selection
</pre>
For RemoveCityHandler.java
<source lang=java>
package ecl.team2.lab3.commands;
import java.util.ArrayList;
import java.util.Iterator;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.handlers.HandlerUtil;
import ecl.team2.lab3.rcpexample.WeatherView;
import ecl.team2.lab3.weathermodel.*;
public class RemoveCityHandler extends AbstractHandler implements IHandler {
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();
WeatherView view = (WeatherView) page.findView(WeatherView.ID);
ISelection select = view.getSite().getSelectionProvider().getSelection();
if(select!=null && select instanceof IStructuredSelection)
{
IStructuredSelection sel = (IStructuredSelection)select;
for(Iterator<Weather> iter = sel.iterator(); iter.hasNext();)
{
Weather temp = iter.next();
SimpleWeatherSystem.INSTANCE.removeCity(temp.getCity());
}
view.getViewer().refresh();
}
return null;
}
}
</source>
<br/>
===Views===
Since most of the back-end coding has been completed through the "Commands" section, this portion will be brief.
*In order to view and edit our content, we must create a view. Creating a view is very similar to creating a command, except you must add the extension "org.eclipse.ui.views" in our MANIFEST file.
*You should have something that looks akin to this
[[File:UiviewsT2.png]]
*Now that we've included the extension, we should create a new view so we may view and edit our content. We do this by right-clicking our recent addition, scroll to "New", and then click on "view".
*Enter the following information below and once that's completed click on "class*". Clicking on "class*" will allow us to create classes on the fly using the "New Java Class" wizard. Most of the mandatory components for creating a view java class has already been added, so all we have to do is click "Finish"
[[File:Ext4T2.png]]
*Replace code inside "WeatherView.java" with:
<source lang=java>
package ecl.team2.lab3.rcpexample;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.part.ViewPart;
public class WeatherView extends ViewPart
{
public static final String ID = "ecl.team2.lab3.rcpexample.WeatherView";
@Override
public void createPartControl(Composite parent)
{
this.setPartName("Weather");
Text text = new Text(parent, SWT.BORDER);
text.setText("Weather content will be displayed here");
}
@Override
public void setFocus()
{
// TODO Auto-generated method stub
}
}
</source>
<br/>
*We must now add our recently created view to the perspective, we do this by again engaging with the extensions in the MANIFEST file. We must include the "org.eclipse.ui.perspectiveExtensions" extension. After it is added, we will add a "view" to the last branch dubbed "*(perspectiveExtensions).
*Mimic the contents in the picture below
[[File:Ext5T2.png]]
*Launch the application, should get something akin to this
[[File:AppT2.png]]
<br/>
==Define and Use Editor==
