I decided to implement it in Flex because I figure it would be extremely easy… and it was! Took about 15 minutes total. However, it seems it is having issue when playing without a breakpoint in the code. Just playing through normally, when I scroll up or down, it actually seems to skip a tab when going through them. Yet, if I put a breakpoint at the beginning of the event handler and play through it that way, it goes to the next tab as it should.

Here is a demo of what I have done. Source is included…

http://www.kylehayes.info/tabby/TabThumbWheel.html

Oh yeah, and the code you use is: DESIGNQ108

The examples below are showing connecting to a AMFPHP endpoint as opposed to a ColdFusion one, only because that is what I have been learning and working on recently. For ColdFusion, simply replace the latter part of the string with /flex2gateway/

First, define a new string in your model that references the URI to which you are going to connect with your RemoteObjects:


var endpointUri:String = "http://mysite.com:8000/amfphp/gateway.php";


Then, simply define a new ChannelSet, and Channel to add to the ChannelSet that references your URI:


var cs:ChannelSet = new ChannelSet();
var customChannel:Channel = new AMFChannel("my-amfphp", endpointUri);
cs.addChannel(customChannel);


Finally, define your RemoteObject to access this ChannelSet that you just created and set the destination to the name you gave your AMFChannel:


showBusyCursor="true" />


It is as simple as that! Be sure to take out the services-config declaration in your compiler arguments to test this out appropriately.

I am so happy that the final releases of the long awaited Adobe Flex 3 (and builder) and AIR SDK are here. And they have a couple of other cool bits and pieces about them to go with this major update to the famed leading RIA platform.

First of all, as you can see at the store, the upgrade price is only $99! Also, if you have a keen eye, you will notice that it is no longer a separate license for PC and Mac…they come together now!

This is huge news and is truly making Flex be even more affordable and better than ever. One thing to note, is that the $99 upgrade is for Flex Builder 3.0 standard. Chock up an additional $200 and you’ve got the Pro version which includes advanced charting components and testing tools.

Keep in mind that the Flex framework is still free and open source. The prices above are for the Flex Builder 3.0 IDE products.

Be sure to thank the Flex team for all their hard work!

As you can see there is an issue on the bottom where a partial row of the datagrid is showing and the other part of it is hidden. It’s the hidden part that is causing the skin to appear invisible. Note that, as soon as I scroll the datagrid it goes away. However, if I move my mouse over that row it comes back. Same goes for the [+] button. You can see that it’s bounds are causing an anomaly on the control bar.

Like I said, I am not sure if this is an Adobe issue or a Yahoo! issue, but it is annoying enough that I might be swapping the skin out. I don’t want to, but I may have to.

public function copyText(txt:String):void
{
System.setClipboard(txt);
Alert.show("'" + txt + "' has been copied to your clipboard");
}
...


Simple as that.

Anyway, the application is being programmed with the help of the Cairngorm micro-architecture and as such, there is a lot of copying and pasting of files as I create new commands, events, and delegates. One thing that has bugged me in the past about doing this, is figuring out which import statements belong in the newly created class and which don’t. Many a times, I just didn’t even bother. That has now changed, now that I discovered an easy, automagic way of doing so.

Knowing that Eclipse always has some gems hidden in the right-click context menus, I perused them to see if there was anything about import statements. Lo and behold, if you right-click on any of the lines that contain import statements, and go to the submenu “Source”, there is an option called “Organize Imports” (Or my preference: [Mac] Command + Shift + O, [PC] Ctrl + Shift + O). Not only does it actually organize your import statements by package alphabetically (starting with the root package), but it also eliminates any import statements that you do not need in that class. Pretty neat!

Some features I would like to see added to this:

1. Add statements that are required
2. Combine multiple import statements from the target package using wildcard (*) (Perhaps it could be defined in preferences, how many should be considered before it combines)

I am not suggesting to put all your types in one event class. But let’s say you have a UserEvent. You could call UserEvent.ADD_USER, UserEvent.DELETE_USER, UserEvent.LOGIN_USER, etc. That is all in one class instead of having three separate classes. Can someone please explain to me the reasoning for the one-to-one ratio please?

Thanks in advance!

The benefits of serialization is that you maintain the actual instance of the object–not just a data representation of the object. When you read the serialized file back in to the application, it reads in as a native object to that application.

Traditionally in web applications, we accommodate this need by writing entries in a database. Even when it comes down to session information. For the most part, this is fine, works great and I would recommend it for the majority of use cases. However, the serialization method described above could be used as a more efficient means to storing the state of a rich Internet application. Such a method is possible in ActionScript to use in your Flex application.

The high level process is:

1. Represent your data model as an ActionScript object
2. Serialize your data model into the same AMF format that is used to communicate with middle-tiers like ColdFusion
3. Send the raw AMF message packet to ColdFusion in a RemoteObject call, or similar
4. ColdFusion writes the message packet to a local file on the server

Naturally, you would create this functionality in a series of classes and CFCs. In ActionScript, you will be using the Flash ByteArray class. This class converts any ActionScript object into a ByteArray which is basically serializing the object.


var bytes:ByteArray = new ByteArray();
bytes.writeObject(myDataModel);


From this point, bytes can now be sent to ColdFusion to be written to a file. If you are using ColdFusion, you will want your service function to be expecting an arguments of type=”Binary”. From there, ColdFusion can encode the Binary into a writable format like Base64. You migh have a function that looks something like the following:

It is really that easy. Once you call the save function you will notice that file now exists on the server. If you were to open it, it would just be a series of what appears to be random data.

To read that data back into a usable object in Flex, you will need to setup a service call to ColdFusion to return the binary data from the file.

On the ColdFusion side, the code would look something like this:







And your ActionScript RemoteObject handler would probably have the following:

private function myRO_handler(event:ResultEvent):void
{
var myDataModel:Object = ByteArray(event.result).readObject();
}


Obviously, the above code is very procedural still since the functionality is not encapsulated within well-defined functions. It is only meant to serve as a basis for understanding the concept. For your convenience, and quite frankly for mine as well, I have created an ActionScript class as well as a set of ColdFusion components to encapsulate all this functionality. You may download the files below.

The files below are provided as is without any guarantee of support or documentation:

• Serialization.swc (Compiled with the Flex 3 Beta 3 SDK)
• ColdFusion AMF Package