home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / Framewnd.cpp < prev    next >
C/C++ Source or Header  |  2000-05-11  |  8KB  |  303 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : framewnd.cpp                                                         //
  10. //  Description: SDI and MDI frame window classes                                    //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define WIN32_LEAN_AND_MEAN
  16.  
  17. #include <windows.h>
  18. #include <commctrl.h>
  19. #include <tchar.h>
  20. #include <assert.h>
  21.  
  22. #include "win.h"
  23. #include "Status.h"
  24. #include "Canvas.h"
  25. #include "Toolbar.h"
  26.  
  27. #include "FrameWnd.h"
  28.  
  29.  
  30. KFrame::KFrame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
  31.                KToolbar * pToolbar, KCanvas * pCanvas, KStatusWindow * pStatus)
  32. {
  33.     m_hInst         = hInstance;
  34.     m_pStatus    = NULL;
  35.     m_pCanvas    = NULL;
  36.     m_pToolbar     = NULL;
  37.  
  38.     m_pButtons     = pButtons;
  39.     m_nButtons     = nCount;
  40.  
  41.     m_pToolbar     = pToolbar;
  42.     m_pCanvas     = pCanvas;
  43.     m_pStatus     = pStatus;
  44.  
  45.     m_hMDIClient = NULL;
  46.     m_hAccel     = NULL;
  47. }
  48.  
  49.  
  50. KFrame::~KFrame()
  51. {
  52. }
  53.  
  54.  
  55. // default implementation: create a canvas window and a status window
  56. LRESULT KFrame::OnCreate(void)
  57. {
  58.     RECT rect;
  59.  
  60.     // toolbar window is at the top of client area
  61.     if ( m_pToolbar )
  62.     {
  63.         m_pToolbar->Create(m_hWnd, m_hInst, ID_STATUSWINDOW, m_pButtons, m_nButtons);
  64.         GetWindowRect(m_pToolbar->m_hWnd,  & rect);
  65.  
  66.         m_nToolbarHeight = 37; // rect.bottom - rect.top;
  67.     }
  68.     else
  69.         m_nToolbarHeight = 0;
  70.     
  71.     // status window is at the bottom of client area
  72.     if ( m_pStatus )
  73.     {
  74.         m_pStatus->Create(m_hWnd, ID_STATUSWINDOW);
  75.         GetWindowRect(m_pStatus->m_hWnd,  & rect);
  76.  
  77.         m_nStatusHeight = rect.bottom - rect.top;
  78.     }
  79.     else
  80.         m_nStatusHeight = 0;
  81.     
  82.     // create a canvas window above the status window
  83.     if ( m_pCanvas )
  84.     {
  85.         GetClientRect(m_hWnd, & rect);
  86.  
  87.         m_pCanvas->SetStatus(m_hInst, m_pStatus);
  88.  
  89.         m_pCanvas->CreateEx(0, _T("Canvas Class"), NULL, WS_VISIBLE | WS_CHILD,
  90.                     0, m_nToolbarHeight, rect.right, rect.bottom - m_nToolbarHeight - m_nStatusHeight, 
  91.                     m_hWnd, NULL, m_hInst);
  92.     }
  93.  
  94.     return 0;
  95. }
  96.  
  97.  
  98. LRESULT KFrame::OnSize(int width, int height)
  99. {
  100.     // need to tell status window about resizing
  101.     if ( m_pToolbar )
  102.         m_pToolbar->Resize(m_hWnd, width, height);
  103.  
  104.     if ( m_pStatus )
  105.         m_pStatus->Resize(m_hWnd, width, height);
  106.     
  107.     // resize canvas window
  108.     if ( m_pCanvas )
  109.         MoveWindow(m_pCanvas->m_hWnd, 
  110.                0, m_nToolbarHeight, width, height - m_nToolbarHeight - m_nStatusHeight, TRUE);
  111.  
  112.     if ( m_hMDIClient )
  113.         MoveWindow(m_hMDIClient, 
  114.                0, m_nToolbarHeight, width, height - m_nToolbarHeight - m_nStatusHeight, TRUE);
  115.  
  116.     return 0;
  117. }
  118.  
  119.  
  120. BOOL KFrame::OnCommand(WPARAM wParam, LPARAM lParam)
  121. {
  122.     // forward message to canvas window
  123.     if ( m_pCanvas && m_pCanvas->OnCommand(wParam, lParam) )
  124.         return TRUE;
  125.  
  126.     return FALSE;    // not processed
  127. }
  128.  
  129.  
  130. LRESULT KFrame::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  131. {
  132.     switch( uMsg )
  133.     {
  134.         case WM_CREATE:
  135.             m_hWnd = hWnd;
  136.  
  137.             return OnCreate();
  138.  
  139.         case WM_SIZE:
  140.             return OnSize(LOWORD(lParam), HIWORD(lParam));
  141.  
  142.         case WM_COMMAND:
  143.             if ( OnCommand(wParam, lParam) )
  144.                 return 0;
  145.             break;
  146.  
  147.         case WM_DESTROY:
  148.             PostQuitMessage(0);        // this is the only main window, destroying window means quit program
  149.             return 0;
  150.     }
  151.  
  152.     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  153. }
  154.  
  155.  
  156. WPARAM KFrame::MessageLoop(void)
  157. {
  158.     MSG msg;
  159.  
  160.     while ( GetMessage(&msg, NULL, 0, 0) )
  161.         if ( ! TranslateMDISysAccel(m_hMDIClient, &msg) &&
  162.              ! TranslateAccelerator(m_hWnd, m_hAccel, & msg) )
  163.         {
  164.             TranslateMessage(&msg);
  165.             DispatchMessage(&msg);
  166.         }
  167.  
  168.     return msg.wParam;
  169. }
  170.  
  171.  
  172. ///////////////////////// KMDIFrame
  173.  
  174. BOOL CALLBACK CloseEnumProc(HWND hWnd, LPARAM lParam)
  175. {
  176.     if ( GetWindow(hWnd, GW_OWNER) )
  177.         return TRUE;
  178.  
  179.     SendMessage(GetParent(hWnd), WM_MDIRESTORE, (WPARAM) hWnd, 0);
  180.  
  181.     if ( ! SendMessage(hWnd, WM_QUERYENDSESSION, 0, 0) )
  182.         return TRUE;
  183.  
  184.     SendMessage(GetParent(hWnd), WM_MDIDESTROY, (WPARAM) hWnd, 0);
  185.  
  186.     return TRUE;
  187. }
  188.  
  189.  
  190. BOOL KMDIFrame::OnCommand(WPARAM wParam, LPARAM lParam)
  191. {
  192.     return FALSE; // not processed
  193. }
  194.  
  195.  
  196. LRESULT KMDIFrame::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  197. {
  198.     switch (uMsg)
  199.     {
  200.         case WM_CREATE:
  201.         {
  202.             m_hWnd        = hWnd;
  203.             m_hMainMenu = GetMenu(hWnd);
  204.                 
  205.             OnCreate();    // toolbar & status
  206.  
  207.             CLIENTCREATESTRUCT client;
  208.             client.hWindowMenu  = GetSubMenu(m_hMainMenu, 1);
  209.             client.idFirstChild = 1000;
  210.  
  211.             m_hMDIClient = CreateWindow(_T("MDICLIENT"), NULL,
  212.                 WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
  213.                 0, 0, 0, 0, hWnd, (HMENU) 1, m_hInst, & client);
  214.  
  215.             return 0;
  216.         }
  217.         break;
  218.  
  219.         case WM_COMMAND:
  220.             if ( OnCommand(wParam, lParam) ) // allow overridding
  221.                 return 0;
  222.  
  223.             if ( LOWORD(wParam)==m_Translate[Enum_WINDOW_TILE] )
  224.             {
  225.                 SendMessage(m_hMDIClient, WM_MDITILE, 0, 0);
  226.                 return 0;
  227.             }
  228.             else if ( LOWORD(wParam)==m_Translate[Enum_WINDOW_CASCADE] )
  229.             {
  230.                 SendMessage(m_hMDIClient, WM_MDICASCADE, 0, 0);
  231.                 return 0;
  232.             }
  233.             else if ( LOWORD(wParam)==m_Translate[Enum_WINDOW_ARRANGE] )
  234.             {
  235.                 SendMessage(m_hMDIClient, WM_MDIICONARRANGE, 0, 0);
  236.                 return 0;
  237.             }
  238.             else if ( LOWORD(wParam)==m_Translate[Enum_WINDOW_CLOSEALL] )
  239.             {
  240.                 EnumChildWindows(m_hMDIClient, CloseEnumProc, 0);
  241.                 return 0;
  242.             }
  243.             else if ( LOWORD(wParam)==m_Translate[Enum_FILE_CLOSE] )
  244.             {
  245.                 HWND h = (HWND) SendMessage(m_hMDIClient, WM_MDIGETACTIVE, 0, 0);
  246.  
  247.                 if ( SendMessage(h, WM_QUERYENDSESSION, 0, 0) )
  248.                     SendMessage(m_hMDIClient, WM_MDIDESTROY, (WPARAM) h, 0);
  249.  
  250.                 return 0;
  251.             }
  252.             else if ( LOWORD(wParam)==m_Translate[Enum_FILE_EXIT] )
  253.             {
  254.                 SendMessage(hWnd, WM_CLOSE, 0, 0);
  255.                 return 0;
  256.             }
  257.             else
  258.             {
  259.                 HWND h = (HWND) SendMessage(m_hMDIClient, WM_MDIGETACTIVE, 0, 0);
  260.  
  261.                 if ( h )
  262.                     SendMessage(h, WM_COMMAND, wParam, lParam);
  263.             }
  264.             break;
  265.  
  266.         // forward message to active child window
  267.  
  268.         case WM_QUERYNEWPALETTE:
  269.         {
  270.             HWND h = (HWND) SendMessage(m_hMDIClient, WM_MDIGETACTIVE, 0, 0);
  271.  
  272.             if ( h )
  273.                 SendMessage(h, uMsg, wParam, lParam);
  274.         }
  275.         break;
  276.  
  277.         case WM_SIZE:
  278.             return OnSize(LOWORD(lParam), HIWORD(lParam));
  279.  
  280.         case WM_QUERYENDSESSION:
  281.         case WM_CLOSE:
  282.             SendMessage(hWnd, WM_COMMAND, m_Translate[Enum_WINDOW_CLOSEALL], 0); // Close all child window
  283.                 
  284.             if ( GetWindow(m_hMDIClient, GW_CHILD) )               // stay if child winodow staying    
  285.                 return 0;
  286.             break;
  287.  
  288.         case WM_DESTROY:
  289.             PostQuitMessage(0);        // this is the only main window, destroying window means quit program
  290.             return 0;
  291.  
  292.         case WM_USER:
  293.             if ( wParam )
  294.                 SendMessage(m_hMDIClient, WM_MDISETMENU, (WPARAM) m_hMainMenu, (LPARAM) GetSubMenu(m_hMainMenu, 1));
  295.  
  296.             DrawMenuBar(hWnd);
  297.             return 0;
  298.     }    
  299.  
  300.     return DefFrameProc(hWnd, m_hMDIClient, uMsg, wParam, lParam);
  301. }
  302.  
  303.