Return to maze.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / gdidemo

Annotation of mstools/samples/gdidemo/maze.c, revision 1.1.1.2

1.1.1.2 ! root        1: 
        !             2: /******************************************************************************\
        !             3: *       This is a part of the Microsoft Source Code Samples. 
        !             4: *       Copyright (C) 1993 Microsoft Corporation.
        !             5: *       All rights reserved. 
        !             6: *       This source code is only intended as a supplement to 
        !             7: *       Microsoft Development Tools and/or WinHelp documentation.
        !             8: *       See these sources for detailed information regarding the 
        !             9: *       Microsoft samples programs.
        !            10: \******************************************************************************/
        !            11: 
1.1       root       12: /*---------------------------------------------------------------------------*\
                     13: | MAZE MODULE
                     14: \*---------------------------------------------------------------------------*/
                     15: 
                     16: #include <windows.h>
                     17: #include "gdidemo.h"
                     18: #include  "maze.h"
                     19: 
                     20: /*---------------------------------------------------------------------------*\
                     21: | CREATE MAZE WINDOW PROCEDURE
                     22: \*---------------------------------------------------------------------------*/
                     23: HWND FAR CreateMazeWindow(HWND hWndClient, int nItem)
                     24: {
                     25:     HANDLE          hInstance;
                     26:     MDICREATESTRUCT mcs;
                     27: 
                     28: 
                     29:     hInstance = GETINSTANCE(hWndClient);
                     30: 
                     31:     /*
                     32:     ** Initialize the MDI create struct for creation of the
                     33:     ** test window.
                     34:     */
                     35:     mcs.szClass = MAZECLASS;
                     36:     mcs.szTitle = MAZETITLE;
1.1.1.2 ! root       37:     mcs.hOwner  = hInstance;
1.1       root       38:     mcs.x       = CW_USEDEFAULT;
                     39:     mcs.y       = CW_USEDEFAULT;
                     40:     mcs.cx      = CW_USEDEFAULT;
                     41:     mcs.cy      = CW_USEDEFAULT;
1.1.1.2 ! root       42:     mcs.style   = 0l;
1.1       root       43:     mcs.lParam  = (LONG)nItem;
                     44: 
1.1.1.2 ! root       45:     return((HWND)SendMessage(hWndClient,WM_MDICREATE,0,(LONG)(LPMDICREATESTRUCT)&mcs));
1.1       root       46: }
                     47: 
                     48: 
                     49: /*---------------------------------------------------------------------------*\
                     50: | MAZE WINDOW PROCEDURE
                     51: \*---------------------------------------------------------------------------*/
                     52: LONG APIENTRY MazeProc(HWND hWnd, UINT wMsg, WPARAM wParam, LONG lParam)
                     53: {
                     54:     switch(wMsg)
                     55:     {
                     56:         case WM_CREATE:
                     57:             MazeCreateProc(hWnd);
                     58:             break;
                     59: 
                     60: 
                     61:         case WM_COMMAND:
                     62:             MazeCommandProc(hWnd,wParam,lParam);
                     63:             break;
                     64: 
                     65:         case WM_TIMER:
                     66:             DrawMaze(hWnd);
                     67:             break;
                     68: 
                     69: 
                     70:         case WM_PAINT:
                     71:             MazePaintProc(hWnd);
                     72:             break;
                     73: 
                     74: 
                     75:         case WM_DESTROY:
                     76:             MazeDestroyProc(hWnd);
                     77:             break;
                     78: 
                     79: 
                     80:         default:
                     81:             return(DefMDIChildProc(hWnd,wMsg,wParam,lParam));
                     82:     }
                     83:     return(0l);
                     84: }
                     85: 
                     86: 
                     87: /*---------------------------------------------------------------------------*\
                     88: | MAZE CREATE PROCEDURE
                     89: \*---------------------------------------------------------------------------*/
                     90: BOOL MazeCreateProc(HWND hWnd)
                     91: {
                     92:     PMAZEDATA ppd;
                     93: 
                     94: 
                     95:     if(AllocWindowInfo(hWnd,sizeof(MAZEDATA)))
                     96:     {
                     97:         if(ppd = (PMAZEDATA)LockWindowInfo(hWnd))
                     98:         {
                     99:             UnlockWindowInfo(hWnd);
                    100:             return(TRUE);
                    101:         }
                    102:         FreeWindowInfo(hWnd);
                    103:     }
                    104:     return(FALSE);
                    105: }
                    106: 
                    107: 
                    108: /*---------------------------------------------------------------------------*\
                    109: | MAZE COMMAND PROCEDURE
                    110: \*---------------------------------------------------------------------------*/
                    111: BOOL MazeCommandProc(HWND hWnd, WPARAM wParam, LONG lParam)
                    112: {
                    113:     hWnd   = hWnd;
                    114:     wParam = wParam;
                    115:     lParam = lParam;
                    116: 
                    117:     return(TRUE);
                    118: }
                    119: 
                    120: 
                    121: /*---------------------------------------------------------------------------*\
                    122: | MAZE PAINT PROCEDURE
                    123: \*---------------------------------------------------------------------------*/
                    124: VOID MazePaintProc(HWND hWnd)
                    125: {
                    126:     HDC         hDC;
                    127:     PAINTSTRUCT ps;
                    128: 
                    129: 
                    130:     if(hDC = BeginPaint(hWnd,&ps))
                    131:         EndPaint(hWnd,&ps);
                    132: 
                    133:     return;
                    134: }
                    135: 
                    136: 
                    137: /*---------------------------------------------------------------------------*\
                    138: | MAZE DESTROY PROCEDURE
                    139: \*---------------------------------------------------------------------------*/
                    140: VOID MazeDestroyProc(HWND hWnd)
                    141: {
                    142:     KillTimer(hWnd,1);
                    143:     FreeWindowInfo(hWnd);
                    144:     return;
                    145: }
                    146: 
                    147: 
                    148: VOID DrawMaze(HWND hWnd)
                    149: {
                    150:     hWnd = hWnd;
                    151: 
                    152:     return;
                    153: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.