hmm.. also das ziel meiner klasse ist folgendes:
ich will eine klasse haben die funktionen bietet, mit denen ich einfach ein fenster erstellen kann und einen button.. später erweitere ich das warscheinlich noch.
damit das ganze variabel bleibt, also mal angenommen ich will zu einem fenster ein child fenster haben, hab ich in der klasse die benötigten strukturen und variablen.. aber ich denke code sagt mehr als tausend worte!
zu OOP:
ich bin totaler anfänger +g+
ich würde mich also über tipps und kritik freun.. die muss aber nicht unbedingt unter die gürtellinie gehn! sprich: ich würde gern produktive kritik hören
MAIN.CPP
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
// ###########################################################################
// File: Main.cpp
// Writer: Snooc
// Description: Main
// ###########################################################################
// I N C L U D E S ###########################################################
#include "CWindow.hpp"
// G L O B A L S #############################################################
HWND hwndMainWindow;
HWND hwndButton;
bool run = true;
// P R O T O T Y P E S #######################################################
_w64 long __stdcall WndProc (HWND hwnd, unsigned int msg, unsigned int wParam, _w64 long lParam);
// F U N C T I O N S #########################################################
// M a i n _ F u n c t i o n
int __stdcall WinMain(HINSTANCE instance, HINSTANCE prevInstance, char* cmdLine, int show)
{
CWindow Window(&hwndMainWindow);
Window.WindowClass.lpfnWndProc = WndProc;
Window.WindowProperties.hInstance = instance;
if ( (run = Window.CWindow_Create()) == false )
{ return 0; }
hwndButton = Window.CWindow_CreateButton();
// Update the window
UpdateWindow (hwndMainWindow);
// Object for messages
MSG msg;
// Main-loop (Runs until run == false)
while (run)
{
// Peek message
if (PeekMessage (&msg, NULL, NULL, NULL, PM_REMOVE))
{
// Message for quit?
if (msg.message == WM_QUIT)
run = false;
// Translate and dispatch message
TranslateMessage (&msg);
DispatchMessage (&msg);
}
}
return (static_cast<int>(msg.wParam));
} // WinMain();
// Window procedure for messages
_w64 long __stdcall WndProc (HWND hwnd, unsigned int msg, unsigned int wParam, _w64 long lParam)
// Code d. Nachrichtenschleife ..
return DefWindowProc (hwnd, msg, wParam, lParam);
} // WndProc();
|
CWINDOW.HPP
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
// ###########################################################################
// File: CWindow.hpp
// Writer: Stefan Falk
// Description: Window class header
// ###########################################################################
#if !defined (_CWINDOW_HPP_)
#define _CWINDOW_HPP_
// ###########################################################################
// I N C L U D E S ###########################################################
#include <windows.h>
// D E F I N E S #############################################################
#if defined (NULL)
#undef NULL
#define NULL 0
#endif
// C L A S S #################################################################
class CWindow
{
// P R I V A T E
private:
HWND *m_hwndWindow;
// P U B L I C
public:
// M e m b e r _ S t r u c t s #######################################
// W I N D O W
struct _window_class
{
UINT cbSize;
UINT style;
WNDPROC lpfnWndProc;
int cbClsExtra;
int cbWndExtra;
HINSTANCE hInstance;
HICON hIcon;
HCURSOR hCursor;
HBRUSH hbrBackground;
LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
HICON hIconSm;
}WindowClass; // _window_class
struct _window_properties
{
DWORD dwExStyle;
LPCWSTR lpClassName;
LPCWSTR lpWindowName;
DWORD dwStyle;
int x;
int y;
int nHeight;
HWND hWndParent;
HMENU hMenu;
HINSTANCE hInstance;
LPVOID lpParam;
}WindowProperties; // _window_properties
// B U T T O N
struct _button_properties
{
LPCWSTR lpClassName;
LPCWSTR lpButtonText;
DWORD dwStyle;
int x;
int y;
int nWidth;
int nHeight;
HWND hWndParent;
HMENU hMenu;
HINSTANCE hInstance;
LPVOID lpParam;
}ButtonProperties;
// M e m b e r _ F u n c t i o n s ###################################
CWindow (HWND *hwndWindow); // Constructor
bool CWindow_Create (void);
HWND CWindow_CreateButton (void);
}; // class CWindow
#endif
|
CWINDOW.CPP
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// ###########################################################################
// File: CWindow.cpp
// Writer: Snooc
// Description: Window class definitions
// ###########################################################################
// I N C L U D E S ###########################################################
#include "CWindow.hpp"
// F U N C T I O N S #########################################################
CWindow::CWindow (HWND *hwndWindow)
{
m_hwndWindow = hwndWindow;
// I N I T _ W I N D O W
// Init variables with some standard values
WindowProperties.dwExStyle = NULL;
WindowProperties.lpClassName = L"ClassName";
WindowProperties.lpWindowName = L"WindowName";
WindowProperties.dwStyle = WS_OVERLAPPEDWINDOW;
WindowProperties.x = 100;
WindowProperties.y = 100;
WindowProperties.nWidth = 800;
WindowProperties.nHeight = 600;
WindowProperties.hWndParent = NULL;
WindowProperties.hMenu = NULL;
WindowProperties.hInstance = NULL;
WindowProperties.lpParam = NULL;
// Init the window class with some standard values
WindowClass.cbSize = sizeof(WNDCLASSEX);
WindowClass.style = CS_HREDRAW | CS_VREDRAW;
WindowClass.lpfnWndProc = NULL;
WindowClass.cbClsExtra = NULL;
WindowClass.cbWndExtra = NULL;
WindowClass.hInstance = NULL;
WindowClass.hIcon = NULL;
WindowClass.hCursor = LoadCursor (NULL, IDC_ARROW);
WindowClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
WindowClass.lpszMenuName = NULL;
WindowClass.lpszClassName = L"ClassName";
WindowClass.hIconSm = NULL;
// I N I T _ B U T T O N
ButtonProperties.lpClassName = L"ClassName";
ButtonProperties.lpButtonText = L"ButtonText";
ButtonProperties.dwStyle = WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON;
ButtonProperties.x = 10;
ButtonProperties.y = 10;
ButtonProperties.nWidth = 100;
ButtonProperties.nHeight = 30;
ButtonProperties.hWndParent = *m_hwndWindow;
ButtonProperties.hMenu = NULL;
ButtonProperties.hInstance = NULL;
ButtonProperties.lpParam = NULL;
} // Constructor
bool CWindow::CWindow_Create (void)
{
// Window class
WNDCLASSEX wc;
wc.cbSize = WindowClass.cbSize;
wc.style = WindowClass.style;
wc.lpfnWndProc = WindowClass.lpfnWndProc;
wc.cbClsExtra = WindowClass.cbClsExtra;
wc.cbWndExtra = WindowClass.cbWndExtra;
wc.hInstance = WindowClass.hInstance;
wc.hIcon = WindowClass.hIcon;
wc.hCursor = WindowClass.hCursor;
wc.hbrBackground = WindowClass.hbrBackground;
wc.lpszMenuName = WindowClass.lpszMenuName;
wc.lpszClassName = WindowClass.lpszClassName;
wc.hIconSm = WindowClass.hIconSm;
// Check if window class has a valid pointer to window procedure
if (wc.lpfnWndProc == NULL)
{
MessageBox(NULL, L"No valid pointer to window procedure set.", L"Error",
MB_OK | MB_ICONERROR);
return false;
}
// Register window class
if (!RegisterClassEx(&wc))
{
MessageBox(NULL, L"Registration of window class failed.", L"Error",
MB_OK | MB_ICONERROR);
return false;
}
// Create the window
*m_hwndWindow = CreateWindowEx(
WindowProperties.dwExStyle,
WindowProperties.lpClassName,
WindowProperties.lpWindowName,
WindowProperties.dwStyle,
WindowProperties.x,
WindowProperties.y,
WindowProperties.nWidth,
WindowProperties.nHeight,
WindowProperties.hWndParent,
WindowProperties.hMenu,
WindowProperties.hInstance,
WindowProperties.lpParam
);
// If CreateWindowEx didn't succeed: Quit
if (!m_hwndWindow)
{ return false; }
// Show and update the window
ShowWindow (*m_hwndWindow, SW_SHOW);
UpdateWindow (*m_hwndWindow);
return true;
} // CWindow_Create();
HWND CWindow::CWindow_CreateButton()
{
HWND hwndButton;
hwndButton = CreateWindow(
ButtonProperties.lpClassName,
ButtonProperties.lpButtonText,
ButtonProperties.dwStyle,
ButtonProperties.x,
ButtonProperties.y,
ButtonProperties.nWidth,
ButtonProperties.nHeight,
*m_hwndWindow,
ButtonProperties.hMenu,
ButtonProperties.hInstance,
ButtonProperties.lpParam
);
return hwndButton;
} // CWindow_CreateButton();
|
also eig. will ich die klasse dafür verwenden, dass ich später mit ihr weiter programmieren kann.. also halt ein bischen mit der winapi
die strukturen sind deswegen drin, weil ich mir dachte wenn ich die ganzen sachen als parameter in funktionen übergebe.. werd ich ja jedesmal alt! darum hab ich so gemacht, dass der konstruktor stanardwerte setzt, sodass man eig. nur mehr die nachrichtenschleife angeben muss, und das fenster schon läuft.. und für den fall dass ich was anders haben will, muss ich einfach nur die strukturen ändern, und danach CWindow_Create() ausführen, und mein fenster sieht so aus wie ich will.