templates and instances for custom controls (was: object scripts)

[Jonathan Lynch]

Good stuff...

However one goes about it, we are quite able to create objects that behave
in various ways with transcript.

However...

What if one wants to create a new type of custom object - say, a 3D object
veiwer.

A plain ol' basic object (like a field) does not require any scripts, and
can have many functionalities built into it at the level of Rev's C code...

A 3D object viewer probably would not work in transcript, because of the
intensive processing required to render an image. So, how could one create a
customized object of that sort?


On 2/27/06, Dick Kriesel <dick.kriesel at mail.com> wrote:
>
> On 2/26/06 11:41 AM, "Geoff Canyon" <gcanyon at inspiredlogic.com> wrote:
>
> > The Object Oriented way to do this is to define a new group type:
> > alertGroup, say. In the definition of the alertGroup, you include the
> > original mouseUp handler. Then any time you need a group that has
> > this behavior you declare it to be an alertGroup (instead of a
> > generic group). In every way it acts like a normal group, but when a
> > control in it is clicked, it displays a dialog with the name of the
> > control. If you need to make it a warning dialog, change the class
> > definition and the behavior everywhere changes.
>
> Here's a Transcript-based technique for treating any custom control as a
> template, by creating and deleting instances.  Each instance invokes
> handlers stored only in the template, by executing a Transcript "call."
> Here's an example:
>
> on mouseDown
> try
>    call the params of the uTemplate of the target
> end try
> pass mouseDown
> end mouseDown
>
> All the system message handlers like the above are stored in the
> instance's
> top-level script.  No component control within the instance has a script.
> Every control in the instance has property uTemplate.  A template can
> reside
> in a library, but doesn't need to.  A template can override or supplement
> the instance handlers like the example above, by setting properties in the
> template's uInstanceScript custom property set.  Templates and instances
> refer to each other using "rugged" long ids, which are native long ids
> stripped of any "of group id" clause.  Rugged ids don't fail when the
> developer moves a control to a different owner.
>
> To set that up, the developer creates an instance by sending a message to
> the template, passing a reference to the group that will be the owner of
> the
> new instance:
>
> send "template_createInstance tGroup" to tCustomControl
>
> That's it for the overview.  Here are most of the details:
>
> on template_createInstance pOwner
> if there is a group pOwner then
>    put the uRuggedLongID of the target into tTemplate
>    -- note: the template can be in a library stack
>    copy tTemplate to group pOwner
>    put the uRuggedLongID of it into tInstance
>    set the uInstances of tTemplate to \
>        the uInstances of tTemplate & tInstance & cr
>    -- note: the uInstances can guide a developer to propagate \
>    --       template changes out to the instances
>    set the uTemplate of it to tTemplate
>    set the script of it to the uInstanceScript of tTemplate
>    repeat with i = 1 to number of controls in it
>      set the uTemplate of control i of it to \
>          the uRuggedLongID of control i of tTemplate
>      set the script of control i of it to empty
>    end repeat
>    send "choose browse tool" to me in 0
> else
>    breakPoint
> end if
> end template_createInstance
>
> on template_deleteInstance
> put the uTemplate of the target into tTemplate
> if tTemplate is not empty then
>    put the uInstances of tTemplate into tInstances
>    filter tInstances without the uRuggedLongID of the target
>    set the uInstances of tTemplate to tInstances
> end if
> end template_deleteInstance
>
> getProp uRuggedID
> put the long id of the target into tLongID
> if word 1 of tLongID is not "stack" then
>    -- note: stacks do not have rugged ids
>    put word 1 to 3 of tLongID into tRuggedID
>    put offset(" of card id " & quote,tLongID) into tOffset
>    if tOffset > 0 then
>      put char tOffset to offset(space,tLongID,tOffset) - 1 of tLongID \
>          after tRuggedID
>    end if
> end if
> return tRuggedID
> end uRuggedID
>
> getProp uRuggedLongID
> put the uRuggedID of the target into tRuggedLongID
> put offset(" of stack " & quote,the long id of the target) into tOffset
> put char tOffset to -1 of the long id of the target after tRuggedLongID
> return tRuggedLongID
> end uRuggedLongID
>
> getProp uInstanceScript
> lock messages
> put the uInstanceScript of the target into tInstanceScript
> put cr & the uInstanceScript[word 1 of the target] of me \
>      after tInstanceScript
> unlock messages
> end uInstanceScript
>
> All the above handlers could be stored in a library, which could be called
> something like libTemplate, and which I could produce if people are
> interested.
>
> Any feedback?
>
> -- Dick
>
>
> _______________________________________________
> use-revolution mailing list
> use-revolution at lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your
> subscription preferences:
> http://lists.runrev.com/mailman/listinfo/use-revolution
>