// Globals
var _g_image_cache = new ImageCache();
var _g_image_group = null;


// Top-level methods to provide cache access without
// the need to refer explicitly to global variables
function LoadGroup(group)
{
   _g_image_cache.LoadGroup(group);
}

function GetImage(name)
{
   return _g_image_cache.GetImage(name);
}
		
function loadImage_callback()
{
   // The loading state of some image has just updated
   var obj = event.srcElement;
   var group = _g_image_group;

   // If the image has just loaded, update the count
   if (obj.readyState == "complete")
      group.numLoaded ++;
	
   // Call imageupdate handler on group, if specified;
   // otherwise call imageupdate handler on document
   if (group.imageupdate)
      eval("group.imageupdate(group)");
   else if (document.imageupdate)
      eval("document.imageupdate(group)");

   // If there are still images to load, schedule another callback
   // (condition isn't strictly necessary, since "complete" is the
   // final stage of loading, therefore when an image is "complete"
   // it won't fire further readystatechange events)
   if (group.numLoaded != group.numToLoad)
      obj.onreadystatechange = loadImage_callback;
}

function ImageGroup()
{
   this.AddImage = _addImage;
   this.IsComplete = _isComplete;
   this.imageupdate = null;

   this.items = new Array();
   this.numLoaded = 0;
   this.numToLoad = 0;

   return this;
}

function _addImage(path)
{
   this.items[ this.items.length ] = path;
}

function _isComplete()
{
   return this.numLoaded == this.numToLoad;
}

function ImagePair( _file )
{
   // The ImagePair object's purpose is to
   // keep track of the image and the file that identifies it;
   // we do this because the image's src attribute will read back
   // as uuencoded if interrogated, meaning that, to see if a
   // particular image exists in the cache, we need to uuencode
   // again. It seems easier just to store the path in unencoded
   // form, along with the image associated with it.
   this.file = _file;
   this.image = new Image();
	
   // Add the image to the document; if you don't, readystatechange
   // events won't know where they originated, meaning that
   // event.srcElement will be null
   document.appendChild(this.image);
}

function ImageCache()
{
   this.LoadGroup = _loadGroup;
   this.GetImage = _getImage;

   this.items = new Array();
   return this;
}
	
function _loadGroup( group )
{
   // If there aren't any images to load, do nothing
   if (group.items.length == 0)
      return;
	
   // Set the active group
   _g_image_group = group;
	
   // Reset the count of loaded images and images to load
   group.numLoaded = 0;
   group.numToLoad = group.items.length;

   // num_loaded, like group.numLoaded, is the count of images
   // in the group that have completed loading. However, we
   // only update group.numLoaded after having kicked off all
   // the new images we want to load. Otherwise race conditions
   // can lead to imageupdate getting called more than once after
   // all the images are loaded.
   var num_loaded = 0;
	
   // Add any of the images to the cache if they don't yet exist
   for (i = 0; i < group.numToLoad; i ++)
   {
      var count = this.items.length;
	
      for (j = 0; j < count; j++)
      {
         if (this.items[j].file.indexOf(group.items[i]) != -1)
         {
            break;
         }
      }
		
      // Did we find it?
      if (j == count)
      {
         // No, so add it and start loading. Assignment order is
         // critical in the next few lines. Ensure the image is
         // added to the cache before setting its .src attribute;
         // otherwise for a short time an image group may affirm
         // itself "loaded" before all its elements exist in
         // the cache
         var pair = new ImagePair(group.items[i]);
         this.items[this.items.length] = pair;
         (pair.image).onreadystatechange = loadImage_callback;
         pair.image.src = group.items[i];
      }
      else
      {
         // Yes, but check whether it's finished loading
         if (this.items[j].image.readyState == "complete")
         {
            num_loaded ++;
         }
      }
   }
	
   // Check whether the group has already completely loaded
   if (num_loaded == group.numToLoad)
   {
      // Yes it has; it's safe to set group.numLoaded now,
      // because we know, since all the images are fuly loaded,
      // there won't be any more readystatechange events
      group.numLoaded = num_loaded;

      // Invoke the group's update handler, if specified;
      // otherwise invoke the document's update handler
      if (group.imageupdate)
         eval("group.imageupdate(group)");
      else if (document.imageupdate)
         eval("document.imageupdate(group)");
   }
	
   // We can now throw away num_loaded; its only purpose was to
   // see if everything was already loaded, since, if it was, no
   // readystatechange events would be generated, and therefore
   // no imageupdate events, and therefore no notification that
   // loading was already complete. We do NOT want to update
   // group.numLoaded, since num_loaded may already be out of date
}

function _getImage( name )
{
   // Method to retrieve an existing image from the cache;
   // returns null if the image could not be found
   for (i = 0; i < this.items.length; i ++)
   {
      if (this.items[i].file.indexOf(name) != -1)
         return this.items[i].image;
   }

   return null;
}