clean up readme; remove commented stale code

- remove the commented former and unused class `RefBuffer`
- add more information about architecture (events)
  to read-me; update information about versions and branches

Author: Sciss

README.md

@@ -14,28 +14,35 @@ The widget class hierarchy loosely resembles that of Java Swing. The main differ
   a number of components, like TextField, CheckBox, RadioButton, and so on. Our guess is that 
   this architecture was chosen because Java lacks multiple inheritance. 
   In scala-swing, components that can have child components extend the Container trait.
--  Layout managers and panels are coupled. There is no way to exchange the layout manager
+- Layout managers and panels are coupled. There is no way to exchange the layout manager
   of a panel. As a result, the layout constraints for widgets can be typed. 
   (Note that you gain more type-safety and don't loose much flexibility here. Besides 
   being not a common operation, exchanging the layout manager of a panel in Java 
   Swing almost always leads to exchanging the layout constraints for every of the panel's 
   child component. In the end, it is not more work to move all children to a newly created 
   panel.)
-   
-  The event system. TODO.
-
+- Widget hierarchies are built by adding children to their parent container's `contents`
+  collection. The typical usage style is to create anonymous subclasses of the widgets to
+  customize their properties, and nest children and event reactions.
+- The scala-swing event system follows a different approach than the underlying Java system.
+  Instead of add event listeners with a particular interface (such as `java.awt.ActionListener`),
+  a `Reactor` instances announces the interest in receiving events by calling `listenTo` for
+  a `Publisher`. Publishers are also reactors and listen to themselves per default as a convenience.
+  A reactor contains an object `reactions` which serves as a convenient place to register observers
+  by adding partial functions that pattern match for any event that the observer is interested in.
+  This is shown in the examples section below.
 - For more details see [SIP-8](docs/SIP-8.md)
 
 The library comprises two main packages:
 
 - `scala.swing`: All widget classes and traits.
 - `scala.swing.event`: The event hierarchy.
 
-
 ## Examples
 
 A number of examples can be found in the `examples` project. 
-A good place to start is  `[12] scala.swing.examples.UIDemo` (_index number may be different for you_). This pulls in the all the other examples into a tabbed window.
+A good place to start is `[16] scala.swing.examples.UIDemo`.
+This pulls in the all the other examples into a tabbed window.
 
 ```
 $ sbt examples/run
@@ -62,22 +69,51 @@ Multiple main classes detected, select one to run:
 Enter number:
 ```
 
+### Frame with a Button
+
+The following example shows how to plug components and containers together and react to a
+mouse click on a button:
+
+```scala
+import scala.swing._
+
+new Frame {
+  title = "Hello world"
+  
+  contents = new FlowPanel {
+    contents += new Label("Launch rainbows:")
+    contents += new Button("Click me") {
+      reactions += {
+        case event.ButtonClicked(_) =>
+          println("All the colours!")
+      }
+    }
+  }
+  
+  pack()
+  centerOnScreen()
+  open()
+}
+```
 
 ## Versions
 
 - The `1.0.x` branch is compiled with JDK 6 and released for Scala 2.10, 2.11. The 1.0.x releases can be used with both Scala versions on JDK 6 or newer.
 - The `2.0.x` branch is compiled with JDK 8 and released for Scala 2.11 and 2.12.
   - When using Scala 2.11, you can use the Scala swing 2.0.x releases on JDK 6 or newer.
   - Scala 2.12 requires you to use JDK 8 (that has nothing to do with scala-swing).
+- Version `2.1.0` adds support for Scala 2.13, while dropping Scala 2.10.
 
-The reason to have two versions is to allow for binary incompatible changes. Also, some java-swing classes were generified in JDK 7 (see [SI-3634](https://issues.scala-lang.org/browse/SI-3634)) and require the scala-swing sources to be adjusted.
+The reason to have different major versions is to allow for binary incompatible changes. Also, some java-swing classes were 
+generified in JDK 7 (see [SI-3634](https://issues.scala-lang.org/browse/SI-3634)) and require the scala-swing sources to be adjusted.
 
 
 ## API documentation (Scaladoc)
 
-The API documentation for scala-swing can be found at [http://www.scala-lang.org/documentation/api.html](http://www.scala-lang.org/documentation/api.html).
+The API documentation for scala-swing can be found
+at [http://www.scala-lang.org/documentation/api.html](http://www.scala-lang.org/documentation/api.html).
 
 
 ## Current Work
 
-Current changes are being made on the `2.0.x` branch.
+Current changes are being made on the `work` branch.

src/main/scala/scala/swing/Publisher.scala

@@ -127,48 +127,15 @@ private[swing] trait SingleRefCollection[+A <: AnyRef] extends Iterable[A] { sel
 }
 
 private[swing] class StrongReference[+T <: AnyRef](value: T) extends Reference[T] {
-    private[this] var ref: Option[T] = Some(value)
-    def isValid: Boolean = ref.isDefined
-    def apply(): T = ref.get
-    def get : Option[T] = ref
-    override def toString: String = get.map(_.toString).getOrElse("<deleted>")
-    def clear(): Unit = { ref = None }
-    def enqueue(): Boolean = false
-    def isEnqueued: Boolean = false
-  }
-
-//abstract class RefBuffer[A <: AnyRef] extends BufferWrapper[A] with SingleRefCollection[A] { self =>
-//  protected val underlying: mutable.Buffer[Reference[A]]
-//
-//  def addOne    (el: A): this.type = { purgeReferences(); underlying  += Ref(el)    ; this }
-//  def prependOne(el: A): this.type = { purgeReferences(); Ref(el)     +=: underlying; this }
-//
-//  def remove(el: A): Unit = { underlying -= Ref(el); purgeReferences(); }
-//
-//  def remove(n: Int): A = { val el = apply(n); remove(el); el }
-//
-//  def insertAll(n: Int, iter: Iterable[A]): Unit = {
-//    purgeReferences()
-//    underlying.insertAll(n, iter.view.map(Ref))
-//  }
-//
-//  def update(n: Int, el: A): Unit = { purgeReferences(); underlying(n) = Ref(el) }
-//
-//  def apply(n: Int): A = {
-//    purgeReferences()
-//    var el = underlying(n).get
-//    while (el.isEmpty) {
-//      purgeReferences(); el = underlying(n).get
-//    }
-//    el.get
-//  }
-//
-//  def length: Int = { purgeReferences(); underlying.length }
-//
-//  def clear(): Unit = { underlying.clear(); purgeReferences() }
-//
-//  protected[this] def removeReference(ref: Reference[A]): Unit = { underlying -= ref }
-//}
+  private[this] var ref: Option[T] = Some(value)
+  def isValid: Boolean = ref.isDefined
+  def apply(): T = ref.get
+  def get : Option[T] = ref
+  override def toString: String = get.map(_.toString).getOrElse("<deleted>")
+  def clear(): Unit = { ref = None }
+  def enqueue(): Boolean = false
+  def isEnqueued: Boolean = false
+}
 
 private[swing] abstract class RefSet[A <: AnyRef] extends SetWrapper[A] with SingleRefCollection[A] { self =>
   protected val underlying: mutable.Set[Reference[A]]