Wie am elegantesten eine eigene IDE "basteln"

**stahli**

Ich denke, Du müsstest genauer sagen, wo Dein Problem liegt bzw. wozu Du Tipps brauchst.
Bisher ist das m.E. zu allgemein.

Etwas mit Drag&Drop zu verschieben sollte ja machbar sein...
Es ist natürlich auch davon abhängig, ob Du Controls mit eigenem Handle verschiebst oder nur selbst gezeichnete "Objekte".

Das größere Problem wird sein, die gezeichneten Objekte mit den Ereignisbehandlungen und somit dem Code zu verbinden.

Ich weiß nicht recht, worauf Du raus willst...

**hedie**

Danke für eure Antworten

Ich sehe, ich habe das noch etwas zu ungenau beschrieben.

Bei mir auf dem Tisch liegt ähnliche Hardware:

http://www.cutedigi.com/images/mini_STM32_1.jpg
Auf dem darauf befindlichen Touch-Display, können verschiedene Objekte dargestellt werden.
Diese Objekte (Buttons etc...) werden durch die Firmware des Displays erzeugt. Die Firmware stammt ebenfalls von mir.

Dies funktioniert soweit einwandfrei.
Es gibt eine GUI_Library mit welcher man Buttons ala CreateButton(x,y,height,width,color...); erzeugen kann.

Meine Idee ist nun, eine Software zu schreiben, mit Delphi, mit welcher man ein "VirtuellesDisplay" hat, und darauf nun die Objekte platziert. Damit man dies möglichst genau machen kann, wäre die abbildung der einzelnen Pixel vorteilhaft. Die kleinen Displays haben 320x240 und die grossen 800x480px

In der Display Firmware wird später ein Python Interpreter laufen (falls ihr voschläge für eine "gängigere" Skriptsprache habt, bin ich offen dafür). Dieser Interpreter wird dann das erstellen der Buttons übernehmen.

Wenn nun also in meiner "IDE" ein Button platziert wird, so soll im Codefenster der dazugheörige Pythoncode erstellt werden. Dieser wird wohl ähnlich sein wie jener aus der Firmware:
CreateButton(x,y,.......);

Sinn und Zweck des ganzen soll sein, dass man damit schnell und einfach sein GUI erstellen kann.

Damit es möglichst realistisch aussieht, möchte ich nur ungern auf die Buttons der VCL zurückgreifen.
Auf dem Display sehen die Buttons etwa so aus wie jene auf dem bild aus meinem letzten Post.

Oder in etwa so:

http://blog.lincomatic.com/wp-conten...02/btndemo.jpg

Nebst buttons gibt es aber auch noch Labels, Checkboxen, Radiogroups, Editfelder und Tabs.

Meine konkreten Probelem, wo ich tipps brauche:

1. wie erstelle ich ein gitternetz aus einzelnen "pixels" welche mein Display repräsentieren?

2. Wie erzeuge ich am einfachsten "Objekte" wie buttons, welche sich verschieben lassen, resizen, farbeändern etc... und so aussehen wie jene auf meinem echten display? diese sollten sich dann in mein
Pixelraster integrieren. also pixelgenau sein.

3. In meiner "IDE" wird es auch einen Objektinspektor geben, mit welchem man z.B. die Farbe eines Buttons ändern kann etc. Wie verwalte (zur laufzeit) und wie speichere ich all diese Informationen am besten ab, damit ich diese erneut mit meiner IDE laden kann? Ich hätte da an ein XML File gedacht.
Jemand hat das DFM Format vorgeschlagen. Dieses ist aber wohl nur gültig wenn man die Delphi VCL verwendet oder?

Hoffe es ist nun etwas verständlicher...

Danke schonmal

**Sir Rufo**

Es ist völlig schnurz wie du es speicherst, solange du es speicherst

Das DFM-Format bekommst du allerdings "frei Haus" mitgeliefert und würde sich aus diesem Grund anbieten. Jedes andere Format ist genauso gut, wenn es alle benötigten Werte speichert.

Die Konvertierung in ein wie auch immer Format für das Device erfolgt eben durch eine Konvertierung.

Jetzt baust du dir einfach alle Controls, die das Device darstellen kann, nach, damit du diese in deiner IDE benutzen kannst. Vermutlich würde da am Besten eine Ableitung von TGraphicControl passen.

**hedie**

Zitat von Sir Rufo:

Es ist völlig schnurz wie du es speicherst, solange du es speicherst

Jetzt baust du dir einfach alle Controls, die das Device darstellen kann, nach, damit du diese in deiner IDE benutzen kannst. Vermutlich würde da am Besten eine Ableitung von TGraphicControl passen.

Dann würdest du also die Buttons mit Canvas und Paint direkt zeichnen?
Eigentlich könnte ich dazu den selben Code verwenden, welcher auch in der Displyfirmware läuft.

Gibt es per Zufall noch eine art "Zoom" funktion für Canvas?
Damit ich einfach "ein Pixel" zeichnen kann, es dann aber vergrössert dargestellt wird?

**stahli**

Ok, dann wird das schon verständlicher

Also hast Du alles zur Laufzeit fertig bzw. benötigst Du die IDE nicht zur Laufzeit bzw. zum Debuggen o.ä.
Du willst nur vereinfachen, das Script für das Gerät zu erstellen - richtig?

Ich sehe zwei Möglichkeiten:

1)
Du könntest ein TGraphicControl (oder TPanel) nehmen und Paint überschreiben.
Drag&Drop sollte so kein Problem sein. Auch ein Resize könnte man regeln, wenn sich der Cursor rechts unten befindet.
MouseEnter usw. kannst Du dann ja problemlos abfragen.

Ein Raster oder Gitter könnte man auf eine transparente Paintbox über dem Designer zeichnen - mit einer wählbaren Zoomstufe.
Beim Drag&Drop und Resize müsstest Du auf das Raster runden.
Die Controls würde ich optisch nicht exakt nachbilden sondern abstrahieren. Sonst müsstest Du Schriften ja mit zoomen.
(Wenn Du FMX benutzt könntest Du das Zoomen über FMX lösen und müsstest nicht umrechnen.)

2)
Ein anderer Weg wäre, ein Bitmap zu nehmen und alles selbst dort zu zeichnen. Dann müsstest Du virtuell die Positionen der "Controls" speichern und so eine Art Graphikprogramm bauen. Um ein Control zu verschieben musst Du aus der Mausposition im Designer ermitteln, was sich "virtuell" unter dem Cursor befindet und selbst die Veränderungen berechnen.

Den ersten Weg habe ich in meiner Turniersoftware genutzt, den zweiten in meinem beschriebenen Demoprojekt.

**hedie**

Zitat von stahli:

Ok, dann wird das schon verständlicher

Also hast Du alles zur Laufzeit fertig bzw. benötigst Du die IDE nicht zur Laufzeit bzw. zum Debuggen o.ä.
Du willst nur vereinfachen, das Script für das Gerät zu erstellen - richtig?

Ich sehe zwei Möglichkeiten:

1)
Du könntest ein TGraphicControl (oder TPanel) nehmen und Paint überschreiben.
Drag&Drop sollte so kein Problem sein. Auch ein Resize könnte man regeln, wenn sich der Cursor rechts unten befindet.
MouseEnter usw. kannst Du dann ja problemlos abfragen.

Danke für deine Antwort.

Ja, das hast du so richtig verstanden. Die IDE ist nur ein Werkzeug um aus Grafik -> Skript zu erzeugen.

Die Idee mit dem Panel finde ich grundsätzlich nicht schlecht. Ist dann halt leider nicht genau so wie auf dem Display aber für den Anfang sicher genügend. Eine solche Software hatte ich bereits einmal vor einigen Jahren geschrieben....

Das Problem stellt sich dann halt bei den anderen Controls wie z.B. Checkboxen, Radiogroup etc.
Falls ich auf für diese die bestehenden VCL Controls verwenden würde, hätte ich nicht die notwendigen Freiheiten was die Eigenschaften angeht.

Daher würde mit ein TGraphicControl vermuttlich besser gefallen.
Dieses kann man mit Canvas und Paint zeichnen richtig? (War leider in den letzten jahren nicht mehr so aktiv mit Delphi... deshalb diese Fragen)

Wenn ich das richtig verstehe, würde ich mir eine Klasse "Button" erstellen, welche von TGraphicControl erbt. In dieser gäbe es dann einen Aufruf wie z.B. DrawButton.
Dieser Funktion würde ich dann x,y,height,width etc übergeben.

Ich habe bereits code für alle elemente welcher diese Pixelgenau zeichnen kann.
Dieser befindet sich in der Firmware des displays.

Eigentlich könnte ich ja einfach diesen nach Delphi portieren und dann damit pixelgenau meine Controls zeichnen. Halt einfach grösser, da ein Pixel auf dem PC doch sehr klein ist...

Würde mein vorgehen mit der neuen Klasse "Button" welche von TGraphicControl erbt so funktionieren?
Habe bisher noch keine eigenen Klassen in delphi geschrieben.

Danke euch!

**stahli**

Das Problem mit dem Verwenden des "Geräte-Projektes" unter "Windows" wird sein, dass Deine "Geräte-Controls" wohl nichts mit einem VCL-Control zu tun haben (würde ich mal voraus setzen).

Aber Deine Gerätesoftware muss ja dennoch erkennen, dass z.B. ein Button gedrückt wurde. Vielleicht kannst Du mal noch was sagen, wie Du dieses Gerät programmierst.

Wenn Du für die IDE etwas neues baust und TGraphicControls verwenden willst, dann würde ich für erste Tests abstrakter denken.
Wenn Du in Buttons, Labels, Checkboxen usw denkst, könnte das leicht zu gedanklichen Verwirrungen führen.
Ich würde einfach mal andenken, beliebige Objekte (Früchte, Autos und Zettel) zu verwalten und darzustellen und deren Eigenschaften zu verwalten.

Du brauchst ja in der IDE keinen wirklichen TButton sondern nur einen Platzhalter, dem bestimmte Eigenschaften zugewiesen werden.
Wenn Du einem Button eine "Ereignisbehandlung" zuweist, ist das ja auch nur irgendein blöder Text, mit dem die IDE letztlich nichts anfangen kann.

**hedie**

Zitat von stahli:

Das Problem mit dem Verwenden des "Geräte-Projektes" unter "Windows" wird sein, dass Deine "Geräte-Controls" wohl nichts mit einem VCL-Control zu tun haben (würde ich mal voraus setzen).

Aber Deine Gerätesoftware muss ja dennoch erkennen, dass z.B. ein Button gedrückt wurde. Vielleicht kannst Du mal noch was sagen, wie Du dieses Gerät programmierst.

Wenn Du für die IDE etwas neues baust und TGraphicControls verwenden willst, dann würde ich für erste Tests abstrakter denken.
Wenn Du in Buttons, Labels, Checkboxen usw denkst, könnte das leicht zu gedanklichen Verwirrungen führen.
Ich würde einfach mal andenken, beliebige Objekte (Früchte, Autos und Zettel) zu verwalten und darzustellen und deren Eigenschaften zu verwalten.

Du brauchst ja in der IDE keinen wirklichen TButton sondern nur einen Platzhalter, dem bestimmte Eigenschaften zugewiesen werden.
Wenn Du einem Button eine "Ereignisbehandlung" zuweist, ist das ja auch nur irgendein blöder Text, mit dem die IDE letztlich nichts anfangen kann.

Du hast recht, grundsätzlich soll in der IDE ein Platzhalter angezeigt werden, welcher die grösse des objekts auf dem Display hat. Theoretisch würde dazu ein TShape genügen. Dieses könnte dann halt einfach nicht die entsprechenden Farben darstellen. Diese müsste mann dann über den Objektinspektor ändern. Für den Anfang jedoch ausreichend.

Nun etwas zur Gerätesoftware und Hardware:

Es befindet sich ein STM32 Cortex M3 (32Bit Mikrocontroller) auf dem Board.
Dieser steuert den Displaycontroller direkt an. Damit kann er jedes einzelne Pixel setzen.
Meine Firmware ist in C geschrieben. das sogenannte uGUI (mikroGUI) kennt verschiedene Controls.
Unter anderem einen Button.

Wenn nun ein Button erstellt wird, so werden zwei Strukte erstellt.
Das eine beinhaltet die x0,y0,x1,y1 sowie einen pointer zum eigenschaften strukt sowie einen pointer zur "onClick" funktion.

Wenn nun jemand auf den Button drückt, so wird ein Intterupt im Controller ausgelöst.
Sobald dieser eingetroffen ist, wird die x,y position des Touchscreens ausgelesen.

Nun geht das programm in einer schleife alle strukte mit den koordinaten durch und prüft ob sich
die touch koordinaten x,y, innerhalb eines objekts befinden.

Wenn dies der fall ist, wird die darin definierte "onClick" funktion aufgerufen.

Bisher wird die erzeugung des GUIs "hardkodiert". Daher die funktionien CreateButton etc.
werden direkt im Programmcode aufgerufen, compiliert, und in den Controller geladen.
Änderungen sind dann nicht mehr möglich.

Mein ziel ist es, auf der Hardware, also im Controller, einen Python interpreter laufen zu lassen.
Damit könnte mann dann später buttons dynamisch mittels skript erzeugen lassen.
Steht dann im Python skript CreateButton... dann wid intern in der Firmware einfach ebenfalls CreateButton mit den entsprechenden Parametern aus dem Python skript aufgerufen.

Damit die erzeugung eines GUIs für den Endanwender so bequem wie möglich wird, möchte ich nun einen grafischen editor für das GUI erstellen.
Beim Platzieren eines Buttons bzw. eines Platzhalters dafür

soll im hintergrund bzw, im Codefenster
sogleich der dazugehörige Pythoncode erstellt werden.

Dieses Pythonskript wird dann später auf einer SD-Karte abgelegt und vom Controller ausgelesen.

**himitsu**

Man könnte auch die normalen Windows/Delphi-Controls benutzen.

Man kann die "unsichtbare" Form ja regelmäßig auf ein Bitmap zeichnen und Dieses zum Display übertragen.
Befehle vom Display kann man über Messages an das Form zurückgeben.

**hedie**

Zitat von himitsu:

Man könnte auch die normalen Windows/Delphi-Controls benutzen.

Man kann die "unsichtbare" Form ja regelmäßig auf ein Bitmap zeichnen und Dieses zum Display übertragen.
Befehle vom Display kann man über Messages an das Form zurückgeben.

Danke für deinen Input.
Eventuell ist dies ein wenig untergegangen... Das Display stellt eine eigenständige Einheit dar.
Dieses wird unabhängig vom Computer verwendet.

Die "IDE" soll nur dazu dienen, dem Anwender das Skripten zu erleichtern.