|
OK, interesting stuff!
It's not clear from your description how a given
user would choose the right application build for them.
I can see two possibilities.
1) A flex front end loads a menu (from a web
service) offering a list of application builds to the user (I suppose this might
change for different users, or even just be a single choice for each user?). The
application UI specifics are then loaded into the flex app and the UI
reconfigured.
2) A flex front end loads a menu (as before) but
instead of reconfiguring the UI, executes a separate pre-compiled swf that
implements the appropriate UI. The pre-compiled swf would have been created when
the desktop app
generated the configuration info, it would then
translate the generated configuration to mxml, invoke the compiler to generate
the swf and add the swf reference to the list of apps offered to the
user.
Both these options would provide a fairly seamless
experience for the user, with the only delays being experienced (not by the end
user) when generating a new UI using the desktop app.
Paul
----- Original Message -----
Sent: Wednesday, August 30, 2006 1:08
AM
Subject: Re: [flexcoders] Architecture
question
Thanks for the input Paul.
The desktop application is a
tool to build dynamic models of systems and author an interface for others to
interact with the model. The interface consist of input objects,
(sliders, knobs, input fields, etc), and outputs like graphs and table.
A dashboard or sorts to run the simulation. If an author of such models
wishes to share the model with others, currently they need to direct the user
to download a "player" version of the software to interact with the model.
The application we want to build will allow the author to upload their
work to a website where they can share the interface of their model with
others. An online "player", if you will, that will only require the
end-user to have a web browser with the Flash Player installed.
That
said, it's not unreasonable to have the author do the conversion from the
desktop file format into a SWF in a conversion application. I'm leaning
toward this approach, because the final SWF would only need to interact with
the web service to actually run the model, and record the end-users input
decisions.
I hope this clarifies things. I welcome others
feedback on the pro/cons of this approach vs a dynamically created
interface.
Thanks,
Jeremy
On 8/29/06, Paul
Andrews <[EMAIL PROTECTED]> wrote:
----- Original Message -----
Sent:
Tuesday, August 29, 2006 10:16 PM
Subject:
[flexcoders] Architecture question
Hi all,
I would like some feedback from the group collective
about the approach I'm thinking about taking to implementing an
application using Flex for the UI.
There is an existing desktop
application and the goal of the new application is to be able to run the
files created by the desktop app in a web browser. We've already got
the guts of the desktop app implemented as a web service -- now we need to
add UI.
So here is the question: the files output by the desktop
app have XML that marks up the interface, complete with x and y
coordinates. What would work best?
- To have a generic MXML
file that uses ActionScript to parse the XML and create the components
needed for the UI on the fly and lay them out according to the XML markup
- or-
- To create a conversion utility that creates an MXML
file based on the desktop app's XML and then invoke the Flex compiler to
output an SWF. This approach would require me to redistribute the
Flex SDK, which seems to be okay according to the license.
I'm
leaning toward the latter option as it puts the burden of figuring out the
layout of the UI and all that jazz on the conversion utility. The
resultant SWF would then just communicate with the web service and run the
app.
What are your thoughts on this?
Well, I'm really curious as to what it is that
needs a dynamic interface to be built like this.
My first thought was (as you suggest) to
go with an xml transformation to mxml if the UI doesn't need to be rebuilt
every single time, but I'm wary about what the user experience would be -
there would be a delay in doing the transformation and then compiling then
invoking a swf. There may be a better user experience by running a swf, then
reading and interpreting the xml. In the second situation, there's no
recompile and transformation overhead.
Essentially your application is reading an xml
configuration file from the web service, then configuring
itself.
Paul
Thanks,
Jeremy
--
isee systems, inc.
www.iseesystems.com
(603) 448-4990
__._,_.___
--
Flexcoders Mailing List
FAQ: http://groups.yahoo.com/group/flexcoders/files/flexcodersFAQ.txt
Search Archives: http://www.mail-archive.com/flexcoders%40yahoogroups.com
![]()
SPONSORED LINKS
YAHOO! GROUPS LINKS
__,_._,___
|
