Allgemeine Frage zu Dialogen (EC++)

[Wu-mc]

Hallo Forum,

ich habe jetzt mehrere kleine Konsolenprogramme geschrieben und möchte mich nun an grafische Oberflächen versuchen. Und zwar hab ich da ein Projekt bekommen einen Pocket PC zu programmieren (Windows CE).

1. Grundlegende Frage, mit was fang ich an?
Also ich habe das bis jetzt mit Dialogen versucht, jedoch gehen die ja nicht mehr zu wenn man weiter klickt und damit den nächsten Dialog öffnet. So muss man hinterher wieder eine ganze Reihe an Fenstern schließen was ziemlich nervig ist. So eine Art Wizzard wäre mir da lieber, sollte aber für den Anfang nicht zu aufwendig sein. Was denkt ihr? Dialoge mit denen ich jetzt schon einigermaßen zurecht komme oder gibt es was schöneres / besseres?

2. Schreiben und Lesen von Dateien?
Ich muss in mehreren Fenstern (also bis jetzt Dialoge, siehe oben) auf die Daten einer Datei zugreifen und pro Fenster sammeln sich auch Daten an die hinterher in eine Datei abgelegt werden sollen. Nun möchte ich am liebsten eine Klasse schreiben die am Anfang die komplette Datei einliest und in Arrays speichert. Diese Felder sollen dann von jedem Fenster abrufbar sein. Will ein Programm eine Benutzereingabe abspeichern tut es das ebenfalls in Felder und bevor das Programm komplett geschlossen wird werden diese Felder dann wieder in eine Datei geschreiben.
So, das Auslesen und Schreiben von Dateien ist jetzt nicht mein Problem, sonder wie greife ich von mehreren Dialogen/Fenster/oder was auch immer auf die gleiche Klasse zu?

Vielen Dank für eure Antworten!

Mit freundlichen Grüßen

Niko Will

 

[jokey2]

Du solltest eine SDI (Single document Interface)-Anwendung schreiben. Dann hast du ein Dokument für die Datenhaltung (lesen der Datei, sichern der gemachten Einstellungen) und kannst mehrere Views (Ansichten) auf die Daten des Dokumentes. Mache Dich mit den Grundlagen des Document/View - Konzeptes vertraut, ist garnicht so schwer.

 

[Byteblaster]

Zu 1.) Was verstehst du unter "die gehen nicht mehr zu wenn man weiterdrückt?" Das (die) gestarte Programm(e) bleibt (bleiben) offen? Oder du hast in dem Dialog einen Button in dem man zu dem nächsten Dialog kommt?
Im Code kann man einen Dialog mit der Funktion: EndDialog(HWND,BOOL);
beenden.
2.)Hast du deine Dialoge auch in einer netten Klasse verpackt? Wenn ja, übergibt der jeweiligen Instance deiner Dialogklasse den Pointer auf deine Datenklasse oder besser da C++ eine Referenz.

Gruß Byteblaster

 

[Wu-mc]

Vielen Dank für eure Antworten.

1. SDI scheint mir zu schwierig zu sein für diese doch einfache Aufgabe die mir gestellt wurde.

2. Oh, sollte eigentlich "geht nicht mehr zu wenn man weiter drückt" heißen.

3. Hm, in eine nette Klasse verpackt? Wie gesagt, kenn mich da nicht so aus. Ich habe halt einen "Startdialog" von dem ich dann weitere Dialoge aufrufe. Habe das bis jetzt mit DoModal() gelöst und weiß jetzt nicht wie ich da eine Instanz mitgeben soll und wie ich dann von diesem neuen Dialog mittels Instanz auf die Basisklasse zugreifen soll.

Mit freundlichen Grüßen

Niko Will

 

[anmae]

hallo

zu deinem wizzard:
entweder du machst eine Klasse die in einer schleife alle Dialoge durchgeht. Im Dialog beendest schließt du diesen beim button weiter mit einem Rückgabewert (z.b. 1) und in deiner hauptschleife öffnest du dann bei 1 den nächsten Dialog. Kannst du mit nem Array of Pointers machen

oder du machst einen dialog in welchen du in einem Bereich einen child Dialog einbettest den du dann je nach knopfdruck wechselst.

grüße

 

[Wu-mc]

ja dahingehend hab ich gestern schon erste Versuche gemacht, also das mit Rückgabewert und dann das Hauptprogramm den nächsten Dialog öffnen lassen. Ich denke das ist bei meinem jetztigen Wissensstand das Beste. Den unter Zeitdruck erst noch in SDI einlesen ist etwas zu heftig. Ist vielleicht so nicht die schönste Lösung, aber für die benötigte Anwendung wirds reichen.

So kann ich dann auch die Daten die aus Dateien gelesen und in Dateien geschrieben werden sollen, alle vom Hauptprogramm aus schreiben. Oder?

Grüße

Niko Will

 

[anmae]

du kannst den Konstruktor deiner Klasse überschreiben , z.b. so:

CMeinDialog::CMeinDialog(meinPointer* x){
m_x = x;
}

und übergibst bei der Erstellung deines Dialogs einen pointer auf deine Struktur. Alles was du dann in dem Dialog an m_x Änderst ist gleichzeitig auch in deinem Hauptprogramm geändert (da Pointer).

ich weiß nun nicht so recht wie du deine Daten abspeicherst. Wenn es mehrere Arrays sind machst du am besten eine neue Klasse um deine Daten darin zu speichern. dann kannst du mit einem Pointer auf diese arbeiten.

Edit:
Du könntest auch den pParent* auf die Elternklasse casten und somit vom Dialog auf deine Parent Klasse zugreifen.

 

[Wu-mc]

Vielen Dank anmae,

ich denke ich werde es mal mit der extra Klasse versuchen da es mehrere Arrays sind. Also so wie du es erklärt hast würde ich es folgendermaßen machen. Zuerst eine neue Klasse, mit Konstruktor und Destruktor. Im Konstruktor werden die Dateien eingelesen und in die Arrays geschrieben. Im Destruktor werden die aktualiserten Daten dann wieder in die Dateien geschrieben.

Im Hauptprogramm erstelle ich mit new eine neue Instanz und übergebe diese jedes mal mit an einen neuen Dialog, dann kann dieser mit der Instanz auf meine Daten zugreifen, richtig? Wie kann man dann darauf zugreifen? Muss ich da Schnittstellenfunktionen in meiner Dienstleistungsklasse definieren oder kann ich auf die Arrays direkt zugreifen? Oder nur pro Array eine Funktion schreiben die mir die Referenz des jeweiligen Arrays übergibt, dann kann ich damit drauf zugreifen, oder?

Grüße

 

[anmae]

Genau so hab ich mir das gedacht

wie du deine Klasse nun aufbaust ist deine Sache. Der Destruktor wird erst aufgerufen wenn du die Klasse mit delete() löscht - für das zurückschreiben würd ich also lieber eine Methode nehmen.
Du kannst im Grunde genommen auf alle public Variablen und methoden der Klasse zugreifen. Ob du nun die arrays als public deklarierst und direkt drauf zugreifst oder dir methoden baust is im Grunde Wurscht, wobei ich Methoden bevorzugen würde, da weniger fehleranfällig.

 

[Wu-mc]

Ach ja richtig, das kenn ich noch aus Java. Da haben wir auch gelernt das es mit Methoden besser ist obwohl man auch direkt drauf zugreifen kann.

Mal noch ne andere Frage, wäre es möglich den CDialog::EndDialog ( ) zu überladen, also eine zusätzliche Definition machen die mehr als nur den einen Parameter zurück gibt. Dann könnt ich ja auch so meine Arrays transferieren. Ist zwar bestimmt keine schöne Lösung (oder?) deshalb werde ich es schon mit der Dienstleistungsklasse und der Instanz davon machen, aber so interesse halber würde mich das jetzt schon interessieren.

Vielen Dank für deine Antworten!

Grüße