Idee gesucht : Umsetzung von dynam. Alarmen und Werteanzeige

[moelski]

Moin !

Ich grübel da gerade über einem Problem (ne nennen wir es Herausforderung ) und habe aber noch keine Idee wie ich es praktisch umsetzen könnte. Evtl. hat ja hier jemand eine zündende Idee. Ich versuchs mal (hoffentlich) verständlich zu beschreiben...

Also, nehmen wir mal an wir haben ein Formular mit einem TChart (mit 3 Serien) und z.B. eine Klasse die Daten umrechnet. Die fiktive Klasse könnte z.B. so aussehen:

Delphi-Quellcode:

TMyClass = class(TPersistent)
public
  { public-Deklarationen }
  Wert1,
  Wert2,
  Wert3 : Double;
  constructor Create();
  Procedure   CalcValues(Input : String);  // Wandelt den String um in 3 Double werte ... 
published
  { published-Deklarationen }
end;

Was ich nun erreichen will ist folgendes:
Immer wenn ich bei einer Serie einen Wert einfüge, oder wenn in TMyClass neue Werte berechnet wurden möchte ich diese Werte verwenden. Einmal für ein Alarming (also z.B. Überprüfung ala Wert > 100) und einmal um eine Analoganzeige mit dem Wert zu befeuern.
Nun könnte man sich das einfach machen und für die 6 Möglichen Werte hart verdrahteten Code bereit stellen. Aber ich möchte das ganze dynamisch realisieren.

Bedeutet ich möchte vom User eine Art Liste anlegen lassen. Dort kann er sagen nimm mal den (letzten) Wert von Serie 2 des TChart und mache damit ein Alarming. Und dann nimm noch den Wert 3 aus TMyClass und zeige den in der Analoganzeige (oder sagen wir einfach in einem Edit).

So das ganze wird natürlich noch komplizierter. Denn wir nutzen MDI Fenster und das bedeutet der User kann X Grafiken haben und ggf. auch X TMyClass Klassen.

Jetzt wäre meine Idee das man beim TChart z.B. das Series OnAfterAdd Event nutzt. Damit kriege ich generell mit wenn in der Grafik ein neuer Wert eingetragen wurde. Und bei der Klasse könnte man im CalcValues sicher auch die Werte bereitstellen.
Aber ich habe noch keinen Schimmer wie ich das dann mit der vom User erstellten Liste verknüpfen könnte.

Denn dann müsste ja bildlich gesprochen folgendes passieren:
Punkt in Serie eintragen und somit wird OnAfterAdd abgefeuert. Dort jetzt nachsehen ob für diese Serie ein Alarm oder eine Weitergabe des Werts an (z.B. ein Edit) vorgesehen ist. Tja und dann eben ggf. den Wert dem Alarming / der Werteanzeige zuführen.
Aber wie gesagt, mir fehlt da gerade ne zündende Idee wie ich das praktikabel und universell umsetzen könnte.

Jemand ne Idee ?

Ich hoffe ich habe es verständlich beschrieben

[Alaitoc]

Also ich bin mir nicht sicher ob das ich das richtig verstanden habe...

Jedoch hört sich das für mich nach nem Model-View-Controller an, also du hast da mehrere Speicherobjekte und für jedes der Speicherobjekte mehrere Grafiken. Falls sich irgendwo ein Speicherobjekt ändert muss dann auch an jeder Grafik, die an das Speicherobjekt gekoppelt ist, Änderungen durchgeführt werden.

Bsp:

1. Datenobjekt und Grafik werden am Controller angemeldet.
2. Über eine der Grafiken wird im Speicherobjekt ein Wert geändert.
3. Das Speicherobjekt teilt dies dem Controller mit.
4. Der Controller sagt jeder Grafik das sie sich aktualisieren soll.
5. Die Grafik greift auf ihr Speicherobjekt zu und holt sich die Änderungen.

MfG Alaitoc

Edit: Formatierung und Bezeichner bearbeitet

[moelski]

Moin Alaitoc,

ich glaube das ist noch nicht ganz was ich suche / vor habe. Aber es hat mich doch auf eine Idee gebracht.

Was ich definitiv brauche ist eine Art Bindeglied zwischen meinen Daten und meine Anzeige. Also nehmen wir mal ein weitaus einfacheres Beispiel. Einfach nur 2 Edits. Wenn ich in ein Edit einen String eintrage soll er nach Enter im anderen Edit erscheinen. Nichts anderes möchte ich mit meinen Werten erreichen. Wir haben z.B. einen neu eingetragenen Wert in einer Grafik Serie und dieser Wert soll z.B. in einem Gauge dargestellt werden.

Aber bleiben wir der Einfachheit bei den Edits.
So wenn ich nun eine Universelle Schnittstelle schaffen will und verallgemeinert sage ich möchte generell den String vom Objekt X in Objekt Y anzeigen, dann müssen sich beide Edits erstmal bei dem "Bindeglied" anmelden. Das Bindeglied hält also eine Tabelle wo die Beziehungen definiert werden. Eine Spalte bilden die Eingangsgrößen ab und eine die Ausgangsgrößen. Im Fall von Alarmen müsste man ggf. noch ein Überprüfungskriterium mitgeben - führt aber im Moment zu weit.

Jetzt muss der User aus dieser Ein-Ausgangsliste seine Beziehungen herstellen. Eingang Object X -> Anzeige Object Y.

Was ich jetzt noch brauche ist eine Notifikation wenn sich bei den Eingangsobjkten etwas geändert hat. Im Fall von einem Edit könnte man dafür z.B. OnKeyUp verwenden. Sobald ein chr(13) festgestellt wird löst man die Notifikaation an das Bindeglied aus. Hier müsste man vermutlich mitgeben welche Objekteigenschaft sich nun geändert hat. Im Falle des Edits wäre es .Text.

Jetzt muss das Bindeglied nur noch dafür sorgen das die Objekteigenschaft von X gelesen wird und in Objekt Y eingetragen wird.

Stellt sich die Frage wie ich die Eigenschaft FormX.EditY.Text übergeben kann und damit meine ich nicht den resultierenden String. Auch als Pointer wird das wohl nicht klappen, denn dann müsste ich ja wissen was ich für einen Wert ich über den Pointer lesen will, oder?

Ließe sich das ggf. über RTTI lösen? Hmm aber da es hier um die grundlegende Idee geht werde ich dazu mal einen neuen Fred auf machen.

[Alaitoc]

Das hört sich irgendwie immernoch nach einem MVC an.

Ich hab z.b. ein Editfeld und gebe dort etwas ein, dann soll in allen anderen Grafiken die sozusagen "daran hängen"
dieser Wert auf ihre Weise dargestellt werden.

Es gibt halt immer mehrere Datenobjekte und an jedem Datenobjekt können mehrere Grafiken hängen.
Die Datenobjekte und Grafiken werden an einer Stelle miteinander verknüpft und immer wenn etwas im Datenobjekt
geändert wird, ändern sich die Grafiken.

In der Praxis sieht das in etwa so aus:

1. Du erstellst ein Datenobjekt ( in deinem Fall TMyClass ) und fügst zusätzlich noch eine Notify-Methode,
wo der Handler angesprochen wird, hinzu. Sollte sich was an den Daten ändern, wird ein Notify an den Handler gesendet.
2. Du erstellst mehrere Typen von Grafiken ( Gauge, Kreisdiagramm, etc...), jeder davon hat eine Update-Methode
wo er über eine Referenz auf das Datenobjekt zugreifen kann und sich die Daten holen können und natürlich
auch Änderungen daran vornehmen kann.
3. Du erstellst den Handler, dieser hat eine Anmelden-Methode wo man immer sagt welches Datenobjekt und welche
Grafik miteinander verknüpft werden. Bei mehrfachen Verknüpfungen meldet man das Datenobjekt mit mehreren
Grafiken an. Dann bekommt der Handler noch eine Update-Methode, also falls ein Datenobjekt ein Notify
sendet, führt der Handler seine Update-Methode aus und aktualisiert alle Grafiken die am Datenobjekt hängen.

Fazit:

Das Datenobjekt kennt die Daten und meldet wenn Änderungen vorhanden sind.
Die Grafik weiß wo die Daten liegen und stellt sich selbst da. ( Man brauch also eigentlich nicht FormX.EditX.TextX. )
Der Handler macht die Grafiken auf Änderungen innerhalb des Datenobjekt aufmerksam.

Also brauchst du nicht mit Pointern etc rumzuhantieren

Datenobjekt = Model
Grafik = View
Handler = Controller

MfG Alaitoc

[guidok]

Wie Alaitoc geschrieben hat, solltest du schauen, dass deine GUI-Objekte (Edit) nichts mit der Datenhaltung zu tun haben. D.h. du erstellst die Datenobjekte, an die du GUI-Elemente anbinden kannst. Die Notifikation über Änderungen übernimmt das Datenobjekt, sobald es geändert wird. Evtl. kannst du auch mal nach dem "Observer-Muster" suchen.

[Alaitoc]

Genau das Observer-Pattern wäre auch noch eine Möglichkeit, sozusagen die abgespeckte Version vom Model-View-Controller.

Siehe hier: Observer-Pattern (Wikipedia)

Falls dir zumindest das MVC zusagt, hab ich da ne simple Struktur auf meinem Rechner. Wobei ich da dann noch einen Singleton für den Controller nutze.

MfG Alaitoc

[moelski]

Moin !

Ich habe hier mal meinen entwurf gepostet:
http://www.delphipraxis.net/internal...t.php?t=169477

Zitat:

dass deine GUI-Objekte (Edit) nichts mit der Datenhaltung zu tun haben

Im Grunde ist das auch richtig so. Im Moment habe ich das aber noch nicht so in meinem Entwurf umgesetzt.

Vielleicht könnt ihr ja mal einen Blick in den anderen Fred werfen und dort posten ob der Entwurf im Ansatz brauchbar wäre ...

[Alaitoc]

Wahrscheinlich könntest du es so im Ansatz machen, jedoch sollte man am besten
immer Daten von visuellen Komponenten trennen. Ich habe in dem gelinkten Thread
mal einen Basis Konzeptentwurf vom MVC gepostet, den du sicherlich nutzen könntest.

Sicherlich kannst du deinen Ansatz weiterhin verfolgen, ich jedoch würde hier bei mir
dafür einen auf den Deckel bekommen ^^