JavaFX in AutoIt? - Framework

  • Schönen guten Abend werte Community!
    Lange habe ich nichts mehr von mir hören lassen. Meine Ausbildung nimmt mich doch sehr mit, vor allem für Java muss ich meine Zeit nutzen. Da ich aber wieder Lust bekommen habe was für meine „alte Community“, also ihr, zu tun, kam mir eine kleine prickelnde Idee.


    Ich selber finde die JavaFX Bibliothek (GUI Programmierung) äußerst praktisch und würde sie gerne für AutoIt vollständig verfügbar machen, bzw. das Konzept dahinter. Ob ich hinterher komplett die Bibliothek wrappe oder gar selber schreibe überlege ich mir noch.


    Vorab würde ich aber gerne wissen was ihr von der Idee haltet, und ob diese Bibliothek, sofern ich sie zur Verfügung stelle für AutoIt, auch ihren Nutzen finden wird. Im folgenden möchte ich euch einen kleinen Einblick gewähren was die Bibliothek eigentlich alles bietet.


    Normale GUIs und deren Controls
    Erst einmal unterscheidet sich die Bibliothek nicht von den herkömmlichen. Es gibt die standard Controls wie überall auch. Jedoch bietet sie auch einige erweiterte Controls die ich euch hier einfach mal auflisten möchte:


    Accordion
    ColorPicker
    Hyperlink
    Pagination
    PasswordField
    PopupControl
    SplitPane


    Bis dato nichts ungewöhnliches. :)



    Gridsysteme
    Jetzt wird’s interessant. Statt Controls einzelnd pixelgenau zu positionieren, bietet die Bibliothek einige Gridsysteme. Diese erlauben es eine Art Tabelle zu erstellen (Zeilen und Spalten) wo dann zu den Zellen die Controls zugewiesen werden. Das bietet dynamische Controlgrößen (bei Vergrößerung bzw. Verkleinerung des Fensters) oder auch zum logischen Aufbauen einer GUI. Durch viele Hilfcontrols können so Steuerelemente relativ zu anderen Elementen ausgerichtet sowie Positioniert werden.



    CSS für den Style
    Eine Besonderheit der Bibliothek ist die einfache Designmöglichkeit. Steuerelemente können mithilfe von CSS im Design grundlegend verändert werden. Dies bietet gestalterische Freiheit und trennt das Design vom Code. Ich denke ein Bild sagt mehr als 1000 Worte:


    [Blockierte Grafik: http://www2.pic-upload.de/img/31771704/Screen.png]
    [Blockierte Grafik: http://www2.pic-upload.de/img/31771681/Screen.png]




    Animationen
    Das Framework bietet viele Funktionen um Animationen in der GUI zu erstellen. Es können Laufpfade gesetzt werden an denen Objekte (Shapes) entlang laufen. Verschiedene Farbverläufe etc...


    Sämtliche Spielereien sind möglich ohne großen Aufwand und „manueller Berechnung“. Frei nach dem Prinzip „Keyframes reichen“.


    [Blockierte Grafik: http://www2.pic-upload.de/img/31771691/Screen.png]



    Und und und...
    Im Prinzip bietet die Bibliothek vieles um grundlegend GUIs aufzubauen, zu Designen und neue Steuerelemente hinzuzufügen bzw. selber zu schreiben. Ich würde von euch gerne wissen ob ein allgemeines Interesse an solch einer Bibliothek für AutoIt besteht. Sie muss nicht zwingend 1 zu 1 Orginalgetreu wie die JavaFX sein, jedoch würde ich gerne zumindest die Idee dahinter in eine Bibliothek für AutoIt stecken.


    Was haltet ihr davon? „Braucht“ ihr das oder würde ich meine Zeit verschwenden?

  • Als mir mit Swing, AWT und FX arbeiten mussten kam mir das Kotzen weil es meiner Meinung nach viel zu umständlich war.
    Das positionieren mit Grids und die Styles mit CSS fand ich einfach nur echt schei** und hatte mehr mit Webdevelopment zu tun.


    Ein großer Nachteil ist ja das man Java installiert haben muss, kriegt man etwas ähnliches nicht mit Direct2D und ähnlichen Spielereien hin?

  • Interessant ist die Sache auf jeden Fall, aber ich glaube nicht, dass das eine Person in einem anständigen Zeitraum alleine programmieren kann.

  • Ich empfinde CSS-like Styling als sehr angenehm.
    Positionierung mit Grid-Systemen mag am Anfang etwas gewöhnungsbedürftig sein - ist letztlich aber ein Plus. Vor allem der Vorteil, sich nicht auf fixe Fenster- und Ctrlgrößen festlegen zu müssen und trotzdem ohne große Verrenkungen eine einheitliche Darstellung zu gewährleisten. Wer schon mit wx (Python, Lua, ..) gearbeitet hat, weiß das zu schätzen.


    Bleibt die Frage, welche weiteren Controls (ausser den bereits in AutoIt verfügbaren) in der Bibliothek enthalten wären, die den Aufwand rechtfertigen.
    Wie würde denn die Einbindung in AutoIt stattfinden sollen - per Dll?

  • Ich finde die Idee auch sehr gut (würde auch helfen, wenn du möchtest). Ich selbst benutzt JavaFX sehr gerne (Auch wenn ich MVC dabei gerne ignoriere^^).
    Mich würde auch Interessieren, wie du das Handling mit z.B. Listviews umsetzen möchtest. Diese werden ja mit einzelnen Spalten erzeugt, die mit Factorys arbeiten. Insbesondere die Variablen, die bei Änderung alle eingetragenen Objekte benachrichtigen, mussten dann ja auch umgesetzt werden und allgemein die Objektorientierung ebenfalls... Beim Scrollen wird ja auch immer nur das geladen, was gerade im sichtbaren Bereich ist, der Rest ist nur als Daten im Hintergrund vorhanden uvm..
    Oder wolltest du dich eher nur auf das Design konzentrieren und dabei die in AutoIt vorhandenen Controls nutzen?


    MfG Kanashius

  • Also, ich versuche mal auf alles einzugehen.


    alpines:
    Ja, wenn ich tatsächlich diese Biliothek wrappe (so in der Richtung) wird Java auch erforderlich sein. Allerdings war das JavaFX Framework auch eher ein Vergleichsobjekt. Wie und womit ich das letztendlich umsetze weiß ich noch nicht. Ich habe mich mal grob an dieses Framework orientiert da mir persönlich der Funktionsumfang gefiel. Prinzipiell möchtr ich AutoIt, was die GUI Programmierung betrifft, lediglich erweitern und die bisherigen neueren Technologien zur Verfügung stellen. Je nachdem wie sich hier im Thread noch dazu geäußert wird, benutze ich evtl. sigar eine andere Bibliothek als Basis oder setze selbst eine von Grund aus auf.


    BugFix:
    Zzerst einmal möchte ich definitv 2 Dinge verfügbar machen. Zum einen ist dies das Gridsystem (einfache Möglichkeit das Layout flexibel zu bestimmen), zum anderen die Möglichkeit simpel eigene User Controls hinzuzufügen ohne größeren Aufwand. So soll gewehreistet werden dann zukünftig die Bibliothek von euch selber, um eigene Cintrols zu erweitern. Welche Cintrols ich standardmäßig noch hinzunehme können wir ja zusammen diskutieren, sofern die Nachfrage zu der Projektidee groß genug ist. Eventuell über eine DLL oder sogar ganz in AutoIt als au3 Datei. Mal sehen wie es am effektivsten wird. Vermutlich eher ein Mischmasch.


    Oscar:
    Je nachdem wie ich die Bibliothek schreibe könnte es sein dass Java installiert sein muss. Jedoch steht es noch vollkommen in den Sternen wie genau ich das umsetze. Wie ich bereits weiter oben schrieb, bestegt die Möglichkeit dass ich auch ein anderes Framework dazu benutze bzw. eines selber komplett von Haus aus schreibe.


    Kanashius:
    Das wird ein größeres Projekt, gerne sind da helfende Hände dann gesehen. Ich muss mal noch schauen wie ich was alles mache.




    Also, das mit dem JavaFX war als Vergleich eher gemeint. Viel mehr möchte ich die Technologie zur Verfügung stellen die dahinter steckt. Je nachdem was sich aus dem Thread noch ergibt fang ich das Projekt an oder nicht. Zuerst einmal möchte ich nur abchecken ob dafür überhaupt ein allgemeines Interesse besteht.

  • Nabend,
    ich hätte schon ein Interesse an einer neuen Gui-Umgebung. Aber wie stellst du dir das Handling damit vor? Müsste ich dann selber mit Objekten arbeiten oder erledigst du das innerhalb deiner UDF, weil auf Objekte in AU3 hab ich kein Bock... Auch der GuiMsg Loop, könnten wir die Abfragen so abhandeln wie man es gewohnt ist oder kommt da ein anderes System zum Einsatz? (Das dann andere Befehle verwendet werden meine ich nicht, sollte klar sein) Auch OnEvent wäre wichtig, würdest du das ebenfalls integrieren?


    Wie immer, Fragen über Fragen :D
    Aber grundsätzlich wäre ich an einer alternativen GUI interessiert.


    Grüße!

  • Naja, wie ich das von der Syntax her löse (Richtung OOP-Style) oder aber einfach nur mit ID's arbeite kommt für beides auf's selbe Hinaus. Ich selber tendiere dazu eher das als OOP Syntax umzusetzen, da es meiner Meinung nach schöner zu lesen ist. Ein kleiner Vergleich:


    $oGUI = _Lib_GUI()
    $oButton = _Lib_Button()
    $oButton.setText("Ich bin ein Button")
    $oGUI.add($oButton)


    $hGUI = _Lib_GUI()
    $idButton = _Lib_Button()
    _Lib_ButtonSetText($idButton, "Ich bin ein Button")
    _Lib_GUIAdd($hGUI, $idButton)


    So mal als kleiner Syntaxvergleich. Beides kommt auf's selbe hinaus...
    Mal schauen wie ich's mache, ansonsten kann man ja zum Schluss noch als Feature die andere Möglichkeit noch integrieren. Das sollte nicht das Problem sein.


    Wahrscheinlich wird's darauf hinaus laufen, dass die kompletten GUI Funktionen nicht mit der Bibliothek kompatible werden. Alternativ wird es dafür eigene Funktionen geben, sodass eine schnelle Umgewöhnung möglich sein wird. Ich möchte aber sowieso mit euch nochmal darüber diskutieren, was ihr euch so wünscht und dann Erwartungen daran habt. Immerhin soll die Bibliothek später die GUI Erstellung (ich rede von komplexeren GUI Layouts) wesentlich vereinfachen und euch so weit unterstützen wie nur möglich. Dabei natürlich aber den bisherigen gewohnten Freiraum weiterhin liefern. Was genau ich nun integriere, wie ich Dinge umsetze usw. hängt dann größtenteils von euch ab. Sofern ich das Projekt starte (wenn sich noch ein paar hier melden) werde ich sämtliches mit euch dann besprechen. Was ich mir vorstelle, womit ich anfange und was ihr haben wollt. Es wird eines meiner ersten größeren Projekte die ich meiner Community, die mir geholfen hat einen Start in die Programmierung zu finden, widmen werde.

  • Die Möglichkeit für benutzerdefinierte Controls bietet AutoIt (bzw. die WinAPI) jetzt schon. Das Stichwort lautet Subclassing. Man kann das sogar so weit treiben, dass das eigene Control über Window Messages auf AutoIt-interne Funktionen wie z.B. GUICtrlSetData reagiert.
    Für das Grid-System kann man auch auf die WinAPI zurückgreifen, würde ich schätzen. Du kannst ja einfach die Resize-Messahe abfangen und entsprechend reagieren. Das ist zwar aufwändig, aber grundsätzlich prozedural und in purem AutoIt lösbar.

  • Du kannst ja einfach die Resize-Messahe abfangen und entsprechend reagieren. Das ist zwar aufwändig, aber grundsätzlich prozedural und in purem AutoIt lösbar.

    Das hatte ich vor Jahren mal angefangen. Mein Ansatz damals war: Jedes (Sub)Gridelement wird von einem eigenen Fenster dargestellt (um in jedem Grid unterschiedlich anordnen zu können). Je nach Anzahl der Grids und dort positionierter Controls führt das zu einer Vielzahl von Winmove-Operationen. Probleme waren der Fokuswechsel in die jeweiligen Fenster und das "Verstecken" der Fensterränder.
    Habe das Projekt dann verworfen, weil ich zu keiner befriedigenden Lösung kam. Der Aufwand ist tatsächlich recht groß. Man kann nicht mit GuiRegisterMsg arbeiten - das würde die Funktionalität auf eine GUI im aktuellen Skript begrenzen. Also ist ein Hooken der WM-Messages erforderlich und damit verbunden ein globales Management der erstellten GUI.


    Das Problem beim Resizen in nur einem Fenster ist die Veränderung von Controlgröße und Position beim mehrmaligen Resizen. Das Kalkulieren der Werte führt zu Floatwerten, verwenden können wir nur Ganzzahlen. Es muss also immer ein Teil der Berechnung verworfen werden, sodass ich trotz Wiederherstellung der originalen Fenstergröße plötzlich eine ganz andere Ansicht der Controls erhalte. Mit Min-/Max-Werten kann man da etwas regulieren, aber ein einheitliches Gesamtbild ist schwer zu erreichen.


    Aus meinen Erfahrungen mit der Resize-Thematik halte ich es für wenig wahrscheinlich, dass mit purem AutoIt ein Grid-System effektiv umsetzbar ist.

  • Okey, ich habe mich dazu entschieden das Projekt nun umzusetzen. Nach den Beiträgen hier und nochmaligen Überlegung bin ich der Meinung, dass es sich lohnt und auch Anklang finden wird. Später wird es einen neuen Thread geben wo dann über das Projekt diskutiert werden kann, und ihr aktiv in die Entwicklung beisteuern könnt (sofern ihr mich unterstützen wollt). Das Projekt ist für EUCH, also währe es schön wenn da Ideen und Meinungen geäußert werden.


    Ich habe zudem folgendes beschlossen:
    - Ich werde nicht auf eine externe Bibliothek zugreifen, sondern das Alles von Grund auf aufsetzen. Alleine die WinAPI dient als Basis.
    - Die Bibliothek werde ich in FreeBASIC verfassen und dann via DLL Aufrufe verfügbar machen. So kann sie auch in anderen Sprachen genutzt werden.
    - Ich werde mit Handles und IDs arbeiten und die GUIs können auch mit der WinAPI angesteuert werden, jedoch fallen die GUI Funktionen flach wofür es eigene Funktionen geben wird.
    - Das Projekt wird Open Source unter folgender Lizenz: http://www.wtfpl.net/
    - Die Bibliothek wird MakeGUI heißen ;)


    Im Thread werde ich dann meine ersten Ideen und Vorstellungen detailliert posten, damit darüber diskutiert werden kann. Orientieren tue ich mich (vom Funktionsumfang) an der JavaFX Bibliothek, viele Bezeichnungen werde ich da auch fast 1 zu 1 übernehmen. Vor allem was Methodennamen usw. betreffen. Helfende Hände (egal welcher Hinsicht) sind immer gesehen. Sei es sich aktiv an Diskussionen zu beteiligen, oder aber selber mit zu programmieren. Aber zuerst zur Planung :)


    Gibt es Einwände?

  • Ich habe zudem folgendes beschlossen:
    - Ich werde nicht auf eine externe Bibliothek zugreifen, sondern das Alles von Grund auf aufsetzen. Alleine die WinAPI dient als Basis.
    - Die Bibliothek werde ich in FreeBASIC verfassen und dann via DLL Aufrufe verfügbar machen. So kann sie auch in anderen Sprachen genutzt werden.

    Wenn es so ist werde ich es zumindest testen. Bei benötigter Java-Runtime hätte ich verweigert.

  • Das freut mich doch autoBert, letztenendes möchte ich das GUI Management schlichtweg vereinfachen. Das Hauptziel der Bibliothek soll sein einfach Professionelle GUIs aufzubauen, welche auch leicht erweiterbar sind. Nehmen wir mal ein Beispiel, ihr möchtet euren Programm ein weiteres Control hinzufügen, dafür müsstet ihr jedes andere Control verschieben, was dort im Weg steht. Soll die Bibliothek für euch erledigen, dynamisch versteht sich.


    Oder auch eigene Controls entwickeln. Die Bibliothek soll später die Möglichkeit bieten möglichst einfach eigene Controls zu erstellen welche dann genutzt werden können. Auch das Design der GUI soll später vom Code getrennt werden. Das heißt dass ihr (wie oben gezeigt mit CSS) das Design von Steuerelementen mit einer externen Datei verändern könnt, so habt ihr auch gestalterische Freiheiten.


    Es gibt vieles was ich da im Hinterkopf habe und hier noch nicht geäußert habe. Das Potential entgegen den normalen GUI Funktionen soll sich erst heraus kristallisieren, wenn es soweit ist. Bis dato muss ich erst mal eine ordentliche Basis schaffen. Aber erste Ideen erläutere ich nachher noch. :)


    Und je mehr die Biblithek in der Entwicklung testen, umso schneller komme ich voran und kann Fehler vorbeugen. Ich bin mal gespant wie lange das dauert. potentiell habe ich 1 1/2 Jahre Zeit und werde das Projekt auch fertigstellen.

  • JavaFX

    Hm, ja, das liest sich ja alles wirklich superaffengeil... da ich deine programmiertechnischen Qualitäten mittlerweile ja schon recht gut einschätzen kann ;-) - und ich von daher absolut überzeugt bin, dass du das am Ende alles super umsetzen wirst, sage ich mal in Kurzform: Jeep, ich bin zu 1001% dabei!


    Wenn ich irgendwie helfen kann, lasse es mich wissen - dafür opfere ich gerne meine Freizeit. :D

  • Huch, was meinst du mit einschätzen? Ich war seit einem Jahr nicht mehr hier auf dem Board, geschweige denn dass ich irgendeine Software hier präsentiert habe. o.o
    Jetzt bin ich neugierig, welche Anhaltspunkte nimmst du denn dass du solch eine Aussage tätigen kannst? ^.^


    Nun ja, aber gerne involviere ich dich in das Projekt. Jedoch solltest du (wenn du mir programmiertechnisch da helfen willst) dich mit FreeBASIC auskennen.
    Mit dieser Sprache entwickel ich die Bibliothek. Letztendlich wird es kein JavaFX Wrapper, sondern eine selbständig aufgesetzte Bibliothek die sich an dem JavaFX Framework orientiert.
    Wenn du Discord oder Teamspeak hast, können wir uns gerne mal darüber unterhalten. Ich bin gerade noch in der Planung und muss mir genau überlegen, wie die Bibliothek intern am besten alles verarbeitet
    damit sie:


    1. Leicht erweiterbar ist
    2. eine gute Performance bietet
    3. Leicht verständlich strukturiert ist


    Zudem brauche ich ein System, welches sich um das ganze Management intern kümmert. Da bin ich noch am grübeln. :)

  • Huch, was meinst du mit einschätzen? Ich war seit einem Jahr nicht mehr hier auf dem Board, geschweige denn dass ich irgendeine Software hier präsentiert habe. o.o
    Jetzt bin ich neugierig, welche Anhaltspunkte nimmst du denn dass du solch eine Aussage tätigen kannst?

    Hi Make-Grafik,


    ich habe Dich hier und zur damaligen telefonischen Nachhilfe auch schon mehrfach als "Profi" erleben dürfen. Ich denke Du hast es drauf, das was Du in diesem Thread schreibst, auch umzusetzen. Faszinierend ist für mich nach wie vor, dass sich jemand aus eigener Kraft heraus (wie auch Oscar und manch andere/r hier) das nötige Programmierwissen und das auch noch in mehreren Sprachen anzueignen. Möchte gar nicht wissen, was aus Dir hätte werden können, wenn Du mit Klavier oder Geige angefangen hättest. :saint:


    Zum Thema: Beim Programmieren kann ich nicht helfen. Dafür sind meine Gehirnwindungen für das Thema zu klein und mein Wissen sowie meine Logik viel zu beschränkt. Aber ich werde mich gerne als "Tester" bereitstellen und ich werde diese von Dir genannten Punkte


    1. Leicht erweiterbar ist
    2. eine gute Performance bietet
    3. Leicht verständlich strukturiert ist

    nicht aus den Augen verlieren. :D

  • Mit deinem "Tutorial – OOP in AutoIt" zeigst du doch, mit welcher Gründlichkeit du die Dinge angehst. Zudem bin ich schon seit einigen Jahren hier im Forum unterwegs und habe somit auch schon einige Beiträge von dir gelesen.


    Mit FreeBASIC hantiere ich erst seit ein paar Wochen... programmiertechnisch wäre ich derzeit also keine Hilfe - in ein paar Monaten vielleicht. Und schau an, was @bazii schreibt... grins


    Teamspeak(-Server) habe ich...

  • Servus, es ist nun einige Zeit vergangen. Es war mir zu wenig Interesse an das Thema weshalb ich es damals dann doch wieder verworfen habe. Jedoch benötige ich für ein derzeitig größeres Projekt eine eigene GUI Bibliothek - Oder besser gesagt eher eine Engine. Da ich diese sowieso dann anfange zu programmieren, wollte ich fragen ob es derzeitig einen Bedarf für eine einfach zu verwendende GUI Bibliothek gibt. Dann würde entsprechend eine AutoIt UDF mitliefern.


    Die ganze Bibliothek wird in LUA geschrieben und es werden keine großen externen Frameworks benötigt, lediglich LUA selber (welche ich logischerweise als DLL dann mitliefere). Besteht hieran ggf. ein allgemeines Interesse? Sonst mache ich mir nicht die Mühe die notwendigen Mechanismen mitzuprogrammieren, die notwendig sind um die Bibliothek abseits von LUA zu nutzen.