mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1743 lines
51 KiB
1743 lines
51 KiB
//--------------------------------------------------------------------------;
|
|
//
|
|
// File: volopt.cpp
|
|
//
|
|
// Copyright (c) 1998 Microsoft Corporation. All rights reserved
|
|
//
|
|
//--------------------------------------------------------------------------;
|
|
|
|
#include "precomp.h"
|
|
#include <regstr.h>
|
|
#include <mmsystem.h>
|
|
#include <mmddk.h>
|
|
#include "optres.h"
|
|
#include "cdopti.h"
|
|
#include "cdoptimp.h"
|
|
#include "helpids.h"
|
|
#include "winbase.h"
|
|
|
|
//////////////
|
|
// Help ID's
|
|
//////////////
|
|
|
|
#pragma data_seg(".text")
|
|
const static DWORD aVolOptsHelp[] =
|
|
{
|
|
IDC_VOL_MSG_TEXT, IDH_VOL_MSG,
|
|
IDC_VOL_CONFIG_GROUP, IDH_VOL_MSG,
|
|
IDC_DEFAULTMIXER, IDH_USEMIXERDEFAULTS,
|
|
IDC_SELECTPLAYER_TEXT, IDH_SELECTCDPLAYER,
|
|
IDC_CDDRIVE, IDH_SELECTCDPLAYER,
|
|
IDC_SELECTMIXER_TEXT, IDH_SELECTCDMIXER,
|
|
IDC_AUDIOMIXER, IDH_SELECTCDMIXER,
|
|
IDC_SELECTCONTROL_TEXT, IDH_SELECTCDCONTROL,
|
|
IDC_AUDIOCONTROL, IDH_SELECTCDCONTROL,
|
|
0, 0
|
|
};
|
|
#pragma data_seg()
|
|
|
|
////////////
|
|
// Types
|
|
////////////
|
|
|
|
typedef struct CDCTL // Used to write to reg (don't change)
|
|
{
|
|
DWORD dwVolID;
|
|
DWORD dwMuteID;
|
|
|
|
} CDCTL, *LPCDCTL;
|
|
|
|
|
|
|
|
////////////
|
|
// Globals
|
|
////////////
|
|
#define MYREGSTR_PATH_MEDIA TEXT("SYSTEM\\CurrentControlSet\\Control\\MediaResources")
|
|
const TCHAR gszRegstrCDAPath[] = MYREGSTR_PATH_MEDIA TEXT("\\mci\\cdaudio");
|
|
const TCHAR gszDefaultCDA[] = TEXT("Default Drive");
|
|
|
|
const TCHAR szRegstrCDROMPath[] = TEXT("System\\CurrentControlSet\\Services\\Class\\");
|
|
const TCHAR szPrefMixer[] = TEXT("Preferred Mixer");
|
|
const TCHAR szPrefControls[] = TEXT("Preferred Controls");
|
|
const TCHAR szSelected[] = TEXT("Selected");
|
|
|
|
const TCHAR szMapperPath[] = TEXT("Software\\Microsoft\\Multimedia\\Sound Mapper");
|
|
const TCHAR szPlayback[] = TEXT("Playback");
|
|
const TCHAR szPreferredOnly[] = TEXT("PreferredOnly");
|
|
|
|
const TCHAR szNTCDROMPath[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\DeluxeCD\\Settings\\");
|
|
|
|
|
|
|
|
////////////
|
|
// Functions
|
|
////////////
|
|
|
|
|
|
/////////////
|
|
// Uses new winmm feature to get the preferred wave ID, much cleaner.
|
|
//
|
|
STDMETHODIMP_(MMRESULT) CCDOpt::GetDefaultMixID(DWORD *pdwMixID)
|
|
{
|
|
MMRESULT mmr;
|
|
DWORD dwWaveID;
|
|
DWORD dwFlags = 0;
|
|
|
|
mmr = waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR) &dwWaveID, (DWORD_PTR) &dwFlags);
|
|
|
|
if (!mmr && pdwMixID)
|
|
{
|
|
*pdwMixID = dwWaveID;
|
|
}
|
|
|
|
return(mmr);
|
|
}
|
|
|
|
|
|
///////////
|
|
// A mixer line has been found with controls, this function is called to either 1) verify
|
|
// that passed in VolID and MuteID's can be found on this mixer line and are of the right
|
|
// control type. or 2) to find the Volume Slider and Mute ID controls that do exist on
|
|
// this mixer line.
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::SearchControls(int mxid, LPMIXERLINE pml, LPDWORD pdwVolID, LPDWORD pdwMuteID, TCHAR *szName, BOOL *pfFound, BOOL fVerify)
|
|
{
|
|
MIXERLINECONTROLS mlc;
|
|
DWORD dwControl;
|
|
|
|
memset(&mlc, 0, sizeof(mlc));
|
|
mlc.cbStruct = sizeof(mlc);
|
|
mlc.dwLineID = pml->dwLineID;
|
|
mlc.cControls = pml->cControls;
|
|
mlc.cbmxctrl = sizeof(MIXERCONTROL);
|
|
mlc.pamxctrl = (LPMIXERCONTROL) new(MIXERCONTROL[pml->cControls]);
|
|
|
|
if (mlc.pamxctrl)
|
|
{
|
|
if (mixerGetLineControls((HMIXEROBJ) mxid, &mlc, MIXER_GETLINECONTROLSF_ALL) == MMSYSERR_NOERROR)
|
|
{
|
|
for (dwControl = 0; dwControl < pml->cControls && !(*pfFound); dwControl++)
|
|
{
|
|
if (mlc.pamxctrl[dwControl].dwControlType == (DWORD)MIXERCONTROL_CONTROLTYPE_VOLUME)
|
|
{
|
|
DWORD dwIndex;
|
|
DWORD dwVolID = DWORD(-1);
|
|
DWORD dwMuteID = DWORD(-1);
|
|
|
|
dwVolID = mlc.pamxctrl[dwControl].dwControlID;
|
|
|
|
for (dwIndex = 0; dwIndex < pml->cControls; dwIndex++)
|
|
{
|
|
if (mlc.pamxctrl[dwIndex].dwControlType == (DWORD)MIXERCONTROL_CONTROLTYPE_MUTE)
|
|
{
|
|
dwMuteID = mlc.pamxctrl[dwIndex].dwControlID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fVerify)
|
|
{
|
|
if (*pdwVolID == dwVolID && *pdwMuteID == dwMuteID)
|
|
{
|
|
if (szName)
|
|
{
|
|
lstrcpy(szName, pml->szName); // mlc.pamxctrl[dwControl].szName);
|
|
}
|
|
|
|
*pfFound = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (szName)
|
|
{
|
|
lstrcpy(szName, pml->szName); // mlc.pamxctrl[dwControl].szName);
|
|
}
|
|
|
|
*pfFound = TRUE;
|
|
*pdwVolID = dwVolID;
|
|
*pdwMuteID = dwMuteID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete mlc.pamxctrl;
|
|
}
|
|
}
|
|
|
|
///////////////
|
|
// If a mixer line has connects, this function is called to enumerate all lines that have controls
|
|
// that meet our criteria and then seek out the controls on those connections using the above SearchControls
|
|
// function.
|
|
//
|
|
// NOTE: This function makes two scans over the connections, first looking for CompactDisc lines, and then
|
|
// if unsuccessful, it makes a second scan looking for other lines that might have a CD connected, like line-in
|
|
// and aux lines.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::SearchConnections(int mxid, DWORD dwDestination, DWORD dwConnections, LPDWORD pdwVolID, LPDWORD pdwMuteID, TCHAR *szName, BOOL *pfFound, BOOL fVerify)
|
|
{
|
|
MIXERLINE mlDst;
|
|
DWORD dwConnection;
|
|
DWORD dwScan;
|
|
|
|
for (dwScan = 0; dwScan < 2 && !(*pfFound); dwScan++) // On first scan look for CD, on second scan, look for anything else.
|
|
{
|
|
for (dwConnection = 0; dwConnection < dwConnections && !(*pfFound); dwConnection++)
|
|
{
|
|
mlDst.cbStruct = sizeof ( mlDst );
|
|
mlDst.dwDestination = dwDestination;
|
|
mlDst.dwSource = dwConnection;
|
|
|
|
if (mixerGetLineInfo((HMIXEROBJ) mxid, &mlDst, MIXER_GETLINEINFOF_SOURCE) == MMSYSERR_NOERROR)
|
|
{
|
|
if (mlDst.cControls) // Make sure this source has controls on it
|
|
{
|
|
if (((dwScan == 0) && (mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC)) ||
|
|
((dwScan == 1) && (mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_LINE ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_DIGITAL ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_ANALOG)))
|
|
{
|
|
SearchControls(mxid, &mlDst, pdwVolID, pdwMuteID, szName, pfFound, fVerify);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////
|
|
// Used in two modes, fVerify is TRUE, the VolID and MuteID are inputs and will return TRUE if valid
|
|
// if not in verification mode, this function is used to compute the default vol and mute ID's for this device.
|
|
// It scans all the destinations on the Mixer looking for output destinations (speakers, headphones, etc)
|
|
// Once it finds them, it then Searchs for controls on itself and/or any connections itself.
|
|
//
|
|
// NOTE: The current default behavior is to locate CD type connections, and then, if not finding any that
|
|
// work, to attempt to use the destination master volume. To reverse this, look for master volume first, and then
|
|
// look for CD lines if master can't be found, Switch the two intermost If conditions and calls so that
|
|
// SearchControls on the line happens before the connections are searched.
|
|
|
|
STDMETHODIMP_(BOOL) CCDOpt::SearchDevice(DWORD dwMixID, LPCDUNIT pCDUnit, LPDWORD pdwVolID, LPDWORD pdwMuteID, TCHAR *szName, BOOL fVerify)
|
|
{
|
|
MIXERCAPS mc;
|
|
MMRESULT mmr;
|
|
BOOL fFound = FALSE;
|
|
|
|
mmr = mixerGetDevCaps(dwMixID, &mc, sizeof(mc));
|
|
|
|
if (mmr == MMSYSERR_NOERROR)
|
|
{
|
|
MIXERLINE mlDst;
|
|
DWORD dwDestination;
|
|
|
|
if (pCDUnit)
|
|
{
|
|
lstrcpy(pCDUnit->szMixerName, mc.szPname);
|
|
}
|
|
|
|
for (dwDestination = 0; dwDestination < mc.cDestinations && !fFound; dwDestination++)
|
|
{
|
|
mlDst.cbStruct = sizeof ( mlDst );
|
|
mlDst.dwDestination = dwDestination;
|
|
|
|
if (mixerGetLineInfo((HMIXEROBJ) dwMixID, &mlDst, MIXER_GETLINEINFOF_DESTINATION ) == MMSYSERR_NOERROR)
|
|
{
|
|
if (mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_DST_SPEAKERS || // needs to be a likely output destination
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_DST_HEADPHONES ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT)
|
|
{
|
|
// Note: To default to Master Volume (instead of CD volume) just SearchControls first.
|
|
|
|
if (!fFound && mlDst.cConnections) // only look at connections if there is no master slider control.
|
|
{
|
|
SearchConnections(dwMixID, dwDestination, mlDst.cConnections, pdwVolID, pdwMuteID, szName, &fFound, fVerify);
|
|
}
|
|
|
|
if (!fFound && mlDst.cControls) // If there are controls, we'll take the master
|
|
{
|
|
SearchControls(dwMixID, &mlDst, pdwVolID, pdwMuteID, szName, &fFound, fVerify);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(fFound);
|
|
}
|
|
|
|
|
|
////////////////
|
|
// When a new CD is found, and there are no valid enteries in the registry for it, we compute
|
|
// defaults for that unit. This function uses the above function SearchDevice to do just that.
|
|
// First it finds the preferred MixerID and assumes this CD is connected to it, this it finds
|
|
// the default controls on that mixer and assignes them.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::GetUnitDefaults(LPCDUNIT pCDUnit)
|
|
{
|
|
if (pCDUnit)
|
|
{
|
|
pCDUnit->dwMixID = DWORD(-1);
|
|
pCDUnit->dwVolID = DWORD(-1);
|
|
pCDUnit->dwMuteID = DWORD(-1);
|
|
|
|
if (GetDefaultMixID(&pCDUnit->dwMixID) == MMSYSERR_NOERROR)
|
|
{
|
|
SearchDevice(pCDUnit->dwMixID, pCDUnit, &pCDUnit->dwVolID, &pCDUnit->dwMuteID, pCDUnit->szVolName, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//////////////
|
|
// This function enumerates installed disk devices that are of type CDROM and are installed
|
|
// It seeks out the one that matches the specified drive letter and collects information about it
|
|
// It returns the class driver path and the descriptive name of the drive.
|
|
//
|
|
// NOTE This function assumes both szDriver and szDevDesc are the dwSize bytes each.
|
|
//
|
|
STDMETHODIMP_(BOOL) CCDOpt::MapLetterToDevice(TCHAR DriveLetter, TCHAR *szDriver, TCHAR *szDevDesc, DWORD dwSize)
|
|
{
|
|
HKEY hkEnum;
|
|
BOOL fResult = FALSE;
|
|
|
|
if (!RegOpenKey(HKEY_DYN_DATA, REGSTR_PATH_DYNA_ENUM, &hkEnum))
|
|
{
|
|
HKEY hkDev;
|
|
DWORD dwEnumDevCnt;
|
|
TCHAR aszCMKey[MAX_PATH];
|
|
BOOLEAN found = FALSE;
|
|
|
|
for (dwEnumDevCnt = 0; !found && !RegEnumKey(hkEnum, dwEnumDevCnt, aszCMKey, sizeof(aszCMKey)/sizeof(TCHAR)); dwEnumDevCnt++)
|
|
{
|
|
if (!RegOpenKey(hkEnum, aszCMKey, &hkDev))
|
|
{
|
|
TCHAR aszDrvKey[MAX_PATH];
|
|
TCHAR tmp;
|
|
DWORD cb = sizeof(aszDrvKey);
|
|
|
|
RegQueryValueEx(hkDev, REGSTR_VAL_HARDWARE_KEY, NULL, NULL, (LPBYTE)&aszDrvKey, &cb);
|
|
|
|
tmp = aszDrvKey[5];
|
|
aszDrvKey[5] = TEXT('\0');
|
|
|
|
if ( !lstrcmpi( REGSTR_VAL_SCSI, aszDrvKey ) )
|
|
{
|
|
HKEY hkDrv;
|
|
TCHAR aszEnumKey[MAX_PATH];
|
|
aszDrvKey[5] = tmp;
|
|
|
|
wsprintf(aszEnumKey, TEXT("Enum\\%s"), aszDrvKey);
|
|
|
|
if (!RegOpenKey(HKEY_LOCAL_MACHINE, aszEnumKey, &hkDrv))
|
|
{
|
|
TCHAR DrvLet[3];
|
|
|
|
cb = sizeof( DrvLet );
|
|
|
|
RegQueryValueEx(hkDrv, REGSTR_VAL_CURDRVLET, NULL, NULL, (LPBYTE)&DrvLet, &cb);
|
|
|
|
if ( DrvLet[0] == DriveLetter )
|
|
{
|
|
DWORD cb2 = dwSize;
|
|
cb = dwSize;
|
|
|
|
if ((RegQueryValueEx(hkDrv, REGSTR_VAL_DEVDESC, NULL, NULL, (LPBYTE)szDevDesc, &cb) == NO_ERROR) &&
|
|
(RegQueryValueEx(hkDrv, REGSTR_VAL_DRIVER, NULL, NULL, (LPBYTE)szDriver, &cb2) == NO_ERROR))
|
|
{
|
|
fResult = TRUE;
|
|
}
|
|
|
|
found = TRUE;
|
|
}
|
|
|
|
RegCloseKey(hkDrv);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkDev);
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hkEnum);
|
|
}
|
|
|
|
if (!fResult)
|
|
{
|
|
//check to see if we're on NT
|
|
OSVERSIONINFO os;
|
|
os.dwOSVersionInfoSize = sizeof(os);
|
|
GetVersionEx(&os);
|
|
if (os.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
TCHAR szDrive[MAX_PATH];
|
|
TCHAR szDriverTemp[MAX_PATH*2];
|
|
TCHAR* szGUID = NULL;
|
|
ZeroMemory(szDriverTemp,sizeof(szDriverTemp));
|
|
ZeroMemory(szDriver,dwSize);
|
|
|
|
wsprintf(szDrive,TEXT("%c:\\"),DriveLetter);
|
|
if (GetVolumeNameForVolumeMountPoint(szDrive,szDriverTemp,dwSize/sizeof(TCHAR)))
|
|
{
|
|
//szDriverTemp now has a string like \\?\Volume{GUID}\ ... we just want
|
|
//the {GUID} part, as that is the drive's unique ID.
|
|
szGUID = _tcschr(szDriverTemp,TEXT('{'));
|
|
if (szGUID!=NULL)
|
|
{
|
|
fResult = TRUE;
|
|
_tcscpy(szDriver,szGUID);
|
|
if (szDriver[_tcslen(szDriver)-1] != TEXT('}'))
|
|
{
|
|
szDriver[_tcslen(szDriver)-1] = TEXT('\0');
|
|
}
|
|
}
|
|
}
|
|
} //end if NT
|
|
}
|
|
|
|
return(fResult);
|
|
}
|
|
|
|
|
|
///////////////
|
|
// Since audio devices can come and go, the names of the devices can change since there is
|
|
// number appended by the system inclosed in brackets at the end of the string.
|
|
// This function attempts to truncate this appended number after copying the original into
|
|
// the destination buffer.
|
|
//
|
|
STDMETHODIMP_(BOOL) CCDOpt::TruncName(TCHAR *pDest, TCHAR *pSrc)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
TCHAR *pTrunc;
|
|
|
|
lstrcpy(pDest, pSrc);
|
|
|
|
pTrunc = pDest;
|
|
while (*pTrunc++);
|
|
|
|
while (pTrunc-- > pDest)
|
|
{
|
|
if (*pTrunc == TEXT('['))
|
|
{
|
|
*pTrunc = TEXT('\0');
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pTrunc == pDest)
|
|
{
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
return(fSuccess);
|
|
}
|
|
|
|
|
|
/////////////////
|
|
// After reading the preferred mixer device name from the registry, we have to locate that
|
|
// device in the system by mixer ID. To do this, we scan thru all available mixers looking
|
|
// for an exact match of the name. If an exact match can not be found, we then scan again
|
|
// looking for a match using truncated strings where the system appended instance number is
|
|
// removed. If we can't find it at that point, we are in trouble and have to give up.
|
|
//
|
|
STDMETHODIMP CCDOpt::ComputeMixID(LPDWORD pdwMixID, TCHAR *szMixerName)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DWORD dwNumMixers;
|
|
DWORD dwID;
|
|
MMRESULT mmr;
|
|
BOOL fFound = FALSE;
|
|
TCHAR szTruncName[MAXPNAMELEN];
|
|
TCHAR szTruncSeek[MAXPNAMELEN];
|
|
MIXERCAPS mc;
|
|
|
|
dwNumMixers = mixerGetNumDevs();
|
|
|
|
for (dwID = 0; dwID < dwNumMixers && !fFound; dwID++) // First look for EXACT match.
|
|
{
|
|
mmr = mixerGetDevCaps(dwID, &mc, sizeof(mc));
|
|
|
|
if (mmr == MMSYSERR_NOERROR)
|
|
{
|
|
if (!lstrcmp(mc.szPname, szMixerName))
|
|
{
|
|
hr = S_OK;
|
|
fFound = TRUE;
|
|
*pdwMixID = dwID;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!fFound) // Exact match isn't found, strip off (#) and look again
|
|
{
|
|
if (TruncName(szTruncName, szMixerName))
|
|
{
|
|
for (dwID = 0; dwID < dwNumMixers && !fFound; dwID++)
|
|
{
|
|
mmr = mixerGetDevCaps(dwID, &mc, sizeof(mc));
|
|
|
|
if (mmr == MMSYSERR_NOERROR)
|
|
{
|
|
TruncName(szTruncSeek, mc.szPname);
|
|
|
|
if (!lstrcmp(szTruncSeek, szTruncName))
|
|
{
|
|
lstrcpy(szMixerName, mc.szPname); // repair the name we matched
|
|
hr = S_OK;
|
|
fFound = TRUE;
|
|
*pdwMixID = dwID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
///////////////
|
|
// This function looks up this devices registry information using the driver information that
|
|
// was mapped from the drive letter. It attempts to read in the preferred mixer ID and then
|
|
// calculate the mixerID from it, if that fails, the function fails and the unit will use default
|
|
// information calcuated by this program. If it succeeds, it then reads in the control ID's for
|
|
// the volume and mute controls for this mixer. If it can't find them or the ones it does find
|
|
// can not be located on the specified device, then we compute defaults. If we can't compute defaults
|
|
// the entire function fails and the entire drive is re-computed.
|
|
//
|
|
STDMETHODIMP CCDOpt::GetUnitRegData(LPCDUNIT pCDUnit)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
TCHAR szRegDriverStr[MAX_PATH];
|
|
HKEY hKey;
|
|
DWORD dwMixID;
|
|
CDCTL cdCtl;
|
|
HKEY hKeyRoot = HKEY_LOCAL_MACHINE;
|
|
|
|
if (pCDUnit)
|
|
{
|
|
OSVERSIONINFO os;
|
|
os.dwOSVersionInfoSize = sizeof(os);
|
|
GetVersionEx(&os);
|
|
if (os.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
hKeyRoot = HKEY_CURRENT_USER;
|
|
wsprintf(szRegDriverStr,TEXT("%s%s"),szNTCDROMPath, pCDUnit->szDriver);
|
|
}
|
|
else
|
|
{
|
|
wsprintf(szRegDriverStr,TEXT("%s%s"),szRegstrCDROMPath, pCDUnit->szDriver);
|
|
}
|
|
|
|
if (RegOpenKeyEx(hKeyRoot , szRegDriverStr , 0 , KEY_READ , &hKey) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwSize = sizeof(BOOL);
|
|
|
|
RegQueryValueEx(hKey, szSelected, NULL, NULL, (LPBYTE) &(pCDUnit->fSelected), &dwSize);
|
|
|
|
dwSize = MAXPNAMELEN*sizeof(TCHAR);
|
|
|
|
if (RegQueryValueEx(hKey, szPrefMixer, NULL, NULL, (LPBYTE) pCDUnit->szMixerName, &dwSize) == NO_ERROR)
|
|
{
|
|
hr = ComputeMixID(&dwMixID, pCDUnit->szMixerName);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL fGotControls = FALSE;
|
|
TCHAR szVolName[MIXER_LONG_NAME_CHARS] = TEXT("\0");
|
|
|
|
dwSize = sizeof(cdCtl);
|
|
|
|
if (RegQueryValueEx(hKey, szPrefControls, NULL, NULL, (LPBYTE) &cdCtl, &dwSize) == NO_ERROR)
|
|
{
|
|
fGotControls = SearchDevice(dwMixID, NULL, &cdCtl.dwVolID, &cdCtl.dwMuteID, szVolName, TRUE); // Verify Controls
|
|
}
|
|
|
|
if (!fGotControls) // Either were not in reg or fail verification, compute defaults for this device
|
|
{
|
|
fGotControls = SearchDevice(dwMixID, NULL, &cdCtl.dwVolID, &cdCtl.dwMuteID, szVolName, FALSE);
|
|
}
|
|
|
|
if (!fGotControls) // If we don't have them by now, we are in trouble.
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
pCDUnit->dwMixID = dwMixID;
|
|
pCDUnit->dwVolID = cdCtl.dwVolID;
|
|
pCDUnit->dwMuteID = cdCtl.dwMuteID;
|
|
lstrcpy(pCDUnit->szVolName, szVolName);
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
////////////////
|
|
// This function writes out the preferred mixer device name and the preferred control ID's into the
|
|
// cdrom driver registry for safe keeping.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::SetUnitRegData(LPCDUNIT pCDUnit)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
TCHAR szRegDriverStr[MAX_PATH];
|
|
HKEY hKey;
|
|
CDCTL cdCtl;
|
|
|
|
//this function is very different on NT
|
|
OSVERSIONINFO os;
|
|
os.dwOSVersionInfoSize = sizeof(os);
|
|
GetVersionEx(&os);
|
|
if (os.dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
if (pCDUnit)
|
|
{
|
|
wsprintf(szRegDriverStr,TEXT("%s%s"),szNTCDROMPath, pCDUnit->szDriver);
|
|
|
|
if (RegCreateKeyEx(HKEY_CURRENT_USER , szRegDriverStr , 0 , NULL, 0, KEY_WRITE , NULL, &hKey, NULL) == ERROR_SUCCESS)
|
|
{
|
|
cdCtl.dwVolID = pCDUnit->dwVolID;
|
|
cdCtl.dwMuteID = pCDUnit->dwMuteID;
|
|
|
|
RegSetValueEx(hKey, szPrefMixer, NULL, REG_SZ, (LPBYTE) pCDUnit->szMixerName, (sizeof(TCHAR) * lstrlen(pCDUnit->szMixerName))+sizeof(TCHAR));
|
|
RegSetValueEx(hKey, szPrefControls, NULL, REG_BINARY, (LPBYTE) &cdCtl, sizeof(cdCtl));
|
|
RegSetValueEx(hKey, szSelected, NULL, REG_BINARY, (LPBYTE) &(pCDUnit->fSelected), sizeof(BOOL));
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
} //end if NT
|
|
else
|
|
{
|
|
if (pCDUnit)
|
|
{
|
|
wsprintf(szRegDriverStr,TEXT("%s%s"),szRegstrCDROMPath, pCDUnit->szDriver);
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE , szRegDriverStr , 0 , KEY_WRITE , &hKey) == ERROR_SUCCESS)
|
|
{
|
|
cdCtl.dwVolID = pCDUnit->dwVolID;
|
|
cdCtl.dwMuteID = pCDUnit->dwMuteID;
|
|
|
|
RegSetValueEx(hKey, szPrefMixer, NULL, REG_SZ, (LPBYTE) pCDUnit->szMixerName, (sizeof(TCHAR) * lstrlen(pCDUnit->szMixerName))+sizeof(TCHAR));
|
|
RegSetValueEx(hKey, szPrefControls, NULL, REG_BINARY, (LPBYTE) &cdCtl, sizeof(cdCtl));
|
|
RegSetValueEx(hKey, szSelected, NULL, REG_BINARY, (LPBYTE) &(pCDUnit->fSelected), sizeof(BOOL));
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
} //end else Win9x
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// Given just the drive letter of a CDROM, this function will obtain all information needed by the
|
|
// program on this drive. Some is calcuated via the PnP registry for this drive's driver, other information
|
|
// is obtained from the registry or defaults are computed based on the installed audio components
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::GetUnitValues(LPCDUNIT pCDUnit)
|
|
{
|
|
if (pCDUnit)
|
|
{
|
|
TCHAR cDriveLetter = pCDUnit->szDriveName[0];
|
|
|
|
if (MapLetterToDevice(cDriveLetter, pCDUnit->szDriver, pCDUnit->szDeviceDesc, sizeof(pCDUnit->szDriver)))
|
|
{
|
|
if (FAILED(GetUnitRegData(pCDUnit))) // Can fail if reg is empty or mixer ID can't be computed
|
|
{
|
|
GetUnitDefaults(pCDUnit);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetUnitDefaults(pCDUnit);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////
|
|
// This method is called in response to a PnP notify or a WinMM Device Change message. It will verify
|
|
// the existance of all assigned MixerID's and the corresponding Volume and Mute ID on that device.
|
|
// In the event the device no-longer exists a default will be computed.
|
|
//
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::MMDeviceChanged(void)
|
|
{
|
|
LPCDUNIT pCDUnit = m_pCDOpts->pCDUnitList;
|
|
|
|
while (pCDUnit)
|
|
{
|
|
GetUnitValues(pCDUnit);
|
|
pCDUnit = pCDUnit->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// This function will save all the information for all the CD drives in the system out to the registry
|
|
// it does not modify or delete any of this information.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::WriteCDList(LPCDUNIT pCDList)
|
|
{
|
|
if (pCDList)
|
|
{
|
|
LPCDUNIT pUnit = pCDList;
|
|
|
|
while (pUnit)
|
|
{
|
|
SetUnitRegData(pUnit);
|
|
|
|
pUnit = pUnit->pNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////
|
|
// This function will destory the list containing all the drive information in the system
|
|
// freeing up all memory, this function does not save any information.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::DestroyCDList(LPCDUNIT *ppCDList)
|
|
{
|
|
|
|
if (ppCDList && *ppCDList)
|
|
{
|
|
while(*ppCDList)
|
|
{
|
|
LPCDUNIT pTemp = *ppCDList;
|
|
*ppCDList = (*ppCDList)->pNext;
|
|
delete pTemp;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(UINT) CCDOpt::GetDefDrive(void)
|
|
{
|
|
HKEY hkTmp;
|
|
UINT uDrive = 0;
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, gszRegstrCDAPath, 0, KEY_READ, &hkTmp ) == ERROR_SUCCESS)
|
|
{
|
|
DWORD cb = sizeof(UINT);
|
|
RegQueryValueEx(hkTmp, gszDefaultCDA, NULL, NULL, (LPBYTE)&uDrive, &cb);
|
|
RegCloseKey(hkTmp);
|
|
}
|
|
|
|
return uDrive;
|
|
}
|
|
|
|
/////////////
|
|
// This function builds a list of all the CD drives in the system, the list
|
|
// is a linked list with each node containing information that is specific
|
|
// to that CD player as well as the user options for each player.
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::CreateCDList(LPCDUNIT *ppCDList)
|
|
{
|
|
DWORD dwBytes = 0;
|
|
TCHAR *szDriveNames = NULL;
|
|
HRESULT hr = S_OK;
|
|
UINT uDefDrive = GetDefDrive();
|
|
|
|
if (ppCDList == NULL)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
LPCDUNIT *ppUnit = NULL;
|
|
|
|
*ppCDList = NULL;
|
|
ppUnit = ppCDList;
|
|
|
|
dwBytes = GetLogicalDriveStrings(0, NULL);
|
|
|
|
if (dwBytes)
|
|
{
|
|
szDriveNames = new(TCHAR[dwBytes]);
|
|
|
|
if (szDriveNames == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
dwBytes = GetLogicalDriveStrings(dwBytes, szDriveNames);
|
|
|
|
if (dwBytes)
|
|
{
|
|
UINT uDrive = 0;
|
|
|
|
while (*szDriveNames)
|
|
{
|
|
if (GetDriveType(szDriveNames) == DRIVE_CDROM)
|
|
{
|
|
*ppUnit = new(CDUNIT);
|
|
|
|
if (*ppUnit == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
memset(*ppUnit,0,sizeof(CDUNIT));
|
|
_tcsncpy((*ppUnit)->szDriveName,szDriveNames,min(sizeof((*ppUnit)->szDriveName)/sizeof(TCHAR),(UINT)lstrlen(szDriveNames)));
|
|
|
|
(*ppUnit)->dwTitleID = (DWORD)CDTITLE_NODISC;
|
|
|
|
CharUpper((*ppUnit)->szDriveName);
|
|
|
|
GetUnitValues(*ppUnit);
|
|
|
|
if (uDrive == uDefDrive)
|
|
{
|
|
(*ppUnit)->fDefaultDrive = TRUE;
|
|
}
|
|
|
|
ppUnit = &((*ppUnit)->pNext);
|
|
uDrive++;
|
|
}
|
|
}
|
|
|
|
while(*szDriveNames++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
DestroyCDList(ppCDList);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////
|
|
// Traverse the UI Tree, destroying it as it goes.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::DestroyUITree(LPCDDRIVE *ppCDRoot)
|
|
{
|
|
if (ppCDRoot)
|
|
{
|
|
LPCDDRIVE pDriveList;
|
|
|
|
pDriveList = *ppCDRoot;
|
|
*ppCDRoot = NULL;
|
|
|
|
while (pDriveList)
|
|
{
|
|
LPCDDRIVE pNextDrive = pDriveList->pNext;
|
|
|
|
while (pDriveList->pMixerList)
|
|
{
|
|
LPCDMIXER pNextMixer = pDriveList->pMixerList->pNext;
|
|
|
|
while(pDriveList->pMixerList->pControlList)
|
|
{
|
|
LPCDCONTROL pNextControl = pDriveList->pMixerList->pControlList->pNext;
|
|
delete pDriveList->pMixerList->pControlList;
|
|
pDriveList->pMixerList->pControlList = pNextControl;
|
|
}
|
|
|
|
delete pDriveList->pMixerList;
|
|
pDriveList->pMixerList = pNextMixer;
|
|
}
|
|
|
|
delete pDriveList;
|
|
pDriveList = pNextDrive;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////
|
|
// Add line controls to internal tree data structure for UI
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::AddLineControls(LPCDMIXER pMixer, LPCDCONTROL *ppLastControl, int mxid, LPMIXERLINE pml)
|
|
{
|
|
MIXERLINECONTROLS mlc;
|
|
DWORD dwControl;
|
|
HRESULT hr = S_OK;
|
|
|
|
memset(&mlc, 0, sizeof(mlc));
|
|
mlc.cbStruct = sizeof(mlc);
|
|
mlc.dwLineID = pml->dwLineID;
|
|
mlc.cControls = pml->cControls;
|
|
mlc.cbmxctrl = sizeof(MIXERCONTROL);
|
|
mlc.pamxctrl = (LPMIXERCONTROL) new(MIXERCONTROL[pml->cControls]);
|
|
|
|
if (mlc.pamxctrl)
|
|
{
|
|
if (mixerGetLineControls((HMIXEROBJ) mxid, &mlc, MIXER_GETLINECONTROLSF_ALL) == MMSYSERR_NOERROR)
|
|
{
|
|
for (dwControl = 0; dwControl < pml->cControls; dwControl++)
|
|
{
|
|
if (mlc.pamxctrl[dwControl].dwControlType == (DWORD)MIXERCONTROL_CONTROLTYPE_VOLUME)
|
|
{
|
|
DWORD dwIndex;
|
|
DWORD dwVolID = mlc.pamxctrl[dwControl].dwControlID;
|
|
DWORD dwMuteID = DWORD(-1);
|
|
LPCDCONTROL pControl;
|
|
|
|
for (dwIndex = 0; dwIndex < pml->cControls; dwIndex++)
|
|
{
|
|
if (mlc.pamxctrl[dwIndex].dwControlType == (DWORD)MIXERCONTROL_CONTROLTYPE_MUTE)
|
|
{
|
|
dwMuteID = mlc.pamxctrl[dwIndex].dwControlID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pControl = new (CDCONTROL);
|
|
|
|
if (pControl == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
memset(pControl, 0, sizeof(CDCONTROL));
|
|
|
|
if (pMixer->pControlList == NULL)
|
|
{
|
|
pMixer->pControlList = pControl;
|
|
}
|
|
|
|
if (*ppLastControl)
|
|
{
|
|
(*ppLastControl)->pNext = pControl;
|
|
}
|
|
|
|
lstrcpy(pControl->szName, pml->szName); // mlc.pamxctrl[dwControl].szName);
|
|
pControl->dwVolID = dwVolID;
|
|
pControl->dwMuteID = dwMuteID;
|
|
|
|
*ppLastControl = pControl;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete mlc.pamxctrl;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
/////////////////
|
|
// Searchs connections for controls to add to UI tree
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::AddConnections(LPCDMIXER pMixer, LPCDCONTROL *ppLastControl, int mxid, DWORD dwDestination, DWORD dwConnections)
|
|
{
|
|
MIXERLINE mlDst;
|
|
DWORD dwConnection;
|
|
HRESULT hr = S_OK;
|
|
|
|
for (dwConnection = 0; dwConnection < dwConnections; dwConnection++)
|
|
{
|
|
mlDst.cbStruct = sizeof ( mlDst );
|
|
mlDst.dwDestination = dwDestination;
|
|
mlDst.dwSource = dwConnection;
|
|
|
|
if (mixerGetLineInfo((HMIXEROBJ) mxid, &mlDst, MIXER_GETLINEINFOF_SOURCE) == MMSYSERR_NOERROR)
|
|
{
|
|
if (mlDst.cControls) // Make sure this source has controls on it
|
|
{
|
|
if (mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_LINE ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_DIGITAL ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_ANALOG)
|
|
{
|
|
hr = AddLineControls(pMixer, ppLastControl, mxid, &mlDst);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
//////////////
|
|
// Adds control nodes to the UI tree for the specified device
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::AddControls(LPCDMIXER pMixer)
|
|
{
|
|
MIXERLINE mlDst;
|
|
DWORD dwDestination;
|
|
MIXERCAPS mc;
|
|
LPCDCONTROL pLastControl = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
if (mixerGetDevCaps(pMixer->dwMixID, &mc, sizeof(mc)) == MMSYSERR_NOERROR)
|
|
{
|
|
for (dwDestination = 0; dwDestination < mc.cDestinations; dwDestination++)
|
|
{
|
|
mlDst.cbStruct = sizeof ( mlDst );
|
|
mlDst.dwDestination = dwDestination;
|
|
|
|
if (mixerGetLineInfo((HMIXEROBJ) pMixer->dwMixID, &mlDst, MIXER_GETLINEINFOF_DESTINATION ) == MMSYSERR_NOERROR)
|
|
{
|
|
if (mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_DST_SPEAKERS || // needs to be a likely output destination
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_DST_HEADPHONES ||
|
|
mlDst.dwComponentType == (DWORD)MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT)
|
|
{
|
|
if (mlDst.cControls) // If there are no controls, we won't present it to the user as an option
|
|
{
|
|
hr = AddLineControls(pMixer, &pLastControl, pMixer->dwMixID, &mlDst);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mlDst.cConnections) // If there are connections to this line, lets add thier controls
|
|
{
|
|
AddConnections(pMixer, &pLastControl, pMixer->dwMixID, dwDestination, mlDst.cConnections);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
///////////////////
|
|
// Adds audio mixers to UI tree for the cd player unit specified
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::AddMixers(LPCDDRIVE pDevice)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwNumMixers;
|
|
DWORD dwID;
|
|
MMRESULT mmr;
|
|
MIXERCAPS mc;
|
|
LPCDMIXER pMixer;
|
|
LPCDMIXER pLastMixer = NULL;
|
|
|
|
if (pDevice)
|
|
{
|
|
dwNumMixers = mixerGetNumDevs();
|
|
|
|
for (dwID = 0; dwID < dwNumMixers; dwID++)
|
|
{
|
|
mmr = mixerGetDevCaps(dwID, &mc, sizeof(mc));
|
|
|
|
if (mmr == MMSYSERR_NOERROR && mc.cDestinations)
|
|
{
|
|
pMixer = new (CDMIXER);
|
|
|
|
if (pMixer == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
memset(pMixer, 0, sizeof(CDMIXER));
|
|
|
|
if (pDevice->pMixerList == NULL)
|
|
{
|
|
pDevice->pMixerList = pMixer;
|
|
}
|
|
|
|
if (pLastMixer)
|
|
{
|
|
pLastMixer->pNext = pMixer;
|
|
}
|
|
|
|
lstrcpy(pMixer->szPname, mc.szPname);
|
|
pMixer->dwMixID = dwID;
|
|
|
|
hr = AddControls(pMixer);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pLastMixer = pMixer;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//////////////
|
|
// Takes the UI tree and updates it's current and default setting links based on data
|
|
// from the CDINFO tree which was created from the registry
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::SetUIDefaults(LPCDDRIVE pCDTree, LPCDUNIT pCDList)
|
|
{
|
|
LPCDDRIVE pDriveList;
|
|
LPCDUNIT pCDUnit = pCDList;
|
|
|
|
pDriveList = pCDTree;
|
|
|
|
while(pDriveList && pCDUnit)
|
|
{
|
|
LPCDMIXER pMixer;
|
|
|
|
pMixer = pDriveList->pMixerList;
|
|
|
|
while (pMixer)
|
|
{
|
|
LPCDCONTROL pControl;
|
|
DWORD dwVolID = DWORD(-1);
|
|
DWORD dwMuteID = DWORD(-1);
|
|
|
|
if (pMixer->dwMixID == pCDUnit->dwMixID)
|
|
{
|
|
pDriveList->pCurrentMixer = pMixer;
|
|
pDriveList->pOriginalMixer = pMixer;
|
|
}
|
|
|
|
pControl = pMixer->pControlList;
|
|
|
|
SearchDevice(pMixer->dwMixID, NULL, &dwVolID, &dwMuteID, NULL, FALSE);
|
|
|
|
while (pControl)
|
|
{
|
|
if (pControl->dwVolID == dwVolID && pControl->dwMuteID == dwMuteID)
|
|
{
|
|
pMixer->pDefaultControl = pControl;
|
|
}
|
|
|
|
if (pMixer->dwMixID == pCDUnit->dwMixID && pControl->dwVolID == pCDUnit->dwVolID)
|
|
{
|
|
pMixer->pCurrentControl = pControl;
|
|
pMixer->pOriginalControl = pControl;
|
|
}
|
|
|
|
pControl = pControl->pNext;
|
|
}
|
|
|
|
pMixer = pMixer->pNext;
|
|
}
|
|
|
|
pDriveList = pDriveList->pNext;
|
|
pCDUnit = pCDUnit->pNext;
|
|
}
|
|
|
|
}
|
|
|
|
//////////////
|
|
// Takes the UI tree and updates it's current and default setting links based on data
|
|
// from the CDINFO tree which was created from the registry
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::RestoreOriginals(void)
|
|
{
|
|
LPCDDRIVE pDriveList;
|
|
|
|
pDriveList = m_pCDTree;
|
|
|
|
while(pDriveList)
|
|
{
|
|
LPCDMIXER pMixer;
|
|
|
|
pMixer = pDriveList->pMixerList;
|
|
|
|
while (pMixer)
|
|
{
|
|
LPCDCONTROL pControl;
|
|
|
|
pDriveList->pCurrentMixer = pDriveList->pOriginalMixer;
|
|
|
|
pControl = pMixer->pControlList;
|
|
|
|
while (pControl)
|
|
{
|
|
pMixer->pCurrentControl = pMixer->pOriginalControl;
|
|
pControl = pControl->pNext;
|
|
}
|
|
|
|
pMixer = pMixer->pNext;
|
|
}
|
|
|
|
pDriveList = pDriveList->pNext;
|
|
}
|
|
}
|
|
|
|
//////////////
|
|
// Updates the CD Tree from the UI Tree after the dialog closes (on OK), if there
|
|
// are any changes it returns true. The caller is expected to write these changes out to reg
|
|
//
|
|
|
|
STDMETHODIMP_(BOOL) CCDOpt::UpdateCDList(LPCDDRIVE pCDTree, LPCDUNIT pCDList)
|
|
{
|
|
BOOL fChanged = FALSE;
|
|
LPCDDRIVE pDriveList;
|
|
LPCDUNIT pCDUnit = pCDList;
|
|
|
|
pDriveList = pCDTree;
|
|
|
|
while(pDriveList && pCDUnit)
|
|
{
|
|
if (pCDUnit->fSelected != pDriveList->fSelected) // Selected drive has changed
|
|
{
|
|
pCDUnit->fSelected = pDriveList->fSelected;
|
|
fChanged = TRUE;
|
|
}
|
|
|
|
if (pDriveList->pCurrentMixer && pDriveList->pCurrentMixer->pCurrentControl)
|
|
{
|
|
LPCDMIXER pMixer = pDriveList->pCurrentMixer;
|
|
|
|
if (pMixer->dwMixID != pCDUnit->dwMixID) // Mixer has changed
|
|
{
|
|
pCDUnit->dwMixID = pMixer->dwMixID;
|
|
lstrcpy(pCDUnit->szMixerName, pMixer->szPname);
|
|
|
|
fChanged = TRUE;
|
|
}
|
|
|
|
LPCDCONTROL pControl = pDriveList->pCurrentMixer->pCurrentControl;
|
|
|
|
if (pControl->dwVolID != pCDUnit->dwVolID) // Control has changed
|
|
{
|
|
pCDUnit->dwVolID = pControl->dwVolID;
|
|
pCDUnit->dwMuteID = pControl->dwMuteID;
|
|
lstrcpy(pCDUnit->szVolName, pControl->szName);
|
|
|
|
fChanged = TRUE;
|
|
}
|
|
}
|
|
|
|
pDriveList = pDriveList->pNext;
|
|
pCDUnit = pCDUnit->pNext;
|
|
}
|
|
|
|
return(fChanged);
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
// Contructs UI tree for all devices/mixers/controls
|
|
//
|
|
|
|
STDMETHODIMP CCDOpt::BuildUITree(LPCDDRIVE *ppCDRoot, LPCDUNIT pCDList)
|
|
{
|
|
LPCDUNIT pCDUnit = pCDList;
|
|
LPCDDRIVE pDevice;
|
|
LPCDDRIVE pLastDevice;
|
|
HRESULT hr = S_OK;
|
|
|
|
m_pCDSelected = NULL;
|
|
|
|
if (ppCDRoot)
|
|
{
|
|
*ppCDRoot = NULL;
|
|
pLastDevice = NULL;
|
|
|
|
while (pCDUnit)
|
|
{
|
|
pDevice = new (CDDRIVE);
|
|
|
|
if (pDevice == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
memset(pDevice, 0, sizeof(CDDRIVE));
|
|
|
|
if (*ppCDRoot == NULL)
|
|
{
|
|
*ppCDRoot = pDevice;
|
|
}
|
|
|
|
if (pLastDevice)
|
|
{
|
|
pLastDevice->pNext = pDevice;
|
|
}
|
|
|
|
lstrcpy(pDevice->szDriveName, pCDUnit->szDriveName);
|
|
lstrcpy(pDevice->szDeviceDesc, pCDUnit->szDeviceDesc);
|
|
pDevice->fSelected = pCDUnit->fSelected;
|
|
|
|
hr = AddMixers(pDevice);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pCDUnit = pCDUnit->pNext;
|
|
pLastDevice = pDevice;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (*ppCDRoot)
|
|
{
|
|
DestroyUITree(ppCDRoot);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetUIDefaults(*ppCDRoot, pCDList);
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
/////////////////
|
|
// Updates the control combo box using the mixer node of the UI tree
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::InitControlUI(HWND hDlg, LPCDMIXER pMixer)
|
|
{
|
|
LPCDCONTROL pControl;
|
|
LRESULT dwIndex;
|
|
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_RESETCONTENT,0,0);
|
|
|
|
pControl = pMixer->pControlList;
|
|
|
|
if (pMixer->pCurrentControl == NULL)
|
|
{
|
|
pMixer->pCurrentControl = pMixer->pDefaultControl;
|
|
}
|
|
|
|
while(pControl)
|
|
{
|
|
dwIndex = SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_INSERTSTRING, (WPARAM) -1, (LPARAM) pControl->szName);
|
|
|
|
if (dwIndex != CB_ERR && dwIndex != CB_ERRSPACE)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_SETITEMDATA, (WPARAM) dwIndex, (LPARAM) pControl);
|
|
|
|
if (pMixer->pCurrentControl == pControl)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_SETCURSEL, (WPARAM) dwIndex, 0);
|
|
}
|
|
}
|
|
|
|
pControl = pControl->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
////////////////
|
|
// Sets up the mixer combobox using the specified device
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::InitMixerUI(HWND hDlg, LPCDDRIVE pDevice)
|
|
{
|
|
LPCDMIXER pMixer;
|
|
LRESULT dwIndex;
|
|
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_RESETCONTENT,0,0);
|
|
|
|
pMixer = pDevice->pMixerList;
|
|
|
|
while (pMixer)
|
|
{
|
|
dwIndex = SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_INSERTSTRING, (WPARAM) -1, (LPARAM) pMixer->szPname);
|
|
|
|
if (dwIndex != CB_ERR && dwIndex != CB_ERRSPACE)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_SETITEMDATA, (WPARAM) dwIndex, (LPARAM) pMixer);
|
|
|
|
if (pDevice->pCurrentMixer == pMixer)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_SETCURSEL, (WPARAM) dwIndex, 0);
|
|
|
|
InitControlUI(hDlg, pMixer);
|
|
}
|
|
}
|
|
|
|
pMixer = pMixer->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
////////////////
|
|
// Sets up the cd device combo box
|
|
//
|
|
|
|
STDMETHODIMP_(void) CCDOpt::InitDeviceUI(HWND hDlg, LPCDDRIVE pCDTree, LPCDDRIVE pCurrentDevice)
|
|
{
|
|
LPCDDRIVE pDevice;
|
|
LRESULT dwIndex;
|
|
|
|
SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_RESETCONTENT,0,0);
|
|
|
|
pDevice = pCDTree;
|
|
|
|
while (pDevice)
|
|
{
|
|
TCHAR str[MAX_PATH];
|
|
|
|
wsprintf(str, TEXT("( %s ) %s"), pDevice->szDriveName, pDevice->szDeviceDesc);
|
|
|
|
dwIndex = SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_INSERTSTRING, (WPARAM) -1, (LPARAM) str);
|
|
|
|
if (dwIndex != CB_ERR && dwIndex != CB_ERRSPACE)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_SETITEMDATA, (WPARAM) dwIndex, (LPARAM) pDevice);
|
|
|
|
if (pDevice == pCurrentDevice)
|
|
{
|
|
SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_SETCURSEL, (WPARAM) dwIndex, 0);
|
|
|
|
InitMixerUI(hDlg, pDevice);
|
|
}
|
|
}
|
|
|
|
pDevice = pDevice->pNext;
|
|
}
|
|
}
|
|
|
|
///////////////////
|
|
// Called to init the dialog when it first appears. Given a list of CD devices, this
|
|
// function fills out the dialog using the first device in the list.
|
|
//
|
|
STDMETHODIMP_(BOOL) CCDOpt::InitMixerConfig(HWND hDlg)
|
|
{
|
|
LPCDDRIVE pDevice = m_pCDTree;
|
|
|
|
while (pDevice)
|
|
{
|
|
if (pDevice->fSelected)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pDevice = pDevice->pNext;
|
|
}
|
|
|
|
if (pDevice == NULL)
|
|
{
|
|
pDevice = m_pCDTree;
|
|
}
|
|
|
|
InitDeviceUI(hDlg, m_pCDTree, pDevice); // Init to the selected device
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//////////////
|
|
// This function pulls the CD Drive node out of the combo box and returns it. It returns a
|
|
// reference into the main Drive tree.
|
|
//
|
|
|
|
STDMETHODIMP_(LPCDDRIVE) CCDOpt::GetCurrentDevice(HWND hDlg)
|
|
{
|
|
LRESULT dwResult;
|
|
LPCDDRIVE pDevice = NULL;
|
|
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_GETCURSEL, 0, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_CDDRIVE, CB_GETITEMDATA, (WPARAM) dwResult, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
pDevice = (LPCDDRIVE) dwResult;
|
|
}
|
|
}
|
|
|
|
return(pDevice);
|
|
}
|
|
|
|
//////////////
|
|
// This function pulls the CD Drive mixer out of the combo box and returns it. It returns a
|
|
// reference into the main Drive tree.
|
|
//
|
|
|
|
STDMETHODIMP_(LPCDMIXER) CCDOpt::GetCurrentMixer(HWND hDlg)
|
|
{
|
|
LRESULT dwResult;
|
|
LPCDMIXER pMixer = NULL;
|
|
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_GETCURSEL, 0, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_GETITEMDATA, (WPARAM) dwResult, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
pMixer = (LPCDMIXER) dwResult;
|
|
}
|
|
}
|
|
|
|
return(pMixer);
|
|
}
|
|
|
|
|
|
//////////////
|
|
// Called when the user changes the CD Device. it pulls the CD Drive node out of the combo box and
|
|
// then resets the UI to reflect that drives current settings.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::ChangeCDDrives(HWND hDlg)
|
|
{
|
|
LPCDDRIVE pDevice = GetCurrentDevice(hDlg);
|
|
|
|
if (pDevice)
|
|
{
|
|
LPCDDRIVE pDev = m_pCDTree;
|
|
|
|
InitDeviceUI(hDlg, m_pCDTree, pDevice);
|
|
|
|
while (pDev)
|
|
{
|
|
pDev->fSelected = (BOOL) (pDev == pDevice);
|
|
pDev = pDev->pNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////
|
|
// Called when the user changes the current mixer for the drive, it updates the
|
|
// display and the info for the drive.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::ChangeCDMixer(HWND hDlg)
|
|
{
|
|
LRESULT dwResult;
|
|
LPCDDRIVE pDevice = GetCurrentDevice(hDlg);
|
|
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_GETCURSEL, 0, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOMIXER, CB_GETITEMDATA, (WPARAM) dwResult, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
pDevice->pCurrentMixer = (LPCDMIXER) dwResult;
|
|
|
|
InitMixerUI(hDlg, pDevice);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////
|
|
// Called when the user changes the current control for the mixer on the current device.
|
|
// It updates the internal data structure for that drive.
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::ChangeCDControl(HWND hDlg)
|
|
{
|
|
LPCDMIXER pMixer = GetCurrentMixer(hDlg);
|
|
LRESULT dwResult;
|
|
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_GETCURSEL, 0, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
dwResult = SendDlgItemMessage(hDlg, IDC_AUDIOCONTROL, CB_GETITEMDATA, (WPARAM) dwResult, 0);
|
|
|
|
if (dwResult != CB_ERR)
|
|
{
|
|
pMixer->pCurrentControl = (LPCDCONTROL) dwResult;
|
|
|
|
InitControlUI(hDlg, pMixer);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// Called to set the default control for the current mixer (lets the system pick)
|
|
//
|
|
STDMETHODIMP_(void) CCDOpt::SetMixerDefaults(HWND hDlg)
|
|
{
|
|
LPCDMIXER pMixer = GetCurrentMixer(hDlg);
|
|
|
|
if (pMixer)
|
|
{
|
|
pMixer->pCurrentControl = NULL;
|
|
|
|
InitControlUI(hDlg, pMixer);
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////
|
|
// Dialog handler for the mixer configuration dialog
|
|
//
|
|
|
|
STDMETHODIMP_(BOOL) CCDOpt::MixerConfig(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fResult = TRUE;
|
|
|
|
switch (msg)
|
|
{
|
|
default:
|
|
fResult = FALSE;
|
|
break;
|
|
|
|
|
|
case WM_CONTEXTMENU:
|
|
{
|
|
WinHelp((HWND)wParam, gszHelpFile, HELP_CONTEXTMENU, (ULONG_PTR)(LPSTR)aVolOptsHelp);
|
|
}
|
|
break;
|
|
|
|
case WM_HELP:
|
|
{
|
|
WinHelp((HWND) ((LPHELPINFO)lParam)->hItemHandle, gszHelpFile, HELP_WM_HELP, (ULONG_PTR)(LPSTR)aVolOptsHelp);
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
{
|
|
fResult = InitMixerConfig(hDlg);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
EndDialog(hDlg, TRUE);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
RestoreOriginals();
|
|
EndDialog(hDlg,FALSE);
|
|
break;
|
|
|
|
case IDC_DEFAULTMIXER:
|
|
SetMixerDefaults(hDlg);
|
|
break;
|
|
|
|
case IDC_CDDRIVE:
|
|
if (HIWORD(wParam) == CBN_SELCHANGE)
|
|
{
|
|
ChangeCDDrives(hDlg);
|
|
}
|
|
break;
|
|
|
|
case IDC_AUDIOMIXER:
|
|
if (HIWORD(wParam) == CBN_SELCHANGE)
|
|
{
|
|
ChangeCDMixer(hDlg);
|
|
}
|
|
break;
|
|
|
|
case IDC_AUDIOCONTROL:
|
|
if (HIWORD(wParam) == CBN_SELCHANGE)
|
|
{
|
|
ChangeCDControl(hDlg);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
fResult = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return fResult;
|
|
}
|
|
|
|
///////////////////
|
|
// Dialog handler
|
|
//
|
|
BOOL CALLBACK CCDOpt::MixerConfigProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fResult = TRUE;
|
|
CCDOpt *pCDOpt = (CCDOpt *) GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
if (msg == WM_INITDIALOG)
|
|
{
|
|
pCDOpt = (CCDOpt *) lParam;
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR) pCDOpt);
|
|
}
|
|
|
|
if (pCDOpt)
|
|
{
|
|
fResult = pCDOpt->MixerConfig(hDlg, msg, wParam, lParam);
|
|
}
|
|
|
|
if (msg == WM_DESTROY)
|
|
{
|
|
pCDOpt = NULL;
|
|
}
|
|
|
|
return(fResult);
|
|
}
|
|
|
|
////////////
|
|
// Called to put up the UI to allow the user to change the CD Volume Configuration
|
|
//
|
|
STDMETHODIMP_(BOOL) CCDOpt::VolumeDialog(HWND hDlg)
|
|
{
|
|
BOOL fChanged = FALSE;
|
|
|
|
if (m_pCDOpts && m_pCDOpts->pCDUnitList)
|
|
{
|
|
if (SUCCEEDED(BuildUITree(&m_pCDTree, m_pCDOpts->pCDUnitList)))
|
|
{
|
|
if(DialogBoxParam( m_hInst, MAKEINTRESOURCE(IDD_MIXERPICKER), hDlg, (DLGPROC) CCDOpt::MixerConfigProc, (LPARAM) this) == TRUE)
|
|
{
|
|
fChanged = UpdateCDList(m_pCDTree, m_pCDOpts->pCDUnitList);
|
|
|
|
if (fChanged)
|
|
{
|
|
WriteCDList(m_pCDOpts->pCDUnitList);
|
|
}
|
|
}
|
|
|
|
DestroyUITree(&m_pCDTree);
|
|
}
|
|
}
|
|
|
|
return(fChanged);
|
|
}
|
|
|
|
|
|
|
|
|