|
|
package org.gerweck.scalafx.util
import language.implicitConversions
import cats._
import scalafx.beans.property._ import scalafx.beans.value._ import scalafx.collections._
trait ObservableImplicits { /* NOTE: (Sarah) I believe that the synchronization in these helpers is not
* _really_ required in the JavaFX threading model. However, the overhead of * uncontended synchronization is relatively low, and typical UIs won't have * enough change events for it to be a serious issue. (If you're updating * a property in a tight loop, I expect you'll have bigger performance * issues.) */ implicit val observableInstances: Applicative[Observable] with Functor[Observable] with Monad[Observable] = ObservableImplicits.ObservableInstances implicit val readOnlyObjectPropertyInstances: Applicative[ReadOnlyObjectProperty] with Functor[ReadOnlyObjectProperty] with Monad[ReadOnlyObjectProperty] = ObservableImplicits.ReadOnlyObjectPropertyInstances
implicit def enrichObservable[A, B](o: ObservableValue[A, B]) = new RichObservable(o) implicit def enrichObservableOfIterable[A, B](ooi: ObservableValue[B, B])(implicit ev1: B => Iterable[A]) = new ObservableOfIterable[A, B](ooi) implicit def enrichObservableOfMapLike[A, B, C](ooml: ObservableValue[C, C])(implicit ev1: C => Iterable[(A, B)]) = new ObservableOfMapLike[A, B, C](ooml) implicit def enrichProperty[A, B](o: Property[A, B]) = new RichProperty(o) implicit def enrichObjectProperty[A](o: ObjectProperty[A]) = new RichObjectProperty(o) implicit def enrichTuple[A <: Product](a: A) = new RichTuple(a)
implicit def enrichObservableBuffer[A](ob: ObservableBuffer[A]) = new RichObservableBuffer(ob) implicit def enrichObservableArray[A, B <: ObservableArray[A, B, C], C <: javafx.collections.ObservableArray[C]](oa: ObservableArray[A, B, C]) = new RichObservableArray(oa) implicit def enrichObservableSet[A](os: ObservableSet[A]) = new RichObservableSet(os) }
private object ObservableImplicits { object ObservableInstances extends Applicative[Observable] with Functor[Observable] with Monad[Observable] { /* Map can be derived from `ap`, but this adds less overhead. */ override def map[A, B](a: Observable[A])(f: A => B): ReadOnlyObjectProperty[B] = { @inline def recalculate(): B = f(a.value)
val originalValue = recalculate()
val prop = ObjectProperty[B](originalValue)
var prevValue = originalValue def changeHandler() = prop.synchronized { val newVal = recalculate() if (prevValue != newVal) { prop.value = newVal prevValue = newVal } }
a onChange changeHandler() prop }
override def pure[A](a: A): ReadOnlyObjectProperty[A] = { ObjectProperty[A](a) }
/* Ap can be derived from `point` and `bind`, but this has less overhead. */ override def ap[A, B](f: Observable[A => B])(fa: Observable[A]): ReadOnlyObjectProperty[B] = { @inline def recalculate(): B = (f.value)(fa.value)
val originalValue = recalculate()
val prop = ObjectProperty[B](originalValue)
var prevValue = originalValue
def changeHandler() = prop.synchronized { val newVal = recalculate() if (prevValue != newVal) { prop.value = newVal prevValue = newVal } }
fa onChange changeHandler() f onChange changeHandler()
prop }
override def flatMap[A, B](fa: Observable[A])(f: A => Observable[B]): ReadOnlyObjectProperty[B] = { flatten(map(fa)(f)) }
override def tailRecM[A, B](a: A)(f: A => Observable[Either[A, B]]): Observable[B] = { this.flatMap(f(a)) { case Right(b) => pure(b) case Left(nextA) => tailRecM(nextA)(f) } }
override def flatten[A](ooa: Observable[Observable[A]]): ReadOnlyObjectProperty[A] = { @inline def oa() = ooa.value @inline def calc(): A = oa().value
val originalValue = calc()
val prop = ObjectProperty[A](originalValue)
var prevValue = originalValue
def innerHandle() = prop.synchronized { val newVal = calc() if (prevValue != newVal) { prop.value = newVal prevValue = newVal } } var innerSub = oa() onChange innerHandle()
var prevOuter = oa() def outerHandle() = prop.synchronized { val newOuter = oa() /* We need reference equality here: we're subscribing to a specific object. */ if (prevOuter ne newOuter) { innerSub.cancel() innerSub = newOuter onChange innerHandle() prevOuter = newOuter innerHandle() } }
ooa onChange outerHandle()
prop } }
object ReadOnlyObjectPropertyInstances extends Applicative[ReadOnlyObjectProperty] with Functor[ReadOnlyObjectProperty] with Monad[ReadOnlyObjectProperty] { override def map[A, B](a: ReadOnlyObjectProperty[A])(f: A => B): ReadOnlyObjectProperty[B] = ObservableInstances.map(a)(f) override def pure[A](a: A): ReadOnlyObjectProperty[A] = ObservableInstances.pure(a) override def ap[A, B](f: ReadOnlyObjectProperty[A => B])(fa: ReadOnlyObjectProperty[A]): ReadOnlyObjectProperty[B] = ObservableInstances.ap(f)(fa) override def flatMap[A, B](fa: ReadOnlyObjectProperty[A])(f: A => ReadOnlyObjectProperty[B]): ReadOnlyObjectProperty[B] = ObservableInstances.flatMap(fa)(f) override def tailRecM[A, B](a: A)(f: A => ReadOnlyObjectProperty[Either[A, B]]): ReadOnlyObjectProperty[B] = { flatMap(f(a)) { case Right(b) => pure(b) case Left(nextA) => tailRecM(nextA)(f) } } override def flatten[A](ooa: ReadOnlyObjectProperty[ReadOnlyObjectProperty[A]]): ReadOnlyObjectProperty[A] = { /* NOTE: this is copy-pasted from `observableInstances`. TBD: Find a way to share this. */ @inline def oa() = ooa.value @inline def calc(): A = oa().value
val originalValue = calc()
val prop = ObjectProperty[A](originalValue)
var prevValue = originalValue
def innerHandle() = prop.synchronized { val newVal = calc() if (prevValue != newVal) { prop.value = newVal prevValue = newVal } } var innerSub = oa() onChange innerHandle()
var prevOuter = oa() def outerHandle() = prop.synchronized { val newOuter = oa() /* We need reference equality here: we're subscribing to a specific object. */ if (prevOuter ne newOuter) { innerSub.cancel() innerSub = newOuter onChange innerHandle() prevOuter = newOuter innerHandle() } }
ooa onChange outerHandle()
prop } } }
final class RichTuple[A <: Product](val self: A) extends AnyVal { import shapeless._ import shapeless.ops.hlist._
/* It's possible to do this operation without conversion directly using
* Shapeless's `tuple` package, but it can't infer the exact output type, * which is far less useful. */ def observe[L <: HList, Unwrap <: HList, Tupled <: Product] (implicit tohl: Generic.Aux[A, L], lister: ToTraversable.Aux[L, List, Observable[_]], uw: Mapper.Aux[ObservableUnwrapper.type, L, Unwrap], tplr: Tupler.Aux[Unwrap, Tupled]): ObservableValue[Tupled, Tupled] = { val asHList: L = tohl.to(self) def calculate(): Tupled = uw(asHList).tupled
val original = calculate() val prop = ObjectProperty[Tupled](original)
for (component <- asHList.to[List]) { component onChange { prop.value = calculate() } } prop } }
final class RichObservable[A, C](val self: ObservableValue[A, C]) extends AnyVal { private[this] type ObjObs[X] = ObservableValue[X, X] @inline private[this] def oapp = ObservableImplicits.ObservableInstances
def map[B](f: A => B) = oapp.map(self)(f) def flatMap[B](f: A => Observable[B]) = oapp.flatMap(self)(f) def <*>[B](f: Observable[A => B]): ObservableValue[B, B] = oapp.ap(f)(self) def tuple[B](f: Observable[B]): Observable[(A,B)] = oapp.tuple2(self, f) final def *>[B](fb: ObjObs[B]): Observable[B] = oapp.map2(self,fb)((_,b) => b) final def <*[B](fb: ObjObs[B]): Observable[A] = oapp.map2(self,fb)((a,_) => a) final def >>[B](fb: => ObjObs[B]): Observable[B] = oapp.map2(self, fb)((_, b) => b) final def <<[B](fb: => ObjObs[B]): Observable[A] = oapp.map2(self, fb)((a, _) => a)
final def |@|[B, B1](fb: ObservableValue[B, B1]) = ObservableTupler(self, fb)
/** Alias for `|@|` */ final def ⊛[B, B1](fb: ObservableValue[B, B1]) = |@|(fb) }
final class ObservableOfIterable[A, B](val self: ObservableValue[B, B])(implicit ev1: B => Iterable[A]) { def observeBuffer: ObservableBuffer[A] = { val buff = ObservableBuffer(self.value.toSeq) self onChange { (_, oldV, newV) => fillCollection(buff.delegate, newV) } buff } def observeSet: ObservableSet[A] = { val set = ObservableSet[A](self.value.toSet.toSeq: _*) self onChange { (_, oldV, newV) => val newSet = newV.toSet if (oldV.toSet != newSet) { set.clear() set ++= newSet } } set } } final class ObservableOfMapLike[A, B, C](val self: ObservableValue[C, C])(implicit ev1: C => Iterable[(A, B)]) { def observeMap: ObservableMap[A, B] = { val map = ObservableMap[A, B](self.value.toMap.toSeq: _*) self onChange { (_, oldV, newV) => val newMap = newV.toMap if (oldV.toMap != newV.toMap) { map.clear() map ++= newMap } } map } }
final class RichProperty[A, B](val inner: Property[A, B]) extends AnyVal { def biMap[A1 <: AnyRef](push: A => A1, pull: A1 => A): ObjectProperty[A1] = { val original = push(inner.value) val op = ObjectProperty[A1](original) inner onChange { val oldVal = op.value val newVal = push(inner.value) if (oldVal != newVal) { op.value = push(inner.value) } } op onChange { val oldVal = inner.value val newVal = pull(op.value) if (oldVal != newVal) { inner.value = newVal } } op }
def readOnly: ReadOnlyProperty[A, B] = inner }
final class RichObjectProperty[A](val inner: ObjectProperty[A]) extends AnyVal { def readOnly: ReadOnlyObjectProperty[A] = inner }
|