Dynamic focus management [ AIR / AS3 ] - actionscript-3

Question

I've run into a situation with a project I'm working on and I'm hoping to get some insight on how I might go about tackling it. Basically I am writing an AIR/AS3 app that allows the user to move focus around using the arrow keys on the keyboard. The problem I am trying to over come is that the clips are dynamically placed so I have no idea ahead of time what their position will be relative to each other. In addition to that, all of the clips have different shapes and sizes, so part of the weirdness is that some clips would occupy multiple columns, or multiple rows if you were laying out their positions on a grid for example.
So, the goal would be to have some logic that evaluates all of the clips sizes and/or positions and creates some form of map that allows clips to know who their nearest neighbor is when pressing right, left, up or down. The question is, what is the best approach for tackling something like this? I ultimately need it to feel very natural when moving around, and be far more intelligent then a tab-index list for example.
If I haven't provided enough information, please let me know and I can share additional details as needed. Just didn't want to go all crazy trying to explain things to start with.
Thanks in advance for any help!
Using the reference image, assume block "D" has focus. Using the logic #Pier's provided below, if I was to press "UP", would it know to go to block "A", or would it go to block "B" because it's distance and angle are less? In this case I think the user would expect it to go to block "A", but I'm thinking the code would evaluate to block "B" if I understand it correctly.

Answer 1

Calculating the distance and relative angle between two clips is easy (simple trigonometry). here are the function to calculate distance and angle between 2 x,y positions.
function angle(x1,y1,x2,y2):Number{
return radToDeg(Math.atan2((y2 - y1),(x2 - x1)));
}
function radToDeg(angle:Number):Number{
// to convert radians to degrees
return angle * 180 / Math.PI;
}
function distance(x1,y1,x2,y2):Number{
var dx:Number = x1 - x2;
var dy:Number = y1 - y2;
return Math.sqrt(dx * dx + dy * dy);
}
Knowing that, simply look what arrow the user has pressed. Then look the angles and distances of the other clips, and look how many clips there are in current direction (eg: what clips have an angle offset less than +-45 degrees), then look which one is closer, then change focus if there is any clip that meets the conditions.
I presume you won't have hundreds of clips placed on the stage, because in that case you should only calculate the angles for the closest clips.

Answer 2

Sorry for the delay following up here, but I ended up solving my issue by dynamically generating a grid map of all the clips positions which then allowed me to scan in various directions to find the next clip getting focus. Here is an output based on the example picture I provided originally:
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,4]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-,-,-,-,-,-,-,-,-,5,5,5,5,5,5,5,5,5]
I've had to adjust the grid size to balance the performance vs. fidelity, but it seems to be working great in the various scenarios I needed it.
Thanks again for the help #Pier. Although I didn't end up using the ray casting approach, it was very informative learning about it. I could see how in a game for example that could be super powerful.