[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dash-dev] easy listening
Bjorn and I have shown that we can write listeners in Monkey Script.
Our approach has been to write a series of scripts that share state
through common global scope, identified with the Scope metadata tag.
Although this demonstrates the generality of the current
implementation, it does not serve the need of casual scripting well.
I would like to write a single script and use additional metadata to
trigger the subscribe/unsubscribe logic expected of listeners. We are
considering adding a tag something like:
We solicit advice on this or other schemes to achieve the same
effect. Below are some thoughts that come to mind.
Allow casually written scripts to avail themselves to information
transmitted within Eclipse through listener protocols. Avoid
accidental dangling listeners by capturing as much of the listener
idiom in the metadata handlers as possible.
Metadata tag processing would parse the tag value using regular
expressions to find the object accessor function and an add listener
method. These would be evaluated as follows:
* The object accessor function would be evaluated by the script
engine to produce a wrapped java object. It would be an error for
the script to not implement the function or for the function to
return a non-java object other than null.
* The add listener method will be invoked through java reflection. A
corresponding remove message will be inferred and invoked too.
* The type of the addListener argument (this, above) will be
retrieved as part of the java reflection and a dynamic proxy created.
The proxy will necessarily invoke additional functions within the
script engine, wrapping and passing java arguments as indicated by
the particular method signature. A script need not implement all
* A user saves a script with the Listen: tag. The objectAccessor is
immediately invoked and if not null, the subscription is made and
If the script had a previously subscribed listener, it will be
unsubscribed before the new subscription happens.
* A user invokes a script's main through the monkey menu. Whether or
not the main is present, the listen unsubscription/resubscription
proceeds so that the object accessor has the opportunity to deliver a
* A user saves a script with an error or that otherwise foils the
unsubscribe/resubscribe mechanism. The user receives notification and
any dangling subscription is discarded.
* A user creates a stop-listening menu. It works by causing the
object accessor to return null. The listening stops with no error
Can we predict the pattern of addListener/removeListener methods. Are
there other pairs we should recognize?
Are there threading issues?
Can we parse the metadata with regular expressions? Are there
variations that people would expect to work that can't be parsed
without a context-free grammar.
Thanks and best regards. -- Ward