Menu

Instance Constructors

new Menu(title: String, origin: Vec, w: Int, items: Seq[A] = Seq(), fieldHeight: Double)

Type Members

case class MenuItem(pos: Vec, i: Int, isSelected: Boolean) extends Item[A] with Product with Serializable
type Self = Traversable[Item[A]]

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from Menu[A] to any2stringadd[Menu[A]] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ++[B >: Item[A], That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: Item[A], That](that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike
def ++:[B >: Item[A], That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike
def -->[B](range: Traversable[B]): Ordinal[Item[A], B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def -->[B](range: Bound[B]): OrdinalBoundedRange[Item[A], B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def ->[B](y: B): (Menu[A], B)

Implicit information
This member is added by an implicit conversion from Menu[A] to ArrowAssoc[Menu[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
def /:[B](z: B)(op: (B, Item[A]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (Item[A], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val a: Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, Item[A]) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def applyIf(t: Boolean, f: (Menu[A]) ⇒ Menu[A]): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def applyIf(t: (Menu[A]) ⇒ Boolean)(f: (Menu[A]) ⇒ Menu[A]): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B, That](pf: PartialFunction[Item[A], B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[Item[A], B]): Option[B]

Definition Classes
TraversableOnce
def companion: GenericCompanion[Traversable]

Definition Classes
Traversable → GenTraversable → GenericTraversableTemplate
def contains(mouse: Vec): Boolean
def containsSubsequence(ys: Traversable[Item[A]]): Boolean

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def copyToArray[B >: Item[A]](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: Item[A]](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: Item[A]](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: Item[A]](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: (Item[A]) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def countBy[B](f: (Item[A]) ⇒ B): Map[B, Int]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def countWhile(f: (Item[A]) ⇒ Boolean): Int

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def drop(n: Int): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def dropWhile(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def elementOf(xs: Set[Menu[A]]): Boolean

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def ensuring(cond: (Menu[A]) ⇒ Boolean, msg: ⇒ Any): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to Ensuring[Menu[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (Menu[A]) ⇒ Boolean): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to Ensuring[Menu[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to Ensuring[Menu[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to Ensuring[Menu[A]] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evens: TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def exists(p: (Item[A]) ⇒ Boolean): Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (Item[A]) ⇒ Boolean): Option[Item[A]]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def fitString(sizes: Int*): String

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def fitString: String

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def flatMap[B, That](f: (Item[A]) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: (Item[A]) ⇒ GenTraversableOnce[B]): Traversable[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: Item[A]](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, Item[A]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (Item[A], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def forall(p: (Item[A]) ⇒ Boolean): Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: (Item[A]) ⇒ U): Unit

Definition Classes
Menu → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def foreachBy(dt: Time)(f: (Item[A]) ⇒ Unit)(implicit sc: drx.ScheduledContext, ec: drx.ExecutionContext): drx.Future[Unit]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from Menu[A] to StringFormat[Menu[A]] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def genericBuilder[B]: Builder[B, Traversable[B]]

Definition Classes
GenericTraversableTemplate
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getNonEmpty: Option[TraversableOnce[Item[A]]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def groupBy[K](f: (Item[A]) ⇒ K): Map[K, Traversable[Item[A]]]

Definition Classes
TraversableLike → GenTraversableLike
def groupRuns: Vector[Vector[Item[A]]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def groupRunsBy[B](f: (Item[A]) ⇒ B): Vector[Vector[Item[A]]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def groupWhile(f: (Item[A], Item[A]) ⇒ Boolean): Vector[Vector[Item[A]]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: Item[A]

Definition Classes
TraversableLike → GenTraversableLike
def headOption: Option[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
var hiddenIndices: Set[Int]
def hide: Menu[A]
def indexAt(mouse: Vec): Option[Int]
def init: Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[Traversable[Item[A]]]

Definition Classes
TraversableLike
def isEmpty: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def isHidden: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def isVisible: Boolean
var items: Seq[A]
def last: Item[A]

Definition Classes
TraversableLike → GenTraversableLike
def lastOption: Option[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def map[B, That](f: (Item[A]) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def mapFrom[B](f: (Item[A]) ⇒ B): Map[B, Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def mapIf[B](pf: PartialFunction[Item[A], B]): Map[Item[A], B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def mapLinear[B](f: (Item[A]) ⇒ drx.Future[B])(implicit ec: drx.ExecutionContext): drx.Future[List[B]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def mapWith[B](f: (Item[A]) ⇒ B): Map[Item[A], B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def max[B >: Item[A]](implicit cmp: Ordering[B]): Item[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (Item[A]) ⇒ B)(implicit cmp: Ordering[B]): Item[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: Item[A]](implicit cmp: Ordering[B]): Item[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (Item[A]) ⇒ B)(implicit cmp: Ordering[B]): Item[A]

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[Item[A], Traversable[Item[A]]]

Attributes
protected[this]
Definition Classes
GenericTraversableTemplate → HasNewBuilder
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
def noneIf(f: (Menu[A]) ⇒ Boolean): Option[Menu[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def odds: TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def optionIf(f: (Menu[A]) ⇒ Boolean): Option[Menu[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
var origin: Vec
def par: ParIterable[Item[A]]

Definition Classes
Parallelizable
def parCombiner: Combiner[Item[A], ParIterable[Item[A]]]

Attributes
protected[this]
Definition Classes
TraversableLike → Parallelizable
def partition(p: (Item[A]) ⇒ Boolean): (Traversable[Item[A]], Traversable[Item[A]])

Definition Classes
TraversableLike → GenTraversableLike
def preApply[B](f: (Menu[A]) ⇒ B): B

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def product[B >: Item[A]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def rand(implicit r: Rand): Stream[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def ratioWhere(p: (Item[A]) ⇒ Boolean): Ratio

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def reduce[A1 >: Item[A]](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: Item[A]](op: (B, Item[A]) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: Item[A]](op: (B, Item[A]) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: Item[A]](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: Item[A]](op: (Item[A], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: Item[A]](op: (Item[A], B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr: Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def reversed: List[Item[A]]

Attributes
protected[this]
Definition Classes
TraversableOnce
def same: Boolean

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def sampleByRatio(reductionRatio: Double)(implicit rand: Rand): TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def scan[B >: Item[A], That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, Item[A]) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (Item[A], B) ⇒ B)(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
var scrollOffset: Int
def selectAll: Unit
var selected: Set[Int]
def selectedItems: Seq[A]
def seq: Traversable[Item[A]]

Definition Classes
Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def show: Menu[A]
def shuffle(implicit r: Rand): TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def sideEffect(f: (Menu[A]) ⇒ Unit): Menu[A]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def size: Int

Definition Classes
TraversableOnce → GenTraversableOnce
def skip(skipSize: Int, takeSize: Int, offset: Int): TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def slice(from: Int, until: Int): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def someIf(f: (Menu[A]) ⇒ Boolean): Option[Menu[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
def span(p: (Item[A]) ⇒ Boolean): (Traversable[Item[A]], Traversable[Item[A]])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (Traversable[Item[A]], Traversable[Item[A]])

Definition Classes
TraversableLike → GenTraversableLike
def statBy(f: (Item[A]) ⇒ Vec): StatVec

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def statBy(f: (Item[A]) ⇒ Double): Stat

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def stringPrefix: String

Definition Classes
TraversableLike → GenTraversableLike
def sum[B >: Item[A]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[Traversable[Item[A]]]

Definition Classes
TraversableLike
def take(n: Int): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def takeWhile(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

Definition Classes
TraversableLike → GenTraversableLike
def thisCollection: Traversable[Item[A]]

Attributes
protected[this]
Definition Classes
TraversableLike
val title: String
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Item[A], Col[Item[A]]]): Col[Item[A]]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: Item[A]](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: Item[A]]: Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toCollection(repr: Traversable[Item[A]]): Traversable[Item[A]]

Attributes
protected[this]
Definition Classes
TraversableLike
def toIndexedSeq: IndexedSeq[Item[A]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[Item[A]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterator: Iterator[Item[A]]

Definition Classes
TraversableLike → GenTraversableOnce
def toList: List[Item[A]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[Item[A], (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toParArray: ParArray[T]

Implicit information
This member is added by an implicit conversion from Menu[A] to CollectionsHaveToParArray[Menu[A], T] performed by method CollectionsHaveToParArray in scala.collection.parallel. This conversion will take place only if an implicit value of type (Menu[A]) ⇒ GenTraversableOnce[T] is in scope.
Definition Classes
CollectionsHaveToParArray
def toSeq: Seq[Item[A]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSet[B >: Item[A]]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[Item[A]]

Definition Classes
TraversableLike → GenTraversableOnce
def toString(): String

Definition Classes
TraversableLike → Any
def toTraversable: Traversable[Item[A]]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toTuple2: drx.Try[(Item[A], Item[A])]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def toTuple3: drx.Try[(Item[A], Item[A], Item[A])]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def toVector: Vector[Item[A]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toggle: Menu[A]
def toggleSelection(i: Int): Unit
def transpose[B](implicit asTraversable: (Item[A]) ⇒ GenTraversableOnce[B]): Traversable[Traversable[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def transposeSafe[B](implicit asTraversable: (Item[A]) ⇒ GenTraversable[B]): Traversable[Traversable[B]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Definition Classes
DrxTraversable
def unzip[A1, A2](implicit asPair: (Item[A]) ⇒ (A1, A2)): (Traversable[A1], Traversable[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: (Item[A]) ⇒ (A1, A2, A3)): (Traversable[A1], Traversable[A2], Traversable[A3])

Definition Classes
GenericTraversableTemplate
def valueAt(mouse: Vec): Option[A]
def view(from: Int, until: Int): TraversableView[Item[A], Traversable[Item[A]]]

Definition Classes
TraversableLike
def view: TraversableView[Item[A], Traversable[Item[A]]]

Definition Classes
TraversableLike
def visibleIndices: Set[Int]
def visibleIndices_=(visible: Set[Int]): Unit
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(p: (Item[A]) ⇒ Boolean): FilterMonadic[Item[A], Traversable[Item[A]]]

Definition Classes
TraversableLike → FilterMonadic
def zipFrom[B](f: (Item[A]) ⇒ B): TraversableOnce[(B, Item[A])]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def zipIf[B](pf: PartialFunction[Item[A], B]): TraversableOnce[(Item[A], B)]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def zipTo[B, C](ys: TraversableOnce[B])(f: (Item[A], B) ⇒ C): TraversableOnce[C]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def zipWith[B](f: (Item[A]) ⇒ B): TraversableOnce[(Item[A], B)]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
def →[B](y: B): (Menu[A], B)

Implicit information
This member is added by an implicit conversion from Menu[A] to ArrowAssoc[Menu[A]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

def filter(p: (Item[A]) ⇒ Boolean): TraversableOnce[Item[A]]
Implicit information
This member is added by an implicit conversion from Menu[A] to MonadOps[Item[A]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: MonadOps[Item[A]]).filter(p)
Definition Classes
MonadOps
def flatMap[B](f: (Item[A]) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
Implicit information
This member is added by an implicit conversion from Menu[A] to MonadOps[Item[A]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: MonadOps[Item[A]]).flatMap(f)
Definition Classes
MonadOps
def flatten: Iterator[A]
Implicit information
This member is added by an implicit conversion from Menu[A] to FlattenOps[A] performed by method flattenTraversableOnce in scala.collection.TraversableOnce. This conversion will take place only if an implicit value of type (Item[A]) ⇒ TraversableOnce[A] is in scope.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: FlattenOps[A]).flatten
Definition Classes
FlattenOps
def map[B](f: (Item[A]) ⇒ B): TraversableOnce[B]
Implicit information
This member is added by an implicit conversion from Menu[A] to MonadOps[Item[A]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: MonadOps[Item[A]]).map(f)
Definition Classes
MonadOps
val min: Menu[A]
Implicit information
This member is added by an implicit conversion from Menu[A] to BoundOps[Menu[A]] performed by method DrxBoundOps in cc.drx.predef.Enrich.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: BoundOps[Menu[A]]).min
Definition Classes
BoundOps
def to(max: Menu[A])(implicit b: Boundable[Menu[A]]): Bound[Menu[A]]
Implicit information
This member is added by an implicit conversion from Menu[A] to BoundOps[Menu[A]] performed by method DrxBoundOps in cc.drx.predef.Enrich.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: BoundOps[Menu[A]]).to(max)(b)
Definition Classes
BoundOps
def withFilter(p: (Item[A]) ⇒ Boolean): Iterator[Item[A]]
Implicit information
This member is added by an implicit conversion from Menu[A] to MonadOps[Item[A]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(menu: MonadOps[Item[A]]).withFilter(p)
Definition Classes
MonadOps
val xs: TraversableOnce[Item[A]]
Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(menu: DrxTraversableOnce[Item[A]]).xs
Definition Classes
DrxTraversableOnce
val xs: Traversable[Item[A]]
Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversable[Item[A]] performed by method richDrxTraversable in cc.drx.predef.Enrich.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(menu: DrxTraversable[Item[A]]).xs
Definition Classes
DrxTraversable

Deprecated Value Members

def /@[B](f: Applicable[Item[A], B]): TraversableOnce[B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version v0.2.15) to much magic
def /@[B](f: (Item[A]) ⇒ B): TraversableOnce[B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version v0.2.15) to much magic
def ?>(f: (Menu[A]) ⇒ Boolean): Option[Menu[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
Annotations
@deprecated
Deprecated
(Since version v0.2.15) to many symbols are hard to undertand
def convolve(f: Filter, gapDetect: Option[Time])(tu: (Item[A]) ⇒ (Time, Double)): TraversableOnce[(Time, Double)]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version 0.2.2) use f.convolve(gapDetect)(tu)(xs) instead
def draw(onHover: (Int) ⇒ Unit = (_:Int)=>{})(implicit pg: P5): Unit

Annotations
@deprecated
Deprecated
(Since version v0.1.10) use the more general foreach(mouse)(f:Menu.Item=>Unit)
def mapBy[B](f: (Item[A]) ⇒ B): Map[B, Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version 0.2.13) use mapFrom(f) since it is beter in line wiht the zipFrom command
def mkMap[B](f: (Item[A]) ⇒ B): Map[Item[A], B]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version 0.1.8) use mapWith(f) or mapBy(f)
def sample(reductionRatio: Double)(implicit rand: Rand): TraversableOnce[Item[A]]

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxTraversableOnce[Item[A]] performed by method richDrxTraversableOnce in cc.drx.predef.Enrich.
Definition Classes
DrxTraversableOnce
Annotations
@deprecated
Deprecated
(Since version 0.2.13) use sampleByRatio instead for typesafety between Traverable and IndexedSeq samples
def |>[B](f: (Menu[A]) ⇒ B): B

Implicit information
This member is added by an implicit conversion from Menu[A] to DrxAny[Menu[A]] performed by method richDrxAny in cc.drx.predef.Enrich.
Definition Classes
DrxAny
Annotations
@deprecated
Deprecated
(Since version v0.2.15) use preApply if you must (symbols are concise without concision)

Inherited from Traversable[Item[A]]

Inherited from GenTraversable[Item[A]]

Inherited from GenericTraversableTemplate[Item[A], Traversable]

Inherited from TraversableLike[Item[A], Traversable[Item[A]]]

Inherited from GenTraversableLike[Item[A], Traversable[Item[A]]]

Inherited from Parallelizable[Item[A], ParIterable[Item[A]]]

Inherited from TraversableOnce[Item[A]]

Inherited from GenTraversableOnce[Item[A]]

Inherited from FilterMonadic[Item[A], Traversable[Item[A]]]

Inherited from HasNewBuilder[Item[A], Traversable[Item[A]]]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion CollectionsHaveToParArray from Menu[A] to CollectionsHaveToParArray[Menu[A], T]

Inherited by implicit conversion MonadOps from Menu[A] to MonadOps[Item[A]]

Inherited by implicit conversion flattenTraversableOnce from Menu[A] to FlattenOps[A]

Inherited by implicit conversion richDrxAny from Menu[A] to DrxAny[Menu[A]]

Inherited by implicit conversion richDrxTraversableOnce from Menu[A] to DrxTraversableOnce[Item[A]]

Inherited by implicit conversion richDrxTraversable from Menu[A] to DrxTraversable[Item[A]]

Inherited by implicit conversion DrxBoundOps from Menu[A] to BoundOps[Menu[A]]

Inherited by implicit conversion any2stringadd from Menu[A] to any2stringadd[Menu[A]]

Inherited by implicit conversion StringFormat from Menu[A] to StringFormat[Menu[A]]

Inherited by implicit conversion Ensuring from Menu[A] to Ensuring[Menu[A]]

Inherited by implicit conversion ArrowAssoc from Menu[A] to ArrowAssoc[Menu[A]]

Inherited by implicit conversion alternateImplicit from Menu[A] to ForceImplicitAmbiguity

Ungrouped

Related Docs: object Menu | package gui

class Menu[A] extends Traversable[Item[A]]

Instance Constructors

new Menu(title: String, origin: Vec, w: Int, items: Seq[A] = Seq(), fieldHeight: Double)

Type Members

case class MenuItem(pos: Vec, i: Int, isSelected: Boolean) extends Item[A] with Product with Serializable

type Self = Traversable[Item[A]]

class WithFilter extends FilterMonadic[A, Repr]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[B >: Item[A], That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

def ++:[B >: Item[A], That](that: Traversable[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

def ++:[B >: Item[A], That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

def -->[B](range: Traversable[B]): Ordinal[Item[A], B]

def -->[B](range: Bound[B]): OrdinalBoundedRange[Item[A], B]

def ->[B](y: B): (Menu[A], B)

def /:[B](z: B)(op: (B, Item[A]) ⇒ B): B

def :\[B](z: B)(op: (Item[A], B) ⇒ B): B

final def ==(arg0: Any): Boolean

val a: Menu[A]

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, Item[A]) ⇒ B, combop: (B, B) ⇒ B): B

def applyIf(t: Boolean, f: (Menu[A]) ⇒ Menu[A]): Menu[A]

def applyIf(t: (Menu[A]) ⇒ Boolean)(f: (Menu[A]) ⇒ Menu[A]): Menu[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[Item[A], B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

def collectFirst[B](pf: PartialFunction[Item[A], B]): Option[B]

def companion: GenericCompanion[Traversable]

def contains(mouse: Vec): Boolean

def containsSubsequence(ys: Traversable[Item[A]]): Boolean

def copyToArray[B >: Item[A]](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: Item[A]](xs: Array[B]): Unit

def copyToArray[B >: Item[A]](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: Item[A]](dest: Buffer[B]): Unit

def count(p: (Item[A]) ⇒ Boolean): Int

def countBy[B](f: (Item[A]) ⇒ B): Map[B, Int]

def countWhile(f: (Item[A]) ⇒ Boolean): Int

def drop(n: Int): Traversable[Item[A]]

def dropWhile(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

def elementOf(xs: Set[Menu[A]]): Boolean

def ensuring(cond: (Menu[A]) ⇒ Boolean, msg: ⇒ Any): Menu[A]

def ensuring(cond: (Menu[A]) ⇒ Boolean): Menu[A]

def ensuring(cond: Boolean, msg: ⇒ Any): Menu[A]

def ensuring(cond: Boolean): Menu[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evens: TraversableOnce[Item[A]]

def exists(p: (Item[A]) ⇒ Boolean): Boolean

def filter(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

def filterNot(p: (Item[A]) ⇒ Boolean): Traversable[Item[A]]

def finalize(): Unit

def find(p: (Item[A]) ⇒ Boolean): Option[Item[A]]

def fitString(sizes: Int*): String

def fitString: String

def flatMap[B, That](f: (Item[A]) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Traversable[Item[A]], B, That]): That

def flatten[B](implicit asTraversable: (Item[A]) ⇒ GenTraversableOnce[B]): Traversable[B]

def fold[A1 >: Item[A]](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, Item[A]) ⇒ B): B

def foldRight[B](z: B)(op: (Item[A], B) ⇒ B): B

def forall(p: (Item[A]) ⇒ Boolean): Boolean

def foreach[U](f: (Item[A]) ⇒ U): Unit

def foreachBy(dt: Time)(f: (Item[A]) ⇒ Unit)(implicit sc: drx.ScheduledContext, ec: drx.ExecutionContext): drx.Future[Unit]

def formatted(fmtstr: String): String

def genericBuilder[B]: Builder[B, Traversable[B]]

final def getClass(): Class[_]

def getNonEmpty: Option[TraversableOnce[Item[A]]]

def groupBy[K](f: (Item[A]) ⇒ K): Map[K, Traversable[Item[A]]]

def groupRuns: Vector[Vector[Item[A]]]

def groupRunsBy[B](f: (Item[A]) ⇒ B): Vector[Vector[Item[A]]]

def groupWhile(f: (Item[A], Item[A]) ⇒ Boolean): Vector[Vector[Item[A]]]

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: Item[A]

def headOption: Option[Item[A]]