djhworld · December 8, 2011 15:59 · djhworld · Dec 8, 2011
diff --git a/seesaw-repl-tutorial.clj b/seesaw-repl-tutorial.clj
 ; A REPL-based, annotated Seesaw tutorial
 ; Please visit https://github.com/daveray/seesaw for more info
 ;
 ; This is a very basic intro to Seesaw, a Clojure UI toolkit. It covers
 ; Seesaw's basic features and philosophy, but only scratches the surface
 ; of what's available. It only assumes knowledge of Clojure. No Swing or
 ; Java experience is needed.
 ;
 ; This material was first presented in a talk at @CraftsmanGuild in
 ; Ann Arbor, MI.
 ;
 ; Dave Ray, December 2011


 ; First install Leiningen (https://github.com/technomancy/leiningen) and 
 ; create a new project. In a terminal:
 ;
 ;    $ lein new hello-seesaw
 ;    $ cd hello-seesaw
 ;    $ edit project.clj and add [seesaw "1.2.2"] to :dependencies
 ;    $ lein deps

 ; Now let's start up the REPL and do some Seesaw stuff. Repl results are
 ; marked with ;=> in the usual way.
 $ lein repl

 ; Here we go. First will use Seesaw and stuff
 (use 'clojure.repl)
 ;=> nil
 (use 'seesaw.core)
 ;=> nil

 ; Now before we create any UI stuff, tell Seesaw to try to make things look as
 ; native as possible. This puts the menubar in the right place on Mac, etc.
 (native!)
 ;=> nil

 ; Now we'll start by making a frame to put stuff in. Most Seesaw widgets are
 ; constructed with simple functions that take :keyword/value pairs.
 ; (seesaw.core/frame) creates a new frame.
 (def f (frame :title "Get to know Seesaw"))
 ;=> #'user/f

 ; So now we have a frame, but we haven't displayed it yet. Usually, we
 ; want to pack and show a frame. pack! just auto-sizes the frame for its
 ; contents
 (-> f pack! show!)
 ;=> #<JFrame ... >

 ; Note that pack! and show! both return their argument so they can be chained.
 ; This is true of most Seesaw functions with side-effects.
 ;
 ; At this point you should have a very small, very boring window on your screen.
 ;
 ;                   
 ;               +-----------------------------+
 ;               | Get to know Seesaw         x|
 ;               +-----------------------------+
 ;               |                             |
 ;               +-----------------------------+
 ;

 ; The properties of a widget can be queried ...
 (config f :title)
 ;=> "Get to know Seesaw"

 ; ... and modified
 (config! f :title "No RLY, get to know Seesaw!")
 ;=> #<JFrame ...>

 ; Note that the title of the frame changed!
 ;                   
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               |                              |
 ;               +------------------------------+


 ; So we have an empty frame. Let's give it some content
 (config! f :content "This is some content")
 ;=> #<JFrame ... >
 ;                   
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               | This is some content         |
 ;               +------------------------------+

 ; Now we have a frame with a label in it. When Seesaw sees something like a 
 ; string, it will create a label, mostly out of habit. Of course, we could
 ; create a label ourselves ...
 (def lbl (label "I'm another label"))
 ;=> #'user/lbl

 ; and show it in the frame
 (config! f :content lbl)
 ;=> #<JFrame ... >

 ; You know, we're going to be doing that a lot. Let's make a function
 (defn display [content]
  (config! f :content content)
  content)
 ;=> #'user/display

 (display lbl)

 ; Like the frame, a label can be manipulated with (config!). We can set some
 ; colors
 (config! lbl :background :pink :foreground "#00f")
 ;=> #<JLabel ... >

 ; Seesaw knows about CSS color names and codes. Notice how we can set as many
 ; properties as we want with one (config!) call

 ; We can change the font too
 (config! lbl :font "ARIAL-BOLD-21")
 ;=> #<JLabel ... >

 ; "FAMILY-STYLE-SIZE" is conventient, but using (seesaw.font/font) we get a 
 ; little more control
 (use 'seesaw.font)
 ;=> nil
 (config! lbl :font (font :name :monospaced 
                         :style #{:bold :italic} 
                         :size 18))
 ;=> #<JLabel ... >


 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 ; So we know a little about labels now. How about a button?
 (def b (button :text "Click Me"))
 ;=> #'user/b

 ; Sometimes we might want to show a message ...
 (alert "I'm an alert")
 ;=> nil

 ; or get input from the user ...
 (input "What's your favorite color?")
 ;=> "Blue"

 ; Notice that both functions block until the popup is dismissed. They both
 ; take an additional, initial argument which indicates which frame they're
 ; associated with. Otherwise, they'll just pop up in the middle of your screen


 ; Let's get back to our button and get him doing something...
 (display b)
 ;=> #<JButton>
 ;
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               |+----------------------------+|
 ;               ||                            ||
 ;               ||          Click Me          ||
 ;               ||                            ||
 ;               |+----------------------------+|
 ;               +------------------------------+
 ;
 ; Click it. Nothing happens.

 ; Seesaw's (listen) function let's us register handler functions for events on
 ; a widget. All buttons support an :action event. So,
 (listen b :action (fn [e] (alert e "Thanks!")))
 ;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f> 

 ; Now we can click the button and see something happen. The 'e' parameter
 ; is an event object. Most of the time in Seesaw, an event object can be used
 ; as a proxy for the widget that triggered the event. In this case, the button
 ; becomes the "parent" of the alert, so it's placed nicely over our frame.

 ; Also note that (listen) returned a function. Calling this function will
 ; undo the effects of the (listen) call, i.e. unregister the listener
 (*1)
 ;=> [...]

 ; Now clicking does nothing again.

 ; (listen) can register multiple event handlers at once
 (listen b :mouse-entered #(config! % :foreground :blue)
          :mouse-exited  #(config! % :foreground :red))
 ;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f> 

 ; Move the mouse over the buttons to see the text color change. Again note
 ; that we're using the event parameter as a proxy for the button. This
 ; time with (config!).


 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 ; Now let's talk about a slightly more interesting widget, a listbox.
 (def lb (listbox :model (-> 'seesaw.core ns-publics keys sort)))
 ;=> #<JList ...>
 (display lb)
 ;=> #<JList ...>
 ;
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               |#abtract-panel################|
 ;               | action                       |
 ;               | add!                         |
 ;               | add!*                        |
 ;               | alert                        |
 ;               +------------------------------+

 ; (listbox)'s most important option is :model which can take any (finite)
 ; sequence and display it. Items are displayed using (str) unless a custom
 ; :renderer is used.

 ; This listbox is ok, but our list doesn't fit in the frame and there's no
 ; scrollbars. You can add scrolling to most widgets with (scrollable) ...
 (display (scrollable lb))
 ;=> #<JScrollPane ... >

 ; Now that we have a list, it'd be nice to know what its selection is. Seesaw
 ; has a unified nice selection interface. If there's no selection we get nil
 (selection lb)
 ;=> nil

 ; Otherwise, we get the value:
 (selection lb)
 ;=> abstract-panel
 (type *1)
 ;=> clojure.lang.Symbol

 ; Note we get the same objects out that we put in the :model above.

 ; If we want multi-selection (shift/ctrl-click)
 (selection lb {:multi? true})
 ;=> (action add! add!* alert)

 ; Similarly, we can set the selection
 (selection! lb 'all-frames)
 ;=> #<JList ... >

 ; was all-frames selected for you too?

 ; Finally, we might want to know when the selection changes. Everybody
 ; supports the :selection event
 (listen lb :selection (fn [e] (println "Selection is " (selection e))))
 ;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f> 

 ; click around on the listbox and watch the selection print out.

 ; and unregister as usual
 (*1)
 ;=> [...]


 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 ; Now we come to editable text widgets. It's easy to make one
 (def field (display (text "This is a text field.")))
 ;=> #<JTextField ... >
 ;
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               |                              |
 ;               |                              |
 ;               | This is a text field|        |
 ;               |                              |
 ;               |                              |
 ;               +------------------------------+

 ; A text field is a single line of text. You can query the text...
 (text field)
 ;=> "This is a text field."

 ; ... and change it programmatically
 (text! field "A new value")
 ;=> #<JTextField ... >

 ; ... and you can set the font, etc as usual with config
 (config! field :font "MONOSPACED-PLAIN-12" :background "#f88")
 ;=> #<JTextField ... >


 ; If you've got more than one line, you can make it multi-line...
 (def area (text :multi-line? true :font "MONOSPACED-PLAIN-14"
                :text "This
 is 
 multi
 line
 text"))
 ;=> #<JTextArea ... >

 (display area)
 ;=> #<JTextArea ... >
 ;
 ;               +------------------------------+
 ;               | NO RLY, get to know Seesaw  x|
 ;               +------------------------------+
 ;               | This                         |
 ;               | is                           |
 ;               | multi                        |
 ;               | line|                        |
 ;               +------------------------------+


 ; If you've got a reader, URL, or anything else slurp-able, you can fill up the
 ; text area with it
 (text! area (java.net.URL. "http://clojure.com"))
 ;=> #<JTextArea ... >

 ; Of course, we need scrollbars now
 (display (scrollable area))
 ;=> #<JTextArea ... >

 ; Like selection, Seesaw has a unified scrolling API. You can scroll to the top ...
 (scroll! area :to :top)
 ;=> #<JTextArea ... >

 ; ... or the bottom ...
 (scroll! area :to :bottom)
 ;=> #<JTextArea ... >

 ; ... or to a particular line ...
 (scroll! area :to [:line 50])
 ;=> #<JTextArea ... >


 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 ; Let's try showing two widgets at once. One option is a splitter:
 (def split (left-right-split (scrollable lb) (scrollable area) :divider-location 1/3))
 ;=> #'user/split

 (display split)
 ;=> #<JSplitPane ... >
 ;
 ;
 ;             +-------------------------------------+
 ;             | NO RLY, get to know Seesaw         x|
 ;             +-----------+-------------------------+
 ;             |abstract-pa| This                    |
 ;             |action     | is                      |
 ;             |add!#######| multi                   |
 ;             |add!*      | line|                   |
 ;             +-----------+-------------------------+
 ;

 ; This shows both our listbox on the left and text area on the right with a 
 ; movable splitter. If you're familiar with Swing, you'll recognize what an
 ; achievement :divider-location is.

 ; Let's hook them together. First a function to grab a doc string
 (defn doc-str [s] (-> (symbol "seesaw.core" (name s)) resolve meta :doc))
 ;=> #'user/doc-str

 ; ... and now the usual selection handler
 (listen lb :selection
        (fn [e]
          (when-let [s (selection e)]
            (-> area
              (text!   (doc-str s))
              (scroll! :to :top)))))
 ;=> #<JList ... >

 ; note how we have to be sure to check for nil selection


 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 ; Ok. We're pushing on the limits of what we can comfortably type in a REPL,
 ; so just a couple more things ...

 ; Imagine we wanted to show source as well as docs. A set of radio button might be
 ; a nice way to switch betwen them ...

 (def rbs (for [i [:source :doc]] 
           (radio :id i :class :type :text (name i))))
 ;=> #'user/rbs

 ; we have a couple radio buttons. Let's add them to our frame. We'll use a 
 ; border-panel to lay things out. This is what a border-panel layout looks like:
 ;
 ;     +------------------------------------------+
 ;     |                 :north                   |
 ;     |                                          |
 ;     +----------+-------------------+-----------+
 ;     |          |                   |           |
 ;     |          |                   |           |
 ;     | :west    |       :center     |   :east   |
 ;     |          |                   |           |
 ;     |          |                   |           |
 ;     +----------+-------------------+-----------+
 ;     |                                          |
 ;     |                 :south                   |
 ;     +------------------------------------------+
 ;


 (display (border-panel
           :north (horizontal-panel :items rbs)
           :center split
           :vgap 5 :hgap 5 :border))
 ;=> #<JPanel ...>

 ; The :vgap, :hgap, and :border options just make things look a little nicer.

 ; If you click the radio buttons, you'll notice a little problem. They're not
 ; mutually exclusive. We'll put them in a button group to fix that, but first
 ; a small detour...

 ; How can we get to the radio buttons without using the rbs var? How about
 ; with a selector:
 (select f [:JRadioButton])
 ;=> (#<JRadioButton ... > #<JRadioButton ... >)

 ; or, since we gave them a :class option above ...
 (select f [:.type])
 ;=> (#<JRadioButton ... > #<JRadioButton ... >)

 ; or, we can get them individually by :id
 (select f [:#source])
 ;=> #<JRadioButton ... >

 ; Selectors are always enclosed in a vector.

 ; Now, about those buttons. We'll need a button group...
 (def group (button-group))
 ;=> #'user/group

 ; It happens that (config!) can take a sequence as its first argument in addition
 ; to a single widget ...
 (config! (select f [:.type]) :group group)
 ;=> (#<JRadioButton ... > #<JRadioButton ... >)

 ; Now our buttons are nice and mutex-y. A button group, like most things, has a
 ; selection too, whichever button is currently selected:
 (selection group)
 ;=> #<JRadioButton ...>

 ; Combine this with (id-of) and we have our original keywords back:
 (-> group selection id-of)
 ;=> :source
 (-> group selection id-of)
 ;=> :doc

 ; and, of course, you can register a listener for group selection changes
 (listen group :selection 
        (fn [e] 
          (when-let [s (selection group)] 
            (println "Selection is " (id-of s)))))

 ; Now open hello-seesaw.core.clj and see if you can put this all together into
 ; an app.

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; For more info see the Seesaw wiki:
 ;    https://github.com/daveray/seesaw/wiki
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	; A REPL-based, annotated Seesaw tutorial
	; Please visit https://github.com/daveray/seesaw for more info
	;
	; This is a very basic intro to Seesaw, a Clojure UI toolkit. It covers
	; Seesaw's basic features and philosophy, but only scratches the surface
	; of what's available. It only assumes knowledge of Clojure. No Swing or
	; Java experience is needed.
	;
	; This material was first presented in a talk at @CraftsmanGuild in
	; Ann Arbor, MI.
	;
	; Dave Ray, December 2011


	; First install Leiningen (https://github.com/technomancy/leiningen) and
	; create a new project. In a terminal:
	;
	; $ lein new hello-seesaw
	; $ cd hello-seesaw
	; $ edit project.clj and add [seesaw "1.2.2"] to :dependencies
	; $ lein deps

	; Now let's start up the REPL and do some Seesaw stuff. Repl results are
	; marked with ;=> in the usual way.
	$ lein repl

	; Here we go. First will use Seesaw and stuff
	(use 'clojure.repl)
	;=> nil
	(use 'seesaw.core)
	;=> nil

	; Now before we create any UI stuff, tell Seesaw to try to make things look as
	; native as possible. This puts the menubar in the right place on Mac, etc.
	(native!)
	;=> nil

	; Now we'll start by making a frame to put stuff in. Most Seesaw widgets are
	; constructed with simple functions that take :keyword/value pairs.
	; (seesaw.core/frame) creates a new frame.
	(def f (frame :title "Get to know Seesaw"))
	;=> #'user/f

	; So now we have a frame, but we haven't displayed it yet. Usually, we
	; want to pack and show a frame. pack! just auto-sizes the frame for its
	; contents
	(-> f pack! show!)
	;=> #<JFrame ... >

	; Note that pack! and show! both return their argument so they can be chained.
	; This is true of most Seesaw functions with side-effects.
	;
	; At this point you should have a very small, very boring window on your screen.
	;
	;
	; +-----------------------------+
	; \| Get to know Seesaw x\|
	; +-----------------------------+
	; \| \|
	; +-----------------------------+
	;

	; The properties of a widget can be queried ...
	(config f :title)
	;=> "Get to know Seesaw"

	; ... and modified
	(config! f :title "No RLY, get to know Seesaw!")
	;=> #<JFrame ...>

	; Note that the title of the frame changed!
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \| \|
	; +------------------------------+


	; So we have an empty frame. Let's give it some content
	(config! f :content "This is some content")
	;=> #<JFrame ... >
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \| This is some content \|
	; +------------------------------+

	; Now we have a frame with a label in it. When Seesaw sees something like a
	; string, it will create a label, mostly out of habit. Of course, we could
	; create a label ourselves ...
	(def lbl (label "I'm another label"))
	;=> #'user/lbl

	; and show it in the frame
	(config! f :content lbl)
	;=> #<JFrame ... >

	; You know, we're going to be doing that a lot. Let's make a function
	(defn display [content]
	(config! f :content content)
	content)
	;=> #'user/display

	(display lbl)

	; Like the frame, a label can be manipulated with (config!). We can set some
	; colors
	(config! lbl :background :pink :foreground "#00f")
	;=> #<JLabel ... >

	; Seesaw knows about CSS color names and codes. Notice how we can set as many
	; properties as we want with one (config!) call

	; We can change the font too
	(config! lbl :font "ARIAL-BOLD-21")
	;=> #<JLabel ... >

	; "FAMILY-STYLE-SIZE" is conventient, but using (seesaw.font/font) we get a
	; little more control
	(use 'seesaw.font)
	;=> nil
	(config! lbl :font (font :name :monospaced
	:style #{:bold :italic}
	:size 18))
	;=> #<JLabel ... >


	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	; So we know a little about labels now. How about a button?
	(def b (button :text "Click Me"))
	;=> #'user/b

	; Sometimes we might want to show a message ...
	(alert "I'm an alert")
	;=> nil

	; or get input from the user ...
	(input "What's your favorite color?")
	;=> "Blue"

	; Notice that both functions block until the popup is dismissed. They both
	; take an additional, initial argument which indicates which frame they're
	; associated with. Otherwise, they'll just pop up in the middle of your screen


	; Let's get back to our button and get him doing something...
	(display b)
	;=> #<JButton>
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \|+----------------------------+\|
	; \|\| \|\|
	; \|\| Click Me \|\|
	; \|\| \|\|
	; \|+----------------------------+\|
	; +------------------------------+
	;
	; Click it. Nothing happens.

	; Seesaw's (listen) function let's us register handler functions for events on
	; a widget. All buttons support an :action event. So,
	(listen b :action (fn [e] (alert e "Thanks!")))
	;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f>

	; Now we can click the button and see something happen. The 'e' parameter
	; is an event object. Most of the time in Seesaw, an event object can be used
	; as a proxy for the widget that triggered the event. In this case, the button
	; becomes the "parent" of the alert, so it's placed nicely over our frame.

	; Also note that (listen) returned a function. Calling this function will
	; undo the effects of the (listen) call, i.e. unregister the listener
	(*1)
	;=> [...]

	; Now clicking does nothing again.

	; (listen) can register multiple event handlers at once
	(listen b :mouse-entered #(config! % :foreground :blue)
	:mouse-exited #(config! % :foreground :red))
	;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f>

	; Move the mouse over the buttons to see the text color change. Again note
	; that we're using the event parameter as a proxy for the button. This
	; time with (config!).


	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	; Now let's talk about a slightly more interesting widget, a listbox.
	(def lb (listbox :model (-> 'seesaw.core ns-publics keys sort)))
	;=> #<JList ...>
	(display lb)
	;=> #<JList ...>
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \|#abtract-panel################\|
	; \| action \|
	; \| add! \|
	; \| add!* \|
	; \| alert \|
	; +------------------------------+

	; (listbox)'s most important option is :model which can take any (finite)
	; sequence and display it. Items are displayed using (str) unless a custom
	; :renderer is used.

	; This listbox is ok, but our list doesn't fit in the frame and there's no
	; scrollbars. You can add scrolling to most widgets with (scrollable) ...
	(display (scrollable lb))
	;=> #<JScrollPane ... >

	; Now that we have a list, it'd be nice to know what its selection is. Seesaw
	; has a unified nice selection interface. If there's no selection we get nil
	(selection lb)
	;=> nil

	; Otherwise, we get the value:
	(selection lb)
	;=> abstract-panel
	(type *1)
	;=> clojure.lang.Symbol

	; Note we get the same objects out that we put in the :model above.

	; If we want multi-selection (shift/ctrl-click)
	(selection lb {:multi? true})
	;=> (action add! add!* alert)

	; Similarly, we can set the selection
	(selection! lb 'all-frames)
	;=> #<JList ... >

	; was all-frames selected for you too?

	; Finally, we might want to know when the selection changes. Everybody
	; supports the :selection event
	(listen lb :selection (fn [e] (println "Selection is " (selection e))))
	;=> #<core$juxt$fn__3775 clojure.core$juxt$fn__3775@2e46638f>

	; click around on the listbox and watch the selection print out.

	; and unregister as usual
	(*1)
	;=> [...]


	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	; Now we come to editable text widgets. It's easy to make one
	(def field (display (text "This is a text field.")))
	;=> #<JTextField ... >
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \| \|
	; \| \|
	; \| This is a text field\| \|
	; \| \|
	; \| \|
	; +------------------------------+

	; A text field is a single line of text. You can query the text...
	(text field)
	;=> "This is a text field."

	; ... and change it programmatically
	(text! field "A new value")
	;=> #<JTextField ... >

	; ... and you can set the font, etc as usual with config
	(config! field :font "MONOSPACED-PLAIN-12" :background "#f88")
	;=> #<JTextField ... >


	; If you've got more than one line, you can make it multi-line...
	(def area (text :multi-line? true :font "MONOSPACED-PLAIN-14"
	:text "This
	is
	multi
	line
	text"))
	;=> #<JTextArea ... >

	(display area)
	;=> #<JTextArea ... >
	;
	; +------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +------------------------------+
	; \| This \|
	; \| is \|
	; \| multi \|
	; \| line\| \|
	; +------------------------------+


	; If you've got a reader, URL, or anything else slurp-able, you can fill up the
	; text area with it
	(text! area (java.net.URL. "http://clojure.com"))
	;=> #<JTextArea ... >

	; Of course, we need scrollbars now
	(display (scrollable area))
	;=> #<JTextArea ... >

	; Like selection, Seesaw has a unified scrolling API. You can scroll to the top ...
	(scroll! area :to :top)
	;=> #<JTextArea ... >

	; ... or the bottom ...
	(scroll! area :to :bottom)
	;=> #<JTextArea ... >

	; ... or to a particular line ...
	(scroll! area :to [:line 50])
	;=> #<JTextArea ... >


	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	; Let's try showing two widgets at once. One option is a splitter:
	(def split (left-right-split (scrollable lb) (scrollable area) :divider-location 1/3))
	;=> #'user/split

	(display split)
	;=> #<JSplitPane ... >
	;
	;
	; +-------------------------------------+
	; \| NO RLY, get to know Seesaw x\|
	; +-----------+-------------------------+
	; \|abstract-pa\| This \|
	; \|action \| is \|
	; \|add!#######\| multi \|
	; \|add!* \| line\| \|
	; +-----------+-------------------------+
	;

	; This shows both our listbox on the left and text area on the right with a
	; movable splitter. If you're familiar with Swing, you'll recognize what an
	; achievement :divider-location is.

	; Let's hook them together. First a function to grab a doc string
	(defn doc-str [s] (-> (symbol "seesaw.core" (name s)) resolve meta :doc))
	;=> #'user/doc-str

	; ... and now the usual selection handler
	(listen lb :selection
	(fn [e]
	(when-let [s (selection e)]
	(-> area
	(text! (doc-str s))
	(scroll! :to :top)))))
	;=> #<JList ... >

	; note how we have to be sure to check for nil selection


	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

	; Ok. We're pushing on the limits of what we can comfortably type in a REPL,
	; so just a couple more things ...

	; Imagine we wanted to show source as well as docs. A set of radio button might be
	; a nice way to switch betwen them ...

	(def rbs (for [i [:source :doc]]
	(radio :id i :class :type :text (name i))))
	;=> #'user/rbs

	; we have a couple radio buttons. Let's add them to our frame. We'll use a
	; border-panel to lay things out. This is what a border-panel layout looks like:
	;
	; +------------------------------------------+
	; \| :north \|
	; \| \|
	; +----------+-------------------+-----------+
	; \| \| \| \|
	; \| \| \| \|
	; \| :west \| :center \| :east \|
	; \| \| \| \|
	; \| \| \| \|
	; +----------+-------------------+-----------+
	; \| \|
	; \| :south \|
	; +------------------------------------------+
	;


	(display (border-panel
	:north (horizontal-panel :items rbs)
	:center split
	:vgap 5 :hgap 5 :border))
	;=> #<JPanel ...>

	; The :vgap, :hgap, and :border options just make things look a little nicer.

	; If you click the radio buttons, you'll notice a little problem. They're not
	; mutually exclusive. We'll put them in a button group to fix that, but first
	; a small detour...

	; How can we get to the radio buttons without using the rbs var? How about
	; with a selector:
	(select f [:JRadioButton])
	;=> (#<JRadioButton ... > #<JRadioButton ... >)

	; or, since we gave them a :class option above ...
	(select f [:.type])
	;=> (#<JRadioButton ... > #<JRadioButton ... >)

	; or, we can get them individually by :id
	(select f [:#source])
	;=> #<JRadioButton ... >

	; Selectors are always enclosed in a vector.

	; Now, about those buttons. We'll need a button group...
	(def group (button-group))
	;=> #'user/group

	; It happens that (config!) can take a sequence as its first argument in addition
	; to a single widget ...
	(config! (select f [:.type]) :group group)
	;=> (#<JRadioButton ... > #<JRadioButton ... >)

	; Now our buttons are nice and mutex-y. A button group, like most things, has a
	; selection too, whichever button is currently selected:
	(selection group)
	;=> #<JRadioButton ...>

	; Combine this with (id-of) and we have our original keywords back:
	(-> group selection id-of)
	;=> :source
	(-> group selection id-of)
	;=> :doc

	; and, of course, you can register a listener for group selection changes
	(listen group :selection
	(fn [e]
	(when-let [s (selection group)]
	(println "Selection is " (id-of s)))))

	; Now open hello-seesaw.core.clj and see if you can put this all together into
	; an app.

	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	; For more info see the Seesaw wiki:
	; https://github.com/daveray/seesaw/wiki
	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;