Class n.l.LivePage(rend.Page):

Part of nevow.livepage View Source View In Hierarchy

A Page which is Live provides asynchronous, bidirectional RPC between
Python on the server and JavaScript in the client browser. A LivePage must
include the "liveglue" JavaScript which includes a unique identifier which
is assigned to every page render of a LivePage and the JavaScript required
for the client to communicate asynchronously with the server.

A LivePage grants the client browser the capability of calling server-side
Python methods using a small amount of JavaScript code. There are two
types of Python handler methods, persistent handlers and transient handlers.

1) To grant the client the capability to call a persistent handler over and over
    as many times as it wishes, subclass LivePage and provide handle_foo
    methods. The client can then call handle_foo by executing the following
    JavaScript:

      server.handle('foo')

    handle_foo will be invoked because the default implementation of
    locateHandler looks for a method prefixed handle_*. To change this,
    override locateHandler to do what you wish.

2) To grant the client the capability of calling a handler once and
    exactly once, use ClientHandle.transient to register a callable and
    embed the return result in a page to render JavaScript which will
    invoke the transient handler when executed. For example:

    def render_clickable(self, ctx, data):
        def hello(ctx):
            return livepage.alert("Hello, world. You can only click me once.")

        return ctx.tag(onclick=IClientHandle(ctx).transient(hello))

    The return result of transient can also be called to pass additional
    arguments to the transient handler. For example:

    def render_choice(self, ctx, data):
        def chosen(ctx, choseWhat):
            return livepage.set(
                "choosable",
                ["Thanks for choosing ", choseWhat])

        chooser = IClientHandle(ctx).transient(chosen)

        return span(id="choosable")[
            "Choose one:",
            p(onclick=chooser("one"))["One"],
            p(onclick=chooser("two"))["Two"]]

    Note that the above situation displays temporary UI to the
    user. When the user invokes the chosen handler, the UI which
    allowed the user to invoke the chosen handler is removed from
    the client. Thus, it is important that the transient registration
    is deleted once it is invoked, otherwise uncollectable garbage
    would accumulate in the handler dictionary. It is also important
    that either the one or the two button consume the same handler,
    since it is an either/or choice. If two handlers were registered,
    the untaken choice would be uncollectable garbage.

Split Table into Classes Show Methods in One Table