Source code: com/arranger/jarl/base/Context.java

   package com.arranger.jarl.base;
   
   import com.arranger.jarl.Jarl;
   
   import java.awt.*;
   import java.awt.image.BufferedImage;
   import java.util.*;
   
   /**
   * Context is the concrete implementation of {@link com.arranger.jarl.base.IContext}
   */
  public class Context implements IContext, Cloneable {
  
      protected Jarl m_jarl;
      protected IRenderManager m_renderManager;
      protected IGradientManager m_gradientManager;
      protected RenderingHints m_renderingHints;
      protected int m_height;
      protected int m_width;
      protected Time m_time;
      protected Time m_absoluteTime;
      protected float m_strokeWidth;
      protected Stroke m_defaultStroke = new BasicStroke(5);
      protected Set m_statusListeners = new HashSet();
      protected Map m_attributes = new HashMap();
  
      public Context() {
      }
  
      /**
       * @return the currently configured rendering hints
       */
      public RenderingHints getRenderingHints() {
          return m_renderingHints;
      }
  
      public void setRenderingHints(RenderingHints renderingHints) {
          m_renderingHints = renderingHints;
      }
  
      /**
       * @return the current rendering height
       */
      public int getHeight() {
          return m_height;
      }
  
      public void setHeight(int height) {
          m_height = height;
      }
  
      /**
       * @return the current rendering width
       */
      public int getWidth() {
          return m_width;
      }
  
      public void setWidth(int width) {
          m_width = width;
      }
  
      public float getStrokeWidth() {
          return m_strokeWidth;
      }
  
      public void setStrokeWidth(float strokeWidth) {
          m_strokeWidth = strokeWidth;
          m_defaultStroke = new BasicStroke(m_strokeWidth);
      }
  
      public Stroke getDefaultStroke() {
          return m_defaultStroke;
      }
  
      public void setDefaultStroke(Stroke defaultStroke) {
          m_defaultStroke = defaultStroke;
      }
  
      /**
       * Create a properly initialized image
       * @return an initialized image
       */
      public Image createImage() {
          return new BufferedImage(getWidth(),
                  getHeight(),
                  BufferedImage.TYPE_INT_RGB);
      }
  
      /**
       * Get the current rendering manager
       * @return the current {@link IRenderManager}
       */
      public IRenderManager getRenderManager() {
          return m_renderManager;
      }
  
      /**
       * sets the current render manager
      * @param renderManager
      */
     public void setRenderManager(IRenderManager renderManager) {
         m_renderManager = renderManager;
     }
 
     /**
      * Get the current gradient manager
      * @return the current {@link IGradientManager}
      */
     public IGradientManager getGradientManager() {
         return m_gradientManager;
     }
 
     /**
      * sets the current gradient manager
      * @param gradientManager
      */
     public void setGradientManager(IGradientManager gradientManager) {
         m_gradientManager = gradientManager;
     }
 
     /**
      * @return the current instance of Jarl
      */
     public Jarl getJarl() {
         return m_jarl;
     }
 
     /**
      * Set the current instance of jarl
      * @param jarl
      */
     public void setJarl(Jarl jarl) {
         m_jarl = jarl;
     }
 
     /**
      * Get the current time
      * @return the current rendering time
      */
     public Time getTime() {
         return m_time;
     }
 
     /**
      * Get the absolute current time that won't be affected by holds or echos
      * @return the absolutely current rendering time
      */
     public Time getAbsoluteTime() {
         return m_absoluteTime;
     }
 
     /**
      * Set the absolute current time that won't be affected by holds or echos
      */
     public void setAbsoluteTime(Time time) {
         setTime(time);
         m_absoluteTime = new Time(time.getFrame());
     }
 
     /**
      * sets the current time
      * @param time
      */
     public void setTime(Time time) {
         m_time = time;
     }
 
     public Object clone() {
         try {
             return super.clone();
         } catch (CloneNotSupportedException e) {
             e.printStackTrace();
             return this;
         }
     }
 
     /**
      * Copy the params from the other context
      * @param context
      */
     public void copy(IContext context) {
         m_renderManager = context.getRenderManager();
         m_renderingHints = context.getRenderingHints();
         m_jarl = context.getJarl();
         m_height = context.getHeight();
         m_width = context.getWidth();
         m_time = context.getTime();
     }
 
     /**
      * Adds a status Listener
      * @param statusListener
      */
     public void addStatusListener(IStatusListener statusListener) {
         m_statusListeners.add(statusListener);
     }
 
     /**
      * Removes a status Listener
      * @param statusListener
      */
     public void removeStatusListener(IStatusListener statusListener) {
         m_statusListeners.remove(statusListener);
     }
 
     /**
      * A simple message
      * @param message
      */
     public void onStatus(String message) {
         for (Iterator it = m_statusListeners.iterator(); it.hasNext();) {
             ((IStatusListener) it.next()).onStatus(message);
         }
     }
 
     /**
      * An error occurred
      * @param throwable
      */
     public void onError(Throwable throwable) {
         for (Iterator it = m_statusListeners.iterator(); it.hasNext();) {
             ((IStatusListener) it.next()).onError(throwable);
         }
     }
 
     /**
      *  @return an alterable map
      */
     public Map getAttributes() {
         return m_attributes;
     }
 }