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.

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/

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

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

• Added BindLite.retrieveLast which lets you read the previous value of any bound property.
• Added public property autoDisposeBindings. Setting this to true will make BindLite dispose a binding if it no longer has any listeners after calling BindLite.unbind.
• Added public function BindLite.disposeBinding() to hard dispose a given binding.

This means you can now read the binding’s previous value when it gets set to a new value. This is useful for—say for instance—comparing an image gallery image index against its previous value to determine if the user clicked the next or the previous button.

This version also plays better with garbage collection because you can now have BindLite detect orphan bindings and remove them. Note that you need to specifically set autoDisposeBindings to true and actively remove a binding using unbind to make it run. You can also manually dispose a binding via disposeBinding(). Doing so will free all source and target refrences immediately.

BindLite is a lightweight, flex-less data binding alternative for AS3 applications. The reason I created it is to avoid including the flex.swc in my applications and to get a cleaner, more efficient syntax for data binding with better performance than the [Bindable] meta tag.

It is currently at version 0.9 for obvious reasons; I would like to hear from you about what you think, whether it works for you and if there are features it lacks. I have already tested it on two small projects and it has worked very well for me.

• Visit the project page for more info
• Visit the Google Code page
• Download the zip
• Read the docs
• Give me feedback

1. Open Terminal or whatever command line pertains to your system.
2. Use the “cd” command to navigate to the “bin” folder in the SDK folder you wish to use. In my case the complete command is “cd /Users/nord/as3/sdks/4.0.0/bin”
3. Paste the stuff below into a text editor that supports Regular Expressions (e.g. TextMate).
4. Replace all the paths based on the comments and run search/replace with this pattern: \[.+\]|\r|\n|\t (replace with nothing). This removes the comments and line breaks and creates a complete, but harder to read command that can be pasted into the command line.
5. Select all, copy, paste in the command line, press enter and you are done!.

bash compc
[Define SDK root folder + /frameworks here]
 -framework=
	/Users/nord/as3/sdks/4.0.0/frameworks
[Define target player]
 -target-player=
	10.0
[Debug false when creating libraries]
 -compiler.debug=
	false
[All referenced source folders]
 -source-path=
	/Users/nord/as3/libs/nordhagen/src/,
	/Users/nord/as3/libs/SWFAddress/2.4
[All referenced source SWCs]
 -library-path=
	/Users/nord/as3/sdks/4.0.0/frameworks/libs/player/10.0/playerglobal.swc,
	/Users/nord/as3/sdks/4.0.0/frameworks/libs/flex.swc,
	/Users/nord/as3/libs/Olog2/swc/Olog.swc,
	/Users/nord/as3/libs/TweenLite/greensock.swc,
[Only these sources are actually compiled]
 -include-sources=
	/Users/nord/as3/libs/nordhagen/src
[Path and file name to resulting SWC file]
 -output=
	/Users/nord/as3/libs/nordhagen/bin/nordhagen.swc

Notes

• -source-path and -library-path are source folders and swc files respectively. There is no special treatment for external/linked libraries. This actually confused me a little at first because the project’s main source folder and it’s external dependencies are treated so differently in most IDEs, but here they are equal. This is where you tell the compiler what folders/SWCs it needs to be aware of so to speak. At this point, these paths are solely used for compiler validation, they are not included in the SWC unless you also list them under…
• -include-sources is the list of source folders among those listed under -source-path/-library-path that should be included in the compiled SWC.
• Note that it you decide to format the command without the supplied RegEx, you need to make sure that the paths are separated only by the comma. No spaces!

That’s actually a good question. But it seems there’s no way to force a property to be passed by reference in AS3. The behaviour of most properties are to be passed by value, which means that if you write this:

var myValue:String = _myObject.value;

Then the value of _myObject.value is copied into the value of myValue and not further connection between the two is maintained. There are exceptions to this rule, Arrays being one of them. But in general this is how it works.

But sometimes you want myValue to continuously reflect the value of _myObject.value. Or maybe if you wanted another object to have access to the original object’s value, you would have to pass boh a reference to the object and the property name as a string. You would have to get a little dirty and use the AS3 equivalent of the old eval() function in AS2. In AS3, we do this with a string representation of the property name enclosed in square brackets, like so:

var myValue:String = _myObject["value"];

As we know, eval is evil because it’s slower and more error prone than accessing the property directly. Hence we need an elegant workaround that at the very least looks like we’ve made an attempt to formalize the situation. So I created a small example class.

package
{
	public class PropertyReference
	{
		private var _object:Object;
		private var _property:String;

		public function PropertyReference(object:Object, property:String):void
		{
			_object = object;
			_property = property;
		}

		public function get value():*
		{
			return _object[_property];
		}

		public function set value(val:*):void
		{
			_object[_property] = val;
		}
	}
}

As you see, all it does is store a reference to the object instance containing the property and the name of the property. It also contains getters and setters for hiding the grunt work of accessing and motifying the property. It does not help the speed issue, but it makes it less error prone. You would instantiate it like this:

var propertyRef:PropertyReference = new PropertyReference(_myObject, "value");

That means you only specify the string equivalent of the property name once, which makes it less error prone.

Just thought i’d share this class I made for doing ClickTag banner ads with AS3. It will get the clickTag url form root.loaderInfo. It will also use window.open for compability reasons with IE7 ans Firefox and it will also do logging so the website that will host it can tell if the clickTag is being read in correctly or not.

Here it is:

ClickTag.as