GUI und/in Dll

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • GUI und/in Dll

    Hallo Community,

    nachdem mein Problem mit der GUI gelößt wurde, habe ich nun eine einwandfrei funktionierende, hübsche Oberfläche (siehe unten) :)
    Nun, diese Oberfläche würde ich gerne in eine Dll bringen, bzw. mit einer Dll kommunzieren lassen.
    Werte, welche ich auf Knopdruck in der GUI einlese, möchte ich in dieser Dll verarbeiten:

    C-Quellcode

    1. #include <iostream>
    2. #include <windows.h>
    3. #include <detours.h>
    5. BOOL WINAPI DllMain(HINSTANCE hinstDll, DWORD Reason, LPVOID Reserved)
    6. {
    7. switch(Reason)
    8. {
    9. case DLL_PROCESS_ATTACH:
    10. MessageBox(0,L"Attached.",L"Info",0);
    12. // SchreibeWert();
    13. // Funktion, welche einen eingelesenen Wert aus der GUI
    14. // verwendet.
    16. break;
    17. case DLL_PROCESS_DETACH:
    18. MessageBox(0,L"Detached.",L"Info",0);
    19. break;
    20. }
    21. return TRUE;
    22. }
    Alles anzeigen


    Den grünen Bereich würde ich durch eine Funktion oder Quelltext ersetzen, welcher den eingelesenen Wert aus der GUI verwendet.
    Genauso sollte es auch andersrum funktionieren, werte die in der Dll benutzt werden, sollen in der GUI angezigt werden. :)

    Die Dll habe ich zu Testzwecken in den Prozess "Inkball" mit dem Programm "Winject" injeziert. Werte konnte ich aber hier nur durch die Benutzung von Hotkeys verändern.
    Dies möchte ich nun erleichtern indem ich eine Kontrolloberfläche, eine GUI, zur Bedienung hinzuziehe :)

    Meine einfache Oberfläche als Beispiel könnte so aussehen:

    C-Quellcode

    1. #include <windows.h>
    2. #include <stdio.h>
    3. #include <cstdio>
    5. #ifdef _UNICODE
    6. #if defined _M_IX86
    7. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
    8. #elif defined _M_X64
    9. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
    10. #else
    11. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
    12. #endif
    13. #endif
    15. HWND hwndButton;
    16. HWND hwndEdit;
    18. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    20. int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPrI, PSTR szCmdLine, int iCmdShow)
    21. {
    22. LPWSTR szName = L"Fensterklasse";
    23. WNDCLASS wc;
    25. wc.style = CS_HREDRAW | CS_VREDRAW;
    26. wc.lpfnWndProc = WndProc;
    27. wc.cbClsExtra = 0;
    28. wc.cbWndExtra = 0;
    29. wc.hInstance = hI;
    30. wc.hIcon = LoadIcon (NULL,IDI_WINLOGO);
    31. wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    32. wc.hbrBackground = (HBRUSH) GetStockObject(LTGRAY_BRUSH);
    33. //wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    34. wc.lpszMenuName = NULL;
    35. wc.lpszClassName = szName;
    36. RegisterClass(&wc);
    38. HWND hwnd = CreateWindow(szName, L"<Graphical User Interface>", WS_SYSMENU | WS_SIZEBOX,
    39. 0,0,300,200,NULL,NULL,hI,NULL);
    41. ShowWindow(hwnd, iCmdShow);
    42. UpdateWindow(hwnd);
    44. MSG msg;
    45. while(GetMessage(&msg,NULL,0,0))
    46. {
    47. TranslateMessage(&msg);
    48. DispatchMessage(&msg);
    49. }
    51. return msg.wParam;
    52. }
    55. LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
    56. {
    57. HDC hdc;
    58. PAINTSTRUCT ps;
    60. switch(message)
    61. {
    62. case WM_PAINT:
    63. hdc = BeginPaint(hwnd, &ps);
    64. SetBkMode(hdc,TRANSPARENT);
    65. SetTextColor(hdc,RGB(0,0,0));
    67. TextOut(hdc, 20, 20, L"Wert", 4);
    68. EndPaint(hwnd, &ps);
    69. return 0;
    70. case WM_CREATE:
    71. hwndButton = CreateWindow(L"button", L"Einlesen!", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
    72. 160, 20, 100, 18, hwnd, (HMENU)1, GetModuleHandle(0),0);
    74. hwndEdit = CreateWindow(L"edit",L"50", WS_VISIBLE | WS_CHILD,
    75. 60,20,80,17,hwnd,0, GetModuleHandle(0),0);
    76. break;
    77. case WM_COMMAND:
    78. switch(wParam)
    79. {
    80. case 1:
    81. {
    82. wchar_t text[256];
    84. SendMessage(hwndEdit, WM_GETTEXT, 256, (LPARAM)text);
    85. MessageBox(hwnd, text, L"Edit -- Feld", MB_OK);
    87. break;
    88. }
    89. }
    90. break;
    92. case WM_DESTROY:
    93. PostQuitMessage(0);
    95. return 0;
    97. }
    99. return DefWindowProc(hwnd, message, wParam, lParam);
    100. }
    Alles anzeigen


    In dem rot gekennzeichneten Bereich lese ich einen Wert aus einem Edit Feld aus und speichere diesen in der Variable "text".
    Diesen würde ich nun in der Dll verwenden wollen.

    Allerdings bin ich ratlos, wie ich dies anstelle.
    Google hat zwar einige seiten ausgespuckt, jedoch war dies nicht allzu verständlich für mich! :(

    Über hilfreiche Antworten würde ich mich sehr freuen! :)
    Mit freundlichen Grüßen
    Infemo

  • Die Funktion DllMain wird beim laden und entladen der Bibliothek aufgerufen.

    Da du MSVS verwendest, erstell doch dein Bibliothek über den intigrierten Wizzard:
    Datei->Neu->Projekt ---> Visual C++ -> Win32 Projekt ---> DLL -> Fertig
    Dann kriegst du schon in etwa das was du gepostet als Vorlage.

    Nun kannst du hingeghen und eigen Funktionen definieren:

    Quellcode

    1. int Add(int WertA, int WertB) { return WertA + WertB; }

    Um diese in deinem Hauptprogramm verwenden zu können muss diese als "Exportiert" markiert werden:

    Quellcode

    1. __declspec(dllexport) int Add(int WertA, int WertB) { return WertA + WertB; }

    Wenn du nun die Bibliothek compilerst (Release) kriegst du zwei Dateien BibName.dll und BibName.lib.

    Diese zweite Datei BibName.lib musst du in deinem Hauptprojekt linken, unter MSVS am einfachsten mit:

    Quellcode

    1. #pragma comment(lib, "Pfad/BibName.lib")

    Nun brauchst du nur noch den Prototyp der Funktion zu definieren und zu "importieren":

    Quellcode

    1. __declspec(dllimport) int Add(int WertA, int WertB);

    Und schliesslich kannst du die Funktion benutzen:

    Quellcode

    1. int Sum = Add(4,5);

    Anbei: Fortgeschritten arbeiten da, zur besseren Codeübersicht, jedoch in der Praxis mit Macros

    PS: Sorg Bitte dafür das dein anderer (gleicher) Thread doch entfernt/gelöscht wird.

    Mfg Rushh0ur

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Rushh0ur ()

  • Hallo Rushh0ur,

    vielen Dank für deine so umfang- und hilfreiche Antwort=)
    Entschuldige meine späte Antwort, jedoch war ich in den letzten Tage ziemlich eingesapnnt :/

    Also erstelle ich ein Projekt namen "Probe", so wie Sie es gesagt haben, bekomme ich zwei Header Dateien, zum einen eine stdafx.h und eine targetver.h.
    Die Quelldateien sind dllmain.cpp, Probe.cpp und stdafx.cpp.

    Compiliere ich dies ohne irgenetwas zu verändern bekomme ich eine Probe.dll, eine Probe.ilk und eine Probe.pdb.
    Mit letzteren weis ich nichts anzufangen.

    Allerdings fehlt hier weiterhin jede Spur einer GUI...muss ich dieses als neue Quelldatei hinzufügen?
    Da ich neu im Forum bin, weis ich leider nicht wie ich dies löschen kann, allerdings habe ich das Thema als "Erledigt" markiert =)

    Ich würde mich sehr über weitere Hilfestellungen freuen und bedanke mich nochmal bei Ihnen! :)

    Mit freundlichen Grüßen
    Infemo

  • Die lib wird nur erstellt wenn auch Funktionen exportiert werden.

    Ich hab dich etwas Falsch verstanden, das obige beschriebt wie du Funktionen einer DLL in deiner eigenen EXE verwenden kannst.

    Da du jedoch die DLL in einer anderen EXE, vom Code her dir unbekannt, ladest/injectes steht dir nur die DllMain funktion zur verfügung.
    Um nun dein Formular anzuzeigen musst du deinen Code in einem neuen Thread ausführen:

    Quellcode

    1. #include "stdafx.h"
    2. #include "mylib.h"
    4. // Thread Handle (Identifikation)
    5. HANDLE hThread = NULL;
    7. // Eigene Threadroutin (Eigenes WinMain als Protyp in mylib.h definiert)
    8. DWORD APIENTRY MyThreadRoutine(LPVOID lpThreadParameter)
    9. {
    10. WinMain((HINSTANCE)lpThreadParameter, NULL, NULL, SW_SHOW);
    11. return 0;
    12. }
    14. // Dll Einstiegspunkt
    15. BOOL APIENTRY DllMain( HMODULE hModule,
    16. DWORD ul_reason_for_call,
    17. LPVOID lpReserved
    18. )
    19. {
    20. switch (ul_reason_for_call)
    21. {
    22. case DLL_PROCESS_ATTACH:
    23. // Thread erstellen
    24. DWORD idThread;
    25. hThread = CreateThread(NULL, NULL, &MyThreadRoutine, (LPVOID)hModule, 0, &idThread);
    26. break;
    27. case DLL_PROCESS_DETACH:
    28. // Eigenen Thread Terminieren, unschoen jedoch gits es keine andere Möglichkeit
    29. TerminateThread(hThread, -1);
    30. CloseHandle(hThread);
    31. break;
    32. }
    33. return TRUE;
    34. }
    Alles anzeigen


    Mfg Rushh0ur

  • Die lib wird nur erstellt wenn auch Funktionen exportiert werden.
    Achso, okay.
    Ich hab dich etwas Falsch verstanden, das obige beschriebt wie du Funktionen einer DLL in deiner eigenen EXE verwenden kannst.
    Also zum teil möchte ich beides machen ;) 'Allerdings weniger Funktionen in meiner Exe Datei, sondern einfach nur Variablen in meiner Exe. Würde dies denn genaus so funktionieren, oder geht dies anders ?
    Da du jedoch die DLL in einer anderen EXE, vom Code her dir unbekannt, ladest/injectes steht dir nur die DllMain funktion zur verfügung.
    Um nun dein Formular anzuzeigen musst du deinen Code in einem neuen Thread ausführen

    Das heißt, dass ich in diesem Beispiel in die mylib.h die gesamte GUI packen müsste, damit ich ein Fenster habe, mit dem ich eingelesene Werte aus der GUI an die Dll übetragen kann?

    C-Quellcode

    1. #include <windows.h>
    2. #include <stdio.h>
    3. #include <cstdio>
    5. #ifdef _UNICODE
    6. #if defined _M_IX86
    7. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
    8. #elif defined _M_X64
    9. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
    10. #else
    11. #pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
    12. #endif
    13. #endif
    15. HWND hwndButton;
    16. HWND hwndEdit;
    18. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    20. int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPrI, PSTR szCmdLine, int iCmdShow)
    21. {
    22. LPWSTR szName = L"Fensterklasse";
    23. WNDCLASS wc;
    25. wc.style = CS_HREDRAW | CS_VREDRAW;
    26. wc.lpfnWndProc = WndProc;
    27. wc.cbClsExtra = 0;
    28. wc.cbWndExtra = 0;
    29. wc.hInstance = hI;
    30. wc.hIcon = LoadIcon (NULL,IDI_WINLOGO);
    31. wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    32. wc.hbrBackground = (HBRUSH) GetStockObject(LTGRAY_BRUSH);
    33. //wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    34. wc.lpszMenuName = NULL;
    35. wc.lpszClassName = szName;
    36. RegisterClass(&wc);
    38. HWND hwnd = CreateWindow(szName, L"<Graphical User Interface>", WS_SYSMENU | WS_SIZEBOX,
    39. 0,0,300,200,NULL,NULL,hI,NULL);
    41. ShowWindow(hwnd, iCmdShow);
    42. UpdateWindow(hwnd);
    44. MSG msg;
    45. while(GetMessage(&msg,NULL,0,0))
    46. {
    47. TranslateMessage(&msg);
    48. DispatchMessage(&msg);
    49. }
    51. return msg.wParam;
    52. }
    55. LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
    56. {
    57. HDC hdc;
    58. PAINTSTRUCT ps;
    60. switch(message)
    61. {
    62. case WM_PAINT:
    63. hdc = BeginPaint(hwnd, &ps);
    64. SetBkMode(hdc,TRANSPARENT);
    65. SetTextColor(hdc,RGB(0,0,0));
    67. TextOut(hdc, 20, 20, L"Wert", 4);
    68. EndPaint(hwnd, &ps);
    69. return 0;
    70. case WM_CREATE:
    71. hwndButton = CreateWindow(L"button", L"Einlesen!", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON,
    72. 160, 20, 100, 18, hwnd, (HMENU)1, GetModuleHandle(0),0);
    74. hwndEdit = CreateWindow(L"edit",L"50", WS_VISIBLE | WS_CHILD,
    75. 60,20,80,17,hwnd,0, GetModuleHandle(0),0);
    76. break;
    77. case WM_COMMAND:
    78. switch(wParam)
    79. {
    80. case 1:
    81. {
    82. wchar_t text[256];
    84. SendMessage(hwndEdit, WM_GETTEXT, 256, (LPARAM)text);
    85. MessageBox(hwnd, text, L"Edit -- Feld", MB_OK);
    87. break;
    88. }
    89. }
    90. break;
    92. case WM_DESTROY:
    93. PostQuitMessage(0);
    95. return 0;
    97. }
    99. return DefWindowProc(hwnd, message, wParam, lParam);
    100. }
    Alles anzeigen


    Vielen Dank! Ich hoffe auf weitere Hilfeleistung :)

    Liebe Grüße
    Infemo


  • Das heißt, dass ich in diesem Beispiel in die mylib.h die gesamte GUI packen müsste, damit ich ein Fenster habe, mit dem ich eingelesene Werte aus der GUI an die Dll übetragen kann?

    Kurz gesagt ja (jedoch eher in die cpp-Datei), insofern sich das Formular nicht in der Zielanwendung anderweitig schon vorhanden ist, dann kann therotisch natürlich auch das Formular der Zielanwendung verwendet werden.

    Mfg Rushh0ur