ï¿½ï¿½Ê½22-1  TESTMCI
TESTMCI.C
/*---------------------------------------------------------------------------
   	TESTMCI.C -- MCI Command String Tester
                							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

#define ID_TIMER    1
BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("TestMci") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, szAppName, NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HWND	hwndEdit ;
     	int         iCharBeg, iCharEnd, iLineBeg, iLineEnd, iChar, iLine, iLength ;
     	MCIERROR    			error ;
     	RECT        			rect ;
     	TCHAR       			szCommand [1024], szReturn [1024], 
                 				szError [1024], szBuffer [32] ;

     	switch (message)
     	{
     	case 	WM_INITDIALOG:
               				// Center the window on screen

          			GetWindowRect (hwnd, &rect) ;
          			SetWindowPos (hwnd, NULL, 
               		 (GetSystemMetrics (SM_CXSCREEN) - rect.right + rect.left) / 2,
               		 (GetSystemMetrics (SM_CYSCREEN) - rect.bottom + rect.top) / 2,
               		0, 0, SWP_NOZORDER | SWP_NOSIZE) ;

          			hwndEdit = GetDlgItem (hwnd, IDC_MAIN_EDIT) ;
          			SetFocus (hwndEdit) ;
          			return FALSE ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          		case 	IDOK:
                    // Find the line numbers corresponding to the selection

                SendMessage (hwndEdit, EM_GETSEL, (WPARAM) &iCharBeg, 
                             (LPARAM) &iCharEnd) ;

               	iLineBeg = SendMessage (hwndEdit, EM_LINEFROMCHAR, iCharBeg, 0) ;
               	iLineEnd = SendMessage (hwndEdit, EM_LINEFROMCHAR, iCharEnd, 0) ;

                    // Loop through all the lines

               	for (iLine = iLineBeg ; iLine <= iLineEnd ; iLine++)
               		{
                     // Get the line and terminate it; ignore if blank

                    	* (WORD *) szCommand = sizeof (szCommand) / sizeof (TCHAR) ;

     					iLength = SendMessage 	(hwndEdit, EM_GETLINE, iLine, 
                                                 (LPARAM) szCommand) ;
                    	  szCommand [iLength] = '\0' ;

                    							if (iLength == 0)
                         						continue ;

             // Send the MCI command

             error =	mciSendString (szCommand, szReturn, 
             sizeof (szReturn) / sizeof (TCHAR), hwnd) ;

                        // Set the Return String field

             SetDlgItemText (hwnd, IDC_RETURN_STRING, szReturn) ;

                       // Set the Error String field (even if no error)

            mciGetErrorString (error, szError, sizeof (szError) / sizeof (TCHAR)) ;

			SetDlgItemText (hwnd, IDC_ERROR_STRING, szError) ;
				}
				// Send the caret to the end of the last selected line

				iChar  = SendMessage (hwndEdit, EM_LINEINDEX,  iLineEnd, 0) ;
               				iChar += SendMessage (hwndEdit, EM_LINELENGTH, iCharEnd, 0) ;
               				SendMessage (hwndEdit, EM_SETSEL, iChar, iChar) ;
               
                    				// Insert a carriage return/line feed combination

               		SendMessage (hwndEdit, EM_REPLACESEL, FALSE, 
                                (LPARAM) TEXT ("\r\n")) ;
               				SetFocus (hwndEdit) ;
               				return TRUE ;

          			case	IDCANCEL:
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			case	IDC_MAIN_EDIT:
               					if (HIWORD (wParam) == EN_ERRSPACE)
               					{
                  MessageBox (hwnd, TEXT ("Error control out of space."),
                             szAppName, MB_OK | MB_ICONINFORMATION) ;
                 return TRUE ;
               	}
               	break ;
          			}
          			break ;

     	case 	MM_MCINOTIFY:
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_MESSAGE), TRUE) ;

          			wsprintf (szBuffer, TEXT ("Device ID = %i"), lParam) ;
          			SetDlgItemText (hwnd, IDC_NOTIFY_ID, szBuffer) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_ID), TRUE) ;

          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_SUCCESSFUL),
                              	wParam & MCI_NOTIFY_SUCCESSFUL) ;
          
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_SUPERSEDED),
                              	wParam & MCI_NOTIFY_SUPERSEDED) ;

          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_ABORTED),
                              	wParam & MCI_NOTIFY_ABORTED) ;

          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_FAILURE),
                              	wParam & MCI_NOTIFY_FAILURE) ;

          			SetTimer (hwnd, ID_TIMER, 5000, NULL) ;
    			return TRUE ;

     	case 	WM_TIMER:
          			KillTimer (hwnd, ID_TIMER) ;

          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_MESSAGE), FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_ID), FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_SUCCESSFUL), FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_SUPERSEDED), FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_ABORTED), FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_NOTIFY_FAILURE), FALSE) ;
          			return TRUE ;

     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	SC_CLOSE:
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			}
         			break ;
     }
     	return FALSE ;
}

 TESTMCI.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
TESTMCI 	DIALOG DISCARDABLE  0, 0, 270, 276
STYLE 		WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION 	"MCI Tester"
FONT 8, 	"MS Sans Serif"
BEGIN
    	EDITTEXT        		IDC_MAIN_EDIT,8,8,254,100,ES_MULTILINE | ES_AUTOHSCROLL | 
                    					WS_VSCROLL
    	LTEXT           			"Return String:",IDC_STATIC,8,114,60,8
    	EDITTEXT        		IDC_RETURN_STRING,8,126,120,50,ES_MULTILINE | 
                    					ES_AUTOVSCROLL | ES_READONLY | WS_GROUP | NOT WS_TABSTOP
    	LTEXT           			"Error String:",IDC_STATIC,142,114,60,8
    	EDITTEXT        		IDC_ERROR_STRING,142,126,120,50,ES_MULTILINE | 
                    					ES_AUTOVSCROLL | ES_READONLY | NOT WS_TABSTOP
    	GROUPBOX        		"MM_MCINOTIFY Message",IDC_STATIC,9,186,254,58
    	LTEXT           			"",IDC_NOTIFY_ID,26,198,100,8
    	LTEXT   			"MCI_NOTIFY_SUCCESSFUL",IDC_NOTIFY_SUCCESSFUL,26,212,100,
                    					8,WS_DISABLED
    	LTEXT  			"MCI_NOTIFY_SUPERSEDED",IDC_NOTIFY_SUPERSEDED,26,226,100,
                    					8,WS_DISABLED
    	LTEXT  			"MCI_NOTIFY_ABORTED",IDC_NOTIFY_ABORTED,144,212,100,8,
                    					WS_DISABLED
    	LTEXT  			"MCI_NOTIFY_FAILURE",IDC_NOTIFY_FAILURE,144,226,100,8,
                    					WS_DISABLED
    	DEFPUSHBUTTON   	"OK",IDOK,57,255,50,14
    	PUSHBUTTON      		"Close",IDCANCEL,162,255,50,14
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by TestMci.rc

#define IDC_MAIN_EDIT                   						1000
#define IDC_NOTIFY_MESSAGE              						1005
#define IDC_NOTIFY_ID                   						1006
#define IDC_NOTIFY_SUCCESSFUL           					    1007
#define IDC_NOTIFY_SUPERSEDED           						1008
#define IDC_NOTIFY_ABORTED              						1009
#define IDC_NOTIFY_FAILURE              						1010
#define IDC_SIGNAL_MESSAGE              						1011
#define IDC_SIGNAL_ID                   						1012
#define IDC_SIGNAL_PARAM                						1013
#define IDC_RETURN_STRING               						1014
#define IDC_ERROR_STRING                						1015
#define IDC_DEVICES                     						1016
#define IDC_STATIC                      						-1

error = 	mciSendString (szCommand, szReturn, 
                       		sizeof (szReturn) / sizeof (TCHAR), hwnd) ;

open cdaudio

play cdaudio

pause cdaudio

stop cdaudio

play cdaudio

status cdaudio position

01:15:25

status cdaudio time format

msf

status cdaudio length

39:28:19

status cdaudio number of tracks

8

status cdaudio length track 5

04:30:22

status cdaudio position track 5

17:36:35

play cdaudio from 17:36:35 to 22:06:57

status cdaudio position track 6

set cdaudio time format tmsf

play cdaudio from 5:0:0:0 to 6:0:0:0

play cdaudio from 5 to 6

play cdaudio from 5:0:0 to 5:0:10 wait

play cdaudio wait

break cdaudio on 27

play cdaudio from 5:0:0 to 5:0:10 notify

stop cdaudio

eject cdaudio

close cdaudio

open cdaudio
set cdaudio time format tmsf
break cdaudio on 27
play 	cdaudio from 8 wait
play 	cdaudio from 1 to 2 wait
play 	cdaudio from 5 to 6 wait
stop 	cdaudio
eject 	cdaudio
close 	cdaudio

status cdaudio mode

status cdaudio position

 ï¿½ï¿½Ê½22-2  SINEWAVE
SINEWAVE.C
/*-------------------------------------------------------------------------
   	SINEWAVE.C -- 		Multimedia Windows Sine Wave Generator
                 							(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>
#include <math.h>
#include "resource.h"

#define 		SAMPLE_RATE     		11025	
#define 		FREQ_MIN           	    20	
#define 		FREQ_MAX         		5000	
#define 		FREQ_INIT         		440
#define 		OUT_BUFFER_SIZE  	    4096
#define 		PI                  	3.14159

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("SineWave") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, szAppName, NULL, DlgProc))
	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
	}
     	return 0 ;
}

VOID FillBuffer (PBYTE pBuffer, int iFreq)
{
     	static double 		fAngle ;
     	int    					i ;

     	for (i = 0 ; i < OUT_BUFFER_SIZE ; i++)
     	{
          		pBuffer [i] = (BYTE) (127 + 127 * sin (fAngle)) ;
          		fAngle += 2 * PI * iFreq / SAMPLE_RATE ;
     		if (	fAngle > 2 * PI)
               				fAngle -= 2 * PI ;
     }
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL         					bShutOff, bClosing ;
     	static 	HWAVEOUT     				hWaveOut ;
     	static 	HWND         					hwndScroll ;
     	static 	int          					iFreq = FREQ_INIT ;
     	static 	PBYTE        					pBuffer1, pBuffer2 ;
     	static 	PWAVEHDR     				pWaveHdr1, pWaveHdr2 ;
     	static 	WAVEFORMATEX 		waveformat ;
     	int                 								iDummy ;
     
     	switch (message)
     	{
     	case 	WM_INITDIALOG:
          			hwndScroll = 	GetDlgItem (hwnd, IDC_SCROLL) ;
          			SetScrollRange	(hwndScroll, SB_CTL, FREQ_MIN, FREQ_MAX, FALSE) ;
          			SetScrollPos 	(hwndScroll, SB_CTL, FREQ_INIT, TRUE) ;
          			SetDlgItemInt	(hwnd, IDC_TEXT, FREQ_INIT, FALSE) ;
          
          			return TRUE ;
          
     	case 	WM_HSCROLL:
          			switch (LOWORD (wParam))
          			{
          			case 	SB_LINELEFT:  		iFreq -=  1 ;  break ;
          			case 	SB_LINERIGHT: 		iFreq +=  1 ;  break ;
          			case 	SB_PAGELEFT:  		iFreq /=  2 ;  break ;
          			case 	SB_PAGERIGHT: 	iFreq *=  2 ;  break ;
               
          			case 	SB_THUMBTRACK:
               					iFreq = HIWORD (wParam) ;
               					break ;
               
          			case 	SB_TOP:
               					GetScrollRange (hwndScroll, SB_CTL, &iFreq, &iDummy) ;
               					break ;
               
          			case 	SB_BOTTOM:
               					GetScrollRange (hwndScroll, SB_CTL, &iDummy, &iFreq) ;
               					break ;
          			}
          
          			iFreq = max (FREQ_MIN, min (FREQ_MAX, iFreq)) ;
          			SetScrollPos (hwndScroll, SB_CTL, iFreq, TRUE) ;
          			SetDlgItemInt (hwnd, IDC_TEXT, iFreq, FALSE) ;
          			return TRUE ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDC_ONOFF:
                    					// If turning on waveform, hWaveOut is NULL
               
               					if (hWaveOut == NULL)
               					{
                      // Allocate memory for 2 headers and 2 buffers

                    	pWaveHdr1 	= malloc (sizeof (WAVEHDR)) ;
                    	pWaveHdr2 	= malloc (sizeof (WAVEHDR)) ;
                    	pBuffer1  		= malloc (OUT_BUFFER_SIZE) ;
                    	pBuffer2  		= malloc (OUT_BUFFER_SIZE) ;

          if (!pWaveHdr1 || !pWaveHdr2 || !pBuffer1 || !pBuffer2)
                  {
          if (!pWaveHdr1) free (pWaveHdr1) ;
          if (!pWaveHdr2) free (pWaveHdr2) ;
          if (!pBuffer1)  free (pBuffer1) ;
          if (!pBuffer2)  free (pBuffer2) ;

          MessageBeep (MB_ICONEXCLAMATION) ;
          MessageBox (hwnd, TEXT ("Error allocating memory!"),
                      szAppName, MB_ICONEXCLAMATION | MB_OK) ;
          return TRUE ;
         }

                         	// Variable to indicate Off button pressed

                   							bShutOff = FALSE ;
                         
                         	// Open waveform audio for output
                         
     waveformat.wFormatTag      				= WAVE_FORMAT_PCM ;
     waveformat.nChannels   					= 1 ;
     waveformat.nSamplesPerSec  			    = SAMPLE_RATE ;
     waveformat.nAvgBytesPerSec 		        = SAMPLE_RATE ;
     waveformat.nBlockAlign     				= 1 ;
     waveformat.wBitsPerSample  			    = 8 ;
     waveformat.cbSize          				= 0 ;
                         
     if (waveOutOpen (&hWaveOut, WAVE_MAPPER, &waveformat,
 DWORD) hwnd, 0, CALLBACK_WINDOW)!= MMSYSERR_NOERROR)
                    					{
          free (pWaveHdr1) ;
          free (pWaveHdr2) ;
          free (pBuffer1) ;
          free (pBuffer2) ;

          hWaveOut = NULL ;
          MessageBeep (MB_ICONEXCLAMATION) ;
          MessageBox (hwnd, TEXT ("Error opening waveform audio device!"),
                      szAppName, MB_ICONEXCLAMATION | MB_OK) ;
         return TRUE ;
         }

         // Set up headers and prepare them

         pWaveHdr1->lpData          					= pBuffer1 ;
         pWaveHdr1->dwBufferLength  					= OUT_BUFFER_SIZE ;
         pWaveHdr1->dwBytesRecorded 					= 0 ;
         pWaveHdr1->dwUser          					= 0 ;
         pWaveHdr1->dwFlags         					= 0 ;
         pWaveHdr1->dwLoops         					= 1 ;
         pWaveHdr1->lpNext          					= NULL ;
         pWaveHdr1->reserved        					= 0 ;
                    
         waveOutPrepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;

         pWaveHdr2->lpData          					= pBuffer2 ;
         pWaveHdr2->dwBufferLength  					= OUT_BUFFER_SIZE ;
         pWaveHdr2->dwBytesRecorded 					= 0 ;
         pWaveHdr2->dwUser          					= 0 ;
         pWaveHdr2->dwFlags         					= 0 ;
         pWaveHdr2->dwLoops         					= 1 ;
         pWaveHdr2->lpNext          					= NULL ;
         pWaveHdr2->reserved        					= 0 ;
                    
        waveOutPrepareHeader (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;
               					}
        // If turning off waveform, reset waveform audio
               	else
               					{
                    						bShutOff = TRUE ;
                    						waveOutReset (hWaveOut) ;
               					}
               					return TRUE ;
          			}
          			break ;

               				// Message generated from waveOutOpen call
               
     	case 	MM_WOM_OPEN:
          			SetDlgItemText (hwnd, IDC_ONOFF, TEXT ("Turn Off")) ;

               						// Send two buffers to waveform output device
                    
          			FillBuffer (pBuffer1, iFreq) ;
          			waveOutWrite (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
                    
          			FillBuffer (pBuffer2, iFreq) ;
          			waveOutWrite (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;
          			return TRUE ;

               						// Message generated when a buffer is finished
                    
     	case 	MM_WOM_DONE:
          			if (bShutOff)
          			{
               				waveOutClose (hWaveOut) ;
               				return TRUE ;
          			}

               				// Fill and send out a new buffer

          			FillBuffer (((PWAVEHDR) lParam)->lpData, iFreq) ;
          			waveOutWrite (hWaveOut, (PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
          			return TRUE ;
          
     	case 	MM_WOM_CLOSE:
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr2, sizeof (WAVEHDR)) ;

          			free (pWaveHdr1) ;
          			free (pWaveHdr2) ;
          			free (pBuffer1) ;
          			free (pBuffer2) ;

          			hWaveOut = NULL ;
          			SetDlgItemText (hwnd, IDC_ONOFF, TEXT ("Turn On")) ;
          
          			if (bClosing)
               					EndDialog (hwnd, 0) ;
          
          			return TRUE ;
          
     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case SC_CLOSE:
               					if (hWaveOut != NULL)
               					{
                    						bShutOff = TRUE ;
                    						bClosing = TRUE ;
                    
                    						waveOutReset (hWaveOut) ;
               					}
               					else
                    						EndDialog (hwnd, 0) ;
               
               					return TRUE ;
          			}
          			break ;
     		}
     		return FALSE ;
}

 SINEWAVE.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
SINEWAVE 		DIALOG DISCARDABLE  100, 100, 200, 50
STYLE 			WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION 		"Sine Wave Generator"
FONT 8, 		"MS Sans Serif"
BEGIN
    	SCROLLBAR       			IDC_SCROLL,8,8,150,12
    	RTEXT           					"440",IDC_TEXT,160,10,20,8
    	LTEXT           					"Hz",IDC_STATIC,182,10,12,8
    	PUSHBUTTON      			"Turn On",IDC_ONOFF,80,28,40,14
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by SineWave.rc

#define IDC_STATIC                      							-1
#define IDC_SCROLL                      						1000
#define IDC_TEXT                        						1001
#define IDC_ONOFF                       						1002

waveOutOpen (&hWaveOut, wDeviceID, &waveformat, dwCallBack,
             				dwCallBackData, dwFlags) ;

typedef struct waveformat_tag
{
     	WORD  	wFormatTag ;             // waveform format = WAVE_FORMAT_PCM
     	WORD  	nChannels ;         		// number of channels = 1 or 2
     	DWORD 	nSamplesPerSec ;    		// sample rate
     	DWORD 	nAvgBytesPerSec ; 	    // bytes per second
     	WORD  	nBlockAlign ;       		// block alignment
     	WORD  	wBitsPerSample ;    		// bits per samples = 8 or 16
     	WORD  	cbSize ;            		// 0 for PCM
}
WAVEFORMATEX, * PWAVEFORMATEX ;

waveOutOpen (	&hWaveOut, WAVE_MAPPER, &waveformat, 
             	 (DWORD) hwnd, 0, CALLBACK_WINDOW)

typedef struct wavehdr_tag
{
    	LPSTR lpData;                    				// pointer to data buffer
	    DWORD dwBufferLength;            				// length of data buffer
    	DWORD dwBytesRecorded;      				 	// used for recorded
    	DWORD dwUser;                    				// for program use
    	DWORD dwFlags;                   				// flags
    	DWORD dwLoops;                   				// number of repetitions
    	struct wavehdr_tag FAR *lpNext;  		        // reserved
    	DWORD reserved;                  				// reserved
} 
WAVEHDR, *PWAVEHDR ;

 ï¿½ï¿½Ê½22-3  RECORD1
RECORD1.C
/*---------------------------------------------------------------------------
   	RECORD1.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

#define INP_BUFFER_SIZE 16384
BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record1") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

void ReverseMemory (BYTE * pBuffer, int iLength)
{
     	BYTE 	b ;
     	int 	i ;
     
     	for (i = 0 ; i < iLength / 2 ; i++)
     	{
          		b = pBuffer [i] ;
          		pBuffer [i] = pBuffer [iLength - i - 1] ;
          		pBuffer [iLength - i - 1] = b ;
     	}
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL         			bRecording, bPlaying, bReverse, bPaused,
                         								bEnding, bTerminating ;
     	static 	DWORD        			dwDataLength, dwRepetitions = 1 ;
     	static 	HWAVEIN      		hWaveIn ;
     	static 	HWAVEOUT     		hWaveOut ;
     	static 	PBYTE        			pBuffer1, pBuffer2, pSaveBuffer, pNewBuffer ;
     	static 	PWAVEHDR     		pWaveHdr1, pWaveHdr2 ;
     	static 		TCHAR        		szOpenError[] = TEXT ("Error opening waveform audio!");
     	static 		TCHAR        		szMemError [] = TEXT ("Error allocating memory!") ;
     	static 	WAVEFORMATEX waveform ;
     
     	switch (message)
     {
     	case 	WM_INITDIALOG:
               				// Allocate memory for wave header
          
         		 	pWaveHdr1 = malloc (sizeof (WAVEHDR)) ;
          			pWaveHdr2 = malloc (sizeof (WAVEHDR)) ;
          
               				// Allocate memory for save buffer
          
          			pSaveBuffer = malloc (1) ;
          			return TRUE ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDC_RECORD_BEG:
                    				// Allocate buffer memory

               				pBuffer1 = malloc (INP_BUFFER_SIZE) ;
               				pBuffer2 = malloc (INP_BUFFER_SIZE) ;
               
               				if (!pBuffer1 || !pBuffer2)
               				{
                    					if (pBuffer1) free (pBuffer1) ;
                    					if (pBuffer2) free (pBuffer2) ;

                    					MessageBeep (MB_ICONEXCLAMATION) ;
                    					MessageBox (hwnd, szMemError, szAppName,
                                      	MB_ICONEXCLAMATION | MB_OK) ;
                    					return TRUE ;
               				}
               
                    					// Open waveform audio for input
               
               				waveform.wFormatTag      				= WAVE_FORMAT_PCM ;
               				waveform.nChannels       				= 1 ;
               				waveform.nSamplesPerSec  		= 11025 ;
               				waveform.nAvgBytesPerSec 	= 11025 ;
               				waveform.nBlockAlign     		= 1 ;
               				waveform.wBitsPerSample  		= 8 ;
               				waveform.cbSize          		= 0 ;
               
               	if (waveInOpen (&hWaveIn, WAVE_MAPPER, &waveform, 
                               (DWORD) hwnd, 0, CALLBACK_WINDOW))
               				{
                    					free (pBuffer1) ;
                    					free (pBuffer2) ;
                    					MessageBeep (MB_ICONEXCLAMATION) ;
                    					MessageBox (hwnd, szOpenError, szAppName,
                                      	MB_ICONEXCLAMATION | MB_OK) ;
               				}
                    					// Set up headers and prepare them
               
               				pWaveHdr1->lpData            = pBuffer1 ;
               				pWaveHdr1->dwBufferLength	= INP_BUFFER_SIZE ;
               				pWaveHdr1->dwBytesRecorded 	= 0 ;
               				pWaveHdr1->dwUser          	= 0 ;
               				pWaveHdr1->dwFlags         	= 0 ;
               				pWaveHdr1->dwLoops         	= 1 ;
               				pWaveHdr1->lpNext          	= NULL ;
               				pWaveHdr1->reserved        	= 0 ;
            waveInPrepareHeader (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;
          
              		 		pWaveHdr2->lpData          = pBuffer2 ;
               				pWaveHdr2->dwBufferLength  = INP_BUFFER_SIZE ;
               				pWaveHdr2->dwBytesRecorded 		= 0 ;
               				pWaveHdr2->dwUser          		= 0 ;
               				pWaveHdr2->dwFlags         		= 0 ;
               				pWaveHdr2->dwLoops         		= 1 ;
               				pWaveHdr2->lpNext          	= NULL ;
               				pWaveHdr2->reserved        		= 0 ;
          
               				waveInPrepareHeader (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;
               				return TRUE ;
               
          		case 	IDC_RECORD_END:
                    						// Reset input to return last buffer
               
               				bEnding = TRUE ;
               				waveInReset (hWaveIn) ;
               				return TRUE ;
               
          		case 	IDC_PLAY_BEG:
                    						// Open waveform audio for output
               
               				waveform.wFormatTag      				= WAVE_FORMAT_PCM ;
               				waveform.nChannels       	= 1 ;
               				waveform.nSamplesPerSec  		= 11025 ;
               				waveform.nAvgBytesPerSec 	= 11025 ;
               				waveform.nBlockAlign     		= 1 ;
               				waveform.wBitsPerSample  		= 8 ;
               				waveform.cbSize          		= 0 ;
               
               				if (waveOutOpen (&hWaveOut, WAVE_MAPPER, &waveform, 
                               (DWORD) hwnd, 0, CALLBACK_WINDOW))
               				{
                    		MessageBeep (MB_ICONEXCLAMATION) ;
                    		MessageBox (hwnd,	szOpenError, szAppName,
                         	MB_ICONEXCLAMATION | MB_OK) ;
               				}
               				return TRUE ;
               
          		case 	IDC_PLAY_PAUSE:
                    						// Pause or restart output
               
               				if (!bPaused)
               				{
               waveOutPause (hWaveOut) ;
               SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    			bPaused = TRUE ;
               				}
               				else
               				{
               waveOutRestart (hWaveOut) ;
               SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    			bPaused = FALSE ;
               				}
               					return TRUE ;
               
          			case 	IDC_PLAY_END:
                    		// Reset output for close preparation
               
               					bEnding = TRUE ;
               					waveOutReset (hWaveOut) ;
               					return TRUE ;
               
          			case 	IDC_PLAY_REV:
                   						 // Reverse save buffer and play
               
               					bReverse = TRUE ;
               					ReverseMemory (pSaveBuffer, dwDataLength) ;
               
               					SendMessage (hwnd, WM_COMMAND, IDC_PLAY_BEG, 0) ;
               					return TRUE ;
               
          			case 	IDC_PLAY_REP:
                    						// Set infinite repetitions and play
               
               					dwRepetitions = -1 ;
               					SendMessage (hwnd, WM_COMMAND, IDC_PLAY_BEG, 0) ;
               					return TRUE ;
               
          			case 	IDC_PLAY_SPEED:
                    						// Open waveform audio for fast output
               
               					waveform.wFormatTag     = WAVE_FORMAT_PCM ;
               					waveform.nChannels      = 1 ;
               					waveform.nSamplesPerSec =22050 ;
               					waveform.nAvgBytesPerSec= 22050 ;
               					waveform.nBlockAlign    = 1 ;
               					waveform.wBitsPerSample = 8 ;
               					waveform.cbSize         = 0 ;
               	if (waveOutOpen (&hWaveOut,	0, &waveform, (DWORD) hwnd, 0,
                    CALLBACK_WINDOW))
               					{
                    essageBeep (MB_ICONEXCLAMATION) ;
        MessageBox (hwnd, szOpenError, szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				}
               		return TRUE ;
          			}
          			break ;
               
     	case 	MM_WIM_OPEN:
               						// Shrink down the save buffer
          
          			pSaveBuffer = realloc (pSaveBuffer, 1) ;
          
               						// Enable and disable buttons
          
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), 	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), 	TRUE)  ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REV),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REP),   	FALSE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_SPEED), 	FALSE) ;
          			SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;

               						// Add the buffers
          
          			waveInAddBuffer (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveInAddBuffer (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;
          
               						// Begin sampling
          
          			bRecording = TRUE ;
          			bEnding = FALSE ;
          			dwDataLength = 0 ;
          			waveInStart (hWaveIn) ;
          			return TRUE ;
          
     	case 	MM_WIM_DATA:
         
               						// Reallocate save buffer memory
          
          			pNewBuffer = realloc (	pSaveBuffer, dwDataLength +
 ((PWAVEHDR) lParam)->dwBytesRecorded) ;
          
          			if (pNewBuffer == NULL)
          			{	
               					waveInClose 	(hWaveIn) ;
               					MessageBeep 	(MB_ICONEXCLAMATION) ;
               					MessageBox 	(hwnd, szMemError, szAppName,
                                MB_ICONEXCLAMATION | MB_OK) ;
               					return TRUE ;
          			}
          
          			pSaveBuffer = pNewBuffer ;
          			CopyMemory (pSaveBuffer + dwDataLength, ((PWAVEHDR) lParam)->lpData,
                    ((PWAVEHDR) lParam)->dwBytesRecorded) ;
          
          			dwDataLength += ((PWAVEHDR) lParam)->dwBytesRecorded ;
          
          			if (bEnding)
          			{
               				waveInClose (hWaveIn) ;
               				return TRUE ;
          			}
          
               			// Send out a new buffer
          
          			waveInAddBuffer (hWaveIn, (PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
          			return TRUE ;
          
     	case 	MM_WIM_CLOSE:
               				// Free the buffer memory

          			waveInUnprepareHeader (hWaveIn, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveInUnprepareHeader (hWaveIn, pWaveHdr2, sizeof (WAVEHDR)) ;

          			free (pBuffer1) ;
          			free (pBuffer2) ;
          
               				// Enable and disable buttons
          
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), TRUE) ;
          			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), FALSE) ;
          			SetFocus (GetDlgItem (hwnd, IDC_RECORD_BEG)) ;
          
          			if (dwDataLength > 0)
          			{
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) 	;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE) 	;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REP),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_REV),   	TRUE)  		;
               		EnableWindow (GetDlgItem (hwnd, IDC_PLAY_SPEED), 	TRUE)  		;
               		SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
          			}
          			bRecording = FALSE ;
          
          			if (bTerminating)
               				SendMessage (hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L) ;
          
          			return TRUE ;
          
     	case	MM_WOM_OPEN:
               				// Enable and disable buttons
          
          	EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE),	    TRUE);
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   	TRUE);
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REP),  	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REV),   	FALSE) 	;
          	EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_SPEED),	FALSE) 	;
          	SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;
          
               				// Set up header
          
          			pWaveHdr1->lpData          	= pSaveBuffer ;
          			pWaveHdr1->dwBufferLength  	= dwDataLength ;
          			pWaveHdr1->dwBytesRecorded 	= 0 ;
          			pWaveHdr1->dwUser          	= 0 ;
          			pWaveHdr1->dwFlags         	= WHDR_BEGINLOOP | WHDR_ENDLOOP ;
          			pWaveHdr1->dwLoops         	= dwRepetitions ;
          			pWaveHdr1->lpNext          	= NULL ;
          			pWaveHdr1->reserved        	= 0 ;
          
               				// Prepare and write
          
          			waveOutPrepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutWrite (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          
          			bEnding = FALSE ;
          			bPlaying = TRUE ;
          			return TRUE ;
          
     	case 	MM_WOM_DONE:
          			waveOutUnprepareHeader (hWaveOut, pWaveHdr1, sizeof (WAVEHDR)) ;
          			waveOutClose (hWaveOut) ;
          			return TRUE ;
          
     	case 	MM_WOM_CLOSE:
               				// Enable and disable buttons
          
          			EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE) 	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   		FALSE) 	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REV),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_REP),   		TRUE)  	;
          			EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_SPEED), 	TRUE)  	;
          			SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
          
          			SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
          			bPaused = FALSE ;
          			dwRepetitions = 1 ;
          			bPlaying = FALSE ;
          
          			if (bReverse)
          			{
               				ReverseMemory (pSaveBuffer, dwDataLength) ;
               				bReverse = FALSE ;
          			}
          
          			if (bTerminating)
               				SendMessage (hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L) ;
          
          			return TRUE ;
          
     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
               					{
                    						bTerminating = TRUE ;
                    						bEnding = TRUE ;
                    						waveInReset (hWaveIn) ;
                    						return TRUE ;
               					}
               					if (bPlaying)
               					{
                    						bTerminating = TRUE ;
                    						bEnding = TRUE ;
                    						waveOutReset (hWaveOut) ;
                    						return TRUE ;
               					}
               
               					free (pWaveHdr1) ;
               					free (pWaveHdr2) ;
               					free (pSaveBuffer) ;
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          				}
          				break ;
     	}
     	return FALSE ;
}

 RECORD.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
RECORD 		DIALOG DISCARDABLE  100, 100, 152, 74
STYLE 			WS_MINIMIZEBOX | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION 		"Waveform Audio Recorder"
FONT 8, 		"MS Sans Serif"
BEGIN
    	PUSHBUTTON      		"Record",IDC_RECORD_BEG,28,8,40,14
    	PUSHBUTTON      		"End",IDC_RECORD_END,76,8,40,14,WS_DISABLED
    	PUSHBUTTON      		"Play",IDC_PLAY_BEG,8,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"Pause",IDC_PLAY_PAUSE,56,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"End",IDC_PLAY_END,104,30,40,14,WS_DISABLED
    	PUSHBUTTON      		"Reverse",IDC_PLAY_REV,8,52,40,14,WS_DISABLED
    	PUSHBUTTON      		"Repeat",IDC_PLAY_REP,56,52,40,14,WS_DISABLED
    	PUSHBUTTON      		"Speedup",IDC_PLAY_SPEED,104,52,40,14,WS_DISABLED
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by Record.rc

#define 		IDC_RECORD_BEG                  					1000
#define 		IDC_RECORD_END                  					1001
#define 		IDC_PLAY_BEG                    					1002
#define 		IDC_PLAY_PAUSE                  					1003
#define 		IDC_PLAY_END                    					1004
#define 		IDC_PLAY_REV                    					1005
#define 		IDC_PLAY_REP                    					1006
#define 		IDC_PLAY_SPEED                  					1007

 ï¿½ï¿½Ê½22-4  RECORD2
RECORD2.C
/*---------------------------------------------------------------------------
   	RECORD2.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
 ------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\record1\\resource.h"

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record2") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
      	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

void ShowError (HWND hwnd, DWORD dwError)
{
     	TCHAR szErrorStr [1024] ;
     	mciGetErrorString (dwError, szErrorStr, sizeof (szErrorStr) / sizeof (TCHAR)) ;
     	MessageBeep (MB_ICONEXCLAMATION) ;
     	MessageBox (hwnd, szErrorStr, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static 	BOOL    bRecording, bPlaying, bPaused ;
     	static 	TCHAR   szFileName[] = TEXT ("record2.wav") ;
     	static 	WORD    wDeviceID ;
     	DWORD             		dwError ;
     	MCI_GENERIC_PARMS 		mciGeneric ;
     	MCI_OPEN_PARMS    		mciOpen ;
     	MCI_PLAY_PARMS    		mciPlay ;
     	MCI_RECORD_PARMS  		mciRecord ;
     	MCI_SAVE_PARMS    		mciSave ;
     
     	switch (message)
     {
     	case 	WM_COMMAND:
          			switch (wParam)
          			{
          			case 	IDC_RECORD_BEG:
                    						// Delete existing waveform file
               
               					DeleteFile (szFileName) ;
               
                    						// Open waveform audio
               
               					mciOpen.dwCallback       				= 0 ;
               					mciOpen.wDeviceID        					= 0 ;
               					mciOpen.lpstrDeviceType  		= TEXT ("waveaudio") ;
               					mciOpen.lpstrElementName 		= TEXT ("") ; 
               					mciOpen.lpstrAlias       		= NULL ;
               					dwError = mciSendCommand (0, MCI_OPEN, 
                                MCI_WAIT | MCI_OPEN_TYPE | MCI_OPEN_ELEMENT,
                                (DWORD) (LPMCI_OPEN_PARMS) &mciOpen) ;
               					if (dwError != 0)
               					{
                    						ShowError (hwnd, dwError) ;
                    						return TRUE ;
               					}
                    						// Save the Device ID
               
               					wDeviceID = mciOpen.wDeviceID ;
               
                    						// Begin recording
               
               					mciRecord.dwCallback 			= (DWORD) hwnd ;
               					mciRecord.dwFrom     				= 0 ;
               					mciRecord.dwTo       					= 0 ;
               
               					mciSendCommand (wDeviceID, MCI_RECORD, MCI_NOTIFY,
                               	 (DWORD) (LPMCI_RECORD_PARMS) &mciRecord) ;
               
                    			// Enable and disable buttons
               
               			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), TRUE) ;
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               			EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               			SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;
               
               					bRecording = TRUE ;
               					return TRUE ;
               
          			case 	IDC_RECORD_END:
                    								// Stop recording
               
               		mciGeneric.dwCallback = 0 ;
               
               		mciSendCommand (wDeviceID, MCI_STOP, MCI_WAIT,
                    (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;
               
                    								// Save the file

               		mciSave.dwCallback = 0 ;
               		mciSave.lpfilename = szFileName ;
               
               		mciSendCommand (wDeviceID, MCI_SAVE, MCI_WAIT | MCI_SAVE_FILE,
                    (DWORD) (LPMCI_SAVE_PARMS) &mciSave) ;
               
                    								// Close the waveform device
               
               		mciSendCommand (wDeviceID, MCI_CLOSE, MCI_WAIT,
                    (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;
               
                    								// Enable and disable buttons
               
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_BEG), 	TRUE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_END), 	FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_BEG),   	TRUE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), 	FALSE);
            EnableWindow	(GetDlgItem 	(hwnd, IDC_PLAY_END),       FALSE);
            SetFocus 		 (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
               
            bRecording = FALSE ;
            return TRUE ;
               
          			case 	IDC_PLAY_BEG:
                    						// Open waveform audio
               
               					mciOpen.dwCallback      	 	= 0 ;
               					mciOpen.wDeviceID        		= 0 ;
               					mciOpen.lpstrDeviceType  		= NULL ;
               					mciOpen.lpstrElementName 		= szFileName ;
               					mciOpen.lpstrAlias       		= NULL ;
               
               					dwError = mciSendCommand (	0, MCI_OPEN,
                               MCI_WAIT | MCI_OPEN_ELEMENT,
                               (DWORD) (LPMCI_OPEN_PARMS) &mciOpen) ;
               
               					if (dwError != 0)
               					{
                    						ShowError (hwnd, dwError) ;
                    						return TRUE ;
               					}
                    							// Save the Device ID
               
               					wDeviceID = mciOpen.wDeviceID ;
               
                    							// Begin playing
               
               					mciPlay.dwCallback 		= (DWORD) hwnd ;
               					mciPlay.dwFrom     				= 0 ;
               					mciPlay.dwTo       				= 0 ;
               
               					mciSendCommand (wDeviceID, MCI_PLAY, MCI_NOTIFY,
                               	 (DWORD) (LPMCI_PLAY_PARMS) &mciPlay) ;
               
                    							// Enable and disable buttons
               
         	EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_BEG), FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_RECORD_END), FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_BEG), 	FALSE);
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), TRUE) ;
            EnableWindow 	(GetDlgItem 	(hwnd, IDC_PLAY_END),   TRUE) ;
            SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;
               
            bPlaying = TRUE ;
            return TRUE ;
               
          			case 	IDC_PLAY_PAUSE:
               					if (!bPaused)
                         						// Pause the play
               				{
                    	mciGeneric.dwCallback = 0 ;
                    
                    	mciSendCommand (wDeviceID, MCI_PAUSE, MCI_WAIT,
                        (DWORD) (LPMCI_GENERIC_PARMS) & mciGeneric);
                    
           SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    	Paused = TRUE ;
               				}
               				else
                         							// Begin playing again
               				{
                    		mciPlay.dwCallback 		= (DWORD) hwnd ;
                    		mciPlay.dwFrom     				= 0 ;
                    		mciPlay.dwTo       				= 0 ;
                    
                    		mciSendCommand (wDeviceID, MCI_PLAY, MCI_NOTIFY,
                            (DWORD) (LPMCI_PLAY_PARMS) &mciPlay) ;
                    
           SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    		bPaused = FALSE ;
               				}
               
               				return TRUE ;
               
          		case 	IDC_PLAY_END:
                    						// Stop and close
               
               	mciGeneric.dwCallback = 0 ;
               
               	mciSendCommand (wDeviceID, MCI_STOP, MCI_WAIT,
                (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;
               
               	mciSendCommand (wDeviceID, MCI_CLOSE, MCI_WAIT,
                (DWORD) (LPMCI_GENERIC_PARMS) &mciGeneric) ;
               
                 // Enable and disable buttons
               
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_RECORD_BEG),	TRUE) ;
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_RECORD_END),	FALSE);
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_BEG),	TRUE) ;
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_PAUSE),	FALSE);
               	EnableWindow 	(GetDlgItem	(hwnd, IDC_PLAY_END), 	FALSE);
               	SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
               
               	bPlaying = FALSE ;
               	bPaused  = FALSE ;
               	return TRUE ;
          			}
          			break ;
               
     	case 	MM_MCINOTIFY:
          			switch (wParam)
          			{
          			case 	MCI_NOTIFY_SUCCESSFUL:
               					if (bPlaying)
                    SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0) ;
               
               					if (bRecording)
                    SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0);
               
               					return TRUE ;
          			}
          			break ;
     
     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
                    		SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0L) ;
               					if (bPlaying)
                    		SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0L) ;
               
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			}
          			break ;
     }
	return FALSE ;
}

error = mciSendCommand (wDeviceID, message, dwFlags, dwParam)

mciGetErrorString (error, szBuffer, dwLength)

bSuccess = mciExecute (szCommand) ;

 ï¿½ï¿½Ê½22-5  RECORD3
RECORD3.C
/*---------------------------------------------------------------------------
   	RECORD3.C -- Waveform Audio Recorder
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\record1\\resource.h"

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("Record3") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, TEXT ("Record"), NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
 	}
     	return 0 ;
}

BOOL mciExecute (LPCTSTR szCommand)
{
     	MCIERROR error ;
     	TCHAR    szErrorStr [1024] ;

     	if (error = mciSendString (szCommand, NULL, 0, NULL))
     	{
          		mciGetErrorString (error, szErrorStr, sizeof (szErrorStr) / sizeof (TCHAR)) ;
          		MessageBeep (MB_ICONEXCLAMATION) ;
          		MessageBox (	NULL, szErrorStr, TEXT ("MCI Error"), 
                      							MB_OK | MB_ICONEXCLAMATION) ;
     	}
     	return error == 0 ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static BOOL bRecording, bPlaying, bPaused ;
     	switch (message)
     	{
     	case 	WM_COMMAND:
          			switch (wParam)
          			{
          			case 	IDC_RECORD_BEG:
                    						// Delete existing waveform file
               
               						DeleteFile (TEXT ("record3.wav")) ;
               
                    						// Open waveform audio and record
               
               					if (!mciExecute (TEXT ("open new type waveaudio alias mysound")))
                    						return TRUE ;
               
               					mciExecute (TEXT ("record mysound")) ;
               
                    						// Enable and disable buttons
               
               					EnableWindow (GetDlgItem (hwnd, IDC_RECORD_BEG), FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_RECORD_END), TRUE) ;
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_BEG),   FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               					EnableWindow (GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               					SetFocus (GetDlgItem (hwnd, IDC_RECORD_END)) ;
               
               					bRecording = TRUE ;
               					return TRUE ;
               
          			case	IDC_RECORD_END:
                    						// Stop, save, and close recording
               
               					mciExecute (TEXT ("stop mysound")) ;
               					mciExecute (TEXT ("save mysound record3.wav")) ;
               					mciExecute (TEXT ("close mysound")) ;
               
                    						// Enable and disable buttons
               
               					EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), 	TRUE) ;
               					EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), 	FALSE);
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),  	TRUE) ;
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), 	FALSE);
               					EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   	FALSE);
               					SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
               
               					bRecording = FALSE ;
               					return TRUE ;
               
          			case 	IDC_PLAY_BEG:
                    						// Open waveform audio and play
               
               					if (!mciExecute (TEXT ("open record3.wav alias mysound")))
                    						return TRUE ;
               
               					mciExecute (TEXT ("play mysound")) ;
               
                    						// Enable and disable buttons
               
              	EnableWindow (GetDlgItem 	(hwnd, IDC_RECORD_BEG), 	FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_RECORD_END), 	FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_BEG), 		FALSE);
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_PAUSE), 	TRUE) ;
               	EnableWindow (GetDlgItem 	(hwnd, IDC_PLAY_END), 		TRUE) ;
               	SetFocus (GetDlgItem (hwnd, IDC_PLAY_END)) ;
               
               	bPlaying = TRUE ;
                return TRUE ;
               
          			case 	IDC_PLAY_PAUSE:
               					if (!bPaused)
                         						// Pause the play
               					{
                    					mciExecute (TEXT ("pause mysound")) ;
                    					SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Resume")) ;
                    					bPaused = TRUE ;
               				}
               				else
                         						// Begin playing again
               				{
                    					mciExecute (TEXT ("play mysound")) ;
                    					SetDlgItemText (hwnd, IDC_PLAY_PAUSE, TEXT ("Pause")) ;
                    					bPaused = FALSE ;
               				}
               
               				return TRUE ;
               
          			case 	IDC_PLAY_END:
                    						// Stop and close
               
               				mciExecute (TEXT ("stop mysound")) ;
               				mciExecute (TEXT ("close mysound")) ;
               
                    						// Enable and disable buttons
               				EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_BEG), TRUE) ;
               				EnableWindow 	(GetDlgItem (hwnd, IDC_RECORD_END), FALSE);
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_BEG),   TRUE) ;
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_PAUSE), FALSE);
               				EnableWindow 	(GetDlgItem (hwnd, IDC_PLAY_END),   FALSE);
               				SetFocus (GetDlgItem (hwnd, IDC_PLAY_BEG)) ;
               
               				bPlaying = FALSE ;
               				bPaused  = FALSE ;
               				return TRUE ;
          			}
          			break ;
     
     	case 	WM_SYSCOMMAND:
          			switch (wParam)
          			{
          			case 	SC_CLOSE:
               					if (bRecording)
                    		SendMessage (hwnd, WM_COMMAND, IDC_RECORD_END, 0L);
               
               					if (bPlaying)
                    		SendMessage (hwnd, WM_COMMAND, IDC_PLAY_END, 0L) ;
               
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
          			}
          			break ;
  	}
     	return FALSE ;
}

 ï¿½ï¿½Ê½22-6  ADDSYNTH
ADDSYNTH.C
/*--------------------------------------------------------------------------
   	ADDSYNTH.C -- Additive Synthesis Sound Generation
                 						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include <math.h>
#include "addsynth.h"
#include "resource.h"

#define 		ID_TIMER           1
#define 		SAMPLE_RATE      	22050
#define 		MAX_PARTIALS     21
#define 		PI             		3.14159

BOOL CALLBACK DlgProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName [] = TEXT ("AddSynth") ;
// Sine wave generator
// -------------------

double SineGenerator (double dFreq, double * pdAngle)
{
     	double dAmp ;
     	dAmp = sin (* pdAngle) ;
     	* pdAngle += 2 * PI * dFreq / SAMPLE_RATE ;
     
     	if (* pdAngle >= 2 * PI)
          			* pdAngle -= 2 * PI ;
     
     	return dAmp ;
}

// Fill a buffer with composite waveform
// -------------------------------------

VOID FillBuffer (INS ins, PBYTE pBuffer, int iNumSamples)
{
     	static double 		dAngle [MAX_PARTIALS] ;
     	double        				dAmp, dFrq, dComp, dFrac ;
     	int           					i, iPrt, iMsecTime, iCompMaxAmp, iMaxAmp, iSmp ;
          				// Calculate the composite maximum amplitude
     
     	iCompMaxAmp = 0 ;
     	for (iPrt = 0 ; iPrt < ins.iNumPartials ; iPrt++)
     	{
          			iMaxAmp = 0 ;
          			for (i = 0 ; i < ins.pprt[iPrt].iNumAmp ; i++)
               					iMaxAmp = max (iMaxAmp, ins.pprt[iPrt].pEnvAmp[i].iValue) ;
          			iCompMaxAmp += iMaxAmp ;
	}
     
          				// Loop through each sample
     	for (iSmp = 0 ; iSmp < iNumSamples ; iSmp++)
     	{
          			dComp = 0 ;
          			iMsecTime = (int) (1000 * iSmp / SAMPLE_RATE) ;
          
               				// Loop through each partial
          			for (iPrt = 0 ; iPrt < ins.iNumPartials ; iPrt++)
          			{
               				dAmp = 0 ;
               				dFrq = 0 ;
               
               				for (i = 0 ; i < ins.pprt[iPrt].iNumAmp - 1 ; i++)
               				{
           if (iMsecTime >= ins.pprt[iPrt].pEnvAmp[i  ].iTime &&
           iMsecTime <= ins.pprt[iPrt].pEnvAmp[i+1].iTime)
                    		{
           dFrac = (double) (iMsecTime -
           ins.pprt[iPrt].pEnvAmp[i  ].iTime) /
           (ins.pprt[iPrt].pEnvAmp[i+1].iTime -
           ins.pprt[iPrt].pEnvAmp[i  ].iTime) ;
                         
           dAmp = dFrac  * ins.pprt[iPrt].pEnvAmp[i+1].iValue +
           (1-dFrac) * ins.pprt[iPrt].pEnvAmp[i  ].iValue ;
           break ;
           }
           }
               
           for (i = 0 ; i < ins.pprt[iPrt].iNumFrq - 1 ; i++)
           {
          if (iMsecTime >= ins.pprt[iPrt].pEnvFrq[i  ].iTime &&
              iMsecTime <= ins.pprt[iPrt].pEnvFrq[i+1].iTime)
           {
              dFrac = (double) (iMsecTime -ins.pprt[iPrt].pEnvFrq[i  ].iTime) /
                              				(ins.pprt[iPrt].pEnvFrq[i+1].iTime -
                              				ins.pprt[iPrt].pEnvFrq[i  ].iTime) ;
              dFrq = dFrac  * ins.pprt[iPrt].pEnvFrq[i+1].iValue + (1-dFrac) * 
ins.pprt[iPrt].pEnvFrq[i  ].iValue ;
            break ;
              }
              }
             dComp += dAmp * SineGenerator (dFrq, dAngle + iPrt) ;
          		}
          	pBuffer[iSmp] = (BYTE) (127 + 127 * dComp / iCompMaxAmp) ;
     	}
}

// Make a waveform file
// -------------------------------------------------------------------------

BOOL MakeWaveFile (INS ins, TCHAR * szFileName)
{
     	DWORD        				dwWritten ;
     	HANDLE       				hFile ;
     	int          				iChunkSize, iPcmSize, iNumSamples ;
     	PBYTE        				pBuffer ;
     	WAVEFORMATEX 		        waveform ;

     	hFile = CreateFile (szFileName, GENERIC_WRITE, 0, NULL,
                CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL) ;
	if (hFile == NULL)
          			return FALSE ;
     	iNumSamples = ((long) ins.iMsecTime * SAMPLE_RATE / 1000 + 1) / 2 * 2 ;
     	iPcmSize    = sizeof (PCMWAVEFORMAT) ;
     	iChunkSize 	= 12 + iPcmSize + 8 + iNumSamples ;
     
     	if (NULL == (pBuffer = malloc (iNumSamples)))
     	{
          		CloseHandle (hFile) ;
          		return FALSE ;
     	}
     
     	FillBuffer (ins, pBuffer, iNumSamples) ;
     	waveform.wFormatTag      			= WAVE_FORMAT_PCM ;
     	waveform.nChannels       			= 1 ;
     	waveform.nSamplesPerSec           	= SAMPLE_RATE ;
     	waveform.nAvgBytesPerSec            = SAMPLE_RATE ;
     	waveform.nBlockAlign     			= 1 ;
     	waveform.wBitsPerSample  = 8 ;
     	waveform.cbSize          = 0 ;
     
     	WriteFile 	(hFile, "RIFF", 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iChunkSize, 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, "WAVEfmt ", 8, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iPcmSize, 4, &dwWritten, NULL) ;
     	WriteFile 	 (hFile, &waveform, sizeof (WAVEFORMATEX) - 2, &dwWritten, NULL) ;
     	WriteFile 	(hFile, "data", 4, &dwWritten, NULL) ;
     	WriteFile 	(hFile, &iNumSamples, 4, &dwWritten, NULL) ;
     	WriteFile (hFile, pBuffer, 			iNumSamples,  &dwWritten, NULL) ;
     
     	CloseHandle (hFile) ;
     	free (pBuffer) ;
     
     	if ((int) dwWritten != iNumSamples)
     	{
          		DeleteFile (szFileName) ;
          		return FALSE ;
     	}
     	return TRUE ;
}

void TestAndCreateFile (	HWND hwnd, INS ins, TCHAR * szFileName, 
									int idButton)
{
     	TCHAR szMessage [64] ;
     	if (-1 != GetFileAttributes (szFileName))
          			EnableWindow (GetDlgItem (hwnd, idButton), TRUE) ;
     	else
     	{
          		if (MakeWaveFile (ins, szFileName))
               				EnableWindow (GetDlgItem (hwnd, idButton), TRUE) ;
          		else
       		{
              			 	wsprintf (szMessage, TEXT ("Could not create %x."), szFileName) ;
               				MessageBeep (MB_ICONEXCLAMATION) ;
               				MessageBox (hwnd, 	szMessage, szAppName,
                            MB_OK | MB_ICONEXCLAMATION) ;
      		}
     	}
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	if (-1 == DialogBox (hInstance, szAppName, NULL, DlgProc))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
     	}
     	return 0 ;
}

BOOL CALLBACK DlgProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static TCHAR * szTrum = TEXT ("Trumpet.wav") ;
     	static TCHAR * szOboe = TEXT ("Oboe.wav") ;
     	static TCHAR * szClar = TEXT ("Clarinet.wav") ;
     
     	switch (message)
     	{
     	case 	WM_INITDIALOG:
          			SetTimer (hwnd, ID_TIMER, 1, NULL) ;
          			return TRUE ;
          
     	case 	WM_TIMER:
          			KillTimer (hwnd, ID_TIMER) ;
          			SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
          			ShowCursor (TRUE) ;
          
          			TestAndCreateFile (hwnd, insTrum, szTrum, IDC_TRUMPET) ;
          			TestAndCreateFile (hwnd, insOboe, szOboe, IDC_OBOE) ;
          			TestAndCreateFile (hwnd, insClar, szClar, IDC_CLARINET) ;
          
          			SetDlgItemText (hwnd, IDC_TEXT, TEXT (" ")) ;
          			SetFocus (GetDlgItem (hwnd, IDC_TRUMPET)) ;
          
          			ShowCursor (FALSE) ;
          			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
          			return TRUE ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{		
          			case 	IDC_TRUMPET:
               					PlaySound (szTrum, NULL, SND_FILENAME | SND_SYNC) ;
               					return TRUE ;
               
          			case 	IDC_OBOE:
               					PlaySound (szOboe, NULL, SND_FILENAME | SND_SYNC) ;
               					return TRUE ;
               
          			case 	IDC_CLARINET:
               					PlaySound (szClar, NULL, SND_FILENAME |SND_SYNC) ;
               					return TRUE ;
          			}
          			break ;
          
     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case SC_CLOSE:
               					EndDialog (hwnd, 0) ;
               					return TRUE ;
         	 		}
          			break ;
     	}
     	return FALSE ;
}

 ADDSYNTH.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
ADDSYNTH 		DIALOG DISCARDABLE  100, 100, 176, 49
STYLE 			WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU
CAPTION 		"Additive Synthesis"
FONT 8, 		               "MS Sans Serif"
BEGIN
	PUSHBUTTON      			"Trumpet",IDC_TRUMPET,8,8,48,16
    	PUSHBUTTON      			"Oboe",IDC_OBOE,64,8,48,16
    	PUSHBUTTON      			"Clarinet",IDC_CLARINET,120,8,48,16
    	LTEXT           			"Preparing Data...",IDC_TEXT,8,32,100,8
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by AddSynth.rc

#define 		IDC_TRUMPET                     			1000
#define 		IDC_OBOE                        			1001
#define 		IDC_CLARINET                    			1002
#define 		IDC_TEXT                        			1003

 ï¿½ï¿½Ê½22-7  WAKEUP
WAKEUP.C
/*---------------------------------------------------------------------------
   	WAKEUP.C -- 	Alarm Clock Program
               						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
#include <commctrl.h>

     		// ID values for 3 child windows
#define 		ID_TIMEPICK 		0
#define 		ID_CHECKBOX		1
#define 		ID_PUSHBTN		2

     		// Timer ID

#define 		ID_TIMER			1

     		// Number of 100-nanosecond increments (ie FILETIME ticks) in an hour
#define FTTICKSPERHOUR (60 * 60 * (LONGLONG) 10000000)
     		// Defines and structure for waveform "file"
#define 		SAMPRATE 		11025
#define 		NUMSAMPS 		(3 * SAMPRATE)
#define 		HALFSAMPS	(NUMSAMPS / 2) 

typedef struct
{
     	char  		chRiff[4] ;
     	DWORD 		dwRiffSize ;
     	char  		chWave[4] ;
     	char  		chFmt [4] ;
     	DWORD 		dwFmtSize ;
     	PCMWAVEFORMAT pwf ;
     	char  		chData[4] ;
     	DWORD 		dwDataSize ;
     	BYTE  		byData[0] ;
}
WAVEFORM ;
     	// The window proc and the subclass proc
LRESULT 	CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
LRESULT 	CALLBACK SubProc (HWND, UINT, WPARAM, LPARAM) ;

     	// Original window procedure addresses for the subclassed windows

WNDPROC SubbedProc [3] ;

     	// The current child window with the input focus

HWND hwndFocus ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInst,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR	szAppName [] = TEXT ("WakeUp") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
	
     	wndclass.style         			= 0 ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) (1 + COLOR_BTNFACE) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}

     	hwnd = CreateWindow (	szAppName, szAppName,
                          		WS_OVERLAPPED | WS_CAPTION | 
                                WS_SYSMENU | WS_MINIMIZEBOX,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static HWND          		hwndDTP, hwndCheck, hwndPush ;
     	static WAVEFORM      		waveform = { "RIFF", NUMSAMPS + 0x24, 
"WAVE", "fmt ", 
            						sizeof (PCMWAVEFORMAT), 1, 1, SAMPRATE, 
                                    SAMPRATE, 1, 8, "data", NUMSAMPS } ;
     	static WAVEFORM    			* pwaveform ;
     	FILETIME             		ft ;
     	HINSTANCE            		hInstance ;
     	INITCOMMONCONTROLSEX		icex ;
     	int                  		i, cxChar, cyChar ;
     	LARGE_INTEGER        		li ;
     	SYSTEMTIME           		st ;

     	switch (message)
     	{
     	case 	WM_CREATE:
               					// Some initialization stuff

          			hInstance = (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE) ;

          			icex.dwSize = sizeof (icex) ;
          			icex.dwICC  = ICC_DATE_CLASSES ;
          			InitCommonControlsEx (&icex) ;

               		// Create the waveform file with alternating square waves

          			pwaveform = malloc (sizeof (WAVEFORM) + NUMSAMPS) ;
          			* pwaveform = waveform ;

          			for (i = 0 ; i < HALFSAMPS ; i++)
               					if (i % 600 < 300)
                    			if (i % 16 < 8)
                    pwaveform->byData[i] = 25 ;
                    else
                    pwaveform->byData[i] = 230 ;
               		else
                    if (i % 8 < 4)
                    pwaveform->byData[i] = 25 ;
                    else
                    pwaveform->byData[i] = 230 ;
               		// Get character size and set a fixed window size.
          			cxChar = LOWORD (GetDialogBaseUnits ()) ;
          			cyChar = HIWORD (GetDialogBaseUnits ()) ;

			SetWindowPos (	hwnd, NULL, 0, 0, 42 * cxChar, 10 * cyChar / 3 + 2 * 
GetSystemMetrics (SM_CYBORDER) +GetSystemMetrics (SM_CYCAPTION)
,SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE) ; 

               					// Create the three child windows

          	hwndDTP = CreateWindow (DATETIMEPICK_CLASS, TEXT (""), 
                      WS_BORDER | WS_CHILD | WS_VISIBLE | DTS_TIMEFORMAT,
                      2 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3, 
                      hwnd, (HMENU) ID_TIMEPICK, hInstance, NULL) ;
          	hwndCheck = CreateWindow (TEXT ("Button"), TEXT ("Set Alarm"),
                       WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
                       16 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3,
                       hwnd, (HMENU) ID_CHECKBOX, hInstance, NULL) ;

          	hwndPush = CreateWindow (TEXT ("Button"), TEXT ("Turn Off"),
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_DISABLED,
                       28 * cxChar, cyChar, 12 * cxChar, 4 * cyChar / 3,
                       hwnd, (HMENU) ID_PUSHBTN, hInstance, NULL) ;

         	 		hwndFocus = hwndDTP ;

               							// Subclass the three child windows

          			SubbedProc [ID_TIMEPICK] = (WNDPROC) 
                    SetWindowLong (hwndDTP, GWL_WNDPROC, (LONG) SubProc) ;
          			SubbedProc [ID_CHECKBOX] = (WNDPROC) 
                    SetWindowLong (hwndCheck, GWL_WNDPROC, (LONG) SubProc);
          			SubbedProc [ID_PUSHBTN] = (WNDPROC) 
                    SetWindowLong (hwndPush, GWL_WNDPROC, (LONG) SubProc) ;
          
               			// Set the date and time picker control to the current time
               			// plus 9 hours, rounded down to next lowest hour
          
          			GetLocalTime (&st) ;
          			SystemTimeToFileTime (&st, &ft) ;
          			li = * (LARGE_INTEGER *) &ft ;
          			li.QuadPart += 9 * FTTICKSPERHOUR ; 
          			ft = * (FILETIME *) &li ;
          			FileTimeToSystemTime (&ft, &st) ;
          			st.wMinute = st.wSecond = st.wMilliseconds = 0 ;
          			SendMessage (hwndDTP, DTM_SETSYSTEMTIME, 0, (LPARAM) &st) ;
          			return 0 ;

     	case 	WM_SETFOCUS:
          			SetFocus (hwndFocus) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))      // control ID
          			{
          			case	ID_CHECKBOX:
               
                    					// When the user checks the "Set Alarm" button, get the 
                    					// time in the date and time control and subtract from 
                    					// it the current PC time.

               			if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
               				{
                    						SendMessage (hwndDTP, DTM_GETSYSTEMTIME, 0, (LPARAM) &st) ;
                    						SystemTimeToFileTime (&st, &ft) ;
                    					li = * (LARGE_INTEGER *) &ft ;

                    					GetLocalTime (&st) ;
                    					SystemTimeToFileTime (&st, &ft) ;
                    					li.QuadPart -= ((LARGE_INTEGER *) &ft)->QuadPart ;

                         						// Make sure the time is between 0 and 24 hours!
                         						// These little adjustments let us completely ignore
                         						// the date part of the SYSTEMTIME structures.

                    					while	(	li.QuadPart < 0)
                         								li.QuadPart += 24 * FTTICKSPERHOUR ;

                    					li.QuadPart %= 24 * FTTICKSPERHOUR ;

                         						// Set a one-shot timer! (See you in the morning.)

                    					SetTimer (hwnd, ID_TIMER, (int) (li.QuadPart / 10000), 0) ;
               				}
                    						// If button is being unchecked, kill the timer.

              			else
                    					KillTimer (hwnd, ID_TIMER) ;

               			return 0 ;

               				// The "Turn Off" button turns off the ringing alarm, and also
               				// unchecks the "Set Alarm" button and disables itself.

          		case 	ID_PUSHBTN:
               	PlaySound (NULL, NULL, 0) ;
               	SendMessage (hwndCheck, BM_SETCHECK, 0, 0) ;
              	EnableWindow (hwndDTP, TRUE) ;
               	EnableWindow (hwndCheck, TRUE) ;
                EnableWindow (hwndPush, FALSE) ;
               	SetFocus (hwndDTP) ;
               	return 0 ;
          		}
		return 0 ;

               			// The WM_NOTIFY message comes from the date and time picker.
               			// If the user has checked "Set Alarm" and then gone back to 
               			// change the alarm time, there might be a discrepancy between
               			// the displayed time and the one-shot timer. So the program
               			// unchecks "Set Alarm" and kills any outstanding timer.

     	case 	WM_NOTIFY:
          			switch (wParam)          			// control ID
          			{
          			case 	ID_TIMEPICK:
               		switch (((NMHDR *) lParam)->code) // notification code
               					{
               					case 	DTN_DATETIMECHANGE:
                    		if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
                    		{
                         	KillTimer (hwnd, ID_TIMER) ;
                         	SendMessage (hwndCheck, BM_SETCHECK, 0, 0) ;
                    		}
                    		return 0 ;
               				}
          			}
          			return 0 ;

          			// The WM_COMMAND message comes from the two buttons. 		

     	case 	WM_TIMER:

               			// When the timer message comes, kill the timer (because we only
               			// want a one-shot) and start the annoying alarm noise going.

          			KillTimer (	hwnd, ID_TIMER) ;
          			PlaySound (	(PTSTR) pwaveform,  NULL, 
                     								SND_MEMORY | SND_LOOP | SND_ASYNC);

               			// Let the sleepy user turn off the timer by slapping the 
               			// space bar. If the window is minimized, it's restored; then
               			// it's brought to the forefront; then the pushbutton is enabled
               			// and given the input focus.

          			EnableWindow (hwndDTP, FALSE) ;
          			EnableWindow (hwndCheck, FALSE) ;
          			EnableWindow (hwndPush, TRUE) ;

          			hwndFocus = hwndPush ;
          			ShowWindow (hwnd, SW_RESTORE) ;
          			SetForegroundWindow (hwnd) ;
          			return 0 ;

          			// Clean up if the alarm is ringing or the timer is still set.

     	case 	WM_DESTROY:
          			free (pwaveform) ;

          			if (IsWindowEnabled (hwndPush))
               					PlaySound (NULL, NULL, 0) ;

          			if (SendMessage (hwndCheck, BM_GETCHECK, 0, 0))
               					KillTimer (hwnd, ID_TIMER) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

LRESULT CALLBACK SubProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	int idNext, id = GetWindowLong (hwnd, GWL_ID) ;
     	switch (message)
     	{
     	case 	WM_CHAR:
          			if (wParam == '\t')
          			{
               				idNext = id ;

               				do
                    					idNext = (idNext + 
                         						(GetKeyState (VK_SHIFT) < 0 ? 2 : 1)) % 3 ;
               				while (!IsWindowEnabled (GetDlgItem (GetParent (hwnd), idNext)));

               				SetFocus (GetDlgItem (GetParent (hwnd), idNext)) ;
               				return 0 ;
          			}
          			break ;

     	case 	WM_SETFOCUS:
          			hwndFocus = hwnd ;
          			break ;
     	}
     	return CallWindowProc (	SubbedProc [id], hwnd, message, wParam,lParam) ;
}

type struct _FILETIME       			// ft
{
     	DWORD dwLowDateTime ;
     	DWORD dwHighDateTime ;
}
FILETIME ;

typedef __int64 LONGLONG ;
typedef unsigned __int64 DWORDLONG ;

typedef union _LARGE_INTEGER
{
     	struct
     	{
          		DWORD LowPart ;
          		LONG  HighPart ;
  	} ;
     	LONGLONG QuadPart ;
}
LARGE_INTEGER ;

 ï¿½ï¿½Ê½22-9  KBMIDI
KBMIDI.C
/*--------------------------------------------------------------------------
   	KBMIDI.C --	Keyboard MIDI Player 
               						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
// Defines for Menu IDs
// --------------------

#define 		IDM_OPEN    		0x100
#define 		IDM_CLOSE   		0x101
#define 		IDM_DEVICE  		0x200
#define 		IDM_CHANNEL 		0x300
#define 		IDM_VOICE   		0x400

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
TCHAR    			szAppName [] = TEXT ("KBMidi") ;
HMIDIOUT 		hMidiOut ;
int      			iDevice = MIDIMAPPER, iChannel = 0, iVoice = 0, iVelocity = 64 ;
int      			cxCaps, cyChar, xOffset, yOffset ;

     	// Structures and data for showing families and instruments on menu
     	// --------------------------------------------------------------------

typedef struct
{
	TCHAR * szInst ;
     	int    iVoice ;
}
INSTRUMENT ;
typedef 	struct
{
     	TCHAR      * szFam ;
     	INSTRUMENT   inst [8] ;
}
FAMILY ;
FAMILY 	fam [16] = { 
     
     	TEXT ("Piano"),

          		TEXT ("Acoustic Grand Piano"), 0,
          		TEXT ("Bright Acoustic Piano"),1,
          		TEXT ("Electric Grand Piano"), 2,
          		TEXT ("Honky-tonk Piano"),     3,
          		TEXT ("Rhodes Piano"),         4,
          		TEXT ("Chorused Piano"),       5,
          		TEXT ("Harpsichord"),          6,
          		TEXT ("Clavinet"),             7,
     	        TEXT ("Chromatic Percussion"),
          		TEXT ("Celesta"),              8,
          		TEXT ("Glockenspiel"),         9,
          		TEXT ("Music Box"),           10,
          		TEXT ("Vibraphone"),          11,
          		TEXT ("Marimba"),             12,
          		TEXT ("Xylophone"),           13,
          		TEXT ("Tubular Bells"),       14,
          		TEXT ("Dulcimer"),            15,
     	        TEXT ("Organ"),
          		TEXT ("Hammond Organ"),       16,
          		TEXT ("Percussive Organ"),    17,
          		TEXT ("Rock Organ"),          18,
          		TEXT ("Church Organ"),        19,
          		TEXT ("Reed Organ"),          20,
          		TEXT ("Accordian"),           21,
          		TEXT ("Harmonica"),           22,
          		TEXT ("Tango Accordian"),     23,
     	        TEXT ("Guitar"),
          		TEXT ("Acoustic Guitar (nylon)"), 24,
          		TEXT ("Acoustic Guitar (steel)"), 25,
          		TEXT ("Electric Guitar (jazz)"),  26,
          		TEXT ("Electric Guitar (clean)"), 27,
          		TEXT ("Electric Guitar (muted)"), 28,
          		TEXT ("Overdriven Guitar"),       29,
          		TEXT ("Distortion Guitar"),       30,
          		TEXT ("Guitar Harmonics"),        31,
     	        TEXT ("Bass"),
          		TEXT ("Acoustic Bass"),           32,
          		TEXT ("Electric Bass (finger)"),  33,
          		TEXT ("Electric Bass (pick)"),    34,
          		TEXT ("Fretless Bass"),           35,
          		TEXT ("Slap Bass 1"),             36,
          		TEXT ("Slap Bass 2"),             37,
          		TEXT ("Synth Bass 1"),            38,
          		TEXT ("Synth Bass 2"),            39,
     			TEXT ("Strings"),
          		TEXT ("Violin"),                  40,
          		TEXT ("Viola"),                   41,
          		TEXT ("Cello"),                   42,
          		TEXT ("Contrabass"),              43,
          		TEXT ("Tremolo Strings"),         44,
          		TEXT ("Pizzicato Strings"),       45,
          		TEXT ("Orchestral Harp"),         46,
          		TEXT ("Timpani"),                 47,
	TEXT ("Ensemble"),
          		TEXT ("String Ensemble 1"),       48,
          		TEXT ("String Ensemble 2"),       49,
          		TEXT ("Synth Strings 1"),         50,
          		TEXT ("Synth Strings 2"),         51,
          		TEXT ("Choir Aahs"),              52,
          		TEXT ("Voice Oohs"),              53,
          		TEXT ("Synth Voice"),             54,
          		TEXT ("Orchestra Hit"),           55,
     	        TEXT ("Brass"),
          		TEXT ("Trumpet"),                 56,
          		TEXT ("Trombone"),                57,
          		TEXT ("Tuba"),                    58,
          		TEXT ("Muted Trumpet"),           59,
          		TEXT ("French Horn"),             60,
          		TEXT ("Brass Section"),           61,
          		TEXT ("Synth Brass 1"),           62,
          		TEXT ("Synth Brass 2"),           63,
     	        TEXT ("Reed"),
          		TEXT ("Soprano Sax"),             64,
          		TEXT ("Alto Sax"),                65,
          		TEXT ("Tenor Sax"),               66,
          		TEXT ("Baritone Sax"),            67,
          		TEXT ("Oboe"),                    68,
          		TEXT ("English Horn"),            69,
          		TEXT ("Bassoon"),                 70,
          		TEXT ("Clarinet"),                71,
     	        TEXT ("Pipe"),
          		TEXT ("Piccolo"),                 72,
          		TEXT ("Flute "),                  73,
          		TEXT ("Recorder"),                74,
          		TEXT ("Pan Flute"),               75,
          		TEXT ("Bottle Blow"),             76,
          		TEXT ("Shakuhachi"),              77,
          		TEXT ("Whistle"),                 78,
          		TEXT ("Ocarina"),                 79,
     	TEXT ("Synth Lead"),
          		TEXT ("Lead 1 (square)"),         80,
          		TEXT ("Lead 2 (sawtooth)"),       81,
          		TEXT ("Lead 3 (caliope lead)"),   82,
          		TEXT ("Lead 4 (chiff lead)"),     83,
          		TEXT ("Lead 5 (charang)"),        84,
          		TEXT ("Lead 6 (voice)"),          85,
          		TEXT ("Lead 7 (fifths)"),         86,
          		TEXT ("Lead 8 (brass + lead)"),   87,
     	        TEXT ("Synth Pad"),
          		TEXT ("Pad 1 (new age)"),         88,
         		TEXT ("Pad 2 (warm)"),            89,
          		TEXT ("Pad 3 (polysynth)"),       90,
          		TEXT ("Pad 4 (choir)"),           91,
          		TEXT ("Pad 5 (bowed)"),           92,
          		TEXT ("Pad 6 (metallic)"),        93,
          		TEXT ("Pad 7 (halo)"),            94,
          		TEXT ("Pad 8 (sweep)"),           95,
     	        TEXT ("Synth Effects"),
          		TEXT ("FX 1 (rain)"),             96,
          		TEXT ("FX 2 (soundtrack)"),       97,
          		TEXT ("FX 3 (crystal)"),          98,
          		TEXT ("FX 4 (atmosphere)"),       99,
          		TEXT ("FX 5 (brightness)"),      100,
          		TEXT ("FX 6 (goblins)"),         101,
          		TEXT ("FX 7 (echoes)"),          102,
          		TEXT ("FX 8 (sci-fi)"),          103,
     	        TEXT ("Ethnic"),
          		TEXT ("Sitar"),                  104,
          		TEXT ("Banjo"),                  105,
          		TEXT ("Shamisen"),               106,
          		TEXT ("Koto"),                   107,
          		TEXT ("Kalimba"),                108,	
          		TEXT ("Bagpipe"),                109,
          		TEXT ("Fiddle"),                 110,
          		TEXT ("Shanai"),                 111,
     	        TEXT ("Percussive"),
          		TEXT ("Tinkle Bell"),            112,
          		TEXT ("Agogo"),                  113,
          		TEXT ("Steel Drums"),            114,
          		TEXT ("Woodblock"),              115,
          		TEXT ("Taiko Drum"),             116,
          		TEXT ("Melodic Tom"),            117,
          		TEXT ("Synth Drum"),             118,
          		TEXT ("Reverse Cymbal"),         119,
     	        TEXT ("Sound Effects"),
          		TEXT ("Guitar Fret Noise"),      120,
          		TEXT ("Breath Noise"),           121,
          		TEXT ("Seashore"),               122,
          		TEXT ("Bird Tweet"),             123,
          		TEXT ("Telephone Ring"),         124,
          		TEXT ("Helicopter"),             125,
          		TEXT ("Applause"),               126,
          		TEXT ("Gunshot"),                127 
} ;

     	// Data for translating scan codes to octaves and notes
     	// ----------------------------------------------------

#define NUMSCANS    (sizeof key / sizeof key[0])
struct
{
  	    int     			iOctave ;
     	int     			iNote ;
     	int     			yPos ;
     	int     			xPos ;
     	TCHAR * 		szKey ;
}
key [] =
{
				            // Scan  Char  Oct  Note
				            // ----  ----  ---  ----
	-1,	-1,	1,	-1, 	NULL,	//	0	None
	-1,	-1,	-1,	-1, 	NULL,	//	1	Esc
	-1,	-1,	0,	0, 	TEXT (""),    //   	2     	1
	5,	1,	0,	2, 	TEXT ("C#"),	//   	3	2   5    	C#
	5, 	3,	0,	4, 	TEXT ("D#"), 	//   	4 	3 	5    	D#
	-1,	-1,	0,	6, 	TEXT (""), 	//   	5     	4
	5, 	6,	0,	8, 	TEXT ("F#"), 	//	6	5	5	F#
	5,	8,	0,	10, 	TEXT ("G#"),	//	7	6	5	G#
	5, 	10,	0, 	12, 	TEXT ("A#"),	//	8	7	5	A#
	-1,	-1,	0, 	14, 	TEXT (""), 	//	9	8
	6,	1,	0, 	16, 	TEXT ("C#"),	//	10	9	6	C#
	6,	3,	0, 	18, 	TEXT ("D#"),	//  	11     	0    	6    	D#
	-1,	-1,	0, 	20, 	TEXT (""), 	//  	12     	-
	6,	6,	0, 	22, 	TEXT ("F#"), 	//  	13 	= 	6	F#
	-1,	-1,	-1, 	-1, 	NULL,	//	14 	Back
          
	-1, 	-1, 	-1, 	-1,	NULL,	//	15 	Tab
	5,	0,	1,	1,	TEXT ("C"),	//  	16     	q    	5    	C
	5,  	2,  	1,  	3, 	TEXT ("D"),	//  	17     	w    	5    	D
          	5,  	4,  	1,  	5, 	TEXT ("E"),     	//  	18     	e    	5    	E
          	5,  	5,  	1,  	7, 	TEXT ("F"),     	//  	19     	r    	5    	F
          	5,  	7,  	1,  	9, 	TEXT ("G"),   	//  	20     	t    	5    	G
          	5,  	9,  	1, 	11, 	TEXT ("A"),     	//  	21     	y    	5    	A
          	5, 	11,  	1, 	13, 	TEXT ("B"),     	//  	22     	u    	5    	B
          	6,  	0,  	1, 	15, 	TEXT ("C"),   	//  	23     	i    	6    	C
          	6,  	2,  	1, 	17, 	TEXT ("D"),     	//  	24     	o    	6    	D
          	6,  	4,  	1, 	19, 	TEXT ("E"),     	//  	25     	p    	6    	E
          	6,  	5,  	1, 	21, 	TEXT ("F"),     	//  	26     	[    	6    	F
          	6,  	7,  	1, 	23, 	TEXT ("G"),     	//  	27     	]    	6    	G
         	-1, 	-1, 	-1, 	-1, 	NULL,           	//  	28    	Ent
         	-1, 	-1, 	-1, 	-1, 	NULL,           	//  	29    	Ctrl
          	3,  	8,  	2,  	2, 	TEXT ("G#"),    	//  	30     	a    	3    	G#
          	3, 	10,  	2,  	4, 	TEXT ("A#"),    	//  	31     	s    	3    	A#
         	-1, 	-1,  	2,  	6, 	TEXT (""),      	//  	32     	d
          	4,  	1,  	2,  	8, 	TEXT ("C#"),    	//  	33     	f    	4    	C#
          	4,  	3,  	2, 	10, 	TEXT ("D#"),    	//  	34     	g    	4    	D#
         	-1, 	-1,  	2, 	12, 	TEXT (""),      	//  	35     	h
          	4,  	6,  	2, 	14, 	TEXT ("F#"),    	//  	36     	j    	4    	F#
          	4,  	8,  	2, 	16, 	TEXT ("G#"),    	//  	37     	k    	4    	G#
          	4, 	10,  	2, 	18, 	TEXT ("A#"),    	//  	38     	l   	4    	A#
         	-1, 	-1,  	2, 	20, 	TEXT (""),      	//  	39     	;
          	5,  	1,  	2, 	22, 	TEXT ("C#"),    	//  	40     	'    	5    	C#
         	-1, 	-1, 	-1, 	-1, 	NULL,           	//  	41     	`
         	-1, 	-1,	-1, 	-1, 	NULL,           	//  	42    	Shift
         	-1, 	-1, 	-1, 	-1, 	NULL,           	//  	43     	\  	(not line continuation)
          	3,  	9,  	3,  	3, 	TEXT ("A"), 	//  	44     	z    	3    	A
          	3, 	11,  	3,  	5, 	TEXT ("B"),     	//  	45     	x    	3    	B
          	4,  	0,  	3,  	7, 	TEXT ("C"),     	//  	46     	c    	4    	C
	4,  	2,  	3,  	9, 	TEXT ("D"),     	//  	47     	v    	4    	D
          	4,  	4,  	3, 	11, 	TEXT ("E"),     	//  	48     	b    	4    	E
          	4,  	5,  	3, 	13, 	TEXT ("F"),     	//  	49     	n    	4    	F
          	4,  	7,  	3, 	15, 	TEXT ("G"),     	//  	50     	m    	4    	G
	4,  	9,  	3, 	17, 	TEXT ("A"),     	//  	51     	,    	4    	A
          	4, 	11,  	3, 	19, 	TEXT ("B"),     	//  	52     	.    	4    	B
          	5,  	0,  	3, 	21, 	TEXT ("C")      	//  	53     	/    	5    	C
} ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	MSG      				msg;
     	HWND     				hwnd ;
     	WNDCLASS 			wndclass ;
     
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         					= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       				= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  = NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
         		return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Keyboard MIDI Player"),
              WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
              CW_USEDEFAULT, CW_USEDEFAULT,
              CW_USEDEFAULT, CW_USEDEFAULT,
              NULL, NULL, hInstance, NULL) ;

     	if (!hwnd)
          			return 0 ;
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd); 
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

// Create the program's menu (called from WndProc, WM_CREATE)
// --------------------------------------------------------------------

HMENU CreateTheMenu (int iNumDevs)
{
     	TCHAR       				szBuffer [32] ;
     	HMENU       				hMenu, hMenuPopup, hMenuSubPopup ;
     	int         				i, iFam, iIns ;
     	MIDIOUTCAPS 		moc ;
     
     	hMenu = CreateMenu () ;
          				// Create "On/Off" popup menu
     	hMenuPopup = CreateMenu () ;
     	AppendMenu (hMenuPopup, MF_STRING, IDM_OPEN, TEXT ("&Open")) ; 
     	AppendMenu (hMenuPopup, MF_STRING | MF_CHECKED, IDM_CLOSE, 
                    TEXT ("&Closed")) ;
     	AppendMenu (hMenu, 	MF_STRING | MF_POPUP, (UINT) hMenuPopup, 
                    TEXT ("&Status")) ;
     
          			// Create "Device" popup menu
     
     	hMenuPopup = CreateMenu () ;
      			// Put MIDI Mapper on menu if it's installed
     	if (!midiOutGetDevCaps (MIDIMAPPER, &moc, sizeof (moc)))
          			AppendMenu (hMenuPopup, MF_STRING, IDM_DEVICE + (int) MIDIMAPPER,
                         								moc.szPname) ;
     	else
          			iDevice = 0 ;
          			// Add the rest of the MIDI devices
     	for (i = 0 ; i < iNumDevs ; i++)
     	{
          		midiOutGetDevCaps (i, &moc, sizeof (moc)) ;
          		AppendMenu (hMenuPopup, MF_STRING, IDM_DEVICE + i, moc.szPname) ;
     }
     
     	CheckMenuItem (hMenuPopup, 0, MF_BYPOSITION | MF_CHECKED) ;
     	AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup, 
                        						TEXT ("&Device")) ;
          			// Create "Channel" popup menu
  	hMenuPopup = CreateMenu () ;
  	for (i = 0 ; i < 16 ; i++)
     	{
          		wsprintf (szBuffer, TEXT ("%d"), i + 1) ;
          		AppendMenu (hMenuPopup, MF_STRING | (i ? MF_UNCHECKED : MF_CHECKED),
                              		IDM_CHANNEL + i, szBuffer) ;
     	}
     
     	AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup, 
                        						TEXT ("&Channel")) ;
          				// Create "Voice" popup menu
  	hMenuPopup = CreateMenu () ;
     	for (iFam = 0 ; iFam < 16 ; iFam++)
     	{
     	hMenuSubPopup = CreateMenu () ;
      	for (iIns = 0 ; iIns < 8 ; iIns++)
       	{
               			wsprintf (szBuffer, TEXT ("&%d.\t%s"), iIns + 1,
                                   							fam[iFam].inst[iIns].szInst) ;
               			AppendMenu (hMenuSubPopup,
                        MF_STRING | (fam[iFam].inst[iIns].iVoice ?
                        MF_UNCHECKED : MF_CHECKED),
                        fam[iFam].inst[iIns].iVoice + IDM_VOICE,
                        szBuffer) ;
          			}
          
      wsprintf (szBuffer, TEXT ("&%c.\t%s"), 'A' + iFam,
      fam[iFam].szFam) ;
      AppendMenu (hMenuPopup, MF_STRING | MF_POPUP, (UINT) hMenuSubPopup,
      szBuffer) ;
     }
     	AppendMenu (hMenu, 	MF_STRING | MF_POPUP, (UINT) hMenuPopup, 
        TEXT ("&Voice")) ;
  	return hMenu ;
}

// Routines for simplifying MIDI output
// ------------------------------------

DWORD MidiOutMessage (	HMIDIOUT hMidi, int iStatus, int iChannel,
                      								int iData1,  int iData2)
{
     	DWORD dwMessage ;
     	dwMessage = iStatus | iChannel | (iData1 << 8) | (iData2 << 16) ;
     	return midiOutShortMsg (hMidi, dwMessage) ;
}

DWORD MidiNoteOff (	HMIDIOUT hMidi, int iChannel, int iOct, int iNote, int iVel)
{
     	return MidiOutMessage (hMidi, 0x080, iChannel, 12 * iOct + iNote, iVel) ;
}

DWORD MidiNoteOn (	HMIDIOUT hMidi, int iChannel, int iOct, int iNote, int iVel)
{
     	return MidiOutMessage (	hMidi, 0x090, iChannel, 12 * iOct + iNote, iVel) ;
}

DWORD MidiSetPatch (HMIDIOUT hMidi, int iChannel, int iVoice)
{
     	return MidiOutMessage (hMidi, 0x0C0, iChannel, iVoice, 0) ;
}

DWORD MidiPitchBend (HMIDIOUT hMidi, int iChannel, int iBend)
{
     	return MidiOutMessage (hMidi, 0x0E0, iChannel, iBend & 0x7F, iBend >> 7) ;
}

// Draw a single key on window
// ----------------------------------

VOID DrawKey (HDC hdc, int iScanCode, BOOL fInvert)
{
     	RECT rc ;
     	rc.left 		= 3 * cxCaps * key[iScanCode].xPos / 2 + xOffset ;
     	rc.top  		= 3 * cyChar * key[iScanCode].yPos / 2 + yOffset ;
     	rc.right 		= rc.left + 3 * cxCaps ;
     	rc.bottom	= rc.top  + 3 * cyChar / 2 ;
     
     	SetTextColor	(hdc, fInvert ? 0x00FFFFFFul : 0x00000000ul) ;
     	SetBkColor  		(hdc, fInvert ? 0x00000000ul : 0x00FFFFFFul) ;
     
     	FillRect (hdc, &rc, GetStockObject (fInvert ? BLACK_BRUSH : WHITE_BRUSH)) ;
     	DrawText (hdc, key[iScanCode].szKey, -1, &rc,
                    					DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;
     	FrameRect (hdc, &rc, GetStockObject (BLACK_BRUSH)) ;
}

// Process a Key Up or Key Down message
// ------------------------------------

VOID ProcessKey (HDC hdc, UINT message, LPARAM lParam)
{
     	int iScanCode, iOctave, iNote ;
     	iScanCode = 0x0FF & HIWORD (lParam) ;
     	if (iScanCode >= NUMSCANS)		// No scan codes over 53
          			return ;
     
	if ((iOctave = key[iScanCode].iOctave) == -1) 		// Non-music key
          			return ;
     
     	if (GetKeyState (VK_SHIFT) < 0)
          			iOctave += 0x20000000 & lParam ? 2 : 1 ;
     	if (GetKeyState (VK_CONTROL) < 0)
          			iOctave -= 0x20000000 & lParam ? 2 : 1 ;
     	iNote = key[iScanCode].iNote ;
     	if (message == WM_KEYUP) 		// For key up
     {
          		MidiNoteOff (hMidiOut, iChannel, iOctave, iNote, 0) ;   // Note off
          							DrawKey (hdc, iScanCode, FALSE) ;
          							return ;
     }
     
     	if (0x40000000 & lParam) 		// ignore typematics
          		return ;
     
     	MidiNoteOn (hMidiOut, iChannel, iOctave, iNote, iVelocity) ; // Note on
     	DrawKey (hdc, iScanCode, TRUE) ;  			// Draw the inverted key
}

// Window Procedure
// ---------------------

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static BOOL bOpened = FALSE ;
     	HDC         				hdc ;
     	HMENU       				hMenu ;
     	int         				i, iNumDevs, iPitchBend, cxClient, cyClient ;
     	MIDIOUTCAPS 		moc ;
     	PAINTSTRUCT	 	ps ;
     	SIZE        				size ;
     	TCHAR       				szBuffer [16] ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
               				// Get size of capital letters in system font
          
          			hdc = GetDC (hwnd) ;
          
          			GetTextExtentPoint (hdc, TEXT ("M"), 1, &size) ;
          			cxCaps = size.cx ;
          			cyChar = size.cy ;
          
          			ReleaseDC (hwnd, hdc) ;
          
               				// Initialize "Volume" scroll bar
          
         	 		SetScrollRange 		(hwnd, SB_HORZ, 1, 127, FALSE) ;
          			SetScrollPos  		(hwnd, SB_HORZ, iVelocity, TRUE) ;
          
               				// Initialize "Pitch Bend" scroll bar
          
          			SetScrollRange 		(hwnd, SB_VERT, 0, 16383, FALSE) ;
          			SetScrollPos   		(hwnd, SB_VERT, 8192, TRUE) ;
          
               				// Get number of MIDI output devices and set up menu
          
          			if (0 == (iNumDevs = midiOutGetNumDevs ()))
          			{
               					MessageBeep (MB_ICONSTOP) ;
               					MessageBox (	hwnd, TEXT ("No MIDI output devices!"),
                                szAppName, MB_OK | MB_ICONSTOP) ;
               					return -1 ;
          			}
          			SetMenu (hwnd, CreateTheMenu (iNumDevs)) ;
          			return 0 ;
          
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          
          			xOffset = (cxClient - 25 * 3 * cxCaps / 2) / 2 ;
          			yOffset = (cyClient - 11 * cyChar) / 2 + 5 * cyChar ;
          			return 0 ;
          
     	case 	WM_COMMAND:
          			hMenu = GetMenu (hwnd) ;
          
              				// "Open" menu command
          
          			if (LOWORD (wParam) == IDM_OPEN && !bOpened)
          			{	
               				if (midiOutOpen (&hMidiOut, iDevice, 0, 0, 0))
               				{
                    					MessageBeep (MB_ICONEXCLAMATION) ;
                    					MessageBox (hwnd, TEXT ("Cannot open MIDI device"),
                                		szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               				}
               				else
               				{
                    					CheckMenuItem (hMenu, IDM_OPEN,  MF_CHECKED) ;
                    					CheckMenuItem (hMenu, IDM_CLOSE, MF_UNCHECKED) ;
                    
                    					MidiSetPatch (hMidiOut, iChannel, iVoice) ;
                    					bOpened = TRUE ;
               }
          				}
          
               					// "Close" menu command
          			else if (LOWORD (wParam) == IDM_CLOSE && bOpened)
          			{
               				CheckMenuItem (hMenu, IDM_OPEN,  MF_UNCHECKED) ;
               				CheckMenuItem (hMenu, IDM_CLOSE, MF_CHECKED) ;
               
                    					// Turn all keys off and close device
               				for (i = 0 ; i < 16 ; i++)
                    						MidiOutMessage (hMidiOut, 0xB0, i, 123, 0) ;
               				midiOutClose (hMidiOut) ;
               				bOpened = FALSE ;
          			}
          
               					// Change MIDI "Device" menu command
          			else if (	LOWORD (wParam) >= IDM_DEVICE - 1 && 
                   							LOWORD (wParam) <  IDM_CHANNEL)
          			{
               				CheckMenuItem (hMenu, IDM_DEVICE + iDevice, MF_UNCHECKED) ;
               				iDevice = LOWORD (wParam) - IDM_DEVICE ;
               				CheckMenuItem (hMenu, IDM_DEVICE + iDevice, MF_CHECKED) ;
               
                    					// Close and reopen MIDI device
               
               				if (bOpened)
               				{
                    					SendMessage (hwnd, WM_COMMAND, IDM_CLOSE, 0L) ;
                    					SendMessage (hwnd, WM_COMMAND, IDM_OPEN,  0L) ;
               				}
          			}
          
               				// Change MIDI "Channel" menu command
          
          			else if (	LOWORD (wParam) >= IDM_CHANNEL && 
                   							LOWORD (wParam) <  IDM_VOICE)
          			{
               				CheckMenuItem (hMenu, IDM_CHANNEL + iChannel, MF_UNCHECKED);
               				iChannel = LOWORD (wParam) - IDM_CHANNEL ;
               				CheckMenuItem (hMenu, IDM_CHANNEL + iChannel, MF_CHECKED) ;
               
               				if (bOpened)
                    						MidiSetPatch (hMidiOut, iChannel, iVoice) ;
          			}
          
               				// Change MIDI "Voice" menu command
          
          			else if (LOWORD (wParam) >= IDM_VOICE)
          			{
               				CheckMenuItem (hMenu, IDM_VOICE + iVoice, MF_UNCHECKED) ;
               				iVoice = LOWORD (wParam) - IDM_VOICE ;
               				CheckMenuItem (hMenu, IDM_VOICE + iVoice, MF_CHECKED) ;
               
               				if (bOpened)
                    						MidiSetPatch (hMidiOut, iChannel, iVoice) ;
          			}
          
          			InvalidateRect (hwnd, NULL, TRUE) ;
          			return 0 ;
          
          				// Process a Key Up or Key Down message
          
     	case 	WM_KEYUP:
     	case 	WM_KEYDOWN:
          			hdc = GetDC (hwnd) ;
          
          			if (bOpened)
               					ProcessKey (hdc, message, lParam) ;
          
          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;
          
          				// For Escape, turn off all notes and repaint
          
     	case 	WM_CHAR:
          			if (bOpened && wParam == 27)
          			{
               				for (i = 0 ; i < 16 ; i++)
                    							MidiOutMessage (hMidiOut, 0xB0, i, 123, 0) ;
               
               				InvalidateRect (hwnd, NULL, TRUE) ;
          			}
          			return 0 ;
          
          			// Horizontal scroll: Velocity
          
     	case 	WM_HSCROLL:
          			switch (LOWORD (wParam))
          			{
          			case SB_LINEUP:         				iVelocity -= 1 ;  break ;
          			case SB_LINEDOWN:       			iVelocity += 1 ;  break ;
          			case SB_PAGEUP:         				iVelocity -= 8 ;  break ;
          			case SB_PAGEDOWN:       			iVelocity += 8 ;  break ;
          			case SB_THUMBPOSITION:  	iVelocity = HIWORD (wParam) ;  break ;
          			default:                						return 0 ;
          }
          			iVelocity = max (1, min (iVelocity, 127)) ;
          			SetScrollPos (hwnd, SB_HORZ, iVelocity, TRUE) ;
          			return 0 ;
          
          					// Vertical scroll:  Pitch Bend
     	case 	WM_VSCROLL:
          			switch (LOWORD (wParam))
          			{
          	case SB_THUMBTRACK:	iPitchBend = 16383 - HIWORD (wParam) ; break ;
          	case SB_THUMBPOSITION: iPitchBend = 8191 ;  break ;
          	default:               							return 0 ;
          	}
          			iPitchBend = max (0, min (iPitchBend, 16383)) ;
          			SetScrollPos (hwnd, SB_VERT, 16383 - iPitchBend, TRUE) ;
          
          			if (bOpened)
               					MidiPitchBend (hMidiOut, iChannel, iPitchBend) ;
          			return 0 ;
     
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			for (i = 0 ; i < NUMSCANS ; i++)
               					if (key[i].xPos != -1)
                    							DrawKey (hdc, i, FALSE) ;
               
          			midiOutGetDevCaps (iDevice, &moc, sizeof (MIDIOUTCAPS)) ;
         	 		wsprintf (szBuffer, TEXT ("Channel %i"), iChannel + 1) ;
     
          			TextOut (	hdc, cxCaps, 1 * cyChar, 
                    Opened ? TEXT ("Open") : TEXT ("Closed"),
                    bOpened ? 4 : 6) ;
          			TextOut (	hdc, cxCaps, 2 * cyChar, moc.szPname,
                    lstrlen (moc.szPname)) ;
          			TextOut 	(hdc, cxCaps, 3 * cyChar, szBuffer, lstrlen (szBuffer)) ;
          			TextOut	(hdc, cxCaps, 4 * cyChar,
                    fam[iVoice / 8].inst[iVoice % 8].szInst,
               		lstrlen (fam[iVoice / 8].inst[iVoice % 8].szInst)) ;
     
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
               
     	case 	WM_DESTROY :
          			SendMessage (hwnd, WM_COMMAND, IDM_CLOSE, 0L) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½22-10  DRUM
DRUM.C
/*---------------------------------------------------------------------------
   	DRUM.C -- MIDI Drum Machine
             					(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "drumtime.h"
#include "drumfile.h"
#include "resource.h"

LRESULT 	CALLBACK WndProc   		(HWND, UINT, WPARAM, LPARAM) ;
BOOL    		CALLBACK AboutProc 	(HWND, UINT, WPARAM, LPARAM) ;
                            
void  		DrawRectangle 		(HDC, int, int, DWORD *, DWORD *) ;
void  		ErrorMessage  		(HWND, TCHAR *, TCHAR *) ;
void  		DoCaption     		(HWND, TCHAR *) ;
int   		AskAboutSave  		(HWND, TCHAR *) ;

TCHAR * szPerc [NUM_PERC] =
{
     	TEXT ("Acoustic Bass Drum"), 	TEXT ("Bass Drum 1"),     
     	TEXT ("Side Stick"),         			TEXT ("Acoustic Snare"),     
     	TEXT ("Hand Clap"),          		TEXT ("Electric Snare"),
     	TEXT ("Low Floor Tom"),      		TEXT ("Closed High Hat"), 
     	TEXT ("High Floor Tom"),     		TEXT ("Pedal High Hat"),     
     	TEXT ("Low Tom"),            		TEXT ("Open High Hat"),
     	TEXT ("Low-Mid Tom"),        		TEXT ("High-Mid Tom"),    
     	TEXT ("Crash Cymbal 1"),     		TEXT ("High Tom"),           
     	TEXT ("Ride Cymbal 1"),      		TEXT ("Chinese Cymbal"),
     	TEXT ("Ride Bell"),          		TEXT ("Tambourine"),      
     	TEXT ("Splash Cymbal"),      		TEXT ("Cowbell"),            
     	TEXT ("Crash Cymbal 2"),     		TEXT ("Vibraslap"),
     	TEXT ("Ride Cymbal 2"),      		TEXT ("High Bongo"),      
     	TEXT ("Low Bongo"),          		TEXT ("Mute High Conga"),    
     	TEXT ("Open High Conga"),    		TEXT ("Low Conga"),
     	TEXT ("High Timbale"),       		TEXT ("Low Timbale"),     
     	TEXT ("High Agogo"),         		TEXT ("Low Agogo"),          
     	TEXT ("Cabasa"),             						TEXT ("Maracas"),
     	TEXT ("Short Whistle"),      			TEXT ("Long Whistle"),    
     	TEXT ("Short Guiro"),        		TEXT ("Long Guiro"),         
     	TEXT ("Claves"),             						TEXT ("High Wood Block"),
     	TEXT ("Low Wood Block"),     		TEXT ("Mute Cuica"),      
     	TEXT ("Open Cuica"),         		TEXT ("Mute Triangle"),      
     	TEXT ("Open Triangle")
} ;

TCHAR   		szAppName 	[]	= TEXT ("Drum") ;
TCHAR   		szUntitled	[]	= TEXT ("(Untitled)") ;
TCHAR   		szBuffer [80 + MAX_PATH] ;
HANDLE  	hInst ;
int     		cxChar, cyChar ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HWND        					hwnd ;
     	MSG         					msg ;
     	WNDCLASS    				wndclass ;
     
     	hInst = hInstance ;
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (hInstance, szAppName) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;
          
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      			szAppName, MB_ICONERROR) ;
          		return 0 ;
     }

     	hwnd = CreateWindow (szAppName, NULL, 
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
                              WS_MINIMIZEBOX | WS_HSCROLL | WS_VSCROLL,
                          	  CW_USEDEFAULT, CW_USEDEFAULT,
                          	  CW_USEDEFAULT, CW_USEDEFAULT,
                          	  NULL, NULL, hInstance, szCmdLine) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static	BOOL  		bNeedSave ;
     	static 	DRUM  		drum ;
     	static 	HMENU 		hMenu ;
     	static	int   		iTempo = 50, iIndexLast ;
     	static 	TCHAR 		szFileName  [MAX_PATH], szTitleName [MAX_PATH] ;
     	HDC          					hdc ;
     	int          					i, x, y ;
     	PAINTSTRUCT  			ps ;
     	POINT        					point ;
     	RECT         					rect ;
     	TCHAR      				*	szError ;
     
     	switch (message)
     {
     	case 	WM_CREATE:
               				// Initialize DRUM structure
          
          			drum.iMsecPerBeat = 100 ;
          			drum.iVelocity    =  64 ;
          			drum.iNumBeats    =  32 ;
          
          			DrumSetParams (&drum) ;
          
               				// Other initialization
          
          			cxChar = LOWORD (GetDialogBaseUnits ()) ;
          			cyChar = HIWORD (GetDialogBaseUnits ()) ;

          			GetWindowRect (hwnd, &rect) ;
          			MoveWindow (hwnd, 	rect.left, rect.top, 
                    77 * cxChar, 29 * cyChar, FALSE) ;
          
          			hMenu = GetMenu (hwnd) ;
          
               				// Initialize "Volume" scroll bar
          
          			SetScrollRange 		(hwnd, SB_HORZ, 1, 127, FALSE) ;
          			SetScrollPos   		(hwnd, SB_HORZ, drum.iVelocity, TRUE) ;
          
               				// Initialize "Tempo" scroll bar
          
          			SetScrollRange 		(hwnd, SB_VERT, 0, 100, FALSE) ;
          			SetScrollPos   		(hwnd, SB_VERT, iTempo, TRUE) ;
          
          			DoCaption (hwnd, szTitleName) ;
          			return 0 ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_NEW:
               					if 	( bNeedSave && IDCANCEL == AskAboutSave (hwnd, szTitleName))
                    						return 0 ;
               
                    					// Clear drum pattern
               
               					for (i = 0 ; i < NUM_PERC ; i++)
               					{
                    						drum.dwSeqPerc [i] = 0 ;
                    						drum.dwSeqPian [i] = 0 ;
               					}
               
               					InvalidateRect (hwnd, NULL, FALSE) ;
               					DrumSetParams (&drum) ;
               					bNeedSave = FALSE ;
               					return 0 ;
               
          			case 	IDM_FILE_OPEN:
                    							// Save previous file
               
               					if (bNeedSave && IDCANCEL ==
                    							AskAboutSave (hwnd, szTitleName))
                    						return 0 ;
               
                    							// Open the selected file
               
               					if (DrumFileOpenDlg (hwnd, szFileName, szTitleName))
               					{
                    						szError = DrumFileRead (&drum, szFileName) ;
                    
                    						if (szError != NULL)
                    						{
                         							ErrorMessage (hwnd, szError, szTitleName) ;
                         							szTitleName [0] = '\0' ;
                    						}
                    						else
                    						{
                              								// Set new parameters
                         
                         					Tempo = (int) (50 *
                              				 (log10 (drum.iMsecPerBeat) - 1)) ;
                         
                         SetScrollPos (hwnd, SB_VERT, iTempo, TRUE) ;
                         SetScrollPos (hwnd, SB_HORZ, drum.iVelocity, TRUE) ;
                         
                         DrumSetParams (&drum) ;
                         InvalidateRect (hwnd, NULL, FALSE) ;
                         bNeedSave = FALSE ;
                    }
                    
                    	DoCaption (hwnd, szTitleName) ;
               				}	
               				return 0 ;
          		case 	IDM_FILE_SAVE:
          		case 	IDM_FILE_SAVE_AS:
                    						// Save the selected file
               
               				if ((LOWORD (wParam) == IDM_FILE_SAVE && szTitleName [0]) ||
                         	DrumFileSaveDlg (hwnd, szFileName, szTitleName))
               				{
                    		szError = DrumFileWrite (&drum, szFileName) ;
                    
                    		if (szError != NULL)
                    		{
                         	ErrorMessage (hwnd, szError, szTitleName) ;
                         				szTitleName [0] = '\0' ;
                    						}
                    						else
                         							bNeedSave = FALSE ;
                    
                    						DoCaption (hwnd, szTitleName) ;
               				}
               				return 0 ;
               
          		case 	IDM_APP_EXIT:
               				SendMessage (hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L) ;
               				return 0 ;
               
         			case 	IDM_SEQUENCE_RUNNING:
                    				// Begin sequence
               
               				if (!DrumBeginSequence (hwnd))
               				{
                    					ErrorMessage (hwnd,
                         						TEXT ("Could not start MIDI sequence -- ")
                         						TEXT ("MIDI Mapper device is unavailable!"),
                         						szTitleName) ;
              	 			}
               				else
               				{
                    					CheckMenuItem (hMenu, IDM_SEQUENCE_RUNNING,   MF_CHECKED) ;
                    					CheckMenuItem (hMenu, IDM_SEQUENCE_STOPPED, MF_UNCHECKED) ;
               				}
               				return 0 ;
               
          			case 	IDM_SEQUENCE_STOPPED:
                   		 			// Finish at end of sequence
               
               					DrumEndSequence (FALSE) ;
               					return 0 ;
               
          			case 	IDM_APP_ABOUT:
               					DialogBox (hInst, TEXT ("AboutBox"), hwnd, AboutProc) ;
               					return 0 ;
          			}
          			return 0 ;
                    
     	case 	WM_LBUTTONDOWN:
     	case 	WM_RBUTTONDOWN:
          			hdc = GetDC (hwnd) ;
          
               				// Convert mouse coordinates to grid coordinates
          
          			x =   			LOWORD (lParam) / cxChar - 40 ;
          			y = 2 *	HIWORD (lParam) / cyChar -  2 ;
               				// Set a new number of beats of sequence
          
          			if (x > 0 && x <= 32 && y < 0)
          			{
               				SetTextColor (hdc, RGB (255, 255, 255)) ;
               				TextOut (hdc, (40 + drum.iNumBeats) * cxChar, 0, TEXT (":|"), 2);
               				SetTextColor (hdc, RGB (0, 0, 0)) ;
               
               				if (drum.iNumBeats % 4 == 0)
                    						TextOut 	(	hdc, (40 + drum.iNumBeats) * cxChar, 0,
                             										TEXT ("."), 1) ;
               
               				drum.iNumBeats = x ;
               
               				TextOut (hdc, (40 + drum.iNumBeats) * cxChar, 0, TEXT (":|"), 2);
               
               				bNeedSave = TRUE ;
          			}
          
               				// Set or reset a percussion instrument beat
          
          			if (x >= 0 && x < 32 && y >= 0 && y < NUM_PERC)
          			{
               				if (message == WM_LBUTTONDOWN)
                    						drum.dwSeqPerc[y] ^= (1 << x) ;
               				else
                    						drum.dwSeqPian[y] ^= (1 << x) ;
               
               				DrawRectangle (hdc, x, y, drum.dwSeqPerc, drum.dwSeqPian) ;
               
               				bNeedSave = TRUE ;
          			}
          
          			ReleaseDC (hwnd, hdc) ;
     			DrumSetParams (&drum) ;
     			return 0 ;
          
     	case 	WM_HSCROLL:
               				// Change the note velocity
          
          			switch (LOWORD (wParam))
          			{
          			case SB_LINEUP:         				drum.iVelocity -= 1 ;  break ;
          			case SB_LINEDOWN:       			drum.iVelocity += 1 ;  break ;
      			case SB_PAGEUP:         				drum.iVelocity -= 8 ;  break ;
          			case SB_PAGEDOWN:       			drum.iVelocity += 8 ;  break ;
          			case SB_THUMBPOSITION:
               					drum.iVelocity = HIWORD (wParam) ;
               					break ;
               
          			default:
               					return 0 ;
          			}
          
          			drum.iVelocity = max (1, min (drum.iVelocity, 127)) ;
          			SetScrollPos (hwnd, SB_HORZ, drum.iVelocity, TRUE) ;
          			DrumSetParams (&drum) ;
          			bNeedSave = TRUE ;
          			return 0 ;
     
     	case 	WM_VSCROLL:
               					// Change the tempo
          
          			switch (LOWORD (wParam))
          			{
          			case SB_LINEUP:         				iTempo -=  1 ;  break ;
          			case SB_LINEDOWN:       			iTempo +=  1 ;  break ;
          			case SB_PAGEUP:         				iTempo -= 10 ;  break ;
         	 		case SB_PAGEDOWN:       			iTempo += 10 ;  break ;
          			case SB_THUMBPOSITION:
               					iTempo = HIWORD (wParam) ;
               					break ;
               
          			default:
               				return 0 ;
          			}
          
          			iTempo = max (0, min (iTempo, 100)) ;
          			SetScrollPos (hwnd, SB_VERT, iTempo, TRUE) ;
          
          			drum.iMsecPerBeat = (WORD) (10 * pow (100, iTempo / 100.0)) ;
          
          			DrumSetParams (&drum) ;
          			bNeedSave = TRUE ;
          			return 0 ;
     
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			SetTextAlign (hdc, TA_UPDATECP) ;
          			SetBkMode (hdc, TRANSPARENT) ;
          
               				// Draw the text strings and horizontal lines
          			for (i = 0 ; i < NUM_PERC ; i++)
          			{
               				MoveToEx (hdc, 	i & 1 ? 20 * cxChar : cxChar,
                            (2 * i + 3) * cyChar / 4, NULL) ;
               
               				TextOut (hdc, 0, 0, szPerc [i], lstrlen (szPerc [i])) ;
               
               				GetCurrentPositionEx (hdc, &point) ;
               
               				MoveToEx 	(hdc,  point.x + cxChar, point.y + cyChar / 2, NULL) ;
               				LineTo 	(hdc,   	39 * cxChar, point.y + cyChar / 2) ;
          			}
          
          			SetTextAlign (hdc, 0) ;
          
               				// Draw rectangular grid, repeat mark, and beat marks
          
          			for (x = 0 ; x < 32 ; x++)
          			{
               				for (y = 0 ; y < NUM_PERC ; y++)
                DrawRectangle (hdc, x, y, drum.dwSeqPerc, drum.dwSeqPian) ;
               
               	SetTextColor (	hdc, x == drum.iNumBeats - 1 ?
                RGB (0, 0, 0) : RGB (255, 255, 255)) ;
               
               	TextOut (hdc, (41 + x) * cxChar, 0, TEXT (":|"), 2) ;
               
               	SetTextColor (hdc, RGB (0, 0, 0)) ;
               
               	if (x % 4 == 0)
                TextOut (hdc, (40 + x) * cxChar, 0, TEXT ("."), 1) ;
          		}
          
          		EndPaint (hwnd, &ps) ;
          		return 0 ;
          
     	case 	WM_USER_NOTIFY:
               					// Draw the "bouncing ball"
          
          			hdc = GetDC (hwnd) ;
          
          			SelectObject (hdc, GetStockObject (NULL_PEN)) ;
          			SelectObject (hdc, GetStockObject (WHITE_BRUSH)) ;
          
          			for (i = 0 ; i < 2 ; i++)
          			{
               				x = iIndexLast ;
               				y = NUM_PERC + 1 ;
               
               				Ellipse (hdc, (x + 40) * cxChar, (2 * y + 3) * cyChar / 4,
                    						(x + 41) * cxChar, (2 * y + 5) * cyChar / 4);
               
               				iIndexLast = wParam ;
               				SelectObject (hdc, GetStockObject (BLACK_BRUSH)) ;
          			}
          
          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;
          
     	case 	WM_USER_ERROR:
          			ErrorMessage (hwnd, TEXT ("Can't set timer event for tempo"),
                        			szTitleName) ;
                    // fall through
     	case 	WM_USER_FINISHED:
          			DrumEndSequence (TRUE) ;
          			CheckMenuItem (hMenu, IDM_SEQUENCE_RUNNING,	MF_UNCHECKED) ;
          			CheckMenuItem (hMenu, IDM_SEQUENCE_STOPPED,	MF_CHECKED) ;
          			return 0 ;
          
     	case 	WM_CLOSE:
          			if (!bNeedSave || IDCANCEL != AskAboutSave (hwnd, szTitleName))
               			DestroyWindow (hwnd) ;
          
          			return 0 ;
          
     	case 	WM_QUERYENDSESSION:
          			if (!bNeedSave || IDCANCEL != AskAboutSave (hwnd, szTitleName))
               			return 1L ;
          
         	 		return 0 ;
          
     	case 	WM_DESTROY:
          			DrumEndSequence (TRUE) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

BOOL CALLBACK AboutProc (	HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
     	switch (message)
     	{
     	case 	WM_INITDIALOG:
          			return TRUE ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDOK:
               					EndDialog (hDlg, 0) ;
               					return TRUE ;
          			}
          			break ;
     	}
     	return FALSE ;
}

void DrawRectangle (	HDC hdc, int x, int y, DWORD * dwSeqPerc, 
							DWORD * dwSeqPian)
{
     	int iBrush ;
     	if (dwSeqPerc [y] & dwSeqPian [y] & (1L << x))
          			iBrush = BLACK_BRUSH ;
     	else if (dwSeqPerc [y] & (1L << x))
          					iBrush = DKGRAY_BRUSH ;
     	else if (dwSeqPian [y] & (1L << x))
          					iBrush = LTGRAY_BRUSH ;
     	else
          			iBrush = WHITE_BRUSH ;
     	SelectObject (hdc, GetStockObject (iBrush)) ;
     	Rectangle (hdc, (x + 40) * cxChar , (2 * y + 4) * cyChar / 4,
                     					(x + 41) * cxChar + 1, (2 * y + 6) * cyChar / 4 + 1) ;
}

void ErrorMessage (HWND hwnd, TCHAR * szError, TCHAR * szTitleName)
{
     	wsprintf (szBuffer, szError,
          					(LPSTR) (szTitleName [0] ? szTitleName : szUntitled)) ;
     	MessageBeep (MB_ICONEXCLAMATION) ;
     	MessageBox (hwnd, szBuffer, szAppName, MB_OK | MB_ICONEXCLAMATION) ;
}

void DoCaption (HWND hwnd, TCHAR * szTitleName)
{
     	wsprintf (szBuffer, TEXT ("MIDI Drum Machine - %s"),
               					(LPSTR) (szTitleName [0] ? szTitleName : szUntitled)) ;
     	SetWindowText (hwnd, szBuffer) ;
}

int AskAboutSave (HWND hwnd, TCHAR * szTitleName)
{
     	int iReturn ;
     	wsprintf (szBuffer, TEXT ("Save current changes in %s?"),
               					(LPSTR) (szTitleName [0] ? szTitleName : szUntitled)) ;
     	iReturn = MessageBox (	hwnd, szBuffer, szAppName,
                           		MB_YESNOCANCEL | MB_ICONQUESTION) ;
     
     	if (iReturn == IDYES)
          			if (!SendMessage (hwnd, WM_COMMAND, IDM_FILE_SAVE, 0))
               					iReturn = IDCANCEL ;
     	return iReturn ;
}

 DRUMTIME.H
/*--------------------------------------------------------------------------
   	DRUMTIME.H Header File for Time Functions for DRUM Program
----------------------------------------------------------------------------*/

#define NUM_PERC         					47
#define WM_USER_NOTIFY   		(WM_USER + 1)
#define WM_USER_FINISHED 		(WM_USER + 2)
#define WM_USER_ERROR    			(WM_USER + 3)

#pragma pack(push, 2)
typedef struct
{
     	short iMsecPerBeat ;
     	short iVelocity ;
     	short iNumBeats ;
     	DWORD dwSeqPerc [NUM_PERC] ;
     	DWORD dwSeqPian [NUM_PERC] ;
}
DRUM, * PDRUM ;
#pragma pack(pop)
void DrumSetParams     				(PDRUM) ;
BOOL DrumBeginSequence 		(HWND)  ;
void DrumEndSequence   			(BOOL)  ;

 DRUMTIME.C
/*-----------------------------------------------------------------------------
   	DRUMFILE.C --	Timer Routines for DRUM
                 						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include "drumtime.h"

#define minmax(a,x,b) (min (max (x, a), b))
#define TIMER_RES   5
void CALLBACK DrumTimerFunc (UINT, UINT, DWORD, DWORD, DWORD) ;
BOOL     			bSequenceGoing, bEndSequence ;
DRUM     			drum ;
HMIDIOUT 		hMidiOut ;
HWND     			hwndNotify ;
int      			iIndex ;
UINT     			uTimerRes, uTimerID ;

DWORD MidiOutMessage (	HMIDIOUT hMidi, int iStatus, int iChannel,
                      								int iData1, int iData2)
{
	DWORD dwMessage ;
     	dwMessage = iStatus | iChannel | (iData1 << 8) | (iData2 << 16) ;
     	return midiOutShortMsg (hMidi, dwMessage) ;
}

void DrumSetParams (PDRUM pdrum)
{
	CopyMemory (&drum, pdrum, sizeof (DRUM)) ;
}

BOOL DrumBeginSequence (HWND hwnd)
{
     	TIMECAPS tc ;
     	hwndNotify = hwnd ;           			// Save window handle for notification
     	DrumEndSequence (TRUE) ;     	// Stop current sequence if running
     
          			// Open the MIDI Mapper output port
     
     	if (midiOutOpen (&hMidiOut, MIDIMAPPER, 0, 0, 0))
          			return FALSE ;
          		// Send Program Change messages for channels 9 and 0
     	MidiOutMessage (hMidiOut, 0xC0, 9, 0, 0) ;
     	MidiOutMessage (hMidiOut, 0xC0, 0, 0, 0) ;
     
          		// Begin sequence by setting a timer event
  	timeGetDevCaps (&tc, sizeof (TIMECAPS)) ;
     	uTimerRes = minmax (tc.wPeriodMin, TIMER_RES, tc.wPeriodMax) ;
     	timeBeginPeriod (uTimerRes) ;
     
     	uTimerID = timeSetEvent(max ((UINT) uTimerRes, (UINT) drum.iMsecPerBeat),
                   uTimerRes, DrumTimerFunc, 0, TIME_ONESHOT) ;
     
     	if (uTimerID == 0)
 	{
          		timeEndPeriod (uTimerRes) ;
          		midiOutClose (hMidiOut) ;
          		return FALSE ;
     	}
     
     	iIndex = -1 ;
     	bEndSequence = FALSE ;
     	bSequenceGoing = TRUE ;
     
     	return TRUE ;
}

void DrumEndSequence (BOOL bRightAway)
{
     	if (bRightAway)
     	{
          		if (bSequenceGoing)
          		{
                    					// stop the timer
               			if (uTimerID)
                    					timeKillEvent (uTimerID) ;
               					timeEndPeriod (uTimerRes) ;

       // turn off all notes
               					MidiOutMessage (hMidiOut, 0xB0, 9, 123, 0) ;
       					MidiOutMessage (hMidiOut, 0xB0, 0, 123, 0) ;
      // close the MIDI port midiOutClose (hMidiOut) ; bSequenceGoing = FALSE ;
          			}
     	}
     	else
   		bEndSequence = TRUE ;
}

void CALLBACK DrumTimerFunc (	UINT  uID, UINT uMsg, DWORD dwUser,
                             	DWORD dw1, DWORD dw2)
{
	static DWORD 	dwSeqPercLast [NUM_PERC], dwSeqPianLast [NUM_PERC] ;
	int          				i ;
     
         			// Note Off messages for channels 9 and 0
     
     	if (iIndex != -1)
     	{
          		for (i = 0 ; i < NUM_PERC ; i++)
 		{
               			if (dwSeqPercLast[i] & 1 << iIndex)
                    					MidiOutMessage (hMidiOut, 0x80, 9, i + 35, 0) ;
               			if (dwSeqPianLast[i] & 1 << iIndex) 
                    					MidiOutMessage (hMidiOut, 0x80, 0, i + 35, 0) ;
          		}
  	}
     
          		// Increment index and notify window to advance bouncing ball
     	iIndex = (iIndex + 1) % drum.iNumBeats ;
     	PostMessage (hwndNotify, WM_USER_NOTIFY, iIndex, timeGetTime ()) ;
     
          		// Check if ending the sequence
     	if (bEndSequence && iIndex == 0)
     	{
          		PostMessage (hwndNotify, WM_USER_FINISHED, 0, 0L) ;
          		return ;
     	}
     
          		// Note On messages for channels 9 and 0
     	for (i = 0 ; i < NUM_PERC ; i++)
     	{
          		if (drum.dwSeqPerc[i] & 1 << iIndex)
               				MidiOutMessage (hMidiOut, 0x90, 9, i + 35, drum.iVelocity) ;
          		if (drum.dwSeqPian[i] & 1 << iIndex)
               				MidiOutMessage (hMidiOut, 0x90, 0, i + 35, drum.iVelocity) ;
          				dwSeqPercLast[i] = drum.dwSeqPerc[i] ;
          				dwSeqPianLast[i] = drum.dwSeqPian[i] ;
     		}
          				// Set a new timer event
     	uTimerID = timeSetEvent (max ((int) uTimerRes, drum.iMsecPerBeat),
                   uTimerRes, DrumTimerFunc, 0, TIME_ONESHOT) ;
     	if (uTimerID == 0)
     	{
          		PostMessage (hwndNotify, WM_USER_ERROR, 0, 0) ;
     	}
}

 DRUMFILE.H
/*---------------------------------------------------------------------------
   	DRUMFILE.H Header File for File I/O Routines for DRUM
-----------------------------------------------------------------------------*/

BOOL    		DrumFileOpenDlg 	(HWND, TCHAR *, TCHAR *) ;
BOOL    		DrumFileSaveDlg 	(HWND, TCHAR *, TCHAR *) ;

TCHAR	* 	DrumFileWrite   		(DRUM *, TCHAR *) ;
TCHAR	* 	DrumFileRead    		(DRUM *, TCHAR *) ;

 DRUMFILE.C
/*----------------------------------------------------------------------------
   	DRUMFILE.C --		File I/O Routines for DRUM
                 							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/
#include <windows.h>
#include <commdlg.h>
#include "drumtime.h"
#include "drumfile.h"

OPENFILENAME ofn = { sizeof (OPENFILENAME) } ;
TCHAR * szFilter[] = { 	TEXT ("Drum Files (*.DRM)"),  
                       	TEXT ("*.drm"), TEXT ("") } ;

TCHAR szDrumID 	    []	= TEXT ("DRUM") ;
TCHAR szListID 		[]	= TEXT ("LIST") ;
TCHAR szInfoID 		[]	= TEXT ("INFO") ;
TCHAR szSoftID 		[]	= TEXT ("ISFT") ;
TCHAR szDateID 		[]	= TEXT ("ISCD") ;
TCHAR szFmtID  	[]	= TEXT ("fmt ") ;
TCHAR szDataID 		[]	= TEXT ("data") ;
char  szSoftware	    []	= "DRUM by Charles Petzold, Programming Windows" ;

TCHAR szErrorNoCreate    	[]	=	TEXT	("File %s could not be opened for writing.");
TCHAR szErrorCannotWrite		[]	=	TEXT	("File %s could not be written to. ") ;
TCHAR szErrorNotFound    	[]	=	TEXT	("File %s not found or cannot be opened.") ;
TCHAR szErrorNotDrum		[]	=	TEXT	("File %s is not a standard DRUM file.") ;
TCHAR szErrorUnsupported		[]	=	TEXT	("File %s is not a supported DRUM file.") ;
TCHAR szErrorCannotRead		[]	=	TEXT	("File %s cannot be read.") ;

BOOL DrumFileOpenDlg (HWND hwnd, TCHAR * szFileName, TCHAR * szTitleName)
{
     		ofn.hwndOwner         			= hwnd ;
     		ofn.lpstrFilter      		 		= szFilter [0] ;
     		ofn.lpstrFile         				= szFileName ;
     		ofn.nMaxFile          			= MAX_PATH ;
     		ofn.lpstrFileTitle    			    = szTitleName ;
     		ofn.nMaxFileTitle     				= MAX_PATH ;
     		ofn.Flags             						= OFN_CREATEPROMPT ;
     		ofn.lpstrDefExt       				= TEXT ("drm") ;
     
     	return GetOpenFileName (&ofn) ;
}

BOOL DrumFileSaveDlg (	HWND hwnd, TCHAR * szFileName, 
								TCHAR * szTitleName)
{
     		ofn.hwndOwner         			= hwnd ;
     		ofn.lpstrFilter       				= szFilter [0] ;
     		ofn.lpstrFile         				= szFileName ;
     		ofn.nMaxFile          			= MAX_PATH ;
     		ofn.lpstrFileTitle    			    = szTitleName ;
     		ofn.nMaxFileTitle     				= MAX_PATH ;
     		ofn.Flags             						= OFN_OVERWRITEPROMPT ;
     		ofn.lpstrDefExt       				= TEXT ("drm") ;
     
     	return GetSaveFileName (&ofn) ;
}

TCHAR * DrumFileWrite (DRUM * pdrum, TCHAR * szFileName)
{
     	char        				szDateBuf [16] ;
     	HMMIO       				hmmio ;
     	int         				iFormat = 2 ;
     	MMCKINFO    			mmckinfo [3] ;
     	SYSTEMTIME  		st ;
     	WORD        				wError = 0 ;
     
     	memset (mmckinfo, 0, 3 * sizeof (MMCKINFO)) ;
          				// Recreate the file for writing
    	if ((hmmio = mmioOpen (szFileName, NULL,
               			MMIO_CREATE | MMIO_WRITE | MMIO_ALLOCBUF)) == NULL)
          			return szErrorNoCreate ;
          				// Create a "RIFF" chunk with a "CPDR" type
     	mmckinfo[0].fccType = mmioStringToFOURCC (szDrumID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[0], MMIO_CREATERIFF) ;
          				// Create "LIST" sub-chunk with an "INFO" type
     	mmckinfo[1].fccType = mmioStringToFOURCC (szInfoID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[1], MMIO_CREATELIST) ;
          				// Create "ISFT" sub-sub-chunk
     	mmckinfo[2].ckid = mmioStringToFOURCC (szSoftID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[2], 0) ;
     	wError |= (mmioWrite (hmmio, szSoftware, 	sizeof (szSoftware)) !=
                              sizeof (szSoftware)) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[2], 0) ;
          					// Create a time string
     	GetLocalTime (&st) ;
     	wsprintfA (szDateBuf, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay) ;
          					// Create "ISCD" sub-sub-chunk
     	mmckinfo[2].ckid = mmioStringToFOURCC (szDateID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[2], 0) ;
     	wError |= (mmioWrite (hmmio, szDateBuf, (strlen (szDateBuf) + 1)) !=
                                       					(int) (strlen (szDateBuf) + 1)) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[2], 0) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[1], 0) ;
     
          					// Create "fmt " sub-chunk
     	mmckinfo[1].ckid = mmioStringToFOURCC (szFmtID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[1], 0) ;
     	wError |= (mmioWrite (hmmio, (PSTR) &iFormat, 	sizeof (int)) !=
                   sizeof (int)) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[1], 0) ;
          					// Create the "data" sub-chunk
     	mmckinfo[1].ckid = mmioStringToFOURCC (szDataID, 0) ;
     	wError |= mmioCreateChunk (hmmio, &mmckinfo[1], 0) ;
     	wError |= (mmioWrite (hmmio, (PSTR) pdrum, sizeof (DRUM)) !=
                   sizeof (DRUM)) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[1], 0) ;
     	wError |= mmioAscend (hmmio, &mmckinfo[0], 0) ;
     
          					// Clean up and return
   	wError |= mmioClose (hmmio, 0) ;
     	if (wError)
     	{
          		mmioOpen (szFileName, NULL, MMIO_DELETE) ;
          		return szErrorCannotWrite ;
     	}
     	return NULL ;
}

TCHAR * DrumFileRead (DRUM * pdrum, TCHAR * szFileName)
{
     	DRUM     			drum ;
     	HMMIO    			hmmio ;
     	int      			i, iFormat ;
     	MMCKINFO 		mmckinfo [3] ;
     
     	ZeroMemory 	(mmckinfo, 2 * sizeof (MMCKINFO)) ;
     
         				// Open the file
     
     	if ((hmmio = mmioOpen (szFileName, NULL, MMIO_READ)) == NULL)
          		return szErrorNotFound ;
          				// Locate a "RIFF" chunk with a "DRUM" form-type
     	mmckinfo[0].ckid = mmioStringToFOURCC (szDrumID, 0) ;
     	if (mmioDescend (hmmio, &mmckinfo[0], NULL, MMIO_FINDRIFF))
     	{
          		mmioClose (hmmio, 0) ;
    		return szErrorNotDrum ;
     }
     
          		// Locate, read, and verify the "fmt " sub-chunk
     	mmckinfo[1].ckid = mmioStringToFOURCC (szFmtID, 0) ;
 	if (mmioDescend (hmmio, &mmckinfo[1], &mmckinfo[0], MMIO_FINDCHUNK))
     	{
          		mmioClose (hmmio, 0) ;
          		return szErrorNotDrum ;
     	}
     
  	if (mmckinfo[1].cksize != sizeof (int))
     	{
         	 	mmioClose (hmmio, 0) ;
   		return szErrorUnsupported ;
     }
     
     	if (mmioRead (hmmio, (PSTR) &iFormat, sizeof (int)) != sizeof (int))
     {
          		mmioClose (hmmio, 0) ;
          		return szErrorCannotRead ;
     }
     
     	if (iFormat != 1 && iFormat != 2)
     {
          		mmioClose (hmmio, 0) ;
          		return szErrorUnsupported ;
     }
     
          		// Go to end of "fmt " sub-chunk
     	mmioAscend (hmmio, &mmckinfo[1], 0) ;
          		// Locate, read, and verify the "data" sub-chunk
     	mmckinfo[1].ckid = mmioStringToFOURCC (szDataID, 0) ;
     	if (mmioDescend (hmmio, &mmckinfo[1], &mmckinfo[0], MMIO_FINDCHUNK))
     {
          		mmioClose (hmmio, 0) ;
          		return szErrorNotDrum ;
     }
     
     	if (mmckinfo[1].cksize != sizeof (DRUM))
     	{
          		mmioClose (hmmio, 0) ;
          		return szErrorUnsupported ;
     }
     
     	if (mmioRead (hmmio, (LPSTR) &drum, sizeof (DRUM)) != sizeof (DRUM))
     	{
          		mmioClose (hmmio, 0) ;
          		return szErrorCannotRead ;
     }
     
          			// Close the file 
     	mmioClose (hmmio, 0) ;
          		// Convert format 1 to format 2 and copy the DRUM structure data
     	if (iFormat == 1)
     	{
          		for (i = 0 ; i < NUM_PERC ; i++)
          		{
               			drum.dwSeqPerc [i] = drum.dwSeqPian [i] ;
               			drum.dwSeqPian [i] = 0 ;
          		}
     	}
     
     		memcpy (pdrum, &drum, sizeof (DRUM)) ;
     		return NULL ;
}

 DRUM.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
DRUM 	MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        MENUITEM "&New",	      IDM_FILE_NEW
        MENUITEM "&Open...",    IDM_FILE_OPEN
        MENUITEM "&Save",		  IDM_FILE_SAVE
        MENUITEM "Save &As...", IDM_FILE_SAVE_AS
        MENUITEM SEPARATOR
        MENUITEM "E&xit",       IDM_APP_EXIT
    	END
    	POPUP "&Sequence"
    	BEGIN
        MENUITEM "&Running",    IDM_SEQUENCE_RUNNING
        MENUITEM "&Stopped",    IDM_SEQUENCE_STOPPED
        , CHECKED
    	END
    	POPUP "&Help"
    	BEGIN
        MENUITEM "&About...",   IDM_APP_ABOUT
    	END
END

/////////////////////////////////////////////////////////////////////////////
// Icon
DRUM          ICON   	   DISCARDABLE         "drum.ico"

/////////////////////////////////////////////////////////////////////////////
// Dialog
ABOUTBOX DIALOG DISCARDABLE  20, 20, 160, 164
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Dialog"
FONT 8, "MS Sans Serif"
BEGIN
DEFPUSHBUTTON  "OK",IDOK,54,143,50,14
ICON        "DRUM",IDC_STATIC,8,8,21,20
CTEXT       "DRUM",IDC_STATIC,34,12,90,8
CTEXT     	"MIDI Drum Machine",IDC_STATIC,7,36,144,8
CONTROL     "",IDC_STATIC,"Static",SS_BLACKFRAME,8,88,144,46
LTEXT    	"Left Button:\t\tDrum sounds",IDC_STATIC,12,92,136,8
LTEXT    	"Right Button:\t\tPiano sounds",IDC_STATIC,12,102,136,8
LTEXT  		"Horizontal Scroll:\t\tVelocity",IDC_STATIC,12,112,136,8
LTEXT  		"Vertical Scroll:\t\tTempo",IDC_STATIC,12,122,136,8
CTEXT   	"Copyright (c) Charles Petzold, 1998",IDC_STATIC,8,48, 144,8
CTEXT    	"""Programming Windows,"" 5th Edition",IDC_STATIC,8,60, 144,8
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by Drum.rc

#define 		IDM_FILE_NEW                    					40001
#define 		IDM_FILE_OPEN                   					40002
#define 		IDM_FILE_SAVE                   					40003
#define 		IDM_FILE_SAVE_AS                					40004
#define 		IDM_APP_EXIT                    					40005
#define 		IDM_SEQUENCE_RUNNING            				40006
#define 		IDM_SEQUENCE_STOPPED            				40007
#define 		IDM_APP_ABOUT                   					40008

timeGetDevCaps (&timecaps, uSize) ;

timeBeginPeriod (uResolution) ;

idTimer = timeSetEvent (	uDelay, uResolution, CallBackFunc, dwData, uFlag) ;

timeKillEvent (idTimer) ;

timeEndPeriod (wResolution) ;

dwSysTime = timeGetTime () ;

timeGetSystemTime (&mmtime, uSize) ;