A Widget wraps an object, its model, for display. The model can be a
simple Python object (string, list, etc.) or it can be an instance of model.Model. (The former case is for
interface purposes, so that the rest of the code does not have to treat
simple objects differently from Model instances.)
If the model is-a Model, there are two possibilities:
| Method Summary |
| |
__init__(self,
model,
submodel,
setup,
controller,
viewStack,
*args,
**kwargs)
|
| |
__getitem__(self,
item)
Convenience syntax for getting an attribute from the resultant DOM
Node of this widget. |
| |
__setitem__(self,
item,
value)
Convenience syntax for adding attributes to the resultant DOM Node of
this widget. |
| |
_regenerate(self,
request,
node,
data)
|
| |
_reset(self)
|
| |
add(self,
item)
Add `item' to the children of the resultant DOM Node of this
widget. |
| |
addEventHandler(self,
eventName,
handler,
*args)
Add an event handler to this widget. |
| |
addUpdateMethod(self,
updateMethod)
Add a method to this widget that will be called when the widget is
being rendered. |
| |
appendChild(self,
item)
Add `item' to the children of the resultant DOM Node of this
widget. |
| |
cleanNode(self,
node)
Do your part, prevent infinite recursion! |
| |
generate(self,
request,
node)
Allow a view to be used like a widget. |
| |
generateDOM(self,
request,
node)
Return a DOM Node to replace the Node in the template that this Widget
handles. |
| |
getAllPatterns(self,
name,
default,
clone,
deep)
Get all nodes below this one which have a matching pattern
attribute. |
| |
getAttribute(self,
item)
Convenience syntax for getting an attribute from the resultant DOM
Node of this widget. |
| |
getData(self,
request)
I have a model; however since I am a widget I am only responsible for
a portion of that model. |
| |
getPattern(self,
name,
default,
clone,
deep)
Get a named slot from the incoming template node. |
| |
getTopModel(self)
Get a reference to this page's top model object. |
| |
initialize(self,
*args,
**kwargs)
Use this method instead of __init__ to initialize your Widget, so you
don't have to deal with calling the __init__ of the superclass. |
| |
insert(self,
index,
item)
Insert `item' at `index' in the children list of the resultant DOM
Node of this widget. |
| |
modelChanged(self,
payload)
|
| |
onEvent(self,
request,
eventName,
*args)
Dispatch a client-side event to an event handler that was registered
using addEventHandler. |
| |
setAttribute(self,
item,
value)
Convenience syntax for adding attributes to the resultant DOM Node of
this widget. |
| |
setData(self,
request,
data)
If the return value of getData is a Deferred, I am called when the
result of the Deferred is available. |
| |
setDataCallback(self,
result,
request,
node)
|
| |
setError(self,
request,
message)
Convenience method for allowing a Controller to report an error to the
user. |
| |
setNode(self,
node)
Set a node for this widget to use instead of creating one
programatically. |
| |
setSubmodel(self,
submodel)
I use the submodel to know which attribute in self.model I am
responsible for |
| |
setUp(self,
request,
node,
data)
Override this method to set up your Widget prior to generateDOM. |
| Inherited from View |
| |
dispatchResult(self,
request,
node,
result)
Check a given result from handling a node and look up a NodeMutator
adapter which will convert the result into a node and insert it into the
DOM tree. |
| |
dispatchResultCallback(self,
result,
request,
node)
Deal with a callback from a deferred, checking to see if it is ok to
send the page yet or not. |
| |
getChild(self,
path,
request)
|
| |
getChildWithDefault(self,
path,
request)
|
| |
getNodeController(self,
request,
node,
submodel,
model)
Get a controller object to handle this node. |
| |
getNodeModel(self,
request,
node,
submodel)
Get the model object associated with this node. |
| |
getNodeView(self,
request,
node,
submodel,
model)
|
| |
getSubview(self,
request,
node,
model,
viewName)
Get a sub-view from me. |
| |
getTemplate(self,
request)
Override this if you want to have your subclass look up its template
using a different method. |
| |
handleControllerResults(self,
controllerResult,
request,
node,
controller,
view)
Handle a deferred from a controller. |
| |
handleDocument(self,
request,
document)
Handle the root node, and send the page if there are no outstanding
callbacks when it returns. |
| |
handleNewNode(self,
request,
returnNode)
|
| |
handleNode(self,
request,
node)
|
| |
handleOutstanding(self,
request)
|
| |
importViewLibrary(self,
namespace)
|
| |
lookupTemplate(self,
request)
Use acquisition to look up the template named by self.templateFile,
located anywhere above this object in the heirarchy, and use it as the
template. |
| |
recurseChildren(self,
request,
node)
If this node has children, handle them. |
| |
render(self,
request,
doneCallback)
|
| |
renderFailure(self,
failure,
request)
|
| |
sendPage(self,
request)
Check to see if handlers recorded any errors before sending the
page |
| |
setController(self,
controller)
|
| |
setSubviewFactory(self,
name,
factory,
setup,
*args,
**kwargs)
|
| |
setupAllStacks(self)
|
| |
setupViewStack(self)
|
| |
unlinkViews(self)
|