Tag Archives: ActionScript

SWFAddress seo, the quick and dirty

SWFAddress from http://www.asual.com allows for easy deep linking of Flash sites. There’s quite a lot written about how to set SWFAddress up with SWFObject for deep linking but less about the SEO sample option.

The page for all samples can be found here. The SEO option is described as “Advanced sample which showcases the search engine indexing capabilities of SWFAddress 2.x. It also demonstrates the usage of query parameters and handling of 404 errors. The sample requires Apache 1.3+ and PHP 4+. ”

So here’s how to get the SEO alternative up and running. First thing if you have no local server installed, I recommend downloading xxamp lite from here. Xxamp is a handy apache/php5 distribution. Download .exe, install. That’s it. (However you can skip right to the code part below, this is just a tip.)

Now grab the flashdevelop project SWFAddressSEO.zip (if you don’t use Flashdevelop then Main.as is your init/document class). You can see the basic demo here. (- If you want to run it locally to experiment with further and you’ve installed xxamp lite just now then just unzip and place it in the htdocs folder and go http://localhost/SWFAddressSEO/bin.)

In the unzipped example you will find:

In the bin folder there’s two php files used for the SEO deeplinking. datasource.php is where the seo content resides for each section in the site. It contains a series of case statements with content for them:

1
2
3
4
5
6
7
switch($swfaddress) {
case '/':
echo('<p>At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio.</p>');
break;
case '/ABOUT/':
echo('<p>Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt.</p>');
break;

This content is explained by index.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<div id="content">
<div>
<h1><a href="<?php swfaddress_link('/'); ?>">HOME</a></h1>
<ul>
<li><a href="<?php swfaddress_link('/ABOUT/'); ?>">ABOUT</a></li>
<li><a href="<?php swfaddress_link('/CONTACT/'); ?>">CONTACT</a></li>
</ul>
</div>
<div><?php swfaddress_content(); ?></div>
</div>
<script type="text/javascript">
// <![CDATA[
(new SWFObject('<?php swfaddress_resource('/c.swf?datasource=datasource.php'); ?>', 'website', '400', '400', '9', '#FFFFFF', 'high')).write('content');
// ]]>
</script>

SWFAddress urls read out as http://www.domain.com/#/yourpagename.

The “#” is the signpost of an SWFAddress url. The URL is rewritten into http://www.domain.com/yourpagename/ which is the url that can be indexed. In the index.php this indexable url exists as a link in the html above. When someone visits the indexed address, a redirect is made to the SWFAddress url.

In the case of  Spiders/Bots the address is rewritten without any redirection to http://www.domain.com/?swfaddress=/yourpagename/.

If you right click on the example page either from your local running server or from the demo you will also see this at work with datasource. The datasource.php home content (first case statement) is written out to the page. So the datasource is basically what it sounds like: the data for the spider and indexable content.

So for each section in my dummy site there exists some latin text in the swf. It is just hard copied into my concrete Decorator (or whatever way you set things up with content if you build it from scratch in AS3). And then I just take that content and put that into the datasource.php for each section to mash up some searchable content reflecting the site.

A small caveat to throw in here if we go back to the screenshot of the project folder: notice the occurrence of a “c.swf” file. This is a very minimal stripped down loader that just loads in the main .swf. The reason for doing so is that if you have  a preloader in your main .swf, it will not work with the deep linked pages. It will only work with your direct url. This is so since the deep linked pages (for some reason) are reloaded twice. So having a thin loader that just loads the site will stop your preloader in your main.swf from breaking.

I will not say that much about how to implement the ActionScript API here as it’s already been covered a lot in posts. Just have a look at SWFAddressSite.as. This class imports the two classes SWFAddress.as and SWFAddressEvent.as. We then listen for an update from the API:

1
    SWFAddress.addEventListener(SWFAddressEvent.CHANGE, getValue);

The showPageByMenu() function sets the value of SWFAddress with the static method setValue:

1
    SWFAddress.setValue("/"+e.currentTarget.name)

All that is then needed to be able to trigger the different section’s from the browser is a way to read the value. The value comes as a property of the SWFAddressEvent object:

1
2
3
private function getValue (e:*):void {
    showPageByAddress(e.value);
}

And of course always set the value before you read it. That’s about it.

EventCurb.as , removeAllListeners(object)

In AS3 we can check if an object has listeners, as in:

1
if(object.hasEventListener( type))

. But there is no method for getting all the listeners of an object. Or more importantly for removing all of them. Doh.

The hackish approach to this is to subclass EventDispatcher and write some short code that keeps a reference to each listener.

Which is what my class EventCurb does. – I should say it’s written overnight so anyone that likes can go ahead and try break their application…

Usage is as Singleton:

1
var _ev: EventCurb = EventCurb.getInstance();

To add listener:

1
2
_ev.addListener(obj, MouseEvent.MOUSE_DOWN, someFunc);
_ev.addListener(obj, MouseEvent.MOUSE_UP, someFunc);

If you try to add the same listener twice you will get a trace telling you that listener is already added, and no addition occurs.

To get all listeners of an object:

1
_ev.getListeners(obj);

This returns an Array of all listeners assigned to object which can be traversed as arr[index].type, arr[index].listener.

To remove listener of object:

1
2
_ev.removeListener(obj, MouseEvent.MOUSE_DOWN, someFunc);
_ev.removeListener(obj, MouseEvent.MOUSE_UP, someFunc);

And finally to remove All listeners of an object:

1
_ev.removeAllListeners(obj);

You can copy the class from below or download it from here. Feel free to rewrite or improve upon as you so wish.

EventCurb.as

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package
{
import flash.events.EventDispatcher;
import flash.utils.Dictionary;
/**
* ...
* @author Thomas James Thorstensson
* @version 1.0.1
*/

public class EventCurb extends EventDispatcher
{
private static var instance:EventCurb= new EventCurb();
private var objDict:Dictionary = new Dictionary(true);
private var _listener:Function;
private var objArr:Array;
private var obj:Object;

public function EventCurb() {
if( instance ) throw new Error( "Singleton and can only be accessed through Singleton.getInstance()" );
}

public static function getInstance():EventCurb {
return instance;
}

override public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
{
super.addEventListener(type, listener, useCapture, priority, useWeakReference);
}

override public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
{
super.removeEventListener(type, listener, useCapture);
}

public function addListener(o:EventDispatcher, type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void {
// the object as key for an array of its event types
if (objDict[o] == null) objArr = objDict[o] = [];
for (var i:int = 0; i &lt; objArr.length; i++) {
if ( objArr[i].type == type)
trace ("_______object already has this listener not adding!")
return
}
obj = { type:type, listener:listener }
objArr.push(obj);
o.addEventListener(type, listener, useCapture, priority, useWeakReference);
}

public function removeListener(o:EventDispatcher, type:String, listener:Function, useCapture:Boolean = false):void {
// if the object has listeners (ie exists in dictionary)
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
for (var i:int = 0; i &lt; tmpArr.length; i++) {
if (tmpArr[i].type == type) objArr.splice(i);
}

o.removeEventListener(type, listener, useCapture);
if (tmpArr.length == 0) {
delete objDict[o]
}
}else {
trace("_______object has no listeners");
}
}

/**
* If object has listeners, returns an Array which can be accessed
* as array[index].type,array[index].listeners
* @param o
* @return Array
*/

public function getListeners(o:EventDispatcher):Array{
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
// forget trying to trace out the function name we use the function literal...
for (var i:int = 0; i &lt; tmpArr.length; i++) {
trace("_______object " + o + " has event types: " + tmpArr[i].type +" with listener: " + tmpArr[i].listener);
}
return tmpArr

}else {
trace("_______object has no listeners");
return null
}

}

public function removeAllListeners(o:EventDispatcher, cap:Boolean = false):void {
if (objDict[o] as Array !== null) {
var tmpArr:Array = [];
tmpArr = objDict[o] as Array;
for (var i:int = 0; i &lt; tmpArr.length; i++) {
o.removeEventListener(tmpArr[i].type, tmpArr[i].listener, cap);
}
for (var p:int = 0; p &lt; tmpArr.length; p++) {
objArr.splice(p);
}

if (tmpArr.length == 0) {
delete objDict[o]
}
}else {
trace("_______object has no listeners");
}
}
}
}

Formatting XML text with html tags +
the TextFormat Class

Recently I wrongly came to the conclusion that you can’t apply a TextFormat to dynamic textfield set to htmlText = “My text” without that the TextFormat overwrites the formatting done with html tags in the XML.

It turns out that the issue I was having had more to do with not being read up on the defaultTextFormat setter.

Let us take Arial as an example. To embed it in AS3 in bold, italic, and normal formatting we would like so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package
{
   import flash.display.*;
   import flash.text.*;

   /**
    * ...
    * @author Thomas James Thorstensson
    */

   public class TextFmt extends Sprite
   {

      [Embed(source='C:/Windows/Fonts/arial.ttf'
      ,fontFamily ='arialNormal'
      ,fontStyle ='normal' // normal|italic
      ,fontWeight ='normal' // normal|bold
      ,unicodeRange='U+0020-U+002F,U+0030-U+0039,U+003A-U+0040,U+0041-U+005A,U+005B-U+0060,U+0061-U+007A,U+007B-U+007E'
      //,cff='false'
      )]
      public static const arialNormal:Class;

      [Embed(source='C:/Windows/Fonts/arialbd.ttf'
      ,fontFamily ='arialBold'
      ,fontStyle ='normal' // normal|italic
      ,fontWeight ='bold' // normal|bold
      ,unicodeRange='U+0020-U+002F,U+0030-U+0039,U+003A-U+0040,U+0041-U+005A,U+005B-U+0060,U+0061-U+007A,U+007B-U+007E'
      //,cff='false'
      )]
      public static const arialBold:Class;
     
      [Embed(source='C:/Windows/Fonts/ariali.ttf'
      ,fontFamily ='arialItalic'
      ,fontStyle ='italic' // normal|italic
      ,fontWeight ='normal' // normal|bold
      ,unicodeRange='U+0020-U+002F,U+0030-U+0039,U+003A-U+0040,U+0041-U+005A,U+005B-U+0060,U+0061-U+007A,U+007B-U+007E'
      //,cff='false'
      )]
      public static const arialItalic:Class;

      public function TextFmt()
      {
         Font.registerFont(arialNormal);
         Font.registerFont(arialBold);
         Font.registerFont(arialItalic);
      }

   }
}

In our XML we can then directly refer to one of the versions of the font like so:

1
<xmlnode>Lorem ipsum<font face="arialItalic"> and some italic text</font> and end.</xmlnode>

If we set a dynamic textfield to the above content, we can still apply additional formatting to it
with a regular TextFormat as long as we use defaultTextFormat rather than setTextFormat :

1
2
3
4
5
6
arialNormal = new TextFormat();
arialNormal.font = 'arialNormal';
arialNormal.size = 11;
arialNormal.color = 0xCCCCCC;
myText.defaultTextFormat = arialNormal;
myText.htmlText= xmlnode;

The dynamic textfield will take the ‘arialNormal’ format without the arialItalic format being overwritten. The italic style will so to speak take on the arialItalic and the arialNormal.

If we instead would use setTextFormat after myText.htmlText= xmlnode; it would be the case that the formatting in the html would be overwritten by the TextFormat.

AS 3 Dictionary Object: a way to map instances of sealed Classes

In Action Script 3 most classes are sealed. This means that for most Objects we are not able to create new properties run time beyond those that where available compile time. This is not the case with Array and Object though which are both dynamic and regularly come in handy to us for example in the creation of an associative array (or sometimes called a ‘hash’) :

1
2
3
var myAssoc:Object = new Object();
myAssoc["oranges"] = 101;
trace ("number of oranges " + myAssoc["oranges"])

But what to do if you’re in need of creating properties upon an instance that belongs to a sealed class. For example say that we with flash.display.SimpleButton would like to add the property counter which tells us how what time interval to start a timer with. We could not:

1
2
3
(//import flash.display.SimpleButton etc...)
var myBtn:Simple Button = new SimpleButton();
myBtn.timestamp = 1000;

The above would throw an error as SimpleButton like most classes in ActionScript 3 are sealed. The solution would be to extend SimpleButton with a dynamic class like so :

1
2
3
4
5
6
7
8
9
10
11
package
{
import flash.display.SimpleButton;
public dynamic class DynamicButton extends SimpleButton
{
   public function DynamicButton()
   {

   }
}
}

Making use of our dynamic button we could now :

1
2
3
var dynBtn:DynamicButton = new DynamicButton();
dynBtn.timestamp = 1000;
trace ("dynamic button timestamp value " + dynBtn.timestamp);

And this would compile without errors and work nicely. However there is an other approach to this which comes very handy as a way of creating dynamic properties and referring to them. Here enters the Dictionary Object. This object is a bit like our associative array above but with the big difference that it can take an object itself as lookup key to find a value. For our oranges we get:

1
2
3
4
var dict:Dictionary = new Dictionary();
var myOrange:Object = new Object();
dict[myOrange] = 101;
trace ("number of oranges dictionary approach " + dict[myOrange]);

Using a Dictionary Object we thus have a way to lookup properties using the objects themselwes rather than using the variable names to refer to properties. This also works for instances of sealed classes such as our button example. We can write:

1
2
3
4
dict = new Dictionary();
var myButton: SimpleButton = new SimpleButton ();
dict[myButton] = 1001;
trace ("dictionary button counter value " + dict[myButton]);

Since the button is the key, it does not matter that SimpleButton is a sealed class. We are not trying to assign a new property to the SimpleButton instance by using a variable name. Instead we use the instance itself and thus we here have a handy way of assigning values also to instances that don’t take new dynamic properties.

Some further readings:
http://www.gskinner.com/blog/archives/2006/07/as3_dictionary.html
http://www.zombieflambe.com/actionscript-3/as3-dictionary-class-array-object-benchmark/
http://pixelwelders.com/blog/best-practices/2008/speed-tests-objects-vs-arrays-vs-dictionaries/