Qual è il modo migliore per fare le GUI in Clojure?
https://stackoverflow.com/questions/233171
-
04-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianSoluzione
Suggerirò umilmente Altalena .
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!)
Altri suggerimenti
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 / primi-passi-con-clojure-swing
Se vuoi fare la programmazione della GUI sceglierei Convertitore di temperatura o la colonia di formiche .
Molte operazioni in Swing vengono eseguite in base alla sottoclasse, in particolare se si creano componenti personalizzati. Per questo ci sono due funzioni / macro essenziali: proxy e classe gen .
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 per la creazione di GUI alla CLIM , ma di fare qualcosa altro Lispy: inizia a scrivere la tua applicazione Swing e disegna 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.
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, varrebbe la pena consultare la interoperabilità del sito web di clojure.
Nessuno lo ha ancora suggerito, quindi lo farò: Browser come piattaforma UI. Puoi scrivere la tua app in Clojure, incluso un server HTTP e quindi sviluppare l'interfaccia utente utilizzando qualsiasi cosa, da HTML a hiccup , ClojureScript e qualsiasi altro i miliardi di libaries di JS di cui hai bisogno. Se desideri un comportamento coerente del browser e "app desktop cerca" sentiti "" potresti raggruppare Chrome con la tua app .
Questo sembra essere il modo in cui Tavolo luminoso è distribuito.
Esiste un wrapper per MigLayout in clojure contrib. Puoi anche dare un'occhiata a questa sintesi . Fondamentalmente sto mettendo su 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)))
C'è stato parlare sulla mailing list di alcune celle ( a 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.
Dopo tutto, 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)))
Sto sviluppando 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 best practice più idiomatiche di Clojure, richiedendo l'uso di uno stato mutabile, ecc.
Ma anche io non sono ancora molto vicino a Clojure e potrebbe essere il caso che sia possibile e non ho ancora scoperto come farlo correttamente.
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 utilizzare, 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 credo che ce ne sia uno ufficiale, ma personalmente trarrei vantaggio dal fatto che sto usando uno dei linguaggi 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 un'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 :)
Il mio ambiente di interfaccia utente Clojure preferito utilizza IO.js (Nodo per ES6) + Electron (Container) + Quiescent ( Wrapper ReactJS) .
