DefaultShape.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.foo.paint;

import java.awt.*;
import java.util.concurrent.atomic.AtomicReference;

import javax.swing.ImageIcon;
import org.foo.shape.SimpleShape;

/**
 * This class is used as a proxy to defer object creation from shape provider
 * bundles and also as a placeholder shape when previously used shapes are no
 * longer available. These two purposes are actually orthogonal, but were
 * combined into a single class to reduce the number of classes in the
 * application. The proxy-related functionality is introduced as a way to lazily
 * create shape objects in an effort to improve performance; this level of
 * indirection could be removed if eager creation of objects is not a concern.
 * Since this application uses the service-based extension appraoch, lazy shape
 * creation will only come into effect if service providers register service
 * factories instead of directly registering <tt>SimpleShape</tt> or if they use
 * a technology like Declarative Services or iPOJO to register services. Since
 * the example providers register services instances directly there is no
 * laziness in the example, but the proxy approach is still used to demonstrate
 * how to make laziness possible and to keep it similar to the extender-based
 * approach.
 **/
class DefaultShape implements SimpleShape {
  private AtomicReference<SimpleShape> m_shapeRef = new AtomicReference<SimpleShape>();
  
  private ImageIcon m_icon;

  /**
   * This constructs a placeholder shape that draws a default icon. It is used
   * when a previously drawn shape is no longer available.
   * @param shape 
   **/
  public DefaultShape() {
  // Do nothing.
  }

  /**
   * This constructs a proxy shape that lazily gets the shape service.
   * 
   * @param context The bundle context to use for retrieving the shape service.
   * @param ref The service reference of the service.
   **/
  public DefaultShape(SimpleShape shape) {
    m_shapeRef.set(shape);
  }

  /**
   * This method tells the proxy to dispose of its service object; this is
   * called when the underlying service goes away.
   **/
  public void dispose() {
    m_shapeRef.set(null);
  }

  /**
   * Implements the <tt>SimpleShape</tt> interface method. When acting as a
   * proxy, this method gets the shape service and then uses it to draw the
   * shape. When acting as a placeholder shape, this method draws the default
   * icon.
   * 
   * @param g2 The graphics object used for painting.
   * @param p The position to paint the triangle.
   **/
  public void draw(Graphics2D g2, Point p) {
    SimpleShape shape = m_shapeRef.get();
    
    // If this is a proxy shape, use it to draw the shape.
    if (shape != null) {
        // Draw the shape.
        shape.draw(g2, p);
        // If everything was successful, then simply return.
        return;
    }

    // If the proxied shape could not be drawn for any reason or if
    // this shape is simply a placeholder, then draw the default icon.
    if (m_icon == null) {
      try {
        m_icon = new ImageIcon(this.getClass().getResource("underc.png"));
      } catch (Exception ex) {
        ex.printStackTrace();
        g2.setColor(Color.red);
        g2.fillRect(0, 0, 60, 60);
        return;
      }
    }
    g2.drawImage(m_icon.getImage(), 0, 0, null);
  }
}