ItemsSeqView

abstract def elem: ViewElement

abstract val items: Rx[Seq[Item]]

abstract def newItemView(item: Item): ItemView

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _element: ViewElement

def addItemView(item: Item, iv: ItemView): ItemView

def addView(view: ChildView): ParentView

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 bindElement(el: Element): Unit

Binds element attributes

def bindView(): Unit

def binders: List[ViewBinder]

def binders_=(value: List[ViewBinder]): Unit

def className: String

def clone(): AnyRef

def collectFirst[TOut](partial: PartialFunction[ChildView, TOut])(implicit where: Map[String, ChildView] = this.subviews): Option[TOut]

Collects data from first child view that satisfies the requirements

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 constructItemView(item: Item, mp: Map[String, Any] = Map.empty)(construct: (Element, Map[String, Any]) ⇒ ItemView): ItemView

Function to create Item.

def copyTemplate(): ViewElement

def createHTML(string: String): Element

Trick to create an html

lazy val defaultBinders: List[ViewBinder]

def defaultInjector: InjectorMagnet.Injector

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractStart(): Element

extracts element after which it inserts children

def finalize(): Unit

def findNearestParentViewName(el: Element): 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: ViewEvent, startWithMe: Boolean = false): Unit

Fires an event

def fromParents[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 getClass(): Class[_]

def getItemView(el: Element): Option[Attr]

def hasParent: Boolean

If this view has any parent.

def hashCode(): Int

lazy val id: String

Id of this view

def ifNoID(el: Element, title: ⇒ String): String

Makes id for the binding element

def ifNoIDOption(el: Element, titleOpt: ⇒ Option[String]): Any

def inject(viewName: String, el: Element, params: Map[String, Any]): ChildView

lazy val injector: ViewInjector[OrganizedView]

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

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

final def isInstanceOf[T0]: Boolean

def isTopView: Boolean

val itemViews: Var[Map[Item, ItemView]]

def loadElementInto(el: Element, 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 makeDefault(el: Element, props: Map[String, Any] = Map.empty): ChildView

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onInsert(item: Item): ItemView

def onMove(mv: Moved[Item]): Any

def onRemove(item: Item): Unit

var parent: Option[ParentView]

def propagate(event: ViewEvent): Unit

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

Propagates future to the top for some reason

def receive: PartialFunction[ViewEvent, Unit]

Event subsystem

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

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

refreshes child view

def refreshMe(newElement: Element): Unit

Replaces viewElement of the view and rebinds it

def removeItemView(r: Item): Unit

def removeSubViewsFrom(element: Element): 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: Element): Unit

Removes view, starts search from the top

def replace(newChild: Element, oldChild: Element, switch: Boolean = false): Any

Replaces elementes

def replaceHTML(newChild: Element, oldChild: Element, switch: Boolean = false): Any

def subscribeUpdates(): Unit

This function is very important as it monitors items updates

implicit var subviews: Map[String, ChildView]

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

Changes inner HTML removing redundant views

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

def template: Element

var templateDisplay: Dynamic

def template_=(value: Element): Unit

def toString(): String

var topView: OrganizedView

def unbind(el: Element): Unit

def unbindView(): Unit

lazy val updates: Rx[SequenceUpdate[Item]]

def viewElement: ViewElement

def viewElement_=(value: ViewElement): Unit

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

* Extracts view

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warnIfNoBinders(asError: Boolean): Unit

def withBinder(fun: (ItemsSeqView.this.type) ⇒ ViewBinder): ItemsSeqView.this.type

Returns myself with some binders

def withBinders(fun: (ItemsSeqView.this.type) ⇒ List[ViewBinder]): ItemsSeqView.this.type

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