as3: reloading an image

Question

I have an image that I am attempting to load, and then reload. Here is my code for the loading of the image:

    public function loadImage(url:String, _w:int, _h:int):void 
    {   
        this._stwidth = _w;
        this._stheight = _h;
        this._imageURL = url;

        if(!_imageURL)
        {
            return;
        }

        this.alpha = 1.0;   //need this because we might have just faded the image out

        _ldr.alpha = 0.0;
        _prog.alpha = 1.0;
        _sqr.alpha = 0.0;
        _sqr.graphics.clear();

        if(_hasLoaded) 
        {
            try
            {
                _ldr.close();
                _ldr.unload();                  
            }
            catch(e:Error)
            {
                //trace("bmdisplay has loaded once, but there was an error: " + e.message);
            }           
        }

        _ldr.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, onProgress);
        _ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, onComplete);
        _ldr.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onError);
        _ldr.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
        _ldr.contentLoaderInfo.addEventListener(Event.INIT, onOpen);
        _ldr.load(new URLRequest(_imageURL));
    }

For some reason, this code will not load the image without issuing an Error upon the 2nd load. Can someone please help me figure this out?

I am totally lost on why my variable _asLoaded would do me wrong. I have an onComplete() handler, which sets that var to true, and I never set it to false after that.

I don't know what else I should be trying...

Thanks

Answer 1

Sometimes back I wrote a helper class to achieve something similar. The helper class extends Loader and provides automatic scaling of image. Here is the code for that class:

package {

  import flash.display.Loader;
  import flash.geom.Rectangle;
  import flash.net.URLRequest;
  import flash.events.Event;
  import flash.events.IOErrorEvent;
  import flash.events.SecurityErrorEvent;
  public class ImageLoader extends Loader {
    private var _imageURL:String;            // URL of image
    private var _imageBoundary:Rectangle;    // boundary rectangle for the image
    private var _loaded:Boolean;            // flag which tells whether image is loaded or not.
    private var _isLoading:Boolean;         // flag which say if any loading is in progress
    //Constructor function, which calls Loader's constructor
    // and loads and resize the image
    public function ImageLoader(url:String = null, rect:Rectangle = null):void {
      super();
      _imageURL = url;
      _imageBoundary = rect;
      _loaded = false;
      _isLoading = false;
      loadImage();
    }
    // sets the image for the loader and loads it
    public function set imageURL(url:String):void {
      _imageURL = url;
      loadImage();
    }
    // sets the boundary of the image and resizes it
    public function set boundary(rect:Rectangle):void {
      _imageBoundary = rect;
      resizeImage();
    }
    private function removeListeners():void {
      this.contentLoaderInfo.removeEventListener(Event.COMPLETE, onComplete);
      this.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR, onError);
      this.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
    }
    private function onComplete(e:Event):void {
      _loaded = true;
      _isLoading = false;
      removeListeners();
      resizeImage();
    }
    //In case of error, we are not propogating the event
    private function onError(e:Event):void {
      e.stopImmediatePropagation();
      removeListeners();
    }
    // real loading goes here
    // it first closes and unloads the loader and
    // then loads the image
    private function loadImage():void {
      if (_isLoading) {
        trace("Some loading is in progess");
        return;
      }
      try {
        this.close();
        this.unload();
      }
      catch(e:Error) {
        //discarded
      }
      if (!_imageURL)
        return;
      _loaded = false;
      _isLoading = true;
      this.contentLoaderInfo.addEventListener(Event.COMPLETE, onComplete);
      this.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onError);
      this.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
      this.load(new URLRequest(_imageURL));
    }
    // standard resizing function for image so that it's
    // aspect ratio is maintained.
    private function resizeImage():void {
      if (!_imageBoundary || !_loaded)
        return;
      var aspect:Number = width / height;
      var cAspect:Number = _imageBoundary.width / _imageBoundary.height;
      if (aspect <= cAspect) {
        this.height = _imageBoundary.height;
        this.width = aspect * this.height;
      }
      else {
        this.width = _imageBoundary.width;
        this.height = this.width / aspect;
      }
      this.x = (_imageBoundary.width-this.width)/2 + _imageBoundary.x;
      this.y = (_imageBoundary.height-this.height)/2 + _imageBoundary.y;
    }
  }
}

And you can use it like this:

var _imageLoader:ImageLoader = new ImageLoader();
_imageLoader.imageURL = "http://some-image-url";
_imageLoader.boundary = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight); // or whatever suits you

ImageLoader extends Loader class so you can listen to all the Events dispatches by Loader class. Hope it helps.

Answer 2

Try instantiating new Loader, probably trying to recycle it is giving you the problem

Answer 3

i would declare _ldr inside the function so its dead every time you start this function. and i also would not use this unload() and close() methods. its much simpler if make some thing like this (you need to have a empty movieclip called "ldrHelper"):

public function loadImage(url:String, _w:int, _h:int):void 
{
    // do your job and die bravely, no need to be global 
    var _ldr:Loader = new Loader();
    this._stwidth = _w;
    this._stheight = _h;
    this._imageURL = url;

    if(!_imageURL)
    {
        return;
    }

    this.alpha = 1.0;   //need this because we might have just faded the image out

    // now you will need to make alpha = 1 on ldrHolder since _ldr is dead after this function
    ldrHolder.alpha = 0.0;
    _prog.alpha = 1.0;
    _sqr.alpha = 0.0;
    _sqr.graphics.clear();


   // remove the old image, doesn't matter whether its empty or not
   while(ldrHolder.numChildren > 0){
         ldrHolder.removeChildAt(0);
   }

    //add image
    ldrHolder.addChild(_ldr);

    _ldr.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, onProgress);
    _ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, onComplete);
    _ldr.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onError);
    _ldr.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onError);
    _ldr.contentLoaderInfo.addEventListener(Event.INIT, onOpen);
    _ldr.load(new URLRequest(_imageURL));
}