Hlavní navigace

Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (3)

Pavel Tišnovský 16. 6. 2015

Ve třetí části článku o programovacím jazyce Clojure a o knihovnách dostupných pro tento jazyk si popíšeme další vybrané vlastnosti knihovny nazvané Seesaw. Nejprve si popíšeme použití funkcí alert a input a posléze se budeme zabývat dostupnými správci rozvržení komponent GUI (widgetů) v oknech a panelech.

Obsah

1. Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (3)

2. Volitelný parametr :listen použitý při tvorbě widgetů

3. Využití funkce alert

4. Využití funkce input

5. Další správci rozvržení dostupní v knihovně Seesaw

6. Správce rozvržení flow-panel

7. Správce rozvržení border-panel

8. Správce rozvržení horizontal-panel

9. Správce rozvržení vertical-panel

10. Repositář s demonstračními příklady

11. Odkazy na předchozí části seriálu

12. Odkazy na Internetu

1. Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (3)

V předchozích dvou částech tohoto seriálu jsme si mj. řekli, jakým způsobem je možné reagovat na události vznikající (generované) při práci uživatele s aplikací s grafickým uživatelským rozhraním. Základem bylo „naslouchání“ nějaké události svázané s konkrétním prvkem GUI (widgetem). Příkladem může být naprogramování reakcí na stisk tlačítka, přejetí kurzoru myši do plochy tlačítka či naopak opuštění plochy tohoto tlačítka (reference na tlačítko je uložena v lokální proměnné btn):

    (listen btn :mouse-clicked (fn [e] (println "Very well"))
                :mouse-entered (fn [e] (println "Mouse caught"))
                :mouse-exited  (fn [e] (println "Mouse escaped")))

Alternativně je možné svázat určitý prvek GUI (typicky slider, ale například i listbox, kombobox, vstupní textové pole atd.) se zvolenou proměnnou, jejíž hodnota se bude měnit synchronně se stavem widgetu, tj. například s posunem zmíněného slideru:

(bind/bind slider-control
      slider-atom-value
      slider-control)

2. Volitelný parametr :listen použitý při tvorbě widgetů

Třetím způsobem naprogramování reakce na události je použití volitelného parametru :listen předaného konstruktoru widgetu (například tlačítka). Hodnotou parametru :listen je funkce (typicky anonymní funkce) zavolaná při vzniku zvoleného typu události. Této funkci se (při jejím volání) předá objekt typu Event obsahující všechny informace o události, která v grafickém uživatelském prostředí nastala. V příkladu pod tímto odstavcem je použita anonymní funkce deklarovaná makrem #(), takže její první parametr je přístupný pod pseudojménem %1:

(button :text ":background :red"
        :background :red
        :listen [:action #(println "Button#1\n" %1)])

Použití volitelného parametru :listen si ukážeme na dnešním prvním demonstračním příkladu, který je pojmenovaný seesaw9. Kostru tohoto příkladu vytvoříme způsobem, který již známe z minula a předminula:

lein new app seesaw9

Po spuštění tohoto příkazu by se měla vygenerovat následující struktura adresářů a souborů:

.
├── doc
│   └── intro.md
├── LICENSE
├── project.clj
├── README.md
├── resources
├── src
│   └── seesaw9
│       └── core.clj
└── test
    └── seesaw9
        └── core_test.clj

Obrázek 1: Grafické uživatelské rozhraní příkladu seesaw9.

Úprava projektového souboru project.clj je, podobně jako u dříve popisovaných příkladů, snadná – viz zvýrazněný řádek:

(defproject seesaw9 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw9.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Obrázek 2: Zprávy vypisované na terminál po stisku tlačítek.

Zdrojový soubor src/seesaw9/core.clj:

(ns seesaw9.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(def formular
    (grid-panel :columns 2
                :rows 3
                :items [(button :text ":background :red"
                                :background :red
                                :listen [:action #(println "Button#1\n" %1)])
                        (button :text ":background :yellow"
                                :background :yellow
                                :listen [:action #(println "Button#2\n" %1)])
                        (button :text ":background :orange"
                                :background :orange
                                :listen [:action #(println "Button#3\n" %1)])
                        (button :text ":background #ff8080"
                                :background "#ff8080"
                                :listen [:action #(println "Button#4\n" %1)])
                        (button :text ":background #8080ff"
                                :background "#8080ff"
                                :listen [:action #(println "Button#5\n" %1)])
                        (button :text ":background #8f8"
                                :background "#8f8"
                                :listen [:action #(println "Button#6\n" %1)])
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Color test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

3. Využití funkce alert

V mnoha aplikacích s grafickým uživatelským rozhraním se setkáme s nutností zobrazení zprávy uživateli a potvrzení této zprávy. V případě, že se jedná o jednoduchou textovou zprávu, která se pouze „odklepne“, lze v knihovně Seesaw pro její zobrazení použít funkci alert, která vyvolá zobrazení následujícího dialogu:

Obrázek 3: Příklad použití funkce alert.

Použití této funkce je snadné (ostatně alert představuje snad nejjednodušeji použitelnou GUI funkci):

(defn button-clicked-event
    [e]
    (alert "Button clicked!"))
 
(button :text ":background :yellow"
    :background :yellow
    :listen [:action button-clicked-event])

Vyzkoušejme si nyní tuto funkci zakomponovat do demonstračního příkladu. Vytvoření kostry demonstračního příkladu:

lein new app seesaw10

Projektový soubor project.clj:

(defproject seesaw10 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw10.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw10/core.clj:

(ns seesaw10.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(defn button-clicked-event
    [e]
    (alert (str "Button clicked!")))
 
(def formular
    (grid-panel :columns 2
                :rows 3
                :items [(button :text ":background :red"
                                :background :red
                                :listen [:action button-clicked-event])
                        (button :text ":background :yellow"
                                :background :yellow
                                :listen [:action button-clicked-event])
                        (button :text ":background :orange"
                                :background :orange
                                :listen [:action button-clicked-event])
                        (button :text ":background #ff8080"
                                :background "#ff8080"
                                :listen [:action button-clicked-event])
                        (button :text ":background #8080ff"
                                :background "#8080ff"
                                :listen [:action button-clicked-event])
                        (button :text ":background #8f8"
                                :background "#8f8"
                                :listen [:action button-clicked-event])
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Color test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

4. Využití funkce input

Funkce alert popsaná v předchozí kapitole sice vyniká svou jednoduchostí, ale je možné ji použít pouze pro zobrazení zprávy uživateli a nikoli již pro vstup dat. Pokud je zapotřebí v nějaké GUI aplikaci získat nějaký řetězec, vybrat hodnotu z nabízeného seznamu či se jen rozhodnout mezi Ano/Ne, je možné namísto alert použít podobnou funkci nazvanou prostě input. Tato funkce již dokáže vrátit odpověď uživatele, popř. speciální hodnotu nil v případě, že uživatel okno s dialogem zavřel. Bez delšího vysvětlování si ukažme některé možnosti nabízené funkcí input a jejich nepovinných pojmenovaných parametrů:

Obrázek 4: Dialog vytvořený zavoláním (input „Type anything“).

Obrázek 5: Dialog vytvořený zavoláním (input „Type anything“ :type :warning).

Obrázek 6: Dialog vytvořený zavoláním (input „Type anything“ :type :error).

Obrázek 7: Dialog vytvořený zavoláním (input „Type anything“ :type :info).

Obrázek 8: Dialog vytvořený zavoláním (input „Type anything“ :type :question).

Obrázek 9: Dialog vytvořený zavoláním (input „Type anything“ :value 42).

Obrázek 10: Dialog vytvořený zavoláním (input „Pick a color“ :choices [„red“ „green“ „blue“ „yellow“ „orange“ „pink“]).

Obrázek 11: Dialog vytvořený zavoláním (input „Pick a color“ :type :question :choices [„red“ „green“ „blue“ „yellow“ „orange“ „pink“]).

Vidíme, že je možné zvolit ikonu (parametr :type), napsat výchozí hodnotu (parametr :value), zobrazit dialog se seznamem (parametr :choices) popř. tyto parametry kombinovat. Podívejme se nyní na (polo)praktický příklad, v němž bude funkce input volána. Vytvoření kostry demonstračního příkladu zajistí nám již dobře známý příkaz:

lein new app seesaw11

Projektový soubor project.clj:

(defproject seesaw11 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw11.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw11/core.clj:

(ns seesaw11.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(defn input1
    [e]
    (println (input "Type anything")))
 
(defn input2
    [e]
    (println (input "Type anything" :type :warning)))
 
(defn input3
    [e]
    (println (input "Type anything" :type :error)))
 
(defn input4
    [e]
    (println (input "Type anything" :type :info)))
 
(defn input5
    [e]
    (println (input "Type anything" :type :question)))
 
(defn input6
    [e]
    (println (input "Type anything" :value 42)))
 
(defn input7
    [e]
    (println (input "Pick a color"
              :choices ["red" "green" "blue" "yellow" "orange" "pink"])))
 
(defn input8
    [e]
    (println (input "Pick a color"
              :type :question
              :choices ["red" "green" "blue" "yellow" "orange" "pink"])))
 
(def formular
    (grid-panel :columns 2
                :rows 4
                :items [(button :text "Plain input"
                                :background :red
                                :listen [:action input1])
                        (button :text "Warning"
                                :background :yellow
                                :listen [:action input2])
                        (button :text "Error"
                                :background :orange
                                :listen [:action input3])
                        (button :text "Info"
                                :background "#ff8080"
                                :listen [:action input4])
                        (button :text "Question"
                                :background "#8080ff"
                                :listen [:action input5])
                        (button :text "Init value"
                                :background "#8f8"
                                :listen [:action input6])
                        (button :text "Choice"
                                :background "#ff8"
                                :listen [:action input7])
                        (button :text "Choice + question"
                                :background "#f8f"
                                :listen [:action input8])
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Color test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

5. Další správci rozvržení dostupní v knihovně Seesaw

V předchozí části tohoto seriálu jsme se setkali s prvním správcem rozvržení (layout manager), který sloužil k rozmístění grafických komponent (widgetů) na plochu okna či panelu. Tento správce se jmenoval GridLayout a v knihovně Seesaw ho bylo možné vytvořit s využitím funkce grid-panel. Ovšem GridLayout má ve Swingu a tím pádem i v knihovně Seesaw několik omezení, která se týkají především velikosti komponent a taktéž praktické nemožnosti roztažení vybraných komponent mezi větší množství buněk pomyslné mřížky. Z tohoto důvodu je nutné používat i další správce rozložení. V dalších čtyřech kapitolách si proto popíšeme tyto správce: flow-panel, border-panel, horizontal-panel a vertical-panel.

6. Správce rozvržení flow-panel

Jedním ze základních správců rozvržení, který se poměrně často používá většinou v kombinaci s dalšími manažery, je správce nazvaný jednoduše FlowLayout. Všechny grafické prvky (widgety) jsou při použití tohoto správce umisťovány na jeden řádek a teprve poté, co je dosaženo nastavené maximální šířky okna, se další komponenty začnou přidávat na další řádek – FlowLayout manažer tedy pracuje podobně, jako kdyby se v HTML umisťovaly obrázky (či jiné prvky) do jednoho odstavce. FlowLayout manažer je v knihovně Seesaw představován funkcí flow-panel, které se předají jednotlivé prvky v parametru pojmenovaném :items. Kromě toho lze při volání této funkce specifikovat i další pravidla použitá při umisťování jednotlivých prvků do okna – okraj, horizontální a vertikální mezeru a taktéž zarovnání prvků (doleva, doprava, na střed). Podívejme se na příklad:

(flow-panel :hgap 10 :vgap 10 :border 10 :align :center
            :items [(button :text ":background :red"    :background :red)
                    (button :text ":background :yellow" :background :yellow)
                    (button :text ":background :orange" :background :orange)
                    (button :text ":background #ff8080" :background "#ff8080")
                    (button :text ":background #8080ff" :background "#8080ff")
                    (button :text ":background #8f8"    :background "#8f8"))

Použité pojmenované parametry:

# Parametr Význam
1 :border šířka mezi okraji okna a komponentami
2 :hgap horizontální mezera mezi komponentami
3 :vgap vertikální mezera mezi komponentami
4 :align zarovnání komponent
5 :items sekvence obsahující komponenty, které se mají umístit do okna či na panel

Tento úryvek kódu bude použit v demonstračním příkladu nazvaném seesaw12.

Vytvoření kostry demonstračního příkladu:

lein new app seesaw12

Projektový soubor project.clj:

(defproject seesaw12 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw12.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw12/core.clj:

(ns seesaw12.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(def formular
    (flow-panel :hgap 10 :vgap 10 :border 10 :align :center
                :items [(button :text ":background :red"    :background :red)
                        (button :text ":background :yellow" :background :yellow)
                        (button :text ":background :orange" :background :orange)
                        (button :text ":background #ff8080" :background "#ff8080")
                        (button :text ":background #8080ff" :background "#8080ff")
                        (button :text ":background #8f8"    :background "#8f8")
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Flow layout test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

Obrázek 12: Tlačítka umístěná na plochu okna s využitím správce rozvržení flow-panel.

7. Správce rozvržení border-panel

V pořadí třetím správcem rozvržení grafických komponent, s nímž se setkáme, je BorderLayout manažer. Pro vývojáře, kteří nikdy nepracovali s knihovnou Swing, se může jednat o poněkud zvláštního správce rozvržení (použitelný je pro maximálně pět komponent popř. pro pět subpanelů), ve skutečnosti se však jedná o velmi užitečný nástroj, především při ručním návrhu formulářů. Při použití BorderLayout manažeru se v knihovně Seesaw používá funkce/konstruktor nazvaná border-panel. Této funkci je možné předat několik pojmenovaných parametrů:

# Parametr Význam
1 :border šířka mezi okraji okna a komponentami
2 :hgap horizontální mezera mezi komponentami
3 :vgap vertikální mezera mezi komponentami
4 :north komponenta umístěná v horní části okna/panelu
5 :south komponenta umístěná v dolní části okna/panelu
6 :west komponenta umístěná v levé části okna/panelu
7 :east komponenta umístěná v pravé části okna/panelu
8 :center komponenta umístěná ve střední části okna/panelu

Podívejme se na příklad – umístění pěti tlačítek na formuláři:

(border-panel :hgap 10 :vgap 10 :border 10
              :north  (button :text "North"  :background "#afa")
              :south  (button :text "South"  :background "#aaf")
              :west   (button :text "West"   :background :yellow)
              :center (button :text "Center" :background :orange)
              :east   (button :text "East"   :background :red)
              ))

Obrázek 13: Tlačítka umístěná na plochu okna s využitím správce rozvržení border-panel.

Tento kód je součástí dalšího dnešního demonstračního příkladu. Vytvoření kostry demonstračního příkladu se provede příkazem:

lein new app seesaw13

Projektový soubor project.clj:

(defproject seesaw13 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw13.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw13/core.clj:

(ns seesaw13.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(def formular
    (border-panel :hgap 10 :vgap 10 :border 10
                  :north  (button :text "North"  :background "#afa")
                  :south  (button :text "South"  :background "#aaf")
                  :west   (button :text "West"   :background :yellow)
                  :center (button :text "Center" :background :orange)
                  :east   (button :text "East"   :background :red)
                  ))
 
(defn -main
    [& args]
    (-> (frame :title "Border layout test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

8. Správce rozvržení horizontal-panel

Další správce rozvržení je v knihovně Seesaw reprezentován funkcí/konstruktorem horizontal-panel. Použití tohoto správce je velmi jednoduché, neboť umisťuje jednotlivé komponenty vedle sebe na jediný řádek, podobně jako FlowLayout manažer, ovšem bez automatického přechodu na další řádek:

Obrázek 14: Tlačítka umístěná na plochu okna s využitím správce rozvržení horizontal-panel.

Bez dalšího zdlouhavého popisu se podívejme na dnešní předposlední demonstrační příklad, v němž se tento správce rozložení použije pro umístění pětice tlačítek na formulář.

Vytvoření kostry demonstračního příkladu:

lein new app seesaw14

Projektový soubor project.clj:

(defproject seesaw14 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw14.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw14/core.clj:

(ns seesaw14.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(def formular
    (horizontal-panel :border 10
                :items [(button :text ":background :red"    :background :red)
                        (button :text ":background :yellow" :background :yellow)
                        (button :text ":background :orange" :background :orange)
                        (button :text ":background #ff8080" :background "#ff8080")
                        (button :text ":background #8080ff" :background "#8080ff")
                        (button :text ":background #8f8"    :background "#8f8")
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Horizontal panel layout test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

9. Správce rozvržení vertical-panel

V dnešním sedmém a současně i posledním demonstračním příkladu si ukážeme použití správce rozvržení představovaného v knihovně Seesaw funkcí/konstruktorem se jménem vertical-panel. Jak již název napovídá, jsou všechny komponenty umístěny vertikálně pod sebou, ovšem šířka komponent není (ve výchozím nastavení) nijak ovlivněna šířkou ostatních komponent, což je ostatně patrné i při pohledu na screenshot:

Obrázek 15: Tlačítka umístěná na plochu okna s využitím správce rozvržení vertical-panel.

Použití tohoto správce rozvržení je velmi snadné:

(vertical-panel :border 10
            :items [(button :text ":background :red"    :background :red)
                    (button :text ":background :yellow" :background :yellow)
                    (button :text ":background :orange" :background :orange)
                    (button :text ":background #ff8080" :background "#ff8080")
                    (button :text ":background #8080ff" :background "#8080ff")
                    (button :text ":background #8f8"    :background "#8f8")
                    ]))

Podívejme se nyní na celý kód demonstračního příkladu. Vytvoření kostry demonstračního příkladu:

lein new app seesaw15

Projektový soubor project.clj:

(defproject seesaw15 "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
                 [seesaw "1.4.5"]]
  :main ^:skip-aot seesaw15.core
  :target-path "target/%s"
  :profiles {:uberjar {:aot :all}})

Zdrojový soubor src/seesaw15/core.clj:

(ns seesaw15.core
    (:gen-class))
 
(use 'seesaw.core)
(use 'seesaw.color)
 
(def formular
    (vertical-panel :border 10
                :items [(button :text ":background :red"    :background :red)
                        (button :text ":background :yellow" :background :yellow)
                        (button :text ":background :orange" :background :orange)
                        (button :text ":background #ff8080" :background "#ff8080")
                        (button :text ":background #8080ff" :background "#8080ff")
                        (button :text ":background #8f8"    :background "#8f8")
                        ]))
 
(defn -main
    [& args]
    (-> (frame :title "Vertical panel layout test"
               :on-close :exit
               :content formular)
        (pack!)
        (show!)))

10. Repositář s demonstračními příklady

Všech sedm dnes popsaných demonstračních příkladů bylo, podobně jako v předchozích částech tohoto seriálu, uloženo do GIT repositáře dostupného na adrese https://github.com/tisnik/clojure-examples. V tabulce zobrazené pod tímto odstavcem naleznete na jednotlivé příklady přímé odkazy:

Naklonování celého repositáře zajistí příkaz:

git clone http://github.com/tisnik/clojure-examples.git
Cloning into 'clojure-examples'...
remote: Counting objects: 560, done.
remote: Compressing objects: 100% (50/50), done.
remote: Total 560 (delta 32), reused 0 (delta 0), pack-reused 478
Receiving objects: 100% (560/560), 95.12 KiB | 0 bytes/s, done.
Resolving deltas: 100% (212/212), done.
Checking connectivity... done.

11. Odkazy na předchozí části seriálu

Stalo se již zvykem uvést odkazy na všechny předchozí části tohoto seriálu. Tento zvyk samozřejmě dodržíme i dnes:

  1. Leiningen: nástroj pro správu projektů napsaných v Clojure
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure/
  2. Leiningen: nástroj pro správu projektů napsaných v Clojure (2)
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-2/
  3. Leiningen: nástroj pro správu projektů napsaných v Clojure (3)
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-3/
  4. Leiningen: nástroj pro správu projektů napsaných v Clojure (4)
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-4/
  5. Leiningen: nástroj pro správu projektů napsaných v Clojure (5)
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-5/
  6. Leiningen: nástroj pro správu projektů napsaných v Clojure (6)
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-6/
  7. Programovací jazyk Clojure a databáze (1.část)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-databaze-1-cast/
  8. Pluginy pro Leiningen
    http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-pluginy-pro-leiningen/
  9. Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi/
  10. Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi
    http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi-2/
  11. Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk
    http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk/
  12. Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (2)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-2/
  13. Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (dokončení)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-dokonceni/
  14. Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure
    http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure/
  15. Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (2)
    http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure-2/

12. Odkazy na Internetu

  1. Building User Interfaces with Seesaw (slajdy k přednášce)
    http://darevay.com/talks/clo­jurewest2012/#/title-slide
  2. Seesaw na GitHubu
    https://github.com/daveray/seesaw
  3. Seesaw API Documentation
    http://daveray.github.io/seesaw/
  4. Seesaw wiki
    https://github.com/davera­y/seesaw/wiki
  5. seesaw-repl-tutorial.clj
    https://gist.github.com/da­veray/1441520
  6. Témata o Seesaw na Google groups
    https://groups.google.com/fo­rum/#!forum/seesaw-clj
  7. Threading macro (dokumentace k jazyku Clojure)
    https://clojure.github.io/clo­jure/clojure.core-api.html#clojure.core/->
  8. Understanding the Clojure → macro
    http://blog.fogus.me/2009/09/04/un­derstanding-the-clojure-macro/
  9. Clisk
    https://github.com/mikera/clisk
  10. clojars: net.mikera/clisk
    https://clojars.org/net.mikera/clisk
  11. clojure.inspector
    http://clojure.github.io/clo­jure/clojure.inspector-api.html
  12. Clisk: wiki
    https://github.com/mikera/clisk/wiki
  13. Dokumentace vygenerovaná pro knihovnu core.matrix
    https://cloojure.github.i­o/doc/core.matrix/index.html
  14. Size and Dimensionality
    https://groups.google.com/fo­rum/#!topic/numerical-clojure/zebBCa68eTw/discussion
  15. Towards core.matrix for Clojure?
    https://clojurefun.wordpres­s.com/2013/01/05/towards-core-matrix-for-clojure/
  16. The Clojure Toolbox
    http://www.clojure-toolbox.com/
  17. Neanderthal
    http://neanderthal.uncomplicate.org/
  18. Hello world project
    https://github.com/uncompli­cate/neanderthal/blob/mas­ter/examples/hello-world/project.clj
  19. vectorz-clj
    https://github.com/mikera/vectorz-clj
  20. vectorz – Examples
    https://github.com/mikera/vectorz-clj/wiki/Examples
  21. gloss
    https://github.com/ztellman/gloss
  22. HTTP client/server for Clojure
    http://www.http-kit.org/
  23. Array Programming
    https://en.wikipedia.org/wi­ki/Array_programming
  24. Discovering Array Languages
    http://archive.vector.org­.uk/art10008110
  25. no stinking loops – Kalothi
    http://www.nsl.com/
  26. Vector (obsahuje odkazy na články, knihy a blogy o programovacích jazycích APL, J a K)
    http://www.vector.org.uk/
  27. APL Interpreters
    http://www.vector.org.uk/?a­rea=interpreters
  28. APL_(programming_language
    http://en.wikipedia.org/wi­ki/APL_(programming_langu­age
  29. APL FAQ
    http://www.faqs.org/faqs/apl-faq/
  30. APL FAQ (nejnovější verze)
    http://home.earthlink.net/~swsir­lin/apl.faq.html
  31. A+
    http://www.aplusdev.org/
  32. APLX
    http://www.microapl.co.uk/
  33. FreeAPL
    http://www.pyr.fi/apl/index.htm
  34. J: a modern, high-level, general-purpose, high-performance programming language
    http://www.jsoftware.com/
  35. K, Kdb: an APL derivative for Solaris, Linux, Windows
    http://www.kx.com
  36. openAPL (GPL)
    http://sourceforge.net/pro­jects/openapl
  37. Parrot APL (GPL)
    http://www.parrotcode.org/
  38. Learning J (Roger Stokes)
    http://www.jsoftware.com/hel­p/learning/contents.htm
  39. Rosetta Code
    http://rosettacode.org/wiki/Main_Page
  40. Why APL
    http://www.acm.org/sigapl/whyapl.htm
  41. java.jdbc API Reference
    https://clojure.github.io/java.jdbc/
  42. Hiccup
    https://github.com/weavejester/hiccup
  43. Clojure Ring na GitHubu
    https://github.com/ring-clojure/ring
  44. A brief overview of the Clojure web stack
    https://brehaut.net/blog/2011/rin­g_introduction
  45. Getting Started with Ring
    http://www.learningclojure­.com/2013/01/getting-started-with-ring.html
  46. Getting Started with Ring and Compojure – Clojure Web Programming
    http://www.myclojureadven­ture.com/2011/03/getting-started-with-ring-and-compojure.html
  47. Unit Testing in Clojure
    http://nakkaya.com/2009/11/18/unit-testing-in-clojure/
  48. Testing in Clojure (Part-1: Unit testing)
    http://blog.knoldus.com/2014/03/22/tes­ting-in-clojure-part-1-unit-testing/
  49. API for clojure.test – Clojure v1.6 (stable)
    https://clojure.github.io/clo­jure/clojure.test-api.html
  50. Leiningen: úvodní stránka
    http://leiningen.org/
  51. Leiningen: Git repository
    https://github.com/techno­mancy/leiningen
  52. leiningen-win-installer
    http://leiningen-win-installer.djpowell.net/
  53. Clojure 1: Úvod
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm/
  54. Clojure 2: Symboly, kolekce atd.
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-2-cast/
  55. Clojure 3: Funkcionální programování
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-3-cast-funkcionalni-programovani/
  56. Clojure 4: Kolekce, sekvence a lazy sekvence
    http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-4-cast-kolekce-sekvence-a-lazy-sekvence/
  57. Clojure 5: Sekvence, lazy sekvence a paralelní programy
    http://www.root.cz/clanky/clojure-a-bezpecne-aplikace-pro-jvm-sekvence-lazy-sekvence-a-paralelni-programy/
  58. Clojure 6: Podpora pro paralelní programování
    http://www.root.cz/clanky/programovaci-jazyk-clojure-6-futures-nejsou-jen-financni-derivaty/
  59. Clojure 7: Další funkce pro paralelní programování
    http://www.root.cz/clanky/programovaci-jazyk-clojure-7-dalsi-podpurne-prostredky-pro-paralelni-programovani/
  60. Clojure 8: Identity, stavy, neměnné hodnoty a reference
    http://www.root.cz/clanky/programovaci-jazyk-clojure-8-identity-stavy-nemenne-hodnoty-a-referencni-typy/
  61. Clojure 9: Validátory, pozorovatelé a kooperace s Javou
    http://www.root.cz/clanky/programovaci-jazyk-clojure-9-validatory-pozorovatele-a-kooperace-mezi-clojure-a-javou/
  62. Clojure 10: Kooperace mezi Clojure a Javou
    http://www.root.cz/clanky/programovaci-jazyk-clojure-10-kooperace-mezi-clojure-a-javou-pokracovani/
  63. Clojure 11: Generátorová notace seznamu/list comprehension
    http://www.root.cz/clanky/programovaci-jazyk-clojure-11-generatorova-notace-seznamu-list-comprehension/
  64. Clojure 12: Překlad programů z Clojure do bajtkódu JVM I:
    http://www.root.cz/clanky/programovaci-jazyk-clojure-12-preklad-programu-z-clojure-do-bajtkodu-jvm/
  65. Clojure 13: Překlad programů z Clojure do bajtkódu JVM II:
    http://www.root.cz/clanky/programovaci-jazyk-clojure-13-preklad-programu-z-clojure-do-bajtkodu-jvm-pokracovani/
  66. Clojure 14: Základy práce se systémem maker
    http://www.root.cz/clanky/programovaci-jazyk-clojure-14-zaklady-prace-se-systemem-maker/
  67. Clojure 15: Tvorba uživatelských maker
    http://www.root.cz/clanky/programovaci-jazyk-clojure-15-tvorba-uzivatelskych-maker/
  68. Clojure 16: Složitější uživatelská makra
    http://www.root.cz/clanky/programovaci-jazyk-clojure-16-slozitejsi-uzivatelska-makra/
  69. Clojure 17: Využití standardních maker v praxi
    http://www.root.cz/clanky/programovaci-jazyk-clojure-17-vyuziti-standardnich-maker-v-praxi/
  70. Clojure 18: Základní techniky optimalizace aplikací
    http://www.root.cz/clanky/programovaci-jazyk-clojure-18-zakladni-techniky-optimalizace-aplikaci/
  71. Clojure 19: Vývojová prostředí pro Clojure
    http://www.root.cz/clanky/programovaci-jazyk-clojure-19-vyvojova-prostredi-pro-clojure/
  72. Clojure 20: Vývojová prostředí pro Clojure (Vimu s REPL)
    http://www.root.cz/clanky/programovaci-jazyk-clojure-20-vyvojova-prostredi-pro-clojure-integrace-vimu-s-repl/
  73. Clojure 21: ClojureScript aneb překlad Clojure do JS
    http://www.root.cz/clanky/programovaci-jazyk-clojure-21-clojurescript-aneb-preklad-clojure-do-javascriptu/
Našli jste v článku chybu?
Podnikatel.cz: EET: Totálně nezvládli metodologii projektu

EET: Totálně nezvládli metodologii projektu

Podnikatel.cz: Vrátí zvýhodnění, ale výrazně omezí paušály

Vrátí zvýhodnění, ale výrazně omezí paušály

Podnikatel.cz: Víme první výsledky doby odezvy #EET

Víme první výsledky doby odezvy #EET

Podnikatel.cz: Přehledná titulka, průvodci, responzivita

Přehledná titulka, průvodci, responzivita

Vitalia.cz: Baletky propagují zdravotní superpostel

Baletky propagují zdravotní superpostel

Vitalia.cz: Dáte si jahody s plísní?

Dáte si jahody s plísní?

Měšec.cz: U levneELEKTRO.cz už reklamaci nevyřídíte

U levneELEKTRO.cz už reklamaci nevyřídíte

DigiZone.cz: Recenze Westworld: zavraždit a...

Recenze Westworld: zavraždit a...

Měšec.cz: Air Bank zruší TOP3 garanci a zdražuje kurzy

Air Bank zruší TOP3 garanci a zdražuje kurzy

120na80.cz: Rakovina oka. Jak ji poznáte?

Rakovina oka. Jak ji poznáte?

Podnikatel.cz: Babiše přesvědčila 89letá podnikatelka?!

Babiše přesvědčila 89letá podnikatelka?!

DigiZone.cz: Sony KD-55XD8005 s Android 6.0

Sony KD-55XD8005 s Android 6.0

Vitalia.cz: Jsou čajové sáčky toxické?

Jsou čajové sáčky toxické?

Podnikatel.cz: Na poslední chvíli šokuje výjimkami v EET

Na poslední chvíli šokuje výjimkami v EET

Vitalia.cz: Chtějí si léčit kvasinky. Lék je jen v Německu

Chtějí si léčit kvasinky. Lék je jen v Německu

Lupa.cz: Seznam mění vedení. Pavel Zima v čele končí

Seznam mění vedení. Pavel Zima v čele končí

DigiZone.cz: Rádio Šlágr má licenci pro digi vysílání

Rádio Šlágr má licenci pro digi vysílání

120na80.cz: Horní cesty dýchací. Zkuste fytofarmaka

Horní cesty dýchací. Zkuste fytofarmaka

Podnikatel.cz: Chaos u EET pokračuje. Jsou tu další návrhy

Chaos u EET pokračuje. Jsou tu další návrhy

Lupa.cz: Insolvenční řízení kvůli cookies? Vítejte v ČR

Insolvenční řízení kvůli cookies? Vítejte v ČR