Eclipse Plug-in Development:Working with Project Facet

Every project may have one or more natures. Each nature brings set of properties to the project.For example a Java project has “src” directory and “bin” as build directory or you may want to associate a set of libraries to your custom project.

Faceted Project Framework provides a powerful mechanism for extending the capabilities of the Web Tools Platform. Project facets are typically used as a way of adding functionality to a project. When a facet is added to the project it can perform any necessary setup actions such as copying resources, installing builders, adding natures, etc. Facets can also be used as markers for enabling user interface elements.

This post explains defining a facet and using it.

Prerequisites :

  • Install WST eclipse plug-in
  • Add dependencies to MANIFEST.MF
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Sample
Bundle-SymbolicName: com.facet.sample;singleton:=true
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: com.facet.sample.Activator
Bundle-Vendor: FACET
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime,
 org.eclipse.wst.common.project.facet.core;bundle-version="1.4.100",
 org.eclipse.jst.common.project.facet.ui;bundle-version="1.4.100",
 org.eclipse.core.resources;bundle-version="3.6.0"
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Bundle-ActivationPolicy: lazy

1. Extend extension-point “org.eclipse.wst.common.project.facet.core.facets”, provide name description, version , etc . Plug-in.xml will look like below



<?xml version="1.0" encoding="UTF-8"?>
<?eclipse version="3.4"?>
<plugin>
   <extension
         point="org.eclipse.wst.common.project.facet.core.facets">
      <category id="com.facet.sample.category1">
         <description> Sample Facet Desciption </description>
      </category>
      <project-facet id="my.facet">
         <label> My Facet </label>
         <description> My Facet Description </description>
      </project-facet>
      <project-facet-version facet="my.facet" version="1.0"/>
   </extension>
</plugin>

After above modification in plug-in.xml , “Project Facets” page in “Facet Project” wizard will shows newly declared facet in available facet list


image


Here we have just declared facet only, we need to provide action delegate as well as configurator .



<action
           facet="my.facet"
           id="my.facet.action.INSTALL"
           type="install"
           version="1.0">
        <delegate
              class="com.facet.sample.MyFacetInstallDegegate">
        </delegate>
     </action>

Now we have declared “Install” action and corresponding action delegate. MyFacetInstallDelegate has to implement org.eclipse.wst.common.project.facet.core.IDelegate and provide implementation for execute() method. Whenever “MyFacet” is selected to install, MyFacetInstallDelegate.execute() gets call back. I am creating two directories “src” & “bin” under project.



import java.io.File;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.common.project.facet.core.IDelegate;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
 
public class MyFacetInstallDegegate implements IDelegate {
 
    @Override
    public void execute(IProject project, IProjectFacetVersion fv,
            Object config, IProgressMonitor monitor) throws CoreException {
        IPath projectPath = project.getLocation();
        //creating src & bin folder structure 
        createFolderStructure(projectPath);
    }
 
    private void createFolderStructure(IPath path){
     //....
    }
}


image



In this post, I have explaining creating facet for project and taken appropriate action when the facet is being selected.

Comments

Post a Comment

Popular posts from this blog

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior...
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm...
Read more

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); ...
Read more