一 系统菜单

  1 执行系统提供的窗口命令，例如最大化、关闭等命令。本质上和普通菜单一样，所以我们也可以在程序中使用这个菜单
   
  2 系统菜单的使用
    2.1 获取系统菜单
       GetSystemMenu

  1.  HMENU GetSystemMenu(
  2.     HWND hWnd, //要获取的窗口句柄
  3.   BOOL bRevert  //获取时重置标示
  4.  );

    bRevert: TRUE 重置 FLASE 不重置
    当Revert为TRUE时，会将菜单重新置成默认的状态，并返回菜单句柄。如果为FALSE，菜单项不重置，获取到当前系统菜单的状态。
   
    2.2 修改系统菜单，例如增加、删除
       2.2.1 AppednMenu
       2.2.2 InsertMenu
         比AppednMenu增加了一个插入菜单项的位置或ID。
       2.2.3 删除菜单项

  1.   BOOL RemoveMenu( //
  2.     HMENU hMenu, //菜单句柄
  3.     UINT uPosition,//菜单项的位置或ID
  4.     UINT uFlags );//菜单项的位置或ID的标示。

    uFlags为MF_BYCOMMAND， uPosition为菜单ID
    uFlags为MF_BYPOSITION，uPosition为菜单位置

    2.3 系统菜单的命令响应
       系统菜单的命令响应，是在WM_SYSCOMMAND中。
       WPARAM – LOWORD(wParam)为增加的菜单的ID

  1.      int nID = LOWORD( wParam );
  2.     switch( nID )
  3.     {
  4.     case 1001:
  5.       //...
  6.         break;
  7.     }
View Code 

  1. // SysMenu.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "stdio.h"
  7. HINSTANCE g_hInst   = NULL;
  8. HANDLE    g_hStdOut = NULL;
  10. void OnCreate( HWND hWnd, UINT nMsg, 
  11.               WPARAM wParam, LPARAM lParam )
  12. {    // 获取系统菜单
  13.     HMENU hSysMenu = 
  14.         GetSystemMenu( hWnd, FALSE );
  15.     // 删除菜单项
  16.     RemoveMenu( hSysMenu, 0, MF_BYPOSITION );
  17.     RemoveMenu( hSysMenu, 0, MF_BYPOSITION );
  18.     RemoveMenu( hSysMenu, 0, MF_BYPOSITION );
  19.     RemoveMenu( hSysMenu, 0, MF_BYPOSITION );
  20.     RemoveMenu( hSysMenu, 0, MF_BYPOSITION );
  21.     // 增加菜单项
  22.     InsertMenu( hSysMenu, 0, MF_BYPOSITION|MF_STRING,
  23.         1001, "测试1" );
  24.     InsertMenu( hSysMenu, 1, MF_BYPOSITION|MF_STRING,
  25.         1002, "测试2" );
  26. }
  28. void OnSysCommand( HWND hWnd, UINT nMsg,
  29.                    WPARAM wParam, LPARAM lParam )
  30. {
  31.     CHAR szText[260] = { 0 };
  32.     sprintf( szText,
  33.         "OnSysCommand: WPARAM=%08X,LPARAM=%08X\n",
  34.         wParam, lParam );
  35.     WriteConsole( g_hStdOut, szText, 
  36.         strlen(szText), NULL, NULL );
  38.     int nID = LOWORD( wParam );
  39.     switch( nID )
  40.     {
  41.     case 1001:
  42.         MessageBox( NULL, "Hello 1001", 
  43.             "SysMenu", MB_OK );
  44.         break;
  45.     case 1002:
  46.         MessageBox( NULL, "Hello 1002", 
  47.             "SysMenu", MB_OK );
  48.         break;
  49.     }
  50. }
  52. LRESULT CALLBACK WndProc( HWND   hWnd, 
  53.                           UINT   nMsg,
  54.                           WPARAM wParam,
  55.                           LPARAM lParam )
  56. {
  57.     switch( nMsg )
  58.     {
  59.     case WM_CREATE:
  60.         OnCreate( hWnd, nMsg, wParam, lParam );
  61.         break;
  62.     case WM_SYSCOMMAND:
  63.         OnSysCommand( hWnd, nMsg, wParam, lParam );
  64.         break;
  65.     case WM_DESTROY:
  66.         PostQuitMessage( 0 );
  67.         return 0;
  68.     }
  69.     return DefWindowProc( hWnd, nMsg,
  70.         wParam, lParam );
  71. }
  73. BOOL RegisterWnd( LPSTR pszClassName )
  74. {
  75.     WNDCLASSEX wce = { 0 };
  76.     wce.cbSize        = sizeof( wce );
  77.     wce.cbClsExtra    = 0;
  78.     wce.cbWndExtra    = 0;
  79.     wce.hbrBackground = HBRUSH(COLOR_WINDOW);
  80.     wce.hCursor       = NULL;
  81.     wce.hIcon         = NULL;
  82.     wce.hIconSm       = NULL;
  83.     wce.hInstance     = g_hInst;
  84.     wce.lpfnWndProc   = WndProc;
  85.     wce.lpszClassName = pszClassName;
  86.     wce.lpszMenuName  = NULL;
  87.     wce.style         = CS_HREDRAW|CS_VREDRAW;
  89.     ATOM nAtom = RegisterClassEx( &wce );
  90.     if( 0 ==  nAtom )
  91.     {
  92.         return FALSE;
  93.     }
  95.     return TRUE;
  96. }
  98. HWND CreateWnd( LPSTR pszClassName )
  99. {
  100.     HWND hWnd = CreateWindowEx( 0,
  101.         pszClassName, "MyWnd", 
  102.         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
  103.         CW_USEDEFAULT, CW_USEDEFAULT,
  104.         CW_USEDEFAULT, NULL, NULL, g_hInst,
  105.         NULL );
  106.     return hWnd;
  107. }
  109. void DisplayWnd( HWND hWnd )
  110. {
  111.     ShowWindow( hWnd, SW_SHOW );
  112.     UpdateWindow( hWnd );
  113. }
  115. void Message( )
  116. {
  117.     MSG msg = { 0 };
  118.     while( GetMessage( &msg, NULL, 0, 0 ) )
  119.     {
  120.         TranslateMessage( &msg );
  121.         DispatchMessage( &msg );
  122.     }
  123. }
  125. void NewConsole( )
  126. {
  127.     AllocConsole( );
  128.     g_hStdOut = 
  129.         GetStdHandle( STD_OUTPUT_HANDLE );
  130. }
  132. int APIENTRY WinMain(HINSTANCE hInstance,
  133.                      HINSTANCE hPrevInstance,
  134.                      LPSTR     lpCmdLine,
  135.                      int       nCmdShow)
  136. {
  137.     NewConsole( );
  138.     g_hInst = hInstance;
  139.     RegisterWnd( "MYWND" );
  140.     HWND hWnd = CreateWnd( "MYWND" );
  141.     DisplayWnd( hWnd );
  142.     Message( );
  143.     return 0;
  144. }

二 右键菜单
  1 右键菜单
    当在窗口点击鼠标右键时，弹出的菜单。
  2 右键菜单的使用
    2.1 创建菜单
      CreatePopupMenu
    2.2 菜单增加
     AppendMenu
    2.3 菜单的显示

  1. BOOL TrackPopupMenu(
  2.     HMENU hMenu, //显示的菜单句柄
  3.     UINT uFlags, //显示的方式
  4.   int x, //菜单的X屏幕坐标
  5.   int y, //菜单的Y屏幕坐标
  6.   int nReserved, //保留,必须为0
  7.   HWND hWnd, //处理菜单命令的窗口句柄
  8.   CONST RECT *prcRect ); //忽略

    2.4 菜单的命令处理
     WM_COMMAND
    2.5 使用右键菜单的位置
      2.5.1 WM_RBUTTONUP 消息
        在WM_RBUTTONUP中,添加菜单的创建及显示,
        右键消息坐标,转换成屏幕坐标使用.
          ClientToScreen.
      2.5.2 WM_CONTEXTMENU 消息
        用于显示右键的菜单的消息.
          WPARAM – 右键抬起时对应窗口句柄
          LPARAM – 右键抬起时鼠标的屏幕坐标位置
             LOWORD(lParam) – X屏幕坐标
             HIWORD(lParam) – Y屏幕坐标
      2.5.3 WM_RBUTTONUP和WM_CONTEXTMENU对比
        1) 坐标系不同, WM_RBUTTONUP客户区坐标,WM_CONTEXTMENU屏幕坐标
        2) 先有WM_RBUTTONUP消息,后有WM_CONTEXTMENU消息

View Code 

  1. // PopMenu.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  6. HINSTANCE g_hInst = NULL;
  8. void OnRButtonUp( HWND hWnd, UINT nMsg, 
  9.         WPARAM wParam, LPARAM lParam )
  10. {    // 创建弹出式菜单
  11.     HMENU hPopMenu = CreatePopupMenu( );
  12.     // 增加菜单项
  13.     AppendMenu( hPopMenu, MF_STRING, 1001, "测试1");
  14.     AppendMenu( hPopMenu, MF_SEPARATOR, 0, NULL );
  15.     AppendMenu( hPopMenu, MF_STRING, 1002, "退出");
  16.     // 获取菜单位置
  17.     POINT point = { 0 };
  18.     point.x = LOWORD( lParam );
  19.     point.y = HIWORD( lParam );
  20.     ClientToScreen( hWnd, &point );
  21.     // 显示菜单
  22.     TrackPopupMenu( hPopMenu, TPM_LEFTALIGN,
  23.         point.x, point.y, 0, hWnd, NULL );
  24. }
  26. void OnContextMenu( HWND hWnd, UINT nMsg, 
  27.     WPARAM wParam, LPARAM lParam )
  28. {   // 创建弹出式菜单
  29.     HMENU hPopMenu = CreatePopupMenu( );
  30.     // 增加菜单项
  31.     AppendMenu( hPopMenu, MF_STRING, 1001, "测试2");
  32.     AppendMenu( hPopMenu, MF_SEPARATOR, 0, NULL );
  33.     AppendMenu( hPopMenu, MF_STRING, 1002, "退出");
  34.     // 坐标获取
  35.     int nX = LOWORD( lParam );
  36.     int nY = HIWORD( lParam );
  37.     // 显示菜单
  38.     TrackPopupMenu( hPopMenu, TPM_LEFTALIGN,
  39.         nX, nY, 0, hWnd, NULL );
  40.     // 删除菜单
  41.     DestroyMenu( hPopMenu );
  42. }
  44. void OnCommand( HWND hWnd, UINT nMsg, 
  45.         WPARAM wParam, LPARAM lParam )
  46. {
  47.     int nCmdID = LOWORD( wParam );
  48.     switch( nCmdID )
  49.     {
  50.     case 1001:
  51.         MessageBox( NULL, "Hello Popmenu",
  52.             "PopMenu", MB_OK );
  53.         break;
  54.     case 1002:
  55.         PostQuitMessage( 0 );
  56.         break;
  57.     }
  58. }
  62. LRESULT CALLBACK WndProc( HWND   hWnd, 
  63.                           UINT   nMsg,
  64.                           WPARAM wParam,
  65.                           LPARAM lParam )
  66. {
  67.     switch( nMsg )
  68.     {
  69.     case WM_RBUTTONUP:
  70.         //OnRButtonUp( hWnd, nMsg, wParam, lParam );
  71.         break;
  72.     case WM_CONTEXTMENU:
  73.         OnContextMenu( hWnd, nMsg, wParam, lParam );
  74.         break;
  75.     case WM_COMMAND:
  76.         OnCommand( hWnd, nMsg, wParam, lParam );
  77.         break;
  78.     case WM_DESTROY:
  79.         PostQuitMessage( 0 );
  80.         return 0;
  81.     }
  82.     return DefWindowProc( hWnd, nMsg,
  83.         wParam, lParam );
  84. }
  86. BOOL RegisterWnd( LPSTR pszClassName )
  87. {
  88.     WNDCLASSEX wce = { 0 };
  89.     wce.cbSize        = sizeof( wce );
  90.     wce.cbClsExtra    = 0;
  91.     wce.cbWndExtra    = 0;
  92.     wce.hbrBackground = HBRUSH(COLOR_WINDOW);
  93.     wce.hCursor       = NULL;
  94.     wce.hIcon         = NULL;
  95.     wce.hIconSm       = NULL;
  96.     wce.hInstance     = g_hInst;
  97.     wce.lpfnWndProc   = WndProc;
  98.     wce.lpszClassName = pszClassName;
  99.     wce.lpszMenuName  = NULL;
  100.     wce.style         = CS_HREDRAW|CS_VREDRAW;
  102.     ATOM nAtom = RegisterClassEx( &wce );
  103.     if( 0 ==  nAtom )
  104.     {
  105.         return FALSE;
  106.     }
  108.     return TRUE;
  109. }
  111. HWND CreateWnd( LPSTR pszClassName )
  112. {
  113.     HWND hWnd = CreateWindowEx( 0,
  114.         pszClassName, "MyWnd", 
  115.         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
  116.         CW_USEDEFAULT, CW_USEDEFAULT,
  117.         CW_USEDEFAULT, NULL, NULL, g_hInst,
  118.         NULL );
  119.     return hWnd;
  120. }
  122. void DisplayWnd( HWND hWnd )
  123. {
  124.     ShowWindow( hWnd, SW_SHOW );
  125.     UpdateWindow( hWnd );
  126. }
  128. void Message( )
  129. {
  130.     MSG msg = { 0 };
  131.     while( GetMessage( &msg, NULL, 0, 0 ) )
  132.     {
  133.         TranslateMessage( &msg );
  134.         DispatchMessage( &msg );
  135.     }
  136. }
  138. int APIENTRY WinMain(HINSTANCE hInstance,
  139.                      HINSTANCE hPrevInstance,
  140.                      LPSTR     lpCmdLine,
  141.                      int       nCmdShow)
  142. {
  143.     g_hInst = hInstance;
  144.     RegisterWnd( "MYWND" );
  145.     HWND hWnd = CreateWnd( "MYWND" );
  146.     DisplayWnd( hWnd );
  147.     Message( );
  148.     return 0;
  149. }

三 资源的使用

  1 资源文件
    图标、光标、字符串、菜单、加速键和对话框资源,位图资源等等。
    资源脚本文件 – 扩展名为RC文件。定义了资源和相关文件等等信息。
    资源编译器 – RC.exe
   
  2 图标资源ICON
  
    2.1 常用的几种大小: 16X16, 32X32,48X48
    2.2 使用
       HICON LoadIcon(
     HINSTANCE hInstance, //应用程序的句柄
      LPCTSTR lpIconName );//图标的ID字符串
    2.3 系统提供的图标
       hInstance为空, lpIconName为定义的系统图标.
    2.4 自己绘制的图标
       hInstance为图标所在的应用程序的实例句柄
    2.5 注意点：
      一个图标文件中,可以包含多种大小、颜色不同的图标，系统使用图标时，通过大小来匹配，如果未找到大小完全一致的，那么会使用大小最接近的图标格式替换。
   
  3 光标资源
   
    3.1 光标资源
      热点 Hotspot – 可以产生鼠标点击的位置
    3.2 使用
      HCURSOR LoadCursor(
    HINSTANCE hInstance, //应用程序实例句柄
      LPCTSTR lpCursorName); //光标的ID
    3.3 系统的光标
      hInstance为空，lpCursorName指定为系统的光标即可获得
    3.4 自绘制的光标
      hInstance不能为空。
    3.5 WM_SETCURSOR消息
      当鼠标在窗口内就会产生。可以在程序执行的过程中修改鼠标样式。
        wParam – 窗口句柄;
        LOWORD(lParam) – 所在位置的标识
        HIWORD(lParam) – 鼠标的消息ID
      SetCursour 设置当前窗口的光标

View Code 

  1. // WinRes.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "resource.h"
  7. HINSTANCE g_hInst = NULL;
  8.  
  9. BOOL OnSetCursor( HWND hWnd, UINT nMsg, 
  10.     WPARAM wParam, LPARAM lParam )
  11. {
  12.     int nHitTest = LOWORD( lParam );
  13.     if( HTCLIENT != nHitTest )
  14.     {
  15.         return FALSE;
  16.     }
  18.     //获得窗口的客户区
  19.     RECT rcClient = { 0 };
  20.     GetClientRect( hWnd, &rcClient );
  21.     //获得当前光标的位置
  22.     POINT ptPos = { 0 };
  23.     GetCursorPos( &ptPos );
  24.     ScreenToClient( hWnd, &ptPos );
  25.     //根据位置加载光标
  26.     HCURSOR hCursor = NULL;
  27.     if( ptPos.x < rcClient.right/2 )
  28.     {
  29.         if( ptPos.y < rcClient.bottom/2 )
  30.         {
  31.             hCursor = LoadCursor( NULL, IDC_SIZEALL );
  32.         }
  33.         else
  34.         {
  35.             hCursor = LoadCursor( NULL, IDC_CROSS );
  36.         }
  37.     }
  38.     else
  39.     {
  40.         if( ptPos.y < rcClient.bottom/2 )
  41.         {
  42.             hCursor = LoadCursor( NULL, IDC_WAIT );
  43.         }
  44.         else
  45.         {
  46.             hCursor = LoadCursor( NULL, IDC_UPARROW );
  47.         }
  48.     }
  49.     // 设置光标
  50.     SetCursor( hCursor );
  51.     return TRUE;
  52. }
  54. LRESULT CALLBACK WndProc( HWND   hWnd, 
  55.                           UINT   nMsg,
  56.                           WPARAM wParam,
  57.                           LPARAM lParam )
  58. {
  59.     switch( nMsg )
  60.     {
  61.     case WM_SETCURSOR:
  62.         if( TRUE == OnSetCursor( hWnd, nMsg,
  63.                 wParam, lParam ) )
  64.         {
  65.             return 0;
  66.         }
  67.         break;
  68.     case WM_DESTROY:
  69.         PostQuitMessage( 0 );
  70.         return 0;
  72.     }
  73.     return DefWindowProc( hWnd, nMsg,
  74.         wParam, lParam );
  75. }
  77. BOOL RegisterWnd( LPSTR pszClassName )
  78. {
  79.     WNDCLASSEX wce = { 0 };
  80.     wce.cbSize        = sizeof( wce );
  81.     wce.cbClsExtra    = 0;
  82.     wce.cbWndExtra    = 0;
  83.     wce.hbrBackground = HBRUSH(COLOR_WINDOW);
  84.     wce.hCursor       = 
  85.         LoadCursor( g_hInst, MAKEINTRESOURCE(IDC_CURSOR1) );
  86.     wce.hIcon         = 
  87.         LoadIcon( g_hInst, MAKEINTRESOURCE(IDI_MAIN) );
  88.     wce.hIconSm       = NULL;
  89.     wce.hInstance     = g_hInst;
  90.     wce.lpfnWndProc   = WndProc;
  91.     wce.lpszClassName = pszClassName;
  92.     wce.lpszMenuName  = NULL;
  93.     wce.style         = CS_HREDRAW|CS_VREDRAW;
  95.     ATOM nAtom = RegisterClassEx( &wce );
  96.     if( 0 ==  nAtom )
  97.     {
  98.         return FALSE;
  99.     }
  101.     return TRUE;
  102. }
  104. HWND CreateWnd( LPSTR pszClassName )
  105. {
  106.     HWND hWnd = CreateWindowEx( 0,
  107.         pszClassName, "MyWnd", 
  108.         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
  109.         CW_USEDEFAULT, CW_USEDEFAULT,
  110.         CW_USEDEFAULT, NULL, NULL, g_hInst,
  111.         NULL );
  112.     return hWnd;
  113. }
  115. void DisplayWnd( HWND hWnd )
  116. {
  117.     ShowWindow( hWnd, SW_SHOW );
  118.     UpdateWindow( hWnd );
  119. }
  121. void Message( )
  122. {
  123.     MSG msg = { 0 };
  124.     while( GetMessage( &msg, NULL, 0, 0 ) )
  125.     {
  126.         TranslateMessage( &msg );
  127.         DispatchMessage( &msg );
  128.     }
  129. }
  131. int APIENTRY WinMain(HINSTANCE hInstance,
  132.                      HINSTANCE hPrevInstance,
  133.                      LPSTR     lpCmdLine,
  134.                      int       nCmdShow)
  135. {
  136.     g_hInst = hInstance;
  137.     RegisterWnd( "MYWND" );
  138.     HWND hWnd = CreateWnd( "MYWND" );
  139.     DisplayWnd( hWnd );
  140.     Message( );
  141.     return 0;
  142. }

  4 字符串资源
 
    4.1 包含字符串的资源
    4.2 使用
      int LoadString(
      HINSTANCE hInstance,//程序句柄
       UINT uID, //字符串资源的ID
        LPTSTR lpBuffer, //存放字符串的BUFF
        int nBufferMax ); //BUFF的大小
      返回获取字符串的长度
     
  5 菜单资源
    5.1 添加菜单资源
    5.2 加载菜单资源
     HMENU LoadMenu(
      HINSTANCE hInstance, //应用程序句柄
      LPCTSTR lpMenuName );//菜单ID字符串
     返回加载成功的菜单的句柄
    5.3 命令处理
      使用添加的菜单ID的宏,在WM_COMMAND消息中,处理菜单命令.

View Code 

  1. // WinRes.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "resource.h"
  7. HINSTANCE g_hInst = NULL;
  8.  
  9. BOOL OnSetCursor( HWND hWnd, UINT nMsg, 
  10.     WPARAM wParam, LPARAM lParam )
  11. {    //判断是否是位于客户区之上
  12.     int nHitTest = LOWORD( lParam );
  13.     if( HTCLIENT != nHitTest )
  14.     {    //不在客户区，返回FALSE，
  15.         //让DefWindowProc处理
  16.         return FALSE;
  17.     }
  18.     //获得窗口的客户区
  19.     RECT rcClient = { 0 };
  20.     GetClientRect( hWnd, &rcClient );
  21.     //获得当前光标的位置
  22.     POINT ptPos = { 0 };
  23.     GetCursorPos( &ptPos );
  24.     ScreenToClient( hWnd, &ptPos );
  25.     //根据位置加载光标
  26.     HCURSOR hCursor = NULL;
  27.     if( ptPos.x < rcClient.right/2 )
  28.     {
  29.         if( ptPos.y < rcClient.bottom/2 )
  30.         {
  31.             hCursor = LoadCursor( NULL, IDC_SIZEALL );
  32.         }
  33.         else
  34.         {
  35.             hCursor = LoadCursor( NULL, IDC_CROSS );
  36.         }
  37.     }
  38.     else
  39.     {
  40.         if( ptPos.y < rcClient.bottom/2 )
  41.         {
  42.             hCursor = LoadCursor( NULL, IDC_WAIT );
  43.         }
  44.         else
  45.         {
  46.             hCursor = LoadCursor( NULL, IDC_UPARROW );
  47.         }
  48.     }
  49.     // 设置光标
  50.     SetCursor( hCursor );
  51.     return TRUE;
  52. }
  54. void OnCommand( HWND hWnd, UINT nMsg, 
  55.     WPARAM wParam, LPARAM lParam )
  56. {
  57.     int nCmdID = LOWORD( wParam );
  58.     switch( nCmdID )
  59.     {
  60.     case ID_EXIT:
  61.         PostQuitMessage( 0 );
  62.         break;
  63.     case ID_ABOUT:
  64.         break;
  65.     }
  66. }
  68. LRESULT CALLBACK WndProc( HWND   hWnd, 
  69.                           UINT   nMsg,
  70.                           WPARAM wParam,
  71.                           LPARAM lParam )
  72. {
  73.     switch( nMsg )
  74.     {
  75.     case WM_COMMAND:
  76.         OnCommand( hWnd, nMsg, wParam, lParam );
  77.         break;
  78.     case WM_SETCURSOR:
  79.         if( TRUE == OnSetCursor( hWnd, nMsg,
  80.                 wParam, lParam ) )
  81.         {
  82.             return 0;
  83.         }
  84.         break;
  85.     case WM_DESTROY:
  86.         PostQuitMessage( 0 );
  87.         return 0;
  89.     }
  90.     return DefWindowProc( hWnd, nMsg,
  91.         wParam, lParam );
  92. }
  94. BOOL RegisterWnd( LPSTR pszClassName )
  95. {
  96.     WNDCLASSEX wce = { 0 };
  97.     wce.cbSize        = sizeof( wce );
  98.     wce.cbClsExtra    = 0;
  99.     wce.cbWndExtra    = 0;
  100.     wce.hbrBackground = HBRUSH(COLOR_WINDOW);
  101.     wce.hCursor       = 
  102.         LoadCursor( g_hInst, MAKEINTRESOURCE(IDC_CURSOR1) );
  103.     wce.hIcon         = 
  104.         LoadIcon( g_hInst, MAKEINTRESOURCE(IDI_MAIN) );
  105.     wce.hIconSm       = NULL;
  106.     wce.hInstance     = g_hInst;
  107.     wce.lpfnWndProc   = WndProc;
  108.     wce.lpszClassName = pszClassName;
  109.     wce.lpszMenuName  = NULL;
  110.     wce.style         = CS_HREDRAW|CS_VREDRAW;
  112.     ATOM nAtom = RegisterClassEx( &wce );
  113.     if( 0 ==  nAtom )
  114.     {
  115.         return FALSE;
  116.     }
  118.     return TRUE;
  119. }
  121. HWND CreateWnd( LPSTR pszClassName )
  122. {
  123.     //加载字符串资源
  124.     CHAR szText[260] = { 0 };
  125.     LoadString( g_hInst, IDS_MAIN, szText, 260 );
  126.     //加载菜单
  127.     HMENU hMenu = LoadMenu( g_hInst, 
  128.         MAKEINTRESOURCE(IDR_MAIN) );
  129.     //创建窗口
  130.     HWND hWnd = CreateWindowEx( 0,
  131.         pszClassName, szText, 
  132.         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
  133.         CW_USEDEFAULT, CW_USEDEFAULT,
  134.         CW_USEDEFAULT, NULL, hMenu, g_hInst,
  135.         NULL );
  136.     return hWnd;
  137. }
  139. void DisplayWnd( HWND hWnd )
  140. {
  141.     ShowWindow( hWnd, SW_SHOW );
  142.     UpdateWindow( hWnd );
  143. }
  145. void Message( )
  146. {
  147.     MSG msg = { 0 };
  148.     while( GetMessage( &msg, NULL, 0, 0 ) )
  149.     {
  150.         TranslateMessage( &msg );
  151.         DispatchMessage( &msg );
  152.     }
  153. }
  155. int APIENTRY WinMain(HINSTANCE hInstance,
  156.                      HINSTANCE hPrevInstance,
  157.                      LPSTR     lpCmdLine,
  158.                      int       nCmdShow)
  159. {
  160.     g_hInst = hInstance;
  161.     RegisterWnd( "MYWND" );
  162.     HWND hWnd = CreateWnd( "MYWND" );
  163.     DisplayWnd( hWnd );
  164.     Message( );
  165.     return 0;
  166. }

  6 加速键资源
    6.1 加速键的作用
      可以使用加速键执行命令. 例如Ctrl+S存盘.
    6.2 加速键资源的添加
    6.3 加速键的使用
      6.3.1 加载
       HACCEL LoadAccelerators(
     HINSTANCE hInstance,//资源所在的应用程序句柄
        LPCTSTR lpTableName ); //加速键表的ID字符串
        加载成功返回加速键表的句柄
      6.3.2 增加消息处理

  1.   int TranslateAccelerator(
  2.      HWND hWnd, //处理加速键的窗口句柄
  3.    HACCEL hAccTable, //加速键表
  4.    LPMSG lpMsg );//MSG结构的地址

    6.4 关于加速键的消息
      TranslateAccelerator的作用是将WM_KEYDOWN或者WM_SYSKEYDOWN消息,翻译成WM_COMMAND或者WM_SYSCOMMAND消息.
      当收到KEYDOWN或者SYSKEYDOWN的消息时,会根据加速键表中按键和命令ID对应关系,找到相应的命令ID,然后调用窗口处理函数,执行WM_COMMAND或者WM_SYSCOMMAND消息.
      当找到对应命令ID并执行后，TranslateAccelerator返回非零，那么就不再执行后续的处理，消息循环等候下一条消息。否则，继续让消息循环中的TansnlateMessage和DispatchMessage处理。

View Code 

  1. // WinRes.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "resource.h"
  7. HINSTANCE g_hInst = NULL;
  8.  
  9. BOOL OnSetCursor( HWND hWnd, UINT nMsg, 
  10.     WPARAM wParam, LPARAM lParam )
  11. {    //判断是否是位于客户区之上
  12.     int nHitTest = LOWORD( lParam );
  13.     if( HTCLIENT != nHitTest )
  14.     {    //不在客户区，返回FALSE，
  15.         //让DefWindowProc处理
  16.         return FALSE;
  17.     }
  18.     //获得窗口的客户区
  19.     RECT rcClient = { 0 };
  20.     GetClientRect( hWnd, &rcClient );
  21.     //获得当前光标的位置
  22.     POINT ptPos = { 0 };
  23.     GetCursorPos( &ptPos );
  24.     ScreenToClient( hWnd, &ptPos );
  25.     //根据位置加载光标
  26.     HCURSOR hCursor = NULL;
  27.     if( ptPos.x < rcClient.right/2 )
  28.     {
  29.         if( ptPos.y < rcClient.bottom/2 )
  30.         {
  31.             hCursor = LoadCursor( NULL, IDC_SIZEALL );
  32.         }
  33.         else
  34.         {
  35.             hCursor = LoadCursor( NULL, IDC_CROSS );
  36.         }
  37.     }
  38.     else
  39.     {
  40.         if( ptPos.y < rcClient.bottom/2 )
  41.         {
  42.             hCursor = LoadCursor( NULL, IDC_WAIT );
  43.         }
  44.         else
  45.         {
  46.             hCursor = LoadCursor( NULL, IDC_UPARROW );
  47.         }
  48.     }
  49.     // 设置光标
  50.     SetCursor( hCursor );
  51.     return TRUE;
  52. }
  54. void OnCommand( HWND hWnd, UINT nMsg, 
  55.     WPARAM wParam, LPARAM lParam )
  56. {
  57.     int nCmdID = LOWORD( wParam );
  58.     switch( nCmdID )
  59.     {
  60.     case ID_EXIT:
  61.         PostQuitMessage( 0 );
  62.         break;
  63.     case ID_ABOUT:
  64.         break;
  65.     }
  66. }
  68. LRESULT CALLBACK WndProc( HWND   hWnd, 
  69.                           UINT   nMsg,
  70.                           WPARAM wParam,
  71.                           LPARAM lParam )
  72. {
  73.     switch( nMsg )
  74.     {
  75.     case WM_COMMAND:
  76.         OnCommand( hWnd, nMsg, wParam, lParam );
  77.         break;
  78.     case WM_SETCURSOR:
  79.         if( TRUE == OnSetCursor( hWnd, nMsg,
  80.                 wParam, lParam ) )
  81.         {
  82.             return 0;
  83.         }
  84.         break;
  85.     case WM_DESTROY:
  86.         PostQuitMessage( 0 );
  87.         return 0;
  89.     }
  90.     return DefWindowProc( hWnd, nMsg,
  91.         wParam, lParam );
  92. }
  94. BOOL RegisterWnd( LPSTR pszClassName )
  95. {
  96.     WNDCLASSEX wce = { 0 };
  97.     wce.cbSize        = sizeof( wce );
  98.     wce.cbClsExtra    = 0;
  99.     wce.cbWndExtra    = 0;
  100.     wce.hbrBackground = HBRUSH(COLOR_WINDOW);
  101.     wce.hCursor       = 
  102.         LoadCursor( g_hInst, MAKEINTRESOURCE(IDC_CURSOR1) );
  103.     wce.hIcon         = 
  104.         LoadIcon( g_hInst, MAKEINTRESOURCE(IDI_MAIN) );
  105.     wce.hIconSm       = NULL;
  106.     wce.hInstance     = g_hInst;
  107.     wce.lpfnWndProc   = WndProc;
  108.     wce.lpszClassName = pszClassName;
  109.     wce.lpszMenuName  = NULL;
  110.     wce.style         = CS_HREDRAW|CS_VREDRAW;
  112.     ATOM nAtom = RegisterClassEx( &wce );
  113.     if( 0 ==  nAtom )
  114.     {
  115.         return FALSE;
  116.     }
  118.     return TRUE;
  119. }
  121. HWND CreateWnd( LPSTR pszClassName )
  122. {
  123.     //加载字符串资源
  124.     CHAR szText[260] = { 0 };
  125.     LoadString( g_hInst, IDS_MAIN, szText, 260 );
  126.     //加载菜单
  127.     HMENU hMenu = LoadMenu( g_hInst, 
  128.         MAKEINTRESOURCE(IDR_MAIN) );
  129.     //创建窗口
  130.     HWND hWnd = CreateWindowEx( 0,
  131.         pszClassName, szText, 
  132.         WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
  133.         CW_USEDEFAULT, CW_USEDEFAULT,
  134.         CW_USEDEFAULT, NULL, hMenu, g_hInst,
  135.         NULL );
  136.     return hWnd;
  137. }
  139. void DisplayWnd( HWND hWnd )
  140. {
  141.     ShowWindow( hWnd, SW_SHOW );
  142.     UpdateWindow( hWnd );
  143. }
  145. void Message( HWND hWnd )
  146. {
  147.     //加载加速键表
  148.     HACCEL hAccel = LoadAccelerators( 
  149.         g_hInst, MAKEINTRESOURCE(IDR_ACCEL) );
  150.     //消息循环
  151.     MSG msg = { 0 };
  152.     while( GetMessage( &msg, NULL, 0, 0 ) )
  153.     {    // 增加加速键的消息处理
  154.         if( !TranslateAccelerator( hWnd, hAccel, &msg ) )
  155.         {    //字符消息处理
  156.             TranslateMessage( &msg );
  157.             //消息派发
  158.             DispatchMessage( &msg );
  159.         }
  160.     }
  161. }
  163. int APIENTRY WinMain(HINSTANCE hInstance,
  164.                      HINSTANCE hPrevInstance,
  165.                      LPSTR     lpCmdLine,
  166.                      int       nCmdShow)
  167. {
  168.     g_hInst = hInstance;
  169.     RegisterWnd( "MYWND" );
  170.     HWND hWnd = CreateWnd( "MYWND" );
  171.     DisplayWnd( hWnd );
  172.     Message( hWnd );
  173.     return 0;
  174. }

四 程序编写

  1 定时器设置
    实现定时器的关闭和打开

代码如下，这个是新建一个win32程序，选择简单的hello word程序。和之前的有点小不一样。

View Code 

  1. // WinCase.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "resource.h"
  6.  
  7. #define MAX_LOADSTRING 100
  8.  
  9. // Global Variables:
  10. HINSTANCE hInst;                                // current instance
  11. TCHAR szTitle[MAX_LOADSTRING];                                // The title bar text
  12. TCHAR szWindowClass[MAX_LOADSTRING];
  13. int   g_nX = 0;
  14. int   g_nY = 0;                                // The title bar text
  16. // Foward declarations of functions included in this code module:
  17. ATOM                MyRegisterClass(HINSTANCE hInstance);
  18. BOOL                InitInstance(HINSTANCE, int);
  19. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
  20. LRESULT CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
  22. int APIENTRY WinMain(HINSTANCE hInstance,
  23.                      HINSTANCE hPrevInstance,
  24.                      LPSTR     lpCmdLine,
  25.                      int       nCmdShow)
  26. {
  27.      // TODO: Place code here.
  28.     MSG msg;
  29.     HACCEL hAccelTable;
  31.     // Initialize global strings
  32.     LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  33.     LoadString(hInstance, IDC_WINCASE, szWindowClass, MAX_LOADSTRING);
  34.     MyRegisterClass(hInstance);
  36.     // Perform application initialization:
  37.     if (!InitInstance (hInstance, nCmdShow)) 
  38.     {
  39.         return FALSE;
  40.     }
  42.     hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_WINCASE);
  44.     // Main message loop:
  45.     while (GetMessage(&msg, NULL, 0, 0)) 
  46.     {
  47.         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
  48.         {
  49.             TranslateMessage(&msg);
  50.             DispatchMessage(&msg);
  51.         }
  52.     }
  54.     return msg.wParam;
  55. }
  59. //
  60. //  FUNCTION: MyRegisterClass()
  61. //
  62. //  PURPOSE: Registers the window class.
  63. //
  64. //  COMMENTS:
  65. //
  66. //    This function and its usage is only necessary if you want this code
  67. //    to be compatible with Win32 systems prior to the \'RegisterClassEx\'
  68. //    function that was added to Windows 95. It is important to call this function
  69. //    so that the application will get \'well formed\' small icons associated
  70. //    with it.
  71. //
  72. ATOM MyRegisterClass(HINSTANCE hInstance)
  73. {
  74.     WNDCLASSEX wcex;
  76.     wcex.cbSize = sizeof(WNDCLASSEX); 
  78.     wcex.style            = CS_HREDRAW | CS_VREDRAW;
  79.     wcex.lpfnWndProc    = (WNDPROC)WndProc;
  80.     wcex.cbClsExtra        = 0;
  81.     wcex.cbWndExtra        = 0;
  82.     wcex.hInstance        = hInstance;
  83.     wcex.hIcon            = LoadIcon(hInstance, (LPCTSTR)IDI_WINCASE);
  84.     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
  85.     wcex.hbrBackground    = (HBRUSH)(COLOR_WINDOW+1);
  86.     wcex.lpszMenuName    = (LPCSTR)IDC_WINCASE;
  87.     wcex.lpszClassName    = szWindowClass;
  88.     wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
  90.     return RegisterClassEx(&wcex);
  91. }
  93. //
  94. //   FUNCTION: InitInstance(HANDLE, int)
  95. //
  96. //   PURPOSE: Saves instance handle and creates main window
  97. //
  98. //   COMMENTS:
  99. //
  100. //        In this function, we save the instance handle in a global variable and
  101. //        create and display the main program window.
  102. //
  103. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  104. {
  105.    HWND hWnd;
  107.    hInst = hInstance; // Store instance handle in our global variable
  109.    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  110.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  112.    if (!hWnd)
  113.    {
  114.       return FALSE;
  115.    }
  117.    ShowWindow(hWnd, nCmdShow);
  118.    UpdateWindow(hWnd);
  120.    return TRUE;
  121. }
  123. //
  124. //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
  125. //
  126. //  PURPOSE:  Processes messages for the main window.
  127. //
  128. //  WM_COMMAND    - process the application menu
  129. //  WM_PAINT    - Paint the main window
  130. //  WM_DESTROY    - post a quit message and return
  131. //
  132. //
  133. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  134. {
  135.     int wmId, wmEvent;
  136.     PAINTSTRUCT ps;
  137.     HDC hdc;
  138.     TCHAR szHello[MAX_LOADSTRING];
  139.     LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
  141.     switch (message) 
  142.     {
  143.     case WM_COMMAND:
  144.         wmId    = LOWORD(wParam); 
  145.         wmEvent = HIWORD(wParam); 
  146.         // Parse the menu selections:
  147.         switch (wmId)
  148.         {
  149.         case ID_BEGIN:
  150.             SetTimer( hWnd, 1001, 1 * 1000, NULL );
  151.             break;
  152.         case ID_STOP:
  153.             KillTimer( hWnd, 1001 );
  154.             break;
  155.         case IDM_ABOUT:
  156.            DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
  157.            break;
  158.         case IDM_EXIT:
  159.            DestroyWindow(hWnd);
  160.            break;
  161.         default:
  162.            return DefWindowProc(hWnd, message, wParam, lParam);
  163.         }
  164.         break;
  165.     case WM_PAINT:
  166.         {
  167.             hdc = BeginPaint(hWnd, &ps);
  168.             CHAR szText[] = "Hello Ball";
  169.             TextOut( hdc, g_nX, g_nY, szText,
  170.                 strlen(szText) );
  171.             EndPaint(hWnd, &ps);
  172.         }
  173.         break;
  174.     case WM_DESTROY:
  175.         PostQuitMessage(0);
  176.         break;
  177.     case WM_TIMER:
  178.         g_nX += 5;
  179.         g_nY += 5;
  180.         InvalidateRect( hWnd, NULL, TRUE );
  181.         break;
  182.     default:
  183.         return DefWindowProc(hWnd, message, wParam, lParam);
  184.     }
  185.    return 0;
  186. }
  188. // Mesage handler for about box.
  189. LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  190. {
  191.     switch (message)
  192.     {
  193.         case WM_INITDIALOG:
  194.                 return TRUE;
  196.         case WM_COMMAND:
  197.             if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
  198.             {
  199.                 EndDialog(hDlg, LOWORD(wParam));
  200.                 return TRUE;
  201.             }
  202.             break;
  203.     }
  204.     return FALSE;
  205. }

 

 

版权声明：本文为tangzhengyue原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/tangzhengyue/archive/2012/08/14/2638900.html