Developer Papercuts » Plugin

Eclipse Papercut #7 – Adding the PDE Plugin creation wizard to the Eclipse toolbar

Lars Vogel — Thu, 13 Jan 2011 05:39:56 +0000

Its been a while since I wrote my last Eclipse papercut blog entry.

Today I demonstrate how to add the PDE wizard for creating new plugins to the Eclipse toolbar. I personally create plugin projects on a regular basis therefore it is annoying to select the wizard via File-> New -> blablabla.

I know that I can use Ctrl+3 to select the wizard but I want to be able to select this wizard from the main toolbar.

This is really easily. First find the related Wizard via the Plugin Spy. We see that the wizard is called NewPluginProjectWizard.

Then create a command with the following default handler.


package de.vogella.plugin.pdewizard.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.pde.internal.ui.wizards.plugin.NewPluginProjectWizard;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.handlers.HandlerUtil;

public class SampleHandler extends AbstractHandler {
	public Object execute(ExecutionEvent event) throws ExecutionException {
		Shell shell = HandlerUtil.getActiveShell(event);
		WizardDialog wizard = new WizardDialog(shell,
				new NewPluginProjectWizard());
		wizard.open();
		return null;
	}
}

Via the plugin menu spy you also find quickly a nice place to put your new toolitem to the main toobar

If you also add the dependencies to org.eclipse.ui, org.eclipse.pde.ui, org.eclipse.pde.ui.templates and org.eclipse.core.runtime then you should be able to create a new plugin project via your new button in the main toolbar.

I hope this help. You can follow me on Twitter.

EDIT: A simpler solution was proposed by Remy Suen: Since the new/import/export wizards are parameterized commands, the same effect can actually be achieved with pure XML.

Shortcuts for Next / Previous result in the Search View

Lars Vogel — Tue, 16 Nov 2010 09:44:00 +0000

Paul Webster posted a very nice small Eclipse plugin to support Tor Norby from the Javaposse.

This plugin defines a command which defines shortcuts to navigate through the search results in the search view, even if the search view doesn’t have the focus.

I find such a plugin very useful therefore I decided to “re-blog” Pauls code. Here is the coding and the plugin.xml.

package z.ex.search;

import java.util.HashMap;

public class NextPrevSearchEntryHandler extends AbstractHandler implements IExecutableExtension {
	private String searchCommand = IWorkbenchCommandConstants.NAVIGATE_NEXT;

	public Object execute(ExecutionEvent event) throws ExecutionException {
		IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
		ICommandService cs = (ICommandService) window.getService(ICommandService.class);

		Command showView = cs.getCommand(IWorkbenchCommandConstants.VIEWS_SHOW_VIEW);
		HashMap parms = new HashMap();
		parms.put(IWorkbenchCommandConstants.VIEWS_SHOW_VIEW_PARM_ID, "org.eclipse.search.ui.views.SearchView");
		ParameterizedCommand showSearchView = ParameterizedCommand.generateCommand(showView, parms);

		IHandlerService hs = (IHandlerService) window.getService(IHandlerService.class);
		try {
			hs.executeCommand(showSearchView, (Event)event.getTrigger());
			hs.executeCommand(searchCommand, (Event)event.getTrigger());
			hs.executeCommand(IWorkbenchCommandConstants.WINDOW_ACTIVATE_EDITOR, (Event)event.getTrigger());
		} catch (NotDefinedException e) {
			throw new ExecutionException(e.getMessage(), e);
		} catch (NotEnabledException e) {
			throw new ExecutionException(e.getMessage(), e);
		} catch (NotHandledException e) {
			throw new ExecutionException(e.getMessage(), e);
		}

		return null;
	}

	public void setInitializationData(IConfigurationElement config,
			String propertyName, Object data) throws CoreException {
		if ("previous".equals(data)) {
			searchCommand = IWorkbenchCommandConstants.NAVIGATE_PREVIOUS;
		}
	}

}

I think it would be cool to have this in standard Eclipse. If you agree please place your opinion in the bug report from Paul: Bug Report.

Thanks Paul, I hope it is ok to blog about your development.

If you are located in Germany you may be interested in my Eclipse RCP training which I deliver together with Ralf Ebert.

Eclipse Development – In which plugin do I find this class?

Lars Vogel — Tue, 28 Sep 2010 10:24:24 +0000

A common question for Eclipse Plugin or Eclipse RCP developer is in which plugin a certain class is included.

A very easy way for finding this information is the Open Type Dialog (Hotkey Ctrl + Shift +T). Just look in the right bottom corner.

Thanks for Ralf Ebert for reminding me that this is a common problem.

Using Eclipse Templates to show off

Lars Vogel — Tue, 14 Sep 2010 07:51:42 +0000

Have you ever been in a software demo there the presenter was that fast with the editor that you were scared?

He might have been using personal templates. Templates allow you to save a block of coding and insert it as you desire. You find them under Window-> Preferences -> Java -> Editor -> Templates.

Try it out in the Editor for the SWT templates (within an Eclipse plugin or Eclipse RCP application). Type Label and press Cntr+Space three times until you see only the Java template suggestions.

Select the template and change the code to your liking. Do the same for GridData. You end up the following code almost without typing.

Label label1 = new Label(parent, SWT.NONE);
label1.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false,false));
label1.setText("Test");
GridData gridData2 = new GridData(SWT.FILL, SWT.FILL, true, false);
gridData2.widthHint = SWT.DEFAULT;
gridData2.heightHint = SWT.DEFAULT;
label1.setLayoutData(gridData2);

The great thing about templates is that you can define your own once. So if you have something longer which you need to type again and again you can use your own templates.

Reading resources from a Eclipse plugin

Lars Vogel — Tue, 06 Jul 2010 00:16:16 +0000

Frequenty you want to store static files in your bundle and load them from your bundle. For this you can use the following code, of course replace the bundle id with your version:


Bundle bundle = Platform.getBundle("de.vogella.example.readfile");
URL fileURL = bundle.getEntry("files/test.txt");
File file = null;
try {
	file = new File(FileLocator.resolve(fileURL).toURI());
} catch (URISyntaxException e1) {
	e1.printStackTrace();
} catch (IOException e1) {
	e1.printStackTrace();
}

Alternatively you can also use URL directly. I have to thank Paul Webster for this tip.


URL url;
try {
        url = new URL("platform:/plugin/de.vogella.rcp.plugin.filereader/files/test.txt");
	InputStream inputStream = url.openConnection().getInputStream();
	BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
	String inputLine;

	while ((inputLine = in.readLine()) != null) {
		System.out.println(inputLine);
	}

	in.close();

} catch (IOException e) {
	e.printStackTrace();
}

I believe the second option is the better one, as you avoid a dependency to the class Platform.

Going plugin (from an OSGi bundle)

Lars Vogel — Fri, 12 Mar 2010 15:08:31 +0000

The Eclipse plugin creation wizard allows to create OSGi bundles or Eclipse plugins.

The most notable difference is that the PDE plugin editor does not show the extension tab.

I recently wanted to use an plugin extension in a project which I initially created based on OSGi; therefore I wanted to enable the “Extension” and the “Extension Point” tab in the PDE editor.

To do this remove the line “pluginProject.extensions.false” from the file .settings/org.eclipse.pde.core.prefs. Re-open the “MANIFEST.MF” and the Extensions tab will show.

Many thanks to Neil Bartlett for sharing this tip via twitter.

Poll – Default launch configuration for Eclipse plugin / RCP development

Lars Vogel — Fri, 20 Nov 2009 14:50:12 +0000

Eclipse shows errors during a launch via the log views in both the host and the target system and on the file system. In addition the developer can specify the flag “-consoleLog” in the launch configuration so see potential error messages in the console view.

Bug 284704 had been opened asking if the “-consoleLog” flag could be included by default in a new launch configuration.

What do you think? If you are a plugin or RCP developer please participate in the following survey:

Link to Survey

——————————
Please note that this is my first attempt using SurveyMonkey, I hope this works well. I believe the survey will close after the first 100 answers. If this number has not reached I’m planning to close the survey next week 27. Nov. 2009.

API for reading Eclipse plugin dependencies

Lars Vogel — Mon, 19 Oct 2009 05:04:02 +0000

The Eclipse platform provides an API to allows that you can access in information of the MANIFEST.MF. For example you could read the dependencies of your plugin.

For this example create a plugin “de.vogella.pde.dependencies”. See Eclipse Plugin development for examples on how to develop plugins. Use the “Hello, World Command” template.

Define dependendies to the following plugins:
– org.eclipse.ui
– org.eclipse.core.runtime

Change the command to the following.


package de.vogella.pde.dependencies.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.osgi.util.ManifestElement;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;

public class PrintDependencies extends AbstractHandler {
	public Object execute(ExecutionEvent event) throws ExecutionException {
		String requireBundle = (String)Platform.getBundle("de.vogella.pde.dependencies").getHeaders().get(
				Constants.REQUIRE_BUNDLE);
				try {
					ManifestElement[] elements = ManifestElement.parseHeader(
					Constants.BUNDLE_CLASSPATH, requireBundle);
					for (ManifestElement manifestElement : elements) {
						System.out.println( manifestElement.getValue());
					}
				} catch (BundleException e) {
					e.printStackTrace();
				}
		return null;
	}
}

If you now run your new plugin it and select your command it will print out the dependencies of your plugin.

Eclipse Papercut #6 – Modifying Mylyn Context

Lars Vogel — Mon, 05 Oct 2009 06:06:55 +0000

In this episode of Eclipse Papercuts I will demonstrate how to modify the Mylyn tasks context. Many thanks to David Green for providing sample code to access the Mylyn context.

Mylyn makes certain assumptions how the developer works. If you start a new task the Mylyn context is empty and fills up based on the selected files.

Which is not always the way I work. Frequently I know that for my task a whole package (or project) is relevant. I would like to include all classes in this package / project in my Mylyn task.

Ok, lets see how we can solve this papercut. I describe how to add Java classes from a package to an active task.

Create an command which extends the package explorer with a new popup commands as described here Extend the package explorer.

Create the command handler with the following coding:


package de.vogella.mylyn.tasksmodify.handlers;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.mylyn.context.core.ContextCore;
import org.eclipse.mylyn.context.core.IInteractionContext;
import org.eclipse.mylyn.internal.context.core.ContextCorePlugin;
import org.eclipse.mylyn.monitor.core.InteractionEvent;
import org.eclipse.mylyn.monitor.core.InteractionEvent.Kind;
import org.eclipse.ui.handlers.HandlerUtil;

public class SampleHandler extends AbstractHandler {
	public Object execute(ExecutionEvent event) throws ExecutionException {

		IStructuredSelection selection = (IStructuredSelection) HandlerUtil
				.getActiveMenuSelection(event);
		if (selection ==null){
			return null;
		}

		Object firstElement = selection.getFirstElement();

		if (firstElement instanceof IPackageFragment) {
			IPackageFragment mypackage = (IPackageFragment) firstElement;
			try {
				if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE){
					 ICompilationUnit[] compilationUnits = mypackage.getCompilationUnits();
					 for (ICompilationUnit iCompilationUnit : compilationUnits) {
						 IInteractionContext activeContext = ContextCore.getContextManager()
							.getActiveContext();
						 ContextCorePlugin.getContextManager().processInteractionEvent(iCompilationUnit,
									Kind.PROPAGATION, InteractionEvent.ID_UNKNOWN, activeContext);
					}
				}
			} catch (JavaModelException e) {
				e.printStackTrace();
			}
		}

		return null;
	}
}

Launch your plugin. Create a Mylyn task and select a package in the package explorer. Select your commands and all files of this package will be added to the task.

Further reading: If you want to access other Java Elements, e.g. Project and add them to the Mylyn task this tutorial might help you: Eclipse JDT.

Please note that ContextCorePlugin is supposed to be internal API but I did not find another way of accessing the Mylyn tasks.

Eclipse PDE templates – Your action is my command

Lars Vogel — Tue, 22 Sep 2009 22:10:37 +0000

The Eclipse PDE templates are fantastic to help people to learn the platform and to get oven the first initial resistence to start with Eclipse RCP or Eclipse Plugin development.

Templates indicates to their consumers that they represent best development practices. This puts a certain burden on the quality to the templates. Unfortunately the PDE RCP templates in Eclipse 3.5 were all based on actions which I believe are superseded by Eclipse Commands.

I have seen in the past lots of questions regarding actions in the Eclipse RCP and PDE newsgroups. I believe that at least some of these questions are based on the fact that the PDE templates still promote actions.

I’m therefore happy to see the changes of Bug 265231 applied for the “RCP with a view” template for the upcoming Eclipse 3.6. Special thanks for this to Chris Aniszczyk.

It also looks good for the mail example. It seems that work is happening in Bug 253105

Actions are (a little bit more) dead. Long live the command!