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)
|