LoggedWebpage

abstract def accessLogDirectory: File

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def additionalInformation(): Option[String]

final def asInstanceOf[T0]: T0

def asynchronousLogging: Boolean

def body: Body

def byId[T <: Tag](id: String)(implicit manifest: Manifest[T]): Option[T]

def byName[T <: HTMLTag](name: String)(implicit manifest: Manifest[T]): Stream[T]

def byTag[T <: HTMLTag](implicit manifest: Manifest[T]): Stream[T]

def checkIn(): Unit

val childAdded: ChildAddedProcessor

val childRemoved: ChildRemovedProcessor

def clone(): AnyRef

val created: Long

def debug(message: ⇒ Any): Unit

def defaultTitle: String

def dispose(): Unit

final def disposed: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(message: ⇒ Any, t: Throwable): Unit

def error(message: ⇒ Any): Unit

def errorSupport[R](f: ⇒ R): Option[R]

Error Support wraps the supplied function so if an exception is thrown while invoking it will be properly reported via the pageError method.

def finalize(): Unit

def getById[T <: Tag](id: String)(implicit manifest: Manifest[T]): T

final def getClass(): Class[_]

def hashCode(): Int

def head: Head

lazy val hierarchicalChildren: List[HTML]

def html: HTML

def info(message: ⇒ Any): Unit

val intercept: MarkupIntercepting

final def isInstanceOf[T0]: Boolean

final def lifetime: Double

def listen[Event, Response, Result](name: String, priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response)(implicit eventManifest: Manifest[Event]): FunctionalListener[Event, Response]

val listeners: Listeners

def live[T <: HTMLTag](f: (T) ⇒ Unit)(implicit manifest: Manifest[T]): FunctionalListener[Markup, Unit]

Invokes the supplied function on all matching tags immediately and invokes on all new tags created at init time.

def log(level: Level, message: ⇒ Any): Unit

val logger: InnerLogging

def loggingClassName: String

implicit def manifest: Manifest[S]

def module(name: String): Option[Interface]

val modulesLoaded: TokenProcessor

val modulesLoading: TokenProcessor

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onReceive(request: HttpRequest, response: HttpResponse): HttpResponse

def pageError(t: Throwable): Unit

Pages should invoke this if an exception has been thrown to allow the webpage to gracefully handle the error.

val pageId: String

def pageLoaded(): Unit

Called after the page is (re)loaded.

val pageLoadedEvent: StandardHierarchyEventProcessor[Webpage[S]]

def pageLoading(): Unit

Called before the page is (re)loaded.

val pageLoadingEvent: StandardHierarchyEventProcessor[Webpage[S]]

def parentIntercept: MarkupIntercepting

def rendered: Boolean

def require(interface: Interface, default: Module): Unit

def require(interface: Interface): Unit

def require(name: String): Unit

def session(f: ⇒ Unit): FunctionalListener[Webpage[S], Unit]

Invokes the supplied function once-per session at page loading time.

final def stale: Double

val store: MapStorage[Any, Any]

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val thisListenable: Listenable

def timeout: Double

The amount of time in seconds this webpage will continue to be cached in memory without any communication.

def title: PropertyAttribute[String]

def toString(): String

def trace(message: ⇒ Any): Unit

def update(delta: Double): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def warn(message: ⇒ Any, t: Throwable): Unit

def warn(message: ⇒ Any): Unit

val website: Website[S]