fixes

haxework/gui/GuiBuilder.hx

@@ -39,7 +39,7 @@ class GuiBuilder {
     }
   }
 
-  private static function fill(object:Dynamic, data:Dynamic, ?links:Dynamic):Void {
+  public static function fill(object:Dynamic, data:Dynamic, ?links:Dynamic):Void {
     var fields:Array<String> = Reflect.fields(data);
     for (field in fields) {
       var value:Dynamic = Reflect.field(data, field);

haxework/gui/LabelView.hx

@@ -6,6 +6,7 @@ class LabelView extends TextView {
 
   public function new() {
     super();
+    textField.selectable = false;
     textField.autoSize = TextFieldAutoSize.LEFT;
   }
 

haxework/gui/TextView.hx

@@ -29,7 +29,7 @@ class TextView extends SpriteView implements ITextView<Sprite, TextField> {
   private function set_text(value:String):String {
     if (text != value) {
       text = value;
-      textField.text = text;
+      //textField.text = text;
       invalidate();
     }
     return text;
@@ -72,6 +72,7 @@ class TextView extends SpriteView implements ITextView<Sprite, TextField> {
 
   override public function update():Void {
     textField.setTextFormat(textFormat);
+    if (text != null) textField.text = text;
     if (contentSize && !Std.is(skin, ISize)) {
       width = textField.width;
       height = textField.height;

haxework/net/BaseLoader.hx

@@ -8,6 +8,8 @@ import haxework.net.ILoader.Method;
 
 class BaseLoader<T> implements ILoader<T> {
 
+  private static inline var TAG:String = "Loader";
+
   public static var urlProcessors(default, null):Array<String->String> = new Array<String->String>();
   public static function prepareUrl(url:String):String { for (p in urlProcessors) url = p(url); return url; };
 
@@ -28,7 +30,7 @@ class BaseLoader<T> implements ILoader<T> {
     this.data = data;
     callback = new Callback<T>();
     var url:String = this.url;
-    //trace(prepareUrl(url));
+    L.d(TAG, "Request: " + prepareUrl(url));
     internalRequest(prepareUrl(url));
     return callback;
   }

haxework/net/callback/Callback.hx

@@ -25,6 +25,7 @@ class Callback<T> implements ICallback<T> {
     } catch (error:Dynamic) {
       callFail(error);
     }
+    dispose();
   }
 
   public function callSuccessAsync(data:T):Void {
@@ -39,6 +40,7 @@ class Callback<T> implements ICallback<T> {
     } catch (error:Dynamic) {
       L.d("Callback", "", error);
     }
+    dispose();
   }
 
   public function callFailAsync(error:Dynamic):Void {

haxework/net/order/IOrderSupplier.hx

@@ -0,0 +1,8 @@
+package haxework.net.order;
+
+import haxework.net.callback.ICallback;
+
+interface IOrderSupplier {
+  public function request<T>(url:String, clazz:Class<T>):ICallback<T>;
+  public function release(url:String):Void;
+}

haxework/net/order/OrderSupplier.hx

@@ -0,0 +1,96 @@
+package haxework.net.order;
+
+import Lambda;
+import haxework.net.callback.Callback;
+import Type.ValueType;
+import com.abit.umix.prepare.AutoCallback;
+import flash.display.BitmapData;
+import haxework.net.callback.ICallback;
+
+typedef Order<T> = {
+  var id:String;
+  var data:Null<T>;
+  var callbacks:Array<ICallback<T>>;
+  var clients:Int;
+}
+
+class OrderSupplier implements IOrderSupplier {
+
+  private static inline var TAG:String = "OrderSupplier";
+
+  private var orders:Map<String, Order<Dynamic>>;
+
+  public function new() {
+    orders = new Map<String, Order<Dynamic>>();
+  }
+
+  public function request<T>(url:String, clazz:Class<T>):ICallback<T> {
+    if (orders.exists(url)) {
+      var order:Order<T> = orders.get(url);
+      order.clients++;
+      //L.d(TAG, "Request(" + order.clients + "): " + url);
+      if (order.data == null) {
+        var callback:ICallback<T> = new Callback<T>();
+        order.callbacks.push(callback);
+        return callback;
+      } else {
+        return AutoCallback.success(order.data);
+      }
+    } else {
+      var callback:ICallback<T> = new Callback<T>();
+      var order:Order<T> = {
+        id:url,
+        data:null,
+        callbacks:[callback],
+        clients:1
+      }
+      //L.d(TAG, "Request(" + order.clients + "): " + url);
+      orders.set(url, order);
+      var loader:ILoader<T> = buildLoader(clazz);
+      loader.GET(url)
+        .success(function(data:T):Void {
+          if (orders.exists(url)) {
+            var order:Order<T> = orders.get(url);
+            order.data = data;
+            for (callback in order.callbacks) callback.callSuccess(data);
+            order.callbacks = [];
+          }
+        })
+        .fail(function(error:Dynamic):Void {
+          if (orders.exists(url)) for (callback in orders.get(url).callbacks) callback.callFail(error);
+          orders.remove(url);
+        });
+      return callback;
+    }
+  }
+
+  public function release(url:String):Void {
+    if (orders.exists(url)) {
+      var order:Order<Dynamic> = orders.get(url);
+      if (--order.clients <= 0) {
+        var data:Dynamic = order.data;
+        if (Std.is(data, BitmapData)) {
+          cast(data, BitmapData).dispose();
+        }
+        orders.remove(url);
+      }
+      //L.d(TAG, "Release(" + order.clients + "): " + url);
+      //log();
+    }
+  }
+
+  private function buildLoader<T>(clazz:Class<T>):ILoader<T> {
+    var c:Class<Dynamic> = clazz;
+    return if (c == BitmapData) {
+      untyped new ImageLoader();
+    } else {
+      throw "Unsupported order: " + c;
+    }
+  }
+
+  private function log():Void {
+    L.d(TAG, "\n" + Lambda.map(orders, function(order:Order<Dynamic>):String {
+      return "(" + order.clients + ") " + order.id;
+    }).join("\n"));
+  }
+}