Wie am elegantesten eine eigene IDE "basteln"

[Sir Rufo]

Also ich seh hier gar nichts

[hedie]

Danke ^^ habe ich glatt vergessen

[mkinzler]

Das ist ja weniger eine IDE, sondern eher ein Malprogramm

[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!