able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/test/sbtest/sbtest.c

1020 lines
28 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************
*
* sbtest.c
*
* Copyright (c) 1991 Microsoft Corporation. All Rights Reserved.
*
***************************************************************************/
#include <windows.h>
#include <mmsystem.h>
#include "wincom.h"
#include "sbtest.h"
#include <commdlg.h>
/****************************************************************************
*
* public data
*
***************************************************************************/
HANDLE ghInst; // global instance handle
char szAppName[10]; // app name
HWND hPrintfWnd; // printf child window
HWND hwndVolumeDlg;
int fDebug;
BYTE bChannel = 0;
UINT wLoops = IDM_LOOPOFF;
HMIDIOUT hMidiOut = NULL;
char ach[256];
OPENFILENAME ofn;
char szFname[MAXFILENAME];
BOOL AuxNotSupported;
BOOL SetAux;
/****************************************************************************
*
* local data
*
***************************************************************************/
static HMIDIIN hMidiIn = NULL;
static int iProfiler;
int FAR PASCAL VolumeDlgProc(HWND, unsigned, UINT, LONG);
/****************************************************************************
*
* internal function prototypes
*
***************************************************************************/
static void GetInfo(void);
static void CommandMsg(HWND hWnd, UINT wParam, LONG lParam);
/***************************************************************************
get and show device info
***************************************************************************/
static void GetInfo(void)
{
WAVEOUTCAPS wc;
WAVEINCAPS wic;
MIDIOUTCAPS mc;
MIDIINCAPS mic;
AUXCAPS ac;
UINT wDevs, wDevice;
char acherr[80];
UINT wErr;
wDevs = waveInGetNumDevs();
if (wDevs > 32)
wDevs = 0;
sprintf(ach, "\n%u Wave Input Devices\n", wDevs);
dbgOut;
for (wDevice = 0; wDevice < wDevs; wDevice++) {
sprintf(ach, "Wave input device %u: ", wDevice);
dbgOut;
wErr = waveInGetDevCaps(wDevice, &wic, sizeof(wic));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s", wic.wMid, wic.wPid, (LPSTR) wic.szPname);
dbgOut;
sprintf(ach, "\nFormats:%8.8lXH", wic.dwFormats);
dbgOut;
sprintf(ach, ", channels:%4.4XH\n", wic.wChannels);
dbgOut;
}
else {
sprintf(ach, " Error Getting Wave Input Capabilities\n");
dbgOut;
waveInGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
}
}
wDevs = waveOutGetNumDevs();
if (wDevs > 32)
wDevs = 0;
sprintf(ach, "\n%u Wave Output Devices\n", wDevs);
for (wDevice = 0; wDevice < wDevs; wDevice++) {
sprintf(ach, "Wave output device %u: ", wDevice);
wErr = waveOutGetDevCaps(wDevice, &wc, sizeof(wc));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s", wc.wMid, wc.wPid, (LPSTR) wc.szPname);
dbgOut;
sprintf(ach, "\nFormats:%8.8lXH\n", wc.dwFormats);
dbgOut;
}
else {
sprintf(ach, " Error Getting Wave Output Capabilities\n");
dbgOut;
waveOutGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
}
}
wDevs = midiInGetNumDevs();
if (wDevs > 32)
wDevs = 0;
sprintf(ach, "\n%u MIDI Input Devices\n", wDevs);
for (wDevice = 0; wDevice < wDevs; wDevice++) {
sprintf(ach, "MIDI input device %u: ", wDevice);
wErr = midiInGetDevCaps(wDevice, &mic, sizeof(mic));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s\n", mic.wMid, mic.wPid, (LPSTR) mic.szPname);
dbgOut;
}
else {
sprintf(ach, " Error Getting MIDI Input Capabilities\n");
dbgOut;
midiInGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
}
}
wDevs = midiOutGetNumDevs();
if (wDevs > 32)
wDevs = 0;
sprintf(ach, "\n%u MIDI Output Devices\n", wDevs);
dbgOut;
for (wDevice = 0; wDevice < wDevs; wDevice++) {
sprintf(ach, "MIDI output device %u: ", wDevice);
wErr = midiOutGetDevCaps(wDevice, &mc, sizeof(mc));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s", mc.wMid, mc.wPid, (LPSTR) mc.szPname);
dbgOut;
sprintf(ach, "\nTechnology:%4.4XH", mc.wTechnology);
dbgOut;
sprintf(ach, ", voices:%4.4XH", mc.wVoices);
dbgOut;
sprintf(ach, ", notes:%4.4XH\n", mc.wNotes);
dbgOut;
}
else {
sprintf(ach, " Error Getting MIDI Output Capabilities\n");
dbgOut;
midiOutGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
}
}
sprintf(ach, "MIDI output device %u: ", MIDIMAPPER);
wErr = midiOutGetDevCaps(MIDIMAPPER, &mc, sizeof(mc));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s", mc.wMid, mc.wPid, (LPSTR) mc.szPname);
dbgOut;
sprintf(ach, "\nTechnology:%4.4XH", mc.wTechnology);
dbgOut;
sprintf(ach, ", voices:%4.4XH", mc.wVoices);
dbgOut;
sprintf(ach, ", notes:%4.4XH\n", mc.wNotes);
dbgOut;
}
else {
sprintf(ach, " Error Getting MIDI Output Capabilities\n");
dbgOut;
midiOutGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
}
wDevs = auxGetNumDevs();
if (wDevs > 32)
wDevs = 0;
sprintf(ach, "\n%u Auxiliary Output Devices\n", wDevs);
dbgOut;
for (wDevice = 0; wDevice < wDevs; wDevice++) {
sprintf(ach, "Auxiliary output device %u: ", wDevice);
dbgOut;
wErr = auxGetDevCaps(wDevice, &ac, sizeof(ac));
if (!wErr) {
sprintf(ach, "Mid:%u, Pid:%u, %s", ac.wMid, ac.wPid, (LPSTR) ac.szPname);
dbgOut;
sprintf(ach, "\nTechnology:%4.4XH", ac.wTechnology);
dbgOut;
sprintf(ach, ", Support:%4.4XH", ac.dwSupport);
dbgOut;
}
else {
sprintf(ach, " Error Getting Auxiliary Output Capabilities\n");
dbgOut;
}
}
}
/***************** Main entry point routine *************************/
int __cdecl main(int argc, char **argv)
{
MSG msg;
/* fill in non-variant fields of OPENFILENAME struct. */
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hMainWnd;
ofn.lpstrFilter = NULL;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 1;
ofn.lpstrFile = szFname;
ofn.nMaxFile = MAXFILENAME;
ofn.lpstrInitialDir = NULL;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrTitle = NULL;
ofn.lpstrDefExt = "WAV";
ofn.Flags = 0;
ghInst = GetModuleHandle(NULL); // save our instance handle
// medClientInit();
LoadString(ghInst, IDS_APPNAME, szAppName, sizeof(szAppName));
if (! InitFirstInstance(ghInst)) {
return 1;
}
if (!InitEveryInstance(ghInst, SW_SHOWDEFAULT))
return 1;
// check for messages from Windows and process them
// if no messages, perform some idle function
do {
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
// got a message to process
if (msg.message == WM_QUIT) break;
if (!TranslateAccelerator(hMainWnd, hAccTable, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else {
if (hPosWnd)
ShowPos();
else
WaitMessage();
}
} while (1);
// medClientExit();
return (msg.wParam);
}
/************* main window message handler ******************************/
long FAR PASCAL MainWndProc(HWND hWnd, unsigned message, UINT wParam, LONG lParam)
{
PAINTSTRUCT ps; // paint structure
WAVEOUTCAPS wc;
AUXCAPS ac;
// process any messages we want
switch (message) {
case WM_CREATE:
InitMenus(hWnd);
hPrintfWnd = wpfCreateWindow(hWnd,
ghInst,
"",
WS_CHILD | WS_VISIBLE | WS_VSCROLL,
0, 0, 0, 0,
100,
0);
sprintf(ach, "Wave and MIDI device driver test app.\n");
dbgOut;
waveOutGetDevCaps( 0, &wc, sizeof(wc) );
EnableMenuItem( GetMenu( hWnd ),
IDM_VOLUME,
wc.dwSupport & WAVECAPS_VOLUME
? MF_ENABLED : MF_GRAYED );
if ( !(wc.dwSupport & WAVECAPS_VOLUME) ) {
hwndVolumeDlg = (HWND)1;
}
memset(&ac, 0, sizeof(ac));
auxGetDevCaps( 0, &ac, sizeof(ac) );
EnableMenuItem( GetMenu( hWnd ),
IDM_AUX_VOLUME,
ac.dwSupport & AUXCAPS_VOLUME
? MF_ENABLED : MF_GRAYED );
if ( !(wc.dwSupport & WAVECAPS_VOLUME) ) {
AuxNotSupported = 1;
}
#if 0
{
HMENU hMenu;
iProfiler = ProfInsChk();
switch (iProfiler) {
case 1:
sprintf(ach, "Profiler installed for real/286p modes\n");
dbgOut;
break;
case 2:
sprintf(ach, "Profiler installed for real/286p/386p modes\n");
dbgOut;
break;
default:
sprintf(ach, "Profiler not installed\n");
dbgOut;
iProfiler = 0;
hMenu = GetMenu(hWnd);
EnableMenuItem(hMenu, IDM_PROFSTART, MF_GRAYED);
break;
}
}
#endif
break;
case WM_SIZE:
MoveWindow(hPrintfWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
break;
case WM_COMMAND:
// process menu messages
CommandMsg(hWnd, wParam, lParam);
break;
case WM_PAINT:
BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
if (hMidiOut)
midiOutClose(hMidiOut);
if (hMidiIn)
midiInClose(hMidiIn);
if (hWaveOut) {
waveOutReset(hWaveOut);
waveOutClose(hWaveOut);
}
if (hWaveIn) {
waveInReset(hWaveIn);
waveInClose(hWaveIn);
}
PostQuitMessage(0);
break;
case MM_WIM_CLOSE:
sprintf(ach, " MM_WIM_CLOSE: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_WIM_DATA:
sprintf(ach, " MM_WIM_DATA: %04X %08lX\n",wParam,lParam);
dbgOut;
//
// Get more data if possible
//
dwRecorded += ((LPWAVEHDR)lParam)->dwBytesRecorded;
if (hWaveIn &&
(dwDataSize - (lpRecordBuf - (LPSTR)((LPWAVEHDR)lParam)->lpData))
>= dwBlockSize) {
UINT wRet;
char acherr[80];
((LPWAVEHDR)lParam)->lpData += dwBlockSize;
wRet = waveInAddBuffer(hWaveIn, (LPWAVEHDR)lParam, sizeof(WAVEHDR));
if (wRet) {
waveInGetErrorText(wRet, acherr, sizeof(acherr));
sprintf(ach, "\nwaveInAddBuffer: %s", (LPSTR) acherr);
dbgOut;
}
}
break;
case MM_WIM_OPEN:
sprintf(ach, " MM_WIM_OPEN: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_WOM_OPEN:
sprintf(ach, " MM_WOM_OPEN: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_WOM_CLOSE:
sprintf(ach, " MM_WOM_CLOSE: %04X %08lX\n",wParam,lParam);
dbgOut;
if (hWaveOut != (HWAVEOUT)wParam) {
sprintf(ach, " MM_WOM_CLOSE: ACK! wParam doesn't match hWaveOut!!!!\n");
return 0L;
}
iWaveOut = 0;
hWaveOut = NULL;
break;
case MM_WOM_DONE:
sprintf(ach, " MM_WOM_DONE: %04X %08lX\n",wParam,lParam);
dbgOut;
if (hWaveOut != (HWAVEOUT)wParam) {
sprintf(ach, " MM_WOM_DONE: ACK! wParam doesn't match hWaveOut!!!!\n");
return 0L;
}
//
// the wave block is done playing, we need to let the driver unprepare
// it and free the memory it used.
//
// wParam = hWaveOut
// lParam = lpWaveHdr
//
waveOutUnprepareHeader((HWAVEOUT)wParam, (LPWAVEHDR)lParam, sizeof(WAVEHDR));
// GlobalUnlock(lParam);
// LocalFree(lParam);
GlobalFree( (HANDLE)lParam );
//
// if we have no more outstanding blocks free the wave device.
//
if (--iWaveOut == 0) {
sprintf(ach, " MM_WOM_DONE: Releasing the wave device\n");
waveOutClose(hWaveOut);
}
break;
case MM_MIM_OPEN:
sprintf(ach, " MM_MIM_OPEN: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MIM_CLOSE:
sprintf(ach, " MM_MIM_CLOSE: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MIM_DATA:
sprintf(ach, " MM_MIM_DATA: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MIM_LONGDATA:
sprintf(ach, " MM_MIM_LONGDATA: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MIM_ERROR:
sprintf(ach, " MM_MIM_ERROR: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MIM_LONGERROR:
sprintf(ach, " MM_MIM_LONGERROR: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MOM_OPEN:
sprintf(ach, " MM_MOM_OPEN: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MOM_CLOSE:
sprintf(ach, " MM_MOM_CLOSE: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case MM_MOM_DONE:
sprintf(ach, " MM_MOM_DONE: %04X %08lX\n",wParam,lParam);
dbgOut;
break;
case WM_INITMENU:
EnableMenuItem((HWND)wParam, IDM_LOOPBREAK , hWaveOut ? MF_ENABLED : MF_GRAYED);
EnableMenuItem((HWND)wParam, IDM_RESET , hWaveOut ? MF_ENABLED : MF_GRAYED);
EnableMenuItem((HWND)wParam, IDM_PAUSE , hWaveOut ? MF_ENABLED : MF_GRAYED);
EnableMenuItem((HWND)wParam, IDM_RESUME , hWaveOut ? MF_ENABLED : MF_GRAYED);
EnableMenuItem((HWND)wParam, IDM_VOLUME, hwndVolumeDlg ? MF_GRAYED : MF_ENABLED);
EnableMenuItem((HWND)wParam, IDM_AUX_VOLUME, AuxNotSupported ? MF_GRAYED : MF_ENABLED);
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
static void CommandMsg(HWND hWnd, UINT wParam, LONG lParam)
{
int i;
HMENU hMenu;
BYTE acherr[80];
UINT wErr;
UINT wPortNum;
SHORTMSG sm;
switch (wParam) {
case IDM_SNDPLAYSOUND:
case IDM_PLAYWAVE:
// GetProfileString(szAppName, "wavpath", "", szPath, sizeof(szPath));
// if (lstrlen(szPath)) {
// DosChangeDir(szPath);
// }
// i = OpenFileDialog(hMainWnd,
// "Open file",
// "*.WAV",
// DLGOPEN_MUSTEXIST | DLGOPEN_OPEN,
// szFname,
// sizeof(szFname));
// if (i == DLG_MISSINGFILE) {
// sbtestError"Illegal filename");
// }
// else if (i == DLG_CANCEL) {
// // user pressed cancel
// }
// else {
// }
if (GetOpenFileName(&ofn)) {
// valid file name
if (wParam == IDM_SNDPLAYSOUND) {
if (wLoops == IDM_LOOPOFF)
sndPlaySound(ofn.lpstrFile, SND_ASYNC);
else
sndPlaySound(ofn.lpstrFile, SND_ASYNC|SND_LOOP);
}
else {
PlayFile(ofn.lpstrFile);
}
}
break;
case IDM_LOOPOFF:
case IDM_LOOP2:
case IDM_LOOP100:
wLoops = wParam;
hMenu = GetMenu(hWnd);
CheckMenuItem(hMenu, IDM_LOOPOFF, MF_UNCHECKED);
CheckMenuItem(hMenu, IDM_LOOP2, MF_UNCHECKED);
CheckMenuItem(hMenu, IDM_LOOP100, MF_UNCHECKED);
CheckMenuItem(hMenu, wParam, MF_CHECKED);
if (wParam != IDM_LOOP100) {
if (hWaveOut) {
waveOutBreakLoop(hWaveOut);
}
}
break;
case IDM_LOOPBREAK:
if (hWaveOut) {
waveOutBreakLoop(hWaveOut);
}
break;
case IDM_POSITION:
if (hPosWnd == NULL) {
CreatePosition(hWnd);
}
else {
DestroyWindow(hPosWnd);
hPosWnd = NULL;
}
break;
case IDM_RESET:
if (hWaveOut)
waveOutReset(hWaveOut);
break;
case IDM_PAUSE:
if (hWaveOut)
waveOutPause(hWaveOut);
break;
case IDM_RESUME:
if (hWaveOut)
waveOutRestart(hWaveOut);
break;
case IDM_RECORD:
Record(hWnd);
break;
case IDM_AUX_VOLUME:
SetAux = TRUE;
hwndVolumeDlg = CreateDialog(ghInst, "Volume", hWnd, (DLGPROC)VolumeDlgProc);
SetWindowPos( hwndVolumeDlg, (HWND)-1, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_SHOWWINDOW );
break;
case IDM_VOLUME:
SetAux = FALSE;
hwndVolumeDlg = CreateDialog(ghInst, "Volume", hWnd, (DLGPROC)VolumeDlgProc);
SetWindowPos( hwndVolumeDlg, (HWND)-1, 0,0,0,0, SWP_NOSIZE | SWP_NOMOVE |
SWP_NOZORDER | SWP_SHOWWINDOW );
break;
case IDM_I0:
case IDM_I1:
case IDM_I2:
case IDM_I3:
case IDM_I4:
case IDM_I5:
case IDM_I6:
case IDM_I7:
case IDM_I8:
case IDM_I9:
case IDM_I10:
case IDM_I11:
case IDM_I12:
case IDM_I13:
case IDM_I14:
case IDM_I15:
hMenu = GetMenu(hWnd);
for (i = IDM_I0; i <= IDM_I15; i++) {
CheckMenuItem(hMenu, i, MF_UNCHECKED);
}
CheckMenuItem(hMenu, wParam, MF_CHECKED);
EnableMenuItem(hMenu, IDM_STARTMIDIIN, MF_GRAYED);
EnableMenuItem(hMenu, IDM_STOPMIDIIN, MF_GRAYED);
if (hMidiIn) {
midiInClose(hMidiIn);
hMidiIn = NULL;
}
wPortNum = wParam - IDM_I0;
if (wPortNum != 0) {
// NOTE!!! we must PAGE-LOCK our CODE and DATA segment!!!!
// The FIXED segment attribute is ignored for applications
//
// Callbacks *must* be in FIXED code segments of DLLs *not* APPS
//
// *********** THIS APP IS TOTALY WRONG! *************
// ******************* DONT COPY THIS CODE! **********************
// #define GetDS() HIWORD((DWORD)((LPSTR)&hMidiIn))
// GlobalPageLock(GetDS());
wErr = midiInOpen(&hMidiIn, wPortNum - 1, (DWORD)SBMidiInCallback,
(DWORD)hMidiOut, CALLBACK_FUNCTION);
if (wErr) {
sprintf(ach, " Error opening MIDI Input\n");
dbgOut;
midiInGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
hMidiIn = NULL;
CheckMenuItem(hMenu, wParam, MF_UNCHECKED);
CheckMenuItem(hMenu, IDM_I0, MF_CHECKED);
}
else
EnableMenuItem(hMenu, IDM_STARTMIDIIN, MF_ENABLED);
}
break;
case IDM_STARTMIDIIN:
if (hMidiIn) {
hMenu = GetMenu(hWnd);
EnableMenuItem(hMenu, IDM_STARTMIDIIN, MF_GRAYED);
EnableMenuItem(hMenu, IDM_STOPMIDIIN, MF_ENABLED);
midiInStart(hMidiIn);
}
break;
case IDM_STOPMIDIIN:
if (hMidiIn) {
hMenu = GetMenu(hWnd);
EnableMenuItem(hMenu, IDM_STOPMIDIIN, MF_GRAYED);
EnableMenuItem(hMenu, IDM_STARTMIDIIN, MF_ENABLED);
midiInStop(hMidiIn);
}
break;
case IDM_D0:
case IDM_D1:
case IDM_D2:
case IDM_D3:
case IDM_D4:
case IDM_D5:
case IDM_D6:
case IDM_D7:
case IDM_D8:
case IDM_D9:
case IDM_D10:
case IDM_D11:
case IDM_D12:
case IDM_D13:
case IDM_D14:
case IDM_D15:
hMenu = GetMenu(hWnd);
for (i = IDM_D0; i <= IDM_D15; i++) {
CheckMenuItem(hMenu, i, MF_UNCHECKED);
}
CheckMenuItem(hMenu, wParam, MF_CHECKED);
if (hMidiOut) {
midiOutClose(hMidiOut);
hMidiOut = NULL;
}
if (wParam == IDM_D0 + LASTPORT)
wPortNum = MIDIMAPPER; // open mapper if chose last item
else
wPortNum = wParam - IDM_D0 - 1;
if (wParam != IDM_D0) {
wErr = midiOutOpen(&hMidiOut, wPortNum, (DWORD)hWnd, 0L, 0L);
if (wErr) {
sprintf(ach, " Error opening MIDI Output\n");
dbgOut;
midiOutGetErrorText(wErr, acherr, sizeof(acherr));
sprintf(ach, " Error: %s\n", (LPSTR) acherr);
dbgOut;
hMidiOut = NULL;
}
else { // send patch change
sm.b[0] = (BYTE) 0xC0 + bChannel;
sm.b[1] = bInstrument;
midiOutShortMsg(hMidiOut, sm.dw);
}
}
break;
case IDM_C0:
case IDM_C1:
case IDM_C2:
case IDM_C3:
case IDM_C4:
case IDM_C5:
case IDM_C6:
case IDM_C7:
case IDM_C8:
case IDM_C9:
case IDM_C10:
case IDM_C11:
case IDM_C12:
case IDM_C13:
case IDM_C14:
case IDM_C15:
hMenu = GetMenu(hWnd);
for (i = IDM_C0; i <= IDM_C15; i++) {
CheckMenuItem(hMenu, i, MF_UNCHECKED);
}
CheckMenuItem(hMenu, wParam, MF_CHECKED);
bChannel = (BYTE)(wParam - IDM_C0);
break;
case IDM_KEYBOARD:
if (hKeyWnd == NULL) {
CreateKeyboard(hWnd);
}
else {
DestroyWindow(hKeyWnd);
hKeyWnd = NULL;
}
break;
case IDM_INSTRUMENT:
if (hInstWnd == NULL) {
CreateInstrument(hWnd);
}
else {
DestroyWindow(hInstWnd);
hInstWnd = NULL;
}
break;
case IDM_DUMPPATCH:
hMenu = GetMenu(hWnd);
if (ISBITSET(fDebug, DEBUG_PATCH))
RESETBIT(fDebug, DEBUG_PATCH);
else
SETBIT(fDebug, DEBUG_PATCH);
CheckMenuItem(hMenu, wParam,
ISBITSET(fDebug, DEBUG_PATCH) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_DUMPNOTES:
hMenu = GetMenu(hWnd);
if (ISBITSET(fDebug, DEBUG_NOTE))
RESETBIT(fDebug, DEBUG_NOTE);
else
SETBIT(fDebug, DEBUG_NOTE);
CheckMenuItem(hMenu, wParam,
ISBITSET(fDebug, DEBUG_NOTE) ? MF_CHECKED : MF_UNCHECKED);
break;
case IDM_RIP:
//
// send total stuff to mmsystem APIs
//
waveOutPrepareHeader((HWAVEOUT)1, NULL, sizeof(WAVEHDR));
waveOutClose(NULL);
midiInPrepareHeader(0, (LPMIDIHDR)-1l, 4);
midiOutClose((HMIDIOUT)(-1));
break;
case IDM_GETINFO:
GetInfo();
break;
case IDM_WAVEOPTIONS:
WaveOptions(hWnd);
break;
case IDM_MIDIOPTIONS:
MidiOptions(hWnd);
break;
case IDM_ABOUT:
About(hWnd);
break;
case IDM_EXIT:
PostMessage(hWnd, WM_CLOSE, 0, 0l);
break;
#if 0
case IDM_PROFSTART:
if (iProfiler) {
GetProfileString(szAppName, "profpath", "", szPath, sizeof(szPath));
if (lstrlen(szPath)) {
DosChangeDir(szPath);
}
ProfStart();
sprintf(ach, "\nProfiler started. Files in %s", (LPSTR) szPath);
dbgOut;
EnableMenuItem(hMenu, IDM_PROFSTART, MF_GRAYED);
EnableMenuItem(hMenu, IDM_PROFSTOP, MF_ENABLED);
}
break;
case IDM_PROFSTOP:
if (iProfiler) {
ProfStop();
ProfFlush();
sprintf(ach, "\nProfiler stopped");
dbgOut;
EnableMenuItem(hMenu, IDM_PROFSTART, MF_ENABLED);
EnableMenuItem(hMenu, IDM_PROFSTOP, MF_GRAYED);
}
break;
#endif
default:
break;
}
}
int FAR PASCAL VolumeDlgProc(HWND hwnd, unsigned msg, UINT wParam, LONG lParam )
{
static HWND hwndScrollbar;
static int iScrollPos;
DWORD dwVolumeLevel;
DWORD dwNewVolumeLevel;
WORD wVolumeLeft;
WORD wVolumeRight;
WORD ret;
switch (msg) {
case WM_INITDIALOG:
/*
* What is the current volume setting ?
*/
(SetAux ? auxGetVolume : waveOutGetVolume)( 0, &dwVolumeLevel );
/*
* Take the average of the left and right volume settings
*/
wVolumeLeft = LOWORD( dwVolumeLevel );
wVolumeRight = HIWORD( dwVolumeLevel );
iScrollPos = ( wVolumeLeft + wVolumeRight ) >> 9;
/*
* Set the scroll bar and level indicator
*/
hwndScrollbar = GetDlgItem( hwnd, 105 ); /* 105 is the scroll bar */
SetScrollRange( hwndScrollbar, SB_CTL, 0, 255, FALSE );
SetScrollPos( hwndScrollbar, SB_CTL, iScrollPos, TRUE );
SetDlgItemInt( hwnd, 104, iScrollPos << 8, FALSE );
break;
case WM_HSCROLL:
switch ( LOWORD( wParam ) ) {
case SB_BOTTOM:
iScrollPos = 0;
break;
case SB_TOP:
iScrollPos = 255;
break;
case SB_LINEUP:
iScrollPos--;
break;
case SB_LINEDOWN:
iScrollPos++;
break;
case SB_PAGEDOWN:
iScrollPos += 16;
break;
case SB_PAGEUP:
iScrollPos -= 16;
break;
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
iScrollPos = HIWORD( wParam );
break;
}
/*
* Make sure that the new setting is within the correct volume
* range
*/
if ( iScrollPos > 255 ) {
iScrollPos = 255;
}
if ( iScrollPos < 0 ) {
iScrollPos = 0;
}
/*
* Update the scrollbar position and value indicator
*/
SetScrollPos( hwndScrollbar, SB_CTL, iScrollPos, TRUE );
SetDlgItemInt( hwnd, 104, iScrollPos << 8, FALSE );
/*
* Set the volume on the device and make sure that the
* volume has been set correctly.
*/
dwVolumeLevel = MAKELONG( iScrollPos << 8, iScrollPos << 8 );
if ( 0 != (ret =
(SetAux ? auxSetVolume : waveOutSetVolume)( 0, dwVolumeLevel ) ) ) {
sprintf( ach, "\n waveOutSetVolume %8X ret = %d ",
dwVolumeLevel, ret );
dbgOut;
}
else {
(SetAux ? auxGetVolume : waveOutGetVolume)( 0, &dwNewVolumeLevel );
if ( dwNewVolumeLevel != dwVolumeLevel) {
sprintf( ach, "\n New volume not set correctly" );
dbgOut;
}
}
break;
case WM_COMMAND:
DestroyWindow( hwnd );
hwndVolumeDlg = (HWND)NULL;
break;
default:
return FALSE;
break;
}
return TRUE;
}
Reference in a new issue Copy permalink