ich habe folgendes Problem:
In einer Anwendung habe ich eine CommonControl gesubclasset mit
SetWindowLong(GWL_WNDPROC), ...);
das funktioniert auch alles fein.

Jetzt habe ich das XP-Manifest dazugetan und schon geht es nicht mehr.
Das Programm stürzt einfach ab.

Kann das eventuell daran liegen, dass die Common Controls aus der comctl32.dll Unicode sind und meine Anwendung ANSI is?

thx im voraus

MfG DrakoXP

und habe das XP-Theme über das XP-Manifest eingebunden.
Aber das passt alles, wenn ich nichts subclasse funktioniert ja auch alles MIT XP!

bloß SubClassing UND XP vertragen sich bei mir i.w. net

Kann das eventuell daran liegen, dass die Common Controls aus der comctl32.dll Unicode sind und meine Anwendung ANSI is?...

Nö

Andere frage wie stürzt es ab.
1. Startet nicht
2. Error Message

und Was sagt der debugger

ist InitCommonControls(); geladen

das Programm meldet direkt, wenn man es startet:
"[Programmname] hat ein Problem festgestellt und muss beendet werden."

mir ist außerdem aufgefallen, dass dieses Problem nur in der Release-Version auftritt.
in der Debug-Version funktioniert es

und da der Fehler nur in der Release-Version auftritt, sagt der Debugger gar nix dazu

und hier der gewünschte Code...

main.cpp

// Windows Application Programming Interface
#include <windows.h>

// Windows Common Controls
#include <commctrl.h>

// C Standard Library
#include <cstdlib>

// C Time
#include <ctime>

// C Mathematics
#include <cmath>

// C Standard Input Output
#include <cstdio>

// Resource IDs
#include "resource.h"

// Controls
HWND g_hStaticCount = NULL;
HWND g_hEditCount = NULL;
HWND g_hButtonDrop = NULL;
HWND g_hRenderDrops = NULL;
HWND g_hStaticPI = NULL;
HWND g_hEditPI = NULL;
HWND g_hProgressPI = NULL;

// Handle des Threads
HANDLE hPIThread = INVALID_HANDLE_VALUE;

// Die Tropfen
int g_iNumDrops = 0;
LPPOINT g_pDrops = NULL;

// Button Subclassen
WNDPROC pOldButtonProc = NULL;
LRESULT CALLBACK SubButtonProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_KEYDOWN:
		{
			switch (wParam) {
			case VK_RETURN:
				{
					SendMessage(GetParent(hWnd), WM_COMMAND, IDC_DROP, 0);
				} break;
			case VK_TAB:
				{
					SetFocus(g_hEditCount);
				} break;
			default:
				return pOldButtonProc(hWnd, msg, wParam, lParam);
			}
			return 0;
		} break;
	}
	return pOldButtonProc(hWnd, msg, wParam, lParam);
}

// Edit Subclassen
WNDPROC pOldEditProc = NULL;
LRESULT CALLBACK SubEditProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_KEYDOWN:
		{
			switch (wParam) {
			case VK_RETURN:
				{
					SendMessage(GetParent(hWnd), WM_COMMAND, IDC_DROP, 0);
				} break;
			case VK_TAB:
				{
					SetFocus(g_hButtonDrop);
				} break;
			default:
				return pOldEditProc(hWnd, msg, wParam, lParam);
			}
			return 0;
		} break;
	}
	return pOldEditProc(hWnd, msg, wParam, lParam);
}

// PI berechnen!!!
DWORD WINAPI PIThread(LPVOID pParam) {
	InvalidateRect(g_hRenderDrops, NULL, TRUE);
	Sleep(100);
	HWND hWnd = (HWND)pParam;
	srand(time(NULL));
	ShowWindow(g_hProgressPI, SW_SHOW);
	SendMessage(g_hProgressPI, PBM_SETPOS, 0, 0);
	char szBuffer[1024];
	GetWindowText(g_hEditCount, szBuffer, 1024);
	g_iNumDrops = atoi(szBuffer);
	if (g_pDrops) {
		delete[] g_pDrops;
		g_pDrops = NULL;
	}
	g_pDrops = new POINT[g_iNumDrops];
	int iInCircle = 0, iComplete = 0;
	RECT r;
	GetClientRect(g_hRenderDrops, &r);
	int x0 = (r.right - r.left) / 2;
	int y0 = (r.bottom - r.top) / 2;
	HDC hDC = GetDC(g_hRenderDrops);
	for (int n = 0; n < g_iNumDrops; n++) {
		g_pDrops[n].x = (rand() % 301) - 151;
		g_pDrops[n].y = (rand() % 301) - 151;
		double way = sqrt(pow((double)(g_pDrops[n].x), 2) + pow((double)(g_pDrops[n].y), 2));
		if (way <= 150.0f) {
			HPEN hBluePen = (HPEN)CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
			HPEN hOldPen = (HPEN)SelectObject(hDC, hBluePen);
			HBRUSH hBlueBrush = (HBRUSH)CreateSolidBrush(RGB(0, 0, 255));
			HBRUSH hOldBrush = (HBRUSH)SelectObject(hDC, hBlueBrush);
			Ellipse(hDC, x0 + g_pDrops[n].x - 2, y0 - g_pDrops[n].y + 2, x0 + g_pDrops[n].x + 2, y0 - g_pDrops[n].y - 2);
			DeleteObject(hOldPen);
			DeleteObject(hOldBrush);
			iInCircle++;
		} else {
			HPEN hBlackPen = (HPEN)CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
			HPEN hOldPen = (HPEN)SelectObject(hDC, hBlackPen);
			HBRUSH hBlackBrush = (HBRUSH)CreateSolidBrush(RGB(0, 0, 0));
			HBRUSH hOldBrush = (HBRUSH)SelectObject(hDC, hBlackBrush);
			Ellipse(hDC, x0 + g_pDrops[n].x - 2, y0 - g_pDrops[n].y + 2, x0 + g_pDrops[n].x + 2, y0 - g_pDrops[n].y - 2);
			DeleteObject(hOldPen);
			DeleteObject(hOldBrush);
		}
		iComplete++;
		SendMessage(g_hProgressPI, PBM_SETPOS, (WPARAM)((100.0f / (double)g_iNumDrops) * (double)n), 0);
	}
	ReleaseDC(g_hRenderDrops, hDC);
	double pi = 4.0f * (double)iInCircle / (double)iComplete;
	sprintf(szBuffer, "%f", pi);
	SetWindowText(g_hEditPI, szBuffer);
	SendMessage(g_hProgressPI, PBM_SETPOS, 100, 0);
	ShowWindow(g_hProgressPI, SW_HIDE);
	return 0;
}

// Render Window Procedure
LRESULT CALLBACK RenderProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_PAINT: // Zeichnen
		{
			PAINTSTRUCT ps;
			HDC hDC = BeginPaint(hWnd, &ps); // Zeichnen - Anfang
			{
				RECT r;
				GetClientRect(hWnd, &r);
				int x0 = (r.right - r.left) / 2;
				int y0 = (r.bottom - r.top) / 2;
				HPEN hRectPen = CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
				HPEN hOldPen = (HPEN)SelectObject(hDC, hRectPen);
				// Das Quadrat zeichnen
				Rectangle(hDC, x0 - 150, y0 - 150, x0 + 150, y0 + 150);
				DeleteObject(hOldPen);
				HPEN hCirclePen = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
				hOldPen = (HPEN)SelectObject(hDC, hCirclePen);
				// Den Kreis zeichnen
				Ellipse(hDC, x0 - 150, y0 - 150, x0 + 150, y0 + 150);
				DeleteObject(hOldPen);
				// Die Tropfen zeichnen
				if (g_pDrops) {
					if (g_iNumDrops) {
						for (int n = 0; n < g_iNumDrops; n++) {
							if ((g_pDrops[n].x <= 150) && (g_pDrops[n].y <= 150) && (g_pDrops[n].x >= -150) && (g_pDrops[n].y >= -150)) {
								double way = sqrt(pow((double)(g_pDrops[n].x), 2) + pow((double)(g_pDrops[n].y), 2));
								if (way <= 150.0f) {
									HPEN hBluePen = (HPEN)CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
									HPEN hOldPen = (HPEN)SelectObject(hDC, hBluePen);
									HBRUSH hBlueBrush = (HBRUSH)CreateSolidBrush(RGB(0, 0, 255));
									HBRUSH hOldBrush = (HBRUSH)SelectObject(hDC, hBlueBrush);
									Ellipse(hDC, x0 + g_pDrops[n].x - 2, y0 - g_pDrops[n].y + 2, x0 + g_pDrops[n].x + 2, y0 - g_pDrops[n].y - 2);
									DeleteObject(hOldPen);
									DeleteObject(hOldBrush);
								} else {
									HPEN hBlackPen = (HPEN)CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
									HPEN hOldPen = (HPEN)SelectObject(hDC, hBlackPen);
									HBRUSH hBlackBrush = (HBRUSH)CreateSolidBrush(RGB(0, 0, 0));
									HBRUSH hOldBrush = (HBRUSH)SelectObject(hDC, hBlackBrush);
									Ellipse(hDC, x0 + g_pDrops[n].x - 2, y0 - g_pDrops[n].y + 2, x0 + g_pDrops[n].x + 2, y0 - g_pDrops[n].y - 2);
									DeleteObject(hOldPen);
									DeleteObject(hOldBrush);
								}
							}
						}
					}
				}
			}
			EndPaint(hWnd, &ps); // Zeichnen - Ende
			return 0;
		} break;
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

// Main Window Procedure
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_KEYDOWN:
		{
			switch (wParam) {
			case VK_RETURN:
				{
					SendMessage(hWnd, WM_COMMAND, IDC_DROP, 0);
				} break;
			case VK_TAB:
				{
					SetFocus(g_hEditCount);
				} break;
			}
			return 0;
		} break;
	case WM_CREATE: // Wenn Fenster erstellt wird
		{
			LPCREATESTRUCT pCS = (LPCREATESTRUCT)lParam;
			// Statischen Text für Anzahl der Tropfen erstellen
			g_hStaticCount = CreateWindow("STATIC", "Anzahl Tropfen:", WS_VISIBLE|WS_CHILD|SS_SIMPLE, 10, 10, 108, 20, hWnd, (HMENU)IDC_STATIC_COUNT, pCS->hInstance, NULL);
			if (IsWindow(g_hStaticCount) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			// Editbox für Anzahl der Tropfen erstellen
			g_hEditCount = CreateWindow("EDIT", "256", WS_VISIBLE|WS_CHILD|WS_BORDER|WS_TABSTOP|WS_GROUP, 128, 10, 546, 20, hWnd, (HMENU)IDC_COUNT, pCS->hInstance, NULL);
			if (IsWindow(g_hEditCount) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			pOldEditProc = (WNDPROC)SetWindowLong(g_hEditCount, GWL_WNDPROC, (LONG)SubEditProc);
			// Button zum Starten erstellen
			g_hButtonDrop = CreateWindow("BUTTON", "Start", WS_VISIBLE|WS_CHILD|BS_DEFPUSHBUTTON|WS_TABSTOP, 684, 10, 100, 20, hWnd, (HMENU)IDC_DROP, pCS->hInstance, NULL);
			if (IsWindow(g_hButtonDrop) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			pOldButtonProc = (WNDPROC)SetWindowLong(g_hButtonDrop, GWL_WNDPROC, (LONG)SubButtonProc);
			// Renderwindow zum Zeichnen erstellen
			g_hRenderDrops = CreateWindow("PIRenderWindow", "", WS_VISIBLE|WS_CHILD|WS_BORDER, 10, 40, 774, 474, hWnd, (HMENU)IDC_RENDER, pCS->hInstance, NULL);
			if (IsWindow(g_hRenderDrops) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			// Statischen Text für PI erstellen
			g_hStaticPI = CreateWindow("STATIC", "PI:", WS_VISIBLE|WS_CHILD|SS_SIMPLE, 10, 524, 20, 20, hWnd, (HMENU)IDC_STATIC_PI, pCS->hInstance, NULL);
			if (IsWindow(g_hStaticPI) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			// Edit Box für PI erstellen
			g_hEditPI = CreateWindow("EDIT", "3.141592654", WS_VISIBLE|WS_CHILD|WS_BORDER, 40, 524, 120, 20, hWnd, (HMENU)IDC_PI, pCS->hInstance, NULL);
			if (IsWindow(g_hEditPI) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			EnableWindow(g_hEditPI, FALSE); // Fenster deaktivieren
			// Fortschrittsanzeige erstellen
			g_hProgressPI = CreateWindowEx(0, PROGRESS_CLASS, "", WS_VISIBLE|WS_CHILD|PBS_SMOOTH , 170, 524, 612, 20, hWnd, (HMENU)IDC_PROGRESS, pCS->hInstance, NULL);
			if (IsWindow(g_hProgressPI) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			ShowWindow(g_hProgressPI, SW_HIDE);
			SendMessage(g_hProgressPI, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
			SendMessage(g_hProgressPI, PBM_SETPOS, 0, 0);
			return 0;
		} break;
	case WM_CLOSE: // Wenn Fenster geschlossen wird
		{
			DestroyWindow(hWnd); // Fenster zerstören
			return 0;
		} break;
	case WM_DESTROY: // Wenn Fenster zerstört wird
		{
			if (hPIThread != INVALID_HANDLE_VALUE) {
				ShowWindow(g_hProgressPI, SW_HIDE);
				TerminateThread(hPIThread, 0);
				if (g_iNumDrops) g_iNumDrops = 0;
				if (g_pDrops) { delete[] g_pDrops; g_pDrops = NULL; }
			}
			PostQuitMessage(0); // Programm beenden
			return 0;
		} break;
	case WM_SYSCOMMAND: // Wenn ein Systembefehl gesendet wird
		{
			switch (wParam) {
			case ID_SYSMENU_INFO: // Wenn auf Über "PI Rechner" geklickt wurde
				{
					// Copyright-Info anzeigen
					MessageBox(hWnd, "PI Rechner Version 1.0\nCopyright (C) 2007, PI-Mania Projekt Christoph Graupner Gymnasium Kirchberg\n\nProgrammiert von Felix Bytow.\nIcon von Christian Meier.", "Über \"PI Rechner\"", MB_OK|MB_ICONINFORMATION);
				} break;
			default:
				// Standard Window Prozedur ausführen
				return DefWindowProc(hWnd, msg, wParam, lParam);
			}
			return 0;
		} break;
	case WM_COMMAND: // Wenn ein Befehl gesendet wird
		{
			switch (wParam) {
			case IDC_DROP: // Wenn auf [Start] geklickt wird
				{
					if (hPIThread != INVALID_HANDLE_VALUE) {
						ShowWindow(g_hProgressPI, SW_HIDE);
						TerminateThread(hPIThread, 0);
						if (g_iNumDrops) g_iNumDrops = 0;
						if (g_pDrops) { delete[] g_pDrops; g_pDrops = NULL; }
					}
					DWORD dwDisposition;
					hPIThread = CreateThread(NULL, 0, PIThread, (LPVOID)hWnd, 0, &dwDisposition);
					if (hPIThread == INVALID_HANDLE_VALUE) {
						MessageBox(hWnd, "Fehler: Der Thread zur Berechnung von PI konnte nicht gestartet werden!", "Fehler!", MB_OK|MB_ICONERROR);
					}
				} break;
			case ID_MENUE_INFO: // Wenn auf [Info]->[Über das Programm...] geklickt wird
				{
					// Copyright-Info anzeigen
					MessageBox(hWnd, "PI Rechner Version 1.0\nCopyright (C) 2007, PI-Mania Projekt Christoph Graupner Gymnasium Kirchberg\n\nProgrammiert von Felix Bytow.\nIcon von Christian Meier.", "Über \"PI Rechner\"", MB_OK|MB_ICONINFORMATION);
				} break;
			case ID_MENUE_EXIT: // Wenn auf [Datei]->[Beenden] geklickt wird
				{
					// Beenden
					DestroyWindow(hWnd);
				} break;
			case ID_MENUE_DESCRIPTION:
				{
					// Erklärung anzeigen
					ShellExecute(hWnd, "open", "http://de.wikipedia.org/wiki/Kreiszahl#Statistische_Bestimmung", 0, 0, SW_SHOWMAXIMIZED);
				} break;
			}
			return 0;
		} break;
	case WM_GETMINMAXINFO:
		{
			MINMAXINFO* pMinMaxInfo = (MINMAXINFO*)lParam;
			pMinMaxInfo->ptMinTrackSize.y = 447;
			pMinMaxInfo->ptMinTrackSize.x = 361;
			return 0;
		} break;
	case WM_SIZE:
		{
			RECT r;
			GetClientRect(hWnd, &r);
			r.right -= r.left;
			r.bottom -= r.top;
			r.left = 0;
			r.top = 0;
			MoveWindow(g_hStaticCount, 10, 10, 108, 20, TRUE);
			MoveWindow(g_hButtonDrop, r.right - 110, 10, 100, 20, TRUE);
			MoveWindow(g_hEditCount, 128, 10, r.right - 248, 20, TRUE);
			MoveWindow(g_hRenderDrops, 10, 40, r.right - 20, r.bottom - 80, TRUE);
			MoveWindow(g_hStaticPI, 10, r.bottom - 30, 20, 20, TRUE);
			MoveWindow(g_hEditPI, 40, r.bottom - 30, 120, 20, TRUE);
			MoveWindow(g_hProgressPI, 170, r.bottom - 30, r.right - 180, 20, TRUE);
			return 0;
		} break;
	}
	// Standard Window Prozedur ausführen
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

// Hauptprogramm
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR szCmdLine, int iCmdShow) {
	InitCommonControls(); // Steuerelemente initialisieren
	WNDCLASS wc; // Die Hauptfensterklasse
	wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hInstance = hInstance;
	wc.lpszMenuName = MAKEINTRESOURCE(ID_MAINMENU);
	wc.lpszClassName = "PIMainWindow";
	wc.lpfnWndProc = WndProc;
	wc.hbrBackground = (HBRUSH)GetSysColorBrush(COLOR_BTNFACE);
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.style = CS_HREDRAW|CS_VREDRAW;
	RegisterClass(&wc); // Fensterklasse registrieren
	wc.lpszClassName = "PIRenderWindow";
	wc.lpfnWndProc = RenderProc;
	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wc.hIcon = NULL;
	wc.hCursor = LoadCursor(NULL, IDC_CROSS);
	RegisterClass(&wc); // Fensterklasse registrieren für Render-Window
	// Fenster erstellen
	HWND hWnd = CreateWindow("PIMainWindow", "PI Rechner von Felix Bytow", WS_OVERLAPPEDWINDOW, (GetSystemMetrics(SM_CXSCREEN) - 800) / 2, (GetSystemMetrics(SM_CYSCREEN) - 600) / 2, 800, 600, GetDesktopWindow(), NULL, hInstance, NULL);
	if (IsWindow(hWnd) == FALSE) { // Konnte das Fenster erstellt werden?
		// Nein? -> Fehler ausgeben!
		MessageBox(GetDesktopWindow(), "Fehler: Hauptfenster konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
		return 0;
	}
	// Systemmenü modifizieren
	HMENU hSysMenu = GetSystemMenu(hWnd, FALSE);
	AppendMenu(hSysMenu, MF_SEPARATOR, 0, NULL);
	AppendMenu(hSysMenu, MF_STRING, ID_SYSMENU_INFO, "Über \"PI Rechner\"");
	// Hauptfenster anzeigen
	ShowWindow(hWnd, iCmdShow);
	// Hauptfenster updaten
	UpdateWindow(hWnd);
	// Nachrichtenschleife
	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0)) { // Wiederhole bis PostQuitMessage aufgerufen wird
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return msg.wParam; // Programmende
}

resource.h:

#ifndef RESOURCE_H
#define RESOURCE_H

// Symbol
#define IDI_APPICON 100

// Programmmenü
#define ID_MAINMENU 500
#define ID_MENUE_EXIT 501
#define ID_MENUE_INFO 502
#define ID_MENUE_DESCRIPTION 503

// Systemmenü
#define ID_SYSMENU_INFO 600

// Fenster und Controls
#define IDC_COUNT 800
#define IDC_DROP 801
#define IDC_STATIC_COUNT 802
#define IDC_RENDER 803
#define IDC_STATIC_PI 804
#define IDC_PI 805
#define IDC_PROGRESS 806

#endif

pi.rc:

//Microsoft Developer Studio generated resource script.
//
#include "resrc1.h"

#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#define APSTUDIO_HIDDEN_SYMBOLS
#include "windows.h"
#undef APSTUDIO_HIDDEN_SYMBOLS
#include "resource.h"

/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS

/////////////////////////////////////////////////////////////////////////////
// Deutsch (Deutschland) resources

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU)
#ifdef _WIN32
LANGUAGE LANG_GERMAN, SUBLANG_GERMAN
#pragma code_page(1252)
#endif //_WIN32

/////////////////////////////////////////////////////////////////////////////
//
// Icon
//

// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
IDI_APPICON             ICON    DISCARDABLE     "PI Rechner.ico"

/////////////////////////////////////////////////////////////////////////////
//
// Menu
//

ID_MAINMENU MENU DISCARDABLE 
BEGIN
    POPUP "&Datei"
    BEGIN
        MENUITEM "Be&enden",                    ID_MENUE_EXIT
    END
    POPUP "&Info"
    BEGIN
        MENUITEM "Über das Programm...",        ID_MENUE_INFO
        MENUITEM "Er&klärung",                  ID_MENUE_DESCRIPTION
    END
END

#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//

1 TEXTINCLUDE DISCARDABLE 
BEGIN
    "resrc1.h\0"
END

2 TEXTINCLUDE DISCARDABLE 
BEGIN
    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
    "#include ""windows.h""\r\n"
    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
    "#include ""resource.h""\r\n"
    "\0"
END

3 TEXTINCLUDE DISCARDABLE 
BEGIN
    "\r\n"
    "\0"
END

#endif    // APSTUDIO_INVOKED

/////////////////////////////////////////////////////////////////////////////
//
// 24
//

1                       24      DISCARDABLE     "PI Rechner.exe.Manifest"
#endif    // Deutsch (Deutschland) resources
/////////////////////////////////////////////////////////////////////////////

#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//

/////////////////////////////////////////////////////////////////////////////
#endif    // not APSTUDIO_INVOKED

und zu guter letzt das Manifest:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly
  xmlns="urn:schemas-microsoft-com:asm.v1"
  manifestVersion="1.0">
<assemblyIdentity
    name="DevCpp.Apps.PI_Rechner"
    processorArchitecture="x86"
    version="1.0.0.0"
    type="win32"/>
<description>PI Rechner</description>
<dependency>
    <dependentAssembly>
        <assemblyIdentity
            type="win32"
            name="Microsoft.Windows.Common-Controls"
            version="6.0.0.0"
            processorArchitecture="x86"
            publicKeyToken="6595b64144ccf1df"
            language="*"
        />
    </dependentAssembly>
</dependency>
</assembly>

naja, also mal die Stellen, die mir relevant scheinen

Die ganzen Handles für die Steuerelemente

// Controls
HWND g_hStaticCount = NULL;
HWND g_hEditCount = NULL;
HWND g_hButtonDrop = NULL;
HWND g_hRenderDrops = NULL;
HWND g_hStaticPI = NULL;
HWND g_hEditPI = NULL;
HWND g_hProgressPI = NULL;

die gesubclassden WndProcs

// Button Subclassen
WNDPROC pOldButtonProc = NULL;
LRESULT CALLBACK SubButtonProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_KEYDOWN:
		{
			switch (wParam) {
			case VK_RETURN:
				{
					SendMessage(GetParent(hWnd), WM_COMMAND, IDC_DROP, 0);
				} break;
			case VK_TAB:
				{
					SetFocus(g_hEditCount);
				} break;
			default:
				return pOldButtonProc(hWnd, msg, wParam, lParam);
			}
			return 0;
		} break;
	}
	return pOldButtonProc(hWnd, msg, wParam, lParam);
}

// Edit Subclassen
WNDPROC pOldEditProc = NULL;
LRESULT CALLBACK SubEditProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
	case WM_KEYDOWN:
		{
			switch (wParam) {
			case VK_RETURN:
				{
					SendMessage(GetParent(hWnd), WM_COMMAND, IDC_DROP, 0);
				} break;
			case VK_TAB:
				{
					SetFocus(g_hButtonDrop);
				} break;
			default:
				return pOldEditProc(hWnd, msg, wParam, lParam);
			}
			return 0;
		} break;
	}
	return pOldEditProc(hWnd, msg, wParam, lParam);
}

Der Teil mit SetWindowLong

// Editbox für Anzahl der Tropfen erstellen
			g_hEditCount = CreateWindow("EDIT", "256", WS_VISIBLE|WS_CHILD|WS_BORDER|WS_TABSTOP|WS_GROUP, 128, 10, 546, 20, hWnd, (HMENU)IDC_COUNT, pCS->hInstance, NULL);
			if (IsWindow(g_hEditCount) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			pOldEditProc = (WNDPROC)SetWindowLong(g_hEditCount, GWL_WNDPROC, (LONG)SubEditProc);
			// Button zum Starten erstellen
			g_hButtonDrop = CreateWindow("BUTTON", "Start", WS_VISIBLE|WS_CHILD|BS_DEFPUSHBUTTON|WS_TABSTOP, 684, 10, 100, 20, hWnd, (HMENU)IDC_DROP, pCS->hInstance, NULL);
			if (IsWindow(g_hButtonDrop) == FALSE) { // Hat es geklappt?
				// Nein? -> Fehler anzeigen!
				MessageBox(hWnd, "Fehler: Ein Steuerelement konnte nicht erstellt werden!", "Fehler!", MB_OK|MB_ICONERROR);
				DestroyWindow(hWnd); // Fenster zerstören
				return 0;
			}
			pOldButtonProc = (WNDPROC)SetWindowLong(g_hButtonDrop, GWL_WNDPROC, (LONG)SubButtonProc);

noch was:
der Fehler kommt jetzt auch bei der Debug Version ???...
naja, hab mal im Debugger geguckt und aus irgend einem Grund ist in pOldButtonProc eine ungültige Adresse...

es gibt aber nur 2 schreibende Zugriffe im Code, die Initialisierung mit NULL und dann über SetWindowLong.
Demnach gibt die einen falschen Wert zurück, nur warum?

Weiterhin wird die DefWindowProc für ein subgeclasstes Fenster nicht so aufrufen:

return pOldButtonProc(hWnd, msg, wParam, lParam);

sondern

return CallWindowProc(pOldButtonProc, hWnd, msg, wParam, lParam);

siehe CallWindowProc

ich werde mal CallWindowProc testen.