In this example we are going to create the class ShadowEllipse. This file is located at:

Step 1 - Creating the Class

To create the class:

Step 2 - Defining the Constructors

A constructor is defined to create a new shadow ellipse. These constructors simply set the value of the definition rectangle or create a new ShadowEllipse from an existing ShadowEllipse instance:

  /**
   * Creates a new shadow ellipse.
   * @param rect the bounding rectangle of the shadow ellipse.
   */
  public ShadowEllipse(IlvRect rect)
  {
    super();
    // Stores the bounding rectangle of the object.
    drawrect.reshape(rect.x, rect.y, rect.width, rect.height);
  }

/**
   * Creates an ellipse by copying another one.
   * @param source the object to copy.
   */
  public ShadowEllipse(ShadowEllipse source) 
  {
    // We first call the super class constructor 
    // that will copy the informations of the super class.
    super(source);

    // Copies the bounding rectangle.
    drawrect.reshape(source.drawrect.x, source.drawrect.y, 
		     source.drawrect.width, source.drawrect.height);
    // Copies the color and the color of the shadow.
    setColor(source.getColor());
    setShadowColor(source.getShadowColor());
    // Copies the thickness
    setThickness(source.getThickness());
  }

Step 3 - Overriding the draw Method

This method demonstrates that drawing an object is merely a call to some of the primitive methods contained in the AWT Graphics class.

/**
   * Draws the object.
   * We override the draw method to define the way the object will appear.
   * @param dst The AWT object that will perform the
   * drawing operations. 
   * @param t This parameter is the transformer used to draw the object.
   * This parameter may be a translation, a zoom or a rotation.
   * When the graphic object is drawn in a view (IlvManagerView),
   * this transformer is the transformer of the view.
   */
  public void draw(Graphics dst, IlvTransformer t)
  {
    // We first copy the rectangle that defines the bounding
    // rectangle of the object because we do not want to modify it.
     
    IlvRect r = new IlvRect(drawrect);
     
    // To compute the bounding rectangle of the object in 
    // the view coordinate system, we apply the transformer 't'
    // to the definition rectangle.
    // The transformer may define a zoom, a translation or a rotation.
     
    // We are using applyFloor so the resulting rectangle
    // is correctly projected for drawing in the view.
    // The object's coordinate system is defined by 'float' values
    // and we need 'int' values to be able to draw. applyFloor will
    // apply the transformation to 'r' and then calls Math.floor to
    // translate 'float' values to 'int' values.
    if (t != null) 
      t.applyFloor(r);
    else
      r.floor();
     
    // The variable 'r' now contains the bounding rectangle
    // of the object in the view's coordinate system and we will
    // draw in this rectangle. In this rectangle, we will draw 
    // two ellipses. We first draw the shadow ellipse on the 
    // bottom right corner of the definition rectangle, then the main
    // ellipse on the top-left corner. Each ellipse will be of size
    // (r.width-thickness, r.height-thickness).
 
    int thick = thickness;
 
    // Computes a correct value for thickness.
    // Since we want the size of the ellipses
    // to be (r.width-thickness, r.height-thickness), we
    // must check that the thickness is not too big.
 
    if ((r.width <= thick) || (r.height <= thick))
      thick = (int)Math.min(r.width, r.height);
 
    // Sets the size of the ellipses.
    r.width  -= thick;
    r.height -= thick;
           
    // 'r' now contains the bounding area of the main ellipse.
 
    // Computes a rectangle to draw the shadow.
    // We copy the variable 'r', we will need it for the
    // second ellipse.
    IlvRect shadowRect = new IlvRect(r);
    shadowRect.translate(thick, thick);
 
    // Draws the shadow ellipse
    dst.setColor(getShadowColor());
    dst.fillArc((int)shadowRect.x, 
                (int)shadowRect.y, 
                (int)shadowRect.width, 
                (int)shadowRect.height,
                0, 360);
 
    // Draws the main ellipse.
    dst.setColor(getColor());
    dst.fillArc((int)r.x, 
                (int)r.y, 
                (int)r.width, 
                (int)r.height,
                0, 360);
  }

The method draw fills the two ellipses. The bounding rectangle, drawrect, actually covers both ellipses.

Step 4 - Overriding the boundingBox Method

The method boundingBox simply transforms the bounding box. It creates a copy of the rectangle drawrect even if the transformer is null. This is so the returned rectangle can be modified by ILOG JViews.

 /**
   * Computes the bounding rectangle of the graphic 
   * object when drawn with the specified transformer.
   */
  public IlvRect boundingBox(IlvTransformer t)
  {
    // We first copy the definition rectangle
    // because we do not want to modify it.
    IlvRect rect = new IlvRect(drawrect);
    // Apply the transformer on the rectangle to
    // translate to the correct coordinate system.
    if (t != null) t.apply(rect);
    return rect;
  }

Step 5 - Overriding the applyTransform method

Override the applyTransform method to apply a transformation to the shape of the ShadowEllipse rectangle.

Step 6 - Overriding the copy method

Override the copy method to call the ShadowEllipse copy constructor to make a new instance.

Step 7 - Defining Accessors

Public accessors are added to the graphic object. These accessors deal with thickness and color. They appear in bold type in the following code example.

  /** 
   * Changes the thickness of the shadow ellipse 
   * @param thickness the new thickness
   */ 
  public void setThickness(int thickness) 
  { 
    this.thickness = thickness; 
  } 
 
  /** 
   * Returns the thickness of the shadow ellipse 
   * @return the thickness of the object. 
   */ 
  public int getThickness() 
  { 
    return thickness; 
  } 
 
  /** 
   * Changes the color of the ellipse. 
   * @param color the new color. 
   */ 
  public void setColor(Color color) 
  { 
    this.color = color; 
  } 
 
  /** 
   * Returns the color of the shadow ellipse 
   * @return the color of the object. 
   */ 
  public Color getColor() 
  { 
    return color; 
  } 
 
  /** 
   * Changes the color of the shadow 
   * @param color the new color 
   */ 
  public void setShadowColor(Color color) 
  { 
    this.shadowColor = color; 
  } 
   
  /** 
   * Returns the color of the shadow 
   * @return the color of the shadow 
   */ 
  public Color getShadowColor() 
  { 
    return shadowColor; 
  }