Attachment #356670 for bug #450298

Lines 343-348 Link Here

(-)scala-2.10.2-orig/build.xml (-5 / +5 lines)
343	<echo level="warning"> You are using JDK7 for this build.	343	<echo level="warning"> You are using JDK7 for this build.
344	While this will be able to build most of Scala, it will not build the Swing project.	344	While this will be able to build most of Scala, it will not build the Swing project.
345	You will be unable to create a distribution.	345	You will be unable to create a distribution.
		346	^ The above is a message from the scala 2.10.2 release, the Gentoo
		347	ebuild applies patches for jdk 1.7 swing.
346	</echo>	348	</echo>
347	</then></if>	349	</then></if>
348		350
Lines 1153-1159 Link Here
1153	<target name="quick.partest" depends="quick.scalap, quick.comp, asm.done">	1155	<target name="quick.partest" depends="quick.scalap, quick.comp, asm.done">
1154	<staged-build with="locker" stage="quick" project="partest" version="partest"/> </target>	1156	<staged-build with="locker" stage="quick" project="partest" version="partest"/> </target>
1155		1157
1156	<target name="quick.swing" depends="quick.actors, quick.lib" if="has.java6">	1158	<target name="quick.swing" depends="quick.actors, quick.lib">
1157	<staged-build with="locker" stage="quick" project="swing"/> </target>	1159	<staged-build with="locker" stage="quick" project="swing"/> </target>
1158		1160
1159	<target name="quick.plugins" depends="quick.comp">	1161	<target name="quick.plugins" depends="quick.comp">
Lines 1204-1210 Link Here
1204	<staged-pack project="library"/></target>	1206	<staged-pack project="library"/></target>
1205		1207
1206	<target name="pack.actors" depends="quick.lib"> <staged-pack project="actors"/> </target>	1208	<target name="pack.actors" depends="quick.lib"> <staged-pack project="actors"/> </target>
1207	<target name="pack.swing" if="has.java6" depends="quick.swing"> <staged-pack project="swing"/> </target>	1209	<target name="pack.swing" depends="quick.swing"> <staged-pack project="swing"/> </target>
1208	<target name="pack.reflect" depends="quick.reflect"> <staged-pack project="reflect"/> </target>	1210	<target name="pack.reflect" depends="quick.reflect"> <staged-pack project="reflect"/> </target>
1209		1211
1210	<target name="pack.comp" depends="quick.comp, asm.done">	1212	<target name="pack.comp" depends="quick.comp, asm.done">
Lines 1351-1359 Link Here
1351	<make-plugin-bundle name="continuations" version="${osgi.version.number}" />	1353	<make-plugin-bundle name="continuations" version="${osgi.version.number}" />
1352	<touch file="${build-osgi.dir}/bundles.complete" verbose="no"/>	1354	<touch file="${build-osgi.dir}/bundles.complete" verbose="no"/>
1353		1355
1354	<if><isset property="has.java6"/><then>	1356	<make-bundle name="scala-swing" version="${osgi.version.number}"/>
1355	<make-bundle name="scala-swing" version="${osgi.version.number}"/></then>
1356	</if>
1357	<stopwatch name="osgi.bundle.timer" action="total"/></then>	1357	<stopwatch name="osgi.bundle.timer" action="total"/></then>
1358	</if>	1358	</if>
1359	</target>	1359	</target>




package scala.swing

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

object ComboBox {

  implicit def floatEditor(c: ComboBox[Float]): Editor[Float] = new BuiltInEditor(c)(s => s.toFloat, s => s.toString)
  implicit def doubleEditor(c: ComboBox[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 = selected.asInstanceOf[AnyRef]
      def setSelectedItem(a: Any) {
        if ((selected != null && selected != a) ||
            selected == null && a != null) {

          fireContentsChanged(this, -1, -1)
        }
      }
      def getElementAt(n: Int) = items(n).asInstanceOf[A]
      def getSize = items.size
    }
  }

 * @see javax.swing.JComboBox
 */
class ComboBox[A](items: Seq[A]) extends Component with Publisher {
  override lazy val peer: JComboBox[A] = new JComboBox(ComboBox.newConstantModel(items)) with SuperMixin

  object selection extends Publisher {
    def index: Int = peer.getSelectedIndex

   * of the component to its own defaults _after_ the renderer has been
   * configured. That's Swing's principle of most suprise.
   */
  def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getRenderer.asInstanceOf[ListCellRenderer[A]])
  // def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getRenderer)
  def renderer_=(r: ListView.Renderer[A]) { peer.setRenderer(r.peer) }

  /* XXX: currently not safe to expose:

    peer.setEditor(editor(this).comboBoxPeer)
  }

  def prototypeDisplayValue: Option[A] = Option(peer.getPrototypeDisplayValue)
  def prototypeDisplayValue_=(v: Option[A]) {
    peer.setPrototypeDisplayValue((v map toAnyRef).orNull.asInstanceOf[A])
  }
}




    val MultiInterval = Value(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
  }

  def wrap[A](c: JList[A]) = new ListView[A] {
    override lazy val peer = c
  }

  object Renderer {
    def wrap[A](r: ListCellRenderer[A]): Renderer[A] = new Wrapped[A](r)

    /**
     * Wrapper for <code>javax.swing.ListCellRenderer<code>s
     */
      class Wrapped[A](override val peer: ListCellRenderer[A]) extends Renderer[A] {
        def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int) = {
        Component.wrap(peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent])
        }
      }
  	}

    /**
     * Returns a renderer for items of type <code>A</code>. The given function

     * </code>
     */
    def apply[A,B](f: A => B)(implicit renderer: Renderer[B]): Renderer[A] = new Renderer[A] {
      def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component =
        renderer.componentFor(list.asInstanceOf[ListView[_ <: B]], isSelected, focused, f(a), index)
    }
  }


   * @see javax.swing.ListCellRenderer
   */
  abstract class Renderer[-A] {
    def peer: ListCellRenderer[_ >: A] = new ListCellRenderer[A] {
      def getListCellRendererComponent(list: JList[_ <: A], a: A, index: Int, isSelected: Boolean, focused: Boolean) =
        componentFor(ListView.wrap[A](list.asInstanceOf[JList[A]]), isSelected, focused, a, index).peer
    }
    def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component
  }

  /**

    /**
     * Configures the component before returning it.
     */
    def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = {
      preConfigure(list, isSelected, focused, a, index)
      configure(list, isSelected, focused, a, index)
      component

   * that renders the string returned from an item's <code>toString</code>.
   */
  implicit object GenericRenderer extends Renderer[Any] {
    override lazy val peer: ListCellRenderer[Any] = (new DefaultListCellRenderer).asInstanceOf[ListCellRenderer[Any]]
    def componentFor(list: ListView[_ <: Any], isSelected: Boolean, focused: Boolean, a: Any, index: Int): Component = {
      val c = peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused)
      Component.wrap(c.asInstanceOf[JComponent])
    }
  }
}

 */
class ListView[A] extends Component {
  import ListView._
  override lazy val peer: JList[A] = new JList[A] with SuperMixin

  def this(items: Seq[A]) = {
    this()
    listData = items
  }

  protected class ModelWrapper[A](val items: Seq[A]) extends AbstractListModel[A] {
    def getElementAt(n: Int) = items(n)
    def getSize = items.size
  }

  def listData: Seq[A] = peer.getModel match {
    case model: ModelWrapper[a] => model.items
    case model => new Seq[A] { selfSeq =>
     def length = model.getSize
     def iterator = new Iterator[A] {
       var idx = 0
       def next = { idx += 1; apply(idx-1) }
       def hasNext = idx < selfSeq.length
     }
     def apply(n: Int): A = model.getElementAt(n)
    }
  }

  def listData_=(items: Seq[A]) {
    peer.setModel(new AbstractListModel[A] {
      def getElementAt(n: Int) = items(n)
      def getSize = items.size
    })
  }

    def adjusting = peer.getSelectionModel.getValueIsAdjusting
  }

  def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getCellRenderer.asInstanceOf[ListCellRenderer[A]])
  def renderer_=(r: ListView.Renderer[A]) { peer.setCellRenderer(r.peer) }

  def fixedCellWidth = peer.getFixedCellWidth

Return to bug 450298

Lines 24-44 Link Here

(-)scala-2.10.2-orig/src/swing/scala/swing/ListView.scala (-25 / +25 lines)
24	val MultiInterval = Value(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)	24	val MultiInterval = Value(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION)
25	}	25	}
26		26
27	def wrap[A](c: JList) = new ListView[A] {	27	def wrap[A](c: JList[A]) = new ListView[A] {
28	override lazy val peer = c	28	override lazy val peer = c
29	}	29	}
30		30
31	object Renderer {	31	object Renderer {
32	def wrap[A](r: ListCellRenderer): Renderer[A] = new Wrapped[A](r)	32	def wrap[A](r: ListCellRenderer[A]): Renderer[A] = new Wrapped[A](r)
33		33
34	/**	34	/**
35	* Wrapper for <code>javax.swing.ListCellRenderer<code>s	35	* Wrapper for <code>javax.swing.ListCellRenderer<code>s
36	*/	36	*/
37	class Wrapped[A](override val peer: ListCellRenderer) extends Renderer[A] {	37	class Wrapped[A](override val peer: ListCellRenderer[A]) extends Renderer[A] {
38	def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int) = {	38	def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int) = {
39	Component.wrap(peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent])	39	Component.wrap(peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent])
		40	}
40	}	41	}
41	}
42		42
43	/**	43	/**
44	* Returns a renderer for items of type <code>A</code>. The given function	44	* Returns a renderer for items of type <code>A</code>. The given function
Lines 55-62 Link Here
55	* </code>	55	* </code>
56	*/	56	*/
57	def apply[A,B](f: A => B)(implicit renderer: Renderer[B]): Renderer[A] = new Renderer[A] {	57	def apply[A,B](f: A => B)(implicit renderer: Renderer[B]): Renderer[A] = new Renderer[A] {
58	def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component =	58	def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component =
59	renderer.componentFor(list, isSelected, focused, f(a), index)	59	renderer.componentFor(list.asInstanceOf[ListView[_ <: B]], isSelected, focused, f(a), index)
60	}	60	}
61	}	61	}
62		62
Lines 69-79 Link Here
69	* @see javax.swing.ListCellRenderer	69	* @see javax.swing.ListCellRenderer
70	*/	70	*/
71	abstract class Renderer[-A] {	71	abstract class Renderer[-A] {
72	def peer: ListCellRenderer = new ListCellRenderer {	72	def peer: ListCellRenderer[_ >: A] = new ListCellRenderer[A] {
73	def getListCellRendererComponent(list: JList, a: Any, index: Int, isSelected: Boolean, focused: Boolean) =	73	def getListCellRendererComponent(list: JList[_ <: A], a: A, index: Int, isSelected: Boolean, focused: Boolean) =
74	componentFor(ListView.wrap[A](list), isSelected, focused, a.asInstanceOf[A], index).peer	74	componentFor(ListView.wrap[A](list.asInstanceOf[JList[A]]), isSelected, focused, a, index).peer
75	}	75	}
76	def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component	76	def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component
77	}	77	}
78		78
79	/**	79	/**
Lines 110-116 Link Here
110	/**	110	/**
111	* Configures the component before returning it.	111	* Configures the component before returning it.
112	*/	112	*/
113	def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = {	113	def componentFor(list: ListView[_ <: A], isSelected: Boolean, focused: Boolean, a: A, index: Int): Component = {
114	preConfigure(list, isSelected, focused, a, index)	114	preConfigure(list, isSelected, focused, a, index)
115	configure(list, isSelected, focused, a, index)	115	configure(list, isSelected, focused, a, index)
116	component	116	component
Lines 123-132 Link Here
123	* that renders the string returned from an item's <code>toString</code>.	123	* that renders the string returned from an item's <code>toString</code>.
124	*/	124	*/
125	implicit object GenericRenderer extends Renderer[Any] {	125	implicit object GenericRenderer extends Renderer[Any] {
126	override lazy val peer: ListCellRenderer = new DefaultListCellRenderer	126	override lazy val peer: ListCellRenderer[Any] = (new DefaultListCellRenderer).asInstanceOf[ListCellRenderer[Any]]
127	def componentFor(list: ListView[_], isSelected: Boolean, focused: Boolean, a: Any, index: Int): Component = {	127	def componentFor(list: ListView[_ <: Any], isSelected: Boolean, focused: Boolean, a: Any, index: Int): Component = {
128	val c = peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused).asInstanceOf[JComponent]	128	val c = peer.getListCellRendererComponent(list.peer, a, index, isSelected, focused)
129	Component.wrap(c)	129	Component.wrap(c.asInstanceOf[JComponent])
130	}	130	}
131	}	131	}
132	}	132	}
Lines 142-175 Link Here
142	*/	142	*/
143	class ListView[A] extends Component {	143	class ListView[A] extends Component {
144	import ListView._	144	import ListView._
145	override lazy val peer: JList = new JList with SuperMixin	145	override lazy val peer: JList[A] = new JList[A] with SuperMixin
146		146
147	def this(items: Seq[A]) = {	147	def this(items: Seq[A]) = {
148	this()	148	this()
149	listData = items	149	listData = items
150	}	150	}
151		151
152	protected class ModelWrapper(val items: Seq[A]) extends AbstractListModel {	152	protected class ModelWrapper[A](val items: Seq[A]) extends AbstractListModel[A] {
153	def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef]	153	def getElementAt(n: Int) = items(n)
154	def getSize = items.size	154	def getSize = items.size
155	}	155	}
156		156
157	def listData: Seq[A] = peer.getModel match {	157	def listData: Seq[A] = peer.getModel match {
158	case model: ModelWrapper => model.items	158	case model: ModelWrapper[a] => model.items
159	case model @ _ => new Seq[A] { selfSeq =>	159	case model => new Seq[A] { selfSeq =>
160	def length = model.getSize	160	def length = model.getSize
161	def iterator = new Iterator[A] {	161	def iterator = new Iterator[A] {
162	var idx = 0	162	var idx = 0
163	def next = { idx += 1; apply(idx-1) }	163	def next = { idx += 1; apply(idx-1) }
164	def hasNext = idx < selfSeq.length	164	def hasNext = idx < selfSeq.length
165	}	165	}
166	def apply(n: Int) = model.getElementAt(n).asInstanceOf[A]	166	def apply(n: Int): A = model.getElementAt(n)
167	}	167	}
168	}	168	}
169		169
170	def listData_=(items: Seq[A]) {	170	def listData_=(items: Seq[A]) {
171	peer.setModel(new AbstractListModel {	171	peer.setModel(new AbstractListModel[A] {
172	def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef]	172	def getElementAt(n: Int) = items(n)
173	def getSize = items.size	173	def getSize = items.size
174	})	174	})
175	}	175	}
Lines 216-222 Link Here
216	def adjusting = peer.getSelectionModel.getValueIsAdjusting	216	def adjusting = peer.getSelectionModel.getValueIsAdjusting
217	}	217	}
218		218
219	def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getCellRenderer)	219	def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getCellRenderer.asInstanceOf[ListCellRenderer[A]])
220	def renderer_=(r: ListView.Renderer[A]) { peer.setCellRenderer(r.peer) }	220	def renderer_=(r: ListView.Renderer[A]) { peer.setCellRenderer(r.peer) }
221		221
222	def fixedCellWidth = peer.getFixedCellWidth	222	def fixedCellWidth = peer.getFixedCellWidth

Lines 9-15 Link Here

(-)scala-2.10.2-orig/src/swing/scala/swing/ComboBox.scala (-9 / +10 lines)
9	package scala.swing	9	package scala.swing
10		10
11	import event._	11	import event._
12	import javax.swing.{JList, JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer}	12	import javax.swing.{ JComponent, JComboBox, JTextField, ComboBoxModel, AbstractListModel, ListCellRenderer }
13	import java.awt.event.ActionListener	13	import java.awt.event.ActionListener
14		14
15	object ComboBox {	15	object ComboBox {
Lines 118-127 Link Here
118	implicit def floatEditor(c: ComboBox[Float]): Editor[Float] = new BuiltInEditor(c)(s => s.toFloat, s => s.toString)	118	implicit def floatEditor(c: ComboBox[Float]): Editor[Float] = new BuiltInEditor(c)(s => s.toFloat, s => s.toString)
119	implicit def doubleEditor(c: ComboBox[Double]): Editor[Double] = new BuiltInEditor(c)(s => s.toDouble, s => s.toString)	119	implicit def doubleEditor(c: ComboBox[Double]): Editor[Double] = new BuiltInEditor(c)(s => s.toDouble, s => s.toString)
120		120
121	def newConstantModel[A](items: Seq[A]): ComboBoxModel = {	121	def newConstantModel[A](items: Seq[A]): ComboBoxModel[A] = {
122	new AbstractListModel with ComboBoxModel {	122	new AbstractListModel[A] with ComboBoxModel[A] {
123	private var selected: A = if (items.isEmpty) null.asInstanceOf[A] else items(0)	123	private var selected: A = if (items.isEmpty) null.asInstanceOf[A] else items(0)
124	def getSelectedItem: AnyRef = selected.asInstanceOf[AnyRef]	124	def getSelectedItem = selected.asInstanceOf[AnyRef]
125	def setSelectedItem(a: Any) {	125	def setSelectedItem(a: Any) {
126	if ((selected != null && selected != a) \|\|	126	if ((selected != null && selected != a) \|\|
127	selected == null && a != null) {	127	selected == null && a != null) {
Lines 129-135 Link Here
129	fireContentsChanged(this, -1, -1)	129	fireContentsChanged(this, -1, -1)
130	}	130	}
131	}	131	}
132	def getElementAt(n: Int) = items(n).asInstanceOf[AnyRef]	132	def getElementAt(n: Int) = items(n).asInstanceOf[A]
133	def getSize = items.size	133	def getSize = items.size
134	}	134	}
135	}	135	}
Lines 157-163 Link Here
157	* @see javax.swing.JComboBox	157	* @see javax.swing.JComboBox
158	*/	158	*/
159	class ComboBox[A](items: Seq[A]) extends Component with Publisher {	159	class ComboBox[A](items: Seq[A]) extends Component with Publisher {
160	override lazy val peer: JComboBox = new JComboBox(ComboBox.newConstantModel(items)) with SuperMixin	160	override lazy val peer: JComboBox[A] = new JComboBox(ComboBox.newConstantModel(items)) with SuperMixin
161		161
162	object selection extends Publisher {	162	object selection extends Publisher {
163	def index: Int = peer.getSelectedIndex	163	def index: Int = peer.getSelectedIndex
Lines 182-188 Link Here
182	* of the component to its own defaults _after_ the renderer has been	182	* of the component to its own defaults _after_ the renderer has been
183	* configured. That's Swing's principle of most suprise.	183	* configured. That's Swing's principle of most suprise.
184	*/	184	*/
185	def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getRenderer)	185	def renderer: ListView.Renderer[A] = ListView.Renderer.wrap[A](peer.getRenderer.asInstanceOf[ListCellRenderer[A]])
		186	// def renderer: ListView.Renderer[A] = ListView.Renderer.wrap(peer.getRenderer)
186	def renderer_=(r: ListView.Renderer[A]) { peer.setRenderer(r.peer) }	187	def renderer_=(r: ListView.Renderer[A]) { peer.setRenderer(r.peer) }
187		188
188	/* XXX: currently not safe to expose:	189	/* XXX: currently not safe to expose:
Lines 201-208 Link Here
201	peer.setEditor(editor(this).comboBoxPeer)	202	peer.setEditor(editor(this).comboBoxPeer)
202	}	203	}
203		204
204	def prototypeDisplayValue: Option[A] = toOption[A](peer.getPrototypeDisplayValue)	205	def prototypeDisplayValue: Option[A] = Option(peer.getPrototypeDisplayValue)
205	def prototypeDisplayValue_=(v: Option[A]) {	206	def prototypeDisplayValue_=(v: Option[A]) {
206	peer.setPrototypeDisplayValue((v map toAnyRef).orNull)	207	peer.setPrototypeDisplayValue((v map toAnyRef).orNull.asInstanceOf[A])
207	}	208	}
208	}	209	}