(defpackage "MY-PACKAGE"

  (:add-use-defaults t)

  (:use "CAPI"))


(in-package "MY-PACKAGE")



(contain (make-instance 'title-pane
                        
                        :text "My little title pane"))



(contain (make-instance 'push-button
               :data "Button")) 


(defun test-callback (data interface)
  (display-message "Data ~S in interface ~S" 
                   data interface))

(defun hello (data interface)
  (declare (ignore data interface)) 
  (display-message "Hello World"))


(setq big-title (make-instance 'title-pane
                        
                        :text "My little title pane"

                        :font (gp:make-font-description :size 34)))


(setq button (make-instance 'push-button
                           :text "Hello"
                           :title "Press: "
                           :title-position :top
                           :callback 'hello))


(contain button)

(setf (titled-pane-title button) "New Text:")


(setq text (make-instance 'text-input-pane
                          :title "Search: "
                          :title-position :right
                          :callback 'test-callback))

(contain text)




(setq offbutton (make-instance 'push-button
                   :data "Button"
                   :enabled nil))

(contain offbutton)

(setf (button-enabled offbutton) t)





(setq check (make-instance 'check-button  
                       :selection-callback 'hello
                       :retract-callback 'test-callback
                       :text "Button"))

(contain check)

(setf (button-enabled check) t)





(defun set-title (data interface)
  (setf (interface-title interface)
        (format nil "~S" data)))


(setf test-button-panel (make-instance 'check-button-panel
               :items '(one two three four five)
               :print-function 'string-capitalize
               :selection-callback 'set-title
               :retract-callback 'test-callback))

(contain test-button-panel)




(setf *the-collector*
   (capi:contain (make-instance 'capi:collector-pane)))


(defun test-action-callback (&rest args)
            (format (capi:collector-pane-stream 
                     *the-collector*) "Action"))

(defun test-selection-callback (&rest args)
            (format (capi:collector-pane-stream *the-collector*)
                    "Selection"))

(defun test-extend-callback (&rest args)
            (format (capi:collector-pane-stream *the-collector*)
                    "Extend"))

(defun test-retract-callback (&rest args)
            (format (capi:collector-pane-stream *the-collector*)
                    "Retract"))





(setf *my-graph-pane*
   (make-instance
      'graph-pane 
      :interaction :extended-selection
      :roots '(1)
      :children-function
       #'(lambda (x)
            (when (< x 8)
                  (list (* 2 x) (1+ (* 2 x)))))
      :action-callback 'test-action-callback
      :selection-callback 'test-selection-callback
      :extend-callback 'test-extend-callback
      :retract-callback 'test-retract-callback))

(contain *my-graph-pane*)



(setq red-pane (make-instance 'output-pane
                               :background :red))

(setq green-pane (make-instance 'output-pane
                                :background :green))

(setq blue-pane (make-instance 'output-pane
                               :background :blue))

(setf *test* (make-instance 'tab-layout
               :items (list (list "one" red-pane)
                            (list "two" green-pane)
                            (list "three" blue-pane))
               :print-function 'car
               :visible-child-function 'second))

(contain *test*)


(defun tab-graph (items)
  (let* ((gp (make-instance 'graph-pane))
         (tl (make-instance 'tab-layout
               :description (list gp)
               :items items
               :visible-child-function nil
               :key-function nil
               :print-function (lambda (x) (format nil "~A" x))
               :callback-type :data
               :selection-callback #'(lambda (data)
                                       (setf (graph-pane-roots gp)
                                             (list data))))))
  (contain tl)))

(tab-graph '(1 2 4 5 7))



(setq menu1 (make-instance 'menu

                           :title "Bar"

                           :items (list "One" "Two" "Three" "Four" menu-comp)

                           :callback 'test-callback))

(setq menu2 (make-instance 'menu

                           :title "Foo"

                           :items (list 1 2 3 menu1 4 5)

                           :callback 'test-callback))


(setq menu-comp (make-instance 'menu-component

                               :interaction :multiple-selection

                               :items '("Vessela" "Jürgen")))



(contain menu2)