Hallo Freunde,

ich versuche mich gerade an der Ersteullung einer Klassenbiblithek. Nun habe ich weil es einfacher war schon mal das Programm mit der Funktionalität geschrieben. Nun habe ich aber leider ein Problem beim abstraktieren der Methoden und bei der Erstellung der Klassen. Mein Prog malt in mehreren Images welche übereinander liegen (Ebenen), diese Images liegen auf einem Panel (danach richtet sich die Grösse der Images), welches sich widerum grössenmässig an ein Panel anpasst welches die Grösse der Form annimmt.

Wie kann ich das in mehrere Klassen aufteilen und welche Klasse muss von welcher was erben?

Ich möchte das so hinbekommen das die Ausgabe, sprich Darstellung, von der Verwaltung getrennt ist.

Kann mir da jemand helfen, oder zumindest einen Denkanstoss geben?

Danke schon mal im voraus.

Quivadis
[Edit1] Oder anders und leichter gefragt wie macht man aus einem Programm eine Unit?

Moderiert von Christian S.: Topic aus VCL (Visual Component Library) verschoben am Di 21.06.2005 um 11:59

Oder: Anders gefragt wie baut man ein gesamtes Programm in einer Unit nach? Es muss alles dynamich erzeugt werden. Wie übergabe ich aber die grösse der Form, es existiert ja zu dieeem zietpunkt ja noch gar nicht?

Hoffe ihr könnt mir jetzt irgnewelche Tipps geben.

Quivadis hat folgendes geschrieben:

Oder: Anders gefragt wie baut man ein gesamtes Programm in einer Unit nach?

Am besten garnicht.
Große Programme, sollte man grundsätzlich in mehrere Units aufteilen.. am besten nach ihrer Funktionalität getrennt.

Um einem Formular die Werte zu übergeben, muß eine Instanz erzeugt werden.
Ob du in dieser Zeit das Formular anzeigst oder nicht, ist ja nicht wichtig.

Einfachste Variante:
Erzeuge dein Formular und mach es unsichtbar.

Dein Fenster ist doch bereits eine Unit oder hast du etwa alles in der dpr geschrieben?

Aber das was du wissen willst kann dir niemand genau sagen. Je nach dem eigenen Geschmack kann das auch vollkommen voneinander abweichen. Für so etwas gibt es keine allgemeinen Regeln oder Aussagen. Außerdem kommt es sehr stark darauf an wie erweiterbar und wie viele Funktionalitäten du vorgesehen hast. Du kannst dir aber überlegen welche logischen kleinen Bausteine du aus der Anwendung machen kannst. Und dementsprechend würde ich das dann aufteilen. Nach Mögichkeit solltest du Querverbingen untereinder so gering wie möglich halten. Also es nützt selten etwas, wenn du einzellne Klassen machst die aber wiederum nur als großes ganzes brauchbar sind. Außer du möchtest lediglich die Funktionalität in logische Gruppen zusammenfassen.

Aber als erstes würde ich die Images außer acht lassen. Wenn dann würde ich mir ein TBitmap nehmen und darin malen. Erst wenn du deine Klassen komplett vom Fenster löst kannst du sie sinnvoll (abstrakt) auslagern. Dann würde ich zum Beispiel eine Möglichkeit einbauen die vom Fenster aufgerufen werden muss um die Größe zu setzen. Diese Methode wiederrum setzt dann die Größe bei den Unterklassen (TBitmaps oder Kappselungen davon). Genau das gleich mit dem Zeichenen des Bildes. Also das rufst du auf und übergibst ein TCanvas. Die Klasse wiederum malt sich dann auf das Canvas.

Das sind aber nur Anregungen. Wie es genau werden soll kannst nur du wissen, da nur du wissen kannst welche Funktionatäten bereits existieren oder noch hinzukommen können. Außerdem würde ich mir überlegen ob es überhaupt Sinn macht das aufzuteilen. Also wenn deine Anwendung so funktioniert und nichts weiter hinzukommen soll, dann musst du es ja nichtbedingt alles umschmeißen, oder?

Danke für eure Antworten.

Das Problem ist das mein jetziges Programm als Biblithek für ein anderes dienen soll.
Sprich, ich habe einen Aufruf der was an mein programm übergibt, und dann macht sich mein noch Programm an die Arbeit. Aber es ist jetzt Teil des anderen Programmes und muss die grösse des Fensters von diesen bekommen.

Ich habe ja schon alles in funktionen und Proceduren, so klein wie nötig zerlegt, nur der Fremdaufruf funktioniert nicht. Das Problem ist wie gesagt, ist ja jetzt noch ein Programm mit 2 Formularen. Mein Problem ist nun wie kann ich die dynamisch, also zur Laufzeit, sprich wenn Aufruf von dem anderen Programm kommt erzeugen?

Mein erster Gedanke war das ganze als Komponennte verpacken. Das habe ich auch noch nicht gemacht.


Würde das mit einem Frame gehen auf welchen ich jetzt mein ganzes Prog draufpacke? In das andere Prog müsste dann ja nur noch der Frame eingefügt werden?

Es darf kein Prog zum selbst starten sein. Es muss sich in das andere Prog intigrieren.

mal weiter Hilfe lesen und überlegen

Habe es jetzt mal mit Frame probiert. Dabei habe ich festgestellt das Frame warscheinlich dann ja im selben projekt sein muss. Ging also auch nicht.

Wenn noch jemand eine Idee hat immer raus damit. Ich brauche das dringend, will nicht alles neu proggen müssen.

so weiter am probieren bin. Halte euch auf den laufenden.

hi,

wenn du dein programm modularisieren willst, solltest du mal über packages (.bpl) nachdenken...

viele grüße
alex

Wie macht man aus einer Anwendung ein packages?

wie gesagt muss als Bibliothek für ein anderes Programm dienen. Wie das mit den Units in Delphi geht weiss ich. mein Problem ist das ich ja Forms mit drinnen habe, die ich entweder laden muss, oder später erzeugen.

naja mal sehen, hoffe finde eine Lösung