ogl XML-basierte GUI

[DocJunioR]

Also ich mach mir gerade Gedanken über eine GUI.

Nun bin ich von Hause aus faul und überlege deshalb, wie ich möglichst einfach GUIs generieren kann.
Die meisten Menüs sind ja nicht sooo aufwendig, oder?

Also meine Idee..
XML- denn ne einfache XML-Klasse hab ich eh schon gebaut und nutze sie als Grundlage für fast alle Dateien die ich erstelle.

class cWindow {
  XMLNode *windowdata;
  ...
  public:
   cWindow (const char *filename);

}

Nun überlege ich allerdings, wie die Architektur hierfür sein müsste.
Der Einfacheit halber möchte ich die Programmlogiken nicht auch noch gesondert laden (dann müsst ich ja nen Interpreter bauen und in der Wikipedia ist das Interpreter Pattern immernoch nicht drin..)

Welche Widgets bräuchte ich minimal?

Wie müsste ein effektives Messagesystem zwischen den einzelnen Modulen aussehen? Wie krieg ich das hin ohne den Rechner auszubremsen? Wie häng ich das Ganze an die Windows Messages? (bzw. die SDL)

Ich stelle mir das Ganze ähnlich wie HTML-Formulare vor. Die aufrufende Funktion wartet bis das Formular durch Drücken eines Links abgeschickt wurde.
Texteingabe, Schieberegler, etc. könnte die Windowklasse regeln.

Ist das ganze lösbar ohne Multithreading? Wenn nein, wie realisiere ich dieses am effektivsten?

Wie löse ich überlappende Fenster am einfachsten auf?

Ihr seht, Fragen über Fragen. Will ja wenn, dann was vernünftiges bauen.

[User--]

Gibts schon längst: www.cegui.org

[DocJunioR]

wenn der link jetzt auch nur ansatzweise funktionieren würde..
Will es aber selbst machen und in mein Framework einpassen..

[User--]

Hab das uk vergessen, korrigiert: www.cegui.org.uk

[personenkult]

Super Antwort. Wenn jemand ein Pong programmieren will, sagste ihm dann auch, dass es das schon gibt?

[Vertexwahn]

guck dir mal die Nature Scene von Nvidia an - die hat ein schönes GUI
http://developer.nvidia.com/object/nature_scene.html

es beruht im wesentlichen auf dem Observer Pattern
vereinfachtes Beispiel des Observer Patterns:

#include <iostream>
#include <vector>
using namespace std;

// Vorwärtsdeklaration: Jede Klasse, die beobachtet werden kann muss von dieser Klasse erben
class Observable;

// Jeder Beobachter muss dieses Inteface implementieren
class Observer
{
public:
	// diese Methode wird aufgerufen, wenn das 
	// Beobachtete Objekt etwas zu Melden hat
	virtual void update(Observable * obs) = 0;
};

// Jede Klasse die man beobachten können soll erbt 
// von dieser Basisklasse
class Observable
{
public:
	// Liste aller Beobachter
	vector<Observer*> m_ObserverList;
public:
	// fügt neuen Beobachter zu diesem Objekt hinzu
	void addObserver(Observer *pObserver)
	{
		m_ObserverList.push_back(pObserver);
	}
	// Informiert alle Beobachter wenn sich etwas getann hat
	void notifyObservers()
	{
		for(vector<Observer*>::size_type i = 0;
                    i < m_ObserverList.size();
                    i++)
                      m_ObserverList[i]->update(this);
	}
};

/// Beispiel

/// Getreide Lager... woher kommt nur das Getreide?
class GetreideLager : public Observable
{
private:
	int m_getreide;
public:
	GetreideLager()
	{
		m_getreide = 0;
	}
	void changeGetreidestatus(int getreide)
	{
		cout<<"getreide änderung"<<endl;
		m_getreide = getreide;
		notifyObservers();	
	}
	int getGetreideStatus()
	{
		return m_getreide;
	}
	void setGetreideStatus(int getreide)
	{
		m_getreide = getreide;
	}
};

/// immer wenn genug Getreide vorhanden ist macht Backt der Bäcker Kuchen
class Bäcker : public Observer, public Observable
{
private:
	int Kuchen;
public:
	Bäcker()
	{
		Kuchen = 0;
	}
	void update(Observable * obs)
	{
		GetreideLager* lager = static_cast<GetreideLager*>(obs);
		if((lager->getGetreideStatus() > 200))
		{
			lager->setGetreideStatus(lager->getGetreideStatus()-200);
		}
		backeKuchen();
	}		
	void backeKuchen()
	{
		cout<<"Kuchen backen"<<endl;
		Kuchen++;
		notifyObservers();
	}
	void setKuchenAnzahl(int kuchen)
	{
		Kuchen = kuchen;
	}
	int getKuchenAnzahl()
	{
		return Kuchen;
	}
};

class HungrigerStudent : public Observer
{
public:
	void update(Observable * obs)
	{
		cout<<"update esser"<<endl;
		Bäcker* bäcker = static_cast<Bäcker*>(obs);
		if(bäcker->getKuchenAnzahl() > 0)
		{
			bäcker->setKuchenAnzahl(bäcker->getKuchenAnzahl() - 1);
			cout<<"mmmh lecker kuchen"<<endl;
		}
	}
};

int main()
{
	GetreideLager 		Lager;
	Bäcker				Bachmeier;
	HungrigerStudent     Esser;
	Lager.addObserver(&Bachmeier);
	Bachmeier.addObserver(&Esser);

	Lager.changeGetreidestatus(300);

	cin.get();
}

ich hab basierend auf den Code auch ein GUI Framework für Win32 gebastelt:
http://turing.fh-landshut.de/~jamann/IMB/IMB.html

[User--]

personenkult schrieb:

Super Antwort. Wenn jemand ein Pong programmieren will, sagste ihm dann auch, dass es das schon gibt?

Wenn es OpenSource ist? Warum nicht?

[Tc++H]

Ich beschäftige mich im Moment mit ähnlichen Fragen, gucke dir mal ein Builder bzw. Factory pattern an.

besorge dir malo von http://www.planetpdf.com/developer/article.asp?ContentID=6634
das Buch: Thinking in C++ Vol., falls du es noch nicht hast, alles prima beschrieben, auch wie man Frameworks mit Patterns developt.