Fenster einer fremden DLL öffnet nicht richtig



  • Moin liebe Forenleser,

    ich bin absoluter Anfänger im Programmieren mit C++ und habe seit Tgen ein Problem, das ich einfach nicht gelöst bekomme.

    Ich habe ein bestehendes Programm (geschrieben in C++), welches ich abändern soll. Wäre diese Programm im VisualStudio-Üblichem Kontext verfasst, würde ich mich bestimmt leichter tun. Dummerweise ist es in (für mich zumindest) absolut grundlegendem C++ verfasst.

    Zudem habe ich noch das Problem, dass ich eine DLL verwenden soll, welche nicht einsehbar ist; also quasi eine Black Box.

    In dieser DLL sind nun (wer hät's gedacht) Funktionen enthalten, welche aufgerufen werden. Neu hinzugekommen ist nun zu dem bestehendem Programm, dass eine dieser Funktionen ein Fenster öffnen möchte, in dem der Benutzer Einstellungen vor nimmt.

    Ab hier fängt der Spaß an. Denn das Fenster geht zwar auf, zeigt aber keinen Inhalt. Außerdem ist es immer im Hintergrund und das "Hauptfenster" weigert sich aus dem Vordergrund zu gehen. In VS und dem dort so angenehmen Baukastenprinzip hab ich die DLL und das Fenster schon zum laufen gebracht. Aber da muss man sich ja auch keine Gedanken um die Hintergrundprozesse machen, nur noch den eignen Code in die Ereignisfunktionen schreiben.

    Ich könnte mir vorstellen, dass das Problem relativ einfach zu lösen ist, wenn man weiß, an welcher Stellschraube man drehen muss ... dummerweise sehen über die Hälfte der Codezeilen für mich noch immer aus wie Voodoo. Ich hoffe daher, dass sich jemand die Zeit nehmen könnte, sich den Code kurz anschaut und mir dann ggf dabei helfen kann, das Konfigurationsfenster funktionsfähig zu bekommen. Da das Fenster selber ja von der DLL erstellt wird ist das vermutlich irgend was in die Richtung, dass eine Handler-Funktion zum Darstellen/Anzeigen/Aktualisieren oder oä fehlt.

    Vielen Dank schon mal im Voraus an alle, die bis hierher gelesen haben 😃

    Der Code ist recht umfangreich, da ich nicht wusste, was alles selbstverständlich ist und was relevant. Trotzdem stehen nicht alle Funktionen/Klassen/Threads hier mit drinnen. Das wäre der Übersichtlichkeit halber nicht mehr sinnvoll gewesen vermute ich mal.

    // PyroCamLabVIEW-API.cpp : Definiert den Einstiegspunkt für die Anwendung.
    //
    
    #include "stdafx.h"
    #include "PyroCamLabVIEW-API.h"
    # include <Windows.h>
    
    #define MAX_LOADSTRING 100
    
    TCHAR g_szClassName[] = TEXT("myWindowClass");
    
    // Globale Variablen:
    HINSTANCE hInst;								// Aktuelle Instanz
    TCHAR szTitle[MAX_LOADSTRING];					// Titelleistentext
    TCHAR szWindowClass[MAX_LOADSTRING];			// Klassenname des Hauptfensters
    
    // Vorwärtsdeklarationen der in diesem Codemodul enthaltenen Funktionen:
    ATOM				MyRegisterClass(HINSTANCE hInstance);
    BOOL				InitInstance(HINSTANCE, int);
    LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
    INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
    INT_PTR CALLBACK	PyroCamAPI(HWND, UINT, WPARAM, LPARAM);
    
    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_PYROCAMLABVIEWAPI, szWindowClass, MAX_LOADSTRING);
    
    	MyRegisterClass(hInstance);
    
    	// Anwendungsinitialisierung ausführen:
    	if (!InitInstance (hInstance, nCmdShow))
    	{
    		return FALSE;
    	}
    
    	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PYROCAMLABVIEWAPI));
    
    	// Hauptnachrichtenschleife:
    	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_PYROCAMLABVIEWAPI));
    	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
    	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
    	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_PYROCAMLABVIEWAPI);
    	wcex.lpszClassName	= szWindowClass;
    	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    
    	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
       hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
          CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, 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;
    
    	switch(message){
    	case WM_CREATE:
    		{
    			DialogBoxW(NULL,MAKEINTRESOURCE(IDD_PYROCAMAPI),hWnd,PyroCamAPI);
    		}
    		break;
    	case WM_COMMAND:
    		wmId    = LOWORD(wParam);
    		wmEvent = HIWORD(wParam);
    		// Menüauswahl bearbeiten:
    		switch (wmId)
    		{
    		case IDM_\1:
    			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
    			break;
    		case IDM_EXIT:
    			DestroyWindow(hWnd);
    			break;
    		default:
    			return DefWindowProc(hWnd, message, wParam, lParam);
    		}
    		break;
    	case WM_PAINT:
    		hdc = BeginPaint(hWnd, &ps);
    		// TODO: Hier den Zeichnungscode hinzufügen.
    		EndPaint(hWnd, &ps);
    		break;
    	case WM_DESTROY:
    		PostQuitMessage(0);
    		break;
    	default:
    		return DefWindowProc(hWnd, message, wParam, lParam);
    	}
    	return 0;
    }
    
    INT_PTR CALLBACK PyroCamAPI(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
    {
    	UNREFERENCED_PARAMETER(lParam);
    	switch (message)
    	{
    	case WM_INITDIALOG:
    		{
    			SetDlgItemText(hDlg,IDC_CALIBFILE,TEXT("PyroCam13272_16_mm_oFi.dat"));
    			SetDlgItemText(hDlg,IDL_PXICONNECT,TEXT("PXI Connection: Off"));
    			SetDlgItemInt(hDlg,IDC_PYROCAMERROR,OK,false);
    			SetDlgItemInt(hDlg,IDC_IMAGEWRITEERROR,OK,false);
    			SetDlgItemInt(hDlg,IDC_CONFIGREADERROR,OK,false);
    			return (INT_PTR)TRUE;
    		}
    		break;
    	case WM_COMMAND:
    		switch(LOWORD(wParam))
    		{
    		case IDC_STARTPYROCAM:
    			{
                                    // hier drinne wird die DLL aufgerufen
    				iPCError = PC_API.StartPyroCam(sCalibFile);
    
    			}
    			break;	
    		case IDM_EXIT:
    			DestroyWindow(hDlg);
    			break;
    		default:
    			{
    				return DefWindowProc(hDlg, message, wParam, lParam);
    			}
    			break;
    		}
    		break;
    	}
    	return (INT_PTR)FALSE;
    }
    
    /*******************************************************************************/
    // Startet die PyroCam
    // kalibriorungsddatei laden
    // framegrabber starten
    // Standartwerte der PyroCam setzten
    /*******************************************************************************/
    int  DLG_PyroCamAPI::StartPyroCam(char* sFileName)
    {
    	int iError;
    
    	// DeviceInitGUI ist eine der Funktionen der DLL
            // hier geht zwar das Fenster auf (Rahmen mit X oben rechts) aber es wird kein inhalt angezeigt
    	iError = PyroCam.DeviceInitGUI();
    
    return iError;
    }
    


  • Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (alle ISO-Standards) in das Forum WinAPI verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • Nicht alle auf einmal 😃 😃 😃

    Scheint, als wäre das Problem doch nicht ganz so offensichtlich, wie ich es anfangs angenommen habe. Oder fehlen noch Informationen? Sollte dies der Fall sein einfach rein schreiben. Ich liefere gerne noch was nach, sollte ich etwas wichtiges unterschlagen haben.

    Ansonsten noch einmal: So hilf mir doch einer. Bitte, bitte. Ich bin gerade total aufgeschmissen, weil ich hier nicht weiter komme. Selbst Vermutungen, in welche Richtung es sich lohnen könnte zu suchen, sind willkommen. Denn ich habe leider wirklich keinen Ansatz für das Problem.


  • Mod

    Wende Dich an den Hersteller...

    Ansonsten ist ein solches Fenster-Problem, dass nicht in den Vordergrund kommen will meistens ein Problem der Parent Window Definition. Da hilft Dir evtl. Spy++

    BTW: Solch eine DLL hat meistens auch eine Doku... 😉


Log in to reply