home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c480 / 19.ddi / SAMPLES / MAKEAPP / FRAME.C_ / FRAME.C
Encoding:
C/C++ Source or Header  |  1993-02-08  |  6.2 KB  |  262 lines
  1. #include "makeapp.h"
  2.  
  3. BOOL Frame_Initialize(APP* papp)
  4. {
  5.     if (!papp->hinstPrev)
  6.     {
  7.         WNDCLASS cls;
  8.  
  9.         cls.hCursor         = LoadCursor(NULL, IDC_ARROW);
  10.         cls.hIcon           = LoadIcon(papp->hinst, MAKEINTRESOURCE(IDR_MAINICON));
  11.         cls.lpszMenuName    = MAKEINTRESOURCE(IDR_MAINMENU);
  12.         cls.hInstance       = papp->hinst;
  13.         cls.lpszClassName   = "MakeApp_Frame";
  14.         cls.hbrBackground   = (HBRUSH)(COLOR_WINDOW+1);
  15.         cls.lpfnWndProc     = Frame_WndProc;
  16.         cls.style           = CS_DBLCLKS;
  17.         cls.cbWndExtra      = sizeof(FRAME*);
  18.         cls.cbClsExtra      = 0;
  19.  
  20.         if (!RegisterClass(&cls))
  21.             return FALSE;
  22.     }
  23.     return TRUE;
  24. }
  25.  
  26. void Frame_Terminate(APP* papp, int codeTerm)
  27. {
  28. }
  29.  
  30. LRESULT CALLBACK _export Frame_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  31. {
  32.     FRAME* pfrm = Frame_GetPtr(hwnd);
  33.  
  34.     if (pfrm == NULL)
  35.     {
  36.         if (msg == WM_NCCREATE)
  37.         {
  38.             pfrm = (FRAME*)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(FRAME));
  39.  
  40.             if (pfrm == NULL)
  41.                 return (LRESULT)FALSE;
  42.  
  43.             pfrm->hwnd = hwnd;
  44.             Frame_SetPtr(hwnd, pfrm);
  45.         }
  46.         else
  47.         {
  48.             return Frame_DefProc(hwnd, msg, wParam, lParam);
  49.         }
  50.     }
  51.  
  52.     if (msg == WM_NCDESTROY)
  53.     {
  54.         //LRESULT result = HANDLE_MSG(pfrm, WM_NCDESTROY, Frame_OnNCDestroy);
  55.  
  56.         LocalFree((HLOCAL)pfrm);
  57.         pfrm = NULL;
  58.         Frame_SetPtr(hwnd, NULL);
  59.  
  60.         //return result;
  61.     }
  62.  
  63.     if (msg == WM_MSGFILTER)
  64.         HANDLE_WM_MSGFILTER(pfrm, wParam, lParam, Frame_OnMsgFilter);
  65.  
  66.     switch (msg)
  67.     {
  68.         HANDLE_MSG(pfrm, WM_CREATE, Frame_OnCreate);
  69.         HANDLE_MSG(pfrm, WM_DESTROY, Frame_OnDestroy);
  70.  
  71.         HANDLE_MSG(pfrm, WM_CLOSE, Frame_OnClose);
  72.         HANDLE_MSG(pfrm, WM_QUERYENDSESSION, Frame_OnQueryEndSession);
  73.         HANDLE_MSG(pfrm, WM_ENDSESSION, Frame_OnEndSession);
  74.  
  75.         HANDLE_MSG(pfrm, WM_SIZE, Frame_OnSize);
  76.  
  77.         HANDLE_MSG(pfrm, WM_ACTIVATE, Frame_OnActivate);
  78.  
  79.         HANDLE_MSG(pfrm, WM_INITMENU, Frame_OnInitMenu);
  80.         HANDLE_MSG(pfrm, WM_INITMENUPOPUP, Frame_OnInitMenuPopup);
  81.  
  82.         HANDLE_MSG(pfrm, WM_COMMAND, Frame_OnCommand);
  83.     default:
  84.         return Frame_DefProc(hwnd, msg, wParam, lParam);
  85.     }
  86. }
  87.  
  88. HWND Frame_CreateWindow(
  89.         LPCSTR lpszText,
  90.         int x,
  91.         int y,
  92.         int cx,
  93.         int cy,
  94.         HINSTANCE hinst)
  95. {
  96.     return CreateWindowEx(
  97.             0L,
  98.             "MakeApp_Frame",
  99.             lpszText,
  100.             WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
  101.             x, y, cx, cy,
  102.             NULL,
  103.             NULL,
  104.             hinst,
  105.             NULL);
  106. }
  107.  
  108. BOOL Frame_OnCreate(FRAME* pfrm, CREATESTRUCT FAR* lpCreateStruct)
  109. {
  110.     pfrm->haccel = LoadAccelerators(lpCreateStruct->hInstance,
  111.             MAKEINTRESOURCE(IDR_MAINACCEL));
  112.  
  113.     if (!pfrm->haccel)
  114.         return FALSE;
  115.  
  116.     pfrm->hwndClient = Client_CreateWindow(pfrm->hwnd,
  117.         0, 0, 0, 0,
  118.         TRUE,
  119.         RGB(0, 0, 255), "Hello World!");
  120.  
  121.     if (!pfrm->hwndClient)
  122.         return FALSE;
  123.  
  124.     return TRUE;
  125. }
  126.  
  127. void Frame_OnDestroy(FRAME* pfrm)
  128. {
  129.     pfrm->haccel = NULL;
  130.     pfrm->hwndClient = NULL;
  131. }
  132.  
  133. void Frame_OnClose(FRAME* pfrm)
  134. {
  135.     PostQuitMessage(0);
  136. }
  137.  
  138. BOOL Frame_OnQueryEndSession(FRAME* pfrm)
  139. {
  140.     return FORWARD_WM_QUERYENDSESSION(pfrm->hwndClient, SendMessage);
  141. }
  142.  
  143. void Frame_OnEndSession(FRAME* pfrm, BOOL fEnding)
  144. {
  145.     FORWARD_WM_ENDSESSION(pfrm->hwndClient, fEnding, SendMessage);
  146.  
  147.     // Call app termination handler after client handles it.
  148.     //
  149.     if (fEnding)
  150.         App_Terminate(&g_app, TRUE);
  151. }
  152.  
  153. void Frame_OnSize(FRAME* pfrm, UINT state, int cx, int cy)
  154. {
  155.     SetWindowPos(pfrm->hwndClient, NULL,
  156.             0, 0, cx, cy,
  157.             SWP_NOACTIVATE | SWP_NOZORDER);
  158. }
  159.  
  160. void Frame_OnActivate(FRAME* pfrm, UINT state, HWND hwndActDeact, BOOL fMinimized)
  161. {
  162.     switch (state)
  163.     {
  164.     case WA_INACTIVE:
  165.     break;
  166.  
  167.     case WA_ACTIVE:
  168.         SetFocus(pfrm->hwndClient);
  169.         break;
  170.  
  171.     case WA_CLICKACTIVE:
  172.     break;
  173.     }
  174. }
  175.  
  176. void Frame_OnInitMenu(FRAME* pfrm, HMENU hMenu)
  177. {
  178. }
  179.  
  180. void Frame_OnInitMenuPopup(FRAME* pfrm, HMENU hMenu, int item, BOOL fSystemMenu)
  181. {
  182. }
  183.  
  184. BOOL Frame_OnMsgFilter(FRAME* pfrm, MSG FAR* lpmsg, int context)
  185. {
  186.     // If we're in our main loop, a dialog is up, or we're in
  187.     // menu mode, check for an accelerator press.  Otherwise,
  188.     // don't do any filtering.
  189.     //
  190.     // Note that this allows accelerators to work while a menu
  191.     // is pulled down.  We must explicitly roll the menu back up
  192.     // with a WM_CANCELMODE message, however.
  193.     //
  194.     switch (context)
  195.     {
  196.     case MSGF_MAINLOOP:
  197.     case MSGF_DIALOGBOX:
  198.     case MSGF_MENU:
  199.         if (!TranslateAccelerator(pfrm->hwnd, pfrm->haccel, lpmsg))
  200.             return FALSE;
  201.  
  202.         // An accelerator was translated: if we're in menu mode,
  203.         // be sure to roll up the menu before leaving...
  204.         //
  205.         if (context == MSGF_MENU)
  206.         {
  207.             MessageBeep(0);
  208.             FORWARD_WM_CANCELMODE(GetActiveWindow(), SendMessage);
  209.         }
  210.  
  211.         return TRUE;
  212.         break;
  213.  
  214.     default:
  215.         return FALSE;
  216.     }
  217. }
  218.  
  219. void Frame_OnCommand(FRAME* pfrm, int id, HWND hwndCtl, UINT code)
  220. {
  221.     switch (id)
  222.     {
  223.     case CMD_HELPABOUT:
  224.         AboutDlg_Do(pfrm->hwnd);
  225.         break;
  226.  
  227.     case CMD_FILEEXIT:
  228.     PostQuitMessage(0);
  229.     break;
  230.  
  231.     default:
  232.         //
  233.         // Pass commands not handled by frame on to the client
  234.         //
  235.         FORWARD_WM_COMMAND(pfrm->hwndClient, id, hwndCtl, code, SendMessage);
  236.     break;
  237.     }
  238. }
  239.  
  240. // Simple Help About box
  241. //
  242. void AboutDlg_Do(HWND hwndOwner)
  243. {
  244.     DialogBoxParam(g_app.hinst, MAKEINTRESOURCE(IDR_ABOUTDLG),
  245.             hwndOwner, AboutDlg_DlgProc, 0L);
  246. }
  247.  
  248. BOOL __export CALLBACK AboutDlg_DlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
  249. {
  250.     switch (msg)
  251.     {
  252.     case WM_COMMAND:
  253.         if (wParam == IDOK || wParam == IDCANCEL)
  254.             EndDialog(hwndDlg, TRUE);
  255.         return TRUE;
  256.         break;
  257.  
  258.     case WM_INITDIALOG:
  259.         return TRUE;
  260.     }
  261.     return FALSE;
  262. }