scala.swing.ComboBox should have a method for changing the items

[scabug]

Frequently, the items in the combobox are dynamic and not known at the time of the ComboBox's instantiation.

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-2154?orig=1 Reporter: David Corbin (dcorbin)

[scabug]

mathieu leclaire (mamat) said (edited on Nov 21, 2011 3:32:31 PM UTC): For now, the only solution is to use the peer method setModel. With scala 2.9.1 and JDK7 as classpath, the following error occurs when compiling : error: something is wrong (wrong class file?): class JComboBox with type parameters [E] gets applied to arguments [], phase = namer

[scabug]

@soc said: @Mathieu: Those two things are most likely two completely separate issues.

Could you provide the code which triggered the compiler error (and probably file a new issue for it)?

[scabug]

mathieu leclaire (mamat) said: In a scala console importing the scala-swing jar: scala> val a = new ComboBox(List("one","two")) scala> a.peer.setModel(ComboBox.newConstantModel(List("three","four")))

gives the following error: error: something is wrong (wrong class file?): class JComboBox with type parameters [E] gets applied to arguments [], phase = namer a.peer.setModel(ComboBox.newConstantModel(List("three","four")))

[scabug]

mathieu leclaire (mamat) said: Hi, did you plan to fix this bug in the next version ? Thanks Mathieu

[scabug]

mathieu leclaire (mamat) said: The bug comes from the fact that since Java 7 a ComboBoxModel (returned by ComboBox.newConstantModel) takes a parameter (http://docs.oracle.com/javase/7/docs/api/javax/swing/ComboBoxModel.html) whereas it did not in Java 6.

[scabug]

mathieu leclaire (mamat) said (edited on Mar 15, 2012 3:59:25 PM UTC): Hi, I wrote a patch for the ComboBox class taking into account the java parametrized classes. It enables to run the small piece of code that I tested :

package scala.swing */

import event._ import javax.swing.{JList, JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer} import java.awt.event.ActionListener

object MyComboBox { /**

• An editor for a combo box. Let's you edit the currently selected item.
• It is highly recommended to use the BuiltInEditor class. For anything
• else, one cannot guarantee that it integrates nicely with the current
• LookAndFeel.
• Publishes action events. */ trait Editor[A] extends Publisher { lazy val comboBoxPeer: javax.swing.ComboBoxEditor = new javax.swing.ComboBoxEditor with Publisher { def addActionListener(l: ActionListener) { this match { // TODO case w: Action.Trigger.Wrapper => // w.peer.addActionListener(l) case _ => this.subscribe(new Reactions.Wrapper(l) ({ case ActionEvent(c) => l.actionPerformed(new java.awt.event.ActionEvent(c.peer, 0, "")) })) } } def removeActionListener(l: ActionListener) { this match { // TODO case w: Action.Trigger.Wrapper => // w.peer.removeActionListener(l) case _ => this.unsubscribe(new Reactions.Wrapper(l)({ case _ => })) } } def getEditorComponent: JComponent = Editor.this.component.peer def getItem(): AnyRef = item.asInstanceOf[AnyRef] def selectAll() { startEditing() } def setItem(a: Any) { item = a.asInstanceOf[A] } } def component: Component def item: A def item_=(a: A) def startEditing() }

/**

• Use this editor, if you want to reuse the builtin editor supplied by the current

• Look and Feel. This is restricted to a text field as the editor widget. The

• conversion from and to a string is done by the supplied functions.

• It's okay if string2A throws exceptions. They are caught by an input verifier. */ class BuiltInEditor[A](comboBox: MyComboBox[A])(string2A: String => A, a2String: A => String) extends MyComboBox.Editor[A] { protected[swing] class DelegatedEditor(editor: javax.swing.ComboBoxEditor) extends javax.swing.ComboBoxEditor { var value: A = { val v = comboBox.peer.getSelectedItem try { v match { case s: String => string2A(s) case _ => v.asInstanceOf[A] } } catch { case _: Exception => throw new IllegalArgumentException("ComboBox not initialized with a proper value, was '" + v + "'.") } } def addActionListener(l: ActionListener) { editor.addActionListener(l) } def removeActionListener(l: ActionListener) { editor.removeActionListener(l) }

  def getEditorComponent: JComponent = editor.getEditorComponent.asInstanceOf[JComponent] def selectAll() { editor.selectAll() } def getItem(): AnyRef = { verifier.verify(getEditorComponent); value.asInstanceOf[AnyRef] } def setItem(a: Any) { editor.setItem(a) }

  val verifier = new javax.swing.InputVerifier { // TODO: should chain with potentially existing verifier in editor def verify(c: JComponent) = try { value = string2A(c.asInstanceOf[JTextField].getText) true } catch { case e: Exception => false } }

  def textEditor = getEditorComponent.asInstanceOf[JTextField] textEditor.setInputVerifier(verifier) textEditor.addActionListener(Swing.ActionListener{ a => getItem() // make sure our value is updated textEditor.setText(a2String(value)) }) }

override lazy val comboBoxPeer: javax.swing.ComboBoxEditor = new DelegatedEditor(comboBox.peer.getEditor)

def component = Component.wrap(comboBoxPeer.getEditorComponent.asInstanceOf[JComponent])
def item: A = { comboBoxPeer.asInstanceOf[DelegatedEditor].value }
def item_=(a: A) { comboBoxPeer.setItem(a2String(a)) }
def startEditing() { comboBoxPeer.selectAll() }

}

implicit def stringEditor(c: MyComboBox[String]): Editor[String] = new BuiltInEditor(c)(s => s, s => s) implicit def intEditor(c: MyComboBox[Int]): Editor[Int] = new BuiltInEditor(c)(s => s.toInt, s => s.toString) implicit def floatEditor(c: MyComboBox[Float]): Editor[Float] = new BuiltInEditor(c)(s => s.toFloat, s => s.toString) implicit def doubleEditor(c: MyComboBox[Double]): Editor[Double] = new BuiltInEditor(c)(s => s.toDouble, s => s.toString)

def newConstantModel[A](items: Seq[A]): ComboBoxModel[A] = { new AbstractListModel[A] with ComboBoxModel[A] { private var selected: A = if (items.isEmpty) null.asInstanceOf[A] else items(0) def getSelectedItem: AnyRef = selected.asInstanceOf[AnyRef] def setSelectedItem(a: Any) { if ((selected != null && selected != a) || selected == null && a != null) { selected = a.asInstanceOf[A] fireContentsChanged(this, -1, -1) } } def getElementAt(n: Int) = items(n).asInstanceOf[A] def getSize = items.size } }

/*def newMutableModel[A, Self](items: Seq[A] with scala.collection.mutable.Publisher[scala.collection.mutable.Message[A], Self]): ComboBoxModel = { new AbstractListModel with ComboBoxModel { private var selected = items(0) def getSelectedItem: AnyRef = selected.asInstanceOf[AnyRef] def setSelectedItem(a: Any) { selected = a.asInstanceOf[A] } def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef] def getSize = items.size } }

def newConstantModel[A](items: Seq[A]): ComboBoxModel = items match { case items: Seq[A] with scala.collection.mutable.Publisher[scala.collection.mutable.Message[A], Self] => newMutableModel case _ => newConstantModel(items) }*/ }

/**

• Let's the user make a selection from a list of predefined items. Visually,
• this is implemented as a button-like component with a pull-down menu.
• @see javax.swing.JComboBox */ class MyComboBox[A](items: Seq[A]) extends Component with Publisher { override lazy val peer: JComboBox[A] = new JComboBox(MyComboBox.newConstantModel(items)) with SuperMixin

object selection extends Publisher { def index: Int = peer.getSelectedIndex def index_=(n: Int) { peer.setSelectedIndex(n) } def item: A = peer.getSelectedItem.asInstanceOf[A] def item_=(a: A) { peer.setSelectedItem(a) }

peer.addActionListener(Swing.ActionListener { e =>
  publish(event.SelectionChanged(MyComboBox.this))
})

}

/**

• Sets the renderer for this combo box's items. Index -1 is
• passed to the renderer for the selected item (not in the pull-down menu).
• The underlying combo box renders all items in a ListView
• (both, in the pull-down menu as well as in the box itself), hence the
• ListView.Renderer.
• Note that the UI peer of a combo box usually changes the colors
• of the component to its own defaults after the renderer has been
• configured. That's Swing's principle of most suprise. */ def renderer = peer.getRenderer //ListView.Renderer.wrapA def renderer_=(r: ListView.Renderer[A]) { peer.setRenderer(r.peer.asInstanceOf[javax.swing.ListCellRenderer[A]]) }

/* XXX: currently not safe to expose: def editor: ComboBox.Editor[A] = def editor_=(r: ComboBox.Editor[A]) { peer.setEditor(r.comboBoxPeer) } */ def editable: Boolean = peer.isEditable

/**

• Makes this combo box editable. In order to do so, this combo needs an
• editor which is supplied by the implicit argument. For default
• editors, see ComboBox companion object. */ def makeEditable()(implicit editor: MyComboBox[A] => MyComboBox.Editor[A]) { peer.setEditable(true) peer.setEditor(editor(this).comboBoxPeer) }

def prototypeDisplayValue: Option[A] = OptionA def prototypeDisplayValue_=(v: Option[A]) { peer.setPrototypeDisplayValue(v.get) } }

[Sciss]

I should check in https://github.com/Sciss/SwingPlus/blob/main/src/main/scala/de/sciss/swingplus/ComboBox.scala - since minimum Java version supported is now 8, this would no longer need work around for generics.