ReactiveView

abstract def bindAttributes(el: HTMLElement, ats: Map[String, String]): Unit

abstract def elem: HTMLElement

abstract def makeDefault(el: HTMLElement, props: Map[String, Any] = Map.empty): ChildView

Works when injectors fails to create a view

abstract def params: Map[String, Any]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _element: HTMLElement

def addView(view: ChildView): ChildView

Adds view to children

final def asInstanceOf[T0]: T0

def ask[Value, Result](value: Value, startWithMe: Boolean = false): Future[Result]

Asks parent to provide some future

def attributesToParams(el: HTMLElement): Map[String, Any]

Turns data-param attribute into real param NOTE: If you want to pass other params to child views, just override this function

def bind(el: HTMLElement): Unit

Binds nodes to the element

def bindElement(el: HTMLElement): Unit

Binds element attributes

def bindRx[T](key: String, el: HTMLElement, rx: Rx[T])(assign: (HTMLElement, T) ⇒ Unit): Unit

Binds value to reactive property

def bindVar[T](key: String, el: HTMLElement, v: Var[T])(assign: (HTMLElement, Var[T]) ⇒ Unit): Unit

def bindView(el: HTMLElement): Unit

Fires when view was binded by default does the same as bind

def clone(): AnyRef

def collectFirstSubView[B](pf: PartialFunction[OrganizedView, B])(implicit where: Seq[ChildView] = this.subviews.values.toSeq): Option[B]

def collectFirstView[B](pf: PartialFunction[OrganizedView, B]): Option[B]

def createHTML(string: String): HTMLElement

Trick to create an html

def createView(el: HTMLElement, viewAtt: String): ChildView

Creates view

def dataAttributesOnly(ats: Map[String, String]): Map[String, String]

implicit def defaultInjector: Injector[OrganizedView]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findNearestParentViewName(el: HTMLElement): Option[String]

Finds a view that

def findSubView(viewName: String)(implicit where: Map[String, ChildView] = this.subviews): Option[ChildView]

def findView(viewName: String): Option[ChildView]

Finds view if it exists

def fire(event: BindingEvent, startWithMe: Boolean = false): Unit

Fires an event

final def getClass(): Class[_]

def hasParent: Boolean

If this view has any parent.

def hashCode(): Int

val id: String

Id of this view

def inject(viewName: String, el: HTMLElement, params: Map[String, Any])(implicit injector: Injector[ChildView]): ChildView

Extracts view by name from element

def isInside(element: HTMLElement, me: HTMLElement = this.viewElement): Boolean

checks if this view is inside some html element in the tree

final def isInstanceOf[T0]: Boolean

def isTopView: Boolean

def loadElementInto(el: HTMLElement, newInnerHTML: String, uri: String = ""): Unit

Overrides for load element into that includes view switching NOTE it always executes by top view (if this new is not top it redirects to topview)

def makeEventHandler[TEV <: Event, TV](el: HTMLElement, par: Rx[TV])(assign: (TEV, Var[TV], HTMLElement) ⇒ Unit): (TEV) ⇒ Unit

Creates and even handler that can be attached to different listeners

def makeId(el: HTMLElement, title: String): String

Makes id for the binding element

def name: String

final def ne(arg0: AnyRef): Boolean

def nearestParentOf[TResult](func: PartialFunction[ParentView, TResult]): Option[TResult]

Take nearest parent that satisfy partial function conditions and maps it to arbitary result In other words you can find a parent that satisfy your needs and extract everything you want from it

final def notify(): Unit

final def notifyAll(): Unit

def otherPartial: PartialFunction[String, Unit]

var parent: Option[ParentView]

def parseHTML(string: String): Option[HTMLElement]

def processUrl(url: String, relativeURI: Boolean = true): String

def propagate(event: BindingEvent): Unit

def propagateFuture(event: PromiseEvent[_, _]): Any

Propogates future to the top for some reason

def receive: PartialFunction[BindingEvent, Unit]

Event subsystem

def receiveFuture: PartialFunction[PromiseEvent[_, _], Unit]

def refreshChildView(viewId: String, newElement: HTMLElement): Unit

refreshes child view

def refreshMe(newElement: HTMLElement): Unit

Replaces viewElement of the view and rebinds it

def removeSubViewsFrom(element: HTMLElement): Unit

Removes all subviews that were inside element in the tree

def removeView(view: ChildView): Unit

Removes a view from subviews

def removeViewByName(nm: String): Unit

Removes view

def removeWithView(element: HTMLElement): Unit

Removes view, starts search from the top

def resolveKey[Result](key: String)(fun: PartialFunction[Any, Result]): Result

Resolves mandatory keys from either this view or parent view

def resolveKeyOption[Result](key: String, who: ReactiveView = this)(fun: PartialFunction[Any, Result]): Option[Result]

def resolveMyKey[Result](key: String)(fun: PartialFunction[Any, Result]): Option[Result]

def stackToString(e: Throwable): String

implicit var subviews: Map[String, ChildView]

def switchInner(el: HTMLElement, newInnerHTML: String): Unit

Changes inner HTML removing redundant views

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

def toString(): String

var topView: OrganizedView

def unbind(el: HTMLElement): Unit

def unbindView(): Unit

def viewElement: HTMLElement

def viewElement_=(value: HTMLElement): Unit

def viewFrom(el: HTMLElement): Option[String]

* Extracts view

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withParam(name: String, params: Map[String, Any]): Map[String, Any]

is overriden in parent views

def writeTree(level: Int = 0): String

prepares view tree for printing