1   窗体注冊和创建

1.1WIN32 窗体程序创建步骤

1、WinMain入口函数的定义

2、WindowProc函数的定义

3、注冊窗体类

RegisterClass、RegisterClassEX

4、创建窗体

CreateWindow、CreateWindowEx

HWND CreateWindow(

LPCTSTRlpClassName,//指向已注冊的窗体类的名称的指针

LPCTSTRlpWindowName,//指向窗体名称的指针

DWORDdwStyle,//窗体的风格

intx,//窗体位置的X坐标

inty,//窗体位置的Y坐标

intnWidth,//窗体的宽度

intnHeight,//窗体的高度

HWNDhWndParent,//父窗体的句柄

HMENUhMenu,//窗体菜单句柄

HINSTANCEhInstance,//应用程序使用句柄

LPVOIDlpParam//应用程序数据区句柄

);

參数：

lpClassName

一个指向以零结尾的字符串的指针。或者指向曾经由RegisterClass或RegisterClassEx条用创建的原子的指针。这个原子必须是次參数的低位。高位必须是0。假设是一个字符串，它指定窗体类的名称。类名能够是用RegisterClass或RegisterClassEx注冊过的不论什么名称。providedthat themodule that registers the class is also the module thatcreates the window.类名称也能够是不论什么提前定义的系统类名称。

lpWindowName

指向指定窗体名称的以零结尾的字符串的指针。

假设窗体的风格指定了一个标题栏，则它将会显示在标题栏上。当使用CreateWindow创建控件时，此參数指定控件的文字。当用SS_ICON风格创建static控件时。此參数指定图标的名称或者标识符。要指定一个标识符。使用”#num”语法。

dwStyle

指定要创建窗体的风格。

能够是窗体风格的组合，加上控件的风格的组合。

x

指定窗体的初始水平位置。

对于overlapped或者弹出式窗体。x參数是初始的x坐标相当窗体的左上角，在屏幕坐标系上。Fora childwindow, x is the x-coordinate of the upper-left corner ofthe window relative tothe upper-left corner of the parent window'sclientarea.假设參数值被设置为CW_USEDEFAULT，系统为窗体左上角选择默认的位置并忽略y參数。CW_USEDEFAULT仅对overlapped窗体有效，假设它在弹出窗体或者自窗体上被指定。则x和y參数被设置为零。

y

指定窗体的初始化垂直位置。

对于交叠式窗体或者弹出式窗体，y參数是在屏幕坐标上初始的窗体左上角的y坐标。

对于子窗体。y是和父窗体客户区左上角相关的初始子窗体左上角的y坐标。

对于listbox控件。y是和父窗体客户区左上角相关的listbox客户区初始的左上角的y坐标。

假设用WS_VISIBLE风格创建一个overlapped窗体而且x參数设置为CW_USEDEFAULT，系统忽略y參数。

nWidth

用设备单位指定窗体的宽度。对于overlapped窗体，nWidth參数既能够是在屏幕坐标上窗体的宽度。也能够是CW_USEDEFAULT.假设nWidth是CW_USEDEFAULT，系统选择一个默认的宽度和高度。这个默认的宽度从初始的x坐标到屏幕的右边缘。默认的高度从y坐标到图标区的顶端。

CW_USEDEFAULT仅对overlapped窗体可用，假设对子窗体或者弹出窗体设置了CW_USEDEFAULT，则nWidth和nHeight被设置为0。

nHeight

指定窗体的高度用设备单位。

对于overlapped窗体，nHeight是在屏幕坐标上窗体的高度。

假设nWidth被设置为CW_USEDEFAULT,系统忽略nHeight。

hWndParent

指向被创建窗体的父窗体或者全部者窗体的句柄。要创建一个子窗体或者一个被全部的窗体，提供一个有效的窗体句柄。

这个參数对于弹出式窗体是可选的。

hMenu

菜单句柄，或者指定一个依靠窗体风格的子窗体标识符。

对于overlapped窗体或者弹出式窗体，hMenu识别窗体要使用的菜单。能够是NULL假设使用类的菜单。对于子窗体。hMenu指定自窗体的标识符，一个用来通知父窗体对话框控件的事件的整数。程序决定子窗体的标识，他对于同样父窗体的全部子窗体必须是唯一的。

hInstance

Windows95/98/Me: 和这个窗体有关系的模块的实例句柄。

WindowsNT/2000/XP: 此值被忽略。

lpParam

[in]Pointer to a value to be passed to the window through theCREATESTRUCT structurepassed in the lpParam parameter theWM_CREATE message. 假设一个程序通过调用CreateWindow创建多文档界面的客户窗体。

lpParam必须指向一个CLIENTCREATESTRUCT结构。

5、窗体的显示和刷新

ShowWindow、 UpdateWindow

6、消息处理

GetMessage、 DispatchMessage

7、窗体退出

WM_DESTROY、

1.2窗体的注冊

1.2.1窗体类的分类

1、  系统全局窗体类，比方按钮（BUTTOn），文本编辑框（EDITed）等

2、  应用程序的全局窗体类。能够在一个应用程序中EXE、DLL等全部模块中使用的窗体类。

3、  局部窗体类。

仅仅能在本模块中使用的窗体类。

1.2.2实现窗体类的注冊

1、  系统全局的窗体类。无需注冊直接使用

使用CreateWindow函数，在CLASSNAME中指定系统已经定义好的窗体类型名称就可以。

以下创建一个BUtton或者EDIt窗体

  1. /*File : botton.cpp
  2.  *Auth : sjin
  3.  *Date : 20140618
  4.  *Mail : 413977243@qq.com
  5.  */
  6.  
  7. /*窗体的创建的练习*/
  8.  
  9. #include <Windows.h>
  10. #include <WinNT.h>
  11.  
  12. HINSTANCE g_hInst = NULL; 
  13.  
  14. /*窗体处理函数*/
  15. LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM wParam,LPARAM iParam)
  16. {
  17. 	return DefWindowProc(hWnd,nMsg,wParam,iParam);
  18. }
  19.  
  20. /*创建BUTTON*/
  21. HWND CreateButton()
  22. {
  23.  
  24. 	/*BUTTOn */
  25. #if 0
  26. 	HWND hWnd = CreateWindow(
  27. 		"BUTTON","My first button test",
  28. 		WS_OVERLAPPEDWINDOW,0,0,100,150,
  29. 		NULL,NULL,g_hInst,NULL);
  30. #else
  31. 	HWND hWnd = CreateWindow(
  32. 		"EDIT","My first button test",
  33. 		WS_OVERLAPPEDWINDOW,0,0,100,150,
  34. 		NULL,NULL,g_hInst,NULL);
  35. #endif
  36. 	return hWnd;
  37. }
  38.  
  39. /*注冊*/
  40.  
  41. BOOL RegisterWnd(LPSTR pszClassName)
  42. {
  43. 	WNDCLASSEX hWnd = {'\0'};
  44.  
  45. 	hWnd.cbSize = sizeof(hWnd);
  46. 	hWnd.style  = CS_VREDRAW | CS_HREDRAW;
  47. 	hWnd.lpfnWndProc = WndProc;
  48. 	hWnd.cbClsExtra = 0;
  49. 	hWnd.cbWndExtra = 0;
  50. 	hWnd.hCursor = NULL;
  51. 	hWnd.hIcon = NULL;
  52. 	hWnd.hbrBackground = HBRUSH(COLOR_BTNFACE +1);
  53. 	hWnd.lpszClassName = pszClassName;
  54. 	hWnd.hInstance = g_hInst;
  55.  
  56. 	ATOM  nAtom = RegisterClassEx(&hWnd);
  57.  
  58. 	if( 0 == nAtom) {
  59. 		return FALSE;
  60. 	}
  61. 	return TRUE;
  62.  
  63. }
  64.  
  65. /*显示窗体*/
  66.  
  67. void DisplayButton(HWND hwnd)
  68. {
  69. 	ShowWindow(hwnd,SW_SHOW);
  70. 	UpdateWindow(hwnd);
  71. }
  72.  
  73. void Message()
  74. {
  75. 	MSG msg = {0};
  76.  
  77. 	while(GetMessage(&msg,NULL,0,0)){
  78. 		/*文本框可输入*/
  79. 		TranslateMessage(&msg);
  80. 		DispatchMessage(&msg);
  81. 	}
  82. }
  83.  
  84. /*入口函数*/
  85. int WINAPI WinMain(HINSTANCE hInst,
  86. 				HINSTANCE  hPrevInst,
  87. 				LPSTR  pszCmcLine,
  88. 				int nShowCmd)
  89. {
  90. 	g_hInst = hInst;
  91.  
  92. 	HWND hwnd = CreateButton();
  93.  
  94. 	RegisterWnd("");
  95. 	DisplayButton(hwnd);
  96.  
  97. 	Message();
  98. 	return 0;
  99. }

2、  应用程序全局窗体类，须要用代码实现注冊。在注冊时须要添加CS_CLOBALCLASS（各个模块中都能够使用的）定义的实现方式：

WNDCLASS wc = {'\0'};

wc.style          = CS_CLOBALCLASS |CS_HREARAW;

RegisterClass(&wc);

以下的样例基本都是一样的

3、  局部窗体类。不是添加CS_CLOBALCLASS定义

使用RegisterClass、RegisterClassEX来注冊

  1. /*File : winreg.cpp
  2.  *Auth : sjin
  3.  *Date : 20140619
  4.  *Mail : 413977243@qq.com
  5.  */
  6.  
  7. /*窗体的创建的练习*/
  8.  
  9. #include <Windows.h>
  10. #include <WinNT.h>
  11.  
  12. HINSTANCE g_hInst = NULL; 
  13.  
  14. /*窗体处理函数*/
  15. LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM wParam,LPARAM iParam)
  16. {
  17. 	return DefWindowProc(hWnd,nMsg,wParam,iParam);
  18. }
  19.  
  20. /*创建window*/
  21. HWND Createwindow(LPSTR pszClassName)
  22. {
  23.  
  24. 	HWND hWnd = CreateWindow(
  25. 		pszClassName,"My first wondow test",
  26. 		WS_OVERLAPPEDWINDOW,0,0,100,150,
  27. 		NULL,NULL,g_hInst,NULL);
  28. 	return hWnd;
  29. }
  30.  
  31. /*注冊*/
  32.  
  33. BOOL RegisterWnd(LPSTR pszClassName)
  34. {
  35. 	WNDCLASSEX hWnd = {'\0'};
  36.  
  37. 	hWnd.cbSize = sizeof(hWnd);
  38. 	hWnd.style  = CS_VREDRAW | CS_HREDRAW;
  39. 	hWnd.lpfnWndProc = WndProc;
  40. 	hWnd.cbClsExtra = 0;
  41. 	hWnd.cbWndExtra = 0;
  42. 	hWnd.hCursor = NULL;
  43. 	hWnd.hIcon = NULL;
  44. 	hWnd.hbrBackground = HBRUSH(COLOR_BTNFACE +1);
  45. 	hWnd.lpszClassName = pszClassName;
  46. 	hWnd.hInstance = g_hInst;
  47.  
  48. 	ATOM  nAtom = RegisterClassEx(&hWnd);
  49.  
  50. 	if( 0 == nAtom) {
  51. 		return FALSE;
  52. 	}
  53. 	return TRUE;
  54.  
  55. }
  56.  
  57. /*显示窗体*/
  58.  
  59. void DisplayWnd(HWND hwnd)
  60. {
  61. 	ShowWindow(hwnd,SW_SHOW);
  62. 	UpdateWindow(hwnd);
  63. }
  64.  
  65. void Message()
  66. {
  67. 	MSG msg = {0};
  68.  
  69. 	while(GetMessage(&msg,NULL,0,0)){
  70. 		/*文本框可输入*/
  71. 		TranslateMessage(&msg);
  72. 		DispatchMessage(&msg);
  73. 	}
  74. }
  75.  
  76. /*入口函数*/
  77. int WINAPI WinMain(HINSTANCE hInst,
  78. 				HINSTANCE  hPrevInst,
  79. 				LPSTR  pszCmcLine,
  80. 				int nShowCmd)
  81. {
  82. 	g_hInst = hInst;
  83.  
  84. 	RegisterWnd("MYWIN");
  85.  
  86. 	HWND hwnd = Createwindow("MYWIN");
  87.  
  88. 	DisplayWnd(hwnd);
  89.  
  90. 	Message();
  91. 	return 0;
  92. }

注:上面程序中存在一个问题。就是程序关闭后，并没有全然退出，还在后台执行。问了解决问题，须要在窗体处理函数做以下的改动:

  1. /*窗体处理函数*/
  2. LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM wParam,LPARAM iParam)
  3. {
  4. 	switch(nMsg){
  5. 	case WM_DESTROY:
  6. 		/*添加这个程序能够正常的退出*/
  7. 		PostQuitMessage(0);
  8. 		break;
  9. 	}
  10. 	return DefWindowProc(hWnd,nMsg,wParam,iParam);
  11. }

1.1.1窗体类风格

CS_HREDRAW 窗体水平变化，又一次绘制窗体。

CS_VREDRAW 窗体垂直变化。又一次绘制窗体。

CS_DBCLICK 窗体能够接收鼠标双击消息

CS_GLOBALCLASS 创建应用程序全局窗体类。

CS_BYTEALIGNWINDOW 窗体对齐方式,以8的倍数对齐

CS_BYTEALIGNCLIENT 窗体客户区对齐方式,以8的倍数对齐

CS_CLASSDC 全部这样的类型的窗体使用同一个DC(设备描写叙述表,画图使用)

CS_OWNDC 每一个窗体拥有自己的DC

CS_PARENTDC 使用父窗体的DC

CS_SAVEBITS是用位图保存窗体界面,能够提高窗体界面的刷新性能CS_NOCLOSE 禁止关闭命令

1.1.2窗体类的附加数据 cbClsExtra

在窗体类的数据信息中能够加入自己的信息

cbClsExtra 用于加入信息的内存的大小。

SetClassLong 将信息保存到内存中

GetClassLong 将信息从内存中取出

1.1.3窗体附加数据cbWndExtra

在窗体的数据信息中能够加入自己的信息

cbWndExtra 用于加入信息的内存的大小。

SetWindowLong 将信息保存到内存中

GetWindowLong 将信息从内存中取出

以下代码演示样例：

  1. /*File : winreg.cpp
  2.  *Auth : sjin
  3.  *Date : 20140619
  4.  *Mail : 413977243@qq.com
  5.  */
  6.  
  7. /*窗体的创建的练习*/
  8.  
  9. #include <Windows.h>
  10. #include <WinNT.h>
  11. #include <stdio.h>
  12.  
  13. HINSTANCE g_hInst = NULL; 
  14.  
  15. /*窗体处理函数*/
  16. LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM wParam,LPARAM iParam)
  17. {
  18. 	switch(nMsg){
  19. 	case WM_DESTROY:
  20. 		/*添加这个程序能够正常的退出*/
  21. 		PostQuitMessage(0);
  22. 		break;
  23. 	}
  24. 	return DefWindowProc(hWnd,nMsg,wParam,iParam);
  25. }
  26.  
  27. /*创建window*/
  28. HWND Createwindow(LPSTR pszClassName)
  29. {
  30.  
  31. 	HWND hWnd = CreateWindow(
  32. 		pszClassName,"My first wondow test",
  33. 		WS_OVERLAPPEDWINDOW,0,0,100,150,
  34. 		NULL,NULL,g_hInst,NULL);
  35. 	return hWnd;
  36. }
  37.  
  38. /*注冊*/
  39.  
  40. BOOL RegisterWnd(LPSTR pszClassName)
  41. {
  42. 	WNDCLASSEX hWnd = {'\0'};
  43.  
  44. 	hWnd.cbSize = sizeof(hWnd);
  45. 	/*
  46.      *
  47.      *CS_HREDRAW 窗体水平变化。又一次绘制窗体。
  48.      *CS_VREDRAW 窗体垂直变化。又一次绘制窗体。
  49.  
  50. *CS_DBCLICK 窗体能够接收鼠标双击消息
  51.      *CS_GLOBALCLASS 创建应用程序全局窗体类。
  52.      *CS_BYTEALIGNWINDOW 窗体对齐方式,以8的倍数对齐
  53.      *CS_BYTEALIGNCLIENT 窗体客户区对齐方式,以8的倍数对齐
  54.      *CS_CLASSDC 全部这样的类型的窗体使用同一个DC(设备描写叙述表,画图使用)
  55. 	 *CS_OWNDC 每一个窗体拥有自己的DC
  56.      *CS_PARENTDC 使用父窗体的DC
  57.      *CS_SAVEBITS 是用位图保存窗体界面,能够提高窗体界面的刷新性能
  58.      *CS_NOCLOSE 禁止关闭命令.
  59. 	 */
  60. 	hWnd.style  = CS_VREDRAW | CS_HREDRAW;
  61. 	hWnd.lpfnWndProc = WndProc;
  62. 	hWnd.cbClsExtra = 100;
  63. 	hWnd.cbWndExtra = 100;
  64. 	hWnd.hCursor = NULL;
  65. 	hWnd.hIcon = NULL;
  66. 	hWnd.hbrBackground = HBRUSH(COLOR_BTNFACE +1);
  67. 	hWnd.lpszClassName = pszClassName;
  68. 	hWnd.hInstance = g_hInst;
  69.  
  70. 	ATOM  nAtom = RegisterClassEx(&hWnd);
  71.  
  72. 	if( 0 == nAtom) {
  73. 		return FALSE;
  74. 	}
  75. 	return TRUE;
  76.  
  77. }
  78.  
  79. /*显示窗体*/
  80.  
  81. void DisplayWnd(HWND hwnd)
  82. {
  83. 	ShowWindow(hwnd,SW_SHOW);
  84. 	UpdateWindow(hwnd);
  85. }
  86.  
  87. void Message()
  88. {
  89. 	MSG msg = {0};
  90.  
  91. 	while(GetMessage(&msg,NULL,0,0)){
  92. 		/*文本框可输入*/
  93. 		TranslateMessage(&msg);
  94. 		DispatchMessage(&msg);
  95. 	}
  96. }
  97.  
  98. /*设置附加数据*/
  99. void SetExtra(HWND hWnd)
  100. {
  101. 	SetClassLong(hWnd,1,100);
  102. 	SetWindowLong(hWnd,1,200);
  103. }
  104.  
  105. /*获取附加数据*/
  106. void GetExtra(HWND hWnd)
  107. {
  108. 	DWORD nClass = GetClassLong(hWnd,1);
  109. 	DWORD nWnd =  GetWindowLong(hWnd,1);
  110.  
  111. 	char szText[256]= {0};
  112. 	sprintf(szText,"CLS:%d WND:%d",nClass,nWnd);
  113. 	MessageBox(NULL,szText,"EXTRA",MB_OK);
  114. }
  115. /*入口函数*/
  116. int WINAPI WinMain(HINSTANCE hInst,
  117. 				HINSTANCE  hPrevInst,
  118. 				LPSTR  pszCmcLine,
  119. 				int nShowCmd)
  120. {
  121. 	g_hInst = hInst;
  122.  
  123. 	RegisterWnd("MYWIN");
  124.  
  125. 	HWND hwnd = Createwindow("MYWIN");
  126. 	HWND hwnd2 = Createwindow("MYWIN");
  127. 	SetExtra(hwnd);
  128. 	GetExtra(hwnd);
  129. 	GetExtra(hwnd2);
  130.  
  131. 	DisplayWnd(hwnd);
  132.  
  133. 	Message();
  134. 	return 0;
  135. }

1.1创建窗体

1.1.1窗体创建函数

CreateWindow/CreateWindowEx

HWND CreateWindowEx(

DWORD dwExStyle,//窗体的扩展样式

LPCTSTR lpClassName,  // pointer to registered class name

LPCTSTR lpWindowName, //pointer to window name

DWORD dwStyle,        // window style

int x,                // horizontal position ofwindow

int y,                // vertical position of window

int nWidth,           // window width

int nHeight,          // window height

HWND hWndParent,      // handle to parent or owner window

HMENU hMenu,          // handle to menu, or child-windowidentifier

HINSTANCE hInstance,  // handle to application instance

LPVOID lpParam );     // pointer to window-creation data

1.1.2窗体的风格及扩展风格

窗体风格: WS_XXXX定义的风格,是窗体的基本风格.

扩展风格:WS_EX_XXXXX 定义的风格,是窗体的扩展风格.比方: ToolWindow窗体等等。

在CreateWindow能够使用基本窗体风格,扩展的窗体风格,须要使用CreateWindowEx设置.    
 WS_OVERLAPPED窗体,层叠式窗体
   WS_POPUP窗体,弹出式窗体
   WS_CHILD窗体,子窗体

1.1.3子窗体和父窗体

CreateWindow时,指定父窗体

将窗体的风格添加WS_CHILD

能够使用SetParent和GetParent函数设置和获取指定窗体的父窗体.

其它: MoveWindow 移动窗体

以下是关于父子窗体的演示样例

  1. /* File : createWindow.cpp
  2.  * Auth : sjin
  3.  * Date : 20140623
  4.  * Mail : 413977243@qq.com
  5.  */
  6.  
  7. #include <Windows.h>
  8. #include <stdio.h>
  9.  
  10. HINSTANCE g_hInst = NULL;
  11.  
  12. /*父窗体处理函数*/
  13. LRESULT CALLBACK WndProc(HWND hWnd, UINT nMsg,
  14.                          WPARAM wParam, LPARAM lParam)
  15. {
  16.     switch(nMsg) {
  17.     case WM_DESTROY:
  18. 		PostQuitMessage(0);
  19.         return 0;
  20.     }
  21.     return DefWindowProc(hWnd, nMsg, wParam, lParam);
  22. }
  23.  
  24. /*子窗体处理函数*/
  25. LRESULT CALLBACK ChildProc(HWND hWnd, UINT nMsg,
  26.                          WPARAM wParam, LPARAM lParam)
  27. {
  28.     return DefWindowProc(hWnd, nMsg, wParam, lParam);
  29. }
  30.  
  31. /*注冊窗体*/
  32. BOOL RegisterWnd(LPSTR pszClassName,WNDPROC proc,int nBrush)
  33. {
  34.     WNDCLASSEX wce = {0};
  35.     wce.cbSize = sizeof(wce);
  36.     wce.style = CS_VREDRAW|CS_HREDRAW;
  37.     wce.lpfnWndProc = proc;
  38.     wce.cbClsExtra = 100;
  39.     wce.cbWndExtra = 100;
  40.     wce.hCursor = NULL;
  41.     wce.hIcon = NULL;
  42.     wce.hbrBackground = HBRUSH(nBrush);
  43.     wce.lpszClassName = pszClassName;
  44.     wce.lpszMenuName = NULL;
  45.     wce.hInstance = g_hInst;
  46.     ATOM nAtom = RegisterClassEx(&wce);
  47.     if(0 == nAtom)
  48.     {
  49.         MessageBox(NULL, "registerError", "Error", MB_OK);
  50.         return FALSE;
  51.     }
  52.     return TRUE;
  53. }
  54.  
  55. /*创建窗体*/
  56. HWND CreateWnd(LPSTR pszClassName,HWND hParent,DWORD dwStyle)
  57. {
  58. 	HWND hWnd = CreateWindowEx(
  59. 		0,                    /*窗体扩展风格*/
  60. 		//WS_EX_TOOLWINDOW,   /*没有扩大和隐藏按钮*/
  61. 		//WS_EX_CLIENTEDGE | WS_EX_CONTEXTHELP,
  62. 		//WS_EX_PALETTEWINDOW,/**/
  63. 		pszClassName,
  64.         "My Wnd",
  65. 		dwStyle,
  66. 		CW_USEDEFAULT,
  67. 		CW_USEDEFAULT,
  68. 		CW_USEDEFAULT,
  69. 		CW_USEDEFAULT,
  70.         hParent, NULL, g_hInst, NULL);
  71.  
  72.     return hWnd;
  73. }
  74.  
  75. /*显示窗体*/
  76. void DisplayWnd(HWND hWnd)
  77. {
  78.     ShowWindow(hWnd, SW_SHOW);
  79.     UpdateWindow(hWnd);
  80. }
  81.  
  82. /*消息*/
  83. void Message()
  84. {
  85.     MSG msg = {0};
  86.     while(GetMessage(&msg, NULL, 0, 0))
  87.     {
  88.         TranslateMessage(&msg);
  89.         DispatchMessage(&msg);
  90.     }
  91. }
  92.  
  93. int WINAPI WinMain(HINSTANCE hInst,
  94.                    HINSTANCE hPrevInt,
  95.                    LPSTR lpCmdLine,
  96.                    int nShowCmd)
  97. {
  98.     g_hInst = hInst;
  99.  
  100. 	/*注冊父窗体*/
  101. 	RegisterWnd("parent",WndProc,COLOR_BTNFACE + 1);
  102.  
  103. 	 /*注冊子窗体*/
  104. 	RegisterWnd("Child",ChildProc,COLOR_WINDOW);
  105. 	/*注冊子窗体*/
  106. 	RegisterWnd("Child1",ChildProc,COLOR_WINDOW);
  107.  
  108. 	/*创建父窗体
  109. 	 * 注意 窗体类的名称必须和注冊时的名字一样。否则显示不了窗体
  110. 	 */
  111. 	HWND hMyWnd1 = CreateWnd("parent",NULL,WS_OVERLAPPEDWINDOW);
  112.  
  113. 	/*创建子窗体*/
  114. 	HWND hChild = CreateWnd("Child",hMyWnd1,WS_CHILD| WS_VISIBLE|WS_BORDER|WS_THICKFRAME|WS_CAPTION|WS_SYSMENU);
  115. 	HWND hChild1 = CreateWnd("Child1",hMyWnd1,WS_CHILD| WS_VISIBLE|WS_BORDER|WS_THICKFRAME|WS_CAPTION|WS_SYSMENU);
  116.  
  117. 	/*移动窗体*/
  118. 	MoveWindow(hChild,100,100,100,100,TRUE);
  119. 	/*移动窗体*/
  120. 	MoveWindow(hChild1,100,200,100,100,TRUE);
  121.  
  122.     DisplayWnd(hMyWnd1);
  123.  
  124.     Message();
  125.  
  126.     return 0;
  127. }

MDI 窗体创建

  1. /* File : mdiWindows.c
  2.  * Auth : sjin
  3.  * Date : 20140625
  4.  * Mail : 413977243@qq.com
  5.  */
  6.  
  7. #include <Windows.h>
  8. #include <stdio.h>
  9.  
  10. HINSTANCE g_hInst = NULL;
  11. HWND g_hMDIClient = NULL;
  12.  
  13. /*主窗体处理函数*/
  14. LRESULT CALLBACK MainProc(HWND hWnd,
  15. 	UINT nMsg,
  16. 	WPARAM wParam,
  17. 	LPARAM lParam)
  18. {
  19. 	switch(nMsg){
  20. 	case WM_DESTROY:
  21.  
  22. 		PostQuitMessage(0);
  23. 		return 0;
  24. 	}
  25. 	return DefFrameProc(hWnd,g_hMDIClient,nMsg,wParam,lParam);
  26. }
  27.  
  28. /*子窗体处理函数*/
  29. LRESULT CALLBACK ChildProc(HWND hWnd,
  30. 							UINT nMsg,
  31. 							WPARAM wParam,
  32. 							LPARAM lParam)
  33. {
  34.  
  35. 	return DefMDIChildProc(hWnd,nMsg,wParam,lParam);
  36. }
  37.  
  38. /*窗体注冊函数*/
  39. BOOL RegisterWnd(LPSTR pszClassname,
  40. 				WNDPROC Proc,
  41. 				int nBrush)
  42. {
  43. 	WNDCLASSEX wce = {0};
  44.  
  45.     wce.cbSize = sizeof(wce);
  46.     wce.style = CS_VREDRAW|CS_HREDRAW;
  47.     wce.lpfnWndProc = Proc;
  48.     wce.cbClsExtra = 100;
  49.     wce.cbWndExtra = 100;
  50.     wce.hCursor = NULL;
  51.     wce.hIcon = NULL;
  52.     wce.hbrBackground = HBRUSH(nBrush);
  53.     wce.lpszClassName = pszClassname;
  54.     wce.lpszMenuName = NULL;
  55.     wce.hInstance = g_hInst;
  56. 	wce.hIconSm = NULL;
  57.  
  58.     ATOM nAtom = RegisterClassEx(&wce);
  59.     if(0 == nAtom)
  60.     {
  61.         MessageBox(NULL, "registerError", "Error", MB_OK);
  62.         return FALSE;
  63.     }
  64.     return TRUE;
  65. }
  66.  
  67. /*创建主窗体*/
  68.  
  69. HWND createMainWnd(LPSTR pszClassName)
  70. {
  71. 	HWND hWnd = CreateWindowEx(0,
  72. 		pszClassName,"MainWnd",
  73. 		WS_OVERLAPPEDWINDOW,
  74. 		CW_USEDEFAULT,
  75. 		CW_USEDEFAULT,
  76. 		CW_USEDEFAULT,
  77. 		CW_USEDEFAULT,
  78. 		NULL,
  79. 		NULL,
  80. 		g_hInst,
  81. 		NULL);
  82.  
  83. 	return hWnd;
  84. }
  85.  
  86. /*创建MDICLIENT窗体*/
  87.  
  88. HWND createMdiClient(HWND hParent)
  89. {
  90. 	/*创建时附件的数据
  91. 	 * ＭＤＩＣＬＩＥＮＴ时必须的
  92. 	 */
  93. 	CLIENTCREATESTRUCT cs = {'\0'};
  94. 	cs.idFirstChild = 1000;/*ID号*/
  95.  
  96. 	HWND hWnd = CreateWindowEx(0,
  97. 		"MDICLIENT","MainWnd",
  98. 		WS_CHILD|WS_VISIBLE,
  99. 		0,
  100. 		0,
  101. 		500,
  102. 		500,
  103. 		hParent,
  104. 		NULL,
  105. 		g_hInst,
  106. 		&cs);
  107.  
  108. 	return hWnd;
  109. }
  110.  
  111. /**/
  112. HWND createChildWnd(HWND hParent,LPSTR pszClassName)
  113. {
  114.  
  115. 	HWND hWnd = CreateWindowEx(WS_EX_MDICHILD,
  116. 		pszClassName,"ChildWnd",
  117. 		WS_CHILD|WS_VISIBLE,
  118. 		CW_USEDEFAULT,
  119. 		CW_USEDEFAULT,
  120. 		CW_USEDEFAULT,
  121. 		CW_USEDEFAULT,
  122. 		hParent,
  123. 		NULL,
  124. 		g_hInst,
  125. 		NULL);
  126.  
  127. 	return hWnd;
  128. }
  129.  
  130. /*显示窗体*/
  131. void DisplayWnd(HWND hWnd)
  132. {
  133. 	ShowWindow(hWnd,SW_SHOW);
  134. 	UpdateWindow(hWnd);
  135. }
  136.  
  137. /*消息处理*/
  138. void Message()
  139. {
  140. 	MSG msg = {'\0'};
  141. 	while(GetMessage(&msg,NULL,0,0)){
  142. 		DispatchMessage(&msg);
  143. 	}
  144. }
  145.  
  146. /*main*/
  147. int APIENTRY WinMain(HINSTANCE hInstance,
  148. 					HINSTANCE  hPrevINstance,
  149. 					LPSTR lpCmdLine,
  150. 					int ShowCmd)
  151. {
  152. 	/*注冊窗体*/
  153. 	RegisterWnd("MainWnd",MainProc,COLOR_BTNFACE + 1);
  154.  
  155. 	RegisterWnd("ChildWnd",ChildProc,COLOR_WINDOW);
  156.  
  157. 	/*创建MDI主窗体*/
  158. 	HWND hMain = createMainWnd("MainWnd");
  159.  
  160. 	/*创建MDICLIENT窗体*/
  161. 	HWND hMdiClient = createMdiClient(hMain);
  162. 	//MoveWindow(hMdiClient,0,0,500,500,TRUE);
  163.  
  164. 	/*创建MDI子窗体*/
  165. 	HWND hChild =  createChildWnd(hMdiClient,"ChildWnd");
  166.  
  167. 	/*显示和消息处理*/
  168. 	DisplayWnd(hMain);
  169. 	Message();
  170. 	return 0;
  171. }

走进windows编程的世界-----窗体的注冊及创建的更多相关文章

  1. 走进windows编程的世界-----入门篇

    1   Windows编程基础 1.1Win32应用程序基本类型 1)  控制台程序 不须要完好的windows窗体,能够使用DOS窗体方式显示 2)  Win32窗体程序 包括窗体的程序,能够通过窗 ...

  2. 走进windows编程的世界-----消息处理函数（1）

    Win32消息机制     过程驱动:程序是依照我们预先定义好的顺序运行.每运行一步,下一步都已经依照预定的顺序 继续运行,直至程序结束.     事件驱动:程序的运行顺序是无序的.某个时间点所运行的 ...

  3. 走进windows编程的世界-----画图相关

    Windows画图 1 图形绘制      1.1 图形绘制的方式      获取到画图句柄-设备描写叙述表(DC),使用对应的画图的API,在设备上绘制图形.          1.2 颜色     ...

  4. 走进windows编程的世界-----消息处理函数（2）

    一 WM_PAINT消息 1 WM_PAINT的产生   因为窗体的互相覆盖等,产生须要绘制的区域,那么会产生WM_PAINT消息.   普通情况下,不直接发送WM_PAINT消息,通过API声明须要 ...

  5. 走进windows编程的世界-----对话框、文本框、button

    1 对话框的分类  2 对话框的基本使用方式  3 对话框资源  4 有模式对话框的使用 int DialogBox( HINSTANCE hInstance, LPCTSTR lpTemplate, ...

  6. 走进windows编程的世界-----windows进程

    Windows进程  1 Windows进程    进程是一个容器,包括了一个应用程序实例的各种资源.Windows多任务的操作系统,因此能够同一时候运行多个进程.      2 Windows进程的 ...

  7. 走进windows编程的世界-----消息处理函数（3）

    二 定时器消息 1 定时器消息 WM_TIMER   依照定时器设置时间段,自己主动向窗体发送一个定时器消息WM_TIMER. 优先级比較低.   定时器精度比較低,毫秒级别.消息产生时间也精度比較低 ...

  8. [C#] 走进异步编程的世界 - 在 GUI 中执行异步操作

    走进异步编程的世界 - 在 GUI 中执行异步操作 [博主]反骨仔 [原文地址]http://www.cnblogs.com/liqingwen/p/5877042.html 序 这是继<开始接 ...

  9. 走进异步编程的世界 - 在 GUI 中执行异步操作

    转载:https://www.cnblogs.com/liqingwen/p/5877042.html 走进异步编程的世界 - 在 GUI 中执行异步操作 [博主]反骨仔 [原文地址]http://w ...

随机推荐

  1. C#打印日志的小技巧（转）

    https://www.cnblogs.com/jqg-aliang/p/5234206.html 打印日志的函数 开发中输出日志必不可少,在C#中输出多个不同类型参数的时候,需要连接符累加输出,很是 ...

  2. android 仿ios 对话框已封装成工具类

    对话框 在android中是一种非经常见的交互提示用户的方式,可是非常多产品狗都叫我们这些做android的仿ios,搞的我们android程序猿非常苦逼,凭什么效果老是仿ios,有没有一点情怀,只是 ...

  3. actionbar spinner-用法实例

    今天需要更改一个actionbar上的spinner的字体颜色,结果试了好长时间都没有解决,最后才发现,原来他是在代码下增加的一个textview,然后使用adapter加载的,并不是直接用frame ...

  4. 区分json与jsonp

    JSON(JavaScript Object Notation)和JSONP(JSON with Padding)虽然只有一个字母的差别,但其实他们根本不是一回事儿,下边简单区分概括一下: JSON是 ...

  5. 关于JS面向对象继承问题

    1.原型继承(是JS中很常用的一种继承方式) 子类children想要继承父类father中的所有的属性和方法(私有+公有),只需要让children.prototype=new father;即可. ...

  6. Day1：变量

    一.变量用来干嘛的 用来存东西的,方便后面调用 二.如何定义变量 name = "Hiuhung Wan" 变量名 = 值,一个等号是赋值号,右边的值赋值给左边 三.变量的一些用法 ...

  7. 低成本开始互联网创业：探讨域名、服务器、CDN、邮箱等节流之道

    互联网创业一直是个热门话题,对这个问题我也有不断的思考. 今天,探讨下如何低成本开始互联网创业. 背景 愿意冒险去创业的同志,大多是"屌丝"而非"高富帅",大多 ...

  8. 【2017 ACM-ICPC 亚洲区（西安赛区）网络赛 B】

    [链接]h在这里写链接 [题意] 一个硬币正面朝上的概率为q/p; 抛k次,问你偶数次朝上的概率为多少. [题解] [错的次数] 0 [反思] 在这了写反思 [代码] #include <bit ...

  9. Android小经验

    转载自:http://mp.weixin.qq.com/s?__biz=MzA4MjU5NTY0NA==&mid=404388098&idx=1&sn=8bbbba7692dc ...

  10. 打开utf-8文件乱码的解决方法

    gvim一直用的好好的,但是今天看一网友贴出来的代码时,却发现中文显示乱码了.... 使用notepad++打开,右下角显示是utf-8 w/0 BOM. 马上放狗, 发现解决方法如下:   在_vi ...