Qual è il modo migliore per fare le GUI in Clojure ?
C'è un esempio di alcuni wrapper Swing o SWT funzionali ? O qualche integrazione con la descrizione della GUI dichiarativa di JavaFX che potrebbe essere facilmente inclusa nelle espressioni s usando un po 'di macrologia?
Qualche tutorial?
Risposte:
Suggerirò umilmente il movimento alternato .
Ecco un tutorial basato su REPL che non presuppone alcuna conoscenza di Java o Swing.
L'altalena è molto simile a ciò che suggerisce @tomjen. Ecco "Ciao, mondo":
(use 'seesaw.core)
(-> (frame :title "Hello"
:content "Hello, Seesaw"
:on-close :exit)
pack!
show!)ed ecco l'esempio di @Abhijith e @ dsm, tradotto letteralmente:
(ns seesaw-test.core
(:use seesaw.core))
(defn handler
[event]
(alert event
(str "<html>Hello from <b>Clojure</b>. Button "
(.getActionCommand event) " clicked.")))
(-> (frame :title "Hello Swing" :on-close :exit
:content (button :text "Click Me" :listen [:action handler]))
pack!
show!)Stuart Sierra ha recentemente pubblicato una serie di post sul blog sullo sviluppo della GUI con clojure (e swing). Inizia qui: http://stuartsierra.com/2010/01/02/first-steps-with-clojure-swing
Se si desidera eseguire la programmazione della GUI, sceglierei Convertitore di temperatura o la colonia di formiche .
Swing esegue molte operazioni in subclasse, in particolare se si creano componenti personalizzati. Per questo ci sono due funzioni / macro essenziali: proxy e gen-class .
Ora capisco dove stai andando con il modo più Lispy. Non credo ci sia ancora niente del genere. Consiglio vivamente di non provare a costruire un grandioso framework di costruzione di GUI alla CLIM , ma di fare qualcosa di più Lispy: iniziare a scrivere l'applicazione Swing e astrarre i tuoi schemi comuni con le macro. Quando lo fai potresti finire con una lingua per scrivere il tuo tipo di GUI, o forse alcune cose molto generiche che possono essere condivise e crescere.
Una cosa che perdi quando scrivi le GUI in Clojure è l'uso di strumenti come Matisse. Questo può essere un punto forte per scrivere alcune parti in Java (la GUI) e alcune parti in Clojure (la logica). Il che in realtà ha senso come nella logica sarai in grado di costruire un linguaggio per il tuo tipo di logica usando le macro e penso che ci sia di più da guadagnare rispetto alla GUI. Ovviamente, dipende dalla tua applicazione.
Nessuno l'ha ancora suggerito, quindi lo farò: Browser come piattaforma UI. Potresti scrivere la tua app in Clojure, incluso un server HTTP e quindi sviluppare l'interfaccia utente usando qualsiasi cosa, dall'HTML al singhiozzo , ClojureScript e uno qualsiasi dei miliardi di librerie JS di cui hai bisogno. Se desideri un comportamento coerente del browser e "look'n'feel" per app desktop, puoi raggruppare Chrome con la tua app .
Questo sembra essere il modo in cui è distribuito Light Table .
Da questa pagina :
(import '(javax.swing JFrame JButton JOptionPane)) ;'
(import '(java.awt.event ActionListener)) ;'
(let [frame (JFrame. "Hello Swing")
button (JButton. "Click Me")]
(.addActionListener button
(proxy [ActionListener] []
(actionPerformed [evt]
(JOptionPane/showMessageDialog nil,
(str "<html>Hello from <b>Clojure</b>. Button "
(.getActionCommand evt) " clicked.")))))
(.. frame getContentPane (add button))
(doto frame
(.setDefaultCloseOperation JFrame/EXIT_ON_CLOSE)
.pack
(.setVisible true)))
print("code sample");E, naturalmente, sarebbe la pena di guardare l' interoperabilità sezione del sito web di clojure.
C'è un wrapper per MigLayout nel clojure contrib. Puoi anche dare un'occhiata a questo riassunto . Fondamentalmente sto mettendo qualunque codice sto scrivendo mentre sto imparando swing / miglayout.
L'esempio di dsm riscritto in modo chiaro usando contrib.swing-utils
(ns test
(:import (javax.swing JButton JFrame))
(:use (clojure.contrib
[swing-utils :only (add-action-listener)])))
(defn handler
[event]
(JOptionPane/showMessageDialog nil,
(str "<html>Hello from <b>Clojure</b>. Button "
(.getActionCommand event) " clicked.")))
(let [ frame (JFrame. "Hello Swing")
button (JButton. "Click Me") ]
(add-action-listener button handler)
(doto frame
(.setDefaultCloseOperation JFrame/EXIT_ON_CLOSE)
(.add button)
(.pack)
(.setVisible true)))Nella mailing list si è parlato di alcune implementazioni di Cells (a la Kenny Tilton's Cells ). È un modo abbastanza semplice per eseguire la programmazione della GUI.
Preferirei optare per clojurefx, è un po 'prematuro, ma funziona e ti fa risparmiare tempo.
Ho iniziato la mia GUI con l'altalena e poi ho provato un altro componente in clojurefx.
Ho finito entrambi e sono convinto che rifatterò il movimento alternato in clojurefx.
Dopotutto, JavaFX è la strada da percorrere.
Sembra più leggero del movimento alternato. O almeno, scrivendolo ..
I collegamenti funzionano, i listener funzionano, la maggior parte dei componenti funziona, altrimenti, basta usare una delle macro per creare un costruttore per quel particolare caso e lavoro svolto. Oppure, se lo trovi difficile, scrivi alcuni metodi in Java e chiedi aiuto per migliorare clojurefx.
Il ragazzo che ha scritto clojurefx al momento è impegnato, ma puoi biforcare il progetto e fare alcune correzioni.
Ecco un altro esempio di avvolgimento altalena molto semplice:
; time for some swing
(import '(javax.swing JFrame JTable JScrollPane))
(import '(javax.swing.table DefaultTableModel))
(let
[frame (JFrame. "Hello Swing")
dm (DefaultTableModel.)
table (JTable. dm)
scroll (JScrollPane. table)]
(doto dm
(.setNumRows 30)
(.setColumnCount 5))
(.. frame getContentPane (add scroll))
(doto frame
(.setDefaultCloseOperation JFrame/EXIT_ON_CLOSE)
(.pack)
(.setVisible true)))Ho sviluppato un'applet Java in cui tutto è scritto in Clojure tranne il codice dell'applet, che è scritto in Java. L'applet richiama i callback del codice Clojure di init, paint, ecc. Dagli hook di java per quei metodi che sono definiti dal modello dell'applet. Quindi il codice finisce per essere Clojure al 99,999 per cento e per la maggior parte non devi assolutamente pensare al minuscolo pezzo di Java.
Ci sono alcuni svantaggi di questo approccio, che spero di discutere in modo più dettagliato sul gruppo Google Clojure. Penso che gli sviluppatori di Clojure dovrebbero includere un modo nativo di creare applicazioni. Al momento puoi fare qualsiasi cosa GUI ti piaccia dalla REPL, ma se vuoi un'applicazione GUI consegnabile, è necessario scrivere un po 'di Java per chiamare il codice Clojure. Inoltre, sembra che l'architettura di un tipo di applet Java ti costringa al di fuori delle migliori pratiche più idiomatiche di Clojure, richiedendo l'uso di uno stato mutabile, ecc.
Inoltre, non sono ancora molto vicino a Clojure e potrebbe essere il caso che sia possibile e non ho ancora scoperto come farlo correttamente.
Il mio ambiente di interfaccia utente Clojure preferito utilizza IO.js (Nodo per ES6) + Elettrone (Contenitore) + Quiescente (involucro ReactJS) .
Quindi non ho visto Fn-Fx in questa lista, da Timothy Baldridge (algiri). Questa è una libreria Clojure che fornisce un'astrazione funzionale su JavaFX.
È disponibile su Github all'indirizzo https://github.com/halgari/fn-fx .
Per usarlo, assicurati di utilizzare una versione recente di Java (1.8 90+) e aggiungi una dipendenza al repository github aggiungendo quanto segue a project.clj:
:plugins [[lein-git-deps "0.0.1-SNAPSHOT"]]
:git-dependencies [["https://github.com/halgari/fn-fx.git"]]L'ho provato e funziona subito.
Clojure e SWT è l'approccio migliore per eseguire le GUI. Fondamentalmente, SWT è un approccio plug and play per lo sviluppo di software.
Non penso che ce ne sia uno ufficiale, ma personalmente trarrei vantaggio dal fatto che sto usando una delle lingue più potenti al mondo e immagino solo come sarebbe il perfetto codice gui:
(form {:title :on-close dispose :x-size 500 :y-size 450}
[(button {:text "Close" :id 5 :on-click #(System/exit 0) :align :bottom})
(text-field {:text "" :on-change #(.println System/out (:value %)) :align :center})
(combo-box {:text "Chose background colour" :on-change background-update-function
:items valid-colours})])La tua idea sarebbe diversa ma questo dovrebbe sperare che quanto sopra ti dia qualche idea.
So che stai suggerendo soluzioni desktop classiche, ma il web si adatta abbastanza bene al clojure. Ho scritto un'applicazione audio completa in cui tutto è collegato in modo tale che se aggiungi musica alla cartella audio si rifletta nell'interfaccia utente web. Sto solo dicendo che l'applicazione desktop non è l'unico modo :)