noponies

/* AS3
*Copyright 2008 noponies.
*/

package noponies.display {
  import flash.display.Bitmap;
  import flash.display.BitmapData;
  import flash.display.Loader;
  import flash.display.Sprite;
  import flash.display.Stage;
  import flash.display.StageAlign;
  import flash.display.StageScaleMode;
  import flash.display.Graphics
  import flash.events.Event;
  import flash.events.IOErrorEvent;
  import flash.net.URLRequest;
  import flash.display.BlendMode;
  import flash.system.Capabilities;
 
  /**
  * The NpTileBg class is for creating a tiled bitmap background for your projects. It attempts to emulate the way the CSS background property works in HTML documents. You can pass in an existing library
  * bitmap asset, or load an external bitmap asset at runtime.
  * @langversion ActionScript 3.0
  * @Flash Player 9.0.28.0
  * @author noponies - 2008
  *   @version 1.0
   */
  public class NpTileBg extends Sprite {

    //--------------------------------------
    // PRIVATE INSTANCE PROPERTIES
    //--------------------------------------
    private var bitmap:Bitmap = new Bitmap();
    private var stageInstance:Stage;
    private var bgBlendMode:Boolean = false;
    private var repeatDir:String;
    private var sg:Graphics
    private var performanceMode:Boolean = false
    private var obj:*
    //--------------------------------------
    // GETTERS/SETTERS
    //--------------------------------------
    //set a new tile image at runtime
    /**
    * @langversion ActionScript 3.0
    * @playerversion Flash 9
     *  Set a new image at runtime. Useful for changing background patterns say between sections of your site.
     *  @param newTile Either a URL to a bitmap or a bitmap object.
     *  @return void
     */
    public function set newBgTileImage(newTile:*):void {
      init(newTile);
    }
    /**
    * @langversion ActionScript 3.0
    * @playerversion Flash 9
     *  Get / Set the tiles blend mode. Which will make a tile semi transparent over another display object. Note, that performance can suffer when using this mode.
     *  @default false
     *  @return Boolean representing whether or not to enable MULTIPLY blendmode. A value of <code>true</code> enables MULTIPLY blendmode. A value of <code>false</code> disables MULTIPLY blendmode.
     */
    public function get tileBlendMode():Boolean {
      return bgBlendMode;
    }
    /**
    * @private
    */
    public function set tileBlendMode(toggleMode:Boolean):void {
      bgBlendMode = toggleMode;
      if (toggleMode) {
        this.blendMode=BlendMode.MULTIPLY;
      } else {
        this.blendMode=BlendMode.NORMAL;
      }
    }
    /**
    * @langversion ActionScript 3.0
    * @playerversion Flash 9
     *  Get / Set the tiles repeat mode. Operates similar to the CSS background repeat mode.
     *  @default "repeat"
     *  @return String representing tiles repeat mode. A value of <code>repeat</code> repeats x and y. A value of <code>repeatx</code> repeats on the x axis.
     *  A value of <code>repeaty</code> repeats on the y axis. A value of <code>norepeat</code> turns off repeating altogether.
     */
    public function get bgRepeat():String {
      return repeatDir
    }
    /**
    * @private
    */
    public function set bgRepeat(newRepeat:String):void {
      validateParams(newRepeat)
    }
   
    /**
    * @langversion ActionScript 3.0
    * @playerversion Flash 9
     *  Get / Set the tiles tiling drawing mode. In tileFastMode the class will not actually redraw the background with each resize event. Rather it will simply draw a massive
     *  background tile, that extends beyond the stage boundaries. This increases peformance when resizing but also increases memory footprint. Only use if you
     *  really need to have super smooth resize performance. Bit of a hack....
     *  <p>You can turn this property on or off as you see fit</p>
     *  @default false
     *  @return Boolean representing tileFastMode. A value of true will make the class draw a large background tiled image that is not resized with the browser. The default is to draw this
     *  image 1.25x the users screenResolutionX and screenResolutionY.
     */
    public function get tileFastMode():Boolean {
      return performanceMode
    }
    /**
    * @private
    */
    public function set tileFastMode(newPerformanceMode:Boolean):void {
      performanceMode = newPerformanceMode
    }

    //---------------------------------------
    // CONSTRUCTOR
    //---------------------------------------
    /**
     *  The NpTileBg class is for creating a tiled background for your projects. Takes 3 arguments, the first is either a bitmapData object or URL to an image,
     *  a boolean indicating if you want to multiply blend your image and finally a string representing the repeat direction of your background tile. Using the MULTIPLY mode can make performance suffer!
     *  <p>The two constructor arguments for <code>bgBlendMode</code> which sets the MULITPLY property of the tile and the <code>repeatDir</code> which sets the repeat direction of the tile are
     *  optional. If you do not pass either of these two parameters the class defaults to drawing the tile in non mulitplied repeat mode.</p>
     *  <p>Original Source http://blog.efnx.com/?p=25 Few Edits, to include a setter, and a public destroy method. Along, with a slight rejig of the way the class works to better support the new methods.</p>
     *  @param obj UnTyped, either Bitmap or a URL to an external image asset you would like to load.
     *  @param bgBlendMode Boolean represents whether or not to overlay the pattern over other display objects.
     *  @param repeatDir String representing what repeat pattern to use when repeating the tile. Operates in the same manner as a CSS background repeat. A value of <code>repeat</code> repeats x and y. A value of <code>repeatx</code> repeats on the x axis.
     *  A value of <code>repeaty</code> repeats on the y axis. A value of <code>norepeat</code> turns off repeating altogether.
     *  @see #tileFastMode
     *
     *  @example Demo of class constructor using tileFastMode which is set via the tileFastMode setter.
     *  <listing version="3.0">
     *  import noponies.display.NpTileBg;
     *  var bg:NpTileBg = new NpTileBg(new arrow(0, 0), true,"repeat");
     *  bg.tileFastMode = true
     *  addChild(bg)
     *  </listing>
     *
     * @example Demo of class constructor using library bitmap asset.
     *  <listing version="3.0">
     *  import noponies.display.NpTileBg;
     *  var bg:NpTileBg = new NpTileBg(new tileBitmap(0, 0),true,"repeatx");
     *  addChild(bg)
     *  </listing>
     *
     * @example Demo of class constructor using http bitmap asset.
     *  <listing version="3.0">
     *  import noponies.display.NpTileBg;
     *  var bg:NpTileBg = new NpTileBg("http://www.somesite.com/someimage.jpg",true,"repeat");
     *  addChild(bg)
     *  </listing>
     */

    public function NpTileBg(obj:*, bgBlendMode:Boolean=false, repeatDir:String = "repeat"){
     
      //error checking for repeat param
      validateParams(repeatDir)
      //set the all important blend mode
      if (bgBlendMode) {
        this.blendMode=BlendMode.MULTIPLY;
      }
      this.mouseEnabled= false;
      this.obj = obj
      addEventListener(Event.ADDED_TO_STAGE, addedToStageHandler);
    }
   
    private function addedToStageHandler(event:Event):void{
      //set stage align and scale modes, could possibly test for this and throw and error, but it should
      //be common knowledge to set stage to no scale and top/left align
      stageInstance = stage;
      stageInstance.scaleMode = StageScaleMode.NO_SCALE;
      stageInstance.align = StageAlign.TOP_LEFT;
      stageInstance.addEventListener(Event.RESIZE, resize);
      stageInstance.addEventListener(Event.REMOVED_FROM_STAGE, killBg);
      sg = this.graphics
      init(obj);
    }
   
    //validate the passed in repeat modes.
    private function validateParams(repeatDirection:String):void{
      switch (repeatDirection) {
        case "repeat" :
        this.repeatDir = repeatDirection
        break;
        case  "repeaty" :
        this.repeatDir = repeatDirection
        break
        case  "repeatx" :
        this.repeatDir = repeatDirection
        case  "norepeat" :
        this.repeatDir = repeatDirection
        break
        default:
        throw new Error("Problem :The repeat parameter passed "+ repeatDirection+ " does not match the allowed repeat modes, which are: \"repeat\", \"repeatx\", \"repeaty\", \"norepeat\"");
      }
    }
    //--------------------------------------
    // PRIVATE INSTANCE METHODS
    //--------------------------------------
    private function init(obj):void {
      if (obj is BitmapData) {
        bitmap.bitmapData = obj;
        if(performanceMode){
          drawBigBg()
        }else{
          resize();
        }
      } else if (obj is String) {
        var url:URLRequest = new URLRequest(obj);
        var loader:Loader = new Loader();
        loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loaderComplete);
        loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, loaderError);
        loader.load(url);
      } else {
        throw new Error("Problem : First parameter obj must be a string \"url path_to_image\" or bitmapData.");
      }
    }
    private function loaderComplete(event:Event):void {
      bitmap.bitmapData = Bitmap(event.target.content).bitmapData;
        if(performanceMode){
          drawBigBg()
        }else{
          resize();
        }
    }

    private function loaderError(event:Event):void {
      throw new Error("Problem : There was an error accessing the image file.");
    }
    private function drawBigBg():void{
      sg.clear()
      sg.beginBitmapFill(bitmap.bitmapData);
      sg.drawRect(0, 0, Capabilities.screenResolutionX*1.25, Capabilities.screenResolutionY*1.25);
      sg.endFill();
    }

    //--------------------------------------
    // MAIN RESIZE METHOD
    //--------------------------------------
    private function resize(event:Event = null):void {
      if(performanceMode){
        return;
      }
      switch (repeatDir) {
        case "repeat" :
          sg.clear()
          sg.beginBitmapFill(bitmap.bitmapData);
          sg.drawRect(0, 0, stageInstance.stageWidth, stageInstance.stageHeight);
          sg.endFill();
          break;
        case "repeatx" :
          sg.clear()
          sg.beginBitmapFill(bitmap.bitmapData);
          sg.drawRect(0, 0, stageInstance.stageWidth, bitmap.height);
          sg.endFill();
          break;
        case "repeaty" :
          sg.clear()
          sg.beginBitmapFill(bitmap.bitmapData);
          sg.drawRect(0, 0, bitmap.width, stageInstance.stageHeight);
          sg.endFill();
          break;
        case "norepeat" :
          sg.clear()
          sg.beginBitmapFill(bitmap.bitmapData);
          sg.drawRect(0, 0, bitmap.width, bitmap.height);
          sg.endFill();
          break;
        default :
          sg.clear()
          sg.beginBitmapFill(bitmap.bitmapData);
          sg.drawRect(0, 0, stageInstance.stageWidth, stageInstance.stageHeight);
          sg.endFill();
          break;
      }
      this.x = this.y = 0;
    }
    //--------------------------------------
    // PUBLIC INSTANCE METHODS
    //--------------------------------------
    /**
      * This function will remove any current tiles and remove the Event.RESIZE event listener. This function is called automatically when the class detects a
      * Event.REMOVED_FROM_STAGE event.
      * @return void
      */
    public function killBg(event:Event = null):void {
      stageInstance.removeEventListener(Event.RESIZE, resize);
      stageInstance.removeEventListener(Event.REMOVED_FROM_STAGE, killBg);
      bitmap.bitmapData.dispose();
    }
  }

}