/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package gwt.g2d.client.graphics;
import com.google.gwt.dom.client.ImageElement;
import com.google.gwt.resources.client.ClientBundle;
import gwt.g2d.resources.client.ExternalImageResource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* <p>
* Provides a mechanism for deferred execution of a callback
* method once all specified Images are loaded.
* <p>
* This class may be deprecated in future release. Considers using
* {@link ClientBundle} with {@link ExternalImageResource} instead.
* <p>
* If dynamic image loading is required, please consider using
* {@link gwt.g2d.resources.client.ImageLoader} instead of this one.
* <p>
* (This is a slightly modified by hao1300@gmail.com from the GWT-incubator's
* ImageLoader to provide a more flexible loading scheme.)
*/
public class ImageLoader {
/**
* Interface to allow anonymous instantiation of a CallBack
* Object with method that gets invoked when all the images
* are loaded.
*/
public interface CallBack {
void onImagesLoaded(ImageElement[] imageElements);
}
/**
* Static internal collection of ImageLoader instances.
* ImageLoader is not instantiable externally.
*/
private static Set<ImageLoader> imageLoaders = new HashSet<ImageLoader>();
/**
* Takes in an url String corresponding to the image needed to be loaded.
* The onImagesLoaded() method in the specified CallBack
* object is invoked with an array of ImageElements corresponding to
* the where the first element of the array is the image requested.
*
* @param url Array of urls for the images that need to be loaded
* @param cb CallBack object
*/
public static void loadImages(String url, CallBack cb) {
ImageLoader il = new ImageLoader();
il.finalize(cb);
ImageLoader.imageLoaders.add(il);
il.totalImages = 1;
ImageElement imageElement = il.prepareImage();
il.images.add(imageElement);
imageElement.setSrc(url);
}
/**
* Takes in an array of url Strings corresponding to the images needed to
* be loaded. The onImagesLoaded() method in the specified CallBack
* object is invoked with an array of ImageElements corresponding to
* the original input array of url Strings once all the images report
* an onload event.
*
* @param urls Array of urls for the images that need to be loaded
* @param cb CallBack object
*/
public static void loadImages(String[] urls, CallBack cb) {
loadImages(Arrays.asList(urls), cb);
}
/**
* Takes in a list of url Strings corresponding to the images needed to
* be loaded. The onImagesLoaded() method in the specified CallBack
* object is invoked with a list of ImageElements corresponding to
* the original input list of url Strings once all the images report
* an onload event.
*
* @param urls List of urls for the images that need to be loaded
* @param cb CallBack object
*/
public static void loadImages(List<String> urls, CallBack cb) {
ImageLoader il = new ImageLoader();
il.finalize(cb);
ImageLoader.imageLoaders.add(il);
il.totalImages = urls.size();
for (String url : urls) {
ImageElement imageElement = il.prepareImage();
il.images.add(imageElement);
imageElement.setSrc(url);
}
}
private CallBack callBack = null;
private List<ImageElement> images = new ArrayList<ImageElement>();
private int loadedImages = 0;
private int totalImages = 0;
private ImageLoader() {
}
/**
* Invokes the onImagesLoaded method in the CallBack if all the
* images are loaded AND we have a CallBack specified.
*
* Called from the JSNI onload event handler.
*/
private void dispatchIfComplete() {
if (callBack != null && isAllLoaded()) {
callBack.onImagesLoaded(images.toArray(new ImageElement[0]));
// remove the image loader
ImageLoader.imageLoaders.remove(this);
}
}
/**
* Sets the callback object for the ImageLoader.
* Once this is set, we may invoke the callback once all images that
* need to be loaded report in from their onload event handlers.
*
* @param cb
*/
private void finalize(CallBack cb) {
this.callBack = cb;
}
private void incrementLoadedImages() {
this.loadedImages++;
}
private boolean isAllLoaded() {
return (loadedImages == totalImages);
}
/**
* Returns a handle to an img object. Ties back to the ImageLoader instance
*/
private native ImageElement prepareImage() /*-{
// if( callback specified )
// do nothing
var img = new Image();
var __this = this;
img.onload = function() {
if(!img.__isLoaded) {
// __isLoaded should be set for the first time here.
// if for some reason img fires a second onload event
// we do not want to execute the following again (hence the guard)
img.__isLoaded = true;
__this.@gwt.g2d.client.graphics.ImageLoader::incrementLoadedImages()();
img.onload = null;
// we call this function each time onload fires
// It will see if we are ready to invoke the callback
__this.@gwt.g2d.client.graphics.ImageLoader::dispatchIfComplete()();
} else {
// we invoke the callback since we are already loaded
__this.@gwt.g2d.client.graphics.ImageLoader::dispatchIfComplete()();
}
}
return img;
}-*/;
}