与scala swing应用程序中的actor交互

Question

我正在用scala编写一个小应用程序。 应用程序处理简单的日志文件。 因为处理需要一些时间，所以我决定让我的应用程序核心扩展Actor。

class Application extends Actor {
  def react() {
    loop {
      react {
        case Process(file) => // do something interesting with file...
      }
    }
  }
}

通过单击gui中的按钮来触发日志文件的处理。 gui使用scala swing。

object Gui extends SimpleSwingApplication {
  val application = new Application().start()

  def top = new MainFrame {
    val startButton = new Button

    reactions += {
      case ButtonClicked(`startButton`) => application ! Process(file)
    }
  }
}

现在，应用程序核心需要通知gui当前的进度。

  sender ! Progress(value) // whenever progress is made

我通过在gui中创建一个单独的actor来解决这个问题。 actor在edt线程内执行。 它侦听来自应用程序核心的消息并更新gui。

  object Gui extends SimpleSwingApplication {
    val actor = new Actor {
      override val scheduler = new SchedulerAdapter {
        def execute(fun: => Unit) { Swing.onEDT(fun) }
      }
      start()

      def act() {
        loop {
          react {
            case ForwardToApplication(message) => application ! message
            case Progress(value) => progressBar.value = value
          }
        }
      }
    }
  } 

由于应用程序核心需要知道消息的发送者，我还使用此actor将消息从gui转发到应用程序核心，使我的actor成为新的发送者。

  reactions += {
    case ButtonClicked(`startButton`) => actor ! ForwardToApplication(Process(file))
  }

这段代码工作得很好。 我的问题：有更简单的方法吗？ 简单地使用我的应用程序消息的反应机制是很好的：

  reactions += {
    case Progress(value) => progressBar.value = value
  }

任何想法如何实现这一目标？

Answer 1

我已经扩展了gerferras的想法，使我的应用程序成为swing.Publisher 。 以下类充当swing.Reactor和Actor之间的中介。

import actors.Actor
import swing.Publisher
import swing.event.Event
import swing.Swing.onEDT

case class Send(event: Any)(implicit intermediator: Intermediator) {
  intermediator ! this
}
case class Receive(event: Any) extends Event

case class Intermediator(application: Actor) extends Actor with Publisher {
  start()

  def act() {
    loop {
      react {
        case Send(evt) => application ! evt
        case evt => onEDT(publish(Receive(evt)))
      }
    }
  }
}

现在我的反应可以包括挥杆事件和应用程序事件。

implicit val intermediator = Intermediator(application)
listenTo(intermediator, button)

reactions += {
  case ButtonClicked(`button`) => Send(Process(file))
  case Receive(Progress(value)) => progressBar.value = value
}

注意case class Send如何提供一些语法糖来轻松创建事件并将它们传递给中介。

Answer 2

也许这更简单，但不知道它是否更好。 您可以在每次需要处理文件时创建匿名actor，而不是让应用程序后端成为actor：

reactions += {
  case ButtonClicked(`startButton`) => application.process(file, { v: Int => Swing.onEDT(progressBar.value = v) })
}

对于进度更新部分，您可以将回调传递给每次进行新进度时要执行的进程方法：

import scala.actors.Actor.actor

def process(f: File, progress: Int => Unit) {
  actor {
    // process file while notifying the progress using the callback
    progress(n)
  }  
}

或者（尚未测试）您可以使应用程序成为scala.swing.Publisher ，而不是每次都使用回调，发布和事件。 所以代码可以是：

listenTo(startButton, application) //application is a Publisher

reactions += {
  case ButtonClicked(`startButton`) => application.process(file)
  case Progress(v) => progressBar.value = v
}

在应用程序中：

import scala.actors.Actor.actor

def process(f: File) {
  actor {
    // process file while notifying the progress using an scala.swing.event.Event
    publish(Progess(n))
  }  
}