Data binding is essentially tha synchonization of values, typically between the model and the views (read more here. For Flex applications data binding is typically accomplished with the [Bindable] compiler meta tag. For pure AS3 applications it’s been a roll-your-own world and some even use [Bindable] here as well. This is just wrong.

These are the reasons why BindMax is better than [Bindable]:

• Mobile loving
  Building mobile apps with AIR? Then you know it’s all about squeezing file size out and performace in. BindMax is an implementation of the observer pattern, which is a much simpler structure than the Flash Event bus. In fact it’s beautiful minimalism compared the Events. Smaller file size, better performance.
• Speed!
  For primitive data types BindMax is generally 3x faster than [Bindable]. Performance with complex data types obviously depends on how fast your compare functions are, if you have any. Without them, complex data types propagate just as fast as the primitve ones. The speed tests are included with the source so check for yourself!
• Early type checking
  A data binding is usually defined early in the application run cycle. When that happens, BindMax will evaluate each attempt to bind a property or setter against the data type of the binding and throw an error if the data types don’t match. With [Bindable], you get no errors until the target property/setter for that binding is used. For a property that is used only rarely, you may never even see that error until the client/user stumbles over that rare use case and tells you.
• Boot time property/getter/setter name validation on both sides of data binding
  Just as with type checking, BindMax validates that that the names match between the property or setter you bind a property or getter to.
• Easy custom compare functions for complex and custom data types
  Primitive data type values like numbers and strings are easy to compare. Complex data types like arrays, dictionaries and custom objects require special handling. For this scenario, BindMax provides setCompareFunction which lets you pass it a function reference to a custom function that takes two instances of the same class and returns true if they are equal.
• Optional automatic binding disposal
  To play nice with the garbage collector, BindMax lets you turn on automatic disposal of bindings which are no longer in use. When the last target for a binding is removed, BindMax will dispose of it.
• Previous value retrieval
  BindMax stores the last value of each binding so you can retrieve it with retrieveLast if for comparison with the new value. The typical use case for this functionality is an animated image gallery where animation direction is determined based on image index vs previous image index. I’m sure you can think of several others.
• Powerful reset function
  With the reset function, you can reset any or all of the bound properties to their default values (value of the property when the binding was defined). A quick call to reset followed by propagateAll will effectively reset you application.
• Propagation forcing
  There are times when checking if a value is in fact changed simply doesn’t make sense. Then you wanna be sure that a value spreads to you application each time it is set, even if hasn’t changed. BindMax lets you override change detection on a per-update or per-property basis.

So go get it! At Google Code

NOTE: From now on I will be talking mostly about BindMax instead of it’s little brother BindLite. I’m leaving BindLite in the source in case someone finds it useful, but BindMax is much more verastile by not being an all static access class.

I’ve also updated the BindMax tutorial

The updates I made were the following:

• Added reset all functionality when calling reset without arguments
• Added setForcedPropagation function
• Added propagateAll function
• Removed outdated example project

I needed to draw a dashed line in AS3. I thought it would be easy, but I thought “hey, that one’s already been covered”, expecting that if I could find some ready-made class or lib that would do the job, I might even get some extra benefits. I went on this great interweb page called Google and I searched for “Dashed Line AS3″.

I was disappointed at all the feeble attempts at doing something so simple, so after a couple of attempts i did it myself. I even threw in the added benefit of making it able to draw itself between two points you supply it. I was expecting something extra so I imagine you did too.

Here ya’ go:

DashedLine.as

PS: Damn, that drop shadow Mac OS X includes in window screenshots is really something.

If you’re like me in that you exercise and you track your workouts with a Garmin device, there’s a chance that you’ve experienced the situation where the sync will hang about halfway through.

Why?

What seems to happen is that the Garmin Communicator plug-in is able to read the TCX-files off the device and onto disk (that’s the first 50% of the process), but crashes when it tries to upload the files to Gamin Connect, Dailymile, Runkeeper, Endomondo or any other site that uses the plug-in for sync with Garmin devices. There’s actually one progress bar for each of these steps on Garmin Connect, so the above image would not be completely accurate, the first bar would reach 100% and then it hangs.

One solution..if you can call it that

My previous solution would be to force quit the plug-in in Activity Monitor and try again until it finally worked (often as many as 6-8 attempts). I sync my runs to each of the four afformented websites (if only my friends could agree on the same site), so you can quickly see that this process becomes tedious.

Better solution: Clear the cache

What seems to be the problem is that the last TCX file that was synced is still in the browser cache and is somehow able to confuse to plug-in, because the solution to the problem is rather simple; clear your browser’s cache between each sync. This has proven to be a stable workaround for me for a while.

A note on Garmin Support

I’ve tried contacting Garmin Support several times about this, but no replies yet. The problem is even mentioned several places on the Garmin Support forums, but I doubt Garmin moderates or even monitors their own forum. An official response has yet to be made at least. I have a love-hate realationship with Garmin because I think they make hands down the best GPS HR monitors (with some exceptions), but at the same time their support is appalling and sadly I’m far from the only one who thinks so.

Well not exactly bigger in terms of file size, but since BindLite was taken it had to be BindMax for its brother. BindLite was released earlier this year as a flex-less, event-less alternative to data binding in AS3. But whereas BindLite is a static class suitable for smaller projects, I quickly realized that to make it more usable, it could no longer be all static. Enter BindMax.

BindMax does exactly the same as BindLite does but with the added flexibility of being an instance. The recommended approach is to extend it for your Model class. Example:

public class MyModel extends BindMax {
	public var state:String = State.INPUT;
	public var captureDelay:uint = 0;
	public var capturePhase:String;
	public var currentSwf:SwfVO;
	public var error:ErrorVO;
	public var render:BitmapData;
}

This is all you need for BindMax to do its magic. Your model class need no additional code, not even a constructor. As the superconstructor is implicitly called, BindMax will auto-enumerate all public variables and accessors as bindable with the correct data type for you. Explicitly calling the superconstructor lets you set the autoEnumerate argument to false if you wish to prevent this behaviour.

After this, all is the same as with BindLite with the exception that you need access to the MyModel instance. I recommend providing this acces through a dependency injection-driven framework such as RobotLegs.

Examples of use:

// Binding a property to a public property or setter on view
model.bind( "state", view );

// Property name needs to be passed as string, so using enums is recommended
model.bind( Bindable.STATE, view );

// Changing a property and propagate the change if value is different
model.update( Bindable.STATE, "main" );

// Changing a model property and force propagation
model.update( Bindable.STATE, "main", true );

// Resetting model properties to their values at define time
model.reset( Bindable.STATE, Bindable.FILE );

// Removing a data binding. Omit the second argument to unbind target from all data bindings
model.unbind( view, Bindable.STATE );

// Retrieve the before-change value of a bindable property
model.retrieveLast( Bindable.STATE );

// Control what happens when last target unbinds from a property
// true : Discard orphaned bindings
// false : retain orphaned bindins (default)
model.autoDisposeBindings = true;

Download BindLIte and BindMax as a combined package here: http://code.google.com/p/bindlite/

Docs are here: http://www.oyvindnordhagen.com/bindlite/docs/

Just as part of a fun little side project, I made this class to generate random circular Tron-like patterns. I thought I’d post it here in case anyone else likes the look of what it does. I’ve included an option to save the image in 2880×2880 pixels.

Se the Tron pattern generator here: www.oyvindnordhagen.com/tron/

So these days I’m experimenting with AIR P2P apps through the recently introduced ServerSocket class (which I think is still in beta by the way). Since the AIR API does not provide any network client/server/peer discovery tools, I decided to hack down a simple IP scanner to do the trick.

This package consists of two classes; IPScanner and IPScannerEvent. IPScanner will accept a starting IP and it will scan the rest of the range from that IP. In other words, if you pass in 192.168.1.100, it will try to “ping” each possible address from 192.168.1.100 to 192.168.1.255. Pass in 192.168.0, and it will go on all the way from 192.168.0.0 to 192.168.255.255, but it is limited to those last two segments.

An optional handshake string can also provided. In which case IPScanner will attempt to send this handshake string to each IP it is able to connect to and wait for a reply. This enables you to make sure you’re connecting to the right peer.

I find this works really well for me, so I thougt maybe someone else might need it too. Feel free to leave comments!

IPScanner.zip

Really awesome generative art from flashandmath http://tpt.to/agn5D8

Around 8 months ago, I released LazyFallback, the batch jpg fallback generator for flash. That version was hacked together over just a few hours on the train to and from work and had a few obvious limitations. Especially when it came to movies with scripted animation.

This time, I’ve done it right (I think). Funnily enough, during the time I was working on improving LazyFallback, I talked to @paulholliday who by sheer coincidence was working on the exact same thing, and he kindly let me have the source for his own app, FallbackCreator. Inspired by his solution, I changed the solution for loading the swfs altogether from using a Loader to using AIR’s HTMLLoader to enable AVM1 movies to play as naturally as possible.

Other improvements:

• Much better memory handling
• AutoUpdate
• Graceful error handling
• Slightly more polished UI
• New icons

Also, this has been a trial project for Robotlegs on my part, which I really like. But personally, I’m not too font of Flex data binding, so I combined it withBindLite (or more specifically a new version called BindMax, which I might publish later).

A word of caution

Your swfs should not contain playing MovieClips or ActionScript on the first frame. This is a good practice in genereal when it comes to banners ads either way, but for LazyFallback to be able to reliably control the capture delay, nothing should happen before frame 2.

So why wait—go get LazyFallback now!

Here’s an example class:

public class DropTest {
   private var fileQue:Array;
   private var dropWell:Sprite;

   public function DropTest () {
      dropWell.addEventListener( NativeDragEvent.NATIVE_DRAG_ENTER, dragEnterhandler );
      dropWell.addEventListener( NativeDragEvent.NATIVE_DRAG_DROP, dropHandler );
      dropWell.addEventListener( NativeDragEvent.NATIVE_DRAG_EXIT, dragExitHandler );
   }

   private function dragEnterhandler ( event:NativeDragEvent ):void {
      var files:Array = event.clipboard.getData( ClipboardFormats.FILE_LIST_FORMAT ) as Array;
      if (files && files.length) queFiles( files );
      else queFiles( null );
   }

   private function queFiles ( files:Array ):void {
      fileQue = files;
      if (files) {
         NativeDragManager.acceptDragDrop(dropWell);
         // Update visuals
      }
      else {
         // Update visuals
      }
   }
   private function dragExitHandler ( event:NativeDragEvent ):void {
      // This event handler will be called before dropHandler when dropping files
      queFiles( null );
   }

   private function dropHandler ( event:NativeDragEvent ):void {
      for each (var file:File in fileQue) {
         processFile( file ); // Fails because dragExitHandler has nulled fileQue
      }
   }
}

My suggestion for a solution to this is that you assign responsibilities for the event handlers as follows:

• NativeDragEvent.NATIVE_DRAG_ENTER: Validate files and update visuals
• NativeDragEvent.NATIVE_DRAG_DROP: Que files and start processsing
• NativeDragEvent.NATIVE_DRAG_EXIT: Update visuals

A little background

Two weeks ago — together with several other contributors at Apt, Try and Paradox— I finished a three week long project for the Norwegian Department of Education. It’s a campaign website which aims to encourage people aged 18-24 to become teachers. The site is at www.hardudetideg.no/fremtiden (Norwegian) and it lets you place yourself or a friend as the main subject of a movie filmed in year 2069 about people looking back at their time in school, reminiscing about a teacher who changed their lives for the better. We incorporated run time motion tracking, grading and audio substitution to make it possible and it was a great learning experience for me.

The site has performed very well with 57 569 visits and around 15 000 produced movies over two weeks. In addition to that we seem to have hit the nail on the head demographically, with the majority of the Facebook users right smack down on the target group:

We have good numbers for feedback per share and average time on site as well. But while the response to the site has been overwhelming, what matters most to me is that there is nothing but praise to find when looking up referring sites and Facebook posts about the campaign and today even the Prime Minister of Norway chipped in:

The thanking part

I begun working at Apt this January and this is my project number four since then. It only shows what is possible in a skilled environment with jelled teams and proper project management. These are scarce luxuries that I have had to live without so far in my life.

I was fortunate to be the lead developer and I worked days and nights on this. But I only did the Flash development, and there were many others involved that did an outstanding job. Knowing how lucky I am to work with such awesome people, I feel compelled to give them credit in the best way I know.

• Paradox: They put together the team that shot, edited and mastered the film. This was no small task, with 30 people on set. I don’t know all of their names, but they all get at big hug from me. The names I know are Stefan Faldbakken (director) and Beate Tangre (producer).
• Knut Skåla: One of my colleagues at Apt who served as sort of a helper developer but in reality saved my ass on numerous occations because he knows so much more about Apt’s AS3 framework and the Facebook API than I do.
• Thomas Sømoen: Backend developer at Apt who shared the vision also worked late nights to make the deadline.
• Stina Norgren: Designer at Apt, the one who came up with the UI and the nice 3D touch to the interface. When I first saw her designs, I got really excited about making it work they way she had intended.
• Linda Tillier and Fred Khile: Project manager and consultant at Apt. People like these rarely get the credit they deserve, but the fact of the matter is that they have kept everything else in check, enabling me to keep my eye on the ball and only concern myself with the stuff that affects my part of the job. When I am surprised because great material for me to use simply arrives in my inbox before I have asked for it because someone else is taking pride in their job, these are the people to thank for that.
• Christian Pettersen: Compositor and effects engineer at Apt who also gave more than a days effort to deliver on this project. He kept the external production in alignment with the internal development and was an invaluable wizard when it comes to providing tracking data and retouching the movie for web delivery.

I’m priveleged to work in an agency that values the effort an collaboration of people like these so thank you!