Warning! This is a heavily geeky Adobe Director post! This is something I’ve messed around with in Director for a while now, and I recently brought it up on Direct-L. A lot of people there hadn’t heard about it so I thought I’d blog about it here.

An object’s ancestor property allows you to attach a secondary object that will get events that the original object doesn’t get. For example you can attach a “car” child object as an ancestor to a “Probe” child object. Once you’ve done that, any events sent to “Probe” that the probe script doesn’t process will be passed on to “car”. If you’re confused, look it up in the help docs, because it’s only going to get , um, confusinger.

I discovered a while back that you can assign other types to a child object’s ancestor property and have the resulting object act like the ancestor’s ilk. And by “ilk” I mean lists, property lists, rect(), point(), image objects … you name it and it probably works.

Here’s an example. Let’s say I wanted a list that returned void whenever an out of bounds index was referenced. From a usage standpoint I’d want it to look like this:
ilist = [1, 2, 3]
Put ilist[4]
-- void
put ilist[0]
-- void
So that’s how we want it to work. But currently if you try this with Director, you’ll get errors if you try to access invalid pointers. However, using this trick we can build an overloaded list that will work the way we want to. Here’s some code that goes in a parent script:

-- Parent Script: "BetterList"

property ancestor

on new me
  ancestor = []
  return me
end

on getat me, iposition
  if iposition <1 or iposition > ancestor.count then return void
  return ancestor[iposition]
end

Notice how all this really does is assign an empty list to the ancestor, and a getat function that checks to see if the requested index is out of bounds. Now, if we do this:

ilist = new(script "betterlist")
ilist[1] = "hello"
ilist[2] = "there"

put ilist[1]
-- "hello"

put ilist[3]
-- Void

The ilist variable operates as a normal list: we can address it with brackets, and we can add items to the list like normal. However, when calling an out of bounds index, the list returns void. This is because the GetAt function (which bracket syntax is shorthand for) is being processed not by the list, but by my script. However, all other functions are unused by the child object and are therefore passed to the ancestor. On Direct-L Valentin Schmidt took my script and modified it to create a way to make a list that starts at 0 instead of one. This could be very useful when porting code from other languages where arrays start with zero:

--- parent script "zero_list"
property ancestor

on new me
 l = []
 repeat with i = 2 to the paramcount
   l.append(param(i))
 end repeat
 ancestor = l
 return me
end

on getAt me, pos
 if pos < 0 or iposition >= ancestor.count then return void
 return ancestor[pos+1]
end

on setAt me, pos, val
 ancestor[pos+1] = val
end

--- test
l = script("zero_list").new(1,2,3)
put l[0]
-- 1
l[0] = 23
put l[0]
-- 23

How useful is this hidden functionality? Only time will tell. It has worked with every data type I’ve tried. Drop me a comment if you’ve used this before or have any insight as to what can be done with it.

Reply to this | Trackback | | See Previous Entry | See Next Entry