Package twisted :: Package web :: Package woven :: Module widgets :: Class File

[show private | hide private]
[frames | no frames]

## Class File

    View --+
           |
      Widget --+
               |
           Input --+
                   |
                  File

Method Summary
| ``__init__`(self, model, submodel, setup, controller, viewStack, *args, **kwargs)` (inherited from `Widget`)
| ``__getitem__`(self, item)` Convenience syntax for getting an attribute from the resultant DOM Node of this widget. (inherited from `Widget`)
| ``__setitem__`(self, item, value)` Convenience syntax for adding attributes to the resultant DOM Node of this widget. (inherited from `Widget`)
| ``add`(self, item)` Add `item' to the children of the resultant DOM Node of this widget. (inherited from `Widget`)
| ``addEventHandler`(self, eventName, handler, *args)` Add an event handler to this widget. (inherited from `Widget`)
| ``addUpdateMethod`(self, updateMethod)` Add a method to this widget that will be called when the widget is being rendered. (inherited from `Widget`)
| ``appendChild`(self, item)` Add `item' to the children of the resultant DOM Node of this widget. (inherited from `Widget`)
| ``cleanNode`(self, node)` Do your part, prevent infinite recursion! (inherited from `Widget`)
| ``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. (inherited from `View`)
| ``dispatchResultCallback`(self, result, request, node)` Deal with a callback from a deferred, dispatching the result and recursing children. (inherited from `View`)
| ``generate`(self, request, node)` Allow a view to be used like a widget. (inherited from `Widget`)
| ``generateDOM`(self, request, node)` Return a DOM Node to replace the Node in the template that this Widget handles. (inherited from `Input`)
| ``getAttribute`(self, item)` Convenience syntax for getting an attribute from the resultant DOM Node of this widget. (inherited from `Widget`)
| `getChild(self, path, request)` (inherited from `View`)
| `getChildWithDefault(self, path, request)` (inherited from `View`)
| ``getData`(self, request)` I have a model; however since I am a widget I am only responsible for a portion of that model. (inherited from `Widget`)
| ``getNodeController`(self, request, node, submodel, model)` Get a controller object to handle this node. (inherited from `View`)
| ``getNodeModel`(self, request, node, submodel)` Get the model object associated with this node. (inherited from `View`)
| `getNodeView(self, request, node, submodel, model)` (inherited from `View`)
| ``getPattern`(self, name, default, clone, deep)` Get a named slot from the incoming template node. (inherited from `Widget`)
| ``getSubview`(self, request, node, model, viewName)` Get a sub-view from me. (inherited from `View`)
| ``getTemplate`(self, request)` Override this if you want to have your subclass look up its template using a different method. (inherited from `View`)
| ``getTopModel`(self)` Get a reference to this page's top model object. (inherited from `Widget`)
| ``handleControllerResults`(self, controllerResult, request, node, controller, view, success)` Handle a deferred from a controller. (inherited from `View`)
| ``handleDocument`(self, request, document)` Handle the root node, and send the page if there are no outstanding callbacks when it returns. (inherited from `View`)
| `handleNewNode(self, request, returnNode)` (inherited from `View`)
| `handleNode(self, request, node)` (inherited from `View`)
| `handleOutstanding(self, request)` (inherited from `View`)
| `importViewLibrary(self, namespace)` (inherited from `View`)
| ``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. (inherited from `Widget`)
| ``insert`(self, index, item)` Insert `item' at `index' in the children list of the resultant DOM Node of this widget. (inherited from `Widget`)
| ``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. (inherited from `View`)
| `modelChanged(self, payload)` (inherited from `Widget`)
| ``onEvent`(self, request, eventName, *args)` Dispatch a client-side event to an event handler that was registered using addEventHandler. (inherited from `Widget`)
| ``recurseChildren`(self, request, node)` If this node has children, handle them. (inherited from `View`)
| `render(self, request, doneCallback)` (inherited from `View`)
| `renderFailure(self, failure, request)` (inherited from `View`)
| ``sendPage`(self, request)` Check to see if handlers recorded any errors before sending the page (inherited from `View`)
| ``setAttribute`(self, item, value)` Convenience syntax for adding attributes to the resultant DOM Node of this widget. (inherited from `Widget`)
| `setController(self, controller)` (inherited from `View`)
| ``setData`(self, request, data)` If the return value of `getData`is a Deferred, I am called when the result of the Deferred is available. (inherited from `Widget`)
| `setDataCallback(self, result, request, node)` (inherited from `Widget`)
| ``setError`(self, request, message)` Convenience method for allowing a Controller to report an error to the user. (inherited from `Widget`)
| ``setNode`(self, node)` Set a node for this widget to use instead of creating one programatically. (inherited from `Widget`)
| ``setSubmodel`(self, submodel)` I use the submodel to know which attribute in self.model I am responsible for (inherited from `Input`)
| `setSubviewFactory(self, name, factory, setup, *args, **kwargs)` (inherited from `View`)
| ``setUp`(self, request, node, data)` Override this method to set up your Widget prior to generateDOM.
| `setupAllStacks(self)` (inherited from `View`)
| `setupViewStack(self)` (inherited from `View`)
| `unlinkViews(self)` (inherited from `View`)

Method Details

### setUp(self, request, node, data)

Override this method to set up your Widget prior to generateDOM. This is a good place to call methods like `add`, `insert`, `__setitem__` and `__getitem__`.

Overriding this method obsoletes overriding generateDOM directly, in most cases.

  Parameters:
    `request`
    (type=`twisted.web.server.Request`.)
    `node` - The DOM node which this Widget is operating on.
    `data` - The Model data this Widget is meant to operate upon.
  Overrides:
    `twisted.web.woven.widgets.Widget.setUp` (inherited documentation)

Generated by Epydoc 1.1 on Thu May 8 13:17:10 2003 | http://epydoc.sf.net