Childwindow mit CreateWindow klappt net

Martin Richter

Zeig mal bitte Deine AddProc Fensterprozedur. Ich vermute mal an der ist was faul.

hier, momentan soll darin noch nichts passsieren, einfach nur durchlaufen.
fehtl da etwas, das zwingend notwendig ist ?

LRESULT CALLBACK AddProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	switch(message)
	{
	case WM_CREATE:
		{

		break;
		}

	case WM_SIZE:
		{

		break;
		}

	case WM_COMMAND:
		{
		break;
		}

	case WM_PAINT:
		{
			return 0;
		}

	case WM_CLOSE:
		{
		DestroyWindow(hWnd);
		return (0);
		}
	}

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

Martin Richter

Ist doch kein Wunder, wenn Du nicht mal WM_PAINT behandelst.
Das führt zu einer Endlosschleife...

Wenn Du eine Nachricht nicht behandelst, dann lass den Handler einfach Weg.

WilMen

Hi Martin,
das die Handler weg sollten, wenn man die entsprechende Nachricht nicht behandelt ist klar (bringt ja auch nichts), aber wieso entsteht da eine Endlosschleife? Er hat doch in WM_PAINT nichts à la Aufruf von MessageBox zu stehen!

MfG WilMen

Martin Richter schrieb:

Ist doch kein Wunder, wenn Du nicht mal WM_PAINT behandelst.
Das führt zu einer Endlosschleife...

Wenn Du eine Nachricht nicht behandelst, dann lass den Handler einfach Weg.

ich hab die WM_Paint mal rausgenommen, der effekt ist aber der selbe geblieben. da tut sich einfach nix.....

gibts irgendwo ein bissle sample-code für ein stinknormales childfenster?!

was ich zudem nicht verstehe ist, wenn ich das parentWnd weglasse (also NULL setze den parameter)wird das fenster scheinbar normal erstellt. und ich kann damit arbeiten.

Martin Richter

Wenn niemals BeginPaint aufgerufen wird, und das geschieht bei Dir bene nicht, wird immer iweder WM_PAINT versendet.

Hats Du mal ein Sample Download von Deiner Source....

WilMen

Hi, probier's mal hiermit:

hWndChild = CreateWindow (TEXT("AddWnd"), NULL,
                              WS_CHILDWINDOW | WS_VISIBLE,
                              x, y, nWidth, nHeight,
                              hwnd, (HMENU) (y << 8 | x),
                              (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE),
                              NULL) ;

Damit du das Fenster auch siehst bzw. siehst ob es geklappt hat oder nicht, wär es nicht schlecht die AddProc so zu ergänzen (nur zum Testen!!!):

static RECT rect ;
HDC hDC ;
PAINTSTRUCT ps ;
// ...
case WM_SIZE:
GetClientRect (hWnd, &rect) ;
return 0 ;

case WM_PAINT:
hDC = BeginPaint (hWnd, &ps) ;
Rectangle (hDC, rect.left, rect.top, rect.right, rect.bottom) ;
EndPaint (hWnd, &ps) ;
return 0 ;
//...

MfG WilMen

C-Chris

Martin Richter schrieb:

Wenn niemals BeginPaint aufgerufen wird, und das geschieht bei Dir bene nicht, wird immer iweder WM_PAINT versendet.

Hats Du mal ein Sample Download von Deiner Source....

Öhm nein. Wieso auch? Wieso sollte das erstemal WM_PAINT versendet werden nur weil es zur Auswahl steht? o.O Es könnte allerdings sein dass es mit UpdateWindow erzwungen wird. Aber das endet auch nicht in einer Endlosschleife.

Du solltest alle UpdateWindow"s"(); weglassen
Ich denke das Problem liegt darin dass du ein zweiter Objekt von WNDCLASSEX machen solltest a la :

//das hier bei der WM_COMMAND Ereignissbehandlung(WndProc) hinzufügen
//natürlich mit LParam und richtigen Button etc.
    WNDCLASSEX wcAddex; 

    wcAddex.cbSize = sizeof(WNDCLASSEX); 
//hier dein Code:
    wcAddex.style            = CS_HREDRAW | CS_VREDRAW; 
    wcAddex.lpfnWndProc    = AddProc; //oder wie auch immer das heist
    wcAddex.cbClsExtra        = 0; 
    wcAddex.cbWndExtra        = 0; 
    wcAddex.hInstance        = hInstance; 
    wcAddex.hIcon            = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_KNOWLEDGEBASE)); 
    wcAddex.hCursor        = LoadCursor(NULL, IDC_ARROW); 
    wcAddex.hbrBackground    = (HBRUSH)(COLOR_WINDOW+1); 
    wcAddex.lpszMenuName    = MAKEINTRESOURCE(IDC_KNOWLEDGEBASE); 
    wcAddex.lpszClassName    = szWindowClass; //HIER ANDERER KLASSEN NAME
    wcAddex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL)); 

    //Hier wird das Fenster registiert
    RegisterClassEx(&wcAddex); 
    //So dann musst du das Fenster noch erstellen aber als eignes eben nicht 
    //Childwindow

    hAddnd = CreateWindowW() //Hier deine Fensterbeschreibung
    ShowWindowW(&hAddnd,nCmdShow);
    //No Need for UpdateWindow. UpdateWindow erzwingt eine WM_PAINT Message 
    //die muss allerdings nicht behandelt werden und endet keinesfalls in einer
    //Endlosschleife

Mit einem Childwindow wird das wohl ähnlich gehen so oder so ähnlich muss es alllerdings klappen. Noch eine Anmerkunge lass das erste UpdateWindow in deinem InitCode( Code der immer initalisiert wird).
Viel Spass noch.

P.S.: Kann sein das unzählige Fehler im Code sind, aber bei mir hat das schon eimal so geklappt.

Martin Richter

Wenn ein WM_PAINT Handler eingebaut ist, der nichts tut, wird sofort wieder WM_PAINT gesendet...
Nur wenn man BeginPaint/EndPaint verwendet wird das Fenster validiert.
Das selbe macht natürlich die DefWindowProc, nur wurde die im ersten Snippelt nicht verwendet.

Das sagt aber dennoch nicht, warum man das Fenster nicht ziehen und aktivieren kann. Man müsste mehr Code sehen.

WilMen

Gentlemen, ich bin ganz seiner Meinung. Er soll endlich mal den kompletten Code posten, sonst führt das hier zu nichts!

MfG WilMen :xmas1:

ok, hier ist mal der ganze code des hauptprogrammes:

// KnowledgeBase.cpp : Definiert den Einstiegspunkt für die Anwendung.
//

#include "stdafx.h"
#include "main.h"
#include "commctrl.h"
#include <winsock.h>
#include <mysql.h>
#include "CRequestDB.h"
#include "CSearchArg.h"

#define MAX_LOADSTRING 100
#define ID_LISTVIEW			WM_USER+1
#define ID_SEARCHLINE		WM_USER+2
#define ID_GOBUTTON			WM_USER+3
#define LV_WIDTH			WM_USER+4
#define LV_HEIGHT			WM_USER+5
#define ID_ADDSOLUTION		WM_USER+6

// Globale Variablen:
HINSTANCE hInst;								// Aktuelle Instanz
TCHAR szTitle[MAX_LOADSTRING];					// Titelleistentext
TCHAR szWindowClass[MAX_LOADSTRING];			// Klassenname des Hauptfensters
TRACKMOUSEEVENT tme;

// Vorwärtsdeklarationen der in diesem Codemodul enthaltenen Funktionen:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc       (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	SearchLineProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    ListViewProc  (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	AddProc       (HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About         (HWND, UINT, WPARAM, LPARAM);

// Hilfsfunktionen
int CreateColumn(HWND hwnd, int iCol, TCHAR* Text, int iBreite);
int Create2ColItem(HWND hwnd, TCHAR *Text1, TCHAR *Text2);
std::string GetSearchText(HWND hSearchLine);
void OutputQueryResultsToListView(HWND hListView, CRequestDB *myRequest);

static LONG_PTR PrevWndProcSearchLine;
static LONG_PTR PrevWndProcListView;

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: Hier Code einfügen.
	MSG msg;
	HACCEL hAccelTable;

	// Globale Zeichenfolgen initialisieren
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_KNOWLEDGEBASE, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Anwendungsinitialisierung ausführen:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_KNOWLEDGEBASE));

	// Hauptmeldungsschleife:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int) msg.wParam;
}

//
//  FUNKTION: MyRegisterClass()
//
//  ZWECK: Registriert die Fensterklasse.
//
//  KOMMENTARE:
//
//    Sie müssen die Funktion verwenden,  wenn Sie möchten, dass der Code
//    mit Win32-Systemen kompatibel ist, bevor die RegisterClassEx-Funktion
//    zu Windows 95 hinzugefügt wurde. Der Aufruf der Funktion ist wichtig,
//    damit die kleinen Symbole, die mit der Anwendung verknüpft sind,
//    richtig formatiert werden.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_KNOWLEDGEBASE));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_KNOWLEDGEBASE);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	RegisterClassEx(&wcex);

	wcex.lpszClassName = TEXT("AddWnd");
	wcex.lpfnWndProc   = AddProc;
	wcex.hIcon		   = NULL;
	wcex.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);

	return RegisterClassEx(&wcex);
}

//
//   FUNKTION: InitInstance(HINSTANCE, int)
//
//   ZWECK: Speichert das Instanzenhandle und erstellt das Hauptfenster.
//
//   KOMMENTARE:
//
//        In dieser Funktion wird das Instanzenhandle in einer globalen Variablen gespeichert, und das
//        Hauptprogrammfenster wird erstellt und angezeigt.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Instanzenhandle in der globalen Variablen speichern

   int screenWidth  = GetSystemMetrics(SM_CXFULLSCREEN);
   int screenHeight = GetSystemMetrics(SM_CYFULLSCREEN);

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX,
      static_cast<int>((screenWidth  - (screenWidth  / 1.25)) / 2), // Mittig zentrieren X-Achse 
	  static_cast<int>((screenHeight - (screenHeight / 1.25)) / 2), // Mittig zentrieren Y-Achse
	  static_cast<int>(screenWidth  / 1.25), // 
	  static_cast<int>(screenHeight / 1.25),
	  NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNKTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  ZWECK:  Verarbeitet Meldungen vom Hauptfenster.
//
//  WM_COMMAND	- Verarbeiten des Anwendungsmenüs
//  WM_PAINT	- Zeichnen des Hauptfensters
//  WM_DESTROY	- Beenden-Meldung anzeigen und zurückgeben
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc, hdcTmp;
	static HWND	hListView, hSearchLine, hGoButton, hAddWnd;
	static int iWindowWidth, iWindowHeight;

	switch (message)
	{
	case WM_CREATE:

		/*************************/
		/* Erzeugen der ListView */
		/*************************/

		INITCOMMONCONTROLSEX	inicc;
		inicc.dwSize = sizeof(INITCOMMONCONTROLSEX);
		inicc.dwICC = ICC_LISTVIEW_CLASSES; 
		InitCommonControlsEx(&inicc);

		hListView = CreateWindow(WC_LISTVIEW ,L"", WS_VISIBLE | WS_BORDER | WS_CHILD | LVS_REPORT | LVS_EDITLABELS,
			0, 0, 0, 0, hWnd, HMENU(ID_LISTVIEW), ((LPCREATESTRUCT)lParam)->hInstance, NULL);

		PrevWndProcListView = SetWindowLongPtr(hListView, GWLP_WNDPROC, (LONG_PTR) ListViewProc);

		ListView_SetExtendedListViewStyle(hListView, LVS_EX_FULLROWSELECT);
		ListView_SetExtendedListViewStyle(hListView, ListView_GetExtendedListViewStyle(hListView) | LVS_EX_GRIDLINES );

		/******************************************/
		/* Erzeugen der Zeile für den Suchbegriff */
		/******************************************/

		hSearchLine = CreateWindow(L"edit", L"", WS_VISIBLE | WS_CHILD | ES_LEFT | WS_TABSTOP ,
									0, 0, 0, 0, hWnd, HMENU(ID_SEARCHLINE), ((LPCREATESTRUCT)lParam)->hInstance, NULL);

		PrevWndProcSearchLine = SetWindowLongPtr(hSearchLine, GWLP_WNDPROC, (LONG_PTR) SearchLineProc);

		/***********************************************/
		/* Erzeugen des Button für den Start der Suche */
		/***********************************************/

		hGoButton   = CreateWindowEx(WS_EX_WINDOWEDGE, L"button", L"Go", WS_VISIBLE | WS_CHILD | WS_TABSTOP, 
									0, 0, 0, 0, hWnd, HMENU(ID_GOBUTTON), ((LPCREATESTRUCT)lParam)->hInstance, NULL);

		break;

	case WM_SIZE:
		iWindowHeight = LOWORD(lParam);
		iWindowWidth  = LOWORD(lParam);

		//Positionieren und Festlegen der Größe des Listview im Fenster
		MoveWindow(hListView, 0, 
							  static_cast<int>(iWindowHeight / 10), //Unter grauen Block positionieren
							  iWindowWidth, //Ausdehnung im Fenster auf volle Breite 
							  static_cast<int>(iWindowHeight - (iWindowHeight / 10)), //Höhe der ListView = Fensterhöhe, abzüglich grauen Block
							  true);

		//Positionieren und Festlegen der Größe des Eingabfeldes für den Suchbegriff im Fenster

		TEXTMETRIC	tm;

		hdcTmp = GetDC(hWnd);
		GetTextMetrics(hdcTmp, &tm);
		ReleaseDC(hWnd, hdcTmp);

		MoveWindow(hSearchLine, static_cast<int>(iWindowWidth / 5),
								static_cast<int>((iWindowHeight / 10) / 2),
								tm.tmMaxCharWidth * 50,
								tm.tmHeight,
								true);

		SetFocus(hSearchLine);		

		// Positionieren des Buttons

		MoveWindow(hGoButton, static_cast<int>((iWindowWidth / 5) + (tm.tmMaxCharWidth * 50) + 50),
							  static_cast<int>(((iWindowHeight / 10) / 2) - 5),
							  50, tm.tmHeight + 10, true);

		/******************************
		/* LISTVIEW EINTRÄGE TEST ****/
		/******************************

		/* Hinzufügen von 2 Spaltenüberschriften */
		CreateColumn(hListView, 0, L"Lösungs-ID", 100);
		CreateColumn(hListView, 1, L"Anlesetext", iWindowWidth - 100); 
		/* Testeintrag für eine Zeile */
		Create2ColItem(hListView, L"EY", L"SSSS");
		Create2ColItem(hListView, L"EY2", L"SSSS2");

		break;

	case WM_NOTIFY:
		switch(((LPNMHDR) lParam)->code)
		{
		case(LVN_BEGINLABELEDIT): /* Verhindern, dass man Einträge editieren kann, einfach true zurückgeb. */
			return true;
		}
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Menüauswahl bearbeiten:
		switch (wmId)
		{
		case IDM_ADD_SOLUTION:
			//hAddWnd = CreateWindow(L"AddWnd", L"Add Knowledge", WS_OVERLAPPED  |WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_VISIBLE, 200, 300, 600, 400, NULL, NULL, NULL, NULL);
			hAddWnd = CreateWindow(L"AddWnd", L"Add Knowledge", WS_OVERLAPPED | WS_CHILD | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_VISIBLE, 200, 300, 600, 800, hWnd, (HMENU) ID_ADDSOLUTION, hInst, NULL);
			/*CreateWindowEx(WS_EX_CLIENTEDGE, TEXT("SUB"), TEXT("Erfassung des Adressbuchbesitzer"),
										WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_VISIBLE , 320, 240, 480, 150,
										NULL, NULL, NULL, NULL);*/
			//MessageBox(hWnd, L"bin drin", L"blub", MB_OK);
			break;
		case IDM_\1:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		case ID_GOBUTTON:
			{
			CRequestDB *myRequest = new CRequestDB(hWnd, "localhost","root","root","knowledgebase",3306);
			CSearchArg  mySearchArg;
			myRequest->SearchDB(mySearchArg.GetSearchArguments(hSearchLine));
			OutputQueryResultsToListView(hListView, myRequest);
			delete myRequest;
			break;
			}
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;

	case WM_PAINT:
		{

		RECT clientArea;

		hdc = BeginPaint(hWnd, &ps);
		HBRUSH hOldBrush = (HBRUSH)SelectObject(hdc,
												CreateSolidBrush(RGB(198,192,192)));

		SelectObject(hdc, CreatePen(PS_SOLID, 0, RGB(198, 192, 192)));

		clientArea.left = 0;
		clientArea.top  = 0;
		clientArea.right = iWindowWidth;
		clientArea.bottom = iWindowHeight / 10;

		Rectangle(hdc,
				  0,
				  0,
				  iWindowWidth,
				  iWindowHeight / 10);

		SetBkColor(hdc, RGB(198,192,192));

		DeleteObject(SelectObject(hdc, hOldBrush));

		/******************************************/

		HFONT hFont = CreateFont(14, 14, 0, 0,
								  FW_BOLD,
								  false, false, false,
								  DEFAULT_CHARSET,
								  OUT_DEFAULT_PRECIS,
								  CLIP_DEFAULT_PRECIS,
								  ANTIALIASED_QUALITY,
								  DEFAULT_PITCH ,
								  L"test");

		SelectObject(hdc, hFont);
		TextOut(hdc, static_cast<int>(iWindowWidth / 5), /*Exakte x-Position der Suchzeile */
					 static_cast<int>((iWindowHeight / 10) / 2) - (iWindowHeight / 50), /* Y-Position leicht nach oben versetzt, von Y-Pos. der Suchzeile */
					 L"Suchbegriff eingeben:", 21);

		DeleteObject(hFont);

		EndPaint(hWnd, &ps);
		break;
		}
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

LRESULT CALLBACK SearchLineProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_KEYDOWN:
		switch(wParam)
		{
		case 0x0D: /* Carrige Return (Entertaste) abfragen */
			HWND hMainWnd = FindWindow(szWindowClass, szTitle);
			SendMessage(hMainWnd, WM_COMMAND, ID_GOBUTTON, NULL); /* Bei Eingabetaste identisch wie mit Buttonklick verhalten */
			break;  
		}
	}

return CallWindowProc ((WNDPROC) PrevWndProcSearchLine, hWnd, message, wParam, lParam);
}

LRESULT CALLBACK ListViewProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	switch(message)
	{
		POINT hitPoint;

	case WM_MOUSEMOVE:
		TRACKMOUSEEVENT tme;
		tme.cbSize = sizeof(TRACKMOUSEEVENT);
		tme.dwFlags = TME_HOVER;
		tme.dwHoverTime = HOVER_DEFAULT;
		tme.hwndTrack = hWnd;
		TrackMouseEvent(&tme);
		break;

	case WM_MOUSEHOVER:
		GetCursorPos(&hitPoint);
		LVHITTESTINFO pHitInfo;
		ScreenToClient(hWnd,&hitPoint);
		pHitInfo.pt = hitPoint;
		ListView_HitTest(hWnd, &pHitInfo.pt);
		break;
	}

return CallWindowProc ((WNDPROC) PrevWndProcListView, hWnd, message, wParam, lParam);
}

LRESULT CALLBACK AddProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	switch(message)
	{
	case WM_CREATE:
		{

		break;
		}

	case WM_SIZE:
		{

		break;
		}

	case WM_COMMAND:
		{
		break;
		}

	case WM_CLOSE:
		{
		DestroyWindow(hWnd);
		return (0);
		}
	}

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

// Meldungshandler für Infofeld.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

int CreateColumn(HWND hwndLV, int iCol, TCHAR* Text, int iBreite)
{
	LVCOLUMN lvc;
	lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvc.fmt = LVCFMT_LEFT;
	lvc.cx = iBreite;
	lvc.pszText = Text;  
	lvc.iSubItem = iCol;
	return ListView_InsertColumn(hwndLV, iCol, &lvc);
}

int CreateItem(HWND hwndLV, TCHAR *Text)
{ 
LVITEM lvi = {0};

    lvi.mask = LVIF_TEXT;
    lvi.pszText = Text;
    return ListView_InsertItem(hwndLV, &lvi);
} 

int Create2ColItem(HWND hwndLV, TCHAR *Text1, TCHAR *Text2)
{ 
LVITEM lvi = {0};
int Ret;

    // Initialize LVITEM members that are common to all items. 
    lvi.mask = LVIF_TEXT;
    lvi.pszText = Text1;
    Ret = ListView_InsertItem(hwndLV, &lvi);
    if (Ret>=0) {
        ListView_SetItemText(hwndLV, Ret, 1, Text2);
    }
    return Ret;
}

std::string GetSearchText(HWND hSearchLine)
{

	TCHAR cSearchText[1000];
	char  cMulBySearchText[1000];

	GetWindowText(hSearchLine, cSearchText, 1000);

	WideCharToMultiByte(CP_UTF8, 0, cSearchText, 1000, cMulBySearchText, 1000, NULL, NULL);

	std::string rtnStrng = cMulBySearchText;

	return rtnStrng;

}

void OutputQueryResultsToListView(HWND hListView, CRequestDB *myRequest)
{
	if(myRequest->GetStatSearchSuccess())
	{
		ListView_DeleteAllItems(hListView);

		while(myRequest->rowContent = mysql_fetch_row(myRequest->result))
		{
			std::string id   = myRequest->rowContent[0];
			std::string text = myRequest->rowContent[1];

			TCHAR idTC[10];
			TCHAR textTC[100];

			MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, id.c_str(), 10, idTC, 10);
			MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text.c_str(), 100, textTC, 100);

			Create2ColItem(hListView, idTC, textTC);
		}
	}
}

Martin Richter

Wenn AddWnd ein eigenständiges Popup Window werdne soll, dann darf es den Stil WS_CHILD nicht haben.

Soll das ein modaler Dialog werden? Dann solltest Du auch DialogBox verwenden.

BTW:
1. InitCommonControlsEx gehört nach InitInstance oder nitApplication und Du solltest gewahr sein, dass diese Funktion evtl. fehlschlägt. In diesem Fall solltest DU das Programm sofort verlassen.
2. Du hast keinerlei Fehlerhandling in Deinem Programm. Das Anlegen eines Fensters kann fehlgehen.
3. Es ist wohl absoluter Blödsinn bei jeder WM_SIZE Meldung zwei neue Spalten in die Listbox hinzuzufügen. Der Code gehört nach WM_CREATE.
4. Dein WM_NOTIFY Code hat kein break. Der Prorammfluß läuft sofort in den nächsten Bock weiter (WM_COMMAND).
5. Du solltest die Variablen, die Du benutzt näher an den Blöcken definieren in denen Sie benutzt werden. Die Paintstruct z.B. kannst Du auch im case-Block für WM_PAINT nutzen.
6. WM_COMMAND muss nicht DefWindowProc ausführen, wenn kein Commandcode zutrifft.