public override void ImportDependencies(SwfMovie from, SwfMovie to)
{
foreach (var tag in _tags)
{
tag.ImportDependencies(from, to);
}
}
public override void ImportDependencies(SwfMovie from, SwfMovie to)
{
var cid = CharId;
to.ImportCharacter(from, ref cid);
CharId = cid;
}
public static void LoadExclude(IDictionary filter, string path)
{
string ext = Utils.GetExt(path);
switch (ext)
{
case "abc":
{
var abc = new AbcFile(path);
AddExcludes(filter, abc);
}
break;
case "swf":
{
var swf = new SwfMovie(path);
var list = swf.GetAbcFiles();
foreach (var abc in list)
{
AddExcludes(filter, abc);
}
}
break;
case "swc":
{
var swc = new SwcFile(path);
foreach (var abc in swc.GetAbcFiles())
{
AddExcludes(filter, abc);
}
}
break;
}
}
public void DefineBitsLoseless()
{
var swf = new SwfMovie();
swf.SetDefaultBackgroundColor();
swf.SetFrameLabel("main");
var bmp = GetTestBitmap();
ushort cid = swf.DefineBitmap(bmp);
swf.ShowFrame();
var ms = new MemoryStream();
swf.Save(ms);
ms.Flush();
ms.Position = 0;
var swf2 = new SwfMovie(ms);
var bmp2 = swf2.GetBitmap(cid);
Assert.IsTrue(bmp.IsEqual(bmp2, true));
}
static void DumpSwfChars(SwfMovie swf, string dir)
{
swf.LinkAssets();
foreach (var tag in swf.Tags)
{
var sprite = tag as SwfSprite;
if (sprite != null)
{
}
else
{
var c = tag as ISwfCharacter;
if (c != null)
{
string name = c.CharacterId.ToString();
if (!string.IsNullOrEmpty(c.Name))
{
name += "_";
name += c.Name.ReplaceInvalidFileNameChars();
}
var data = tag.GetData();
data = TrimStart(data, 2);
Directory.CreateDirectory(dir);
string fname = Path.Combine(dir, name + ".bin");
File.WriteAllBytes(fname, data);
}
}
}
}
public static void SaveSwf(SwfMovie swf, string name)
{
string dir = Path.Combine(Root, "swf");
Directory.CreateDirectory(dir);
swf.Save(Path.Combine(dir, name));
}
private static void ResolveEmbed(SwfMovie lib, AbcInstance instance, AbcTrait trait)
{
if (instance.IsInterface)
{
return;
}
var superName = instance.BaseTypeName.FullName;
if (!superName.EndsWith("Asset") || IsAssetClass(instance))
{
return;
}
string className = instance.FullName;
var asset = lib.FindAsset(className);
if (asset == null)
{
CompilerReport.Add(Warnings.UnableFindSwfAsset, className);
return;
}
Embed.Apply(trait, asset, lib);
}
private ISwfCharacter ImportCharacter(SwfMovie from, SwfAsset asset)
{
var c = _charCache[asset.Name] as ISwfCharacter;
if (c != null)
{
return(c);
}
var tag = asset.Character as SwfTag;
CheckCharacter(tag);
var mytag = Swf.Import(from, tag);
CheckCharacter(mytag);
c = (ISwfCharacter)mytag;
if (asset.IsExported)
{
_exports.Add(c, asset.Name);
}
_charCache[asset.Name] = c;
return(c);
}
public void ImportDependencies(SwfMovie from, SwfMovie to)
{
if (Fill != null)
{
Fill.ImportDependencies(from, to);
}
}
void ResolveXmlDeps(SwfMovie lib)
{
CacheScripts(lib);
var abcFiles = lib.GetAbcFiles();
foreach (var abc in abcFiles)
{
AbcInstance defInstance = abc.Def;
if (defInstance == null)
{
continue;
}
var scriptElem = abc.SwcElement;
//if (_linker != null)
// _linker.LinkType(defInstance);
var depElems = GetElements(scriptElem, "dep");
foreach (var depElem in depElems)
{
string depID = depElem.GetAttribute("id");
string type = depElem.GetAttribute("type");
if (type == "n")
{
ResolveNamespace(defInstance, depID);
}
else
{
ResolveDefLink(defInstance, depID);
}
}
}
}
private void ProcessTraits(SwfMovie lib, AbcFile abc)
{
foreach (var instance in abc.Instances)
{
if (IsMixin(instance))
{
RegisterMixin(instance);
}
}
foreach (var trait in abc.GetTraits(AbcTraitOwner.Script))
{
if (trait.HasMetadata)
{
foreach (var e in trait.Metadata)
{
ProcessMeta(lib, trait, e);
}
}
if (trait.Kind == AbcTraitKind.Class && trait.Embed == null)
{
ResolveEmbed(lib, trait.Class.Instance, trait);
}
}
}
void CacheScripts(SwfMovie lib)
{
if (lib.SwcScriptsCached)
{
return;
}
lib.SwcScriptsCached = true;
var libElem = lib.SwcElement;
var scriptElems = GetElements(libElem, "script");
foreach (var scriptElem in scriptElems)
{
string scriptName = scriptElem.GetAttribute("name");
var abc = lib.FindAbc(scriptName);
if (abc == null)
{
throw new BadImageFormatException();
}
string defID = GetDefID(scriptElem);
string fn = ToFullName(defID);
abc.Def = abc.FindInstance(fn);
abc.SwcElement = scriptElem;
_defCache[defID] = abc;
}
}
public static void Apply(AbcTrait trait, SwfAsset asset, SwfMovie lib)
{
if (trait.Embed != null)
{
return;
}
var klass = trait.Class;
if (klass == null)
{
throw new InvalidOperationException("Embed can be applied to class trait only");
}
var instance = klass.Instance;
var embed = new Embed
{
Asset = asset,
Movie = lib,
Instance = instance
};
trait.Embed = embed;
trait.AssetInstance = instance;
}
public void ImportDependencies(SwfMovie from, SwfMovie to)
{
foreach (var style in this)
{
style.ImportDependencies(from, to);
}
}
private static IEnumerable <AbcFile> GetAbcFiles(string path)
{
string ext = Utils.GetExt(path);
if (ext == "abc")
{
var abc = new AbcFile(path);
var list = new List <AbcFile> {
abc
};
return(list);
}
if (ext == "swf")
{
var swf = new SwfMovie(path);
var list = swf.GetAbcFiles();
return(list);
}
if (ext == "swc")
{
var swc = new SwcFile(path);
var list = swc.GetAbcFiles();
return(list);
}
return(Enumerable.Empty <AbcFile>());
}
public static void MergeSwc(string path, string output)
{
var lib = path.ExtractSwfLibrary();
var mov = new SwfMovie(lib);
var list = mov.GetAbcFiles();
Merge(list, output);
}
static bool DumpMethod(string path, string method)
{
string ext = Utils.GetExt(path);
if (ext == "abc")
{
int index;
if (!int.TryParse(method, out index))
{
return(false);
}
var abc = new AbcFile(path);
return(DumpMethod(abc, index, path + "." + method + ".xml"));
}
if (ext == "swf")
{
int i = method.IndexOf('.');
if (i < 0)
{
return(false);
}
int frame;
if (!int.TryParse(method.Substring(0, i), out frame))
{
return(false);
}
int index;
if (!int.TryParse(method.Substring(i + 1), out index))
{
return(false);
}
if (frame < 0)
{
return(false);
}
if (index < 0)
{
return(false);
}
var swf = new SwfMovie(path);
var list = swf.GetAbcFiles();
if (frame >= list.Count)
{
return(false);
}
return(DumpMethod(list[frame], index, path + "." + method + ".xml"));
}
return(false);
}
public override void ImportDependencies(SwfMovie from, SwfMovie to)
{
if (HasCharacter)
{
to.ImportCharacter(from, ref _cid);
}
else
{
}
}
public void ImportDependencies(SwfMovie from, SwfMovie to)
{
foreach (var r in this)
{
var s = r as SwfShapeSetupRecord;
if (s != null && s.Styles != null)
{
s.Styles.ImportDependencies(from, to);
}
}
}
static void DumpSwfChars(string path)
{
string ext = Utils.GetExt(path);
if (ext == "swf")
{
var swf = new SwfMovie(path,
SwfTagDecodeOptions.DonotDecodeCharacters
| SwfTagDecodeOptions.DonotDecodeSprites);
DumpSwfChars(swf, path + ".chars");
return;
}
}
private static void SWF_CreateMovingRectangles()
{
var swf = new SwfMovie();
swf.SetBackgroundColor(Color.LightSteelBlue);
var g = swf.Graphics;
g.DrawRectangle(Pens.Black, 100, 100, 100, 100);
g.FillRectangle(Brushes.Red, 100, 250, 100, 100);
var r = new RectangleF(100, 400, 100, 100);
var lg = new LinearGradientBrush(r, Color.Lime, Color.Yellow, LinearGradientMode.Horizontal);
g.FillRectangle(lg, r);
r = new RectangleF(250, 100, 200, 250);
lg = CreateGradient(r, Color.Purple, Color.Blue, Color.Cyan, Color.Green, Color.Yellow, Color.Orange, Color.Red);
g.FillRectangle(lg, r);
r = new RectangleF(500, 100, 200, 250);
var bmp = typeof(QA).GetImageResource("images.bg5.jpg");
var tb = new TextureBrush(bmp);
g.FillRectangle(tb, r);
swf.ShowFrame();
int n = 6;
for (int i = 0; i < 100; ++i)
{
for (int id = 1; id <= n; ++id)
{
swf.MoveObject((ushort)id, i, 0);
}
swf.ShowFrame();
}
for (int i = 100; i >= 0; --i)
{
for (int id = 1; id <= n; ++id)
{
swf.MoveObject((ushort)id, i, 0);
}
swf.ShowFrame();
}
QA.SaveSwf(swf, "MovingRectangles.swf");
}
static void RemoveExports(string path)
{
var swf = new SwfMovie();
swf.Load(path, SwfTagDecodeOptions.DonotDecodeTags);
for (int i = 0; i < swf.Tags.Count; ++i)
{
var tag = swf.Tags[i];
if (tag.TagCode == SwfTagCode.ExportAssets)
{
swf.Tags.RemoveAt(i);
--i;
}
}
swf.Save(path + ".noexports.swf");
}
public static string RunSwfTestCase(string name, Stream input)
{
var list = SwfMovie.GetRawAbcFiles(input);
int n = list.Count;
for (int i = 0; i < n; ++i)
{
var data = list[i];
string err = Test(name, data);
if (!string.IsNullOrEmpty(err))
{
return(err);
}
}
return(null);
}
private static void WriteAssets(TextWriter writer, string header, SwfMovie swf, IEnumerable <SwfAsset> assets)
{
bool h = true;
foreach (var asset in assets)
{
if (h)
{
writer.WriteLine("-------------------------------------------------");
writer.WriteLine(header);
writer.WriteLine("-------------------------------------------------");
h = false;
}
DumpAsset(writer, swf, asset);
}
}
public SwfMovie GetLibrary(string name)
{
InitLibElems();
if (string.IsNullOrEmpty(name))
{
name = LIBRARY_SWF;
}
var libElem = _libElems[name];
if (libElem == null)
{
name = name + ".swf";
libElem = _libElems[name];
}
if (libElem == null)
{
throw new ArgumentException(string.Format("Unable to find library {0}", name));
}
var lib = _libs[name];
if (lib != null)
{
return(lib);
}
var stream = _zip.ExtractEntry(name);
if (stream == null)
{
return(null);
}
lib = new SwfMovie();
lib.Load(stream, _tagDecodeOptions);
lib.Index = _libs.Count;
lib.Name = name;
lib.Swc = this;
lib.SwcElement = libElem;
_libs.Add(lib);
//CacheScripts(lib);
return(lib);
}
static void BuildTypeRefs(File f, SwfMovie lib, AbcFile abc, ITypeResolver resolver)
{
int n = abc.Multinames.Count;
for (int i = 1; i < n; ++i)
{
var mn = abc.Multinames[i];
if (mn.IsRuntime)
{
continue;
}
foreach (var fullName in mn.GetFullNames())
{
if (string.IsNullOrEmpty(fullName))
{
continue;
}
var type = resolver.Resolve(fullName);
if (type == null)
{
continue;
}
var instance = type.AbcInstance();
if (instance != null)
{
if (instance.Swc == lib.Swc)
{
int libIndex = instance.Abc.Swf.Index;
int abcIndex = instance.Abc.Index;
if (libIndex != lib.Index || abcIndex != abc.Index)
{
f.AddFileRef(libIndex, abcIndex);
}
}
else if (!instance.Abc.IsCore)
{
f.AddTypeRef(fullName);
}
}
else
{
f.AddTypeRef(fullName);
}
}
}
}
private static void TestClone(string resname)
{
var rs = typeof(SwfIOTest).GetResourceStream(resname);
if (rs == null)
{
return;
}
var swf = new SwfMovie(rs);
int n = swf.Tags.Count;
for (int i = 0; i < n; ++i)
{
var tag1 = swf.Tags[i];
tag1.Clone();
}
}
private static void DumpAssetsCore(SwfMovie swf, string path)
{
try
{
using (var writer = new StreamWriter(path))
{
WriteAssets(writer, "Import Assets:", swf, swf.GetImportAssets());
WriteAssets(writer, "Export Assets:", swf, swf.GetExportAssets());
WriteAssets(writer, "Symbol Table:", swf, swf.GetSymbolAssets());
}
}
catch (Exception e)
{
Console.WriteLine("Unable to dump assets");
Console.WriteLine(e);
}
}
public static void Resolve(AbcTrait trait, AbcMetaEntry e, SwfMovie lib)
{
if (trait.Embed != null)
{
return;
}
var klass = trait.Class;
if (klass == null)
{
throw new InvalidOperationException("Embed can be applied to class trait only");
}
string symbol = e[Attrs.Symbol];
string exportSymbol = e[Attrs.ExportSymbol];
string source = e[Attrs.Source];
var asset = lib.FindAsset(symbol);
if (asset == null)
{
asset = lib.FindAsset(exportSymbol);
if (asset == null)
{
throw Errors.Linker.UnableToFindSymbol.CreateException(symbol);
}
asset.IsExported = true;
}
var instance = klass.Instance;
var embed = new Embed
{
Symbol = symbol,
Asset = asset,
Movie = lib,
Source = source,
ExportSymbol = exportSymbol,
Instance = instance
};
trait.Embed = embed;
trait.AssetInstance = instance;
}
private static void TestReadWriteShapes(string resname)
{
var rs = typeof(SwfIOTest).GetResourceStream(resname);
if (rs == null)
{
return;
}
var ms = rs.ToMemoryStream();
var swf1 = new SwfMovie(ms, SwfTagDecodeOptions.DonotDecodeTags);
ms.Position = 0;
var swf2 = new SwfMovie(ms);
Assert.AreEqual(swf1.Tags.Count, swf2.Tags.Count, resname + "#count");
int n = swf1.Tags.Count;
for (int i = 0; i < n; ++i)
{
var tag1 = swf1.Tags[i];
var tag2 = swf2.Tags[i];
if (SwfTag.IsShape(tag1.TagCode))
{
string msg;
var c = tag2 as ISwfCharacter;
if (c != null)
{
msg = string.Format("{0}, #{1}, {2}, {3} - {4}",
resname, i, tag1.TagCode, c.CharacterId, c.Name);
}
else
{
msg = string.Format("{0}, #{1}, {2}",
resname, i, tag1.TagCode);
}
TagEquals(tag1, tag2, msg);
}
}
}
