CacheAsBitmap with a mask breaks mouse events

If you have a sprite that has a mask and cacheAsBitmap set the true, the display object will no longer dispatch mouse events.

In this example, I’m using a PNG that’s partially transparent as a mask and it’s masking a black square. This type of mask only works when cacheAsBitmap is set to true for both the mask and the maskee. The result is a working mask, but the maskee will no longer dispatch mouse events.

[Embed(source="books.png")]
protected var Books:Class;
 
public function CacheAsBitmapAndMask()
{
	var books:Bitmap = new Books();
 
	var square:Sprite = new Sprite();
	square.graphics.beginFill(0x000000);
	square.graphics.drawRect(0, 0, books.width, books.height);
	square.graphics.endFill();
 
	square.addChild(books);
	square.mask = books;
	square.cacheAsBitmap = true;
	books.cacheAsBitmap = true;
	addChild(square);
 
	square.addEventListener(MouseEvent.CLICK, clickHandler);
}
 
protected function clickHandler(event:MouseEvent):void
{
	trace('click');
}

Filter and a mask breaks mouse events

At its core, this quirk seems to be the same as the previous one. In this example I have a shape masking a sprite and the sprite has a drop shadow. It’s important to remember that adding a filter to a display object will automatically set cacheAsBitmap to true. The display object again will not dispatch mouse events.

public class FilterAndMask extends Sprite
{
	public function FilterAndMask()
	{
		var mask:Shape = new Shape();
		mask.graphics.beginFill(0xff0000);
		mask.graphics.drawRect(25, 25, 50, 50);
		mask.graphics.endFill();
 
		var maskee:Sprite = new Sprite();
		maskee.graphics.beginFill(0x000000);
		maskee.graphics.drawRect(0, 0, 100, 100);
		maskee.graphics.endFill();
		maskee.filters = [new DropShadowFilter()];
 
		maskee.addChild(mask);
		maskee.mask = mask;
		addChild(maskee);
 
		maskee.addEventListener(MouseEvent.CLICK, clickHandler);
	}
 
	protected function clickHandler(event:MouseEvent):void
	{
		trace('click');
	}
}

See https://bugs.adobe.com/jira/browse/FP-61 and https://bugs.adobe.com/jira/browse/FP-3818 for the bug reports.

You can work around this issue by wrapping the maskee in another sprite. Rather than setting the filter on the maskee, set it on the wrapper. Here’s an example:

public function FilterAndMaskWorkaround()
{
	var mask:Shape = new Shape();
	mask.graphics.beginFill(0xff0000);
	mask.graphics.drawRect(0, 0, 100, 100);
	mask.graphics.endFill();
 
	var maskee:Sprite = new Sprite();
	maskee.graphics.beginFill(0x000000);
	maskee.graphics.drawRect(0, 0, 100, 100);
	maskee.graphics.endFill();
	maskee.addChild(mask);
	maskee.mask = mask;
 
	var maskeeWrapper:Sprite = new Sprite();
	maskeeWrapper.addChild(maskee);
	maskeeWrapper.filters = [new DropShadowFilter()];
 
	addChild(maskeeWrapper);
 
	maskee.addEventListener(MouseEvent.CLICK, clickHandler);
}
 
protected function clickHandler(event:MouseEvent):void
{
	trace('click');
}

CacheAsBitmap breaks concatenatedMatrix and hitTestPoint()

When an ancestor of a given display object has cacheAsBitmap set to true, the display object’s concatenated matrix is incorrect. This also affects the validity of hitTestPoint() and probably some other functions as well.

In this example the ancestor has a filter which in turn sets cacheAsBitmap to true. When clicking on the child, the concatenated matrix reports tx=1 and ty=1. In this case, tx and ty are incorrect.

public function CacheAsBitmapConcatMatrix()
{
	var ancestor:Sprite = new Sprite();
	ancestor.x = 50;
	ancestor.y = 50;
	ancestor.filters = [new DropShadowFilter()];
 
	addChild(ancestor);
 
	var child:Sprite = new Sprite();
	child.x = 25;
	child.y = 25;
 
	var g:Graphics = child.graphics;
 
	g.beginFill(0x00dd00);
	g.drawRect(0,0,200,200);
	g.endFill();
 
	child.cacheAsBitmap = true;
	child.addEventListener(MouseEvent.CLICK, child_clickHandler);
 
	ancestor.addChild(child);
}
 
protected function child_clickHandler(event:MouseEvent):void
{
	var child:DisplayObject = DisplayObject(event.target);
	trace(child.transform.concatenatedMatrix); 
}

The workaround is fairly simple:

protected function getConcatenatedMatrix(source:DisplayObject):Matrix
{
	var concatenated:Matrix = source.transform.concatenatedMatrix.clone(); 
	var p:Point = source.localToGlobal(new Point(0, 0)); 
	concatenated.tx = p.x; 
	concatenated.ty = p.y;
	return concatenated;
}

See https://bugs.adobe.com/jira/browse/FP-121 for the bug report. This post is also helpful: http://www.sephiroth.it/weblog/archives/2008/03/cacheasbitmap_hell.php.

Mouse events dispatched for transparent portions of bitmaps

Add a bitmap with some transparent pixels to a sprite. If you then click the tranparent portions of the bitmap, the sprite will dispatch a click event just as it would if you clicked opaque portions. This is often not desired behavior as you may want the click to “fall through” to whatever display object is behind it. There’s no easy way to toggle this functionality either. Most workarounds are limited by the other quirks mentioned so far or are not dynamic enough for general use. The best workaround I’ve used so far is InteractivePNG created by Moses Gunesch.

Possibly unexpected dimensions after rotation and scaling

Take a 100×100 square and rotated it 45 degrees. What’s the width of the shape? In Flash-world, it’s 141.4, or in other words, the “bounds” of the rotated rectangle is 141.4 pixels across. What if I want to access the unrotated width again? For one, you can set the rotation back to 0 and then request the width. That’s generally not the greatest option. Another option is to get the bounds of the square within its own coordinate space. Here’s an example:

public function RotatedDimensions()
{
	var square:Shape = new Shape();
	square.graphics.beginFill(0xff0000);
	square.graphics.drawRect(0, 0, 100, 100);
	square.graphics.endFill();
	square.rotation = 45;
	addChild(square);
	trace(square.width); // Traces 141.4
 
	var internalBounds:Rectangle = square.getBounds(square);
	trace(internalBounds.width); // Traces 100
}

The best way I can describe what getBounds() is doing here is that it’s seeing the square without regard to its scale or rotation within its parent. It’s important to understand what this does when scale is introduced. Let’s take this example:

public function RotatedScaledDimensions()
{
	var square:Shape = new Shape();
	square.graphics.beginFill(0xff0000);
	square.graphics.drawRect(0, 0, 100, 100);
	square.graphics.endFill();
	square.scaleX = square.scaleY = .5;
	square.rotation = 45;
	addChild(square);
	trace(square.width); // Traces 70.7
 
	var internalBounds:Rectangle = square.getBounds(square);
	trace(internalBounds.width); // Traces 100
	trace(internalBounds.width * square.scaleX); // Traces 50
}

In this case the square’s been scaled down to half its original size and is rotated 45 degrees. If you ask for the width, flash reports 70.7. If you get the dimensions of the square within its own coordinate space, it will report 100 for the width. In other words, these are the unscaled, unrotated dimensions of the square. The third trace is an example of how to get the scaled but unrotated width of the square.

Invisible children contribute to parent’s dimensions

Create a child shape, set it to be invisible, and add it to a sprite. Even though the child is not visible, its dimensions still contribute to the parent’s dimensions. This may or may not be what you’re expecting, but there’s no way to easily toggle the inclusion of invisible children when calculating a display object’s dimensions.

Take this example:

public function InvisibleBounds()
{
	var container:Sprite = new Sprite();
 
	var left:Shape = new Shape();
	left.graphics.beginFill(0xff0000);
	left.graphics.drawRect(0, 0, 50, 50);
	left.graphics.endFill();
	container.addChild(left);
 
	var right:Shape = new Shape();
	right.graphics.beginFill(0xff0000);
	right.graphics.drawRect(0, 0, 50, 50);
	right.graphics.endFill();
	right.x = 50;
	right.visible = false;
	container.addChild(right);
 
	trace(container.width); // Traces 100
}

Even though the child on the right is invisible, the container still includes it in its dimensions.

See https://bugs.adobe.com/jira/browse/FP-741 for the bug report and some workarounds that work well but can be slow.

I hope that helps anyone running into the same issues. Please post a comment if you have quirks or tips of your own.

Before we get too far, be aware that these JavaUtils are currently for Windows only. Macs have their own version of the JRE that’s deployed through the Software Update feature so the process of detecting and installing the JRE is very different and is left for another day.

The Short Story

To get started with the utilities, first download the source by checking out the git repository or installing the sample application. If you choose to install the sample application, run the app and right-click on the stage to view the source.

The utilities include two executables:

1. whereis.exe – This is used internally by the tools. See the juicy details below if you care to learn more about this.
2. jre-blah-blah-blah.exe – This is the Windows JRE online installer found here: http://www.java.com/en/download/manual.jsp. This is the installer that is used to install a JRE of your choice if the user’s system does not have an adequate JRE already installed. Because it’s the “online” installer, it’s lightweight and lets you avoid bundling an entire JRE with your AIR app.

There are two main utility classes:

1. JavaValidationUtil – This is used to determine if the user has an adequate JRE installed. Call validate() and it will dispatch an event letting you know if the user has a JRE installed and if the version is sufficient.
2. JavaInstallUtil – This is used to install the JRE if needed. Call install() and it will dispatch an event letting you know when the installation is complete.

The Juicy Details

Let’s dig into the details of how this works. Support for running other executables as described below comes from the new NativeProcess in AIR 2.0.

Validation. The first chore is to validate whether the user has a JRE installed and, if so, whether the JRE is sufficient for the application’s needs. The developer provides the validation utility with a minimum acceptable version broken into four segments: major, minor, revision, and update.

Now we need to find the version of the installed JRE to compare. But first we need to find out where the JRE is installed if one exists. On Windows there’s an environment variable called PATH which contains several directories that should be searched to find an application when a command is executed in the command shell. When you open up cmd, for example, you can type “notepad” and hit enter. The fact that it’s able to open notepad isn’t magic. Windows simply searches the PATH directories for notepad.exe and then executes it.

We need to do the same thing to find the java executable (java.exe). On *nix operating systems this is pretty easy. There’s a simple tool called whereis that comes with the operating system that searches the paths to find a given executable. On Windows, not so much. Luckily, our friends over at Synesis have released a similar tool for Windows that allows us to do the same thing. We bundle whereis.exe with our AIR application.

We execute whereis.exe, passing in name of the executable we’d like to find (java.exe) as an argument. If we don’t find java.exe, the user doesn’t have a JRE installed–at least not in the PATH paths. And if a JRE does exist that’s not in those paths it could take a long time to find and we probably don’t want to mess with it anyway. If java.exe is found, we then execute it passing in the -version argument. Java will then output the version in a specified format that we can then parse. After we parse the version, we compare with the minimum acceptable version and dispatch appropriate events.

Installation. If no JRE is installed or the one installed isn’t adequate, the application would then generally notify the user they need a newer JRE and ask if they’d like to proceed with the installation.

If the user chooses to proceed, it’s time to execute the installer. But there’s a catch. In Windows, installer applications require “elevated privileges” before executing which means Windows nags the user asking for permission to install the JRE. If I were to double-click the installer when it was on the desktop, it would appropriately nag. However, if I execute the installer using AIR’s NativeProcess, nothing happens. No error, no output, no nagging, no installing, nothing. Is this a bug in AIR? Eight ball says signs point to yes, but who knows, maybe Windows is to blame.

In my search for a workaround I found that by executing the installer from the command shell, Windows again appropriately nagged. So then I tried executing cmd from AIR and having cmd execute the JRE installer by passing the path of the installer into cmd as an argument. What do you know–Windows nagged appropriately and off goes the installation as planned. When presenting this problem on the Adobe AIR forums, not receiving a response, then proposing the workaround, a member of the AIR engineering team seemed to think it was a good trick–nay, a great trick–so I guess that’s just the way we have to do things for now.

So first we use our trusty whereis.exe to find the location to cmd.exe. Then we use cmd.exe to execute our Java installer by passing the installer path into cmd as an argument. Windows prompts the user for permission and after permission is granted the installation proceeds as expected. After the installation is complete, we dispatch an appropriate event. Of course we also stay aware of fringe cases (like if the user cancels the installation) and likewise dispatch appropriate events.

Hopefully that’ll give you some good direction as you start your journey pairing your AIR app with Java. Now go make something freaking fetching awesome.

A pedestal elevates a washer or dryer so you don’t have to bend down as far. Yes, we’re that lazy. And tall. And the wifers has a bad back. And apparently the rest of America is in the same boat because you can purchase them at your nearest appliance store for a mere $200 or more per pedestal. No thanks. Instead, I bought a bunch of wood, screws, and paint from Home Depot and made our own. Homemade they cost around $30 per pedestal.

Here’s a tour:

Here’s the material I used for a single pedestal:

• (1) Top board: 27″ x 27″ x 23/32″ CDX plywood
• (1) Back board: 27″ x 15″ x 23/32″ CDX plywood
• (2) Side boards: 26 9/32″ x 15″ x 23/32″ CDX plywood
• (3) Top supports: 25 18/32″ x 3.5″ x 1.5″ aka two-by-fours
• (6) Side supports: 13 1/2″ x 3.5″ x 1.5″ aka two-by-fours
• 3″ and 2″ wood screws
• 1 liter black paint
• 3″ paintbrush

When I purchased the wood at Home Depot, they also cut the wood for me for free which was a huge score and saved me a bunch of trouble. I also used my electric sander to make sure the legs and supports were all even and get rid of any slivers. To help protect the floor and cushion any shaking, I glued straps of carpet to the bottom of the pedestal legs using Gorilla Glue.

Overall, we’re really pleased with the outcome. They do a great job holding the weight of the washer and dryer, look great, and saved us a bundle of money.

What is it?

RedLiteGreenLite is a small, simple app that allows a group of people to communicate the status of something. The status can be either red or green and the subject can be whatever. That may sound a bit general, but that’s the point. It can be used for whatever purpose your crazy mind can come up with. I’ll get you started:

1. At work, we have a single shower and a lot of shweaty guys after soccer. So we know when the shower’s available, someone can turn the status red when he enters the shower and turn it green when he exits. This way nobody has to keep stopping by the shower to see if it’s available. When it’s green, it’s available. When it’s red, it’s not.
2. At a call center, representatives are split into groups. When one group is on break, no other group is allowed to go on break. Again, when the status is red, a group is on break and other groups must continue attending the phones. When the lite is green, the next group is free to take a break.

The process is pretty simple: join a group. Other people join the same group. When others in the group change the status, you’ll be notified. When you change the status, others in the group will be notified. The status of the group will be persisted across sessions. In other words, if everyone logs out and then logs back in a week later, the status will remain as it was the last time it was set.

There’s no need to explicitly create a group. When you attempt to join a group, the group will automatically be created if it does not already exist.

The app is free. As in free free.

What technologies are used?

RedLiteGreenLite has a client portion and a server portion.

The client is the app users download and install on their computers. It’s built in Flex and published for AIR. It uses the RobotLegs MVCS framework and makes use of AMF remoting and messaging.

The server portion is built in Java using BlazeDS and is hosted on Google Apps Engine.

Ooh, that’s simply juicy. Tell me more.

Don’t mind if I do. First of all, BlazeDS is an open source implementation of AMF-based remoting and messaging. Natively it’s not compatible with Google Apps Engine, but I wanted to use GAE because it’s extremely scalable, it’s free (let’s be honest–I’m cheap like that–this is the main reason), and I wanted the challenge.

To get BlazeDS working on GAE, I recommend following Martin Zoldano’s blog post. Not only does he outline the steps you’ll need to take but he provides a critical patch to flex-messaging-core.jar as well. While you can find this patch re-distributed elsewhere, I recommend posting a comment requesting that he email you the patched jar. That’s how he seems to want to distribute his patch and I respect that. He’s really helpful and quick to respond so it shouldn’t be much trouble.

Once BlazeDS was set up and configured, I started to plan the architecture. First of all, I needed one client in the group to be able to send a message to the rest of the clients in the group. This could be achieved through the messaging service BlazeDS provides. However, messaging doesn’t store state; it just redistributes messages to clients. I needed the group’s status to be persisted to storage so (1) when a new client joins a group it can retrieve the group’s current status and (2) the group’s status can be retained even when no clients are connected.

By default, BlazeDS’s messaging configuration uses ActionScriptAdapter to receive and distribute messages between clients. It doesn’t persist messages. To do so, I extend ActionScriptAdapter and persist the status to Google Storage before sending the message out to the other clients. When clients connect to BlazeDS, they use remoting (not messaging) to retrieve the most recently persisted status for the group. After the initial status is retrieved, the client talks to other clients using the messaging service. You can see how this is set up in messaging-config.xml and PersistentASAdapter.java in the server code.

While GAE has been really nice to get the app up and running, it does have its downsides. To send messages between clients, BlazeDS can use a few different techniques:

• Simple polling. The client, at a standard interval, simply asks the server if there is any new information. The server responds to the request immediately regardless of whether there is new information.
• Long polling. The client sends a request to the server. The server holds onto the request until it has something useful to tell the client at which time it sends back the response.
• Streaming. The client opens an HTTP connection and the connection remains open. The server shoots messages down the connection whenever it has something to say. It’s an “infinate response”.

While each approach has its pros and cons, simple polling leaves a lot to be desired as it creates a lot of HTTP traffic. Unfortunately, from my testing and research, GAE doesn’t seem to support either of the other two methods. But hey, it’s free. If any of you have a java environment and would like to host RedLiteGreenLite so we can step up our game, let me know.

Last but not least, RedLiteGreenLite is open source. I’d love for you to fork the project and do something cool with it.

Now go have fun! Install the client using the badge at the top of the post or fork the project using the link below.

ImageInspector works with images of any aspect ratio. Also, you’ll notice the picture-in-picture will size itself to the aspect ratio of the image. Just set maxWidth and maxHeight and it won’t get larger than those dimensional limits.

The focal point is maintained during scaling. For example, zoom in, move the focal point to the corner of the image, zoom out, then zoom in. Notice that, as you zoom out and in, the focal point is maintained as much as possible.

The focal point and relative scale are both maintained during resizing. For example, if an image inside ImageInspector is at 200% of its “fit” size, ImageInspector is 100% width and height of the window, and the user starts making the window larger, ImageInspector will continue to scale up the image inside it, attempting to keep it at 200% of its “fit” size. Likewise, the focal point will be maintained while resizing the window as well.

Right-click the demo app to view the source. The app might take a little while to load because it contains two embedded high-res images.

The basic methodology is very similar to the Guess the Number game where you whittle down the options until you get to the one you’re after. With a few smart guesses, this can be decently efficient (~20ms). If you can come up with a more efficient or elegant way to accomplish the same task, post a comment below!

Exhibit A

As a boy scout I remember being taught principles of emergency preparedness. One of the principles stated that, when in an emergency, never say “Someone call 9-1-1!” Instead, point to a specific person and say, “You–call 9-1-1!”

The principle was simple and the difference small, but the effect of assigning specific responsibility could be a matter of life and death.

At my church I’ve been charged with the role of keeping membership records up to date. This includes updating the computer system when members move in or out of the church unit, receive or are released from callings, are baptized, are ordained to priesthood offices, etc. In order to get this information into the computer system, I first must receive or track down the required information. This is also the most difficult part of what I do.

When I was called to the position, very few, if any, processes existed for this exchange of information. Soon enough, I began to discover that several baptisms went unrecorded. The list of callings soon became outdated. The reason? A lack of processes and responsibility.

Who was responsible for delivering the information to me? Or was I responsible for asking someone else? If I should ask someone else, who should I ask? Who else needs to know?

When asking the advice of a superior, I received the following instruction. Forgive me if you’re not acquainted with LDS lingo.

(1) The clerk should give you the information.
(2) Or one of the bishopric.
(3) Or you could ask the president or secretary of the organization.
(4) Or you could write it down if it’s announced.

And that’s also the problem. Nobody knew who was supposed to do what and everyone thought everyone else was doing it. More avenues of communication can, and in this case did, actually decrease the effectiveness of communication. Just like telling everyone to call 9-1-1 in an emergency, a lack of declared responsibility resulted in no responsibility and what should have occurred didn’t occur at all.

Since then, we’ve begun a process where a certain form flows from one entity to another until it reaches my box. This is very effective in helping people know where the buck is–who currently is responsible for taking the next action. If everyone does his/her part, the paper should end up in my box and I make the appropriate updates. Unfortunately, this only covers a portion of the information that needs to be entered into the system, but it’s a good start.

Exhibit B

At work, we use programming frameworks to help out with our application development. After having worked at the company for six months, I noticed the framework we were using had been patched and plugged one too many times. In my “spare” time, I re-wrote the framework to give us a clean start. Although I had been charged with providing direction on that specific framework, I wasn’t ever declared the keeper of frameworks. Even so, other employees began asking why we weren’t using X framework or why we weren’t using Y standard.

Hmm…interesting question. The direct answer was probably that the company as a whole never decided otherwise. But maybe the question was deeper than that. Maybe the questioner wanted to know my personal thoughts on X framework. Thoughts I have and thoughts I can share. Or maybe the questioner wanted to know if we could use X framework? I don’t know. I wouldn’t mind making that decision, but I wasn’t really given the authority and frankly I didn’t want to steal authority from someone who had or thought they had such authority.

Fortunately, the company had some structural reorganization where a co-worker was officially assigned the responsibility of managing frameworks and standards. The immediate benefits are:

(1) Employees now know who they can lobby for change in frameworks and standards.
(2) The keeper of frameworks and standards knows he/she holds the responsibility and is empowered to effect change.
(3) The concerns and needs regarding frameworks and standards can be represented in appropriate meetings.
(4) The keeper of frameworks and standards can hopefully be recognized for service rendered.

Exhibit C

A few years ago I was an intern at ExxonMobil as a software engineer. Prior to the internship, I was used to start-ups and small businesses where I had a huge amount of control over most aspects of my work. If I ever needed an application on my computer, I installed it. No questions asked.

At ExxonMobil, I quickly discovered this wasn’t going to be the case. We quite literally had one person to set up authentication, one to set up computer hardware, one to set up the operating system, one to set up specific software, one to handle networking, one to handle support requests, and so on. On top of that, employees would have to funnel required forms through management to get approval for most any action.

My responsibility was to create a business application in ASP.NET. Incidentally, it was to implement yet another permissions-based process. To develop the application effectively, I needed Visual Studio on my machine. The paperwork had already started its journey before I arrived for the internship. By the end of the internship four months later, there was still no sign of Visual Studio on my machine. For four months I remote desktopped into a computer residing on another floor of the building that happened to have Visual Studio. Installing Firefox or the Firebug plugin to debug the application? There’s a form for that too.

There was a form for everything. To be fair, a lot of this “bureaucracy” was probably created in an effort to decrease legal risk and avoid yet another Enron scandal. Even so, the processes really hampered productivity and in the end influenced my decision not to join the company full-time.

Exhibit D

Several years back I worked for a company developing user interfaces for in-cab taxi internet and the company’s website. I worked directly under two co-founders who, to my knowledge, had the same level of decision-making power.

After developing a portion of the interface, I would show it to co-founder A who would request a change. I’d make the change, then show it to co-founder B who would then request a change in the opposite direction. I’d make the change, then show it to co-founder A who would request the opposite of what co-founder B requested. It wasn’t my intent to go back and forth between the two co-founders; it just so happened that one co-founder would be around when the other wasn’t. Rather than sitting around for the co-founder who made the request, I wanted to get quick approval so I could move onto the next task. This resulted in huge amounts of time going back and forth between opposing demands.

To some extent, this has happened at every job I’ve held. It’s almost inevitable, but the occasions should be few. In this case, it wasn’t a huge personal detriment because I was being paid hourly, but the company unnecessarily lost money and nobody likes being unproductive.

Find out who makes the decisions early on and which decisions they make. If the client doesn’t know, help them find out. If you as the consultant have been given decision-making authority, know which decisions that responsibility covers. And remember–even if someone has been delegated decision-making responsibility, they still almost always have a boss that can override their decision. A VP is still subordinate to the CEO. The CEO is still subordinate to the board of directors. The board of directors is still subordinate to the shareholders. The shareholders are still, in effect, subordinate to the customers. Even if someone has been delegated responsibility, the chances are you’ll still find someone “higher-up” that disagrees. Know who makes the decisions and be nimble.

Have experiences of your own? Care to share?

That’s right! I’m worth it! I’m worth L’Oréal beauty product and nobody can take that away from me. What else must I need for convincing? Why buy anything else? I’m going bold with L’Oréal and never coming back because I’m worth it.

But that’s not all. This morning my TV once again reminded me I’m worth it. CNN, America’s most trusted news source, interviewed a man in his 50s-ish who decided he was healthy enough to play the odds without health insurance. That’s not just my assessment; he literally acknowledged he was playing the odds. Good for him. Soon enough, he found out he had a cancerous growth in his neck and the operations to remove it would cost hundreds of thousands of dollars. Fortunately for him, he found a charitable organization that allowed him to get the operations he needed to remove the cancer. In the end, it cost the man $50,000 and the rest was paid on his behalf. What would he have done if that charitable organization did not exist? Poignant to rip the tears right out of my eyes, he, with some help from the reporter, finished up the interview with his delight that the health care bill passed because nobody should be placed in his situation–everyone deserves health care. Everyone deserves it. You deserve it. I deserve it. He deserves it. Because we’re all worth it.

Does a gambler deserve to be reimbursed for gambling his life’s savings away? Then why does this man, or anyone like this man, deserve (to have earned or merited) health care? For the mere act of breathing sweet air into his lungs? According to the reporter, this man was able to, and did, pay the $50,000 required of him. If he could pay $50,000, he could afford insurance. As Dennis Miller put it so plainly, “I want to help the helpless, but I could care less about the clueless.”

I feel bad the guy got cancer. I don’t feel bad he’s out $50,000. If you’re prepared to gamble, you better be prepared to lose.

I present the container panner. It’s a single class. Instantiate it and set the container property. That’s it. If you want, you can toggle the panning functionality and set custom cursors. Right-click to view the source. Go make something crazy.