Scala Swing Box 订阅多个事件答案

【问题标题】：Scala Swing Box Subscribes Multiple EventsScala Swing Box 订阅多个事件
【发布时间】：2012-08-30 12:34:08
【问题描述】：

我正在用 Scala 编写一个 GUI，在尝试在 foreach 语句中注册按钮事件时遇到了一个奇怪的问题：应该是每个元素 object_i 在对象列表中（object₀ ... object_n），检索相应的按钮 x = button_i 并使用box.listenTo(x) 订阅给定的 Box。当按下按钮时，应该执行一些与 object_i 相关的操作（在本例中为println("Event triggered: " + event)）：

import scala.swing.ComboBox
import scala.collection.mutable.Buffer
import scala.swing.Button
import scala.swing.event.ButtonClicked
import scala.swing.Action
import scala.swing.SimpleSwingApplication
import scala.swing.MainFrame
import scala.swing.GridPanel
import scala.swing.BorderPanel


object EventSet extends SimpleSwingApplication  {

    object PhoneKeyEvent extends Enumeration {
        val Key1 = Value("1")
        val Key2 = Value("2")
    }

    /* Constants */

    private val DisplayHistory = Buffer[String]()   

    private val KeypadKeyEvents = List(
        PhoneKeyEvent.Key1, PhoneKeyEvent.Key2)

   private val PhoneKeyEventButtonNames = Map(
        PhoneKeyEvent.Key1 -> "1",
        PhoneKeyEvent.Key2 -> "2"
        )

    /* End constants */        


    private var PhoneKeyEventButtons = Map[PhoneKeyEvent.Value, Button]()

    private def createDisplay() : ComboBox[String] = {

        new ComboBox(DisplayHistory) {
            // Listen to keypad keys
            // Get the set of all keypad key events
            val keypadEvents = List(PhoneKeyEvent.Key1, PhoneKeyEvent.Key2)
            println("keypadEvents: " + keypadEvents)
            keypadEvents.foreach({ event =>
                println("event: " + event)
                // Listen to each button representing a keypad key event
                var keypadEventButton = PhoneKeyEventButtons(event)
                println("keypadEventButton: " + keypadEventButton)
                listenTo(keypadEventButton)
              reactions += {
                  case ButtonClicked(keypadEventButton) => {
                    // TODO: fix strange bug here: adds all possible inputs
                    println("Event triggered: " + event)


//                        selection.item = selection.item + event
                  }

              }


            })
        }

    }

    private def createPhoneControllerPanel() : BorderPanel = {
        new BorderPanel() {
            val keypadControlPanel = createPhoneKeyEventTypeControlPanel(KeypadKeyEvents)
            add(keypadControlPanel, BorderPanel.Position.Center)

            add(createDisplay(), BorderPanel.Position.North)   


            focusable = true
            requestFocus
        }
    }

     /**
     * Creates a new {@link Button} for a given {@link PhoneKeyEvent} and adds
     * the button to the global map of such buttons to their respective events;
     * that means multiple buttons cannot be created for the same key event.
     */
    private def createPhoneKeyEventButton(phoneKeyEvent: PhoneKeyEvent.Value) : Button = {
        // Only one button can be created per key event
        require(!PhoneKeyEventButtons.contains(phoneKeyEvent),
            {System.err.println("A Button for the PhoneKeyEvent " + phoneKeyEvent + "has already been created.")})

        val keyEventButtonName = PhoneKeyEventButtonNames(phoneKeyEvent)

        val result = new Button(Action(keyEventButtonName) {
            println("Key event button pressed: " + phoneKeyEvent)

        })

        // Add the button to the map of all created key event buttons
        PhoneKeyEventButtons += phoneKeyEvent -> result  
        return result

    }

    private def createPhoneKeyEventTypeControlPanel(keyEvents : Iterable[PhoneKeyEvent.Value]) : GridPanel = {
        new GridPanel(4, 3) {


            // Get the intersection of all key events of the given type and the events with button names
            keyEvents.foreach(phoneKeyEvent => contents += createPhoneKeyEventButton(phoneKeyEvent))
        }

    }

    override def top = new MainFrame {

        contents = createPhoneControllerPanel()


    }

}

但是，我得到了一些非常奇怪的行为，单击任何按钮会导致 all 触发此类对象操作 -- 请参阅程序输出：

keypadEvents: List(1, 2)
event: 1
keypadEventButton: scala.swing wrapper scala.swing.Button$$anon$1[,0,0,0x0,invalid,alignmentX=0.0,alignmentY=0.5,border=
javax.swing.plaf.BorderUIResource$CompoundBorderUIResource@7633f09,flags=296,maximumSize=,minimumSize=,preferredSize=,de
faultIcon=,disabledIcon=,disabledSelectedIcon=,margin=javax.swing.plaf.InsetsUIResource[top=2,left=14,bottom=2,right=14]
,paintBorder=true,paintFocus=true,pressedIcon=,rolloverEnabled=true,rolloverIcon=,rolloverSelectedIcon=,selectedIcon=,te
xt=1,defaultCapable=true]
event: 2
keypadEventButton: scala.swing wrapper scala.swing.Button$$anon$1[,0,0,0x0,invalid,alignmentX=0.0,alignmentY=0.5,border=
javax.swing.plaf.BorderUIResource$CompoundBorderUIResource@7633f09,flags=296,maximumSize=,minimumSize=,preferredSize=,de
faultIcon=,disabledIcon=,disabledSelectedIcon=,margin=javax.swing.plaf.InsetsUIResource[top=2,left=14,bottom=2,right=14]
,paintBorder=true,paintFocus=true,pressedIcon=,rolloverEnabled=true,rolloverIcon=,rolloverSelectedIcon=,selectedIcon=,te
xt=2,defaultCapable=true]
Key event button pressed: 1
Event triggered: 1
Event triggered: 2
Key event button pressed: 2
Event triggered: 1
Event triggered: 2

我完全不知道为什么会这样；无论如何，我对 Scala 还是很陌生，所以这是一个非常陌生的领域，但我尝试摆弄很多东西并在 Swing 源代码中窥探，但仍然一无所知...... 每个在每次迭代中都使用循环内的引用值？或者 Swing 如何一次触发每个事件？还是……？

编辑：以下是两个最小化版本，它们的行为不同：

import scala.swing.SimpleSwingApplication

object ButtonEvents extends SimpleSwingApplication  {

import scala.swing.Button
import scala.swing.event.ButtonClicked
import scala.swing.Action
import scala.swing.MainFrame
import scala.swing.FlowPanel

override def top = new MainFrame {

    contents = new FlowPanel {

        val button1 = new Button(Action("1") {
        println("Button 1 pressed")

    })
        contents += button1
        val button2 = new Button(Action("2") {
        println("Button 2 pressed")

    })
        contents += button2
        val buttons = List(button1, button2)
        buttons.foreach({ button =>
            listenTo(button)
            reactions += {
                case ButtonClicked(button) => {
                    println("Event triggered: " + button.text)
                }
            }
        })


    }


}

}

打印：

Button 1 pressed
Event triggered: 1
Event triggered: 1
Button 2 pressed
Event triggered: 2
Event triggered: 2

还有一个似乎表现正确的版本（但我不确定为什么）：

import scala.swing.SimpleSwingApplication


object ButtonEvents extends SimpleSwingApplication  {

    import scala.swing.Button
    import scala.swing.event.ButtonClicked
    import scala.swing.Action
    import scala.swing.MainFrame
    import scala.swing.FlowPanel

    override def top = new MainFrame {

        contents = new FlowPanel {

            val button1 = new Button(Action("1") {
            println("Button 1 pressed")

        })
            contents += button1
            val button2 = new Button(Action("2") {
            println("Button 2 pressed")

        })
            contents += button2
            val buttons = Map("1" -> button1, "2" -> button2)
            buttons.foreach({ eventButton =>
                listenTo(eventButton._2)
                reactions += {
                    case ButtonClicked(eventButton._2) => {
                        println("Event triggered: " + eventButton._1)
                    }
                }
            })


        }


    }

}

打印（正确）：

Button 1 pressed
Event triggered: 1
Button 2 pressed
Event triggered: 2

【问题讨论】：

tl;dr - 你应该把代码归结为问题的本质
问题是，当我尝试“简化代码”时，我得到了不同（但相关）的行为，我不知道区别在哪里：这里有两个不同的版本，它们的行为不同从上面：

标签： swing events scala foreach

【解决方案1】：

排队

reactions += {
  case ButtonClicked(keypadEventButton) => {

您正在创建一个新的val keypadEventButton 并将其分配给ButtonClicked() 中的任何内容。将行更改为case ButtonClicked(abstractButton) 仍然可以工作并显示相同的问题。

我猜你希望这与前面几行中keypadEventButton 的使用相匹配。您可能想要创建一个反应，然后使用abstractButton 来判断按下了哪个按钮。

【讨论】：

非常感谢您的帮助：通过将 reactions 块替换为 reactions += { case ButtonClicked(abstractButton) => { if(abstractButton == keypadEventButton) { println("Event triggered: " + event) } } }，我让它按照我想要的方式运行

【解决方案2】：

@andy 是正确的。像 IDEA 这样的优秀 IDE 会突出显示“变量模式的可疑阴影”，因为您在模式匹配中绑定了一个新变量。 Scala 允许您在嵌套代码块中尽可能多地隐藏变量，例如：

scala> val a = 1; {val a = 2; println(a)}; println(a)
2
1
a: Int = 1

那么下面的返回结果是什么？

val a = 1
2 match {
  case a => "it was 1"
  case _ => "something else"
}

它返回"it was 1"，因为a 被遮蔽了。现在试试：

2 match {
  case `a` => "it was 1"
  case _ => "something else"
}

这会返回"something else"，因为我们使用反引号来引用他之前定义的变量的值。（也可以试试这个变量以大写字母开头的地方......）

所以你只需要添加反引号，即

case ButtonClicked(`button`) => {

【讨论】：

非常感谢您的阴影提示；但是，在使用 ButtonClicked 的给定情况下，我收到“需要稳定标识符，但找到 keypadEventButton”消息。尽管如此，我还是找到了使用此信息和安迪的解决方案（见上文）。
@errantlinguist 这是因为您将keypadEventButton 声明为var。不要使用var，除非你真的需要它。将其声明为val，应该没问题。您也可以使用警卫更好地表达您在上面写的内容：case b: ButtonClicked if b == keypadEventButton => ...