Flash 9 and 10 serious limitations

Question

Hello!
I've been developping flash applications with AS2 for years.
While Flash 9 and 10 are great, for the very first time in Flash
history it had become impossible for me to do something important
that I was once able to do with previous versions.
In Flash 8, I developped a complex but wonderful run-time
system in order to load my classes dynamically. As you know,
classes were stored in the "global" object in previous versions. In
order to store my classes in only ONE swf file in complex projects,
I used the "global" keyword in all my actionscript code so that I
could always decide WHERE i wanted to include a particular class.
Of course, I had to create a special class in order to load
all my other classes. For example, the following code
allowed me to load a package of classes :
myClassLoader.load ("com.mynamespace.Map");
The classLoader was a very handful. Basically, it was
performing the following tasks :
1) convert the string "com.mynamespace.Map" to
"com/mynamespace/map.swf"
2) load the file "com/mynamespace/map.swf"
Of course, the file "com/mynamespace/map.swf" contained the
class "com.mynamespace.map" therefore my class loader was checking
if _global.com.nymespace.map was defined.
3) Once the _global.com.nymespace.map is defined, my class
loader look for the following static properties :
public static var PARENT_S :String= "net.tanoa.Component";
public static var TANOA_REQUIREMENT_A :Array=
["net.tanoa.Geodesy","net.tanoa.Component"]
At this point, you have are probably understanding where I am
going.
My classLoader is looking for all requiered classes and if
they are not already defined, those classes will be loaded as well.
Here, you must understand that I single SWF can contain many
classes actually, but those classes are "raw" (thas is there is not
inheritage at this point)
4) When ALL required classes are loaded, my classLoader needs
to perform an other important task : to link classes prototypes in
order to build dynamically the inheritage. As you have already
understood, I use the "PARENT_S" static property of all classes to
do so.
5) When the inheritage structure is build, the classLoader
check out if there is any initilialization to perform on each
classes (there was a standard name for my initilaization method in
all classes) this was required in order to create default
properties of some classes (when those default properties are
instances of other classes for example) I don't want to make it
more complex than required, but there was also an optionnal
propertie "initalization_priority" to determine which classes
should be initialized first.
Well at this point I hope you understand the main ideas. I
have a lot of classes in many swf files. There is NEVER any
duplication of any classes. Many different projects can reuse the
same classes and therefore the same files stored in the cache. It's
possible for me to create a virtual Windows application and load an
XML file in which i determine which "components" are required, and
they will be loaded only when needed.
As far as I know, I am the only guy in Fiji (and in the
world) who developped such a system.
In order to avoid the inclusion of my classes in more than
one swf, I had to use the keyword "_global" in all my code (it was
a pain in the ***) and I couldn't take advanatge of the compilator
check-ups or special keywords like "extends" etc... it was the big
price to pay.
I am really sad that Flash 9 and Flash 10 do not allow us to
deal with inheritage dynamically. Technically, Flash 9 and 10 are
very limited, it's like if it was impossible for a program running
in Windows to load a "dll" file.
In my opinion, the next generation of flash applications
should allow us to find a solution to that problem.
As long as I am concerned, if I can't continue to do what I
did before, it means that I have a big problem.
Fijiflasher

Answer 1

Thank you for the link David, I'm gonna have a look to it but
at this point I am not absolutely sure that i'll be able to create
dynamic inheritage and stuff like that...well let's stay
optimistic...;-)
Thank you for your reply Raymond. The problem here is not
really the "global" object. using the _global object in my as code
was the best way to avoid the inclusion of classes in my swf files.
On the first frame of my Fla file, i was adding the following code
in order to force the inclusion of some classes in a particular swf
if (com.mynamespace.Map)
As you can see, this code doesn't do anything (that's
great...) but the class Map will be included in the "global" object
automatically as soon as the swf is loaded.
From there, it is possible to load many SWF files from a main
SWF file (once they are loaded, I unload the swf files but the
"classes" remain in the global object) it might sounds weird for
some of you, but i can tell you it was a wonderful way to build
complex applications. Unfortunately, this brings some problems (you
don't get advanatage of the compilator check-up when you compile
your modules, etc...)
it was important for me to be able to check up at run time if
a particular class was available. For example :
if (_global.com.Map ==undefined){
// i need to load "com/Map.swf"
see? that's great isn't it? As soon as the _global keyword
was encountered by the compilator, the following reference was
"ignored" and therefore I could manage to validate if a class was
there or not WITHOUT including it. it was better than using the
"xml exclusion file" for many reasons.
As far as I know, there is no way with AS3 to do something
like that (there is no "eval" function) so i can't validate at the
run time if some classes are there or not. I need to check David's
link before to confirm that.
An other great think when you need to develop applications in
many languages : if you use jokers like this
"com.mynamespace.{language}.textFunction" in your architecture
(where "language" is a parameter which is replaced dynamically by
my classLoader function), you can actually create a wonderful kind
of dynamic classes. Generally, it's not possible to translate
English to French in a "simple way", I mean that you need a proper
function to "generate" a string output using some parameters passed
to a function. In my architecture, only the "french" or "english"
classes were loaded. Also, I can use other "jokers" like {style}
for example if i have a collection of different "rendering
functions" for a same application...when you need to use bitmaps,
it's really useful.
Well my main point is that it's very important to :
1) be able to load classes at run time in a "common" place ;
2) be able to check out if a class is available in that
"commom" place without forcing the inclusion of that class in the
code.
There is a few more other things, but that is the core idea
here.
Thanks
Mathieu