Is there a simpler way to manage multiple sizes (dimensions) of Bitmaps?

Question

I have a custom Image class that I am using to store individual image information for a gallery application:

package mtm.test
{
 public class Image extends Object
 {
  public var id:int;
  public var filename:String;
  public var title:String;
  public var description:String;

  public var thumbExists:int;
  public var mediumExists:int;
  public var fullExists:int;
 }
}

To manage three different sizes of Bitmaps, I have created the following base class (BitmapType) and three sub-classes (BitmapThumbnail, BitmapMediumSize, BitmapFullSize):

package mtm.test 
 {
  import flash.display.Bitmap;
  import flash.display.BitmapData;
  public class BitmapType extends Bitmap
  {
   public function BitmapType(bitmapData:BitmapData = null, pixelSnapping:String = 'auto', smoothing:Boolean = false)
   {
    super(bitmapData, pixelSnapping, smoothing);
   }
  }
 }

 package mtm.test 
 {
  import flash.display.BitmapData;
  public class BitmapFullSize extends BitmapType 
  { 
   public function BitmapFullSize(bitmapData:BitmapData = null, pixelSnapping:String = 'auto', smoothing:Boolean = false)
   {
    super(bitmapData, pixelSnapping, smoothing);
   }
  }
 }

 package mtm.test 
 {
  import flash.display.BitmapData;
  public class BitmapMediumSize extends BitmapType 
  { 
   public function BitmapMediumSize(bitmapData:BitmapData = null, pixelSnapping:String = 'auto', smoothing:Boolean = false)
   {
    super(bitmapData, pixelSnapping, smoothing);
   }
  }
 }

 package mtm.test 
 {
  import flash.display.BitmapData;
  public class BitmapThumbnail extends BitmapType 
  {
   public function BitmapThumbnail(bitmapData:BitmapData = null, pixelSnapping:String = 'auto', smoothing:Boolean = false)
   {
    super(bitmapData, pixelSnapping, smoothing);
   }
  }
 }

This is how I would implement the above:

var image:Image = new Image();

//I would be loading external bitmaps but for the example I'll just create new ones:
image[BitmapThumbnail] = new BitmapThumbnail(new BitmapData(65,65,false,0x000000));
image[BitmapMediumSize] = new BitmapMediumSize(new BitmapData(200,200,false,0x000000));
image[BitmapFullSize] = new BitmapFullSize(new BitmapData(500,500,false,0x000000));

Is there a simpler way to do this? I feel that there is a lot of repeated code within the BitmapType sub-classes.

At the least, this helps to avoid a bunch of for loops trying to find the requested size, and it seems portable to situations where more or less sizes of Bitmaps are required.

Answer 1

you could simply use a cache and have it filled on demand. here's a sketch:

class Image {
    var url:String;
    //... other stuff
    var cache:Object = {};
    function getImage(size:int, onDone:Function, onProgress:Function = null, onError:Function = null):void {
        if (onProgress == null) onProgress = function (loaded:int, total:int):void {};
        var cached:* = this.cache[size];
        if (cache == null) {
            var l:Loader = new Loader();
                    var req:URLRequest = new URLRequest(url)
            //add parameters here, depending on size
            l.load();
            l.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, function (e:IOErrorEvent):void {
                onError(cache[size] = e);
            });
            l.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, function (p:ProgressEvent):void {
                onProgress(p.byteLoaded, p.byteTotal);
            });
            l.contentLoaderInfo.addEventListener(Event.COMPLETE, function (e:Event):void {
                onDone(cache[size] = l.content);
            });
        }
        else if (cache is DisplayObject) {
            onDone(cache);
        }
        else onError(cache);
    }
}

hypothetical example usage:

myImage.getImage(ImageSize.THUMB, displayImage, updateLoader, displayBroken);