Hey Robert,
I should have realized that. Your way does the same thing without the silly hack at the bottom.

I'll go change my jsfl lib files now.
Joel

hi i was lookin' for the way to make an include in JSFL.
I've read your solution which not work completely : you can only pass Object or variable not classes and methods.

I think i've found another way

you have to declare constructors like in yours :
[included file]
myConstructor = function()
{
}

myConstructor.prototype.method = function()
{
fl.trace("test method");
}

[/included file]

[main file]

function include (file)
{
var contents = FLfile.read( file );
eval( contents );
}

include( "included.jsfl" );
var t = new myConstructor();
t.method();

[/main file]

hope that helps

François.

I have found that when working with this issue you run into some further issues:

(1) When you are coding in JSFL and using the global variable hack to make classes, you end up with SEVERE cacheing issues. Meaning that if you write the class, and test it, change it and run it again, you will get the 1st versions results. The only way to clear the cache is to close Flash and reopen it, and start coding again.

(2) If you declare your class like this:

Person = function()
{
returnName = function()
{
fl.trace("hello");
};
};

And then call the file like this:
fl.runScript("Person.jsfl");

And then instantiate the class like this:
me = new Person();
me.returnName();

It works just fine. However, if you declare the
class like this:
Person = function()
{
function returnName()
{
fl.trace("hello");
};
};

Where the internal methods has the function
preceeding the function name it won't work.
However this gives an alternate benefit that
the 1st style does not give. When you write
it this way, you end up with the ability to
do this:
fl.runScript("Person.jsfl");
Person.returnName();

Which allows you to treat the Person class
as reserved namespace in jsfl.

(3) And finally, when you are using this version of classing, you have to put an initialize function in your class, like this:
Person = function()
{
var name;
function init()
{
name = "~{ zafa }~";
};
function returnName()
{
fl.trace("name = "+name);
};
};
Person.init();

Then you can call use the Person as a reserved
namespace (sortof) and use it like it's always
been there.
fl.runScript("Person.jsfl");
Person.returnName();

If you tried doing the following it won't work:
Person = function()
{
var name = "~{ zafa }~";
function returnName()
{
fl.trace("name = "+name);
};
};

And then called it from your other jsfl file:
fl.runscript("Person.jsfl");
Person.returnName();

I created my own string class that allowed me
to do things like swap slashes, etc. but what
I found was that it wouldn't let me change
the value of variables declared in var whatever;
statements within the globaly defined class. I
had to use an init function to set the value,
and I couldn't give it a default value.

Hope this helps.

~{ zafa }~