Zugriff auf ViewVariablen über Dialogklasse

Tjorben

Ich habe folgendes Problem:
Über LeftButtonDown erscheint ein Dialog der über Radiobuttons bestimmte Eigenschaften abfragt und diese in Dialogvariablen speichert. Diese Eigenschaften benötige ich jetzt aber in der Ansichtsklasse.
Ich müsste also in der Dialogklasse auf die Viewklasse zugreifen können um die Eigenschaften dort gleich zu speichern.
Wie bekomm ich das denn hin?
Wäre super wenn mir jemand schnell weiterhelfen könnte!

Gruß Tjorben

Nanuq

Vorweg: korrigiert mich bitte, wenn ich Blödsinn erzähle...

Du könntest deiner Dialogklasse eine Membervariable vom Typ CView* spendieren, die du im Konstruktor des Dialogs mit deinem View initialisierst. Über diesen Zeiger kannst du anschließend auf die Methoden deiner Ansicht zugreifen.

Tjorben

Müsste schon gehen, aber wie initialisiere ich das genau? Woher weiß ich denn wie mein Objekt der ViewKlasse genau heißt?

Nanuq

Deiner Dialogklasse fügst du eine Membervariable hinzu und den Konstruktor erweiterst du um einen entsprechenden Parameter:

// MyDialog.h
class CMyDialog : public CDialog
{
private:
    CMyAppView* m_pView;  // Membervariable vom Typ Zeiger auf Ansichtsklasse
    // ...
public:
    CMyDialog(CMyAppView* pView); // Konstruktor mit Parameter vom Typ Zeiger auf Ansichtsklasse
    //...
}

Die Implemetierung des Konstruktors also ungefähr so:

// MyDialog.cpp
CMyDialog::CMyDialog(CMyAppView* pView)
    : m_pView(pView) // Initialisierung der Membervariable
{
    //...
}

Irgendwo anders konstruierst du dir dann dein Dialogobjekt, z.B.:

CMyDialog Dialog(/*Zeiger auf Ansicht übergeben*/)
if(IDOK == Dialog.DoModal())
{
    //...
}

Wie du dir hier einen Zeiger auf die Ansicht besorgst hängt davon ab, von wo aus der Aufruf des Konstruktors erfolgt.

Und innerhalb deiner Dialogklasse kannst du über den Zeiger auf die Methoden deiner Ansichtsklasse zugreifen:

// CMyDialog.cpp
m_pView->DoSomething();

Tjorben

public:
CMyDialog(CMyAppView* pView); oder bei mir

CLinienDialog(CSemArbView* pView);

führt bei mir zu folgenden Fehlermeldungen:

Syntaxfehler: Es fehlt ')' vor ''
Syntaxfehler: Es fehlt ';' vor ''
'CLinienDialog::CSemArbView': Verwendet gerade definiertes 'CLinienDialog'
'CLinienDialog::pView': Fehlende Speicherklasse oder Typspezifizierer
'CLinienDialog::CSemArbView': Fehlende Speicherklasse oder Typspezifizierer
'CLinienDialog::m_pView': Fehlende Speicherklasse oder Typspezifizierer

Diese Fehlermeldungen wiederholen sich dann ein paar mal

Weiß jemand was da nicht funktioniert?

Die Implemetierung des Konstruktors also ungefähr so:
C/C++ Code:
// MyDialog.cpp
CMyDialog::CMyDialog(CMyAppView* pView)
: m_pView(pView) // Initialisierung der Membervariable
{
//...
}
C/C++ Code:
// MyDialog.cpp
CMyDialog::CMyDialog(CMyAppView* pView)
: m_pView(pView) // Initialisierung der Membervariable
{
//...
}
C/C++ Code:
// MyDialog.cpp
CMyDialog::CMyDialog(CMyAppView* pView)
: m_pView(pView) // Initialisierung der Membervariable
{
//...
}

Irgendwo anders konstruierst du dir dann dein Dialogobjekt, z.B.:
C/C++ Code:
CMyDialog Dialog(/*Zeiger auf Ansicht übergeben*/)
if(IDOK == Dialog.DoModal())
{
//...
}
C/C++ Code:
CMyDialog Dialog(/*Zeiger auf Ansicht übergeben*/)
if(IDOK == Dialog.DoModal())
{
//...
}
C/C++ Code:
CMyDialog Dialog(/*Zeiger auf Ansicht übergeben*/)
if(IDOK == Dialog.DoModal())
{
//...
}
Wie du dir hier einen Zeiger auf die Ansicht besorgst hängt davon ab, von wo aus der Aufruf des Konstruktors erfolgt.

Und innerhalb deiner Dialogklasse kannst du über den Zeiger auf die Methoden deiner Ansichtsklasse zugreifen:
C/C++ Code:
// CMyDialog.cpp
m_pView->DoSomething();
C/C++ Code:
// CMyDialog.cpp
m_pView->DoSomething();
C/C++ Code:
// CMyDialog.cpp
m_pView->DoSomething();

EXDW

Ich würde es anders lösen, ich finde es eleganter wenn die Dialog klasse Settings bekommt und ausgibt.

In der Funktion in der View klasse ist ja bereits eine Instanz enthalten, dann halt:

class CSettingsContainer
{
public:
    int m_a, m_b, m_c;
    CString m_strText;
    CSettingsContainer(int a, int b, int c, CString strText)
    : m_a(a), m_b(b), m_c(c), m_strText(strText)
    {}
};
//.
/*...*/
//.
void CChildView::Func()
{
    CSettings settings;
    settings.SetPropertys(CSettingsContainer(1, 2, 3, _T("Text")));
    settings.DoModal();
    CSettingsContainer NewSettings = settings.GetPropertys();
    /*...*/
}

Den Vorteil den ich da sehe ist, du kannst diese Settings klasse von jeder anderen klasse heraus aufrufen ohne dich um Pointer kümmern zu müssen, du brauchst keine werte Überprüfen ob sie gültig sind, das kannst du in dem Container erledigen,
der Container kann auch nötige Konvertierungen durchführen.
Einfach diesen Container in den selben Header wie die Settings klasse deklarieren und definieren, dann kannst du das wunderbar als Schnittstelle verwenden.
Es bietet sich auch an einzelne Getter und Setter hinzuzufügen für einzelne werte, das kannst du halten wie du willst.