Fix Animate generated class inclusion and duplicate runtime resolution

scripts/Tools.hx

@@ -55,6 +55,67 @@ class Tools
 	private static var targetDirectory:String;
 	private static var targetFlags:Map<String, String>;
 
+	private static function readGeneratedClassesFile(path:String):Array<String>
+	{
+		if (path == null || !FileSystem.exists(path))
+		{
+			return null;
+		}
+
+		var generatedClasses = [];
+		for (line in File.getContent(path).split("\n"))
+		{
+			var className = StringTools.trim(line);
+			if (className != "" && !StringTools.startsWith(className, "#"))
+			{
+				generatedClasses.push(className);
+			}
+		}
+
+		return generatedClasses;
+	}
+
+	private static function writeGeneratedClassesCache(path:String, generatedClasses:Array<String>):Void
+	{
+		if (path == null)
+		{
+			return;
+		}
+
+		File.saveContent(path, generatedClasses.join("\n"));
+	}
+
+	private static function deleteGeneratedClassFiles(targetPath:String, classNames:Array<String>):Void
+	{
+		if (targetPath == null || classNames == null)
+		{
+			return;
+		}
+
+		for (className in classNames)
+		{
+			if (className == null || className == "")
+			{
+				continue;
+			}
+
+			var classPath = Path.combine(targetPath, className.split(".").join("/") + ".hx");
+
+			if (FileSystem.exists(classPath))
+			{
+				FileSystem.deleteFile(classPath);
+			}
+		}
+	}
+
+	private static function pushUniqueHaxeflag(output:HXProject, value:String):Void
+	{
+		if (value != null && output.haxeflags.indexOf(value) == -1)
+		{
+			output.haxeflags.push(value);
+		}
+	}
+
 	#if neko
 	public static function __init__()
 	{
@@ -996,7 +1057,7 @@ class Tools
 
 					for (className in generatedClasses)
 					{
-						output.haxeflags.push(className);
+						pushUniqueHaxeflag(output, className);
 					}
 				}
 
@@ -1018,11 +1079,14 @@ class Tools
 				var cacheAvailable = false;
 				var cacheDirectory = null;
 				var cacheFile = null;
+				var generatedClassesFile = null;
+				var cachedGeneratedClasses:Array<String> = null;
 
 				if (targetDirectory != null)
 				{
 					cacheDirectory = targetDirectory + "/obj/libraries";
 					cacheFile = cacheDirectory + "/" + library.name + ".zip";
+					generatedClassesFile = cacheDirectory + "/" + library.name + ".classes.txt";
 
 					if (FileSystem.exists(cacheFile))
 					{
@@ -1036,6 +1100,16 @@ class Tools
 						}
 					}
 
+					if (cacheAvailable && library.generate != false)
+					{
+						cachedGeneratedClasses = readGeneratedClassesFile(generatedClassesFile);
+
+						if (cachedGeneratedClasses == null)
+						{
+							cacheAvailable = false;
+						}
+					}
+
 					if (!cacheAvailable)
 					{
 						if (cacheDirectory != null)
@@ -1056,6 +1130,7 @@ class Tools
 						if (library.generate != false)
 						{
 							var targetPath:String;
+							var previousGeneratedClasses = readGeneratedClassesFile(generatedClassesFile);
 
 							if (project.target == IOS)
 							{
@@ -1067,26 +1142,42 @@ class Tools
 							}
 
 							var generatedClasses = exporter.generateClasses(targetPath, output.assets, library.prefix);
+							var generatedLookup = new Map<String, Bool>();
+
+							for (className in generatedClasses)
+							{
+								generatedLookup.set(className, true);
+							}
+
+							if (previousGeneratedClasses != null)
+							{
+								var removedGeneratedClasses = [];
 
-							// for (className in generatedClasses)
-							// {
-							// 	output.haxeflags.push(className);
-							// }
+								for (className in previousGeneratedClasses)
+								{
+									if (!generatedLookup.exists(className))
+									{
+										removedGeneratedClasses.push(className);
+									}
+								}
 
-							// if (cacheDirectory != null)
-							// {
-							// 	File.saveContent(cacheDirectory + "/classNames.txt", generatedClasses.join("\n"));
-							// }
+								deleteGeneratedClassFiles(targetPath, removedGeneratedClasses);
+							}
+
+								for (className in generatedClasses)
+								{
+									pushUniqueHaxeflag(output, className);
+								}
+
+							writeGeneratedClassesCache(generatedClassesFile, generatedClasses);
 						}
 					}
-					else
+					else if (library.generate != false && cachedGeneratedClasses != null)
 					{
-						// var generatedClasses = File.getContent(cacheDirectory + "/classNames.txt").split("\n");
-
-						// for (className in generatedClasses)
-						// {
-						// 	output.haxeflags.push(className);
-						// }
+						for (className in cachedGeneratedClasses)
+						{
+							pushUniqueHaxeflag(output, className);
+						}
 					}
 
 					var asset = new Asset(cacheFile, "lib/" + library.name + ".zip", AssetType.BUNDLE);

src/swf/exporters/animate/AnimateBitmapSymbol.hx

@@ -1,5 +1,6 @@
 package swf.exporters.animate;
 
+import swf.utils.SymbolUtils;
 import openfl.display.Bitmap;
 import openfl.display.BitmapData;
 import openfl.display.PixelSnapping;
@@ -14,6 +15,9 @@ class AnimateBitmapSymbol extends AnimateSymbol
 	public var path:String;
 	public var smooth:Null<Bool>;
 
+	private var resolvedSymbolType:Class<Dynamic>;
+	private var resolvedSymbolTypeReady = false;
+
 	public function new()
 	{
 		super();
@@ -22,9 +26,53 @@ class AnimateBitmapSymbol extends AnimateSymbol
 	private override function __createObject(library:AnimateLibrary):Bitmap
 	{
 		#if lime
-		return new Bitmap(BitmapData.fromImage(library.getImage(path)), PixelSnapping.AUTO, smooth != false);
+		return new Bitmap(__createBitmapData(library), PixelSnapping.AUTO, smooth != false);
 		#else
 		return null;
 		#end
 	}
+
+	private function __createBitmapData(library:AnimateLibrary):BitmapData
+	{
+		var symbolType = __resolveSymbolType();
+
+		if (symbolType != null)
+		{
+			AnimateGeneratedTypeContext.setBitmap(library, this);
+
+			try
+			{
+				var bitmapData:BitmapData = cast Type.createInstance(symbolType, []);
+				AnimateGeneratedTypeContext.clearBitmapIfMatches(library, this);
+				if (bitmapData != null)
+				{
+					return bitmapData;
+				}
+			}
+			catch (e:Dynamic)
+			{
+				AnimateGeneratedTypeContext.clearBitmap();
+				throw e;
+			}
+		}
+
+		return BitmapData.fromImage(library.getImage(path));
+	}
+
+	private function __resolveSymbolType():Class<Dynamic>
+	{
+		if (className == null)
+		{
+			return null;
+		}
+
+		if (resolvedSymbolTypeReady)
+		{
+			return resolvedSymbolType;
+		}
+
+		resolvedSymbolType = Type.resolveClass(SymbolUtils.formatClassName(className));
+		resolvedSymbolTypeReady = true;
+		return resolvedSymbolType;
+	}
 }

src/swf/exporters/animate/AnimateButtonSymbol.hx

@@ -65,11 +65,18 @@ class AnimateButtonSymbol extends AnimateSymbol
 
 			if (symbolType != null)
 			{
-				simpleButton = Type.createInstance(symbolType, []);
-			}
-			else
-			{
-				// Log.warn ("Could not resolve class \"" + symbol.className + "\"");
+				AnimateGeneratedTypeContext.setButton(library, this);
+
+				try
+				{
+					simpleButton = Type.createInstance(symbolType, []);
+					AnimateGeneratedTypeContext.clearButtonIfMatches(library, this);
+				}
+				catch (e:Dynamic)
+				{
+					AnimateGeneratedTypeContext.clearButton();
+					throw e;
+				}
 			}
 		}