Ein Steuerelement könnte ja theoretisch von der Fensterklasse einige Funktionen erben??
Und wie kann ich es bewältigen das jede WindowFrame Instanz eine eigene WndProc bekommt, sodass ich für jedes "Hauptfenster" die Nachrichten verarbeiten kann?

Die Fensterprozedur kann ruhig immer dieselbe sein, sie ruft dann den Code einer pure virtual Class auf, von der alle anderen Fensterklassen abgeleitet sind. Dann ist es Kaese-einfach.

/*
* Description: creates a CALLBACK-thunk.
* For more information see readme.txt
*/

#include <windows.h>
#include "CWndUnknown.h"

void CWndProcThunk::Init(WNDPROC WndProc, void* pThis)
{
	thunk.m_mov		= 0x042444C7;  //C7 44 24 04
	thunk.m_this	= (DWORD)pThis;
	thunk.m_jmp		= 0xe9;
	thunk.m_relproc	= *((int*)&WndProc) - ((int)this + 
						sizeof(_WndProcThunk));

	FlushInstructionCache(GetCurrentProcess(), 
            &thunk, sizeof(thunk));
}

CWndUnknown::CWndUnknown()
{
	m_hwnd	= 0;
}

LRESULT CWndUnknown::ProcessWindowMessage(HWND hwnd, UINT message,
									WPARAM wParam, LPARAM lParam)
{
	return false;
}

LRESULT CALLBACK CWndUnknown::StartWindowProc(HWND hwnd, UINT message,
										WPARAM wParam, LPARAM lParam)
{
	if(message == WM_CREATE)
	{
		CWndUnknown *pThis = (CWndUnknown*)((LPCREATESTRUCT)lParam)->lpCreateParams;
		pThis->m_hwnd = hwnd;
		pThis->m_thunk.Init(WindowProc, pThis);
		WNDPROC pProc = (WNDPROC)&(pThis->m_thunk.thunk);
		SetWindowLong(hwnd, GWL_WNDPROC, (LONG)pProc);
		return pProc(hwnd, message, wParam, lParam);
	}

	return DefWindowProc(hwnd, message, wParam, lParam);
}

LRESULT CALLBACK CWndUnknown::WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	CWndUnknown *pThis = (CWndUnknown*)hwnd;
	return pThis->ProcessWindowMessage(pThis->m_hwnd, message, wParam, lParam);
}

void* CWndUnknown::GetUnknownClassPtr()
{
	return this;
}

WNDPROC CWndUnknown::GetStartWndProc()
{
	return (WNDPROC)&StartWindowProc;
}

CWndUnknown.h:

#ifndef _CWNDUNKNOWN_H_
#define _CWNDUNKNOWN_H_

#pragma pack(push,1)
struct _WndProcThunk
{
	DWORD   m_mov;          // mov dword ptr [esp+0x4], pThis (esp+0x4 is hWnd)
	DWORD   m_this;
	BYTE    m_jmp;          // jmp WndProc
	DWORD   m_relproc;      // relative jmp
};
#pragma pack(pop)

class CWndProcThunk
{
public:
	_WndProcThunk thunk;
	void Init(WNDPROC WndProc, void* pThis);
};

class CWndUnknown
{
public:
	CWndUnknown();
	void* GetUnknownClassPtr();
	static WNDPROC GetStartWndProc();

protected:
	HWND			m_hwnd;
	CWndProcThunk	m_thunk;

	virtual LRESULT ProcessWindowMessage(HWND, UINT, WPARAM, LPARAM);

	static LRESULT CALLBACK StartWindowProc(HWND, UINT, WPARAM, LPARAM);
	static LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);

};

#endif

einmaliges Initialisieren der Fensterklasse:

wc.cbSize		= sizeof(WNDCLASSEX);
	wc.cbClsExtra	= 0;
	wc.cbWndExtra	= 0;
	wc.hbrBackground= (HBRUSH)GetStockObject(BLACK_BRUSH);
	wc.hCursor		= LoadCursor(0, IDC_ARROW);
	wc.hIcon		= 0;
	wc.hIconSm		= 0;
	wc.hInstance	= hInstance;
	wc.lpfnWndProc	= CWndUnknown::GetStartWndProc();
	wc.lpszClassName= g_pszUnknownClass;
	wc.lpszMenuName	= 0;
	wc.style		= 0;
	if(!RegisterClassEx(&wc))
		return false;

(g_pszUnknownClass musst du irgendwo global definiern, eigentlich könnte man es auch als static in die klasse rein, aber kA)

willst jetzt ein fenster haben das in der Klasse CWndMain ist, sieht diese klasse so aus (ausschnitt):

#ifndef _CMAINWND_H_
#define _CMAINWND_H_

#include "CWndUnknown.h"

class CMainWnd : public CWndUnknown
{
public:
	CMainWnd();
	~CMainWnd();

private:
	HINSTANCE	m_hInstance;

	virtual LRESULT ProcessWindowMessage(HWND, UINT, WPARAM, LPARAM);
};

#endif

so erstellst du das fenster in der Klasse (CMainWnd::Create):

HWND CMainWnd::Create()
{
	m_hInstance = GetModuleHandle(0);
	CreateWindowEx(0, g_pszUnknownClass, "itel",
				WS_VISIBLE, 100, 100, 400, 600,
				0, 0, m_hInstance, GetUnknownClassPtr());
	return m_hwnd;
}

irgendwas schlummert in meinm kopf dass man m_hwnd nicht speichern darf und auch nicht klassmember sein darf, kA. s. CWndUnknown Klasse ^^.
jo das wars.

mfg

Was ich oben gesagt habe, reicht.

(Falls ich ein passendes Codebeispiel finde, poste ich es hier; EDIT: nix! war wohl doch in einer Firma gewesen, wo ich das programmiert habe, sorry! )

// Widget.h
class Widget {
public:
   Widget();
   virtual ~Widget();

   const HWND getHandle();

protected:
   static LRESULT CALLBACK WindowProc(HWND _Handle, UINT _Message, WPARAM _wParam, LPARAM _lParam);

   virtual LRESULT DefWindowProc(UINT _Message, WPARAM _wParam, LPARAM _lParam);

   HWND         Handle;
   WNDPROC      PrevWndProc;

private:

};

// Widget.cpp
#include "Widget.h"

// -----------------------------------------------------------------------------
Widget::Widget() : Handle(0), PrevWndProc(0), Text(""), Parent(0), 
                   BackgroundColor(0xFFFFFF), PaintBackground(true) {
}

Widget::~Widget() {
}
// -----------------------------------------------------------------------------
const HWND Widget::getHandle() {
   return reinterpret_cast<HWND>(this->Handle);
}
// -----------------------------------------------------------------------------
LRESULT Widget::DefWindowProc(UINT _Message, WPARAM _wParam, LPARAM _lParam) {

	// hier Message-Verarbeitung

	if (this->PrevWndProc) {
      return ::CallWindowProc(this->PrevWndProc, this->getHandle(), _Message, _wParam, _lParam);
	}

   return ::DefWindowProc(this->getHandle(), _Message, _wParam, _lParam);
}
// -----------------------------------------------------------------------------
// default windowproc for all objects based on this class
LRESULT CALLBACK Widget::WindowProc(HWND _Handle, UINT _Message, WPARAM _wParam, LPARAM _lParam) {

	if(_Message == WM_CREATE) { // übergebenen this merken
		::SetWindowLong(_Handle, GWL_USERDATA, (LONG)((CREATESTRUCT*)_lParam)->lpCreateParams);
	}

	Widget* pReceiver = reinterpret_cast<Widget*>(GetWindowLong(_Handle, GWL_USERDATA));

	if (!pReceiver) {
      return ::DefWindowProc(_Handle, _Message, _wParam, _lParam);
	}

	return pReceiver->DefWindowProc(_Message, _wParam, _lParam);
}
// -----------------------------------------------------------------------------

In einer weiteren Klasse (hier Window) kann man dann CreateWindow z.B. so aufrufen:

...
wc.lpfnWndProc   = Widget::WindowProc;
...
   this->Handle = ::CreateWindowEx(0,
                                   "Window",
                                   this->Text.c_str(),
                                   WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | (this->Parent ? WS_CHILD : 0),
                                   _x, _y, _Width, _Height,
                                   (this->Parent ? this->Parent->getHandle() : 0), 
                                   0, 0, this);

Wichtig dabei ist, dass der this-Zeiger übergeben wird und vorher die WndProc der Fensterklasse auf die static-WndProc von Widget gesetzt wird. Bei Buttons, etc. muss man die halt später mit SetWindowLong(Ptr) ändern, da diese ja bereits eine registierte Fensterklasse haben. Aber das war's dann auch schon.

Wenn es hierfür noch andere Möglichkeiten gibt, nur her damit.

Und wie kann ich es bewältigen das jede WindowFrame Instanz eine eigene WndProc bekommt, sodass ich für jedes "Hauptfenster" die Nachrichten verarbeiten kann?

Das beste Framework das ich jemals gehsen habe:
http://download.nvidia.com/developer/Third_Party/Nature/NatureScene.zip

bauste dir noch ne add Methode in die Window-Klasse und fertig

Window.add(new Label("Hallo Welt"));

wenn du willst kann ich mal den ganzen Grafikcode rausschmeißen und es so programmieren, das Window.add(new Label("Hallo Welt")); funktioniert

Ich wollte eine Anwendung mit Steuerelementen proggen, sodass ich einige OpenGL States Checken und ihre Eigenschaften lernen kann.