able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/deluxe2/cdopt/volopt.cpp

1744 lines
51 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//--------------------------------------------------------------------------;
//
// 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);
}
Reference in a new issue Copy permalink