[OpenAjaxIDE] Ideas on distinguishing between widgets and gadgets
jferrai at us.ibm.com
Wed Aug 27 03:16:21 PDT 2008
As I remember from yesterday:
(1) We agreed that a widget probably needed special metadata, such as a new
attribute or some particular new usage of the <require> element, to say
whether or not it is a "gadget" (i.e., where the term "gadget" means
suitable for mashup environments)
(2) When I asked whether which of the following we would support of basic
widgets, mashupable widgets, or widgets that could work as either basic or
mashable widgets, we decided that there would only be two options: basic
widgets and mashable widgets.
(3) We decided that both kinds of tools (i.e., IDEs and mashup tools) would
support both types of widgets (i.e., basic and mashable).
(4) For IDEs to support mashable widgets, one option that looked attractive
was for OpenAjax to supply a reference implementation of either a
Before proposing solutions, does the above match what everyone else
remembers? Incidentally, I am highly positive about this general direction
of distinguishing between basic widgets and mashable widgets.
I will do a little cheerleading here to point out that we should be able to
achieve this distinction with only small changes to the existing
specification. After doing an inventory of the widget markup we have so
far, here are things that apply to basic widgets: <widget>, <category>,
descriptive metadata (including icons), compatibility metadata, property
transformations (@@foo@@) and localization transformations (%%bar%%). I
also think __WID__ applies to basic widgets, but we probably need further
discussion on that one. I will point out that these "basic widget" features
represent the vast majority of our current widget metadata.
Here are the small number of extra things within the current spec that only
apply to mashable widgets:
* <topics>/<topic> elements
* The 'publish', 'subscribe' and 'topic' attributes on the <property>
* Widget APIs (getConnectionHandle(), registerCallback(), getPropertyValue
(Am I missing anything?)
Here is a sketch of how we might proceed:
(1) Add the following feature to our XML format:
<require type="feature" name="OpenAjax.mashupwrappers"/>.
This tells IDEs that it needs to insert extra stuff into the HTML page so
that the widget won't crash when it attempts to call the widget APIs. By
using the feature approach, we allow the tool greatest flexibility in how
to deliver the required functionality (versus pointing to a particular
mashup wrappers. This will allow IDEs an easy path where they simply add
that we provide. Our open source reference implementation for IDEs would
only support OpenAjax Hub pub/sub within a single browser frame using Hub
1.1 APIs. Therefore, reference implementation would:
* support connHandle = wrapper.getHubConnection()
* support connHandle.publish().
* support connHandle.subscribe()
* listen for the document load event and invoke any callbacks registered
via wrapper.registerCallback('load', ...);
* return null for most everything else in our Widget APIs
(3) IDEs could choose to customize the open source we provide (or replace
it entirely) to provide additional functionality (e.g., resizing API
support). Mashup tools almost certainly would provide their own mashup
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the IDE