Joan Llenas at Garnet Works :: Thoughts on software development http://joan.garnet.io/en/ Thoughts on software development Wed, 14 Nov 2012 10:39:04 +0000 en-US hourly 1 http://wordpress.org/?v=3.4.2 Runtime Remoting configuration with Parsley http://feedproxy.google.com/~r/joan_garnet_io_english/~3/gLqxCHkmN-w/ http://joan.garnet.io/en/?p=1679#comments Sun, 13 Feb 2011 16:00:18 +0000 Joan Llenas http://joan.garnet.io/?p=1679 When you develop applications that rely on remoting for services consumption you usually end up with two or more configurations, at least one that points to your dev server, and another that points to your pre-production server.
The traditional approach is to have a couple of services-config.xml files and switch the -services compiler flag when you want to test any of the endpoints. The bad thing is that you need different compilations in order to consume different Remoting endpoints.

Luckily Flex provides APIs to set Remoting configurations at runtime, and if you add Parsley and flashvars to the mix you get a self-maintained runtime configuration.
Let's see an example:

First of all you have to create an XML file for each Remoting configuration you may need:

  • local.config.xml
  • pre.config.xml
  • pro.config.xml

Parsley XML configuration file

Let's see how the local xml configuration file looks like:
local.config.xml

PLAIN TEXT
XML:
  1. <objects xmlns="http://www.spicefactory.org/parsley"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://www.spicefactory.org/parsley
  4.         http://www.spicefactory.org/parsley/schema/2.3/parsley-core.xsd">
  5.  
  6.     <object id="amfChannel"
  7.         type="mx.messaging.channels.AMFChannel">
  8.         <property name="uri"
  9.             value="http://localhost/amfphp/gateway.php"/>
  10.     </object>
  11.  
  12.     <object id="amfChannelset"
  13.         type="mx.messaging.ChannelSet">
  14.         <property name="channels">
  15.             <array>
  16.                 <object -ref id-ref="amfChannel"/>
  17.             </array>
  18.         </property>
  19.     </object>
  20.  
  21. </objects>

For each xml config file you have, just change the AMFChannel.uri property and set it pointing to your its corresponding Remoting gateway.

Flashvars to set the correct xml config file dynamically

Now you have to modify the index.template.html file so to specify the flashvars attribute of the HTML embed tag.

PLAIN TEXT
HTML:
  1. <script type="text/javascript">
  2.          //(...)
  3.          var flashvars = {configFile:"local.config.xml"};
  4.          //(...)
  5.          swfobject.embedSWF(
  6.              "${swf}.swf", "flashContent",
  7.              "${width}", "${height}",
  8.              swfVersionStr, xiSwfUrlStr,
  9.              flashvars, params, attributes);
  10.          //(...)
  11.      </script>

This one is easy, just add var flashvars = {configFile:"local.config.xml"};. In this way the XML config file can be changed easily without having to recompile.

Create the Parsley context

Now you have to connect everything with Parsley.
The first thing you need is a context where to declare your objects:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <fx:object xmlns:fx="http://ns.adobe.com/mxml/2009"
  3.     xmlns:s="library://ns.adobe.com/flex/spark"
  4.     xmlns:mx="library://ns.adobe.com/flex/mx"
  5.     xmlns:parsley="http://www.spicefactory.org/parsley">
  6.     <fx:script>
  7.         <![CDATA[
  8.             import mx.rpc.remoting.RemoteObject;
  9.         ]]>
  10.     </fx:script>
  11.  
  12.     <fx:declarations>
  13.         <parsley:object id="helloService"
  14.             type="{RemoteObject}">
  15.             <parsley:property name="source"
  16.                 value="HelloWorldService"/>
  17.             <parsley:property name="destination" value="amfphp"/>
  18.             <parsley:property name="channelSet"
  19.                 idRef="amfChannelset"/>
  20.         </parsley:object>
  21.     </fx:declarations>
  22.  
  23. </fx:object>

Basically we declare the service that we will be calling later on. As you can see we are assuming that we already have access to the XML declared objects.

Write the application that consumes the service

Now that we have all the pieces together, we invoke Parsley from within our application:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <s:application preinitialize="preinitializeHandler()"
  3.     xmlns:fx="http://ns.adobe.com/mxml/2009"
  4.     xmlns:s="library://ns.adobe.com/flex/spark"
  5.     xmlns:mx="library://ns.adobe.com/flex/mx"
  6.     xmlns:parsley="http://www.spicefactory.org/parsley">
  7.  
  8.     <fx:script>
  9.         <![CDATA[
  10.             import context.ApplicationContext;
  11.  
  12.             import mx.controls.Alert;
  13.             import mx.core.FlexGlobals;
  14.             import mx.rpc.AsyncToken;
  15.             import mx.rpc.Responder;
  16.             import mx.rpc.events.FaultEvent;
  17.             import mx.rpc.events.ResultEvent;
  18.             import mx.rpc.remoting.RemoteObject;
  19.             import mx.utils.ObjectProxy;
  20.  
  21.             [Bindable]
  22.             private var flashvars:ObjectProxy;
  23.  
  24.             protected function preinitializeHandler():void
  25.             {
  26.                 flashvars = new ObjectProxy(FlexGlobals.topLevelApplication.parameters);
  27.             }
  28.  
  29.  
  30.             protected function contextbuilder_errorHandler(event:ErrorEvent):void
  31.             {
  32.                 Alert.show(event.text, "Error");
  33.             }
  34.  
  35.             [Inject(id="helloService")]
  36.             public var service:RemoteObject;
  37.  
  38.             [Init]
  39.             public function injectionComplete():void
  40.             {
  41.                 sayHelloButton.enabled = true;
  42.             }
  43.  
  44.             protected function sayHello():void
  45.             {
  46.                 var token:AsyncToken = service.sayHello(yourname.text);
  47.                 token.addResponder(new mx.rpc.Responder(onHello, onHelloError));
  48.             }
  49.  
  50.             private function onHello(event:ResultEvent):void
  51.             {
  52.                 currentState = "hello";
  53.                 helloMessage.text = String(event.result);
  54.             }
  55.  
  56.             private function onHelloError(event:FaultEvent):void
  57.             {
  58.                 Alert.show(event.fault.faultString, "Error");
  59.             }
  60.         ]]>
  61.     </fx:script>
  62.  
  63.     <fx:declarations>
  64.         <parsley:contextbuilder error="contextbuilder_errorHandler(event)">
  65.             <parsley:xmlconfig file="{ flashvars.configFile }"/>
  66.             <parsley:flexconfig type="{ApplicationContext}"/>
  67.         </parsley:contextbuilder>
  68.         <parsley:configure />
  69.     </fx:declarations>
  70.  
  71.  
  72.     <s:states>
  73.         <s:state name="normal"/>
  74.         <s:state name="hello"/>
  75.     </s:states>
  76.  
  77.     <s:vgroup horizontalCenter="0"
  78.         verticalCenter="0"
  79.         excludeFrom="hello">
  80.         <s:textinput id="yourname"
  81.             text="Joan"/>
  82.         <s:button id="sayHelloButton"
  83.             label="Call service" enabled="false"
  84.             click="sayHello()"/>
  85.     </s:vgroup>
  86.  
  87.     <s:label id="helloMessage"
  88.         color="#FF0000"
  89.         fontSize="30"
  90.         horizontalCenter="0"
  91.         verticalCenter="0"
  92.         includeIn="hello"/>
  93.  
  94. </s:application>

The key point here is the ContextBuilder, located within the Declarations tag.
In the first place we declare the XMLConfig processor, and then the FlexConfig processor.
The order is important because Parsley sequences the context building process, and we need it in this exact order because the Flex context configuration relies on the XML context configuration to get some properties.

Download an example:

Zip file with a Flex4 Flash Builder project.

Parsley Runtime Remoting configuration (364) - 858.97 kB
zip
]]> http://joan.garnet.io/?feed=rss2&p=1679 2 http://joan.garnet.io/en/?p=1679 Declarative approaches to event listeners http://feedproxy.google.com/~r/joan_garnet_io_english/~3/PmLVpgb8k2g/ http://joan.garnet.io/en/?p=1652#comments Sun, 13 Feb 2011 00:08:59 +0000 Joan Llenas http://joan.garnet.io/?p=1652 Event listeners are common actors in Flex applications. They play a key role in the interactive nature of RIAs.
This fact makes them very verbose in some situations, specially when you want to create reusable components or minimize coupling between Views and other classes.
The fact is that opening a <Script> tag and adding ActionScript code to handle these events seems just too much, specially when you took care of not adding any logic to your MXML file.

[Event] metadata tag

As far as I know the only way to keep on with a declarative approach to event listeners is by using the [Event] metadata tag:

PLAIN TEXT
Actionscript:
  1. [Event(name="myEventType",type="flash.events.Event")]
  2. public class MyClass extends EventDispatcher
  3. {
  4.     private function whatever():void
  5.     {
  6.         dispatchEvent(new Event("myEventType"));
  7.     }
  8. }

In this way you can declare MyClass and listen for events directly from within the very tag.

PLAIN TEXT
MXML:
  1. <fx:declarations>
  2.     <ns:myclass myEventType="trace('Handling myEventType event')"/>
  3. </fx:declarations>

EventListener MXML tag

So when for whatever reason the [Event] tag is not an option, you run out of options. That's why I decided to create a declarative implementation of the addEventListener() function.
It's very small and allows you to register listeners declaratively. Just like this:

PLAIN TEXT
XML:
  1. <fx:declarations>
  2.     <mxml:eventlistener source="{model}"
  3.         type="loggedIn"
  4.         listener="{loggedIn}"/>
  5. </fx:declarations>

The EventListener tag implementation:

PLAIN TEXT
Actionscript:
  1. package io.garnet.events.mxml
  2. {
  3.     import flash.events.IEventDispatcher;
  4.     import mx.core.IMXMLObject;
  5.  
  6.     public class EventListener implements IMXMLObject
  7.     {
  8.         private var _source:IEventDispatcher;
  9.         private var _type:String;
  10.         private var _listener:Function;
  11.         public var useCapture:Boolean = false;
  12.         public var priority:int = 0;
  13.         public var useWeakReference:Boolean = false;
  14.        
  15.         public function initialized(document:Object, id:String):void
  16.         {
  17.             createListener();
  18.         }
  19.        
  20.         public function createListener():void
  21.         {
  22.             if( _source && listener && type && !_source.hasEventListener(type) )
  23.             {
  24.                 _source.addEventListener(type, listener, useCapture, priority, useWeakReference);
  25.                 // to avoid memory leaks
  26.                 _source = null;
  27.                 _listener = null;
  28.             }
  29.         }
  30.  
  31.         public function get source():IEventDispatcher
  32.         {
  33.             return _source;
  34.         }
  35.         public function set source(value:IEventDispatcher):void
  36.         {
  37.             _source = value;
  38.             createListener();
  39.         }
  40.        
  41.         public function get type():String
  42.         {
  43.             return _type;
  44.         }
  45.         public function set type(value:String):void
  46.         {
  47.             _type = value;
  48.             createListener();
  49.         }
  50.        
  51.         public function get listener():Function
  52.         {
  53.             return _listener;
  54.         }
  55.         public function set listener(value:Function):void
  56.         {
  57.             _listener = value;
  58.             createListener();
  59.         }
  60.     }
  61. }

Download an example:

Zip file with a Flex4 Flash Builder project.

Declarative addEventListener implementation (251) - 20.04 kB
zip
]]> http://joan.garnet.io/?feed=rss2&p=1652 1 http://joan.garnet.io/en/?p=1652 New domain! http://feedproxy.google.com/~r/joan_garnet_io_english/~3/lPZQc5MfXQA/ http://joan.garnet.io/en/?p=1591#comments Sun, 30 Jan 2011 21:56:22 +0000 Joan Llenas http://joan.garnet.io/?p=1591 I have decided to merge my two blogs joangarnet.com (spanish) and joanllenas.com (english) into one single domain.
Thanks to WPML and a tiny bit of magic I've been able to set up WordPress as a multi language blog.
I won't be translating all the spanish content I already wrote, It doesn't make any sense, but I'll try to find the most notable entries to make them available in English.
If you want me to translate anything in particular don't hesitate to contact me and I'll do it ASAP.

]]> http://joan.garnet.io/?feed=rss2&p=1591 0 http://joan.garnet.io/en/?p=1591 Refactoring closures to strategies http://feedproxy.google.com/~r/joan_garnet_io_english/~3/c5Xu4e0nsPc/ http://joan.garnet.io/en/?p=1510#comments Fri, 28 Jan 2011 17:07:50 +0000 Joan Llenas http://joan.garnet.io/?p=1510 Sometimes you need to expose a feature of your API as a function reference in order to allow the execution of that feature in a custom way.
This kind of functions are known as closures.
A closure is basically a function reference that is executed within a particular scope, being able to access any scope member through argument passing.
This feature is very powerful as it enables the injection of external logic into an encapsulated scope, but has the drawback that there's no way of knowing whether a given function will satisfy its target closure's signature.
Languages like C# have a feature called delegates that enable closures to be type safe. ActionScript does not, so we have to make use of other OOP features in order to overcome the limitations that the use of closures impose us.

A good closure use case can be found in the ListBase APIs of the Flex SDK.
The ListBase.labelFunction property expects a function reference which, when assigned by the user, will parse every object within the list’s collection, providing the custom logic needed in order to render a correct representation of the iterating object.
Let's see an example: (You can download the completed example)

API:

PLAIN TEXT
Actionscript:
  1. package
  2. {
  3.     import flash.text.TextField;
  4.    
  5.     public class ItemRenderer extends TextField
  6.     {
  7.         private var defaultLabelField:String = "label";
  8.         public var labelFunction:Function;//closure
  9.        
  10.         public function setData( data:Object ):void{
  11.             if( labelFunction == null ){
  12.                 this.text = data[defaultLabelField];
  13.             }else{
  14.                 this.text = labelFunction( data );
  15.             }
  16.         }
  17.     }
  18. }

You can see that in this case the closure is the labelFunction property.
User code using the API (with closures):

PLAIN TEXT
Actionscript:
  1. package
  2. {
  3.     import flash.display.Sprite;
  4.    
  5.     public class ClosureExample extends Sprite
  6.     {
  7.         public function ClosureExample()
  8.         {
  9.             var renderer:ItemRenderer = new ItemRenderer();
  10.             renderer.x = renderer.y = 50;
  11.             renderer.setData( {label:"The Label"} );
  12.             addChild( renderer );
  13.            
  14.             var closure:Function = function( data:Object ):String
  15.             {
  16.                 return String( data["altLabel"] );
  17.             }
  18.             renderer = new ItemRenderer();
  19.             renderer.x = renderer.y = 100;
  20.             renderer.labelFunction = closure;
  21.             renderer.setData( {altLabel:"Alternative Label"} );
  22.             addChild( renderer );
  23.         }
  24.     }
  25. }

The above code adds two ItemRenderer instances to the display list, where the second one uses the closure in order to render its label.
This snippet above is absolutely correct, but let's see whether we can improve its readability.
Problems that I see with this approach:

  • Users will have to check the documentation from time to time in order to remind the closure's implementation details (closure signature).
  • The only way of being sure that the labelFunction is correct is by running the affected piece of code where the closure is called.

What we need in order to overcome this issues is a way of enforcing the closure's signature at compile time.
This can be achieved by using what is known as a Strategy, one of the design patterns defined in the GoF book.

A strategy is an algorithm plugged into an object in an encapsulated way.
Both closures and strategies do help with the externalization of application logic, that’s why they can be exchanged very easily as they have the same purpose and behave in the same way.
Let's see how the refactored code looks like after replacing closures with strategies:

User code using the API (with strategies):

PLAIN TEXT
Actionscript:
  1. package
  2. {
  3.     import flash.display.Sprite;
  4.    
  5.     import labelResolvers.DateLabelResolver;
  6.     import labelResolvers.FullNameLabelResolver;
  7.    
  8.     public class TypeSafeClosure extends Sprite
  9.     {
  10.         public function TypeSafeClosure()
  11.         {
  12.             var renderer:ItemRenderer = new ItemRenderer();
  13.             renderer.x = renderer.y = 25;
  14.             renderer.setData( {label:"The Label"} );
  15.             addChild( renderer );
  16.            
  17.             renderer = new ItemRenderer();
  18.             renderer.x = renderer.y = 50;
  19.             renderer.labelResolver = new FullNameLabelResolver( "name", "surname" );
  20.             renderer.setData( {name:"Joan", surname:"Llenas"} );
  21.             addChild( renderer );
  22.            
  23.             renderer = new ItemRenderer();
  24.             renderer.x = renderer.y = 75;
  25.             var df:DateFormatter = new DateFormatter( DateFormatter.FULLYEAR, DateFormatter.MONTH, DateFormatter.DAY );
  26.             renderer.labelResolver = new DateLabelResolver( df, "date" );
  27.             renderer.setData( {date:new Date(1976,2,12)} );
  28.             addChild( renderer );
  29.         }
  30.     }
  31. }

APIs:
ItemRenderer

PLAIN TEXT
Actionscript:
  1. package
  2. {
  3.     import flash.text.TextField;
  4.    
  5.     import labelResolvers.ILabelResolver;
  6.    
  7.     public class ItemRenderer extends TextField
  8.     {
  9.         private var defaultLabelField:String = "label";
  10.         public var labelResolver:ILabelResolver;
  11.        
  12.         public function setData( data:Object ):void{
  13.             if( labelResolver == null ){
  14.                 this.text = data[defaultLabelField];
  15.             }else{
  16.                 this.text = labelResolver.resolve( data );
  17.             }
  18.         }
  19.     }
  20. }

ILabelResolver

PLAIN TEXT
Actionscript:
  1. package labelResolvers
  2. {
  3.     public interface ILabelResolver
  4.     {
  5.         function resolve(data:Object):String;
  6.     }
  7. }

FullNameLabelResolver

PLAIN TEXT
Actionscript:
  1. package labelResolvers
  2. {
  3.     public class FullNameLabelResolver implements ILabelResolver
  4.     {
  5.         private var nameDataField:String;
  6.         private var surnameDataField:String;
  7.        
  8.         public function FullNameLabelResolver( nameDataField:String="name", surnameDataField:String="surname" )
  9.         {
  10.             this.nameDataField = nameDataField;
  11.             this.surnameDataField = surnameDataField;
  12.         }
  13.        
  14.         public function resolve(data:Object):String
  15.         {
  16.             return data[nameDataField] +" "+ data[surnameDataField];
  17.         }
  18.     }
  19. }

DateLabelResolver

PLAIN TEXT
Actionscript:
  1. package labelResolvers
  2. {
  3.     public class DateLabelResolver implements ILabelResolver
  4.     {
  5.         private var dateField:String;
  6.         private var formatter:DateFormatter;
  7.        
  8.         public function DateLabelResolver( formatter:DateFormatter, dateField:String="date" )
  9.         {
  10.             this.dateField = dateField;
  11.             this.formatter = formatter;
  12.         }
  13.        
  14.         public function resolve(data:Object):String
  15.         {
  16.             return formatter.format( data[dateField] );
  17.         }
  18.     }
  19. }

As you can see there's a little bit more code to write; not much more anyway; but the implementation is better in some aspects:

  • Strategies encourage reuse: i.e. It has sense having a FullNameLabelResolver or a DateLabelResolver packed in a library.
  • No need to look at the documentation: The auto complete functionality will give you all the details you may need.
  • Compile time error checking: The closure signature is abstracted by the strategy implementation, so as far as you pass the correct parametrization to the ILabelResolver instance you can be sure that the rest will work.

Descarga ejemplo

En el zip hay un proyecto Flex4 para Flash Builder.

Refactoring Closures to Strategies (339) - 42.09 kB
zip
]]> http://joan.garnet.io/?feed=rss2&p=1510 0 http://joan.garnet.io/en/?p=1510 Flex and PHP integration through AMF http://feedproxy.google.com/~r/joan_garnet_io_english/~3/ZSnqEdSggXQ/ http://joan.garnet.io/en/?p=1583#comments Sun, 01 Nov 2009 21:24:42 +0000 Joan Llenas http://joan.garnet.io/?p=1583 At the 2009 PHPConference I gave a presentation about PHP-Flex integration through the AMF protocol.
At some point I showed a couple of code samples about how integration can be leveraged with libraries such AMFPHP, ZendAMF and WebOrb. Nothing complex, just basic stuff with enough RIA touch to justify the use of Flex (at that time the HTML5 buz was still to arrive).
Here are the two projects I showcased:

Sample 1: AMF File Chat

AMF File Chat: Chat that uses WebORB polling capabilities. Supports file sharing.
Flex + WebOrb Chat

AMF Chat (1361) - 26.42 MB
ZIP

Sample 2: Contact manager (Multi AMF implementation)

A single Flex project and how (easily) the three remoting gateways (Weborb, AMFPHP and Zend_AMF) can be switched at runtime.
Contact Manager. Multi AMF implementation

Gestor Contactos Multi AMF implementation (1356) - 27.39 MB
ZIP
]]> http://joan.garnet.io/?feed=rss2&p=1583 0 http://joan.garnet.io/en/?p=1583 AIR based Download Manager http://feedproxy.google.com/~r/joan_garnet_io_english/~3/QPeWQGj_sO0/ http://joan.garnet.io/en/?p=1608#comments Wed, 18 Feb 2009 22:32:50 +0000 Joan Llenas http://joan.garnet.io/?p=1608 AIR download manager (prototipo)
I was wondering if it would be possible to write an AIR based download manager. After experimenting for a while with the network APIs and reading a little bit about how the HTTP protocol works I have prototyped what could be a first step in developing a real download manager.
These are the features that one could expect from a download manager and wether the prototype have them implemented.

  • pause / resume download: Implemented
  • multipart download:Implemented
  • Download session persistence:Not implemented

Download

Download the Download Manager prototype source code

AIR Download Manager (prototipo) (1184) - 496.53 KB
zip
]]> http://joan.garnet.io/?feed=rss2&p=1608 0 http://joan.garnet.io/en/?p=1608 JSProxy: inject Javascript into the DOM with Actionscript http://feedproxy.google.com/~r/joan_garnet_io_english/~3/YqSfapFklJs/ http://joan.garnet.io/en/?p=1615#comments Tue, 24 Jun 2008 21:48:57 +0000 Joan Llenas http://joan.garnet.io/?p=1615 A library to manage Javascript code from within ActionScript.

  • Compile inline javascript code
  • Load external Javascript files and inject them

ActionScript only sample:

PLAIN TEXT
Actionscript:
  1. import com.joangarnet.js.JavaScript;
  2. import flash.events.Event;
  3. import flash.external.ExternalInterface;
  4.  
  5. var flashAppId:String = ExternalInterface.objectID;
  6. test1();
  7. test2();
  8. function test1():void{
  9.     // some javascript to inject into the DOM
  10.     var js1:XML =
  11.     <script type="text/javascript">
  12.         <![CDATA[
  13.             function sayHello(){
  14.                 alert( "hello" );
  15.             }
  16.             Utils = {
  17.                 getURL:function(){
  18.                     return window.location.href.toString();
  19.                 }
  20.             }
  21.             var z = 10;
  22.             var a = {
  23.                 b:{
  24.                     c:{
  25.                         prop1:"hola 1",
  26.                         prop2:"--"
  27.                     }
  28.                 }
  29.             };
  30.         ]]>
  31.     </script>;
  32.     var javascript1:JavaScript = new JavaScript(flashAppId);
  33.     javascript1.addEventListener(Event.COMPLETE,javascript1Complete);
  34.     javascript1.js = js1.toString();
  35. }
  36. // the injected javascript code is ready to be used
  37. function javascript1Complete(event:Event):void{
  38.     var javascript1:JavaScript = event.target as JavaScript;
  39.     trace( javascript1.getScope("Utils").getURL() );
  40.     javascript1.getScope(JavaScript.WINDOW).sayHello();
  41.     trace( javascript1.getScope(JavaScript.WINDOW).z );
  42.     trace( javascript1.getScope("a.b.c").prop1 );
  43.     javascript1.getScope("a.b.c").prop2 = "hola 2";
  44.     trace( javascript1.getScope("a.b.c").prop2 );
  45. }
  46. // let's try to load an external library
  47. function test2():void{
  48.     var javascript2:JavaScript = new JavaScript
  49.     (
  50.         flashAppId,
  51.         "http://ajax.googleapis.com/ajax/libs/jquery/1.2.6/jquery.min.js"
  52.     );
  53.     javascript2.addEventListener(Event.COMPLETE,javascript2Complete);
  54. }
  55. // the library is loaded and ready to be used
  56. function javascript2Complete(event:Event):void{
  57.     var javascript2:JavaScript = event.target as JavaScript;
  58.     trace( javascript2.getScope("jQuery.browser").version );
  59. }

JSProxy(flash): javascript desde actionscript (1330) - 634.6 KB
zip

JSProxy(flex): javascript desde actionscript (1101) - 295 KB
zip
]]> http://joan.garnet.io/?feed=rss2&p=1615 0 http://joan.garnet.io/en/?p=1615