Building a custom feature renderer in Eclipse IDE

public boolean canRender(IFeatureClass fc, IDisplay display)throws IOException,
    AutomationException{

    if (fc.getShapeType() == esriGeometryType.esriGeometryPoint)
        return true;
    else
        return false;

}

public boolean isRenderPhase(int drawPhase)throws IOException, AutomationException{
    //Renders only in the geography phase.
    if (drawPhase == esriDrawPhase.esriDPGeography)
        return true;
    else
        return false;
}

//instance variables.
private double dispersalRatio;

//Use the draw method that draws the features on a dispersed location.
public void draw(IFeatureCursor featureCursor, int drawPhase, IDisplay display,
    ITrackCancel trackCancel)throws IOException, AutomationException{

    // Do not draw features if the display is null. 
    if (display == null){
        System.exit(0);
    }

    //Step 1: Create and set the display symbol to represent the features.

    // Set the display symbol.  
    CharacterMarkerSymbol markerSym = new CharacterMarkerSymbol();
    markerSym.setCharacterIndex(72);
    markerSym.setSize(12.0);
    IColor myFavColor = new RgbColor();
    myFavColor.setRGB(0xff0000);
    markerSym.setColor(myFavColor);
    display.setSymbol(markerSym);

    // Step 2: Loop through the features and draw them using the display symbol.

    //Calculate the dispersal distance from the dispersal ratio.
    //
    //The dispersal distance defines the minimum distance between two points.
    IDisplayTransformation displayTrans = display.getDisplayTransformation();
    double dispersalDist = displayTrans.fromPoints(markerSym.getSize()) *
        this.dispersalRatio;


    // Build a geometry bag to collect the drawn locations.
    IGeometryCollection geomColl = new GeometryBag();
    IFeature feature = featureCursor.nextFeature();
    boolean bContinue = false;
    if (trackCancel != null)
        bContinue = trackCancel.esri_continue();
    do{
        IPoint featureLocation = (IPoint)feature.getShape();
        IPoint disperseLocation = new Point();
        IPolygon symPoly = new Polygon();

        //Find a dispersed location that does not overlap previously drawn points.

        //The placeFeature method is a utility method.
        placeFeature(featureLocation, 0, geomColl, display, markerSym,
            disperseLocation, symPoly, dispersalDist);

        //Draw the symbol in the new dispersed location.
        display.drawPoint(disperseLocation);

        //Add the dispersed location's envelope to the geometry bag.
        geomColl.addGeometry(symPoly.getEnvelope(), null, null);

        //Move on to the next feature.
        feature = featureCursor.nextFeature();
        if (trackCancel != null)
            bContinue = trackCancel.esri_continue();

    }
    while ((feature != null) && (bContinue == true)); //End of loop.
}

//Add the getter method for instance variable dispersal ratio.
public double getDispersalRatio(){
    return dispersalRatio;
}

//Add the setter method for instance variable dispersal ratio.
public void setDispersalRatio(double dispersalRatio){
    this.dispersalRatio = dispersalRatio;
}

//Use the utility method to find the dispersed location.

public void placeFeature(IPoint point, int lTried, IGeometryCollection geomColl,
    IDisplay display, ISymbol symbol, IPoint disperseLocation, IPolygon symPoly,
    double dDispersalDist){
    try{
        // Calculate the place to try the feature.
        if (lTried == 0){
            disperseLocation.putCoords(point.getX(), point.getY());
        }
        else{
            double dDist = ((lTried - 1) / 4) * dDispersalDist;
            switch (lTried % 4){
                case 0:
                    disperseLocation.putCoords(point.getX() - dDist, point.getY());
                case 1:
                    disperseLocation.putCoords(point.getX(), point.getY() + dDist);
                    break;
                case 2:
                    disperseLocation.putCoords(point.getX() + dDist, point.getY());
                    break;
                case 3:
                    disperseLocation.putCoords(point.getX(), point.getY() - dDist);
                    break;
            }
        }
        // If it intersects previously drawn features,
        IRelationalOperator relOp = (IRelationalOperator)geomColl;
        symbol.queryBoundary(display.getHDC(), display.getDisplayTransformation(),
            disperseLocation, symPoly);
        if (!relOp.disjoint(symPoly.getEnvelope()))

        // try a new dispersed location.
            placeFeature(point, lTried + 1, geomColl, display, symbol,
                disperseLocation, symPoly, dDispersalDist);
        else
            return ;
    }
    catch (AutomationException e){
        e.printStackTrace();
    }
    catch (IOException e){
        e.printStackTrace();
    }
}

//Write the variables.
public void writeExternal(ObjectOutput out)throws IOException{
    out.writeDouble(this.dispersalRatio);
}

//Read the variables. 
public void readExternal(ObjectInput in)throws IOException, ClassNotFoundException{
    this.dispersalRatio = in.readDouble();
}

//This method returns the alternative renderer.
public Object convertToSupportedObject(int docVersion)throws IOException,
    AutomationException{
    SimpleRenderer simpleRend = new SimpleRenderer();
    SimpleMarkerSymbol simpleMarkerSymbol = new SimpleMarkerSymbol();
    simpleMarkerSymbol.setSize(8);
    simpleMarkerSymbol.setStyle(esriSimpleMarkerStyle.esriSMSDiamond);
    simpleRend.setSymbolByRef(simpleMarkerSymbol);
    return simpleRend;
}

//This method verifies the existing version.
public boolean isSupportedAtVersion(int docVersion)throws IOException,
    AutomationException{
    //Support all versions above or equal to 9.3.
    if (arg0 >= esriArcGISVersion.esriArcGISVersion93)
        return true;
    else
    //The convertToSupportedObject() method is invoked if the isSupportedAtVersion() method returns false.
        return false;
}

package arcgissample.renderer;

import java.awt.Rectangle;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.UIManager;
import javax.swing.border.TitledBorder;

public class SimpleRendererPropertyPageUI extends JFrame{
    private JPanel jContentPane = null;
    private JLabel jLabel = null;
    private JTextField jTextField = null;
    private JPanel jPanel = null;
    private JLabel jLabel1 = null;
    /**
     * This is the default constructor.
     */

    public SimpleRendererPropertyPageUI()throws Exception{
        initialize();
    }
    /**
     * This method initializes the frame.
     * @return void
     */
    private void initialize()throws Exception{
        this.setSize(424, 254);
        this.setResizable(false);
        this.setContentPane(getJContentPane());
        this.setTitle("Dispersal Property Page");

    }
    /**
     * This method creates a content pane for the panel.
     * @return javax.swing.JPanel
     */
    private JPanel getJContentPane()throws Exception{
        if (jContentPane == null){
            jContentPane = new JPanel();
            jContentPane.setLayout(null);
            jContentPane.add(getJPanel(), null);
        }
        return jContentPane;
    }
    /**
     * This method creates a panel. 
     * 
     * @return javax.swing.JPanel 
     */
    private JPanel getJPanel(){
        if (jPanel == null){
            jPanel = new JPanel();
            jPanel.setLayout(null);
            jPanel.setBounds(new Rectangle(8, 14, 405, 206));
            TitledBorder titled = new TitledBorder("Change Dispersal Ratio");
            jPanel.setBorder(titled);

            //Create a label that reads Dispersal Ratio.
            jLabel = new JLabel();
            jLabel.setText("Dispersal Ratio");
            jLabel.setBounds(new Rectangle(14, 97, 83, 27));
            //Add the label to the panel.
            jPanel.add(jLabel, null);
            //Create and add a text field that accepts the dispersal ratio value to the panel.
            jPanel.add(getJTextField(), null);

            //Create an information label.
            jLabel1 = new JLabel();
            jLabel1.setBounds(new Rectangle(12, 35, 385, 40));
            jLabel1.setText(
                "This ratio affects how far the marker symbol is moved from its original location.");
            //Add the label to the panel.
            jPanel.add(jLabel1, null);
        }
        return jPanel;
    }
    /**
     * This method creates a text field that accepts a dispersal ratio for the DispersalRenderer.
     * @return javax.swing.JTextField 
     */
    public JTextField getJTextField(){
        if (jTextField == null){
            jTextField = new JTextField();
            jTextField.setBounds(new Rectangle(107, 98, 100, 27));
        }
        return jTextField;
    }
    static{
        try{
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

//instance variable: The GUI form created using the previous code snippet.
SimpleRendererPropertyPageUI simplePropertyPageUI;


//This method returns the GUI form instance to the framework.
public JFrame initGUI(IFeatureRenderer arg0){

    try{
        this.simplePropertyPageUI = new SimpleRendererPropertyPageUI();
    }
    catch (Exception e){
        e.printStackTrace();
    }
    return simplePropertyPageUI;
}

//instance variable: The GUI form. 
SimpleRendererPropertyPageUI simplePropertyPageUI;

//This method applies the properties retrieved from the GUI dialog.
public void apply(IFeatureRenderer arg0){

    SimpleDispersalRenderer simpleRenderer = (SimpleDispersalRenderer)arg0;

    //Retrieve the value from the text field of the form.
    String dispersalRatio = this.simplePropertyPageUI.getJTextField().getText();

    //Set the property of the custom renderer.
    simpleRenderer.setDispersalRatio(Double.parseDouble(dispersalRatio));
}