|
|
/* DRIVERS.C
**** Copyright (C) Microsoft, 1990, All Rights Reserved.**** Multimedia Control Panel Applet for installing/configuring installable** device drivers. See the ispec doc DRIVERS.DOC for more information.**** History:**** Tue Jul 31 1990 -by- MichaelE** Created.**** Thu Oct 25 1990 -by- MichaelE** Added restart, horz. scroll, added SKIPDESC reading desc. strings.**** Sat Oct 27 1990 -by- MichaelE** Added FileCopy. Uses SULIB.LIB and LZCOPY.LIB. Finished stuff** for case of installing a driver with more than one type.**** May 1991 -by- JohnYG** Added and replaced too many things to list. Better management** of removed drivers, correct usage of DRV_INSTALL/DRV_REMOVE,** installing VxD's, replaced "Unknown" dialog with an OEMSETUP.INF** method, proper "Cancel" method, fixed many potential UAE's.*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntseapi.h>
#include <windows.h>
#include <mmsystem.h>
#include <memory.h>
#include <string.h>
#include <stdlib.h>
#include <cpl.h>
#include <cphelp.h>
#include <commctrl.h>
#include <mmcpl.h>
#include <mmddkp.h>
#include <mmreg.h>
#include <msacm.h>
#include <msacmdrv.h>
#include <regstr.h>
#include "drivers.h"
#include "sulib.h"
#include "utils.h"
#include "medhelp.h"
#include "midi.h"
#ifdef FIX_BUG_15451
#include "trayvol.h"
#endif // FIX_BUG_15451
#ifndef cchLENGTH
#define cchLENGTH(_sz) (sizeof(_sz) / sizeof((_sz)[0]))
#endif
#ifndef TreeView_GetGrandParent
#define TreeView_GetGrandParent(_htree,_hti) \
TreeView_GetParent(_htree,TreeView_GetParent(_htree,_hti))#endif
/*
* Enable the definition below to cause MCI devices to be listed by their * internal descriptions in the tree, rather than their descriptions as * read from Drivers.Desc. * */// #define GET_MCI_DEVICE_DESCRIPTIONS_FROM_THEIR_DEVICES
typedef struct{ int idIcon; int idName; int idInfo; BOOL bEnabled; DWORD dwContext; LPTSTR pszHelp;} APPLET_INFO;
#define NUM_APPLETS 1
#define OBJECT_SIZE 1024
BOOL bBadOemSetup;BOOL bRestart = FALSE;int iRestartMessage = 0;BOOL bInstallBootLine = FALSE;BOOL bCopyVxD;BOOL bFindOEM = FALSE;BOOL bRelated = FALSE;BOOL bCopyEvenIfOlder = FALSE;BOOL bDriversAppInUse;BOOL bCopyingRelated;BOOL bDescFileValid;HANDLE myInstance;HWND hAdvDlgTree;UINT wHelpMessage;DWORD dwContext;PINF pinfOldDefault = NULL;TCHAR szDriversHlp[24];TCHAR szLastQuery[20];TCHAR szSetupInf[18];TCHAR szKnown[250];TCHAR szRestartDrv[80];TCHAR szUnlisted[150];TCHAR szRelatedDesc[30];TCHAR szAppName[26];TCHAR szDrivers[12];TCHAR szRemove[12];TCHAR szControlIni[20];TCHAR szSysIni[20];TCHAR szMCI[6];TCHAR szOutOfRemoveSpace[54];TCHAR szDriversDesc[38];TCHAR szUserDrivers[38];
// Where the source of files to copy is - user updates
TCHAR szDirOfSrc[MAX_PATH];TCHAR szAddDriver[36];TCHAR szNoDesc[36];TCHAR szError[20];TCHAR szRemoveOrNot[250];TCHAR szRemoveOrNotStrict[250];TCHAR szStringBuf[128];TCHAR szMDrivers[38];TCHAR szMDrivers32[38];TCHAR szFullPath[MAXFILESPECLEN];TCHAR szSystem[MAX_PATH];TCHAR szOemInf[MAX_PATH];TCHAR aszClose[16];TCHAR szFileError[50];
#ifdef FIX_BUG_15451
TCHAR szDriverWhichNeedsSettings[MAX_PATH]; // See MMCPL.C
#endif // FIX_BUG_15451
static HANDLE hIList;static HANDLE hWndMain;
/*
* Global flag telling us if we're allowed to write to ini files */
BOOL IniFileReadAllowed; BOOL IniFileWriteAllowed;
/*
*** Stuff for keeping track of the TreeView window * */
#define GetString(_psz,_id) LoadString(myInstance,(_id),(_psz),sizeof((_psz))/sizeof(TCHAR))
static struct // aDriverKeyword
{ LPTSTR psz; // text found as alias for driver
DriverClass dc; // DriverClass inferred from keyword
}aDriverKeyword[] = // (used by GuessDriverClass())
{ { TEXT("waveaudio"), dcMCI }, // (sort in inverse alphabetical;
{ TEXT("wavemap"), dcWAVE }, // in particular, longer names first)
{ TEXT("wave"), dcWAVE }, { TEXT("vids"), dcVCODEC }, { TEXT("vidc"), dcVCODEC }, { TEXT("sequencer"), dcMCI }, { TEXT("msvideo"), dcVIDCAP }, { TEXT("msacm"), dcACODEC }, { TEXT("mpegvideo"), dcMCI }, { TEXT("mixer"), dcMIXER }, { TEXT("midimapper"), dcMIDI }, { TEXT("midi"), dcMIDI }, { TEXT("mci"), dcMCI }, { TEXT("icm"), dcVCODEC }, { TEXT("cdaudio"), dcMCI }, { TEXT("avivideo"), dcMCI }, { TEXT("aux"), dcAUX }, { TEXT("acm"), dcACODEC }, { TEXT("joy"), dcJOY } };
#define nDriverKEYWORDS ((int)(sizeof(aDriverKeyword) / \
sizeof(aDriverKeyword[0])))
static struct // aKeywordDesc
{ DriverClass dc; // DriverClass
LPTSTR psz; // alias which best describes class
}aKeywordDesc[] = // (used by DriverClassToClassNode())
{ { dcWAVE, TEXT("wave") }, { dcMIXER, TEXT("mixer") }, { dcVIDCAP, TEXT("msvideo") }, { dcVCODEC, TEXT("icm") }, { dcAUX, TEXT("aux") }, { dcACODEC, TEXT("acm") }, { dcMIDI, TEXT("midi") }, { dcJOY, TEXT("joystick") } };
#define nKeywordDESCS ((int)(sizeof(aKeywordDesc) / \
sizeof(aKeywordDesc[0])))
static struct // aDriverRoot
{ DriverClass dc; // corresponding driver classification
BOOL fAlwaysMake; // TRUE if should exist even w/o child
int idIcon; // icon for items under this tree
int idDesc; // description string for parent
int idEnable; // string to describe enabling action
int idDisable; // string to describe disabling action
HTREEITEM hti; // item within tree
DWORD dwBit; // bit mask representing this node
}aDriverRoot[] = // (order will define order in display)
{ { dcINVALID, TRUE, IDI_MMICON, IDS_MM_HEADER, 0, 0 }, { dcWAVE, TRUE, IDI_WAVE, IDS_WAVE_HEADER, IDS_ENABLEAUDIO, IDS_DISABLEAUDIO }, { dcMIDI, TRUE, IDI_MIDI, IDS_MIDI_HEADER, IDS_ENABLEMIDI, IDS_DISABLEMIDI }, { dcMIXER, TRUE, IDI_MIXER, IDS_MIXER_HEADER, IDS_ENABLEMIXER, IDS_DISABLEMIXER }, { dcAUX, TRUE, IDI_AUX, IDS_AUX_HEADER, IDS_ENABLEAUX, IDS_DISABLEAUX }, { dcMCI, TRUE, IDI_MCI, IDS_MCI_HEADER, IDS_ENABLEMCI, IDS_DISABLEMCI }, { dcVCODEC, TRUE, IDI_ICM, IDS_ICM_HEADER, IDS_ENABLEICM, IDS_DISABLEICM }, { dcACODEC, TRUE, IDI_ACM, IDS_ACM_HEADER, IDS_ENABLEACM, IDS_DISABLEACM }, { dcVIDCAP, TRUE, IDI_VIDEO, IDS_VIDCAP_HEADER, IDS_ENABLECAP, IDS_DISABLECAP }, { dcJOY, TRUE, IDI_JOYSTICK,IDS_JOYSTICK_HEADER, IDS_ENABLEJOY, IDS_DISABLEJOY }, { dcOTHER, FALSE, IDI_MMICON, IDS_OTHER_HEADER, IDS_ENABLEJOY, IDS_DISABLEJOY }, };
#define nDriverROOTS ((int)(sizeof(aDriverRoot) / sizeof(aDriverRoot[0])))
static LPCTSTR aDriversToSKIP[] = { TEXT( "MMDRV.DLL" ), TEXT( "MIDIMAP.DLL" ), TEXT( "MSACM32.DRV" ) };
static TCHAR cszMMDRVDLL[] = TEXT("MMDRV.DLL");static TCHAR cszAliasKERNEL[] = TEXT("KERNEL");static TCHAR cszRegValueLOADTYPE[] = TEXT("Load Type");
#define nDriversToSKIP ((int)( sizeof(aDriversToSKIP) \
/ sizeof(aDriversToSKIP[0]) ))
static HIMAGELIST hImageList = NULL; // image list for treeview in advdlg
DriverClass g_dcFilterClass = dcINVALID;
short DriverClassToRootIndex (DriverClass);DriverClass GuessDriverClass (PIDRIVER);#ifdef FIX_BUG_15451
DriverClass GuessDriverClassFromAlias (LPTSTR);#endif // FIX_BUG_15451
DriverClass GuessDriverClassFromTreeItem (HTREEITEM hti);BOOL EnsureRootIndexExists (HWND, short);HTREEITEM AdvDlgFindTopLevel (void);BOOL InitAdvDlgTree (HWND);void FreeAdvDlgTree (HWND);void TreeContextMenu (HWND, HWND);
int lstrnicmp (LPTSTR, LPTSTR, size_t);LPTSTR lstrchr (LPTSTR, TCHAR);void lstrncpy (LPTSTR, LPTSTR, size_t);
void ShowDeviceProperties (HWND, HTREEITEM);
PIDRIVER FindIDriverByTreeItem (HTREEITEM);
#ifdef FIX_BUG_15451
HTREEITEM FindTreeItemByDriverName (LPTSTR);#endif // FIX_BUG_15451
// We want to run "control joy.cpl" when the joystick devices
// are highlight and the user clicks Add/Remove/Properties buttons.
BOOL RunJoyControlPanel(void); //qzheng
/*
*** * */
DWORD GetFileDateTime (LPTSTR);LPTSTR GetProfile (LPTSTR,LPTSTR, LPTSTR, LPTSTR, int);void AddIDrivers (HWND, LPTSTR, LPTSTR);HTREEITEM AddIDriver (HWND, PIDRIVER, DriverClass);BOOL AddIDriverByName (HWND, LPCWSTR, DriverClass);PIDRIVER GetSelectedIDriver (HWND);BOOL FillTreeFromWinMM (HWND);BOOL FillTreeFromMSACM (HWND);BOOL FillTreeFromMCI (HWND);BOOL FillTreeFromMIDI (HWND);BOOL FillTreeFromRemaining (HWND);void FillTreeFromRemainingBySection (HWND, long ii, LPCTSTR, DriverClass);BOOL CALLBACK FillTreeFromMSACMQueryCallback (HACMDRIVERID, DWORD_PTR, DWORD);int __cdecl FillTreeFromMSACMSortCallback (const void *p1, const void *p2);BOOL InitAvailable (HWND, int);void RemoveAvailable (HWND);BOOL UserInstalled (LPTSTR);INT_PTR RestartDlg (HWND, unsigned, WPARAM, LPARAM);INT_PTR AddUnlistedDlg (HWND, unsigned, WPARAM, LPARAM);INT_PTR AvailableDriversDlg (HWND, unsigned, WPARAM, LPARAM);INT_PTR AdvDlg (HWND, unsigned, WPARAM, LPARAM);void ReBoot (HWND);BOOL GetMappable (PIDRIVER);BOOL SetMappable (PIRESOURCE, BOOL);
#define REGSTR_PATH_WAVEMAPPER TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Wave Mapper")
#define REGSTR_VALUE_MAPPABLE TEXT("Mappable")
#define REGSTR_PATH_MCI TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI")
#define REGSTR_PATH_MCI32 TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\MCI32")
#define REGSTR_PATH_DRIVERS TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Drivers")
#define REGSTR_PATH_DRIVERS32 TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32")
/*
* REALLOC - Allows expansion of GlobalAlloc()'d block while retaining contents * * Newly-allocated portions of memory are initialized to zero, while * the contents of reallocated portions of memory are retained. * * Parameters: * LPVOID _pData....allocated array * mysize_t _cOld.....current count of elements in allocated array * mysize_t _cNew.....minimum number of elements requested * mysize_t _cDelta...granularity of increase * * Example: * { * mysize_t cElements = 0; // Number of elements allocated so far
* DataType *aElements = NULL; // Allocated array of DataType
* * // At this point, cElements == 0 (obviously)
* * REALLOC (aElements, cElements, 10, 16) * * // The line above requested 10 elements, and indicated that elements
* // should be allocated in increments of 16. So cElements is 16 at this
* // point (thus, sizeof(aElements) == sizeof(DataType)*16).
* * REALLOC (aElements, cElements, 12, 16) * * // The line above requested 12 elements. Since cElements is already 16,
* // REALLOC knows that 12 elements are already available--and does nothing.
* * REALLOC (aElements, cElements, 17, 16) * * // The line above requested 17 elements, in increments of 16. aElements
* // has been reallocated to contain 32 elements, and cElements is
* // therefore 32.
* * GlobalFree ((HGLOBAL)aElements); // All done!
* aElements = NULL; * cElements = 0; * } * * */
typedef signed long mysize_t;
#ifdef REALLOC
#undef REALLOC
#endif
#define REALLOC(_pData,_cOld,_cNew,_cDelta) \
ReallocFn (sizeof(*_pData), (void **)&_pData, &_cOld, _cNew, _cDelta)
#ifdef DivRoundUp
#undef DivRoundUp
#endif
#define DivRoundUp(_a,_b) ( (LONG)(((_a) + (_b) -1) / (_b)) )
#ifdef RoundUp
#undef RoundUp
#endif
#define RoundUp(_a,_b) ( DivRoundUp(_a,_b) * (LONG)_b )
BOOL ReallocFn (mysize_t cbElement, LPVOID *ppOld, mysize_t *pcOld, mysize_t cNew, mysize_t cDelta){ LPVOID pNew; mysize_t cbOld, cbNew;
// First check if we actually need to reallocate or not.
// It's possible that {ppOld} was already allocated with
// enough space.
//
if ( ((*ppOld) != NULL) && (cNew <= (*pcOld)) ) return TRUE;
// Oh well. Determine how much space we need, and how much
// is allocated now.
//
cNew = RoundUp (cNew, cDelta); cbNew = cbElement * cNew; cbOld = (ppOld == NULL) ? 0 : (cbElement * (*pcOld));
// Allocate the space and copy over the original contents.
// Zero-fill the remaining space.
//
if ((pNew = (LPVOID)GlobalAlloc (GMEM_FIXED, cbNew)) == NULL) return FALSE;
if (cbOld != 0) { memcpy (pNew, *ppOld, cbOld); GlobalFree ((HGLOBAL)(*ppOld)); }
memset (&((char*)pNew)[ cbOld ], 0x00, cbNew -cbOld);
// Finally, update the passed-in pointers and we're done.
//
*pcOld = cNew; *ppOld = pNew;
return TRUE;}
/*
* PIDRIVER ARRAY * * The AddIDrivers() routine LocalAlloc()'s a single IDRIVER structure * for each installed device driver. Pointers to these structures are * retained in the InstalledDriver array, and indices into this array * are stored as the LPARAM values for each tree item. Each element * in the array stores not only a pointer to the driver's IDRIVER structure, * but also a DWORD which, as a combination of aDriverRoot[].dwBit values, * reflects the tree root items under which the driver has tree items. * */
typedef struct // InstalledDriver
{ PIDRIVER pIDriver; // Pointer to AddIDrivers()'s PIDRIVER structure
DWORD dwBits; // Combination of aDriverRoot[].dwBit flags
} InstalledDriver;
InstalledDriver *aInstalledDrivers = NULL;mysize_t cInstalledDrivers = 0;
#define NOPIDRIVER ((LPARAM)-1)
/*
* CheckSectionAccess() * * See if we can read/write to a given section */
BOOL CheckSectionAccess(TCHAR *szIniFile, TCHAR *SectionName) { static TCHAR TestKey[] = TEXT("TestKey!!!"); static TCHAR TestData[] = TEXT("TestData"); static TCHAR ReturnData[50];
/*
* Check we can write, read back and delete our key */
return WritePrivateProfileString(SectionName, TestKey, TestData, szIniFile) &&
GetPrivateProfileString(SectionName, TestKey, TEXT(""), ReturnData, sizeof(ReturnData) / sizeof(TCHAR), szIniFile) == (DWORD)wcslen(TestData) &&
WritePrivateProfileString(SectionName, TestKey, NULL, szIniFile); }
/*
* CheckIniAccess() * * Checks access to our 2 .ini file sections - DRIVERS_SECTION and * MCI_SECTION by just writing and reading some junk * * Basically if we don't have access to these sections we're not * going to allow Add and Remove. The individual MCI drivers must * take care not to put their data into non-writeable storage although * this completely messes up the default parameters thing so we're going * to put these into a well-known key in the win.ini file (ie per user). * */
BOOL CheckIniAccess(void) { return CheckSectionAccess(szSysIni, szDrivers) && CheckSectionAccess(szSysIni, szMCI) && CheckSectionAccess(szControlIni, szUserDrivers) && CheckSectionAccess(szControlIni, szDriversDesc) && CheckSectionAccess(szControlIni, szRelatedDesc); }
/*
* QueryRemoveDrivers() * * Ask the user if they're sure. If the Driver is one required by the * system (ie not listed in [Userinstallable.drivers] in control.ini) * warn the user of that too. */
BOOL QueryRemoveDrivers(HWND hDlg, LPTSTR szKey, LPTSTR szDesc) { TCHAR bufout[MAXSTR];
if (UserInstalled(szKey)) wsprintf(bufout, szRemoveOrNot, (LPTSTR)szDesc); else wsprintf(bufout, szRemoveOrNotStrict, (LPTSTR)szDesc);
return (MessageBox(hDlg, bufout, szRemove, MB_ICONEXCLAMATION | MB_TASKMODAL | MB_YESNO) == IDYES ); }
/*
* GetProfile() * * Get private profile strings. */
LPTSTR GetProfile(LPTSTR pstrAppName, LPTSTR pstrKeyName, LPTSTR pstrIniFile, LPTSTR pstrRet, int cbSize) { TCHAR szNULL[2];
szNULL[0] = TEXT('\0'); GetPrivateProfileString(pstrAppName, (pstrKeyName==NULL) ? NULL : (LPTSTR)pstrKeyName, szNULL, pstrRet, cbSize/sizeof(TCHAR), pstrIniFile); return(pstrRet); }
/*********************************************************************
* * AddIDrivers() * * Add drivers in the passed key strings list to the InstalledDrivers array * *********************************************************************/
void AddIDrivers(HWND hWnd, LPTSTR pstrKeys, LPTSTR pstrSection){ PIDRIVER pIDriver; LPTSTR pstrKey; LPTSTR pstrDesc;
pstrKey = pstrKeys; pstrDesc = (LPTSTR)LocalAlloc(LPTR, MAXSTR);
if (!pstrDesc) return;
/*
* parse key strings for profile, and make IDRIVER structs */
while ( *pstrKey ) { pIDriver = (PIDRIVER)LocalAlloc(LPTR, sizeof(IDRIVER)); if ( pIDriver ) { LPTSTR pstr;
if (*GetProfile(pstrSection, pstrKey, szSysIni, pIDriver->szFile, sizeof(pIDriver->szFile)) == TEXT('\0')) { LocalFree((HANDLE)pIDriver); goto nextkey; }
for ( pstr=pIDriver->szFile; *pstr && (*pstr!=COMMA) && (*pstr!=SPACE); pstr++ ) ; *pstr = TEXT('\0');
#ifdef TRASHDRIVERDESC
if (bDescFileValid)#endif
/*
* try to load the cached description */
GetProfile(szDriversDesc, pIDriver->szFile, szControlIni, pIDriver->szDesc, sizeof(pIDriver->szDesc));
/*
* if we failed, then try to get the information from * mmdriver.inf or the exehdr */
if (pIDriver->szDesc[0] == TEXT('\0')) { if (LoadDescFromFile(pIDriver, pstrKey, pstrDesc) != DESC_NOFILE) { if (!*pstrDesc) { /*
* failed to load a description. * The file isn't in setup.inf * and doesn't have exehdr information */
lstrcpy(pIDriver->szDesc, pIDriver->szFile); lstrcat(pIDriver->szDesc, szNoDesc); } else lstrcpy(pIDriver->szDesc, pstrDesc);
WritePrivateProfileString(szDriversDesc, pIDriver->szFile, pIDriver->szDesc, szControlIni); } else { LocalFree((HANDLE)pIDriver); goto nextkey; } }
wcsncpy(pIDriver->szAlias, pstrKey, sizeof(pIDriver->szAlias)/sizeof(TCHAR)); pIDriver->szAlias[sizeof(pIDriver->szAlias)/sizeof(TCHAR) - 1] = TEXT('\0'); wcscpy(pIDriver->wszAlias, pIDriver->szAlias);
wcsncpy(pIDriver->szSection, pstrSection,sizeof(pIDriver->szSection)/sizeof(TCHAR)); pIDriver->szSection[sizeof(pIDriver->szSection)/sizeof(TCHAR) - 1] = TEXT('\0'); wcscpy(pIDriver->wszSection, pIDriver->szSection);
pIDriver->KernelDriver = IsFileKernelDriver(pIDriver->szFile); pIDriver->fQueryable = pIDriver->KernelDriver ? 0 : -1;
pIDriver->lp = 0L;
if (!AddIDriverToArray (pIDriver)) LocalFree((HANDLE)pIDriver); } else break; //ERROR Low Memory
nextkey: while (*pstrKey++); } LocalFree((HANDLE)pstrDesc);}
/*
* AddIDriverToArray - Adds the given PIDRIVER to the InstalledDrivers array * */
BOOL AddIDriverToArray (PIDRIVER pIDriver){ mysize_t ii;
if (pIDriver == NULL) { return FALSE; }
// Don't create duplicate entries in this array; one PIDRIVER
// per driver-file is sufficient.
//
for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver != NULL) { if (!lstrcmpi (aInstalledDrivers[ ii ].pIDriver->szFile, pIDriver->szFile)) { return FALSE; } } }
// To reduce repetitive calls to GlobalAlloc(), we'll allocate
// space for an additional 50 InstalledDriver entries within
// the aInstalledDrivers array each time we run out of space.
//
#define nDriverEntriesToAllocAtONCE 50
for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == NULL) break; }
if (ii >= cInstalledDrivers) { if (!REALLOC (aInstalledDrivers, // Array
cInstalledDrivers, // Current size of array
1+ii, // Requested size of array
nDriverEntriesToAllocAtONCE)) { return FALSE; } }
aInstalledDrivers[ ii ].pIDriver = pIDriver; aInstalledDrivers[ ii ].dwBits = 0L;
return TRUE;}
/*********************************************************************
* * FindInstallableDriversSection() * *********************************************************************/
PINF FindInstallableDriversSection(PINF pinf){ PINF pinfFound;
pinfFound = infFindSection(pinf, szMDrivers32);
if (pinfFound == NULL) { pinfFound = infFindSection(pinf, szMDrivers); }
return pinfFound;}
//NOTE: Returns nSize as a count of bytes, not characters (later calls expect this)
int GetINISectionSize(LPCTSTR pstrSection, LPCTSTR pstrFile){ int ncbSize = 0; int ncbMaxSize = 0;
while (ncbSize >= ncbMaxSize) { TCHAR szNULL[2]; LPTSTR pStr = NULL;
szNULL[0] = TEXT('\0');
ncbMaxSize += SECTION; //allocate another 512 bytes
pStr = (LPTSTR)LocalAlloc(LPTR, ncbMaxSize);
if (!pStr) { //we're trying to allocate too much memory ...
//drop out and use the last smaller size that worked
break; }
ncbSize = GetPrivateProfileString(pstrSection, NULL, szNULL, pStr, ncbMaxSize/sizeof(TCHAR), pstrFile); ncbSize = (ncbSize+2) * sizeof(TCHAR); //convert to byte count, adding two chars
//to account for terminating null and API's truncation
LocalFree(pStr); }
return (ncbSize);}
/*********************************************************************
* * InitInstalled() * * Add the drivers installed in [DRIVERS] and [MCI] to the Installed * Drivers list box. * *********************************************************************/
BOOL InitInstalled(HWND hWnd, LPTSTR pstrSection){ BOOL bSuccess=FALSE; LPTSTR pstr; int nSize = SECTION;
#ifdef TRASHDRIVERDESC
UINT wTime; BOOL fForce; TCHAR szOut[10];
wTime = LOWORD(GetFileDateTime(szControlIni)) >> 1; if (fForce = (GetPrivateProfileInt((LPTSTR)szUserDrivers, (LPTSTR)szLastQuery, 0, (LPTSTR)szControlIni) != wTime)) { wsprintf(szOut, TEXT("%d"), wTime); WritePrivateProfileString((LPTSTR)szUserDrivers, (LPTSTR)szLastQuery, szOut, (LPTSTR)szControlIni); WritePrivateProfileString((LPTSTR)szDriversDesc, NULL, NULL, (LPTSTR)szControlIni); bDescFileValid = FALSE; } else bDescFileValid = TRUE;#endif
nSize = GetINISectionSize(pstrSection, szSysIni);
pstr = (LPTSTR)LocalAlloc(LPTR, nSize); if ( pstr ) { if (*GetProfile(pstrSection, NULL, szSysIni, pstr, nSize )) { AddIDrivers(hWnd,pstr,pstrSection); bSuccess = TRUE; }
LocalFree((HANDLE)pstr); }
return(bSuccess);}
/*
* RefreshAdvDlgTree - Clears the Devices tree, and fills it back in * */
void RefreshAdvDlgTree (void){ if (hAdvDlgTree != NULL) { SendMessage (hAdvDlgTree, WM_SETREDRAW, FALSE, 0L);
FreeAdvDlgTree (hAdvDlgTree); InitAdvDlgTree (hAdvDlgTree); InitInstalled (GetParent (hAdvDlgTree), szDrivers); InitInstalled (GetParent (hAdvDlgTree), szMCI); FillTreeInAdvDlg (hAdvDlgTree, NULL);
SendMessage (hAdvDlgTree, WM_SETREDRAW, TRUE, 0L); }}
/*
* FillTreeInAdvDlg - Adds TreeItems for each entry in aInstalledDrivers * * If pIDriver is specified, the first treeitem to mention that driver * will be highlighted. * */
BOOL FillTreeInAdvDlg (HWND hTree, PIDRIVER pIDriver){ if (!FillTreeFromWinMM (hTree)) return FALSE;
if (!FillTreeFromMSACM (hTree)) return FALSE;
if (!FillTreeFromMCI (hTree)) return FALSE;
if (!FillTreeFromMIDI (hTree)) return FALSE;
if (!FillTreeFromRemaining (hTree)) return FALSE;
if (pIDriver != NULL) // Do we have to highlight a pIDriver?
{ short idr;
for (idr = 0; idr < nDriverROOTS; idr++) { HTREEITEM hti;
if ((hti = aDriverRoot[ idr ].hti) == NULL) continue;
for (hti = TreeView_GetChild (hTree, hti); hti != NULL; hti = TreeView_GetNextSibling (hTree, hti)) { if (pIDriver == FindIDriverByTreeItem (hti)) { TreeView_SelectItem (hTree, hti); break; } }
if (hti != NULL) // Found and selected a TreeItem?
break; // Then we're done!
} }
return TRUE;}
/*
* FillTreeFromWinMM - Adds tree items for all WinMM-controlled MM devices * * This routine adds tree items under the following DriverClasses: * dcWAVE - waveOut* * dcMIXER - mixer* * dcAUX - aux* * */
BOOL FillTreeFromWinMM (HWND hTree){ UINT iDevice; UINT cDevices; WCHAR szDriver[ cchRESOURCE ];
// Add entries for each waveOut device
//
cDevices = waveOutGetNumDevs (); for (iDevice = 0; iDevice < cDevices; ++iDevice) { if (waveOutMessage (HWAVEOUT_INDEX(iDevice), DRV_QUERYFILENAME, (DWORD_PTR)szDriver, (DWORD_PTR)cchRESOURCE) == MMSYSERR_NOERROR) { AddIDriverByName (hTree, szDriver, dcWAVE); } }
// Add entries for each mixer device
//
cDevices = mixerGetNumDevs (); for (iDevice = 0; iDevice < cDevices; ++iDevice) { if (mixerMessage (HMIXER_INDEX(iDevice), DRV_QUERYFILENAME, (DWORD_PTR)szDriver, (DWORD_PTR)cchRESOURCE) == MMSYSERR_NOERROR) { AddIDriverByName (hTree, szDriver, dcMIXER); } }
// Add entries for each aux device
//
cDevices = auxGetNumDevs (); for (iDevice = 0; iDevice < cDevices; ++iDevice) { if (auxOutMessage (iDevice, DRV_QUERYFILENAME, (DWORD_PTR)szDriver, (DWORD_PTR)cchRESOURCE) == MMSYSERR_NOERROR) { AddIDriverByName (hTree, szDriver, dcAUX); } }
return TRUE;}
/*
* FillTreeFromMSACM - Adds tree items for all MSACM-controlled MM devices * * This routine adds tree items under the following DriverClasses: * dcACODEC - acmDriverEnum() * * Note that, since audio codecs are supposed to be sorted in the tree, * all audio codec treeitems are first deleted from the tree (if there * are any at this point) then all audio codecs are added in their * sorted order. * */
typedef struct { DWORD dwPriority; // priority of this audio codec
PIDRIVER pIDriver; // matching driver file (or NULL)
WORD wMid; // manufacturer ID
WORD wPid; // product ID
TCHAR szDesc[ ACMDRIVERDETAILS_LONGNAME_CHARS ]; } AudioCodec;
AudioCodec *pCodecs;mysize_t cCodecs;
extern BOOL gfLoadedACM; // From MSACMCPL.C
BOOL FillTreeFromMSACM (HWND hTree){ MMRESULT mmr; short idr; mysize_t ii;
if (!gfLoadedACM) { if (LoadACM()) gfLoadedACM = TRUE; } if (!gfLoadedACM) return FALSE;
// Step one: get rid of any audio codecs listed in the tree
//
if ((idr = DriverClassToRootIndex (dcACODEC)) != -1) { if (aDriverRoot[ idr ].hti != NULL) { HTREEITEM hti;
while ((hti = TreeView_GetChild (hTree, aDriverRoot[ idr ].hti)) != 0) { TreeView_DeleteItem (hTree, hti);
if (hti == TreeView_GetChild (hTree, aDriverRoot[ idr ].hti)) break; // if it didn't delete, make sure we don't loop forever!
} }
for (ii = 0; ii < cInstalledDrivers; ++ii) { aInstalledDrivers[ ii ].dwBits &= ~aDriverRoot[ idr ].dwBit; } }
// Step two: query ACM to obtain the list of codecs
//
pCodecs = NULL; cCodecs = 0;
mmr = (MMRESULT)acmDriverEnum (FillTreeFromMSACMQueryCallback, 0, ACM_DRIVERENUMF_NOLOCAL | ACM_DRIVERENUMF_DISABLED);
// Step three: sort the list of codecs and add each to the tree
//
if ((mmr == MMSYSERR_NOERROR) && (pCodecs != NULL)) { mysize_t iiDr;
qsort (pCodecs, (size_t)cCodecs, sizeof(AudioCodec), FillTreeFromMSACMSortCallback);
// Assign lp=wMid+wPid for each audio codec we find
//
for (iiDr = 0; iiDr < cInstalledDrivers; ++iiDr) { if (aInstalledDrivers[ iiDr ].pIDriver == NULL) continue; if (aInstalledDrivers[ iiDr ].pIDriver->lp != 0L) // already did this
continue;
if (GuessDriverClass (aInstalledDrivers[ iiDr ].pIDriver) == dcACODEC) { HANDLE hDriver;
hDriver = OpenDriver (aInstalledDrivers[iiDr].pIDriver->wszAlias, aInstalledDrivers[iiDr].pIDriver->wszSection, 0L); if (hDriver != NULL) { ACMDRIVERDETAILSW add; memset ((TCHAR *)&add, 0x00, sizeof(add)); add.cbStruct = sizeof(add); SendDriverMessage (hDriver, ACMDM_DRIVER_DETAILS, (LONG_PTR)&add, 0); CloseDriver (hDriver, 0L, 0L);
aInstalledDrivers[ iiDr ].pIDriver->lp = MAKELONG( add.wMid, add.wPid ); } } }
// Search for installed drivers with matching lp=wMid+wPid's
//
for (iiDr = 0; iiDr < cInstalledDrivers; ++iiDr) { if (aInstalledDrivers[ iiDr ].pIDriver == NULL) continue;
if ((aInstalledDrivers[ iiDr ].pIDriver->szAlias[0] == TEXT('\0')) || (GuessDriverClass (aInstalledDrivers[iiDr].pIDriver) == dcACODEC)) { for (ii = 0; ii < cCodecs; ++ii) { if (pCodecs[ ii ].dwPriority == 0) continue;
if ( (pCodecs[ ii ].wMid == LOWORD( aInstalledDrivers[ iiDr ].pIDriver->lp )) && (pCodecs[ ii ].wPid == HIWORD( aInstalledDrivers[ iiDr ].pIDriver->lp )) ) { pCodecs[ ii ].pIDriver = aInstalledDrivers[ iiDr ].pIDriver; break; } } } }
// Add each in-use entry in pCodecs to the treeview
//
for (ii = 0; ii < cCodecs; ++ii) { if (pCodecs[ ii ].dwPriority == 0) continue;
// The PCM converter, for instance, won't have a matching
// PID. So create a bogus one--the lack of an szAlias
// will let us know it's bogus--and insert it into the
// aInstalledDrivers array.
//
if (pCodecs[ ii ].pIDriver == NULL) { PIDRIVER pid = (PIDRIVER)LocalAlloc(LPTR, sizeof(IDRIVER));
if (pid != NULL) { memset (pid, 0x00, sizeof(IDRIVER)); pid->lp = MAKELONG( pCodecs[ ii ].wMid, pCodecs[ ii ].wPid ); lstrcpy (pid->szDesc, pCodecs[ ii ].szDesc);
if (!AddIDriverToArray (pid)) LocalFree ((HLOCAL)pid); else { pCodecs[ ii ].pIDriver = pid; } } }
if (pCodecs[ ii ].pIDriver != NULL) { AddIDriver (hTree, pCodecs[ ii ].pIDriver, dcACODEC); } } }
// Cleanup
//
if (pCodecs != NULL) { GlobalFree ((HGLOBAL)pCodecs); pCodecs = NULL; cCodecs = 0; }
return (mmr == MMSYSERR_NOERROR) ? TRUE : FALSE;}
/*
* FillTreeFromMCI - Adds tree items for all MCI devices * * This routine adds tree items under the following DriverClasses: * dcMCI - mciSendCommand * */
BOOL FillTreeFromMCI (HWND hTree){ MCI_SYSINFO_PARMS mciSysInfo; TCHAR szAlias[ cchRESOURCE ];
// How many MCI devices does WinMM know about?
//
memset ((TCHAR *)&mciSysInfo, 0x00, sizeof(mciSysInfo)); mciSysInfo.lpstrReturn = szAlias; mciSysInfo.dwRetSize = cchLENGTH(szAlias); mciSysInfo.wDeviceType = MCI_ALL_DEVICE_ID;
if (mciSendCommand (MCI_ALL_DEVICE_ID, MCI_SYSINFO, MCI_SYSINFO_QUANTITY, (DWORD_PTR)&mciSysInfo) == 0) { DWORD iDevice; DWORD cDevices;
cDevices = *((DWORD *)(mciSysInfo.lpstrReturn));
// Get the name of each MCI device in turn.
//
for (iDevice = 0; iDevice < cDevices; ++iDevice) { mysize_t ii;
memset ((TCHAR *)&mciSysInfo, 0x00, sizeof(mciSysInfo)); mciSysInfo.lpstrReturn = szAlias; mciSysInfo.dwRetSize = cchLENGTH(szAlias); mciSysInfo.wDeviceType = MCI_ALL_DEVICE_ID; mciSysInfo.dwNumber = 1+iDevice; // note: 1-based, not 0-based!
if (mciSendCommand (MCI_ALL_DEVICE_ID, MCI_SYSINFO, MCI_SYSINFO_NAME, (DWORD_PTR)&mciSysInfo) != 0) { continue; }
// Got an alias--search the InstalledDrivers array
// and try to find a matching PIDRIVER.
//
for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == NULL) continue; if (!lstrcmpi (aInstalledDrivers[ ii ].pIDriver->szAlias, szAlias)) {#ifdef GET_MCI_DEVICE_DESCRIPTIONS_FROM_THEIR_DEVICES
MCI_OPEN_PARMS mciOpen; MCI_INFO_PARMS mciInfo; MCIERROR rc;
// It's an installed, functioning, happy MCI device.
// Open it up and see what it calls itself; update the
// description in the PIDRIVER (what's in there was
// obtained from the registry, thus from MMDRIVER.INF,
// and we instead want what Media Player lists in its
// Device menu).
//
memset ((TCHAR *)&mciOpen, 0x00, sizeof(mciOpen)); mciOpen.lpstrDeviceType = szAlias;
rc = mciSendCommand (0,MCI_OPEN,MCI_OPEN_TYPE,(DWORD)&mciOpen); if (rc == MCIERR_MUST_USE_SHAREABLE) { rc = mciSendCommand (0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_SHAREABLE, (DWORD)&mciOpen); } if (rc == 0) { TCHAR szDesc[ cchRESOURCE ]; szDesc[0] = 0;
mciInfo.lpstrReturn = szDesc; mciInfo.dwRetSize = cchLENGTH(szDesc);
if (mciSendCommand (mciOpen.wDeviceID, MCI_INFO, MCI_INFO_PRODUCT, (DWORD)&mciInfo) == 0) { lstrcpy (aInstalledDrivers[ ii ].pIDriver->szDesc, szDesc); }
mciSendCommand (mciOpen.wDeviceID, MCI_CLOSE, 0L, 0); }#endif // GET_MCI_DEVICE_DESCRIPTIONS_FROM_THEIR_DEVICES
AddIDriver (hTree, aInstalledDrivers[ ii ].pIDriver, dcMCI); break; } } } }
return TRUE;}
/*
* FillTreeFromMIDI - Adds tree items for all MIDI devices and instruments * * This routine adds tree items under the following DriverClasses: * dcMIDI - LoadInstruments() provides necessary data * */
BOOL FillTreeFromMIDI (HWND hTree){ MCMIDI mcm; UINT iiRoot; int idrMIDI;
if ((idrMIDI = DriverClassToRootIndex (dcMIDI)) == -1) return FALSE;
// First load in all relevant information regarding MIDI
// instruments. Fortunately, all that work is encapsulated
// nicely within one routine.
//
memset (&mcm, 0x00, sizeof(mcm)); LoadInstruments (&mcm, FALSE);
// Each entry in mcm's api array is one of three things:
// - a parent (say, a sound card)
// - a child (say, an external instrument)
// - the "(none)" thing that we want to skip
//
// Add each parent to the tree, and when we find a parent,
// add all its children.
//
for (iiRoot = 0; iiRoot < mcm.nInstr; ++iiRoot) { TCHAR szName[ MAXSTR ]; LPTSTR pch; PIDRIVER pid;
if (mcm.api[ iiRoot ] == NULL) continue; if (mcm.api[ iiRoot ]->piParent != NULL) continue; if (mcm.api[ iiRoot ]->szKey[0] == TEXT('\0')) continue;
// Found a parent! If we can match it to an installed driver,
// add it to the tree. Note that mcm.api[]->szKey will
// be of the form "MMDRV.DLL<0000>"--we need to strip off
// the "<0000>" before we can match this thing to a PIDRIVER.
//
lstrcpy (szName, mcm.api[ iiRoot ]->szKey); if ((pch = lstrchr (szName, TEXT('<'))) != NULL) *pch = TEXT('\0');
if ((pid = FindIDriverByName (szName)) != NULL) { HTREEITEM hti; UINT ii; TV_ITEM tvi;
if ((hti = AddIDriver (hTree, pid, dcMIDI)) == NULL) continue;
#if 0
tvi.mask = TVIF_TEXT; tvi.hItem = hti; tvi.pszText = mcm.api[ iiRoot ]->szFriendly; TreeView_SetItem(hTree, &tvi);#endif
// We've added this parent. See if it has any children,
// and if so, stick 'em in the tree.
//
for (ii = 0; ii < mcm.nInstr; ++ii) { PINSTRUM lp; TV_INSERTSTRUCT ti;
if (mcm.api[ ii ] == NULL) continue; if (mcm.api[ ii ]->piParent != mcm.api[ iiRoot ]) continue;
// Yep--it's got a parent. Allocate a second copy
// of this PINSTRUM; that copy will be our LPARAM value.
//
if ((lp = (PINSTRUM)LocalAlloc(LPTR,sizeof (INSTRUM))) == NULL) continue; memcpy ((TCHAR *)lp, (TCHAR *)mcm.api[ ii ], sizeof (INSTRUM));
// Now add a treeitem for this instrument.
//
ti.hParent = hti; ti.hInsertAfter = TVI_LAST; ti.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE; ti.item.iImage = (int)idrMIDI; ti.item.iSelectedImage = (int)idrMIDI; ti.item.pszText = mcm.api[ ii ]->szFriendly; ti.item.lParam = (LPARAM)lp;
if (!TreeView_InsertItem (hTree, &ti)) break; } } }
// Done--cleanup and we're out of here.
//
FreeInstruments (&mcm);
if (mcm.hkMidi) RegCloseKey (mcm.hkMidi);
return TRUE;}
// To reduce repetitive calls to GlobalAlloc(), we'll allocate
// space for an additional 10 AudioCodec entries within
// the pCodecs array each time we run out of space.
//
#define nAudioCodecEntriesToAllocAtONCE 10
BOOL CALLBACK FillTreeFromMSACMQueryCallback (HACMDRIVERID hadid, DWORD_PTR dwUser, DWORD fdwSupport){ short ii; AudioCodec *pac; ACMDRIVERDETAILS add;
// Find or create a place in which to store information
// about this codec
//
for (ii = 0; ii < cCodecs; ++ii) { if (pCodecs[ ii ].dwPriority == 0) break; } if (ii >= cCodecs) { if (!REALLOC (pCodecs, cCodecs, 1+ii, nAudioCodecEntriesToAllocAtONCE)) return FALSE; } pac = &pCodecs[ ii ]; // for shorthand
// Find out about this codec
//
memset ((TCHAR *)&add, 0x00, sizeof(add)); add.cbStruct = sizeof(add); if (acmDriverDetails (hadid, &add, 0) == MMSYSERR_NOERROR) { acmMetrics ((HACMOBJ)hadid,ACM_METRIC_DRIVER_PRIORITY,&pac->dwPriority);
lstrcpy (pac->szDesc, add.szLongName);
pac->wMid = add.wMid; pac->wPid = add.wPid;
pac->pIDriver = NULL; }
return TRUE; // keep counting
}
int __cdecl FillTreeFromMSACMSortCallback (const void *p1, const void *p2){ if (((AudioCodec *)p1)->dwPriority == 0) return 1; if (((AudioCodec *)p2)->dwPriority == 0) return -1; return ((AudioCodec *)p1)->dwPriority - ((AudioCodec *)p2)->dwPriority;}
/*
* FillTreeFromRemaining - Adds tree items for all remaining MM devices * * This routine adds a single tree item for each entry in the aInstalledDrivers * array which is not already represented somewhere in the tree. The * classification is based on the driver's alias--if that fails, it is lumped * under dcOTHER. * */
BOOL FillTreeFromRemaining (HWND hTree){ mysize_t ii;
for (ii = 0; ii < cInstalledDrivers; ++ii) { UINT iiSkipCheck;
if (aInstalledDrivers[ ii ].pIDriver == NULL) continue; if (aInstalledDrivers[ ii ].pIDriver->szAlias[0] == TEXT('\0')) continue;
// (don't do this for any not-to-be-displayed drivers)
//
for (iiSkipCheck = 0; iiSkipCheck < nDriversToSKIP; iiSkipCheck++) { if (!FileNameCmp ((LPTSTR)aDriversToSKIP[ iiSkipCheck ], (LPTSTR)aInstalledDrivers[ ii ].pIDriver->szFile)) break; } if (iiSkipCheck < nDriversToSKIP) continue;
// Zip through the {drivers,drivers32,mci,mci32} sections, to
// try to classify this driver. If we find a classification
// for which we haven't already added an entry in the tree,
// add another.
//
FillTreeFromRemainingBySection (hTree, ii, REGSTR_PATH_DRIVERS, dcINVALID);
FillTreeFromRemainingBySection (hTree, ii, REGSTR_PATH_DRIVERS32, dcINVALID);
FillTreeFromRemainingBySection (hTree, ii, REGSTR_PATH_MCI, dcMCI);
FillTreeFromRemainingBySection (hTree, ii, REGSTR_PATH_MCI32, dcMCI);
// If the dwBits element is zero, then this driver hasn't
// already been assigned a treeitem elsewhere. In that event,
// call AddIDriver() with dcOTHER--to tell it to lump this
// driver under "Other Drivers".
//
if (aInstalledDrivers[ ii ].dwBits == 0) { AddIDriver (hTree, aInstalledDrivers[ ii ].pIDriver, dcOTHER); } }
return TRUE;}
void FillTreeFromRemainingBySection (HWND hTree, long iiDriver, LPCTSTR pszSection, DriverClass dcSection){ HKEY hk; UINT ii;
if (RegOpenKey (HKEY_LOCAL_MACHINE, pszSection, &hk)) return;
for (ii = 0; ; ++ii) { TCHAR szLHS[ cchRESOURCE ]; TCHAR szRHS[ cchRESOURCE ]; DWORD dw1; DWORD dw2; DWORD dw3;
dw1 = cchRESOURCE; dw3 = cchRESOURCE; if (RegEnumValue (hk, ii, szLHS, &dw1, 0, &dw2, (LPBYTE)szRHS, &dw3) != ERROR_SUCCESS) { break; }
if (!FileNameCmp (szRHS, aInstalledDrivers[ iiDriver ].pIDriver->szFile)) { DriverClass dc;
if ((dc = dcSection) == dcINVALID) dc = GuessDriverClassFromAlias (szLHS);
if ((dc == dcINVALID) || (dc == dcOTHER)) continue;
(void)AddIDriver (hTree, aInstalledDrivers[ iiDriver ].pIDriver, dc); } }
RegCloseKey (hk);}
#ifdef FIX_BUG_15451
HWND MakeThisCPLLookLikeTheOldCPL (HWND hWndCPL){ TCHAR szTitle[ cchRESOURCE ]; HWND hWndOldCPL = NULL;
GetWindowText (hWndCPL, szTitle, cchRESOURCE);
for (hWndOldCPL = GetWindow (hWndCPL, GW_HWNDFIRST); hWndOldCPL != NULL; hWndOldCPL = GetWindow (hWndOldCPL, GW_HWNDNEXT)) { TCHAR szTitleTest[ cchRESOURCE ]; GetWindowText (hWndOldCPL, szTitleTest, cchRESOURCE); if ( (!lstrcmpi (szTitle, szTitleTest)) && (hWndCPL != hWndOldCPL) ) { RECT rOld; GetWindowRect (hWndOldCPL, &rOld); SetWindowPos (hWndCPL, hWndOldCPL, rOld.left, rOld.top, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER); SetWindowPos (hWndOldCPL, hWndCPL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); } }
return hWndOldCPL;}
HWND MakeThisDialogLookLikeTheOldDialog (HWND hDlg){ TCHAR szTitle[ cchRESOURCE ]; RECT rOld; POINT pt; HWND hWndOldDlg;
GetWindowText (hDlg, szTitle, cchRESOURCE);
for (hWndOldDlg = GetWindow (hDlg, GW_HWNDFIRST); hWndOldDlg != NULL; hWndOldDlg = GetWindow (hWndOldDlg, GW_HWNDNEXT)) { TCHAR szTitleTest[ cchRESOURCE ]; GetWindowText (hWndOldDlg, szTitleTest, cchRESOURCE); if ( (!lstrcmpi (szTitle, szTitleTest)) && (hDlg != hWndOldDlg) ) { GetWindowRect (hWndOldDlg, &rOld);
SetWindowPos (hDlg, NULL, rOld.left, rOld.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
return hWndOldDlg; } }
return NULL;}
BOOL WaitForNewCPLWindow (HWND hWndMyDlg){ TCHAR szTitle[ cchRESOURCE ]; HWND hWnd; DWORD tickStart;
#define msecMAXWAIT 5000
hWndMyDlg = GetParent (hWndMyDlg); // (hWndMyDlg was a property sheet)
GetWindowText (hWndMyDlg, szTitle, cchRESOURCE);
for (tickStart = GetTickCount(); GetTickCount() - tickStart < msecMAXWAIT;) { MSG msg;
for (hWnd = GetWindow (hWndMyDlg, GW_HWNDFIRST); hWnd != NULL; hWnd = GetWindow (hWnd, GW_HWNDNEXT)) { TCHAR szTitleTest[ cchRESOURCE ]; if (!IsWindowVisible (hWnd)) continue; GetWindowText (hWnd, szTitleTest, cchRESOURCE); if ( (!lstrcmpi (szTitle, szTitleTest)) && (hWnd != hWndMyDlg) ) { PropSheet_PressButton (hWndMyDlg, PSBTN_CANCEL); hWnd = GetParent (GetParent (hAdvDlgTree)); PropSheet_PressButton (hWnd, PSBTN_CANCEL); return TRUE; } }
if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) { if (GetMessage (&msg, NULL, 0, 0)) { TranslateMessage (&msg); DispatchMessage (&msg); } } }
return FALSE;}#endif // FIX_BUG_15451
// Prevent any more REMOVE button presses
// Otherwise one can get stacked up and cause trouble,
// particularly if it is assocated with a driver that
// is automatically removed. We have to use a static
// as any focus changes cause the button to change state.
//
static long fWorking = 0;
/********************************************************************
* * AdvDlg () * * Display list of installed installable drivers. Return TRUE/FALSE * indicating if should restart windows. * ********************************************************************/
const static DWORD aAdvDlgHelpIds[] = { // Context Help IDs
IDC_ADV_TREE, IDH_GENERIC_DEVICES, ID_ADV_PROP, IDH_ADV_PROPERTIES, ID_ADV_REMOVE, IDH_MMCPL_DEVPROP_REMOVE, 0, 0};
void MapDriverClass(DWORD_PTR dwSetupClass){ g_dcFilterClass = dcINVALID;
switch (dwSetupClass) { case IS_MS_MMMCI : { g_dcFilterClass = dcMCI; } break;
case IS_MS_MMVID : { g_dcFilterClass = dcVCODEC; } break;
case IS_MS_MMACM : { g_dcFilterClass = dcACODEC; } break;
case IS_MS_MMVCD : { g_dcFilterClass = dcVIDCAP; } break;
case IS_MS_MMDRV : { g_dcFilterClass = dcLEGACY; } break; }}
INT_PTR AdvDlg (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam){ HANDLE hWndI, hWnd; PIDRIVER pIDriver; DWORD_PTR dwType = 0;
switch ( uMsg ) { case WM_INITDIALOG:#ifdef FIX_BUG_15451
if (szDriverWhichNeedsSettings[0] != TEXT('\0')) { MakeThisCPLLookLikeTheOldCPL (GetParent(hDlg)); }#endif // FIX_BUG_15451
wsStartWait();
if (lParam) { dwType = ((LPPROPSHEETPAGE) lParam)->lParam; }
MapDriverClass(dwType);
hWndI = GetDlgItem(hDlg, IDC_ADV_TREE); SendMessage(hWndI,WM_SETREDRAW, FALSE, 0L);
InitAdvDlgTree (hWndI); // initialize the treeview display
/*
* Handle the fact that we may not be able to update our .ini * sections * */
IniFileWriteAllowed = CheckIniAccess();
// Note nasty sneaky hack: using (A|B) instead of (A&&B)
// makes both functions evaluate in either success or
// failure cases.
//
IniFileReadAllowed = ( InitInstalled (hDlg, szDrivers) | InitInstalled (hDlg, szMCI) );
FillTreeInAdvDlg (GetDlgItem (hDlg, IDC_ADV_TREE), NULL);
wsEndWait();
if ((!IniFileReadAllowed) || (!IniFileWriteAllowed)) { TCHAR szCantAdd[120]; EnableWindow(GetDlgItem(hDlg, ID_ADV_ADD),FALSE); EnableWindow(GetDlgItem(hDlg, ID_ADV_REMOVE),FALSE); LoadString(myInstance,IDS_CANTADD,szCantAdd,sizeof(szCantAdd)/sizeof(TCHAR)); MessageBox(hDlg, szCantAdd, szError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL); }
SendMessage (hWndI, WM_SETREDRAW, TRUE, 0L);
break;
case WM_COMMAND: hWndI = GetDlgItem(hDlg, IDC_ADV_TREE); hWndMain = hDlg;
pIDriver = GetSelectedIDriver (hWndI);
switch ( LOWORD(wParam )) { case ID_ADV_PROP: { HTREEITEM htiCur = TreeView_GetSelection (hWndI); DriverClass dc = GuessDriverClassFromTreeItem (htiCur);
if (fWorking) break;
++fWorking; // Just starting an operation
if( dc == dcJOY ) // We want to run "control joy.cpl" when the joystick devices
// are highlight and the user clicks Properties buttons.
RunJoyControlPanel(); else ShowDeviceProperties (hDlg, TreeView_GetSelection(hWndI));
--fWorking; // Finished with this operation
} break;
case ID_WHATSTHIS: { WinHelp((HWND)GetDlgItem (hDlg, IDC_ADV_TREE), gszWindowsHlp, HELP_WM_HELP, (UINT_PTR)(LPTSTR)aAdvDlgHelpIds); } break;
case ID_ADV_REMOVE: { HWND hTree = GetDlgItem (hDlg, IDC_ADV_TREE); HTREEITEM htiCur = TreeView_GetSelection (hTree); DriverClass dc = GuessDriverClassFromTreeItem (htiCur); PIDRIVER pid; LONG_PTR Status;
if ((!IniFileReadAllowed) || (!IniFileWriteAllowed)) break; // (button should be disabled)
if( dc == dcJOY ) { RunJoyControlPanel(); break; }
if (TreeView_GetParent (hAdvDlgTree, htiCur) && TreeView_GetGrandParent (hAdvDlgTree, htiCur) && (GuessDriverClassFromTreeItem ( TreeView_GetGrandParent (hAdvDlgTree, htiCur) ) == dcMIDI)) { TV_ITEM tvi; PINSTRUM pin;
tvi.mask = TVIF_PARAM; tvi.hItem = htiCur; tvi.lParam = 0; TreeView_GetItem(hAdvDlgTree, &tvi);
if ((pin = (PINSTRUM)tvi.lParam) != NULL) { RemoveInstrumentByKeyName (pin->szKey); RefreshAdvDlgTree (); KickMapper (hDlg); }
break; }
if ((pid = FindIDriverByTreeItem (htiCur)) == NULL) break;
if (dc == dcLEGACY) { dc = GuessDriverClass(pid); }
if (pid->szAlias[0] == TEXT('\0')) { TCHAR szCantRemove[ cchRESOURCE ]; GetString(szCantRemove, IDS_ACMREMOVEFAIL); MessageBox(hDlg, szCantRemove, szError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL); break; }
if (fWorking) break; ++fWorking; // Just starting an operation
if (QueryRemoveDrivers (hDlg, pid->szAlias, pid->szDesc)) { if ((Status = PostRemove (pid, TRUE)) != DRVCNF_CANCEL) { switch (dc) { case dcMIDI: break; case dcACODEC: acmDeleteCodec (LOWORD(pid->lp), HIWORD(pid->lp)); break; default: break; }
iRestartMessage = IDS_RESTART_REM;
if (Status == DRVCNF_RESTART) { DialogBox (myInstance, MAKEINTRESOURCE(DLG_RESTART), hDlg, RestartDlg); } } }
--fWorking; // Finished with this operation
} break;
case ID_ADV_ADD: { HTREEITEM htiCur = TreeView_GetSelection (hWndI); DriverClass dc = GuessDriverClassFromTreeItem (htiCur);
if ((!IniFileReadAllowed) || (!IniFileWriteAllowed)) break; // (button should be disabled)
if( dc == dcJOY ) { RunJoyControlPanel(); break; }
if (fWorking) break; ++fWorking; // Just starting an operation
bCopyEvenIfOlder = FALSE;
DialogBox(myInstance, MAKEINTRESOURCE(DLG_KNOWN), hDlg, AvailableDriversDlg);
bCopyEvenIfOlder = FALSE;
--fWorking; // Finished with this operation
} break;
case ID_ADV_TSHOOT: { TCHAR szCommand[ MAX_PATH ]; STARTUPINFO si; PROCESS_INFORMATION pi; LoadString(myInstance,IDS_TSHOOT, szCommand, sizeof(szCommand)/sizeof(TCHAR)); ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_NORMAL; if (CreateProcess(NULL, szCommand, NULL, NULL, FALSE, 0, 0, NULL, &si, &pi)) { CloseHandle(pi.hThread); CloseHandle(pi.hProcess); } } break;
#ifdef FIX_BUG_15451
case ID_INIT: if (szDriverWhichNeedsSettings[0] != TEXT('\0')) { HTREEITEM hti;
if ((hti = FindTreeItemByDriverName ( szDriverWhichNeedsSettings)) != 0) { TreeView_Expand (hAdvDlgTree, TreeView_GetParent(hAdvDlgTree,hti), TVE_EXPAND); TreeView_SelectItem(hAdvDlgTree,hti); FORWARD_WM_COMMAND(hDlg,ID_ADV_PROP,0,0,PostMessage); } else { szDriverWhichNeedsSettings[0] = 0; } } break;#endif // FIX_BUG_15451
default: return(FALSE); } break;
case WM_NOTIFY: { NMHDR *lpnm = (NMHDR *)lParam; LPNM_TREEVIEW lpnmtv = (LPNM_TREEVIEW)lParam;
switch (lpnm->code) { case PSN_KILLACTIVE: FORWARD_WM_COMMAND (hDlg, IDOK, 0, 0, SendMessage); break;
case PSN_APPLY: FORWARD_WM_COMMAND (hDlg, ID_APPLY, 0, 0, SendMessage); break;
case PSN_SETACTIVE: FORWARD_WM_COMMAND (hDlg, ID_INIT, 0, 0, SendMessage); break;
case PSN_RESET: FORWARD_WM_COMMAND (hDlg, IDCANCEL, 0, 0, SendMessage); break;
case NM_DBLCLK: // show properties or expand/collapse tree node.
//
if (lpnm->idFrom == (UINT)IDC_ADV_TREE) { HWND hTree = GetDlgItem (hDlg, IDC_ADV_TREE); HTREEITEM htiCur = TreeView_GetSelection (hTree); TV_HITTESTINFO tvht;
if (!htiCur) break;
GetCursorPos (&tvht.pt); ScreenToClient (hTree, &tvht.pt); TreeView_HitTest (hTree, &tvht);
if ( (tvht.flags & TVHT_ONITEM) && (TreeView_GetChild (hTree, htiCur) == NULL) && (IsWindowEnabled (GetDlgItem(hDlg,ID_ADV_PROP))) ) { FORWARD_WM_COMMAND(hDlg,ID_ADV_PROP,0,0,PostMessage); } } break;
case NM_RCLICK: TreeContextMenu (hDlg, GetDlgItem (hDlg, IDC_ADV_TREE)); return TRUE; break; } } break;
// The TreeView has its own right-click handling, and presents a
// "What's This?" automatically--so don't handle WM_CONTEXTMENU
// for that control.
//
case WM_CONTEXTMENU: if (wParam != (WPARAM)GetDlgItem (hDlg, IDC_ADV_TREE)) { WinHelp((HWND)wParam, gszWindowsHlp, HELP_CONTEXTMENU, (UINT_PTR)(LPTSTR)aAdvDlgHelpIds); } break;
case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, gszWindowsHlp, HELP_WM_HELP, (UINT_PTR)(LPTSTR)aAdvDlgHelpIds); break;
case WM_DESTROY: FreeAdvDlgTree (GetDlgItem (hDlg, IDC_ADV_TREE)); return FALSE; break;
default: return FALSE; break; } return(TRUE);}
/*
*** TreeContextMenu * * This function displays the context menu that pops up when the * user right clicks on any of the tree view items. * */void TreeContextMenu (HWND hWnd, HWND hKeyTreeWnd){ DWORD MessagePos; POINT MessagePoint; TV_HITTESTINFO TVHitTestInfo; HMENU hContextMenu; HMENU hContextPopupMenu; TV_ITEM TVItem; int MenuCommand; TCHAR szCollapse[32];
// dont bring up a menu unless click is on the item.
//
MessagePos = GetMessagePos(); MessagePoint.x = GET_X_LPARAM(MessagePos); MessagePoint.y = GET_Y_LPARAM(MessagePos);
TVHitTestInfo.pt = MessagePoint; ScreenToClient(hKeyTreeWnd, &TVHitTestInfo.pt); TVItem.hItem = TreeView_HitTest(hKeyTreeWnd, &TVHitTestInfo);
if (TVItem.hItem == NULL) return;
hContextMenu = LoadMenu(ghInstance, MAKEINTRESOURCE(POPUP_TREE_CONTEXT)); if (hContextMenu == NULL) return;
hContextPopupMenu = GetSubMenu (hContextMenu, 0);
TVItem.mask = TVIF_STATE | TVIF_HANDLE | TVIF_CHILDREN | TVIF_PARAM; TreeView_GetItem(hKeyTreeWnd, &TVItem);
// show collapse item because we are expanded?
//
if (TVItem.state & TVIS_EXPANDED) { LoadString(ghInstance, IDS_COLLAPSE, szCollapse, sizeof(szCollapse)/sizeof(TCHAR)); ModifyMenu(hContextPopupMenu, ID_TOGGLE, MF_BYCOMMAND | MF_STRING, ID_TOGGLE, szCollapse); } SetMenuDefaultItem (hContextPopupMenu, ID_TOGGLE, MF_BYCOMMAND);
if (TVItem.cChildren == 0) //gray expand/collaps if no children
{ SetMenuDefaultItem(hContextPopupMenu, ID_ADV_PROP, MF_BYCOMMAND); EnableMenuItem(hContextPopupMenu, ID_TOGGLE, MF_GRAYED |MF_BYCOMMAND); }
TreeView_SelectItem (hKeyTreeWnd, TVItem.hItem); MenuCommand = TrackPopupMenuEx (hContextPopupMenu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN | TPM_TOPALIGN, MessagePoint.x, MessagePoint.y, hWnd, NULL);
DestroyMenu (hContextMenu); FORWARD_WM_COMMAND(hWnd, MenuCommand, 0, 0, SendMessage);}
/*--------------------------------------------------------------------------*
* * * * * LB_AVAILABLE Dialog Routines * * * * * *--------------------------------------------------------------------------*/
/*
* DLG: LB_AVAILABLE * * InitAvailable() * * Add the available drivers from mmdriver.inf to the passed list box. * The format of [Installable.drivers] in setup.inf is: * profile=disk#:driverfile,"type1,type2","Installable driver Description","vxd1.386,vxd2.386","opt1,2,3" * * for example: * * driver1=6:sndblst.drv,"midi,wave","SoundBlaster MIDI and Waveform drivers","vdmad.386,vadmad.386","3,260" */
BOOL InitAvailable(HWND hWnd, int iLine){ PINF pinf; BOOL bInitd=FALSE; LPTSTR pstrKey; int iIndex; TCHAR szDesc[MAX_INF_LINE_LEN];
SendMessage(hWnd,WM_SETREDRAW, FALSE, 0L);
/*
* Parse the list of keywords and load their strings */
for (pinf = FindInstallableDriversSection(NULL); pinf; pinf = infNextLine(pinf)) { //
// found at least one keyname!
//
bInitd = TRUE; if ( (pstrKey = (LPTSTR)LocalAlloc(LPTR, MAX_SYS_INF_LEN)) != NULL ) infParseField(pinf, 0, pstrKey); else break; /*
* add the installable driver's description to listbox, and filename as data */
infParseField(pinf, 3, szDesc);
if ( (iIndex = (int)SendMessage(hWnd, LB_ADDSTRING, 0, (LONG_PTR)(LPTSTR)szDesc)) != LB_ERR )
SendMessage(hWnd, LB_SETITEMDATA, iIndex, (LONG_PTR)pstrKey);
}
if (iLine == UNLIST_LINE) { //
// Add the "Install unlisted..." choice to the top of the list
// box.
LoadString(myInstance, IDS_UPDATED, szDesc, sizeof(szDesc)/sizeof(TCHAR)); if ((iIndex = (int)(LONG)SendMessage(hWnd, LB_INSERTSTRING, 0, (LPARAM)(LPTSTR)szDesc)) != LB_ERR) SendMessage(hWnd, LB_SETITEMDATA, (WPARAM)iIndex, (LPARAM)0); } if (bInitd)
SendMessage(hWnd, LB_SETCURSEL, 0, 0L );
SendMessage(hWnd,WM_SETREDRAW, TRUE, 0L); return(bInitd);}
/*
* DLG: LB_AVAILABLE * * RemoveAvailable() * * Remove all drivers from the listbox and free all storage associated with * the keyname */
void RemoveAvailable(HWND hWnd){ int iIndex; HWND hWndA; LPTSTR pstrKey;
hWndA = GetDlgItem(hWnd, LB_AVAILABLE); iIndex = (int)SendMessage(hWndA, LB_GETCOUNT, 0, 0L); while ( iIndex-- > 0) { if (( (pstrKey = (LPTSTR)SendMessage(hWndA, LB_GETITEMDATA, iIndex, 0L)) != (LPTSTR)LB_ERR ) && pstrKey) LocalFree((HLOCAL)pstrKey); }}
/*
* DLG: LB_AVAILABLE * * AvailableDriversDlg() * * List the available installable drivers or return FALSE if there are none. */
const static DWORD aAvailDlgHelpIds[] = { // Context Help IDs
LB_AVAILABLE, IDH_ADD_DRIVER_LIST, ID_DRVSTRING, IDH_ADD_DRIVER_LIST,
0, 0};
INT_PTR AvailableDriversDlg(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){ LPTSTR pstrKey; //-jyg- added
HWND hWndA; int iIndex;
switch ( uMsg ) { case WM_INITDIALOG: ShowWindow(hWnd, TRUE); wsStartWait(); if (pinfOldDefault) { infSetDefault(pinfOldDefault); pinfOldDefault = NULL; }
if ( !InitAvailable(hWndA = GetDlgItem(hWnd, LB_AVAILABLE), UNLIST_LINE)) { /*
* We weren't able to find the [installable.drivers] section * of the * mmdriver.inf OR it was corrupt. Go ahead and query the * user to find an oemsetup.inf to make our default. This * is a bad state. */ EndDialog(hWnd, FALSE); bFindOEM = TRUE; wcscpy(szDrv, szOemInf); if (DialogBox(myInstance, MAKEINTRESOURCE(DLG_INSERTDISK), hWnd, AddDriversDlg) == TRUE) PostMessage(hWnd, WM_INITDIALOG, 0, 0L); else pinfOldDefault = infSetDefault(pinfOldDefault);
bFindOEM = FALSE; } wsEndWait(); break;
case WM_COMMAND:
switch ( LOWORD(wParam )) { case LB_AVAILABLE:
// Hm... We've picked it.
if ( HIWORD(wParam) == LBN_DBLCLK ) SendMessage(hWnd, WM_COMMAND, IDOK, 0L); break;
case IDOK:
/*
* We've made our selection */
hWndA = GetDlgItem(hWnd, LB_AVAILABLE);
if ( (iIndex = (int)SendMessage(hWndA, LB_GETCURSEL, 0, 0L)) != LB_ERR) { if (!iIndex) { /*
* The first entry is for OEMs */
INT_PTR iFound; bBadOemSetup = FALSE;
bCopyEvenIfOlder = TRUE; bFindOEM = TRUE; hMesgBoxParent = hWnd; while ((iFound = DialogBox(myInstance, MAKEINTRESOURCE(DLG_INSERTDISK), hWnd, AddDriversDlg)) == 2); if (iFound == 1) { RemoveAvailable(hWnd); SendDlgItemMessage(hWnd, LB_AVAILABLE, LB_RESETCONTENT, 0, 0L); PostMessage(hWnd, WM_INITDIALOG, 0, 0L); } bFindOEM = FALSE; } else { /*
* The user selected an entry from our .inf */
wsStartWait();
/*
* The data associated with the list item is * the driver key name (field 0 in the inf file). */
pstrKey = (LPTSTR)SendMessage(hWndA, LB_GETITEMDATA, iIndex, 0L); bCopyingRelated = FALSE; bQueryExist = TRUE;
if (InstallDrivers(hWndMain, hWnd, pstrKey)) { RefreshAdvDlgTree (); wsEndWait();
/*
* If bRestart is true then the system must * be restarted to activate these changes */
if (bRestart) { iRestartMessage= IDS_RESTART_ADD; DialogBox(myInstance, MAKEINTRESOURCE(DLG_RESTART), hWnd, RestartDlg); } } else wsEndWait();
bRestart = FALSE; bRelated = FALSE; } } EndDialog(hWnd, FALSE); break;
case IDCANCEL: EndDialog(hWnd, FALSE); break;
default: return(FALSE); } break;
case WM_CONTEXTMENU: WinHelp((HWND)wParam, gszWindowsHlp, HELP_CONTEXTMENU, (UINT_PTR)(LPTSTR)aAvailDlgHelpIds); break;
case WM_HELP: WinHelp(((LPHELPINFO)lParam)->hItemHandle, gszWindowsHlp, HELP_WM_HELP, (UINT_PTR)(LPTSTR)aAvailDlgHelpIds); break;
case WM_DESTROY: //
// free the strings added as DATAITEM to the avail list
RemoveAvailable(hWnd); return(FALSE);
default: return FALSE; break; } return(TRUE);}
BOOL DriversDllInitialize( IN PVOID hInstance , IN DWORD ulReason , IN PCONTEXT pctx OPTIONAL ){ if (ulReason != DLL_PROCESS_ATTACH) return TRUE;
myInstance = hInstance; LoadString(myInstance, IDS_CLOSE, aszClose, sizeof(aszClose)/sizeof(TCHAR)); LoadString(myInstance, IDS_DRIVERDESC, szDriversDesc, sizeof(szDriversDesc)/sizeof(TCHAR)); LoadString(myInstance, IDS_FILE_ERROR, szFileError, sizeof(szFileError)/sizeof(TCHAR)); LoadString(myInstance, IDS_INSTALLDRIVERS, szMDrivers, sizeof(szMDrivers)/sizeof(TCHAR)); LoadString(myInstance, IDS_INSTALLDRIVERS32, szMDrivers32, sizeof(szMDrivers)/sizeof(TCHAR)); LoadString(myInstance, IDS_RELATEDDESC, szRelatedDesc, sizeof(szRelatedDesc)/sizeof(TCHAR)); LoadString(myInstance, IDS_USERINSTALLDRIVERS, szUserDrivers, sizeof(szUserDrivers)/sizeof(TCHAR)); LoadString(myInstance, IDS_UNLISTED, (LPTSTR)szUnlisted, sizeof(szUnlisted)/sizeof(TCHAR)); LoadString(myInstance, IDS_KNOWN, szKnown, sizeof(szKnown)/sizeof(TCHAR)); LoadString(myInstance, IDS_OEMSETUP, szOemInf, sizeof(szOemInf)/sizeof(TCHAR)); LoadString(myInstance, IDS_SYSTEM, szSystem, sizeof(szSystem)/sizeof(TCHAR)); LoadString(myInstance, IDS_OUT_OF_REMOVE_SPACE, szOutOfRemoveSpace, sizeof(szOutOfRemoveSpace)/sizeof(TCHAR)); LoadString(myInstance, IDS_NO_DESCRIPTION, szNoDesc, sizeof(szNoDesc)/sizeof(TCHAR)); LoadString(myInstance, IDS_ERRORBOX, szError, sizeof(szError)/sizeof(TCHAR)); LoadString(myInstance, IDS_REMOVEORNOT, szRemoveOrNot, sizeof(szRemoveOrNot)/sizeof(TCHAR)); LoadString(myInstance, IDS_REMOVEORNOTSTRICT, szRemoveOrNotStrict, sizeof(szRemoveOrNotStrict)/sizeof(TCHAR)); LoadString(myInstance, IDS_SETUPINF, szSetupInf, sizeof(szSetupInf)/sizeof(TCHAR)); LoadString(myInstance, IDS_APPNAME, szAppName, sizeof(szAppName)/sizeof(TCHAR));
LoadString(myInstance, IDS_DRIVERS, szDrivers, sizeof(szDrivers)/sizeof(TCHAR)); LoadString(myInstance, IDS_REMOVE, szRemove, sizeof(szRemove)/sizeof(TCHAR)); LoadString(myInstance, IDS_CONTROLINI, szControlIni, sizeof(szControlIni)/sizeof(TCHAR)); LoadString(myInstance, IDS_SYSINI, szSysIni, sizeof(szSysIni)/sizeof(TCHAR)); LoadString(myInstance, IDS_MCI, szMCI, sizeof(szMCI)/sizeof(TCHAR)); LoadString(myInstance, IDS_DEFDRIVE, szDirOfSrc, sizeof(szDirOfSrc)/sizeof(TCHAR)); LoadString(myInstance, IDS_CONTROL_HLP_FILE, szDriversHlp, sizeof(szDriversHlp)/sizeof(TCHAR)); LoadString(myInstance, IDS_LASTQUERY, szLastQuery, sizeof(szLastQuery)/sizeof(TCHAR));
return TRUE;}
void DeleteCPLCache(void){ HKEY hKeyCache;
if (ERROR_SUCCESS == RegOpenKey(HKEY_CURRENT_USER, TEXT("Control Panel\\Cache\\multimed.cpl"), &hKeyCache)) { for ( ; ; ) { TCHAR Name[50];
if (ERROR_SUCCESS == RegEnumKey(hKeyCache, 0, Name, sizeof(Name)/sizeof(TCHAR))) { HKEY hSubKey;
RegDeleteKey(hKeyCache, Name); } else { break; // leave loop
} }
RegDeleteKey(hKeyCache, NULL); RegCloseKey(hKeyCache); }}
/*
** RestartDlg()**** Offer user the choice to (not) restart windows.*/INT_PTR RestartDlg(HWND hDlg, unsigned uiMessage, WPARAM wParam, LPARAM lParam){ switch (uiMessage) { case WM_COMMAND: switch (LOWORD(wParam)) { case IDCANCEL: //
// don't restart windows
//
EndDialog(hDlg, FALSE); break;
case IDOK: //
// do restart windows, *dont* dismiss dialog incase
// the user canceled it.
//
ReBoot(hDlg); SetActiveWindow(hDlg); //EndDialog(hDlg, TRUE);
break;
default: return FALSE; } return TRUE;
case WM_INITDIALOG: /*
** Delete the control panel's cache so it will get it ** right! */
DeleteCPLCache();
if (iRestartMessage) { TCHAR szMesg1[300]; TCHAR szMesg2[300];
LoadString(myInstance, iRestartMessage, szMesg1, sizeof(szMesg1)/sizeof(TCHAR)); wsprintf(szMesg2, szMesg1, (LPTSTR)szRestartDrv); SetDlgItemText(hDlg, IDS_RESTARTTEXT, (LPTSTR)szMesg2);
if (iRestartMessage == IDS_RESTART_NOSOUND) { PostMessage (hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hDlg,IDOK), (LPARAM)TRUE); } } return TRUE;
case WM_KEYUP: if (wParam == VK_F3) //
// don't restart windows
//
EndDialog(hDlg, FALSE); break;
default: break; } return FALSE;}
/*
* UserInstalled() * * */
BOOL UserInstalled(LPTSTR szKey){ TCHAR buf[MAXSTR]; LPTSTR lpstr = NULL; ZeroMemory (buf, sizeof (buf)); // make prefix happy.
lpstr = GetProfile (szUserDrivers, (LPTSTR)szKey, szControlIni, buf, sizeof(buf)); if (lpstr && *lpstr != TEXT('\0')) return(TRUE); else return(FALSE);}
/*
* AddUnlistedDlg() * * The following function processes requests by the user to install unlisted * or updated drivers. * * PARAMETERS: The normal Dialog box parameters * RETURN VALUE: The usual Dialog box return value */
INT_PTR AddUnlistedDlg(HWND hDlg, unsigned nMsg, WPARAM wParam, LPARAM lParam){ switch (nMsg) { case WM_INITDIALOG: { HWND hListDrivers; BOOL bFoundDrivers;
wsStartWait(); hListDrivers = GetDlgItem(hDlg, LB_UNLISTED);
/* Search for drivers */ bFoundDrivers = InitAvailable(hListDrivers, NO_UNLIST_LINE); if (!bFoundDrivers) { //
// We weren't able to find the MMDRIVERS section of the
// setup.inf OR it was corrupt. Go ahead and query the
// user to find an oemsetup.inf to make our default. This
// is a bad state.
//
INT_PTR iFound;
bFindOEM = TRUE; bBadOemSetup = TRUE; while ((iFound = DialogBox(myInstance, MAKEINTRESOURCE(DLG_INSERTDISK), hMesgBoxParent, AddDriversDlg)) == 2); bFindOEM = FALSE; if (iFound == 1) { SendDlgItemMessage(hDlg, LB_AVAILABLE, LB_RESETCONTENT, 0, 0L); PostMessage(hDlg, WM_INITDIALOG, 0, 0L); } EndDialog(hDlg, FALSE); } SendMessage(hListDrivers, LB_SETCURSEL, 0, 0L); wsEndWait();
break; }
case WM_COMMAND: switch (LOWORD(wParam)) { case IDH_DLG_ADD_UNKNOWN: goto DoHelp;
case LB_UNLISTED: if (HIWORD(wParam) != LBN_DBLCLK) break;
// else Fall through here
case IDOK: { HWND hWndA; int iIndex; LPTSTR pstrKey;
hWndA = GetDlgItem(hDlg, LB_UNLISTED); if ( (iIndex = (int)SendMessage(hWndA, LB_GETCURSEL, 0, 0L)) != LB_ERR) { wsStartWait(); pstrKey = (LPTSTR)SendMessage(hWndA, LB_GETITEMDATA, iIndex, 0L); bCopyingRelated = FALSE; bQueryExist = TRUE; if (InstallDrivers(hWndMain, hDlg, pstrKey)) { RefreshAdvDlgTree (); wsEndWait();
if (bRestart) { iRestartMessage= IDS_RESTART_ADD; DialogBox(myInstance, MAKEINTRESOURCE(DLG_RESTART), hDlg, RestartDlg); } } else wsEndWait(); bRelated = FALSE; bRestart = FALSE; } EndDialog(hDlg, FALSE); } break;
case IDCANCEL: EndDialog(hDlg, wParam); break;
default: return FALSE; } break;
case WM_HELP:DoHelp: WinHelp (hDlg, gszWindowsHlp, HELP_CONTEXT, IDH_MMCPL_DEVPROP_ENABLE); break;
default: return FALSE; } return TRUE;}/*
* ReBoot() * * Restart the system. If this fails we put up a message box */
void ReBoot(HWND hDlg) { DWORD Error; BOOLEAN WasEnabled;
/*
* We must adjust our privilege level to be allowed to restart the * system */
RtlAdjustPrivilege( SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &WasEnabled ); /*
* Try to reboot the system */
if (!ExitWindowsEx(EWX_REBOOT, 0xFFFFFFFF)) {
Error = GetLastError();
/*
* Put up a message box if we failed */
if (Error != NO_ERROR) { TCHAR szCantRestart[80]; LoadString(myInstance, Error == ERROR_PRIVILEGE_NOT_HELD || Error == ERROR_NOT_ALL_ASSIGNED || Error == ERROR_ACCESS_DENIED ? IDS_CANNOT_RESTART_PRIVILEGE : IDS_CANNOT_RESTART_UNKNOWN, szCantRestart, sizeof(szCantRestart)/sizeof(TCHAR));
MessageBox(hDlg, szCantRestart, szError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL); } } }
void OpenDriverError(HWND hDlg, LPTSTR szDriver, LPTSTR szFile){ TCHAR szMesg[MAXSTR]; TCHAR szMesg2[MAXSTR];
LoadString(myInstance, IDS_INSTALLING_DRIVERS, szMesg, sizeof(szMesg)/sizeof(TCHAR)); wsprintf(szMesg2, szMesg, szDriver, szFile); MessageBox(hDlg, szMesg2, szError, MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
}
/*
*** AddIDriver - Adds a treeitem referencing the given PIDRIVER * * Note that the listed PIDRIVER should already have been added to the * aInstalledDrivers array (via AddIDriverToArray()) before calling this * routine. * */
HTREEITEM AddIDriver (HWND hTree, PIDRIVER pIDriver, DriverClass dc){ short idr; TV_INSERTSTRUCT ti; HTREEITEM hti; short ii; TCHAR szFile[ _MAX_FNAME +1 +_MAX_EXT +1 ]; TCHAR szExt[ _MAX_EXT +1 ]; TCHAR szDesc[ cchRESOURCE ];
// don't add an entry for one of the to-be-skipped drivers
//
lsplitpath (pIDriver->szFile, NULL, NULL, szFile, szExt);
if (szExt[0] != TEXT('\0')) lstrcat (szFile, szExt);
//check to see if we're trying to put a PNP driver into the legacy tree
if (g_dcFilterClass == dcLEGACY) { if ((dc == dcWAVE) || (dc == dcMIDI) || (dc == dcMIXER) || (dc == dcAUX)) { if (IsPnPDriver(szFile)) { return FALSE; } } }
if (dc != dcMIDI) { for (ii = 0; ii < nDriversToSKIP; ii++) { if (!lstrcmpi (szFile, aDriversToSKIP[ ii ])) return FALSE; } }
// If we were given a DriverClass, then the caller has
// specified where we should create an entry--add the "Audio for"
// (etc) tag before the description, and add it.
//
// Otherwise, determine where this driver belongs in the tree
//
if (dc != dcINVALID) { TCHAR szTag[ cchRESOURCE ];
switch (dc) { case dcWAVE: GetString (szTag, IDS_AUDIOFOR); break; case dcMIDI: GetString (szTag, IDS_MIDIFOR); break; case dcMIXER: GetString (szTag, IDS_MIXERFOR); break; case dcAUX: GetString (szTag, IDS_AUXFOR); break; default: lstrcpy (szTag, TEXT("%s")); break; }
wsprintf (szDesc, szTag, pIDriver->szDesc); } else { if ((dc = GuessDriverClass (pIDriver)) == dcINVALID) return FALSE;
lstrcpy (szDesc, pIDriver->szDesc); }
// map that classification into an index within the
// root entries of the tree (aDriverRoot[])
//
if ((idr = DriverClassToRootIndex (dc)) == -1) return FALSE;
// if this driver already has an entry under this DriverClass,
// then don't add another.
//
for (ii =0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == pIDriver) break; } if (ii >= cInstalledDrivers) { ii = (short)NOPIDRIVER; } else if (aInstalledDrivers[ ii ].dwBits & aDriverRoot[ idr ].dwBit) { return FALSE; // Already have an entry here!
}
// since not all roots need exist all the time, make sure
// this classification HAS a root in the tree
//
if (!EnsureRootIndexExists (hTree, idr)) return FALSE;
// finally, insert an item into the tree for this driver
// note that for audio codecs to be sorted properly, they must
// be added via this routine in their appropriate order--ie,
// call this routine for the highest-priority codec first.
//
ti.hParent = aDriverRoot[ idr ].hti; ti.hInsertAfter = (dc == dcACODEC) ? TVI_LAST : TVI_SORT; ti.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE; ti.item.iImage = (int)idr; ti.item.iSelectedImage = (int)idr; ti.item.pszText = szDesc; ti.item.lParam = ii;
if ((hti = TreeView_InsertItem (hTree, &ti)) == NULL) return FALSE;
if (ii != NOPIDRIVER) aInstalledDrivers[ ii ].dwBits |= aDriverRoot[ idr ].dwBit;
return hti;}
BOOL AddIDriverByName (HWND hTree, LPCWSTR wszFile, DriverClass dc){ LPTSTR pch; TCHAR tszFile[ max(cchRESOURCE, MAX_PATH) ]; PIDRIVER pid;
#ifdef UNICODE
lstrcpy (tszFile, wszFile);#else
wcstombs (tszFile, wszFile, cchRESOURCE);#endif
// Strip off any trailing whitespace
//
if (tszFile[0] == TEXT('\0')) return FALSE;
for (pch = &tszFile[ lstrlen(tszFile)-1 ]; pch >= tszFile && (*pch == TEXT('\t') || *pch == TEXT(' ')); --pch) ; *(1+pch) = TEXT('\0');
// If this is MMDRV.DLL, then it's possibly providing the
// user-mode component for kernel-mode drivers. Since it's
// apparently impossible to determine the name of the .SYS
// file which is providing a "\\.\WaveIn0" device (etc),
// we'll use a hack: Check around for anyone registered
// under the alias "Kernel", and use that.
//
if (!lstrcmpi (tszFile, cszMMDRVDLL)) { mysize_t ii; for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == NULL) continue; if (!lstrnicmp (aInstalledDrivers[ ii ].pIDriver->szAlias, cszAliasKERNEL, lstrlen(cszAliasKERNEL))) { lstrcpy (tszFile, aInstalledDrivers[ ii ].pIDriver->szFile); break; } } if (ii >= cInstalledDrivers) return FALSE; }
// Find the driver in the aInstalledDriver array, and add
// an entry for it in the tree.
//
if ((pid = FindIDriverByName (tszFile)) == NULL) return FALSE;
if (AddIDriver (hTree, pid, dc) == NULL) return FALSE;
return TRUE;}
/*
*** RemoveIDriver - Removes (and optionally frees) an IDRIVER from hAdvDlgTree * */
void RemoveIDriver (HWND hTree, PIDRIVER pIDriver, BOOL fFreeToo){ mysize_t ii; short idr; HTREEITEM hti;
// Find each TreeItem which references this entry.
//
for (idr = 0; idr < nDriverROOTS; idr++) { if ((hti = aDriverRoot[ idr ].hti) == NULL) continue;
hti = TreeView_GetChild (hTree, hti); while (hti != NULL) { if (pIDriver != FindIDriverByTreeItem (hti)) { hti = TreeView_GetNextSibling (hTree, hti); continue; }
// We found a tree item which uses this driver, so delete the
// item. Also note that this may cause the driver's parent
// node to no longer be necessary.
//
TreeView_DeleteItem (hTree, hti); hti = TreeView_GetChild (hTree, aDriverRoot[ idr ].hti);
if (!aDriverRoot[ idr ].fAlwaysMake) // may no longer need parent?
{ if (hti == NULL) // parent now has no children?
{ TreeView_DeleteItem (hTree, aDriverRoot[ idr ].hti); aDriverRoot[ idr ].hti = NULL; } } } }
// See if we can find the given pIDriver within the
// aInstalledDriver array.
//
for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == pIDriver) { aInstalledDrivers[ ii ].dwBits = 0L; // no longer in tree at all
if (fFreeToo) { LocalFree ((HANDLE)aInstalledDrivers[ ii ].pIDriver); aInstalledDrivers[ ii ].pIDriver = NULL; }
break; // There's only one entry in this array for each pIDriver
} }}
#ifdef FIX_BUG_15451
HTREEITEM FindTreeItemByDriverName (LPTSTR pszName){ PIDRIVER pid; short idr; HTREEITEM hti;
if ((pid = FindIDriverByName (pszName)) == NULL) return (HTREEITEM)0;
for (idr = 0; idr < nDriverROOTS; idr++) { if ((hti = aDriverRoot[ idr ].hti) == NULL) continue;
for (hti = TreeView_GetChild (hAdvDlgTree, hti); hti != NULL; hti = TreeView_GetNextSibling (hAdvDlgTree, hti)) { if (pid == FindIDriverByTreeItem (hti)) { return hti; } } }
return (HTREEITEM)0;}#endif // FIX_BUG_15451
PIDRIVER FindIDriverByTreeItem (HTREEITEM hti){ TV_ITEM tvi;
tvi.mask = TVIF_PARAM; tvi.hItem = hti; TreeView_GetItem (hAdvDlgTree, &tvi);
if ( (tvi.lParam < 0) || (tvi.lParam >= cInstalledDrivers) ) { return NULL; }
return aInstalledDrivers[ tvi.lParam ].pIDriver;}
/*
*** FindIDriverByName - Returns the first found IDRIVER structure with a name * */
PIDRIVER FindIDriverByName (LPTSTR szFile){ mysize_t ii;
for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver == NULL) continue; if (aInstalledDrivers[ ii ].pIDriver->szAlias[0] == TEXT('\0')) continue;
if (!FileNameCmp (aInstalledDrivers[ ii ].pIDriver->szFile, szFile)) return aInstalledDrivers[ ii ].pIDriver; }
return NULL;}
PIDRIVER FindIDriverByResource (PIRESOURCE pir){ return FindIDriverByName (FileName( pir->szFile ));}
/*
*** GetSelectedIDriver - Returns the IDRIVER structure the user has selected * */
PIDRIVER GetSelectedIDriver (HWND hTree){ HTREEITEM htiCur = TreeView_GetSelection (hTree);
if (htiCur == NULL) return NULL;
return FindIDriverByTreeItem (htiCur);}
/*
*** DriverClassToRootIndex - obtain idr for which {aDriverRoot[idr].dc == dc} * * The array index for aDriverRoot[] is NOT a DriverClass--that is, * aDriverRoot[ PickAnyDC ].dc is not necessarily equal to PickAnyDC. * Given a DC, this routine finds the index into aDriverRoot which references * that DC. * */
short DriverClassToRootIndex (DriverClass dc){ short idr;
for (idr = 0; idr < nDriverROOTS; idr++) { if (aDriverRoot[ idr ].dc == dc) return idr; }
return -1;}
/*
*** GetDriverClass - guess a DriverClass based on an IDRIVER structure * * The registry has several different aliases which it uses in the LHS * of HKLM\software\microsoft\windowsnt\drivers,drivers32,etc to indicate * the classification of a particular driver. These include: * * AUX, MIDI, MIDIMAPPER, MIXER, MSACM.*, VIDC.* WAVE, WAVEMAPPER * * as well as others--the full array of known entries is tracked within * aDriverKeywords[]. In addition, any of these may be followed by a * string of digits by which they are distinguished. This routine parses * these keywords and returns a corresponding DriverClass enum. * */
DriverClass GuessDriverClass (PIDRIVER pid){#ifdef FIX_BUG_15451
return GuessDriverClassFromAlias (pid->szAlias);}
DriverClass GuessDriverClassFromAlias (LPTSTR pszAlias){#endif // FIX_BUG_15451
TCHAR szAlias[ cchRESOURCE ]; TCHAR *pch; short ii;
#ifdef FIX_BUG_15451
lstrcpy (szAlias, pszAlias); // Make a local copy so we can munge it
#else // FIX_BUG_15451
lstrcpy (szAlias, pid->szAlias); // Make a local copy so we can munge it
#endif // FIX_BUG_15451
if ((pch = lstrchr (szAlias, TEXT('.'))) != NULL) *pch = TEXT('0');
for (ii = 0; ii < nDriverKEYWORDS; ii++) { if (!lstrnicmp (szAlias, aDriverKeyword[ii].psz, lstrlen (aDriverKeyword[ii].psz))) { return aDriverKeyword[ii].dc; } }
return dcOTHER;}
DriverClass GuessDriverClassFromTreeItem (HTREEITEM hti){ short idr;
for (idr = 0; idr < nDriverROOTS; idr++) { if (hti == aDriverRoot[idr].hti) return aDriverRoot[idr].dc; }
return (g_dcFilterClass);}
/*
*** EnsureRootIndexExists - makes sure a given parent exists in hAdvDlgTree * */
BOOL EnsureRootIndexExists (HWND hTree, short idr){ TV_INSERTSTRUCT ti; TCHAR szDesc[ cchRESOURCE ]; HWND hwndParent = NULL; HWND hwndName = NULL;
// If we already HAVE a root in the tree, we're done.
//
if (aDriverRoot[ idr ].hti != NULL) return TRUE;
if (g_dcFilterClass != dcINVALID) { if (g_dcFilterClass == dcLEGACY) { if ((aDriverRoot[ idr ].dc != dcWAVE) && (aDriverRoot[ idr ].dc != dcMIDI) && (aDriverRoot[ idr ].dc != dcMIXER) && (aDriverRoot[ idr ].dc != dcAUX)) { return FALSE; } } else if (aDriverRoot[ idr ].dc != g_dcFilterClass) { return FALSE; } }
aDriverRoot[idr].hti = TVI_ROOT;
LoadString (myInstance, aDriverRoot[idr].idDesc, szDesc, cchRESOURCE);
if ((g_dcFilterClass == dcINVALID) || (g_dcFilterClass == dcLEGACY)) { ti.hInsertAfter = TVI_LAST; ti.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE; ti.item.iImage = idr; ti.item.iSelectedImage = idr; ti.item.pszText = szDesc; ti.item.lParam = NOPIDRIVER;
if (aDriverRoot[idr].dc == dcINVALID) ti.hParent = TVI_ROOT; else ti.hParent = AdvDlgFindTopLevel ();
if ((aDriverRoot[idr].hti = TreeView_InsertItem (hTree, &ti)) == NULL) return FALSE; }
if (g_dcFilterClass != dcINVALID) { hwndParent = GetParent(hTree); if (hwndParent) { hwndName = GetDlgItem(hwndParent,IDC_DEVICECLASS); if (hwndName) { if (g_dcFilterClass == dcLEGACY) { LoadString (myInstance, IDS_WAVE_HEADER, szDesc, cchRESOURCE); }
SetWindowText(hwndName,szDesc); } } }
return TRUE;}
/*
**** AdvDlgFindTopLevel - Finds the HTREEITEM associated with the tree root * * If there's a "Multimedia Devices" tree item under which the other roots * are collected, this will return that item. Otherwise, it returns TVI_ROOT. * */
HTREEITEM AdvDlgFindTopLevel (void){ short idr;
for (idr = 0; idr < nDriverROOTS; idr++) { if (aDriverRoot[idr].dc == dcINVALID) return aDriverRoot[idr].hti; }
return TVI_ROOT;}
/*
**** InitAdvDlgTree - Prepares the AdvDlg's treeview to display devices * */
BOOL InitAdvDlgTree (HWND hTree){ int cxIcon, cyIcon; short idr; UINT uFlags; DWORD dwLayout;
#ifdef UNICODE
TreeView_SetUnicodeFormat(hTree,TRUE); #endif
// Make sure we start with a clean slate
//
hAdvDlgTree = hTree; SendMessage (hTree, WM_SETREDRAW, FALSE, 0L);
for (idr = 0; idr < nDriverROOTS; idr++) { aDriverRoot[ idr ].hti = NULL; aDriverRoot[ idr ].dwBit = ((DWORD)1) << idr; }
// Create an imagelist for the icons in the treeview
//
cxIcon = (int)GetSystemMetrics (SM_CXSMICON); cyIcon = (int)GetSystemMetrics (SM_CYSMICON); uFlags = ILC_MASK | ILC_COLOR32;
if (GetProcessDefaultLayout(&dwLayout) && (dwLayout & LAYOUT_RTL)) { uFlags |= ILC_MIRROR; }
if ((hImageList = ImageList_Create (cxIcon, cyIcon, uFlags, nDriverROOTS, 1)) == NULL) return FALSE;
for (idr = 0; idr < nDriverROOTS; idr++) { HICON hi = LoadImage (myInstance, MAKEINTRESOURCE( aDriverRoot[idr].idIcon ), IMAGE_ICON, cxIcon, cyIcon, LR_DEFAULTCOLOR); ImageList_AddIcon (hImageList, hi); }
TreeView_SetImageList (hTree, hImageList, TVSIL_NORMAL);
if (g_dcFilterClass == dcINVALID) { // Create the root nodes that are supposed to exist
// even without children (note that not all are)
//
for (idr = 0; idr < nDriverROOTS; idr++) { if (aDriverRoot[ idr ].dc == dcINVALID) { if (!EnsureRootIndexExists (hTree, idr)) return FALSE; } } for (idr = 0; idr < nDriverROOTS; idr++) { if (aDriverRoot[ idr ].dc != dcINVALID && aDriverRoot[ idr ].fAlwaysMake) { if (!EnsureRootIndexExists (hTree, idr)) return FALSE; } } } // Expand the tree somewhat, so the user doesn't get
// greeted by a blank page
//
TreeView_Expand (hTree, AdvDlgFindTopLevel(), TVE_EXPAND);
SendMessage (hTree, WM_SETREDRAW, TRUE, 0L); return TRUE;}
/*
**** FreeAdvDlgTree - Removes and frees all items within the AdvDlg treeview * */
void FreeAdvDlgTree (HWND hTree){ short idr;
// Delete all leaf nodes
//
for (idr = 0; idr < nDriverROOTS; idr++) { HTREEITEM hti;
if (aDriverRoot[idr].dc == dcINVALID) continue; if (aDriverRoot[idr].hti == NULL) continue;
while ((hti = TreeView_GetChild (hTree, aDriverRoot[idr].hti)) != NULL) { if (aDriverRoot[ idr ].dc == dcMIDI) { HTREEITEM htiInstrument;
while ((htiInstrument = TreeView_GetChild (hTree, hti)) != NULL) { TV_ITEM tvi; tvi.mask = TVIF_PARAM; tvi.hItem = htiInstrument; tvi.lParam = 0;
TreeView_GetItem(hTree, &tvi);
if (tvi.lParam != 0) LocalFree ((HANDLE)tvi.lParam);
TreeView_DeleteItem (hTree, htiInstrument); } }
TreeView_DeleteItem (hTree, hti); } }
// Delete everything else
//
TreeView_DeleteAllItems (hTree);
// Delete the tree's image list
//
if (hImageList) { TreeView_SetImageList (hTree, NULL, TVSIL_NORMAL); ImageList_Destroy (hImageList); hImageList = NULL; }
// Delete the InstalledDrivers array
//
if (aInstalledDrivers != NULL) { mysize_t ii; for (ii = 0; ii < cInstalledDrivers; ++ii) { if (aInstalledDrivers[ ii ].pIDriver != NULL) { LocalFree ((HANDLE)aInstalledDrivers[ ii ].pIDriver); aInstalledDrivers[ ii ].pIDriver = NULL; } }
GlobalFree ((HGLOBAL)aInstalledDrivers); aInstalledDrivers = NULL; cInstalledDrivers = 0; }}
int lstrnicmp (LPTSTR pszA, LPTSTR pszB, size_t cch){#ifdef UNICODE
size_t cchA, cchB; TCHAR *pch;
for (cchA = 1, pch = pszA; cchA < cch; cchA++, pch++) { if (*pch == TEXT('\0')) break; } for (cchB = 1, pch = pszB; cchB < cch; cchB++, pch++) { if (*pch == TEXT('\0')) break; }
return (CompareStringW (GetThreadLocale(), NORM_IGNORECASE, pszA, cchA, pszB, cchB) )-2; // CompareStringW returns {1,2,3} instead of {-1,0,1}.
#else
return _strnicmp (pszA, pszB, cch);#endif
}
LPTSTR lstrchr (LPTSTR pszTarget, TCHAR ch){ size_t ich; if (pszTarget == NULL) return NULL; for (ich = 0; pszTarget[ich] != TEXT('\0'); ich++) { if (pszTarget[ich] == ch) return &pszTarget[ ich ]; }
return NULL;}
void lsplitpath (LPTSTR pszSource, LPTSTR pszDrive, LPTSTR pszPath, LPTSTR pszName, LPTSTR pszExt){ LPTSTR pszLastSlash = NULL; LPTSTR pszLastDot = NULL; LPTSTR pch; size_t cchCopy;
/*
* NOTE: This routine was snitched out of USERPRI.LIB 'cause the * one in there doesn't split the extension off the name properly. * * We assume that the path argument has the following form, where any * or all of the components may be missing. * * <drive><dir><fname><ext> * * and each of the components has the following expected form(s) * * drive: * 0 to _MAX_DRIVE-1 characters, the last of which, if any, is a * ':' * dir: * 0 to _MAX_DIR-1 characters in the form of an absolute path * (leading '/' or '\') or relative path, the last of which, if * any, must be a '/' or '\'. E.g - * absolute path: * \top\next\last\ ; or * /top/next/last/ * relative path: * top\next\last\ ; or * top/next/last/ * Mixed use of '/' and '\' within a path is also tolerated * fname: * 0 to _MAX_FNAME-1 characters not including the '.' character * ext: * 0 to _MAX_EXT-1 characters where, if any, the first must be a * '.' * */
// extract drive letter and :, if any
//
if (*(pszSource + _MAX_DRIVE - 2) == TEXT(':')) { if (pszDrive) { lstrncpy (pszDrive, pszSource, _MAX_DRIVE-1); pszDrive[ _MAX_DRIVE-1 ] = TEXT('\0'); } pszSource += _MAX_DRIVE-1; } else if (pszDrive) { *pszDrive = TEXT('\0'); }
// extract path string, if any. pszSource now points to the first
// character of the path, if any, or the filename or extension, if
// no path was specified. Scan ahead for the last occurence, if
// any, of a '/' or '\' path separator character. If none is found,
// there is no path. We will also note the last '.' character found,
// if any, to aid in handling the extension.
//
for (pch = pszSource; *pch != TEXT('\0'); pch++) { if (*pch == TEXT('/') || *pch == TEXT('\\')) pszLastSlash = pch; else if (*pch == TEXT('.')) pszLastDot = pch; }
// if we found a '\\' or '/', fill in pszPath
//
if (pszLastSlash) { if (pszPath) { cchCopy = (size_t)min((UINT)_MAX_DIR-1, (pszLastSlash-pszSource) + 1); lstrncpy (pszPath, pszSource, cchCopy); pszPath[ cchCopy ] = 0; } pszSource = pszLastSlash +1; } else if (pszPath) { *pszPath = TEXT('\0'); }
// extract file name and extension, if any. Path now points to
// the first character of the file name, if any, or the extension
// if no file name was given. Dot points to the '.' beginning the
// extension, if any.
//
if (pszLastDot && (pszLastDot >= pszSource)) { // found the marker for an extension -
// copy the file name up to the '.'.
//
if (pszName) { cchCopy = (size_t)min( (UINT)_MAX_DIR-1, (pszLastDot-pszSource) ); lstrncpy (pszName, pszSource, cchCopy); pszName[ cchCopy ] = 0; }
// now we can get the extension
//
if (pszExt) { lstrncpy (pszExt, pszLastDot, _MAX_EXT -1); pszExt[ _MAX_EXT-1 ] = TEXT('\0'); } } else { // found no extension, give empty extension and copy rest of
// string into fname.
//
if (pszName) { lstrncpy (pszName, pszSource, _MAX_FNAME -1); pszName[ _MAX_FNAME -1 ] = TEXT('\0'); }
if (pszExt) { *pszExt = TEXT('\0'); } }
}
void lstrncpy (LPTSTR pszTarget, LPTSTR pszSource, size_t cch){ size_t ich; for (ich = 0; ich < cch; ich++) { if ((pszTarget[ich] = pszSource[ich]) == TEXT('\0')) break; }}
/*
* DEVICE PROPERTY SHEETS _____________________________________________________ * */
// General flag macros
//
#define SetFlag(obj, f) do {obj |= (f);} while (0)
#define ToggleFlag(obj, f) do {obj ^= (f);} while (0)
#define ClearFlag(obj, f) do {obj &= ~(f);} while (0)
#define IsFlagSet(obj, f) (BOOL)(((obj) & (f)) == (f))
#define IsFlagClear(obj, f) (BOOL)(((obj) & (f)) != (f))
BOOL InstrumentToResource (PIRESOURCE, HTREEITEM);BOOL DriverToResource (HWND,PIRESOURCE,PIDRIVER,DriverClass);DriverClass OldClassIDToDriverClass (int);void FreeClassNode (PCLASSNODE);PIDRIVER FindIDriverByResource (PIRESOURCE);void EnableDriverService (PIRESOURCE, BOOL);
BOOL PASCAL DoDevPropCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify);STATIC void SetDevStatus(int iStatus, HWND hDlg);INT_PTR CALLBACK ACMDlg(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam);
/*
*** DriverToResource - create a PIRESOURCE structure from a PIDRIVER structure * * The Win95 code uses PIRESOURCEs (among other structures) to keep track of * the item in the Advanced tab's treeview; the old WinNT code used PIDRIVER * structures to keep track of the items in its listbox. The tree now uses * PIDRIVER structures, but we create PIRESOURCE structures out of 'em before * passing control off to the Win95 properties dialogs, which came through * largely unmodified. * * BTW, I retained the PIDRIVER structures as the main treeview structure * because it prevented difficulty in porting over the Install/Remove Driver * code from the old NT code. * */
BOOL DriverToResource (HWND hPar, PIRESOURCE pir, PIDRIVER pid, DriverClass dc){ if (dc == dcINVALID) { if ((dc = GuessDriverClass (pid)) == dcINVALID) return FALSE; }
if ((pir->pcn = (PCLASSNODE)LocalAlloc (LPTR, sizeof(CLASSNODE))) == NULL) return FALSE;
if (!DriverClassToClassNode (pir->pcn, dc)) { LocalFree ((HANDLE)pir->pcn); return FALSE; }
if (dc == dcACODEC) pir->iNode = 3; // 1=class, 2=device, 3=acm, 4=instmt
// else if (dc == dcINSTRUMENT)
// pir->iNode = 4; // 1=class, 2=device, 3=acm, 4=instmt
else pir->iNode = 2; // 1=class, 2=device, 3=acm, 4=instmt
lstrcpy (pir->szFriendlyName, pid->szDesc); lstrcpy (pir->szDesc, pid->szDesc); lstrcpy (pir->szFile, pid->szFile); lstrcpy (pir->szDrvEntry, pid->szAlias); lstrcpy (pir->szClass, pir->pcn->szClass);
pid->fQueryable = IsConfigurable (pid, hPar); pir->fQueryable = (short)pid->fQueryable; pir->iClassID = (short)DriverClassToOldClassID (dc); pir->szParam[0] = 0; pir->dnDevNode = 0; pir->hDriver = NULL;
// Find fStatus, which despite its name is really a series of
// flags--in Win95 it's composed of DEV_* flags (from the old
// mmcpl.h), but those are tied with PNP. Here, we use the
// dwStatus* flags:
//
pir->fStatus = (int)GetDriverStatus (pid);
return TRUE;}
BOOL InstrumentToResource (PIRESOURCE pir, HTREEITEM hti){ TV_ITEM tvi; PINSTRUM pin;
tvi.mask = TVIF_PARAM; tvi.hItem = hti; tvi.lParam = 0; TreeView_GetItem(hAdvDlgTree, &tvi);
if ((pin = (PINSTRUM)tvi.lParam) == NULL) return FALSE;
if ((pir->pcn = (PCLASSNODE)LocalAlloc (LPTR, sizeof(CLASSNODE))) == NULL) return FALSE;
if (!DriverClassToClassNode (pir->pcn, dcMIDI)) { LocalFree ((HANDLE)pir->pcn); return FALSE; }
pir->iNode = 4; // 1=class, 2=device, 3=acm, 4=instmt
lstrcpy (pir->szFriendlyName, pin->szFriendly); lstrcpy (pir->szDesc, pin->szKey);// lstrcpy (pir->szFile, TEXT("unused"));
// lstrcpy (pir->szDrvEntry, TEXT("unused"));
lstrcpy (pir->szClass, pir->pcn->szClass);
pir->fQueryable = FALSE; pir->iClassID = MIDI_ID; pir->szParam[0] = 0; pir->dnDevNode = 0; pir->hDriver = NULL; pir->fStatus = 0;
return TRUE;}
BOOL DriverClassToClassNode (PCLASSNODE pcn, DriverClass dc){ short idr; short ii; int cxIcon, cyIcon;
if ((idr = DriverClassToRootIndex (dc)) == -1) return FALSE;
pcn->iNode = 1; // 1=class, 2=device, 3=acm, 4=instmt
GetString (pcn->szClassName, aDriverRoot[idr].idDesc); pcn->szClass[0] = TEXT('\0');
for (ii = 0; ii < nKeywordDESCS; ii++) { if (aKeywordDesc[ii].dc == dc) { lstrcpy (pcn->szClass, aKeywordDesc[ii].psz); break; } }
cxIcon = (int)GetSystemMetrics (SM_CXICON); cyIcon = (int)GetSystemMetrics (SM_CYICON);
pcn->hIcon = LoadImage (myInstance, MAKEINTRESOURCE( aDriverRoot[ idr ].idIcon ), IMAGE_ICON, cxIcon, cyIcon, LR_DEFAULTCOLOR);
return TRUE;}
int DriverClassToOldClassID (DriverClass dc){ switch (dc) { case dcWAVE: return WAVE_ID; break; case dcMIDI: return MIDI_ID; break; case dcMIXER: return MIXER_ID; break; case dcAUX: return AUX_ID; break; case dcMCI: return MCI_ID; break; case dcACODEC: return ACM_ID; break; case dcVCODEC: return ICM_ID; break; case dcVIDCAP: return VIDCAP_ID; break; case dcJOY: return JOYSTICK_ID; break; default: return JOYSTICK_ID; break; }}
DriverClass OldClassIDToDriverClass (int ii){ switch (ii) { case WAVE_ID: return dcWAVE; break; case MIDI_ID: return dcMIDI; break; case MIXER_ID: return dcMIXER; break; case AUX_ID: return dcAUX; break; case MCI_ID: return dcMCI; break; case ACM_ID: return dcACODEC; break; case ICM_ID: return dcVCODEC; break; case VIDCAP_ID: return dcVIDCAP; break; case JOYSTICK_ID: return dcJOY; break; default: return dcOTHER; }}
void FreeIResource (PIRESOURCE pir){ if (pir->pcn != NULL) { FreeClassNode (pir->pcn); LocalFree ((HANDLE)pir->pcn); pir->pcn = NULL; }}
void FreeClassNode (PCLASSNODE pcn){ if (pcn->hIcon != NULL) { DestroyIcon (pcn->hIcon); pcn->hIcon = NULL; }}
DWORD GetDriverStatus (PIDRIVER pid){ DWORD dwStatus; SC_HANDLE scManager; SC_HANDLE scDriver; TCHAR szName[ cchRESOURCE ];
dwStatus = 0;
lsplitpath (pid->szFile, NULL, NULL, szName, NULL);
// First step: determine if the driver has a service
//
if ((scManager = OpenSCManager (NULL, NULL, GENERIC_READ)) != NULL) { if ((scDriver = OpenService (scManager, szName, GENERIC_READ)) != NULL) { QUERY_SERVICE_CONFIG qsc; SERVICE_STATUS ss; DWORD cbReq; void *pqsc;
SetFlag (dwStatus, dwStatusHASSERVICE);
// Great! It has a service. Find out if the service
// is actively running, and whether it is disabled.
//
if (QueryServiceConfig (scDriver, &qsc, sizeof(qsc), &cbReq)) { if (qsc.dwStartType != SERVICE_DISABLED) { SetFlag (dwStatus, dwStatusSvcENABLED); } } else if ((pqsc = (void *)LocalAlloc (LPTR, cbReq)) != NULL) { if (QueryServiceConfig (scDriver, (QUERY_SERVICE_CONFIG *)pqsc, cbReq, &cbReq)) { if ( ((QUERY_SERVICE_CONFIG *)pqsc)->dwStartType != SERVICE_DISABLED) { SetFlag (dwStatus, dwStatusSvcENABLED); } }
LocalFree ((HANDLE)pqsc); }
if (QueryServiceStatus (scDriver, &ss)) { if ((ss.dwCurrentState != SERVICE_STOPPED) && (ss.dwCurrentState != SERVICE_STOP_PENDING)) { SetFlag (dwStatus, dwStatusSvcSTARTED); } }
CloseServiceHandle (scDriver); }
CloseServiceHandle (scManager); }
// If no service, see if we can talk to the driver itself
//
if (!IsFlagSet (dwStatus, dwStatusHASSERVICE)) { HANDLE hDriver;
if ((hDriver = OpenDriver (pid->wszAlias, pid->wszSection, 0L)) != NULL) { SetFlag (dwStatus, dwStatusDRIVEROK);
CloseDriver (hDriver, 0L, 0L); } }
// If it's a wave device, can we map through it?
//
if (GetMappable (pid)) { SetFlag (dwStatus, dwStatusMAPPABLE); }
return dwStatus;}
void GetTreeItemNodeDesc (LPTSTR pszTarget, PIRESOURCE pir){ lstrcpy (pszTarget, pir->szFriendlyName);}
void GetTreeItemNodeID (LPTSTR pszTarget, PIRESOURCE pir){ DriverClass dc; CLASSNODE cn;
*pszTarget = 0; // In case we fail later
dc = OldClassIDToDriverClass (pir->iClassID); if (!DriverClassToClassNode (&cn, dc)) return;
switch (pir->iNode) // 1=class, 2=device, 3=acm, 4=instmt
{ case 1: // class
lstrcpy (pszTarget, cn.szClass); break;
case 2: // instrument
wsprintf (pszTarget, TEXT("%s\\%s"), cn.szClass, pir->szDrvEntry); break;
case 4: // instrument
lstrcpy (pszTarget, pir->szDesc); break;
default: lstrcpy (pszTarget, pir->szDesc); break; }
FreeClassNode (&cn);}
void ShowDeviceProperties (HWND hPar, HTREEITEM hti){ IRESOURCE ir; CLASSNODE cn; DEVTREENODE dtn; short idr; TCHAR szTitle[ cchRESOURCE ]; TCHAR szTab[ cchRESOURCE ]; DriverClass dc; PIDRIVER pid;
if (hti == NULL) return;
if (TreeView_GetParent (hAdvDlgTree, hti) && TreeView_GetGrandParent (hAdvDlgTree, hti) && (GuessDriverClassFromTreeItem ( TreeView_GetGrandParent (hAdvDlgTree, hti) ) == dcMIDI)) { if (InstrumentToResource (&ir, hti)) { ShowMidiPropSheet (NULL, ir.szFriendlyName, hPar, MIDI_INSTRUMENT_PROP, ir.szFriendlyName, hti, (LPARAM)&ir, (LPARAM)hAdvDlgTree);
FreeIResource (&ir); } return; } else if ((pid = FindIDriverByTreeItem (hti)) != NULL) { dc = GuessDriverClassFromTreeItem (TreeView_GetParent(hAdvDlgTree,hti)); if (dc == dcINVALID) { if ((dc = GuessDriverClass (pid)) == dcINVALID) return; } } else { if ((dc = GuessDriverClassFromTreeItem (hti)) == dcINVALID) return; }
if (g_dcFilterClass != dcINVALID) { if ((dc == dcOTHER) || (dc == dcINVALID)) { dc = g_dcFilterClass; } }
if ((idr = DriverClassToRootIndex (dc)) == -1) return;
if (pid == NULL) // Just want class properties?
{ if (!DriverClassToClassNode (&cn, dc)) return;
if (dc == dcMIDI) // MIDI class properties?
{ GetString (szTitle, aDriverRoot[idr].idDesc);
ShowMidiPropSheet (NULL, szTitle, hPar, MIDI_CLASS_PROP, szTitle, hti, (LPARAM)&cn, (LPARAM)hAdvDlgTree); } else // Generic class properties? (nothing to do, really)
{ GetString (szTab, IDS_GENERAL); GetString (szTitle, aDriverRoot[idr].idDesc);
dtn.lParam = (LPARAM)&cn; dtn.hwndTree = hAdvDlgTree;
ShowPropSheet (szTab, DevPropDlg, DLG_DEV_PROP, hPar, szTitle, (LPARAM)&dtn); }
FreeClassNode (&cn); } else { switch (dc) { case dcACODEC: GetString (szTab, IDS_GENERAL);
ShowPropSheet (szTab, ACMDlg, DLG_ACMDEV_PROP, hPar, pid->szDesc, pid->lp);
// Re-sort the Audio Codec entries, in case their priorities
// have changed. Then find treeview item for this codec,
// and select it.
//
{ HTREEITEM hti; short idr;
SendMessage (hAdvDlgTree, WM_SETREDRAW, FALSE, 0L); FillTreeFromMSACM (hAdvDlgTree); SendMessage (hAdvDlgTree, WM_SETREDRAW, TRUE, 0L);
if ((idr = DriverClassToRootIndex (dcACODEC)) != -1) { if ((hti = aDriverRoot[ idr ].hti) != NULL) { for (hti = TreeView_GetChild (hAdvDlgTree, hti); hti != NULL; hti = TreeView_GetNextSibling (hAdvDlgTree, hti)) { if (pid == FindIDriverByTreeItem (hti)) { TreeView_SelectItem (hAdvDlgTree, hti); break; } } } } } break;
case dcMIDI: if (!DriverToResource (hPar, &ir, pid, dc)) break;
GetString (szTab, IDS_GENERAL);
dtn.lParam = (LPARAM)&ir; dtn.hwndTree = hAdvDlgTree;
ShowWithMidiDevPropSheet (szTab, DevPropDlg, DLG_DEV_PROP, hPar, pid->szDesc, hti, (LPARAM)&dtn, (LPARAM)&ir, (LPARAM)hAdvDlgTree);
FreeIResource (&ir); break;
case dcWAVE: if (!DriverToResource (hPar, &ir, pid, dc)) break;
GetString (szTab, IDS_GENERAL);
dtn.lParam = (LPARAM)&ir; dtn.hwndTree = hAdvDlgTree;
ShowPropSheet (szTab, DevPropDlg, DLG_WAVDEV_PROP, hPar, pid->szDesc, (LPARAM)&dtn);
FreeIResource (&ir); break;
default: if (!DriverToResource (hPar, &ir, pid, dc)) break;
GetString (szTab, IDS_GENERAL);
dtn.lParam = (LPARAM)&ir; dtn.hwndTree = hAdvDlgTree;
ShowPropSheet (szTab, DevPropDlg, DLG_DEV_PROP, hPar, pid->szDesc, (LPARAM)&dtn);
FreeIResource (&ir); break; } }}
#include "medhelp.h"
const static DWORD aDevPropHelpIds[] = { // Context Help IDs
ID_DEV_SETTINGS, IDH_MMCPL_DEVPROP_SETTINGS, IDC_DEV_ICON, NO_HELP, IDC_DEV_DESC, NO_HELP, IDC_DEV_STATUS, NO_HELP, IDC_ENABLE, IDH_MMCPL_DEVPROP_ENABLE, IDC_DISABLE, IDH_MMCPL_DEVPROP_DISABLE, IDC_DONOTMAP, IDH_MMCPL_DEVPROP_DONT_MAP, 0, 0};
/*
*************************************************************** * DlgProc for device Property sheet. *************************************************************** */INT_PTR CALLBACK DevPropDlg (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam){ NMHDR FAR *lpnm;
switch (uMsg) { case WM_NOTIFY: lpnm = (NMHDR FAR *)lParam; switch(lpnm->code) { case PSN_KILLACTIVE: FORWARD_WM_COMMAND(hDlg, IDOK, 0, 0, SendMessage); break;
case PSN_APPLY: FORWARD_WM_COMMAND(hDlg, ID_APPLY, 0, 0, SendMessage); break;
case PSN_SETACTIVE: FORWARD_WM_COMMAND(hDlg, ID_INIT, 0, 0, SendMessage); break;
case PSN_RESET: FORWARD_WM_COMMAND(hDlg, IDCANCEL, 0, 0, SendMessage); break; } break;
case WM_INITDIALOG: { PIRESOURCE pIResource; PCLASSNODE pcn; PDEVTREENODE pdtn = (PDEVTREENODE)(((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr(hDlg, DWLP_USER, ((LPPROPSHEETPAGE)lParam)->lParam);
if (*((short *)(pdtn->lParam)) == 1) { HWND hwndTree = pdtn->hwndTree; HTREEITEM htiCur = TreeView_GetSelection(hwndTree); TCHAR sz[cchRESOURCE]; TV_ITEM tvi;
tvi.mask = TVIF_CHILDREN; tvi.hItem = htiCur; TreeView_GetItem(hwndTree, &tvi);
pcn = (PCLASSNODE)(pdtn->lParam); //set class icon.
SendDlgItemMessage(hDlg, IDC_DEV_ICON, STM_SETICON, (WPARAM)pcn->hIcon , 0L); SetWindowText(GetDlgItem(hDlg, IDC_DEV_DESC), pcn->szClassName); DestroyWindow(GetDlgItem(hDlg, IDC_ENABLE)); DestroyWindow(GetDlgItem(hDlg, IDC_DISABLE)); DestroyWindow(GetDlgItem(hDlg, ID_DEV_SETTINGS));
GetString (sz, (tvi.cChildren) ? IDS_NOPROP : IDS_NODEVS); SetWindowText(GetDlgItem(hDlg, IDC_DEV_STATUS), sz); } else { pIResource = (PIRESOURCE)(pdtn->lParam); SendDlgItemMessage(hDlg, IDC_DEV_ICON, STM_SETICON, (WPARAM)pIResource->pcn->hIcon , 0L); SetWindowText(GetDlgItem(hDlg, IDC_DEV_DESC), pIResource->szDesc); if (!IsFlagSet(pIResource->fStatus, dwStatusHASSERVICE) && !IsFlagSet(pIResource->fStatus, dwStatusDRIVEROK)) { SetDevStatus(pIResource->fStatus, hDlg); } else { if (pIResource->iClassID == WAVE_ID) { CheckDlgButton (hDlg, IDC_DONOTMAP, IsFlagClear(pIResource->fStatus, dwStatusMAPPABLE)); }
if (!pIResource->fQueryable || pIResource->fQueryable == -1) EnableWindow(GetDlgItem(hDlg, ID_DEV_SETTINGS), FALSE); if (!IsFlagSet (pIResource->fStatus, dwStatusHASSERVICE)) { DestroyWindow(GetDlgItem(hDlg, IDC_ENABLE)); DestroyWindow(GetDlgItem(hDlg, IDC_DISABLE)); } else { TCHAR szStatusStr[MAXSTR]; DriverClass dc; short idr;
dc = OldClassIDToDriverClass (pIResource->iClassID); idr = DriverClassToRootIndex (dc);
if (idr == -1) { DestroyWindow (GetDlgItem(hDlg, IDC_ENABLE)); DestroyWindow (GetDlgItem(hDlg, IDC_DISABLE)); } else { GetString (szStatusStr, aDriverRoot[idr].idEnable); SetDlgItemText(hDlg, IDC_ENABLE, szStatusStr); GetString (szStatusStr, aDriverRoot[idr].idDisable); SetDlgItemText(hDlg, IDC_DISABLE, szStatusStr); } } } SetDevStatus(pIResource->fStatus, hDlg); }
#ifdef FIX_BUG_15451
if (szDriverWhichNeedsSettings[0] != TEXT('\0')) { MakeThisDialogLookLikeTheOldDialog (GetParent(hDlg)); }#endif // FIX_BUG_15451
break; }
case WM_DESTROY: break;
case WM_DROPFILES: break;
case WM_CONTEXTMENU: WinHelp ((HWND) wParam, NULL, HELP_CONTEXTMENU, (UINT_PTR) (LPTSTR) aDevPropHelpIds); return TRUE;
case WM_HELP: { LPHELPINFO lphi = (LPVOID) lParam; WinHelp (lphi->hItemHandle, NULL, HELP_WM_HELP, (UINT_PTR) (LPTSTR) aDevPropHelpIds); return TRUE; }
case WM_COMMAND: HANDLE_WM_COMMAND(hDlg, wParam, lParam, DoDevPropCommand); break; } return FALSE;}
/*
*************************************************************** * *************************************************************** */BOOL PASCAL DoDevPropCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify){ PDEVTREENODE pdtn = (PDEVTREENODE)GetWindowLongPtr(hDlg, DWLP_USER); PIRESOURCE pIResource; static int fDevStatus;
if (!pdtn) return FALSE; pIResource = (PIRESOURCE)(pdtn->lParam);
switch (id) {
case ID_APPLY: if ((pIResource->iNode == 2) && (fDevStatus != pIResource->fStatus)) { if ( (IsFlagSet (fDevStatus, dwStatusMAPPABLE)) != (IsFlagSet (pIResource->fStatus, dwStatusMAPPABLE)) ) { SetMappable (pIResource, (BOOL)IsFlagSet (fDevStatus, dwStatusMAPPABLE)); }
if ( (IsFlagSet (fDevStatus, dwStatusHASSERVICE)) && (IsFlagSet (fDevStatus, dwStatusSvcENABLED) != IsFlagSet (pIResource->fStatus, dwStatusSvcENABLED)) ) {#if 0 // TODO: Multiportmidi
if ( (pIResource->iClassID == MIDI_ID) && (IsFlagSet(fDevStatus, DEV_MULTIPORTMIDI)) ) { EnableMultiPortMIDI (pIResource, IsFlagSet (fDevStatus, dwStatusSvcENABLED)); } else#endif
{ EnableDriverService (pIResource, IsFlagSet (fDevStatus, dwStatusSvcENABLED)); } } DisplayMessage(hDlg, IDS_CHANGESAVED, IDS_RESTART, MB_OK); } return TRUE;
case IDOK: return TRUE; case IDCANCEL: break;
case ID_INIT: if (pIResource->iNode == 2) fDevStatus = pIResource->fStatus;#ifdef FIX_BUG_15451
if (szDriverWhichNeedsSettings[0] != TEXT('\0')) { FORWARD_WM_COMMAND(hDlg,ID_DEV_SETTINGS,0,0,PostMessage); }#endif // FIX_BUG_15451
break;
case IDC_DONOTMAP: if(Button_GetCheck(GetDlgItem(hDlg, IDC_DONOTMAP))) ClearFlag(fDevStatus, dwStatusMAPPABLE); else SetFlag(fDevStatus, dwStatusMAPPABLE); PropSheet_Changed(GetParent(hDlg),hDlg); break;
case IDC_ENABLE: if (IsFlagSet (fDevStatus, dwStatusHASSERVICE)) { SetFlag(fDevStatus, dwStatusSvcENABLED); SetDevStatus(fDevStatus, hDlg); PropSheet_Changed(GetParent(hDlg),hDlg);#if 0 // TODO: Multiportmidi
if (IsFlagSet(fDevStatus, DEV_MULTIPORTMIDI)) { DisplayMessage(hDlg, IDS_ENABLE, IDS_ENABLEMULTIPORTMIDI, MB_OK); }#endif
} break;
case IDC_DISABLE: if (IsFlagSet (fDevStatus, dwStatusHASSERVICE)) { ClearFlag(fDevStatus, dwStatusSvcENABLED); SetDevStatus(fDevStatus, hDlg); PropSheet_Changed(GetParent(hDlg),hDlg);#if 0 // TODO: Multiportmidi
if (IsFlagSet(fDevStatus, DEV_MULTIPORTMIDI)) { DisplayMessage(hDlg, IDS_DISABLE, IDS_DISABLEMULTIPORTMIDI, MB_OK); }#endif
} break;
case ID_DEV_SETTINGS:#ifdef FIX_BUG_15451
if (szDriverWhichNeedsSettings[0] != TEXT('\0')) { ConfigureDriver (hDlg, szDriverWhichNeedsSettings); szDriverWhichNeedsSettings[0] = 0; } else { PIDRIVER pid;
if ((pid = FindIDriverByResource (pIResource)) == NULL) break;
ShowDriverSettings (hDlg, pid->szFile); }#else // FIX_BUG_15451
{ PIDRIVER pid; HANDLE hDriver;
if ((pid = FindIDriverByResource (pIResource)) == NULL) break;
if ((hDriver = OpenDriver (pid->wszAlias, pid->wszSection, 0L)) == 0) { OpenDriverError(hDlg, pid->szDesc, pid->szFile); } else { DRVCONFIGINFO DrvConfigInfo; InitDrvConfigInfo(&DrvConfigInfo, pid); if ((SendDriverMessage( hDriver, DRV_CONFIGURE, (LONG)hDlg, (LONG)(LPDRVCONFIGINFO)&DrvConfigInfo) == DRVCNF_RESTART)) { iRestartMessage= 0; DialogBox(myInstance, MAKEINTRESOURCE(DLG_RESTART), hDlg, RestartDlg); } CloseDriver(hDriver, 0L, 0L); } }#endif // FIX_BUG_15451
break; } return FALSE;}
/*
*************************************************************** * Check the status flag for the device and display the appropriate text the * the device properties prop sheet. *************************************************************** */STATIC void SetDevStatus(int iStatus, HWND hDlg){ HWND hwndS = GetDlgItem(hDlg, IDC_DEV_STATUS); TCHAR szStatus[cchRESOURCE];
if (IsFlagSet (iStatus, dwStatusHASSERVICE)) { if (IsFlagSet (iStatus, dwStatusSvcENABLED)) { if (IsFlagSet (iStatus, dwStatusSvcSTARTED)) GetString (szStatus, IDS_DEVENABLEDOK); else GetString (szStatus, IDS_DEVENABLEDNOTOK);
CheckRadioButton (hDlg, IDC_ENABLE, IDC_DISABLE, IDC_ENABLE); } else // service has been disabled
{ if (IsFlagSet (iStatus, dwStatusSvcSTARTED)) GetString (szStatus, IDS_DEVDISABLEDOK); else GetString (szStatus, IDS_DEVDISABLED);
CheckRadioButton(hDlg, IDC_ENABLE, IDC_DISABLE, IDC_DISABLE); }
SetWindowText(hwndS, szStatus); } else // driver does not have a service, and thus can't be disabled
{ if (IsFlagSet (iStatus, dwStatusDRIVEROK)) GetString (szStatus, IDS_DEVENABLEDOK); else GetString (szStatus, IDS_DEVENABLEDNODRIVER);
CheckRadioButton(hDlg, IDC_ENABLE, IDC_DISABLE, IDC_ENABLE); SetWindowText(hwndS, szStatus); }}
/*
*** EnableDriverService - enable or disable a service-based driver * * If Enable, the service will be set to start==system_start. * If !Enable, the service will be set to start==disabled. * */
void EnableDriverService (PIRESOURCE pir, BOOL fEnable){ SC_HANDLE scManager; SC_HANDLE scDriver; TCHAR szName[ cchRESOURCE ];
lsplitpath (pir->szFile, NULL, NULL, szName, NULL);
// First step: determine if the driver has a service
//
if ((scManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) { if ((scDriver = OpenService (scManager, szName, SERVICE_ALL_ACCESS)) != 0) { QUERY_SERVICE_CONFIG qsc; SERVICE_STATUS ss; DWORD cbReq; void *pqsc;
ChangeServiceConfig (scDriver, SERVICE_NO_CHANGE, (fEnable) ? SERVICE_SYSTEM_START : SERVICE_DISABLED, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
CloseServiceHandle (scDriver); }
CloseServiceHandle (scManager); }}
/*
*************************************************************** * SetMappable * * Sets the "Mappable" value for wave devices in the registry. * The registry key is created if necessary * *************************************************************** */
BOOL SetMappable (PIRESOURCE pIResource, BOOL fMappable){ TCHAR szFile[ _MAX_FNAME +1 +_MAX_EXT +1 ]; TCHAR szExt[ _MAX_EXT +1 ]; TCHAR szRegKey[MAX_PATH+1]; DWORD dwMappable; HKEY hKey;
dwMappable = (fMappable) ? 1 : 0;
lsplitpath (pIResource->szFile, NULL, NULL, szFile, szExt); if (szExt[0] != TEXT('\0')) lstrcat (szFile, szExt);
wsprintf (szRegKey, TEXT("%s\\%s"), REGSTR_PATH_WAVEMAPPER, szFile);
if (RegCreateKey (HKEY_LOCAL_MACHINE, szRegKey, &hKey) != ERROR_SUCCESS) { return FALSE; }
if (RegSetValueEx (hKey, REGSTR_VALUE_MAPPABLE, (DWORD)0, REG_DWORD, (void *)&dwMappable, sizeof(dwMappable)) != ERROR_SUCCESS) { RegCloseKey (hKey); return FALSE; }
RegCloseKey (hKey);
if (fMappable) { SetFlag(pIResource->fStatus, dwStatusMAPPABLE); } else { ClearFlag(pIResource->fStatus, dwStatusMAPPABLE); }
return TRUE;}
BOOL GetMappable (PIDRIVER pIDriver){ TCHAR szFile[ _MAX_FNAME +1 +_MAX_EXT +1 ]; TCHAR szExt[ _MAX_EXT +1 ]; TCHAR szRegKey[MAX_PATH+1]; DWORD dwMappable; DWORD dwSize; DWORD dwType; HKEY hKey;
lsplitpath (pIDriver->szFile, NULL, NULL, szFile, szExt); if (szExt[0] != TEXT('\0')) lstrcat (szFile, szExt);
wsprintf (szRegKey, TEXT("%s\\%s"), REGSTR_PATH_WAVEMAPPER, szFile);
if (RegOpenKey (HKEY_LOCAL_MACHINE, szRegKey, &hKey) != ERROR_SUCCESS) { return TRUE; }
dwSize = sizeof(dwMappable); if (RegQueryValueEx (hKey, REGSTR_VALUE_MAPPABLE, NULL, &dwType, (void *)&dwMappable, &dwSize) != ERROR_SUCCESS) { RegCloseKey (hKey); return TRUE; }
RegCloseKey (hKey);
return (dwMappable) ? TRUE : FALSE;}
#ifdef FIX_BUG_15451
// FixDriverService - work around known problems with sound drivers
//
// If there was a functioning kernel-mode service in place before the
// config dialog was presented, then there should still be one
// afterwards. However, there are two known problems with the
// currently-release drivers:
//
// 1) The service may not have shut down properly, and is stuck
// in a STOP_PENDING state(*). If this is the case, we need to
// ensure that the service is set to load on SYSTEM_START, and
// tell the user that the machine has to be rebooted before sound
// will work again.
//
// 2) The service may have failed to restart properly, and is
// stopped(**). If this is the case, and LoadType!=0, try setting
// LoadType=1 and starting the service.
//
// (*) -- bug #15451 in NT/SUR, where pending IRPs and open mixer
// handles prevent the service from shutting down
//
// (**) -- bug #XXXXX in NT/SUR, where some RISC machines stop the
// service, set LoadType=1, and fail to restart the service
// after you cancel their config dialog
//
BOOL FixDriverService (PIDRIVER pid){ SC_HANDLE scManager; SC_HANDLE scDriver; SERVICE_STATUS ss; BOOL rc = FALSE; TCHAR szName[ cchRESOURCE ];
lsplitpath (pid->szFile, NULL, NULL, szName, NULL);
// First step: open the service...even if it's hosed, we should
// still be able to do this.
//
if ((scManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS)) == 0) { return FALSE; } if ((scDriver = OpenService (scManager, szName, SERVICE_ALL_ACCESS)) == 0) { CloseServiceHandle (scManager); return FALSE; }
// Now check its status. Look for STOP_PENDING and STOPPED states.
//
if (QueryServiceStatus (scDriver, &ss)) { if (ss.dwCurrentState == SERVICE_STOP_PENDING) { // The service didn't stop properly--we'll have to reboot.
// Make sure the service is configured such that it will start
// properly when we restart.
//
ChangeServiceConfig (scDriver, SERVICE_NO_CHANGE, SERVICE_SYSTEM_START, // Enable this puppy!
SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
// Tell the caller that a reboot is mandatory
rc = TRUE; } else if (ss.dwCurrentState == SERVICE_STOPPED) { TCHAR szKey[ cchRESOURCE ]; HKEY hkParams;
// The service stopped, but didn't restart properly--it could
// just be the LoadType problem. To fix this, we'll need
// to enumerate all the keys underneath the key
// HKLM\System\CurrentControlSet\Services\(thisdriver)\Parameters,
// and look for ...\Parameters\*\LoadType==(DWORD)1.
//
// First step is to open HKLM\System\CCS\Services\(driver)\Parms.
//
wsprintf (szKey, TEXT("%s\\%s\\Parameters"), REGSTR_PATH_SERVICES, szName);
if (RegOpenKey (HKEY_LOCAL_MACHINE, szKey, &hkParams) == 0) { DWORD cSubKeys; DWORD iSubKey; BOOL fFixedLoadType = FALSE;
// Find out how many subkeys there are under here--the
// keys we want are named "Device0" through "Device(n-1)"
//
RegQueryInfoKey (hkParams, NULL, // lpClass
NULL, // lpcbClass
NULL, // lpReserved
&cSubKeys, // Whoops! We want this.
NULL, // lpcbMaxSubKeyLen
NULL, // lpcbMaxClassLen
NULL, // lpcValues
NULL, // lpcbMaxValueNameLen
NULL, // lpcbMaxValueLen
NULL, // lpcbSecurityDescriptor
NULL); // lpftLastWriteTime
// Open each subkey in turn, and look for a LoadType=
// which is bogus.
//
for (iSubKey = 0; iSubKey < cSubKeys; ++iSubKey) { HKEY hk; TCHAR szSubKey[ cchRESOURCE ]; wsprintf (szSubKey, TEXT("Device%lu"), (LONG)iSubKey);
if (RegOpenKey (hkParams, szSubKey, &hk) == ERROR_SUCCESS) { DWORD dwLoadType; DWORD dwType; DWORD dwSize = sizeof(dwType);
if (RegQueryValueEx (hk, cszRegValueLOADTYPE, NULL, &dwType, (void *)&dwLoadType, &dwSize) == 0) { if (dwLoadType == 1) { dwLoadType = 0; fFixedLoadType = TRUE;
RegSetValueEx (hk, cszRegValueLOADTYPE, 0, REG_DWORD, (void *)&dwLoadType, sizeof(dwLoadType)); } }
RegCloseKey (hk); } }
// If we fixed a LoadType value, try to restart the service.
//
if (fFixedLoadType) { if (StartService (scDriver, 0, NULL)) { ChangeServiceConfig (scDriver, SERVICE_NO_CHANGE, SERVICE_SYSTEM_START, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL); } } } } }
// Clean up. We'll return TRUE if a reboot is necessary, and FALSE
// otherwise.
//
CloseServiceHandle (scDriver); CloseServiceHandle (scManager); return rc;}
void ConfigureDriver (HWND hDlg, LPTSTR pszName){ PIDRIVER pid; HANDLE hDriver; BOOL fShowTrayVol; BOOL fRestartDialog = FALSE;
if ((pid = FindIDriverByName (pszName)) == NULL) return;
fShowTrayVol = GetTrayVolumeEnabled(); if (fShowTrayVol) SetTrayVolumeEnabled(FALSE);
if ((hDriver = OpenDriver (pid->wszAlias, pid->wszSection, 0L)) == 0) { OpenDriverError(hDlg, pid->szDesc, pid->szFile); } else { DWORD dwStatus = GetDriverStatus (pid); BOOL fHadService = IsFlagSet (dwStatus, dwStatusSvcSTARTED) && IsFlagSet (dwStatus, dwStatusHASSERVICE);
DRVCONFIGINFO DrvConfigInfo; InitDrvConfigInfo(&DrvConfigInfo, pid); if ((SendDriverMessage( hDriver, DRV_CONFIGURE, (LONG_PTR)hDlg, (LONG_PTR)(LPDRVCONFIGINFO)&DrvConfigInfo) == DRVCNF_RESTART)) { iRestartMessage = 0; fRestartDialog = TRUE; } CloseDriver(hDriver, 0L, 0L);
// If there was a functioning kernel-mode service in place before the
// config dialog was presented, then we should verify that there is
// still one in place now. See FixDriverService() for details.
//
if (fHadService) { dwStatus = GetDriverStatus (pid);
if (!IsFlagSet (dwStatus, dwStatusSvcSTARTED) || !IsFlagSet (dwStatus, dwStatusHASSERVICE)) { if (FixDriverService (pid)) { iRestartMessage = IDS_RESTART_NOSOUND; fRestartDialog = TRUE; } } } }
if (fShowTrayVol) SetTrayVolumeEnabled(TRUE);
if (fRestartDialog) { DialogBox(myInstance,MAKEINTRESOURCE(DLG_RESTART),hDlg,RestartDlg); }}
BOOL fDeviceHasMixers (LPTSTR pszName){ HKEY hk; UINT ii; BOOL rc = FALSE;
if (RegOpenKey(HKEY_LOCAL_MACHINE, REGSTR_PATH_DRIVERS32, &hk)) { return FALSE; }
for (ii = 0; ; ++ii) { TCHAR szLHS[ cchRESOURCE ]; TCHAR szRHS[ cchRESOURCE ]; DWORD dw1; DWORD dw2; DWORD dw3;
dw1 = cchRESOURCE; dw3 = cchRESOURCE; if (RegEnumValue (hk, ii, szLHS, &dw1, 0, &dw2, (LPBYTE)szRHS, &dw3) != ERROR_SUCCESS) { break; }
if ( (GuessDriverClassFromAlias (szLHS) == dcMIXER) && (!FileNameCmp (pszName, szRHS)) ) { rc = TRUE; break; } }
RegCloseKey (hk); return rc;}#endif // FIX_BUG_15451
TCHAR c_tszControlExeS[] = TEXT("control.exe %s");
BOOL RunJoyControlPanel(void){ STARTUPINFO si; PROCESS_INFORMATION pi; TCHAR tsz[MAX_PATH]; BOOL fRtn;
memset(&si, 0, sizeof(si)); si.cb = sizeof(si); wsprintf(tsz, c_tszControlExeS, TEXT("joy.cpl")); if (CreateProcess(0, tsz, 0, 0, 0, 0, 0, 0, &si, &pi)) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); fRtn = TRUE; } else { fRtn = FALSE; }
return fRtn;}
|
