Here is how:
1) apply flash.display.BlendMode.LAYER to the parent object
2) apply flash.display.BlendMode.ERASE to your inverse mask object
3) Awesome.

After working on a project for a while utilizing native as3 3d space, moving objects along the z axis, rotation and having the time of my life,
I realized that as soon as you try something stupid like that, every object will be blurred even if you reset their position to their original 2D positions, with no rotation, and the z position set to 0.

The designers would, of course, have none of it.

If any of you have encountered this issue and need a workaround, here is one:

1) remember your objects x/y positions
2) set your matrix3D to null (someObject.transform.matrix3D = null)
this will place your objects in your corner, so you need to
3) reset x/y on your objects. you know them from 1)

For example:

var position:Point = new Point(content.x, content.y);
content.transform.matrix3D = null;
content.x = position.x;
content.y = position.y;

But i can’t help but feel there is something to how i do things that must be at the very least affirming to some developers out there. Flash developers often work alone or in small groups, and few really have a big community to hang out with. It creates an atmosphere where you are never really comfortable with your own skill level, and for me at least it fostered a belief that everybody out there were doing rocket science and I was still building Lego cars and didn’t even bother to make the colors uniform.

I’ll write down some specific beliefs that have helped me a lot.

Object-oriented programming is there to make your life easier, not the machine’s.

When AS2 first dropped on us and i was firmly embedded in AS1 and prototype hacking, i could barely grasp the need for inheritance, and interfaces came much later. I was comfortable with functions-as-classes, long rambling frame scripts and include statements, and i felt like i was on top of the platform and what it could do.

Every time i tried to read about OOP i would be drowned in talk about design patterns and other things that are only really material from a philosophical point of view, but are often portrayed as fact, and digging your way through the religious forum conflicts you find out there can serve as a royal boot to the head if you’re trying to find your way in. My first bumbling steps into OOP were moving from include statements and frame scripts into a single frame script that instantiated an Application class. The actual difference was semantic at best, but it felt good  to test the waters.

The actual BOOM moment where i suddenly “got it” was when i started doing application design on paper. Previously I’d drawn visual states -Big boxy wireframes and rough line charts- and eyeballed the code from there, which was good while i was in the moment, but hell to return to a while later. When putting down thoughts i stopped writing MovieClip or Button, String and Array, and instead started naming things just what i physically imagined them to be. It’s an obvious thing in retrospect, but much like understanding Arrays and other such abstractions that no longer name objects, it was a huge mental tectonic shift. An image isn’t a MovieClipLoader in a MovieClip, it is simply an Image.  The change in work process was literally over night. I stopped starting at Application.as and working my way outwards. I started creating dozens of stub classes simply to have the names and concepts in place before i began the actual coding.

It dawned on me that OOP didn’t just let me apply programming principles i felt were beyond my need. It let me alter the fundamental constructs of the programming language. By compartmentalizing problems, i had been given the opportunity to break an application down into dozens of individual small problems that were typically easily surmountable, that in concert could be used to solve even bigger problems. A hypothetical image gallery is an ImageGallery loading xml into an ImageList containing ImageListItems consisting of an Image and an ImageInfoOverlay. I don’t have to worry about how the Image is displayed in the ImageList, the Image handles that. I don’t have to worry about what information to display about an image on mouseover, the ImageInfoOverlay does that.  Mentally, i’m not thinking about abstractions like sprites or arrays anymore; Those are simply words i use to describe a concept. The concept is what actually matters.

In summary: OOP lets you dictate the language in which you write your application. It is this key principle that lets a developer move from one OOP language to another with relative ease. I shudder to think what i would have gone through trying to learn C++ or C# with only AS1 under my belt. If i have any specific wisdom I’d like to impart on a developer new to OOP concepts, it would be this: Make it easy for yourself first, and you’ll be typing what is natural to you.

It is okay to have many classes, it’s okay to be verbose, and it’s okay to be an idiot

Actually, the more classes the better, because with every class you are bending the language semantics to your will. This comes down to the absolute basics. Say you are implementing a geometry algorithm for the first time. The document you are learning from refers to points as vertices. At this point, i would typically create a class named Vertex that simply extends Point and does nothing more than call super(). All i have done here is change the name of the Point class. Why? Because it’s one less step for my brain to walk while i’m learning this new algorithm.

I’m an artist first. I began as a designer, I consider myself a musician first, and i have the attention span of a cat. In spite of this, i find programming hugely empowering and satisfying. It wouldn’t be half as fun if i wasn’t able to recognize that my brain simply works in visual and physical concepts, not deep abstraction. It’s a common saying that programming is like explaining to a really, really dumb person how to do something, but i think it’s important to realize that you are also talking to yourself most of the time.

I’m comfortable with my own inability to work effectively with heavily abstracted patterns like MVC, because they don’t speak well to me as a person. My goal is to complete a task and ship a product i feel good about, not successfully apply a design pattern someone else put together in their own language. Which brings us to the next point.

If it floats your boat…

Design patterns can be absolutely wonderful things, but they should in my opinion be read as philosophies, not sets of rules. It is entirely possible to work within a very abstract design pattern and not be aware that you are doing so. I cherry pick concepts from patterns that i like and apply liberally with little real concern beyond getting the job done with a minimum of pain; Patterns are typically merely solutions to generic problems, and there is no reason to be afraid of them, or treating them like a set of commandments.

You’ll find a lot of technical developers with a very technical point of view that will, for instance, decry the merits of a singleton, while as a developer under stress a singleton can be an enormous timesaver. Don’t let the philosophical debate around patterns stop you from reading into them and taking with you what you need. In the end it should all help YOU be a better and more effective developer and prevent headaches, not the other way around. My first venture into patterns, a rudimentary exploration of MVC, resulted in me actually feeling dumber than before, and was a serious setback for me as someone getting comfortable with new concepts.

Fuzzy coding is fine within a known system

Don’t be afraid to create utilities for speeding up your workflow, even if it does mean doing something “dumb”. Unless it’s realtime or inner-loop code, optimization isn’t something you should even have to consider for solving menial tasks. Here’s one of my favorite utilities of recent:

Say i want to set up a TextFormat with a font name. I know the font is called “whateverfont”, but the actual embedded name of the font if i want to refer to it embedded is case intensive and may have spaces or extra characters that I’m not aware of, such as Whatever Font STD. Before, this would entail using an enumerateFonts call to grab the font objects, and then manually look through them to get the correct font name. With this utility, i simply call FontUtils.getFontBySimilarFontName(“whatever”). It allows me to be fast and loose, at the cost of a couple of extra loops when it gets called, which is ONCE when i declare the TextFormat. This is a trade-off I’m very ready to make, and I don’t see why I shouldn’t be allowed to.

You should allow yourself to be fuzzy and loose when coding, because it, again, takes your mind off the menial boredom and keeps your eyes on the ball.

Have fun

Don’t let nerds and sourpusses bring you down. Programming isn’t “for smart people”. It’s just another language, albeit one where clarity is the point and not the model. Don’t let high-end tech-talk make you feel poorly about your skills. Don’t be afraid to mix and blend. Think naturally. When you are starting up, think about the product you are making and not the individual problems within it; You can solve each problem on its own. Whatever way you solved the problem, the problem remains solved.

Magical world of virtual trees

Today we launched our super hip Christmas card generator, where you can draw a tree, decorate it, and send it to a friend.
The tree is then planted in our mysterious Christmas tree mountain world for everyone to see.

In these green times – make a virtual tree and share the love here:  http://creunaclient.no/jul/

We are looking forward to seeing YOUR tree in the magical forest of virtual Christmascards.

It turns out, however, that this is very boring to do.

Instead, as i was playing around with the particles and various combinations and sequences of blend modes, I started listening to my current favorite contemporary composer, Max Richter, and I wound up making this thing instead. (Beware! Music! Also, CPU murder!)

This kind of thing just happens naturally when I start playing around. It’s not particularly complex technically, more a question of constantly tweaking values until you feel happy. In ActionScript terms, it’s a linked list object pool of 100k particles, a double buffer of bitmapdata, two blendmodes and a blurfilter, as well as a few tweaks timed to trigger at moments in the music. A mouse trailer tracks the, er, mouse, and samples colors from an underlying image. I don’t put much thought into the images i use for backgrounds, they’re more color palettes than anything else. The result in this case is a little chaotic i think, but the point for me was the music. I wanted something hypnotic and organic, sort of like thousands of leaves blowing in the wind, and i wanted it to lift and fall with the music. I think i did that pretty okay for a first ;-)

The music is Autumn Music 2 by Max Richter off his fantastic album Memoryhouse.

I’m still not 100% sure it’s a good idea to electrocute your eyes every few seconds. Feel free to complain about any headaches!

Just a real quick PSA to let you know that we’ve moved the RSS feeds over to feedburner.com. I believe the transfer should be seamless, but just in cased someone feel stranded, just unsubscribe and re-subscribe to fix any problems.

We apologize for any inconvenience but we’re stat-whores, so we need to satisfy our curiosity.

That’s all.

Hear ye; Codesmiths and Script Artisans. Nay; Hear ye all who labour with keyboard and mouse, for you owe a debt to the singular person we commemorate today.

Ahem. On this day, the 10th of december, a shockingly large number of years ago the First Programmer was born. If this story isn’t old hat to you you might be surprised to learn the bearer of this distinct honorific was born in 1815 in London.
What might also surprise you, a pleasant surprise, is that she was a woman.

Ada Lovelace

Born Augusta Ada Byron she was the daughter of Lord Byron (he of poetry fame and infamy) and Anne Isabella Milbanke.
Her mother, who was not impressed with Lord Byrons debauchery and loose morals focused her education on mathematics and science, forbidding her to pursue the social sciences in order to prevent her from becoming a bohemian bum like her father. At seventeen Ada showed remarkable aptitude in mathematics and her interest continued even after her marriage; Contrary to the custom of women at the time.

Charles Babbage, her friend and fellow math wiz (amongst other things) had been working with logarithms and in an effort to remove uncertainty and human errors in this line of work he conceived of a Mechanical Computing Device to replace the traditional system of the time which were human clerks with the title ‘Computer’; “One who computes”.

Babbage; For all his genius ground work, was severely limited in his conception of the computer. He saw it as a mechanical means to execute mathematical operations with high precision. Enter our heroine Lady Lovelace.

In 1842-43 she translated a memoir of italian mathematician Luigi Menabrea on Babbages conceptual machine. Her additional notes were longer than the memoir itself, and substantially more visionary in nature. In these notes she conceived of making the analytical device accept, comprehend and execute commands; In essence creating the first programming language.

Babbage was never able to actually create his machine, and Ada never got to see the fruits of her labour. Vindicated in history her notes are published and distributed today, she has post-humously been awarded a medal from The British Computer Society and the contemporary programming language Ada is named in her honor. As a side note; Babbages machine have later been constructed as per his notes and was found to be highly accurate at mathematical operations.

Why should we care?

Geek holidays are great, and we need more of them. But if you look at the notable dates and personalities in this industry there are two factors that separate Ada Lovelace from the rest.
Firstly; she is by far one of the strongest examples of the long heritage of brilliant people on whose shoulders we stand to todays technology. Secondly: and it’s sad that this should matters, but it remains to be a factor and an important one at that; She is a woman. Our industry is heavily male-dominated. Not only in our workplaces but also in our heroes and legends.
I mean no slight to Alan Turing, Steve Wozniak, Sir Tim Berners-Lee and their esteemed co-idols, but by god; this sausage party needs some dames.

Searching for “Ada Lovelace” yields among other links a page that declares 24th of March to be Ada Lovelace Day and ask bloggers to pledge to write a post about Ada. Since the site seemed defunct after this date I propose that Ada Lovelace Day should be her birthday; the 10th of December and that we geeks make room for it among Towel Day, Blue Beanie Day and PI Day so this amazing historical figure gets the attention she deserves.

Who’s with me?

Further studies.

• The wikipedia article on Ada Lovelace from which most of this post was taken
• iTunes link for “The Enchantress of Numbers“. The episode of the great podcast “Stuff you missed in history class“.
• The difference engine; A site dedicated to the work of Charles Babbage.

This ability to “bend the dictionary” is the #1 reason i am in love with programming, and probably why i can stomach doing it for a living at all. Design patterns are Good Things, but overuse and attitudes bordering on religion take this flexibility and bashes it with rocks until you’re back to square one;  Speaking another people’s language.

There has been a lot of discussion in the Flash community recently about fundamental choices Adobe have made when developing ActionScript 3 and the Flash platform. Joa Ebert has essentially torn the Flash compiler a new one over its lack of efficient compile-time optimizations, and Robert Penner has been advocating a change in how Flash handles events, driving him to create his own alternative to the native event model, dubbed Signals.

The compound effect of these two figureheads of the Flash community openly questioning Adobe’s wisdom has had a wonderful effect; Adobe have become noticeably better at responding to the community in recent years, but the questions raised by Penner and Ebert dig deep. When these guys ask what’s going on, their followers start asking the same questions. Twitter has been buzzing with this new found skepticism of the Flash platform and the design of the ActionScript language It’s forcing Adobe to question themselves. Only good things can come from that, and Adobe commentary at this year’s Flash on the beach indicate that the arguments have not gone unheard.

I am, however, worried that all this discussion of development fundamentals is taking the focus somewhat off the ball within the community. The vibe I’m getting is that getting the ball in the net isn’t as important as the flair with which you do it. I didn’t get any such vibe during the AS1/2 days, where the end product on display was what was being judged. Now, developers may feel like they are not doing a good job unless they are doing so while executing triple backflips.

My favorite boogieman example today is the notion that listening to enter-frame is bad because it generates a new event object on every frame update. As we “all know”, generating objects is the slowest thing you can do in Flash. This is, to me, a sign of a complete lack of focus. This is developers looking for a problem in the wrong place. A particular tweet i read went along the lines of “With all this talk about Events and enter-frames, i don’t know what to program anymore”. What a nightmare! To have your fundamental technique be thrown into question; It’s almost as though you are LAZY if you don’t change your way of thinking! This is not the good kind of skepticism. This is the kind that destroys productivity.

To attack this example in particular, the notion that enter-frame is slow is a reflective question; Perhaps you shouldn’t be relying on dozens of enter-frame events? Enter-frame events are used for real-time applications, and a game loop model and a has-a relationship gets around this quickly and elegantly with only one enter-frame in a single spot, as they have in game development for ages. A single enter-frame dispatch is enough to drive your entire application. That a single object creation 60 times a second is somehow a noticeable impediment to performance is flat out absurd.

To say that differently, you can safely ignore this whole discussion and get on with your work. The community is *riddled* with examples like this, from the broadest strokes (what design pattern to use, and if you don’t use design pattern X you are failing at life), to the most granular details (use –i, because i– is slower). When all you want to do is create something amazing, why should you have to wade through this minefield of needless exposition? I’ve seen the most fundamental advertising campaign sites with little more than a few video players and some transitions built in overwrought MVC-a-likes. It’s absolutely absurd!

This is something that has bugged me for a while, i felt like i need to get this out, and I’m hoping for some discussion. All this granular dissection of the most fundamental building blocks of our application is, in 99% of cases, a case of premature optimization and a complete waste of time. Our goal should be to develop quickly, efficiently and create good experiences for our users, not over-engineer.

I strongly urge developers to not let the multitude of senior developer prophets out there confuse you and take your focus off what actually teaches you real world lessons; getting the job done. I’m as guilty as anyone of this, and I’m struggling with it on a day by day basis. A recent example is an origami folding engine i spent 2 days over-engineering to cope with any and all possibilities, and Anders just sits down and does exactly what the job requires and delivers on time.

I hope this doesn’t read as some sort of attack on the science of programming and the brilliant people out there sciencing it up, but I’m starting to feel like we need more duct tape, scissors and cardboard.

To people, (or at least to people with some computer competence) it’s pretty easy to see the difference between a seemingly valid URL and an invalid one. To a computer it’s a lot harder than you’d might think if you want it to be both flexible and accurate at the same time.

To clarify; I want to match any of the following URLS,

• http://www.domain.com
• www.domain.com
• domain.com
• subdomain.domain.com
• subdomain.domain.com/some/path?to&stuff
• www.domain.com/
• ftp://martin@domain.com:8080

Naturally, I do not want to match false positives such as

• http@\/\:www.domain.combo
• www.breakfast.com-org
• bad.punctuation
• http://.com

This has turned out to be a lot more difficult than I thought; and not only because the ActionScript implementation of RegExp is, in my opinion, flaky as hell, but because I found it hard to explain in rules that a computer understands, the human intuition that tells us “google dot com” is a good URL while “burger dot ham” isn’t.

I made an honest attempt at resolving this problem with the URLValidator class back in february. The class performs pretty well at validating and finding URLs. However it works by doing some nasty jumping through various string-parsing hoops, and I’m currently rewriting it to be a tad more legible and efficient. I’ll publish the code when it’s done, but I thought I’d share some of the lessons and frustrations I’ve had at this point.

Warning! This stuff is pretty geeky. No eye candy experiments here.

The components of a valid URL

So let’s have a look at what can, should, or may be found in a valid URL. I’ve made this handy chart as an intro (click for big version):

There are several points to be considered here:

• The protocol: Just matching literally http:// is at best naíve. There are multiple other protocols to consider. These days there seems to be even more of them as apps invent their own protocol prefixes. iTunes podcast prefixes start with itpc://, Spotify links have spotify:// and you can even send commands to TextMate with txmt://. Perhaps you don’t want to support all these crazy protocols, but you need to at least be able to accept ( http | https | ftp ). Matching the protocol is also extremely handy to use as a word boundary. That is; Search for something that looks like a protocol and that’s where we’ll start our matching.
  Seeing as I want the protocol to be optional there’s no such luck here though. In order to handle the protocol if it is present you might do something like this:
  • Does the string contain ://?
  • If yes, check for valid characters before the match and proceed to validate domain after the match.
  • If no; proceed to validate domain from the start of the string.
• The URL may contain the www. prefix, or it may not. It might include any number of subdomains or none at all. http://a.long.subdomain.bin-debug.net/ is a valid URL, so searching for www. is silly as it would exclude any other valid subdomain. Yes www. is certainly indicative of a URL, but in my opinion it should be treated as any other subdomain.
• Matching domain + Top Level Domain:
  Optional protocols, haphazard subdomains… Is there anything concrete left to match?
  Yes. Yes there is. Every valid URL will somewhere in it contain the following structure:
  
  [domain-name][.][TLD][(end-of-string | / | ? | : )] where
  • [domain-name] is a string of 1 or more characters in the range a-z, 0-9 or “-” and may not start with “-”
  • [.] is literally a period and absolutely nothing else.
  • [TLD] is one of the 267 legal Top Level Domains.
  • [(end-of-string | / | ? | : )] is either the “/” character, the “?” character, the “:” character (usually followed by numbers) or nothing at all. That is to say: If the next character is a space, the url string is at its end.
• After the domain-dot-TLD-/? sequence you’ll find all sorts of stuff. These are the legal characters you might run into: /~*?.,;:-%=_$s&’”@!)(][+. To be honest; If I manage to confirm a valid URL up to the character following the TLD I just run a match on those characters until I find a white space although there are probably some combinations of these legal characters that are not valid.

Ok. That's something to hang on to. Knowing that no white space is allowed in URLs, and that we can't rely on the handy protocol to find the beginning of the potential URL we instead fixate on this structure which is guaranteed to be present in a valid URL (disregarding IP-addresses for the moment.) Our method of matching should then, from a mile high view, be:

• Is there a valid domain-dot-tld-endcharacter structure present in the string?
• If yes, work backwards to find the legal structures of subdomains or protocols or end-of-string.
• Work forward to find end-of-string or illegal character.

Validating the Domain

Having decided to start with the root domain for your matching this is what you're looking for:

http://www.all.kinds.of.crap.domain-name.com/even/more?crap#here

 
If you match this unbroken sequence (remember [domain-name][.][TLD][end-of-string or ( ? | / | : )]) you have a starting point. Now you need to see if whatever comes before or after your match is valid.

The end of the TLD string is very important. Consider this; http://sub.combo.co/. In this case we find the “.com” first, but it isn’t followed by a legal end character. Moving on we see that .co however is, and identify the TLD correctly.

Verifying the TLD

At this point regular expressions won’t be able to help you any more. At least not efficiently. The Top Level Domain list just isn’t really mappable in patterns. Example. .cc .cd and .cf are all valid TLDs, but .ce is not. If you don’t really care whether the TLD is actually valid rather than just structurally sound you would typically match a string of 2-6 characters in the a-z range and leave it at that.
If you do want to make sure that domain.fuck or domain.yo aren’t regarded as positives and that the valid country codes .no and .ly are, there’s nothing for it but to use the actual list and loop through it.

For your convenience here is a code example of a Vector.<String> containing all TLDs and sorted by length.

Stop. Exhale.

The rest of the string

Once you’ve identified the aforementioned structure you need to look forward and backward in the string. When looking forward you’re typically looking for either an illegal character or whitespace and assuming the end of the URL at the matching point.
When you look backward there are several different options you need to match. You will be looking for either:

• A subdomain. These are groups of characters in the a-z,0-9 range or “-”, just like domain names. They are separated by dots and there doesn’t seem to be any limit to how many you can make, but usually you won’t find more than one of these.
• A protocol. Protocols seem to follow the same convention as domain names, except for a couple of characteristics.
  • They are followed by “://” rather than “.”
  • They’ll always be found at the start of the URL string, if present.
  • To my knowledge you can only have a single protocol in a URL.
• A user prefix. These are the ftp://martin@domain.com or https://user:password@domain.com variants.

Why can’t it ever be easy…
So a pattern to match whatever comes before the domain-dot-TLD-/? sequence would look something like this:

• Start from the beginning of the validated domain.
• Is there anything at all (except white space) before the validated domain?
• If yes; Does it contain “://”, and only once?
• If yes; is “://” preceded by a string of characters in the range (“a-z”, “0-9″, “-”)?
• If yes; Start from the end of “://”. Is there anything before the validated domain?
• If yes; Does it consist of valid domain strings separated by dots (“a-z” “0-9″ “-”) and alternatively either or both of “@” and “:”?

And so forth.

But wait!

So you’ve finally got it working perfectly. Your pattern gets matches on all the valid examples at the top of this post, and rejects all the false positives. Pat yourself on the back, and then consider this.

What about characters that invalidate your URL, but frequently occur in the wild? Or what about the characters that are allowed in the URL, but almost certainly were meant as punctuation.
For example:

• =”http:// isn’t valid as the beginning of a protocol, and .com” isn’t a valid TLD but you will probably run into this: <a href=”http://domain.com”>
• While “)”, “,” and “.” are legal characters in a URL, it probably wasn’t meant to be part of the link in this example:
  “W00t! Listening to TWIT (http.twit.tv).”
  However, in this case:
  “Have you guys heard of this? http://en.wikipedia.org/wiki/WWII_(disambiguation) “
  It’s actually meant to be included.

As is plain to see it’s not easy validating URLs with precision once you remove the protocols. It seems like it should be, but it’s not. I never got it to work, but just the fact that this pattern exists tells you something about just how frustrating an experience it is. The usual compromise is to decide (perhaps sensibly) that it’s not worth the effort to try and catch unlikely cases such as http://subdo://main.com since the chance of it occurring in the wild are slim. Me, I obsess about shit like this.

If any of you have some insights that I may have missed, be sure to leave a comment. I know that this text excludes both local characters (æøå) and IP-addresses, which is something I may or may not rectify.

I had a revelation today, and it makes me furious to the point of wall-climbing. I’m not going to mention names, but you know all that talk about how clickTAG doesn’t work in Flash 9+? Complete sham. First of all, since ad publishers are uniformly incapable of explaining the perceived “intricacies” of their magical clickTAG system outside of “Please copy this simple AS2 code into your application”, i’ll go through what clickTAG actually is, how i implement it, and a hilarious case of misinformation and unprofessional conduct indicative of certain elements of this industry.

Ready to know the AWESOME POWER of clickTAG? Drumroll. clickTAG is a flashvar containing the url to open. High tech! This URL points to a forwarding and tracking service, but beyond it being a valid URL it isn’t your problem anymore. It might as well be http://www.google.com for all you should have to care. The important thing to take with you here is that no matter how badly the publisher wants you to think there is MAGIC involved that you don’t understand, the tech is caveman simple, and the problem in 9/10 cases lies with the agency.

So how do we get this flashvar? In AS2, where near-every class was dynamic, flashvars were simply appended as properties to the root object. For instance, given the flashvar “foobar”, you could access it with _root.foo, or if working on root level of the timeline, simply refer directly to foobar. For instance, here’s a straight copy from a clickTAG guide:

This is, hilariously, the ONLY available documentation if you Google for official info, and it neglects to explain what would happen if you were to actually paste this code into a nested button or MovieClip.
This is where the clickTAG problem begins. It simply isn’t specific enough. For instance, in the previous example, the variable name is clickTAG. This is however not really a standard. It might be ClickTag, it might be clickTAG, it might be clickTag, or any combination of cases. For AS3, which is case sensitive, this is a no-go. You might have a perfectly workable clickTag implementation only to have the publisher reject it as non-specifically “wrong”, simply because their cases are nonstandard.

Our first problem then, is how do you get the right clickTAG variable, and from where. The stage and root objects of any relevant on-stage DisplayObject (Sprite, MovieClip) hold references to a LoaderInfo object, which in turn has a dynamic “parameters” object which is populated by the embed script. Thus, to get at “clickTAG”, you’d typically use something like this.

With that out of the way, how can we make our solution case insensitive? The natural solution, i feel, is to for-in through the parameters object, toLowerCase each variable name and get any matching results, as such:

From there on the rest becomes absolutely trivial.

1. MouseEvent objects have a target property pointing to whatever the user clicked
2. Whatever the user clicked is on stage
3. The stage has a loaderInfo property
4. And there we have our variables!

The result is a framework for a method we can call from wherever that will always know where the stage is, and will always know where to find the variables, and will always be case insensitive. In our implementation, this results in the following:

Using ExternalInterface
There is some debate, apparently, as to whether navigateToURL with a _blank target is “reliable”. It appears navigateToURL from older browsers may be misinterpreted as an automated popup and thus blocked regardless of user interaction. I have personally never encountered this issue, from testing with a multitude of browsers, so i’m taking this issue with a huge pinch of salt.
Regardless, the accepted “fix” to this problem is to circumvent navigateToURL altogether and instead call the Javascript window.open through ExternalInterface. I’m not sold on this, but i’ve implemented it anyway primarily just in case.

A tale of escapades
Today i had a long, winding, pointless argument with a publisher. We supplied a set of AS3 banners using the above method, which were rejected. Out of professional curiosity, i see it as my responsibility to figure out where this process fails, and if there is something i can do about it. Immediately i get the standard company line, copied straight out of the aforementioned clickTAG guide; An AS2 code example. I inform them in return that our implemented code in effect follows this standard to a tee, and that our application is Flash 9 only, and thus incompatible with their code snippet. We do not deliver content in outdated technology, so the problem stands; How do we make this work? We both work for the same client; isn’t it in our best interest to keep them happy?
The response is a rewrite of the same nonsense, with no further details given; This is obviously a person on the other end with little idea what she’s selling or how it works.

As this pointless exercise in “i’m right because i say so” goes on, i start doing more research; What possible method could they be using to validate these swfs? They’re obviously not implementing them in a standard way, because the standard way is toilet training simple, and we are supplying several sets of embedded examples that show clickTAG operating as expected, so what could they be doing? We come across INMA’s SWF clickTAG validator, which purports to judge whether a SWF has clickTAG properly implemented. Uploading our banners immediatly fails, but with the strange error message that clicktag is written as “ClickTag”, not “clickTAG”. Puzzling, since we don’t actually have any ClickTag strings in our banners at all. Cristobal points out that my ClickTag utility has that very same camelcase name. Hmm!

So we make a new SWF, drop in the following.

What do you know? This empty trojan SWF validates perfectly. After rapid-fire facepalms, we change the classname to clickTAG and retest our banners; They now validate perfectly.

In the meantime, the discussion with the publisher has rolled on; They have “tested the banners“, with our ClickTag class, “in 3 different systems and it doesn’t work“. We send over new banners with the renamed class. Oh but now they “work perfectly“!

Mind. Blowing.

Publishers are lying to us because they know next to nothing about what they are selling. They force us to use ancient technology (five years now since Flash 8!) under the pretense of some magical system they operate, that they themselves don’t know well enough to diagnose, and they don’t have the courtesy to be honest about that.

Flash developers; You do not need to use Flash 8/AS2, no matter what they tell you. You don’t. Don’t let these dinosaurs drag us down. Their time has obviously passed.