I think there is a good possibility of creating embeddable OL
applications for swf9+ because the laszlo application is compiled as a
class. Similarly for DHTML because the laszlo application is loaded
into its own <iframe>. There would still be work to be done to
eliminate the use of the global namespace. This has been done to a
large extent (it is the purpose of the `lz` object that now holds most
LZX objects), but there are still some global references that need to
be cleaned up.
The <html> tag is intended to allow you to embed arbitrary <html>
content into an OL app, and this tag has been improved, but not yet to
the point where you can embed another swf (Max will have more to say
on this subject, as he is the designer of the embedding system).
Being able to dynamically load a module at run time is theoretically
possible. This is essentially how the debugger evaluates expressions
in swf: It creates a tiny module that is compiled against the
application module and then loaded into the application. This could
be extended to create dynamic loading. The current restriction on
having to compile your entire application at once (even modules that
will be loaded later) is a matter of bookkeeping in the compiler.
(Henry may have more to say on this subject, as he is the designer of
the debugger compiler).
Summary: we want to do all the things you suggest. We have just not
had the resources so far. As you know, the OL project has only a few
financial sponsors and they direct what the core team focuses on.
Implementing extensions like what you propose therefore either falls
to the community, or if there were a sponsor that required these
features able to provide funding, we could add resources to the core
team.
On 2009-07-13, at 04:54EDT, Sebastian Wagner wrote:
hi,
a long term goal of many users is to embed their existing SWFs into an
OpenLaszlo Application.
Or the other way tound: To load a compiled OpenLaszlo SWF into ...
weather
and existing SWF compiled with Flex or into another OpenLaszlo SWF.
Do you have plans for that kind of extension?
It would be very useful in terms of Modularization to be able to
compile and
load Modules at runtime into a Core without the need to have those
Modules
all available while you are compiling the Core. So that you can load
and
initiate new Classes dynamically at Runtime.
Or just compile a Core Product and ship Modules separated.
I read some posts in the forums about loading a canvas into another
but it
does not seem to me that it was a solution to the problem. Does
anyone work
or have ideas of that kind of extension?
I think the main Issue here is just that you have to load two canvas
tags
into another and have to register classes and assets at runtime. The
*import* tag does something similar. The problem is just => The
import tag
still needs to code of the module to be available while you compile
the
core. So there is no real advantage in using this Tag compared to an
*include* (if you ignore those Kbits that are loaded at runtime with
import.load() instead of an initial include).
So my idea for a workaround was: Is there a way of cheating the
compiler by
:
1) having a tiny container-class that is linked with an *import* tag
2) this gets compiled into the core
3) replace this compiled container-SWF at runtime with the actual
module?
the problem would be just that you still need the hole core to
compile the
module ... and some mystery if the this is going to work.
Also the other way round is a bummer for users: They see a nice
OpenLaszlo
Application and want to integrate it into their existing Flex, Flash
environment, but they can't as the canvas tag is not compatible for
loading
it into another SWF.
thanks,
sebastian
--
Sebastian Wagner
http://www.webbase-design.de
http://openmeetings.googlecode.com
http://www.laszlo-forum.de
[email protected]
