home *** CD-ROM | disk | FTP | other *** search
/ Game Audio Programming / GameAudioProgramming.iso / Extras / Sensaura / SDK1.0 / data1.cab / Example_Files / ZoomFX / mainwnd.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-13  |  17.7 KB  |  743 lines
  1. /*
  2.     Company:            Sensaura Ltd
  3.     Copyright:          (C) 2000
  4.  
  5.     File Name:            mainwnd.cpp
  6.     File Description:    Source file for implementation of MainWnd class
  7.     Author:                Adam Philp
  8.     Last Update:        04-JAN-00
  9.  
  10.     Target Compiler:    Microsoft Visual C++ Version 5.0
  11. */
  12.  
  13. ///////////////////////    Included files ////////////////////////////////////////////////////////////
  14.  
  15. #include <windows.h>
  16. #include <stddef.h>
  17. #include <string.h>
  18.  
  19. #include "mainwnd.h"
  20. #include "applicat.h"
  21. #include "aboutbox.h"
  22. #include "buffrdlg.h"
  23. #include "lstnrdlg.h"
  24. #include "directx.h"
  25. #include "debug.h"
  26. #include "resource.h"
  27.  
  28. ///////////////////////    Definitions ///////////////////////////////////////////////////////////////
  29.  
  30. #define TIMERPERIOD        500                // 1/2 second
  31.  
  32. ///////////////////////    Local type definitions ////////////////////////////////////////////////////
  33.  
  34. typedef LRESULT (CALLBACK *ThunkProc)(HWND, UINT, WPARAM, LPARAM);
  35.  
  36. #pragma pack(1)
  37.  
  38. struct InstanceThunk 
  39. {
  40.   BYTE        Call;
  41.   int        Offset;
  42.   ThunkProc    Proc;
  43.   MainWnd*    MainWnd;
  44.   BYTE        Code[6];
  45. };
  46. #pragma pack()
  47.  
  48. ///////////////////////    Constants /////////////////////////////////////////////////////////////////
  49.  
  50. static const int CodeOffset = offsetof(InstanceThunk, Code)-offsetof(InstanceThunk, Proc);
  51.  
  52. ///////////////////////    Local variables ///////////////////////////////////////////////////////////
  53.  
  54. MainWnd* g_ThunkWindow = NULL;
  55.  
  56. ///////////////////////    Local functions ///////////////////////////////////////////////////////////
  57.  
  58. /*
  59.     The following functions handle setting the pThunk for our window object to enable us to use a
  60.     C++ class to handle Windows messages
  61. */
  62.  
  63. WNDPROC CreateInstanceThunk(MainWnd* w, ThunkProc thunkProc)
  64. {
  65.   InstanceThunk* pThunk;
  66.   
  67.   pThunk = new InstanceThunk;
  68.  
  69.   pThunk->Call = 0xE8u;        // CALL rel32
  70.   pThunk->Offset = CodeOffset; // relative displacement to Code[5]
  71.   pThunk->Proc = thunkProc;
  72.   pThunk->MainWnd = w;
  73.  
  74.   // POP ECX
  75.   //
  76.   // pop return address of call into ecx (address of member "Proc")
  77.   //
  78.   pThunk->Code[0] = 0x59u;
  79.  
  80.   // MOV EAX,[ECX+4]
  81.   //
  82.   // load "MainWnd" into ebx
  83.   //
  84.   pThunk->Code[1] = 0x8Bu;     // MOV r32,r/m32
  85.   pThunk->Code[2] = 0x41u;     // eax,disp8[ECX]
  86.   pThunk->Code[3] = 0x04u;     // +4
  87.  
  88.   // JMP [ECX]
  89.   //
  90.   // jump to window function provided
  91.   //
  92.   pThunk->Code[4] = 0xFFu;     // JMP r/m32
  93.   pThunk->Code[5] = 0x21u;     // [ECX]
  94.  
  95.   return (WNDPROC)pThunk;
  96. }
  97.  
  98. void FreeInstanceThunk(WNDPROC proc)
  99. {
  100.   delete (InstanceThunk*)proc;
  101. }
  102.  
  103. void SetWindowToThunk(MainWnd* w)
  104. {
  105.     g_ThunkWindow = w;
  106. }
  107.  
  108. MainWnd* GetWindowToThunk()
  109. {
  110.     return g_ThunkWindow;
  111. }
  112.  
  113. LRESULT    CALLBACK InitWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  114. {
  115.     WNDPROC pThunk;
  116.  
  117.     if(!g_ThunkWindow)
  118.         return DefWindowProc(hwnd, message, wParam, lParam);
  119.     g_ThunkWindow->m_hWnd = hwnd;
  120.     g_ThunkWindow->SetDefaultProc((WNDPROC)GetProcAddress((HINSTANCE)GetModuleHandle("USER32"), 
  121.                                                           "DefWindowProcA"));
  122.     pThunk = g_ThunkWindow->GetThunk();
  123.     g_ThunkWindow = NULL;
  124.  
  125.     SetWindowLong(hwnd, GWL_WNDPROC, (long)pThunk);
  126.     return (*(WNDPROC)(pThunk))(hwnd, message, wParam, lParam);
  127. }
  128.  
  129. /////////////////////// MainWnd class implementation ///////////////////////////////////////////////
  130.  
  131. MainWnd::MainWnd(LPCSTR pCaption, Application* pApp)
  132. {
  133.     m_pApp = pApp;
  134.     m_hWnd = NULL;
  135.     m_DefaultProc = NULL;
  136.     m_Thunk = CreateInstanceThunk(this, StdWndProc);
  137.  
  138.     m_xNextPos = 0;
  139.     m_yNextPos = 0;
  140.  
  141.     m_pDirectSound = NULL;
  142.     m_pPrimary = NULL;
  143.     m_pListener = NULL;
  144.  
  145.     m_bCanDoZoomFX = false;
  146.     m_bZoomFX = false;
  147.  
  148.     m_dwTimer = 0;
  149.     m_hbmZoomFX = NULL;
  150.     memset(&m_dsCaps, 0, sizeof(m_dsCaps));
  151.     m_dsCaps.dwSize = sizeof(m_dsCaps);
  152.  
  153.     m_pListenerDlg = NULL;
  154.     m_pBufferDlgs = NULL;
  155.  
  156. }
  157.  
  158. MainWnd::~MainWnd()
  159. {
  160.     if(m_hWnd)
  161.         DestroyWindow();                // Destroy MS-MainWnd
  162.     
  163.     FreeInstanceThunk(m_Thunk);
  164. }
  165.  
  166. /////////////////////// MainWnd public member functions ///////////////////////////////////////////
  167.  
  168. int MainWnd::GetClassName(LPSTR className, int maxCount) const
  169. {
  170.     return ::GetClassName(m_hWnd, className, maxCount);
  171. }
  172.  
  173. LPSTR MainWnd::GetClassName() const
  174. {
  175.     return "MainWnd";
  176. }
  177.  
  178. LPCSTR MainWnd::GetCaption() const 
  179. { 
  180.     return m_pApp->GetName(); 
  181. }
  182.  
  183. void MainWnd::GetWindowClass(WNDCLASS& wc) const
  184. {
  185.     wc.cbClsExtra = 0;
  186.     wc.cbWndExtra = 0;
  187.     wc.hInstance = m_pApp->GetInstance();
  188.     wc.hIcon = LoadIcon(m_pApp->GetInstance(), MAKEINTRESOURCE(IDI_SENSAURA));
  189.     wc.hCursor = ::LoadCursor(0, IDC_ARROW);
  190.     wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  191.     wc.lpszMenuName = MAKEINTRESOURCE(IDM_MAINMENU);
  192.     wc.lpszClassName = GetClassName();
  193.     wc.style = CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
  194.     wc.lpfnWndProc = InitWndProc;
  195. }
  196.  
  197. bool MainWnd::Create()
  198. {
  199.     BITMAP                    bm;
  200.     LPDIRECTSOUNDBUFFER        pBuffer;
  201.     LPDIRECTSOUND3DBUFFER    p3dBuffer;
  202.     LPKSPROPERTYSET            pKsPropertySet;
  203.     unsigned long            ulSupport;
  204.     WAVEFORMATEX            wfx;
  205.     DSBUFFERDESC            dsbd;
  206.  
  207.     TRY_DS(DirectSoundCreate(NULL, &m_pDirectSound, NULL))
  208.  
  209.     m_hbmZoomFX = LoadBitmap(m_pApp->GetInstance(), MAKEINTRESOURCE(IDB_ZOOMFX));
  210.     if(m_hbmZoomFX == NULL)
  211.         return false;
  212.     GetObject(m_hbmZoomFX, sizeof(bm), &bm);
  213.  
  214.     if(Register()) 
  215.     {
  216.         SetWindowToThunk(this);
  217.  
  218.         m_hWnd = CreateWindowEx(0, GetClassName(), GetCaption(),
  219.                                 WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_BORDER|WS_MINIMIZEBOX,
  220.                                 CW_USEDEFAULT, CW_USEDEFAULT, 
  221.                                 bm.bmWidth+2*GetSystemMetrics(SM_CXBORDER), 
  222.                                 bm.bmHeight+2*GetSystemMetrics(SM_CYBORDER)+GetSystemMetrics(SM_CYMENU)+GetSystemMetrics(SM_CYCAPTION),      
  223.                                 NULL, NULL, m_pApp->GetInstance(), NULL);
  224.     }
  225.     if(GetWindowToThunk() == this)
  226.         SetWindowToThunk(NULL);
  227.  
  228.     if(m_hWnd == NULL)
  229.         return false;
  230.  
  231.     TRY_DS(m_pDirectSound->SetCooperativeLevel(m_hWnd, DSSCL_NORMAL))
  232.  
  233.     dsbd.dwSize = sizeof(DSBUFFERDESC);    // Set primary buffer properties
  234.     dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER|DSBCAPS_CTRL3D;        
  235.     dsbd.dwBufferBytes = 0;                  
  236.     dsbd.dwReserved = 0;                
  237.     dsbd.lpwfxFormat = NULL;
  238.  
  239.     TRY_DS(m_pDirectSound->CreateSoundBuffer(&dsbd, &m_pPrimary, NULL))
  240.     if(m_pPrimary->QueryInterface(IID_IDirectSound3DListener, (void**)&m_pListener) != S_OK)
  241.         return false;
  242.  
  243.     wfx.wFormatTag = WAVE_FORMAT_PCM;    // Create a temp secondary buffer
  244.     wfx.nChannels = 1;
  245.     wfx.nSamplesPerSec = 11025;
  246.     wfx.nAvgBytesPerSec = 11025;
  247.     wfx.nBlockAlign = 1; 
  248.     wfx.wBitsPerSample = 8; 
  249.     wfx.cbSize = 0; 
  250.  
  251.     dsbd.dwSize = sizeof(DSBUFFERDESC);    // First, set up the DirectSound buffer description
  252.     dsbd.dwFlags = DSBCAPS_CTRL3D|DSBCAPS_LOCHARDWARE;
  253.     dsbd.dwBufferBytes = 256;
  254.     dsbd.dwReserved = 0;
  255.     dsbd.lpwfxFormat = &wfx;
  256.                 
  257.     TRY_DS(m_pDirectSound->CreateSoundBuffer(&dsbd, &pBuffer, NULL))
  258.     if(pBuffer->QueryInterface(IID_IDirectSound3DBuffer, (void**)&p3dBuffer) != S_OK)
  259.     {
  260.         pBuffer->Release();
  261.         return false;
  262.     }
  263.     if(pBuffer->QueryInterface(IID_IKsPropertySet, (void**)&pKsPropertySet))
  264.     {
  265.         p3dBuffer->Release();
  266.         pBuffer->Release();
  267.         return false;
  268.     }
  269.     m_bCanDoZoomFX = false;
  270.     if(pKsPropertySet->QuerySupport(DSPROPSETID_ZOOMFX_BufferProperties, DSPROPERTY_ZOOMFXBUFFER_ALL, &ulSupport) == S_OK)
  271.     {
  272.         if(ulSupport == (KSPROPERTY_SUPPORT_GET | KSPROPERTY_SUPPORT_SET))
  273.         {
  274.             m_bCanDoZoomFX = true;        // Set status flag    
  275.             m_bZoomFX = true;            // ZoomFX on by default
  276.         }
  277.     }
  278.     pKsPropertySet->Release();
  279.     p3dBuffer->Release();
  280.     pBuffer->Release();
  281.  
  282.     if(!m_bCanDoZoomFX)                    // Allow the program to continue if ZoomFX not present
  283.         MessageBox("ZoomFX extensions are not supported", GetCaption(), MB_OK|MB_ICONEXCLAMATION);
  284.  
  285.     if((m_dwTimer = SetTimer(m_hWnd, 1, TIMERPERIOD, NULL)) == 0)
  286.     {                                    // Quit the app if we can't get a timer
  287.         MessageBox("Cannot allocate timer, aborting", GetCaption(), MB_OK|MB_ICONSTOP);
  288.         return false;
  289.     }
  290.     return true;
  291.  
  292. DS_ERROR:
  293.     return false;
  294.  
  295. }
  296.  
  297. bool MainWnd::ShowWindow(int nCmdShow)
  298. {
  299.     if(m_hWnd)
  300.         return ::ShowWindow(m_hWnd, nCmdShow) ? true : false;
  301.     return false;
  302. }
  303.  
  304. void MainWnd::Paint(HDC hdc, RECT& rect, bool bErase)
  305. {
  306.     RECT        rcClient;
  307.     TCHAR        szText[128];
  308.     SIZE        sizeExtent;
  309.     COLORREF    clrOld;
  310.  
  311.     GetClientRect(m_hWnd, &rcClient);
  312.     SetBkMode(hdc, TRANSPARENT);
  313.     clrOld = GetTextColor(hdc);
  314.     SetTextColor(hdc, RGB(0, 128, 64));
  315.  
  316.     wsprintf(szText, "Free HW Mem: %luKb", m_dsCaps.dwFreeHwMemBytes / 1024);
  317.     GetTextExtentPoint32(hdc, szText, lstrlen(szText), &sizeExtent);
  318.     DrawText(hdc, szText, -1, &rcClient, DT_TOP | DT_LEFT);
  319.  
  320.     wsprintf(szText, "Free HW Mixing Buffers: %lu", m_dsCaps.dwFreeHwMixingStaticBuffers);
  321.     rcClient.top += sizeExtent.cy;
  322.     DrawText(hdc, szText, -1, &rcClient, DT_TOP | DT_LEFT);
  323.  
  324.     wsprintf(szText, "Free HW 3D Buffers: %lu", m_dsCaps.dwFreeHw3DStaticBuffers);
  325.     rcClient.top += sizeExtent.cy;
  326.     DrawText(hdc, szText, -1, &rcClient, DT_TOP | DT_LEFT);
  327.  
  328.     wsprintf(szText, "ZoomFX extensions: %s", !m_bCanDoZoomFX ? "NOT PRESENT" : m_bZoomFX ? "ON" : "OFF");
  329.     rcClient.top += sizeExtent.cy;
  330.     DrawText(hdc, szText, -1, &rcClient, DT_TOP | DT_LEFT);
  331.  
  332.     SetTextColor(hdc, clrOld);
  333. }
  334.  
  335. LRESULT MainWnd::EvCommand(UINT id, HWND hwndCtl, UINT notifyCode)
  336. {
  337.     BufferList* pBuffer;
  338.  
  339.     switch(id)
  340.     {
  341.     case CM_FILE_OPEN:
  342.         OpenFile(NULL);
  343.         break;
  344.  
  345.     case CM_FILE_EXIT: 
  346.         SendMessage(WM_CLOSE);
  347.         break;
  348.  
  349.     case CM_BUFFERS_MINIMIZEALL:
  350.         pBuffer = m_pBufferDlgs;
  351.         while(pBuffer)
  352.         {
  353.             ::ShowWindow(pBuffer->pDlg->m_hWnd, SW_MINIMIZE);
  354.             pBuffer = pBuffer->pNext;
  355.         }
  356.         break;
  357.  
  358.     case CM_BUFFERS_RESTOREALL:
  359.         pBuffer = m_pBufferDlgs;
  360.         while(pBuffer)
  361.         {
  362.             ::SendMessage(pBuffer->pDlg->m_hWnd, WM_SYSCOMMAND, SC_RESTORE, 0L);
  363.             pBuffer = pBuffer->pNext;
  364.         }
  365.         break;
  366.  
  367.     case CM_BUFFERS_CASCADE:
  368.         pBuffer = m_pBufferDlgs;
  369.         if(pBuffer)
  370.             ResetCascade();
  371.  
  372.         while(pBuffer)
  373.         {
  374.             CascadeWindow(pBuffer->pDlg->m_hWnd);
  375.             pBuffer = pBuffer->pNext;
  376.         }
  377.         break;
  378.  
  379.     case CM_BUFFERS_CLOSEALL:
  380.         while(m_pBufferDlgs)
  381.         {
  382.             pBuffer = m_pBufferDlgs->pNext;
  383.             ::SendMessage(m_pBufferDlgs->pDlg->m_hWnd, WM_COMMAND, MAKELONG(IDCANCEL, 0), 0L);
  384.             m_pBufferDlgs = pBuffer;
  385.         }
  386.         EnableMenuItem(GetMenu(m_hWnd), 1, MF_BYPOSITION|MF_GRAYED);
  387.         DrawMenuBar(m_hWnd);
  388.         break;
  389.  
  390.     case CM_HELP_ABOUT:
  391.         AboutBox(m_hWnd, m_pApp->GetInstance());
  392.         break;
  393.     }
  394.     return 0;
  395. }
  396.  
  397. void MainWnd::DestroyChild(HWND hwndChild)
  398. {
  399.     BufferList* pBuffer = m_pBufferDlgs;
  400.     BufferList* pPrev = NULL;
  401.     
  402.     while(pBuffer)
  403.     {
  404.         if(pBuffer->pDlg->m_hWnd == hwndChild)    // Here it is
  405.         {
  406.             if(pBuffer == m_pBufferDlgs)
  407.                 m_pBufferDlgs = m_pBufferDlgs->pNext;
  408.             if(pPrev)
  409.                 pPrev->pNext = pBuffer->pNext;
  410.             delete pBuffer->pDlg;
  411.             delete pBuffer;                // Not our job to destroy the actual object
  412.  
  413.             pBuffer = NULL;
  414.             pBuffer = NULL;
  415.         }
  416.         else                            // On to the next entry
  417.         {
  418.             pPrev = pBuffer;
  419.             pBuffer = pBuffer->pNext;
  420.         }
  421.     }
  422. }
  423.  
  424. void MainWnd::Invalidate(bool bErase)
  425. {
  426.     if(m_hWnd)
  427.     {
  428.         RECT rc;
  429.         GetClientRect(m_hWnd, &rc);
  430.         InvalidateRect(m_hWnd, &rc, bErase ? TRUE : FALSE);
  431.     }
  432. }
  433.  
  434. int    MainWnd::MessageBox(LPCSTR message, LPCSTR pCaption, UINT uStyle) const
  435. {
  436.     return ::MessageBox(m_hWnd, message, pCaption, uStyle);
  437. }
  438.  
  439. void MainWnd::ResetCascade()
  440. {
  441.     POINT   ptParent;
  442.  
  443.     ptParent.x = ptParent.y = 0;
  444.     ClientToScreen(m_hWnd, &ptParent);
  445.     m_xNextPos = ptParent.x;
  446.     m_yNextPos = ptParent.y;
  447. }
  448.  
  449. void MainWnd::CascadeWindow(HWND hWnd)
  450. {
  451.     RECT    rc;
  452.     int        nStep;
  453.  
  454.     // Don't move minimized windows
  455.     if(IsIconic(hWnd))
  456.         return;
  457.  
  458.     GetWindowRect(hWnd, &rc);
  459.  
  460.     if(m_xNextPos+(rc.right-rc.left) > GetSystemMetrics(SM_CXSCREEN))
  461.         ResetCascade();
  462.     else if(m_yNextPos+(rc.bottom-rc.top) > GetSystemMetrics(SM_CYSCREEN))
  463.         ResetCascade();
  464.  
  465.     SetWindowPos(hWnd, NULL, m_xNextPos, m_yNextPos, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
  466.     // Move diagonally by the height of the title bar
  467.     nStep = GetSystemMetrics(SM_CYCAPTION);
  468.     m_xNextPos += nStep;
  469.     m_yNextPos += nStep;
  470. }
  471.  
  472. /////////////////////// MainWnd protected member functions /////////////////////////////////////////
  473.  
  474. bool MainWnd::Register()
  475. {
  476.     WNDCLASS wc;
  477.  
  478.     if(!GetClassInfo(m_pApp->GetInstance(), GetClassName(), &wc)) 
  479.     {
  480.         GetWindowClass(wc);
  481.         return ::RegisterClass(&wc) ? true : false;
  482.     }
  483.     return true;
  484. }
  485.  
  486. bool MainWnd::OpenFile(LPTSTR lpszPath)
  487. {
  488.     TCHAR            szFileName[MAX_PATH];
  489.     LPTSTR            lpszFileName;
  490.     int                nFileIndex;
  491.     BufferListEntry    pBuffer;
  492.  
  493.     PTRACE("MainWnd::OpenFile(%s)", lpszPath);
  494.  
  495.     if(m_dsCaps.dwFreeHw3DStaticBuffers <= 0)
  496.     {
  497.         MessageBox("No more 3D buffers available for ZoomFX", GetCaption(), MB_ICONSTOP|MB_OK);
  498.         return false;
  499.     }
  500.  
  501.     if(lpszPath != NULL)
  502.     {
  503.         lpszFileName = strrchr(lpszPath, '\\');
  504.         if(lpszFileName == NULL)
  505.             nFileIndex = 0;
  506.         else
  507.             nFileIndex =  lpszFileName-lpszPath+sizeof(TCHAR);
  508.         lstrcpy(szFileName, lpszPath);
  509.     }
  510.     else
  511.     {
  512.         if(!OpenFileDialog(szFileName, &nFileIndex))
  513.             return false;
  514.     }
  515.     if(m_pListenerDlg == NULL)            // This is the first buffer
  516.     {
  517.         ResetCascade();
  518.  
  519.         m_pListenerDlg = new ListenerDlg;
  520.         if(m_pListenerDlg == NULL)
  521.         {
  522.             MessageBox("Cannot create listener dialog object", GetCaption(), MB_ICONSTOP|MB_OK);
  523.             return false;
  524.         }
  525.         if(!m_pListenerDlg->Create(m_pApp, m_pListener))
  526.             return false;
  527.     }
  528.     pBuffer = new BufferList;
  529.     if(pBuffer == NULL)
  530.     {
  531.         MessageBox("No memory for buffer", GetCaption(), MB_ICONSTOP|MB_OK);
  532.         return false;
  533.     }
  534.     pBuffer->pDlg = new BufferDlg;
  535.     if(pBuffer->pDlg == NULL)
  536.     {
  537.         MessageBox("No memory for dialog", GetCaption(), MB_ICONSTOP|MB_OK);
  538.         return false;
  539.     }
  540.     if(!pBuffer->pDlg->Create(m_pApp, szFileName, m_pDirectSound))
  541.     {
  542.         MessageBox("Unable to create buffer", GetCaption(), MB_ICONSTOP|MB_OK);
  543.         return false;
  544.     }
  545.  
  546.     pBuffer->pNext = m_pBufferDlgs;
  547.     m_pBufferDlgs = pBuffer;
  548.  
  549.     EnableMenuItem(GetMenu(m_hWnd), 1, MF_BYPOSITION);
  550.     DrawMenuBar(m_hWnd);
  551.  
  552.     return true;
  553. }
  554.  
  555. bool MainWnd::OpenFileDialog(LPTSTR pszFileName, int* pnFileName)
  556. {
  557.     bool            fReturn;
  558.     OPENFILENAME    ofn;
  559.  
  560.     pszFileName[0]          = 0;
  561.     ofn.lStructSize         = sizeof(ofn);
  562.     ofn.hwndOwner           = m_hWnd;
  563.     ofn.hInstance           = m_pApp->GetInstance();
  564.     ofn.lpstrFilter         = "Wave Files\0*.wav\0All Files\0*.*\0\0";
  565.     ofn.lpstrCustomFilter   = NULL;
  566.     ofn.nMaxCustFilter      = 0;
  567.     ofn.nFilterIndex        = 1;
  568.     ofn.lpstrFile           = pszFileName;
  569.     ofn.nMaxFile            = MAX_PATH;
  570.     ofn.lpstrFileTitle      = NULL;
  571.     ofn.nMaxFileTitle       = 0;
  572.     ofn.lpstrInitialDir     = /*grs.szInitialDir*/NULL;
  573.     ofn.lpstrTitle          = "File Open";
  574.     ofn.Flags               = OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_HIDEREADONLY;
  575.     ofn.nFileOffset         = 0;
  576.     ofn.nFileExtension      = 0;
  577.     ofn.lpstrDefExt         = "wav";
  578.     ofn.lCustData           = 0;
  579.     ofn.lpfnHook            = NULL;
  580.     ofn.lpTemplateName      = NULL;
  581.  
  582.     fReturn = GetOpenFileName(&ofn) ? true : false;
  583.  
  584.     return fReturn;
  585. }
  586.  
  587. void MainWnd::DestroyWindow(int)
  588. {
  589.     if(m_pListenerDlg)
  590.     {
  591.         delete m_pListenerDlg;
  592.         m_pListenerDlg = NULL;
  593.     }
  594.     if(m_dwTimer)
  595.     {
  596.         KillTimer(m_hWnd, m_dwTimer);
  597.         m_dwTimer = 0;
  598.     }
  599.  
  600.     if(m_hWnd)
  601.         ::DestroyWindow(m_hWnd);
  602.  
  603.     RELEASE(m_pListener)
  604.     RELEASE(m_pPrimary)
  605.     RELEASE(m_pDirectSound)
  606.  
  607.     if(m_hbmZoomFX)
  608.     {
  609.         DeleteObject(m_hbmZoomFX);
  610.         m_hbmZoomFX = NULL;
  611.     }
  612. }
  613.  
  614. void MainWnd::CloseWindow(int ret)
  615. {
  616.     DestroyWindow(ret);
  617. }
  618.  
  619. LRESULT MainWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  620. {
  621.     switch(message) 
  622.     {
  623.     case WM_COMMAND:
  624.         return EvCommand((UINT)LOWORD (wParam), (HWND)LOWORD (lParam), (UINT) HIWORD(wParam));
  625.     
  626.     case WM_PAINT:
  627.         EvPaint();
  628.         return 0;
  629.  
  630.     case WM_DESTROY:
  631.         EvDestroy();
  632.         break;
  633.  
  634.     case WM_CLOSE:
  635.         EvClose();
  636.         return 0;
  637.  
  638.     case WM_INITMENU:
  639.         return EvInitMenu((HMENU)wParam);
  640.  
  641.     case WM_ERASEBKGND:
  642.         return EvEraseBkgnd((HDC)wParam);
  643.  
  644.     case WM_TIMER:
  645.         return EvTimer(wParam);
  646. }
  647.     return DefWindowProc(m_hWnd, message, wParam, lParam);
  648. }
  649.  
  650. void MainWnd::EvPaint()
  651. {
  652.     PAINTSTRUCT    ps;
  653.     
  654.     BeginPaint(m_hWnd, &ps);
  655.     Paint(ps.hdc, ps.rcPaint, ps.fErase ? true : false);
  656.     EndPaint(m_hWnd, &ps);
  657. }
  658.  
  659. void MainWnd::EvClose()
  660. {
  661.     CloseWindow();
  662. }
  663.  
  664. void MainWnd::EvDestroy()
  665. {
  666.     if(m_pApp)
  667.         if(m_pApp->GetMainWindow() == this)
  668.             PostQuitMessage(0);
  669.  
  670.     m_hWnd = NULL;
  671. }
  672.  
  673. LRESULT    MainWnd::EvInitMenu(HMENU hMenu)
  674. {
  675.     if(hMenu == GetMenu(m_hWnd))
  676.     {
  677.         EnableMenuItem(hMenu, CM_FILE_OPEN, MF_BYCOMMAND|(m_dsCaps.dwFreeHw3DStaticBuffers == 0 ? MF_GRAYED : 0));
  678.         DrawMenuBar(m_hWnd);
  679.     }
  680.     return 0;
  681. }
  682.  
  683. LRESULT MainWnd::EvEraseBkgnd(HDC hdc)
  684. {
  685.     HDC        hdcMem;
  686.     HGDIOBJ hbmOld;
  687.  
  688.     hdcMem = CreateCompatibleDC(hdc);
  689.     if(hdcMem == NULL)
  690.         return 0;
  691.  
  692.     hbmOld = SelectObject(hdcMem, m_hbmZoomFX);
  693.     BitBlt(hdc, 0, 0, 256, 256, hdcMem, 0, 0, SRCCOPY);
  694.  
  695.     SelectObject(hdcMem, hbmOld);
  696.     DeleteDC(hdcMem);
  697.  
  698.     return 1;
  699. }
  700.  
  701. LRESULT MainWnd::EvTimer(WORD)
  702. {
  703.     DSCAPS dsCaps;
  704.     BufferList* pBuffer;
  705.  
  706.     dsCaps.dwSize = sizeof(dsCaps);
  707.     m_pDirectSound->GetCaps(&dsCaps);
  708.     if(memcmp(&dsCaps, &m_dsCaps, sizeof(m_dsCaps)))
  709.     {
  710.         memcpy(&m_dsCaps, &dsCaps, sizeof(m_dsCaps));
  711.         Invalidate(true);
  712.     }
  713.  
  714.     pBuffer = m_pBufferDlgs;
  715.     while(pBuffer)
  716.     {
  717.         pBuffer->pDlg->Update();
  718.         pBuffer = pBuffer->pNext;
  719.     }
  720.     return 0;
  721. }
  722. /////////////////////// MainWnd private member functions ///////////////////////////////////////////
  723.  
  724. void MainWnd::InstallWindowProc()
  725. {
  726.     DWORD processId;
  727.  
  728.     if(m_hWnd) 
  729.     {
  730.         GetWindowThreadProcessId(m_hWnd, &processId);
  731.         if(processId == GetCurrentProcessId()) 
  732.             m_DefaultProc = (WNDPROC)SetWindowLong(m_hWnd, GWL_WNDPROC, (long)GetThunk());
  733.     }
  734. }
  735.  
  736. LRESULT    CALLBACK MainWnd::StdWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  737. {
  738.     MainWnd* w;
  739.  
  740.     _asm mov w, eax
  741.     return w->WindowProc(message, wParam, lParam);
  742. }
  743.