//设置package包名称以及导入依赖的类
package bozzy.steno

import java.io.File
import java.nio.charset.MalformedInputException

import scala.io.Source
import scalafx.collections.ObservableBuffer


class StenoDictionary(val filename: String, val format: DictionaryFormat.Value) {
  val entries = ObservableBuffer[DictionaryEntry]()
  val dictionaryName = new File(filename) getName

  if (format == DictionaryFormat.RTF) {
    try {
      // Ideally, we'd have UTF-8
      DictionaryFormat.parseRtfDictionary(Source.fromFile(filename).mkString)
        .foreach((entry: (String, String)) =>
          entries add new DictionaryEntry(entry._1, entry._2, DictionaryFormat.RTF, this))
    } catch {
      case _: MalformedInputException => {
        // But most traditional steno dictionaries will be in ANSI
        entries removeAll entries
        DictionaryFormat.parseRtfDictionary(Source.fromFile(filename, "Cp1252").mkString)
          .foreach((entry: (String, String)) =>
            entries add new DictionaryEntry(entry._1, entry._2, DictionaryFormat.RTF, this))
      }
    }
  } else if (format == DictionaryFormat.JSON) {
    val jsonDictionaryString = try Source.fromFile(filename).mkString catch {
      case _: MalformedInputException => Source.fromFile(filename, "Cp1252").mkString
    }
    DictionaryFormat.parseJsonDictionary(jsonDictionaryString).foreach((entry: (String, String)) =>
      entries add new DictionaryEntry(entry._1, entry._2, DictionaryFormat.JSON, this))
  }

  override def toString = dictionaryName
} 

//设置package包名称以及导入依赖的类
package net.mikolak.pomisos.utils

import net.mikolak.pomisos.crud.{DbIdable, MultiDao}
import net.mikolak.pomisos.data.WithDbId
import shapeless.Lens

import scalafx.beans.property.ObjectProperty
import scalafx.collections.ObservableBuffer
import scalafx.collections.ObservableBuffer.{Add, Remove, Update}

object UiUtils {

  def propFor[Type <: WithDbId, FieldType](l: Lens[Type, FieldType], o: Type)(
      saveFunc: Type => Type): ObjectProperty[FieldType] = {
    var obj = o

    val prop = ObjectProperty.apply(l.get(o))

    prop.onChange((_, _, newVal) => {
      obj = saveFunc(l.set(o)(newVal))
    })

    prop
  }

  def observerFor[T <: Product with Serializable: DbIdable](
      dao: MultiDao[T]): (ObservableBuffer[_ <: T], Seq[ObservableBuffer.Change[T]]) => Unit =
    (items, rawEvents) => {

      //splice Add and Remove events into collection
      val eventMap = rawEvents.groupBy {
        case Add(i, _)    => i
        case Remove(i, _) => i
      }

      val events = eventMap.toList.flatMap {
        case (index, rowEvents) => {
          if (rowEvents.exists(_.isInstanceOf[Add[T]]) && rowEvents.exists(_.isInstanceOf[Remove[T]])) {
            List(Update(index, index + 1))
          } else {
            rowEvents
          }
        }
      }

      val toId = implicitly[DbIdable[T]]
      events.collect {
        case Update(from, until) =>
          items.slice(from, until).foreach(dao.save)
        case Remove(_, removed) =>
          val ids = removed.toSeq.flatMap(toId.idsOf)
          dao.remove(ids: _*)
      }
    }

}