1873 lines
60 KiB
C
1873 lines
60 KiB
C
/****************************************************************************\
|
|
*
|
|
* Module Name : winmm.c
|
|
*
|
|
* Multimedia support library
|
|
*
|
|
* This module contains the entry point, startup and termination code
|
|
*
|
|
* Copyright (c) 1992 Microsoft Corporation
|
|
*
|
|
\****************************************************************************/
|
|
|
|
#define UNICODE
|
|
#include "nt.h"
|
|
#include "ntrtl.h"
|
|
#include "nturtl.h"
|
|
#include "winmmi.h"
|
|
#include "mmioi.h"
|
|
#include "mci.h"
|
|
#include <regstr.h>
|
|
|
|
#define _INC_WOW_CONVERSIONS
|
|
#include "mmwow32.h"
|
|
|
|
BOOL WaveInit(void);
|
|
BOOL MidiInit(void);
|
|
BOOL AuxInit(void);
|
|
void InitDevices(void);
|
|
void InitHandles(void);
|
|
HANDLE mmDrvOpen(LPWSTR szAlias);
|
|
void WOWAppExit(HANDLE hTask);
|
|
void MigrateSoundEvents(void);
|
|
STATIC void NEAR PASCAL mregAddIniScheme(LPTSTR lszSection,
|
|
LPTSTR lszSchemeID,
|
|
LPTSTR lszSchemeName,
|
|
LPTSTR lszINI);
|
|
STATIC void NEAR PASCAL mregCreateSchemeID(LPTSTR szSchemeName, LPTSTR szSchemeID);
|
|
int lstrncmpi (LPTSTR pszA, LPTSTR pszB, size_t cch);
|
|
void RemoveMediaPath (LPTSTR pszTarget, LPTSTR pszSource);
|
|
|
|
#ifndef cchLENGTH
|
|
#define cchLENGTH(_sz) (sizeof(_sz) / sizeof(_sz[0]))
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
|
|
global data
|
|
|
|
****************************************************************************/
|
|
|
|
HANDLE ghInst; // Module handle
|
|
BOOL WinmmRunningInServer; // Are we running in the user/base server?
|
|
BOOL WinmmRunningInWOW; // Are we running in WOW
|
|
CRITICAL_SECTION DriverListCritSec; // Protect driver interface globals
|
|
CRITICAL_SECTION DriverLoadFreeCritSec; // Protect driver load/unload
|
|
CRITICAL_SECTION MapperInitCritSec; // Protect test of mapper initialized
|
|
|
|
MIDIDRV midioutdrv[MAXMIDIDRIVERS+1]; // midi output device driver list
|
|
MIDIDRV midiindrv[MAXMIDIDRIVERS+1]; // midi input device driver list
|
|
WAVEDRV waveoutdrv[MAXWAVEDRIVERS+1]; // wave output device driver list
|
|
WAVEDRV waveindrv[MAXWAVEDRIVERS+1]; // wave input device driver list
|
|
AUXDRV auxdrv[MAXAUXDRIVERS+1]; // aux device driver list
|
|
UINT wTotalMidiOutDevs; // total midi output devices
|
|
UINT wTotalMidiInDevs; // total midi input devices
|
|
UINT wTotalWaveOutDevs; // total wave output devices
|
|
UINT wTotalWaveInDevs; // total wave input devices
|
|
UINT wTotalAuxDevs; // total auxiliary output devices
|
|
#ifdef DEBUG_RETAIL
|
|
BYTE fIdReverse; // reverse wave/midi id's
|
|
#endif
|
|
|
|
// For sounds:
|
|
|
|
STATIC TCHAR gszControlIniTime[] = TEXT("ControlIniTimeStamp");
|
|
TCHAR gszControlPanel[] = TEXT("Control Panel");
|
|
TCHAR gszSchemesRootKey[] = TEXT("AppEvents\\Schemes");
|
|
TCHAR gszJustSchemesKey[] = TEXT("Schemes");
|
|
TCHAR aszExplorer[] = TEXT("Explorer");
|
|
TCHAR aszDefault[] = TEXT(".Default");
|
|
TCHAR aszCurrent[] = TEXT(".Current");
|
|
TCHAR gszAppEventsKey[] = TEXT("AppEvents");
|
|
TCHAR gszSchemeAppsKey[] = TEXT("Apps");
|
|
TCHAR aszSoundsSection[] = TEXT("Sounds");
|
|
TCHAR aszSoundSection[] = TEXT("Sound");
|
|
TCHAR aszActiveKey[] = TEXT("Active");
|
|
TCHAR aszBoolOne[] = TEXT("1");
|
|
|
|
TCHAR asz2Format[] = TEXT("%s\\%s");
|
|
TCHAR asz3Format[] = TEXT("%s\\%s\\%s");
|
|
TCHAR asz4Format[] = TEXT("%s\\%s\\%s\\%s");
|
|
TCHAR asz5Format[] = TEXT("%s\\%s\\%s\\%s\\%s");
|
|
TCHAR asz6Format[] = TEXT("%s\\%s\\%s\\%s\\%s\\%s");
|
|
|
|
STATIC TCHAR aszSchemeLabelsKey[] = TEXT("EventLabels");
|
|
STATIC TCHAR aszSchemeNamesKey[] = TEXT("Names");
|
|
STATIC TCHAR aszControlINI[] = TEXT("control.ini");
|
|
STATIC TCHAR aszWinINI[] = TEXT("win.ini");
|
|
STATIC TCHAR aszSchemesSection[] = TEXT("SoundSchemes");
|
|
STATIC TCHAR gszSoundScheme[] = TEXT("SoundScheme.%s");
|
|
STATIC TCHAR aszCurrentSection[] = TEXT("Current");
|
|
STATIC TCHAR aszYourOldScheme[] = TEXT("Your Old Scheme");
|
|
STATIC TCHAR aszNone[] = TEXT("<none>");
|
|
STATIC TCHAR aszDummyDrv[] = TEXT("mmsystem.dll");
|
|
STATIC TCHAR aszDummySnd[] = TEXT("SystemDefault");
|
|
STATIC TCHAR aszDummySndValue[] = TEXT(",");
|
|
STATIC TCHAR aszExtendedSounds[] = TEXT("ExtendedSounds");
|
|
STATIC TCHAR aszExtendedSoundsYes[] = TEXT("yes");
|
|
|
|
STATIC TCHAR gszApp[] = TEXT("App");
|
|
STATIC TCHAR gszSystem[] = TEXT("System");
|
|
|
|
STATIC TCHAR gszAsterisk[] = TEXT("Asterisk");
|
|
STATIC TCHAR gszDefault[] = TEXT("Default");
|
|
STATIC TCHAR gszExclamation[] = TEXT("Exclamation");
|
|
STATIC TCHAR gszExit[] = TEXT("Exit");
|
|
STATIC TCHAR gszQuestion[] = TEXT("Question");
|
|
STATIC TCHAR gszStart[] = TEXT("Start");
|
|
STATIC TCHAR gszHand[] = TEXT("Hand");
|
|
|
|
STATIC TCHAR gszClose[] = TEXT("Close");
|
|
STATIC TCHAR gszMaximize[] = TEXT("Maximize");
|
|
STATIC TCHAR gszMinimize[] = TEXT("Minimize");
|
|
STATIC TCHAR gszOpen[] = TEXT("Open");
|
|
STATIC TCHAR gszRestoreDown[] = TEXT("RestoreDown");
|
|
STATIC TCHAR gszRestoreUp[] = TEXT("RestoreUp");
|
|
|
|
STATIC TCHAR aszOptionalClips[] = REGSTR_PATH_SETUP REGSTR_KEY_SETUP TEXT("\\OptionalComponents\\Clips");
|
|
STATIC TCHAR aszInstalled[] = TEXT("Installed");
|
|
|
|
STATIC TCHAR * gpszSounds[] = {
|
|
gszClose,
|
|
gszMaximize,
|
|
gszMinimize,
|
|
gszOpen,
|
|
gszRestoreDown,
|
|
gszRestoreUp,
|
|
gszAsterisk,
|
|
gszDefault,
|
|
gszExclamation,
|
|
gszExit,
|
|
gszQuestion,
|
|
gszStart,
|
|
gszHand
|
|
};
|
|
|
|
STATIC TCHAR aszMigration[] = TEXT("Migrated Schemes");
|
|
#define wCurrentSchemeMigrationLEVEL 1
|
|
|
|
static struct {
|
|
LPCTSTR pszEvent;
|
|
int idDescription;
|
|
LPCTSTR pszApp;
|
|
} gaEventLabels[] = {
|
|
{ TEXT("AppGPFault"), STR_LABEL_APPGPFAULT, aszDefault },
|
|
{ TEXT("Close"), STR_LABEL_CLOSE, aszDefault },
|
|
{ TEXT("EmptyRecycleBin"), STR_LABEL_EMPTYRECYCLEBIN, aszExplorer },
|
|
{ TEXT("Maximize"), STR_LABEL_MAXIMIZE, aszDefault },
|
|
{ TEXT("MenuCommand"), STR_LABEL_MENUCOMMAND, aszDefault },
|
|
{ TEXT("MenuPopup"), STR_LABEL_MENUPOPUP, aszDefault },
|
|
{ TEXT("Minimize"), STR_LABEL_MINIMIZE, aszDefault },
|
|
{ TEXT("Open"), STR_LABEL_OPEN, aszDefault },
|
|
{ TEXT("RestoreDown"), STR_LABEL_RESTOREDOWN, aszDefault },
|
|
{ TEXT("RestoreUp"), STR_LABEL_RESTOREUP, aszDefault },
|
|
{ TEXT("RingIn"), STR_LABEL_RINGIN, aszDefault },
|
|
{ TEXT("RingOut"), STR_LABEL_RINGOUT, aszDefault },
|
|
{ TEXT("SystemAsterisk"), STR_LABEL_SYSTEMASTERISK, aszDefault },
|
|
{ TEXT(".Default"), STR_LABEL_SYSTEMDEFAULT, aszDefault },
|
|
{ TEXT("SystemExclamation"), STR_LABEL_SYSTEMEXCLAMATION, aszDefault },
|
|
{ TEXT("SystemExit"), STR_LABEL_SYSTEMEXIT, aszDefault },
|
|
{ TEXT("SystemHand"), STR_LABEL_SYSTEMHAND, aszDefault },
|
|
{ TEXT("SystemQuestion"), STR_LABEL_SYSTEMQUESTION, aszDefault },
|
|
{ TEXT("SystemStart"), STR_LABEL_SYSTEMSTART, aszDefault },
|
|
};
|
|
|
|
TCHAR gszDefaultBeepOldAlias[] = TEXT("SystemDefault");
|
|
|
|
#define nEVENTLABELS (sizeof(gaEventLabels)/sizeof(gaEventLabels[0]))
|
|
|
|
STATIC TCHAR gszChimes[] = TEXT("chimes.wav");
|
|
STATIC TCHAR gszDing[] = TEXT("ding.wav");
|
|
STATIC TCHAR gszTada[] = TEXT("tada.wav");
|
|
STATIC TCHAR gszChord[] = TEXT("chord.wav");
|
|
|
|
STATIC TCHAR * gpszKnownWAVFiles[] = {
|
|
gszChord,
|
|
gszTada,
|
|
gszChimes,
|
|
gszDing,
|
|
};
|
|
|
|
#define INISECTION 768
|
|
#define BIGINISECTION 2048
|
|
TCHAR szNull[] = TEXT("");
|
|
TCHAR aszSetup[] = REGSTR_PATH_SETUP;
|
|
TCHAR aszValMedia[] = REGSTR_VAL_MEDIA;
|
|
TCHAR aszValMediaUnexpanded[] = TEXT("MediaPathUnexpanded");
|
|
|
|
extern HANDLE hInstalledDriverList; // List of installed driver instances
|
|
extern int cInstalledDrivers; // High water count of installed driver instances
|
|
|
|
/**************************************************************************
|
|
|
|
@doc EXTERNAL
|
|
|
|
@api BOOL | DllInstanceInit | This procedure is called whenever a
|
|
process attaches or detaches from the DLL.
|
|
|
|
@parm PVOID | hModule | Handle of the DLL.
|
|
|
|
@parm ULONG | Reason | What the reason for the call is.
|
|
|
|
@parm PCONTEXT | pContext | Some random other information.
|
|
|
|
@rdesc The return value is TRUE if the initialisation completed ok,
|
|
FALSE if not.
|
|
|
|
**************************************************************************/
|
|
|
|
BOOL DllInstanceInit(PVOID hModule, ULONG Reason, PCONTEXT pContext)
|
|
{
|
|
PIMAGE_NT_HEADERS NtHeaders; // For checking if we're in the
|
|
HANDLE hModWow32;
|
|
// server.
|
|
|
|
ghInst = (HANDLE) hModule;
|
|
|
|
DBG_UNREFERENCED_PARAMETER(pContext);
|
|
|
|
if (Reason == DLL_PROCESS_ATTACH) {
|
|
|
|
#if DBG
|
|
CHAR strname[MAX_PATH];
|
|
GetModuleFileNameA(NULL, strname, sizeof(strname));
|
|
dprintf2(("Process attaching, exe=%hs (Pid %x Tid %x)", strname, GetCurrentProcessId(), GetCurrentThreadId()));
|
|
#endif
|
|
|
|
//
|
|
// We don't need to know when threads start
|
|
//
|
|
|
|
DisableThreadLibraryCalls(hModule);
|
|
|
|
//
|
|
// Get access to the process heap. This is cheaper in terms of
|
|
// overall resource being chewed up than creating our own heap.
|
|
//
|
|
|
|
hHeap = RtlProcessHeap();
|
|
if (hHeap == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Find out if we're in WOW
|
|
//
|
|
if ( (hModWow32 = GetModuleHandleW( L"WOW32.DLL" )) != NULL ) {
|
|
WinmmRunningInWOW = TRUE;
|
|
|
|
GetVDMPointer =
|
|
(LPGETVDMPOINTER)GetProcAddress( hModWow32, "WOWGetVDMPointer");
|
|
lpWOWHandle32 =
|
|
(LPWOWHANDLE32)GetProcAddress( hModWow32, "WOWHandle32" );
|
|
lpWOWHandle16 =
|
|
(LPWOWHANDLE16)GetProcAddress( hModWow32, "WOWHandle16" );
|
|
}
|
|
else {
|
|
WinmmRunningInWOW = FALSE;
|
|
}
|
|
|
|
//
|
|
// Find out if we're in the server
|
|
//
|
|
|
|
NtHeaders = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress);
|
|
|
|
WinmmRunningInServer =
|
|
(NtHeaders->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_CUI) &&
|
|
(NtHeaders->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_GUI);
|
|
|
|
InitializeCriticalSection(&DriverListCritSec);
|
|
InitializeCriticalSection(&DriverLoadFreeCritSec);
|
|
InitializeCriticalSection(&MapperInitCritSec);
|
|
|
|
InitDebugLevel();
|
|
|
|
InitHandles();
|
|
|
|
mciInitCrit();
|
|
|
|
InitDevices();
|
|
|
|
// it is important that the MCI window initialisation is done AFTER
|
|
// we have initialised Wave, Midi, etc. devices. Note the server
|
|
// uses Wave devices, but nothing else (e.g. MCI, midi...)
|
|
|
|
if (!WinmmRunningInServer) {
|
|
mciGlobalInit();
|
|
} else {
|
|
InitializeCriticalSection(&mciGlobalCritSec);
|
|
}
|
|
|
|
InitializeCriticalSection(&WavHdrCritSec);
|
|
InitializeCriticalSection(&SoundCritSec);
|
|
InitializeCriticalSection(&midiStrmHdrCritSec);
|
|
|
|
|
|
} else if (Reason == DLL_PROCESS_DETACH) {
|
|
|
|
dprintf2(("Process ending (Pid %x Tid %x)", GetCurrentProcessId(), GetCurrentThreadId()));
|
|
|
|
if (!WinmmRunningInServer) {
|
|
TimeCleanup(0); // DLL cleanup
|
|
}
|
|
|
|
DeleteCriticalSection(&HandleListCritSec);
|
|
mciCleanup();
|
|
mmRegFree();
|
|
DeleteCriticalSection(&WavHdrCritSec);
|
|
DeleteCriticalSection(&SoundCritSec);
|
|
DeleteCriticalSection(&midiStrmHdrCritSec);
|
|
DeleteCriticalSection(&DriverListCritSec);
|
|
DeleteCriticalSection(&DriverLoadFreeCritSec);
|
|
DeleteCriticalSection(&MapperInitCritSec);
|
|
|
|
if (hInstalledDriverList)
|
|
{
|
|
GlobalFree ((HGLOBAL)hInstalledDriverList);
|
|
hInstalledDriverList = NULL;
|
|
cInstalledDrivers = 0; // Count of installed drivers
|
|
}
|
|
} else if (Reason == 999) {
|
|
// This is a dummy call to an entry point in ADVAPI32.DLL. By
|
|
// statically linking to the library we avoid the following:
|
|
// An application links to winmm.dll and advapi32.dll
|
|
// When the application loads the list of dependent dlls is built,
|
|
// and a list of the dll init routines is created. It happens
|
|
// that the winmm init routine is called first.
|
|
// IF there is a sound card in the system, winmm's dll init routine
|
|
// call LoadLibrary on the sound driver DLL. This DLL WILL
|
|
// reference advapi32.dll - and call entry points in advapi32.
|
|
// Unfortunately the init routine of advapi32.dll is marked as
|
|
// having RUN - although that is not yet the case as we are still
|
|
// within the load routine for winmm.
|
|
// When the advapi32 entry point runs, it relies on its init
|
|
// routine having completed; specifically a CriticalSection should
|
|
// have been initialised. This is not the case, and BOOM!
|
|
// The workaround is to ensure that advapi32.dll runs its init
|
|
// routine first. This is done by making sure that WINMM has a
|
|
// static link to the dll.
|
|
ImpersonateSelf(999); // This routine will never be called.
|
|
// If it is called, it will fail.
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL MMSYSTEM
|
|
*
|
|
* @api void | WOWAppExit | This function cleans up when a (WOW) application
|
|
* terminates.
|
|
*
|
|
* @parm HANDLE | hTask | Thread id of application (equivalent to windows task
|
|
* handle).
|
|
*
|
|
* @rdesc Nothing
|
|
*
|
|
* @comm Note that NOT ALL threads are WOW threads. We rely here on the
|
|
* fact that ONLY MCI creates threads other than WOW threads which
|
|
* use our low level device resources.
|
|
*
|
|
* Note also that once a thread is inside here no other threads can
|
|
* go through here so, since we clean up MCI devices first, their
|
|
* low level devices will be freed before we get to their threads.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void WOWAppExit(HANDLE hTask)
|
|
{
|
|
MCIDEVICEID DeviceID;
|
|
HANDLE h, hNext;
|
|
|
|
dprintf3(("WOW Multi-media - thread %x exiting", (UINT)hTask));
|
|
|
|
//
|
|
// Free MCI devices allocated by this task (thread).
|
|
//
|
|
|
|
EnterCriticalSection(&mciCritSec);
|
|
for (DeviceID=1; DeviceID < MCI_wNextDeviceID; DeviceID++)
|
|
{
|
|
|
|
if (MCI_VALID_DEVICE_ID(DeviceID) &&
|
|
MCI_lpDeviceList[DeviceID]->hCreatorTask == hTask)
|
|
{
|
|
//
|
|
// Note that the loop control variables are globals so will be
|
|
// reloaded on each iteration.
|
|
//
|
|
// Also no new devices will be opened by APPs because this is WOW
|
|
//
|
|
// Hence it's safe (and essential!) to leave the critical
|
|
// section which we send the close command
|
|
//
|
|
|
|
dprintf2(("MCI device %ls (%d) not released.", MCI_lpDeviceList[DeviceID]->lpstrInstallName, DeviceID));
|
|
LeaveCriticalSection(&mciCritSec);
|
|
mciSendCommandW(DeviceID, MCI_CLOSE, 0, 0);
|
|
EnterCriticalSection(&mciCritSec);
|
|
}
|
|
}
|
|
LeaveCriticalSection(&mciCritSec);
|
|
|
|
//
|
|
// Free any timers
|
|
//
|
|
|
|
TimeCleanup((DWORD)hTask);
|
|
|
|
//
|
|
// free all WAVE/MIDI/MMIO handles
|
|
//
|
|
|
|
EnterCriticalSection(&HandleListCritSec);
|
|
h = GetHandleFirst();
|
|
|
|
while (h)
|
|
{
|
|
hNext = GetHandleNext(h);
|
|
|
|
if (GetHandleOwner(h) == hTask)
|
|
{
|
|
HANDLE hdrvDestroy;
|
|
|
|
//
|
|
// hack for the wave/midi mapper, always free handles backward.
|
|
//
|
|
if (hNext && GetHandleOwner(hNext) == hTask) {
|
|
h = hNext;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// do this so even if the close fails we will not
|
|
// find it again.
|
|
//
|
|
SetHandleOwner(h, NULL);
|
|
|
|
//
|
|
// set the hdrvDestroy global so DriverCallback will not
|
|
// do anything for this device
|
|
//
|
|
hdrvDestroy = h;
|
|
|
|
switch(GetHandleType(h))
|
|
{
|
|
case TYPE_WAVEOUT:
|
|
dprintf1(("WaveOut handle (%04X) was not released.", h));
|
|
waveOutReset((HWAVEOUT)h);
|
|
waveOutClose((HWAVEOUT)h);
|
|
break;
|
|
|
|
case TYPE_WAVEIN:
|
|
dprintf1(("WaveIn handle (%04X) was not released.", h));
|
|
waveInReset((HWAVEIN)h);
|
|
waveInClose((HWAVEIN)h);
|
|
break;
|
|
|
|
case TYPE_MIDIOUT:
|
|
dprintf1(("MidiOut handle (%04X) was not released.", h));
|
|
midiOutReset((HMIDIOUT)h);
|
|
midiOutClose((HMIDIOUT)h);
|
|
break;
|
|
|
|
case TYPE_MIDIIN:
|
|
dprintf1(("MidiIn handle (%04X) was not released.", h));
|
|
midiInReset((HMIDIIN)h);
|
|
midiInClose((HMIDIIN)h);
|
|
break;
|
|
|
|
//
|
|
// This is not required because WOW does not open any
|
|
// mmio files.
|
|
//
|
|
// case TYPE_MMIO:
|
|
// dprintf1(("MMIO handle (%04X) was not released.", h));
|
|
// if (mmioClose((HMMIO)h, 0) != 0)
|
|
// mmioClose((HMMIO)h, MMIO_FHOPEN);
|
|
// break;
|
|
}
|
|
|
|
//
|
|
// unset hdrvDestroy so DriverCallback will work.
|
|
// some hosebag drivers (like the TIMER driver)
|
|
// may pass NULL as their driver handle.
|
|
// so dont set it to NULL.
|
|
//
|
|
hdrvDestroy = (HANDLE)-1;
|
|
|
|
//
|
|
// the reason we start over is because a single free may cause
|
|
// multiple free's (ie MIDIMAPPER has another HMIDI open, ...)
|
|
//
|
|
h = GetHandleFirst();
|
|
} else {
|
|
h = GetHandleNext(h);
|
|
}
|
|
}
|
|
LeaveCriticalSection(&HandleListCritSec);
|
|
|
|
//
|
|
// Clean up an installed IO procs for mmio
|
|
//
|
|
// This is not required because wow does not install any io procs.
|
|
//
|
|
// mmioCleanupIOProcs(hTask);
|
|
//
|
|
|
|
|
|
// If avicap32.dll is loaded, then ask it to clean up
|
|
// capture drivers
|
|
{
|
|
HMODULE hmod;
|
|
hmod = GetModuleHandle(TEXT("avicap32.dll"));
|
|
if (hmod) {
|
|
typedef void (*AppCleanupProc)(HANDLE);
|
|
AppCleanupProc fp;
|
|
|
|
fp = (AppCleanupProc) GetProcAddress(hmod, "AppCleanup");
|
|
if (fp) {
|
|
fp(hTask);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitHandles(void)
|
|
{
|
|
InitializeCriticalSection(&HandleListCritSec);
|
|
}
|
|
|
|
void FreeUnusedDrivers(PMMDRV pmmdrv, int NumberOfEntries)
|
|
{
|
|
int i;
|
|
for (i = 0; i < NumberOfEntries; i++) {
|
|
if (pmmdrv[i].hDriver != NULL) {
|
|
if (pmmdrv[i].bNumDevs == 0) {
|
|
|
|
DrvClose(pmmdrv[i].hDriver, 0, 0);
|
|
pmmdrv[i].hDriver = NULL;
|
|
pmmdrv[i].drvMessage = NULL;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern BOOL IMixerLoadDrivers( void );
|
|
void InitDevices(void)
|
|
{
|
|
|
|
WaveInit();
|
|
|
|
//
|
|
// The server only needs wave to do message beeps.
|
|
//
|
|
|
|
if (!WinmmRunningInServer) {
|
|
MidiInit();
|
|
if (!TimeInit()) {
|
|
dprintf1(("Failed to initialize timer services"));
|
|
}
|
|
midiEmulatorInit();
|
|
AuxInit();
|
|
JoyInit();
|
|
IMixerLoadDrivers();
|
|
|
|
//
|
|
// Clear up any drivers which don't have any devices (we do it this
|
|
// way so we don't keep loading and unloading mmdrv.dll).
|
|
//
|
|
// Note - we only load the mappers if there are real devices so we
|
|
// don't need to worry about unloading them.
|
|
//
|
|
|
|
FreeUnusedDrivers(waveindrv, MAXWAVEDRIVERS);
|
|
FreeUnusedDrivers(midioutdrv, MAXMIDIDRIVERS);
|
|
FreeUnusedDrivers(midiindrv, MAXMIDIDRIVERS);
|
|
FreeUnusedDrivers(auxdrv, MAXAUXDRIVERS);
|
|
}
|
|
FreeUnusedDrivers(waveoutdrv, MAXWAVEDRIVERS);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL MMSYSTEM
|
|
*
|
|
* @api UINT | mmsystemGetVersion | This function returns the current
|
|
* version number of the Multimedia extensions system software.
|
|
*
|
|
* @rdesc The return value specifies the major and minor version numbers of
|
|
* the Multimedia extensions. The high-order byte specifies the major
|
|
* version number. The low-order byte specifies the minor version number.
|
|
*
|
|
****************************************************************************/
|
|
UINT APIENTRY mmsystemGetVersion(void)
|
|
{
|
|
return(MMSYSTEM_VERSION);
|
|
}
|
|
|
|
|
|
#define MAXDRIVERORDINAL 9
|
|
|
|
/****************************************************************************
|
|
|
|
strings
|
|
|
|
****************************************************************************/
|
|
|
|
STATICDT SZCODE szWodMessage[] = WOD_MESSAGE;
|
|
STATICDT SZCODE szWidMessage[] = WID_MESSAGE;
|
|
STATICDT SZCODE szModMessage[] = MOD_MESSAGE;
|
|
STATICDT SZCODE szMidMessage[] = MID_MESSAGE;
|
|
STATICDT SZCODE szAuxMessage[] = AUX_MESSAGE;
|
|
|
|
STATICDT WSZCODE wszWave[] = L"wave";
|
|
STATICDT WSZCODE wszMidi[] = L"midi";
|
|
STATICDT WSZCODE wszAux[] = L"aux";
|
|
STATICDT WSZCODE wszMidiMapper[]= L"midimapper";
|
|
STATICDT WSZCODE wszWaveMapper[]= L"wavemapper";
|
|
STATICDT WSZCODE wszAuxMapper[] = L"auxmapper";
|
|
|
|
WSZCODE wszNull[] = L"";
|
|
WSZCODE wszSystemIni[] = L"system.ini";
|
|
WSZCODE wszDrivers[] = DRIVERS_SECTION;
|
|
|
|
/*
|
|
** WaveMapperInit
|
|
**
|
|
** Initialize the wave mapper if it's not already initialized.
|
|
**
|
|
*/
|
|
BOOL WaveMapperInitialized = FALSE;
|
|
void WaveMapperInit(void)
|
|
{
|
|
HDRVR h;
|
|
|
|
EnterCriticalSection(&MapperInitCritSec);
|
|
|
|
if (WaveMapperInitialized) {
|
|
LeaveCriticalSection(&MapperInitCritSec);
|
|
return;
|
|
}
|
|
|
|
/* The wave mapper.
|
|
*
|
|
* MMSYSTEM allows the user to install a special wave driver which is
|
|
* not visible to the application as a physical device (it is not
|
|
* included in the number returned from getnumdevs).
|
|
*
|
|
* An application opens the wave mapper when it does not care which
|
|
* physical device is used to input or output waveform data. Thus
|
|
* it is the wave mapper's task to select a physical device that can
|
|
* render the application-specified waveform format or to convert the
|
|
* data into a format that is renderable by an available physical
|
|
* device.
|
|
*/
|
|
|
|
if (wTotalWaveInDevs + wTotalWaveOutDevs > 0)
|
|
{
|
|
if (0 != (h = mmDrvOpen(wszWaveMapper)))
|
|
{
|
|
mmDrvInstall(h, wszWaveMapper, NULL, MMDRVI_MAPPER|MMDRVI_WAVEOUT|MMDRVI_HDRV);
|
|
|
|
if (!WinmmRunningInServer) {
|
|
h = mmDrvOpen(wszWaveMapper);
|
|
mmDrvInstall(h, wszWaveMapper, NULL, MMDRVI_MAPPER|MMDRVI_WAVEIN |MMDRVI_HDRV);
|
|
}
|
|
}
|
|
}
|
|
|
|
WaveMapperInitialized = TRUE;
|
|
|
|
LeaveCriticalSection(&MapperInitCritSec);
|
|
}
|
|
|
|
/*
|
|
** MidiMapperInit
|
|
**
|
|
** Initialize the MIDI mapper if it's not already initialized.
|
|
**
|
|
*/
|
|
void MidiMapperInit(void)
|
|
{
|
|
static BOOL MidiMapperInitialized = FALSE;
|
|
HDRVR h;
|
|
|
|
EnterCriticalSection(&MapperInitCritSec);
|
|
|
|
if (MidiMapperInitialized) {
|
|
LeaveCriticalSection(&MapperInitCritSec);
|
|
return;
|
|
}
|
|
|
|
/* The midi mapper.
|
|
*
|
|
* MMSYSTEM allows the user to install a special midi driver which is
|
|
* not visible to the application as a physical device (it is not
|
|
* included in the number returned from getnumdevs).
|
|
*
|
|
* An application opens the midi mapper when it does not care which
|
|
* physical device is used to input or output midi data. It
|
|
* is the midi mapper's task to modify the midi data so that it is
|
|
* suitable for playback on the connected synthesizer hardware.
|
|
*/
|
|
|
|
if (wTotalMidiInDevs + wTotalMidiOutDevs > 0)
|
|
{
|
|
if (0 != (h = mmDrvOpen(wszMidiMapper)))
|
|
{
|
|
mmDrvInstall(h, wszMidiMapper, NULL, MMDRVI_MAPPER|MMDRVI_MIDIOUT|MMDRVI_HDRV);
|
|
|
|
h = mmDrvOpen(wszMidiMapper);
|
|
mmDrvInstall(h, wszMidiMapper, NULL, MMDRVI_MAPPER|MMDRVI_MIDIIN |MMDRVI_HDRV);
|
|
}
|
|
}
|
|
|
|
MidiMapperInitialized = TRUE;
|
|
|
|
LeaveCriticalSection(&MapperInitCritSec);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc INTERNAL WAVE
|
|
*
|
|
* @api BOOL | WaveInit | This function initialises the wave services.
|
|
*
|
|
* @rdesc Returns TRUE if the services of all loaded wave drivers are
|
|
* correctly initialised, FALSE if an error occurs.
|
|
*
|
|
* @comm the wave devices are loaded in the following order
|
|
*
|
|
* \Device\WaveIn0
|
|
* \Device\WaveIn1
|
|
* \Device\WaveIn2
|
|
* \Device\WaveIn3
|
|
*
|
|
****************************************************************************/
|
|
BOOL WaveInit(void)
|
|
{
|
|
WCHAR szKey[ (sizeof(wszWave) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
|
|
int i;
|
|
HDRVR h;
|
|
|
|
// Find the real WAVE drivers
|
|
|
|
lstrcpyW(szKey, wszWave);
|
|
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
|
|
for (i=0; i<=MAXDRIVERORDINAL; i++)
|
|
{
|
|
h = mmDrvOpen(szKey);
|
|
if (h)
|
|
{
|
|
mmDrvInstall(h, szKey, NULL, MMDRVI_WAVEOUT|MMDRVI_HDRV);
|
|
|
|
if (!WinmmRunningInServer) {
|
|
h = mmDrvOpen(szKey);
|
|
mmDrvInstall(h, szKey, NULL, MMDRVI_WAVEIN |MMDRVI_HDRV);
|
|
}
|
|
}
|
|
szKey[ (sizeof(wszWave) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
|
|
}
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc INTERNAL MIDI
|
|
*
|
|
* @api BOOL | MidiInit | This function initialises the midi services.
|
|
*
|
|
* @rdesc The return value is TRUE if the services are initialised, FALSE if
|
|
* an error occurs
|
|
*
|
|
* @comm the midi devices are loaded from SYSTEM.INI in the following order
|
|
*
|
|
* midi
|
|
* midi1
|
|
* midi2
|
|
* midi3
|
|
*
|
|
****************************************************************************/
|
|
BOOL MidiInit(void)
|
|
{
|
|
WCHAR szKey[ (sizeof(wszMidi) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
|
|
int i;
|
|
HDRVR h;
|
|
|
|
// Find the real MIDI drivers
|
|
|
|
lstrcpyW(szKey, wszMidi);
|
|
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
|
|
for (i=0; i<=MAXDRIVERORDINAL; i++)
|
|
{
|
|
h = mmDrvOpen(szKey);
|
|
if (h)
|
|
{
|
|
mmDrvInstall(h, szKey, NULL, MMDRVI_MIDIOUT|MMDRVI_HDRV);
|
|
|
|
h = mmDrvOpen(szKey);
|
|
mmDrvInstall(h, szKey, NULL, MMDRVI_MIDIIN |MMDRVI_HDRV);
|
|
}
|
|
|
|
szKey[ (sizeof(wszMidi) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc INTERNAL AUX
|
|
*
|
|
* @api BOOL | AuxInit | This function initialises the auxiliary output
|
|
* services.
|
|
*
|
|
* @rdesc The return value is TRUE if the services are initialised, FALSE if
|
|
* an error occurs
|
|
*
|
|
* @comm SYSTEM.INI is searched for auxn.drv=.... where n can be from 1 to 4.
|
|
* Each driver is loaded and the number of devices it supports is read
|
|
* from it.
|
|
*
|
|
* AUX devices are loaded from SYSTEM.INI in the following order
|
|
*
|
|
* aux
|
|
* aux1
|
|
* aux2
|
|
* aux3
|
|
*
|
|
****************************************************************************/
|
|
BOOL AuxInit(void)
|
|
{
|
|
WCHAR szKey[ (sizeof(wszAux) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
|
|
int i;
|
|
HDRVR h;
|
|
|
|
// Find the real Aux drivers
|
|
|
|
lstrcpyW(szKey, wszAux);
|
|
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
|
|
for (i=0; i<=MAXDRIVERORDINAL; i++)
|
|
{
|
|
h = mmDrvOpen(szKey);
|
|
if (h)
|
|
{
|
|
mmDrvInstall(h, szKey, NULL, MMDRVI_AUX|MMDRVI_HDRV);
|
|
}
|
|
|
|
// advance driver ordinal
|
|
szKey[ (sizeof(wszAux) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
|
|
}
|
|
|
|
/* The aux mapper.
|
|
*
|
|
* MMSYSTEM allows the user to install a special aux driver which is
|
|
* not visible to the application as a physical device (it is not
|
|
* included in the number returned from getnumdevs).
|
|
*
|
|
* I'm not sure why anyone would do this but I'll provide the
|
|
* capability for symmetry.
|
|
*
|
|
*/
|
|
|
|
if (wTotalAuxDevs > 0)
|
|
{
|
|
h = mmDrvOpen(wszAuxMapper);
|
|
if (h)
|
|
{
|
|
mmDrvInstall(h, wszAuxMapper, NULL, MMDRVI_MAPPER|MMDRVI_AUX|MMDRVI_HDRV);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @api HANDLE | mmDrvOpen | This function load's an installable driver, but
|
|
* first checks weather it exists in the [Drivers] section.
|
|
*
|
|
* @parm LPSTR | szAlias | driver alias to load
|
|
*
|
|
* @rdesc The return value is return value from DrvOpen or NULL if the alias
|
|
* was not found in the [Drivers] section.
|
|
*
|
|
****************************************************************************/
|
|
|
|
HANDLE mmDrvOpen(LPWSTR szAlias)
|
|
{
|
|
WCHAR buf[300]; // Make this large to bypass GetPrivate... bug
|
|
|
|
if ( winmmGetPrivateProfileString( wszDrivers,
|
|
szAlias,
|
|
wszNull,
|
|
buf,
|
|
sizeof(buf) / sizeof(WCHAR),
|
|
wszSystemIni) ) {
|
|
return (HANDLE)DrvOpen(szAlias, NULL, 0L);
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* @doc INTERNAL
|
|
*
|
|
* @api HANDLE | mmDrvInstall | This function installs/removes a WAVE/MIDI driver
|
|
*
|
|
* @parm HANDLE | hDriver | Module handle or driver handle containing driver
|
|
*
|
|
* @parm WCHAR * | wszDrvEntry | String corresponding to hDriver to be stored for
|
|
* later use
|
|
*
|
|
* @parm DRIVERMSGPROC | drvMessage | driver message procedure, if NULL
|
|
* the standard name will be used (looked for with GetProcAddress)
|
|
*
|
|
* @parm UINT | wFlags | flags
|
|
*
|
|
* @flag MMDRVI_TYPE | driver type mask
|
|
* @flag MMDRVI_WAVEIN | install driver as a wave input driver
|
|
* @flag MMDRVI_WAVEOUT | install driver as a wave ouput driver
|
|
* @flag MMDRVI_MIDIIN | install driver as a midi input driver
|
|
* @flag MMDRVI_MIDIOUT | install driver as a midi output driver
|
|
* @flag MMDRVI_AUX | install driver as a aux driver
|
|
*
|
|
* @flag MMDRVI_MAPPER | install this driver as the mapper
|
|
* @flag MMDRVI_HDRV | hDriver is a installable driver
|
|
* @flag MMDRVI_REMOVE | remove the driver
|
|
*
|
|
* @rdesc returns NULL if unable to install driver
|
|
*
|
|
****************************************************************************/
|
|
|
|
UINT APIENTRY mmDrvInstall(
|
|
HANDLE hDriver,
|
|
WCHAR * wszDrvEntry,
|
|
DRIVERMSGPROC drvMessage,
|
|
UINT wFlags
|
|
)
|
|
{
|
|
#define SZ_SIZE 128
|
|
|
|
int i;
|
|
DWORD dw;
|
|
PMMDRV pdrv;
|
|
HANDLE hModule;
|
|
int max_drivers;
|
|
UINT msg_num_devs;
|
|
UINT *pTotalDevs;
|
|
CHAR *szMessage;
|
|
WCHAR sz[SZ_SIZE];
|
|
|
|
if (hDriver && (wFlags & MMDRVI_HDRV))
|
|
{
|
|
hModule = DrvGetModuleHandle(hDriver);
|
|
}
|
|
else
|
|
{
|
|
hModule = hDriver;
|
|
hDriver = NULL;
|
|
}
|
|
|
|
switch (wFlags & MMDRVI_TYPE)
|
|
{
|
|
case MMDRVI_WAVEOUT:
|
|
pdrv = (PMMDRV)waveoutdrv;
|
|
max_drivers = MAXWAVEDRIVERS;
|
|
msg_num_devs = WODM_GETNUMDEVS;
|
|
pTotalDevs = &wTotalWaveOutDevs;
|
|
szMessage = szWodMessage;
|
|
break;
|
|
|
|
case MMDRVI_WAVEIN:
|
|
pdrv = (PMMDRV)waveindrv;
|
|
max_drivers = MAXWAVEDRIVERS;
|
|
msg_num_devs = WIDM_GETNUMDEVS;
|
|
pTotalDevs = &wTotalWaveInDevs;
|
|
szMessage = szWidMessage;
|
|
break;
|
|
|
|
case MMDRVI_MIDIOUT:
|
|
pdrv = (PMMDRV)midioutdrv;
|
|
max_drivers = MAXMIDIDRIVERS;
|
|
msg_num_devs = MODM_GETNUMDEVS;
|
|
pTotalDevs = &wTotalMidiOutDevs;
|
|
szMessage = szModMessage;
|
|
break;
|
|
|
|
case MMDRVI_MIDIIN:
|
|
pdrv = (PMMDRV)midiindrv;
|
|
max_drivers = MAXMIDIDRIVERS;
|
|
msg_num_devs = MIDM_GETNUMDEVS;
|
|
pTotalDevs = &wTotalMidiInDevs;
|
|
szMessage = szMidMessage;
|
|
break;
|
|
|
|
case MMDRVI_AUX:
|
|
pdrv = (PMMDRV)auxdrv;
|
|
max_drivers = MAXAUXDRIVERS;
|
|
msg_num_devs = AUXDM_GETNUMDEVS;
|
|
pTotalDevs = &wTotalAuxDevs;
|
|
szMessage = szAuxMessage;
|
|
break;
|
|
|
|
default:
|
|
goto error_exit;
|
|
}
|
|
|
|
if (drvMessage == NULL && hModule != NULL)
|
|
drvMessage = (DRIVERMSGPROC)GetProcAddress(hModule, szMessage);
|
|
|
|
if (drvMessage == NULL)
|
|
goto error_exit;
|
|
|
|
#if 0
|
|
//
|
|
// either install or remove the specified driver
|
|
//
|
|
if (wFlags & MMDRVI_REMOVE)
|
|
{
|
|
//
|
|
// try to find the driver, search to max_drivers+1 so we find the
|
|
// mapper too.
|
|
//
|
|
for (i=0; i<max_drivers+1 && pdrv[i].drvMessage != drvMessage; i++)
|
|
;
|
|
|
|
//
|
|
// we did not find it!
|
|
//
|
|
if (i==max_drivers+1)
|
|
goto error_exit; // not found
|
|
|
|
//
|
|
// we need to check if any outstanding handles are open on
|
|
// this device, if there are we cant unload it!
|
|
//
|
|
if (pdrv[i].bUsage > 0)
|
|
goto error_exit; // in use
|
|
|
|
//
|
|
// dont decrement number of dev's for the mapper
|
|
//
|
|
if (i != max_drivers)
|
|
*pTotalDevs -= pdrv[i].bNumDevs;
|
|
|
|
//
|
|
// unload the driver if we loaded it in the first place
|
|
//
|
|
if (pdrv[i].hDriver)
|
|
DrvClose(pdrv[i].hDriver, 0, 0);
|
|
|
|
pdrv[i].drvMessage = NULL;
|
|
pdrv[i].hDriver = NULL;
|
|
pdrv[i].bNumDevs = 0;
|
|
pdrv[i].bUsage = 0;
|
|
pdrv[i].wszDrvEntry[0] = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
#endif // 0
|
|
{
|
|
//
|
|
// try to find the driver already installed
|
|
//
|
|
for (i=0; i<max_drivers+1 && pdrv[i].drvMessage != drvMessage; i++)
|
|
;
|
|
|
|
if (i!=max_drivers+1) // we found it, dont re-install it!
|
|
goto error_exit;
|
|
|
|
//
|
|
// Find a slot the the device, if we are installing a 'MAPPER' place
|
|
// it in the last slot.
|
|
//
|
|
if (wFlags & MMDRVI_MAPPER)
|
|
{
|
|
i = max_drivers;
|
|
|
|
//
|
|
// don't allow more than one mapper
|
|
//
|
|
if (pdrv[i].drvMessage)
|
|
goto error_exit;
|
|
}
|
|
else
|
|
{
|
|
for (i=0; i<max_drivers && pdrv[i].drvMessage != NULL; i++)
|
|
;
|
|
|
|
if (i==max_drivers)
|
|
goto error_exit;
|
|
}
|
|
|
|
//
|
|
// call driver to get num-devices it supports
|
|
//
|
|
dw = drvMessage(0,msg_num_devs,0L,0L,0L);
|
|
|
|
//
|
|
// the device returned a error, or has no devices
|
|
//
|
|
// if (HIWORD(dw) != 0 || LOWORD(dw) == 0)
|
|
if (HIWORD(dw) != 0)
|
|
goto error_exit;
|
|
|
|
pdrv[i].hDriver = hDriver;
|
|
pdrv[i].bNumDevs = (BYTE)LOWORD(dw);
|
|
pdrv[i].bUsage = 0;
|
|
pdrv[i].drvMessage = drvMessage;
|
|
|
|
winmmGetPrivateProfileString(wszDrivers, // ini section
|
|
wszDrvEntry, // key name
|
|
wszDrvEntry, // default if no match
|
|
sz, // return buffer
|
|
SZ_SIZE, // sizeof of return buffer
|
|
wszSystemIni); // ini. file
|
|
|
|
lstrcpyW(pdrv[i].wszDrvEntry,sz);
|
|
|
|
//
|
|
// dont increment number of dev's for the mapper
|
|
//
|
|
if (i != max_drivers)
|
|
*pTotalDevs += pdrv[i].bNumDevs;
|
|
|
|
return (BOOL)(i+1); // return a non-zero value
|
|
}
|
|
|
|
error_exit:
|
|
if (hDriver && !(wFlags & MMDRVI_REMOVE))
|
|
DrvClose(hDriver, 0, 0);
|
|
|
|
return FALSE;
|
|
|
|
#undef SZ_SIZE
|
|
}
|
|
|
|
/*
|
|
*************************************************************************
|
|
* MigrateSoundEvents
|
|
*
|
|
* Description:
|
|
* Looks at the sounds section in win.ini for sound entries.
|
|
* Gets a current scheme name from the current section in control.ini
|
|
* Failing that it tries to find the current scheme in the registry
|
|
* Failing that it uses .default as the current scheme.
|
|
* Copies each of the entries in the win.ini sound section into the
|
|
* registry under the scheme name obtained
|
|
* If the scheme name came from control.ini, it creates a key from the
|
|
* scheme name. This key is created by removing all the existing spaces
|
|
* in the scheme name. This key and scheme name is added to the registry
|
|
*
|
|
*************************************************************************
|
|
*/
|
|
void MigrateSoundEvents (void)
|
|
{
|
|
LPTSTR szSectionBuf;
|
|
TCHAR aszEvent[SCH_TYPE_MAX_LENGTH];
|
|
BOOL fPrimaryMigration = FALSE;
|
|
|
|
szSectionBuf = (LPTSTR)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, INISECTION * sizeof(TCHAR));
|
|
if (!szSectionBuf)
|
|
return;
|
|
|
|
// If a MediaPathUnexpanded key exists (it will be something
|
|
// like "%SystemRoot%\Media"), expand it into a fully-qualified
|
|
// path and write out a matching MediaPath key (which will look
|
|
// like "c:\win\media"). This is done every time we enter the
|
|
// migration path, whether or not there's anything else to do.
|
|
//
|
|
// Setup would like to write the MediaPath key with the
|
|
// "%SystemRoot%" crap still in it--but while we could touch
|
|
// our apps to understand expansion, any made-for-Win95 apps
|
|
// probably wouldn't think to expand the string, and so wouldn't
|
|
// work properly. Instead, it writes the MediaPathUnexpanded
|
|
// key, and we make sure that the MediaPath key is kept up-to-date
|
|
// in the event that the Windows drive gets remapped (isn't
|
|
// NT cool that way?).
|
|
//
|
|
if (mmRegQueryMachineValue (aszSetup, aszValMediaUnexpanded,
|
|
cchLENGTH(aszEvent), aszEvent))
|
|
{
|
|
WCHAR szExpanded[MAX_PATH];
|
|
|
|
ExpandEnvironmentStrings (aszEvent, szExpanded, cchLENGTH(szExpanded));
|
|
mmRegSetMachineValue (aszSetup, aszValMedia, szExpanded);
|
|
}
|
|
|
|
// If there exists an event label for "SystemDefault", delete it.
|
|
//
|
|
// Also, if the key AppEvents\Schemes\Apps\.Default\SystemDefault
|
|
// exists, delete it.
|
|
//
|
|
wsprintf (aszEvent, asz3Format,
|
|
gszAppEventsKey, aszSchemeLabelsKey, gszDefaultBeepOldAlias);
|
|
|
|
if (mmRegQueryUserKey (aszEvent)) // AppEvents\EventLabels\SystemDefault
|
|
mmRegDeleteUserKey (aszEvent);
|
|
|
|
wsprintf (aszEvent, asz4Format, gszSchemesRootKey, gszSchemeAppsKey,
|
|
aszDefault, gszDefaultBeepOldAlias);
|
|
|
|
if (mmRegQueryUserKey (aszEvent)) // ApEvts\Schemes\Apps\.Def\SystemDefault
|
|
mmRegDeleteUserKey (aszEvent);
|
|
|
|
// mmRegCreateUserKey doesn't work unless the parent path already
|
|
// exists, so we have to create the basic tree structure up-front.
|
|
//
|
|
// Create AppEvents
|
|
// Create AppEvents\EventLabels
|
|
// Create AppEvents\Schemes
|
|
// Create AppEvents\Schemes\Apps
|
|
// Create AppEvents\Schemes\Names
|
|
//
|
|
if (!mmRegCreateUserKey (NULL, gszAppEventsKey))
|
|
return;
|
|
|
|
if (!mmRegCreateUserKey (gszAppEventsKey, aszSchemeLabelsKey))
|
|
return;
|
|
|
|
if (!mmRegCreateUserKey (gszAppEventsKey, gszJustSchemesKey))
|
|
return;
|
|
|
|
if (!mmRegCreateUserKey (gszSchemesRootKey, gszSchemeAppsKey))
|
|
return;
|
|
|
|
if (!mmRegCreateUserKey (gszSchemesRootKey, aszSchemeNamesKey))
|
|
return;
|
|
|
|
// Go through CONTROL.INI's SoundSchemes section, and migrate
|
|
// any schemes we find there.
|
|
//
|
|
if (GetPrivateProfileString (aszSchemesSection, NULL, szNull,
|
|
szSectionBuf, INISECTION, aszControlINI))
|
|
{
|
|
LPTSTR szKey;
|
|
|
|
for (szKey = szSectionBuf; *szKey; szKey += lstrlen(szKey) + 1)
|
|
{
|
|
if (lstrcmpi(szKey, aszYourOldScheme))
|
|
{
|
|
TCHAR aszScheme[SCH_TYPE_MAX_LENGTH];
|
|
TCHAR aszSchemeID[SCH_TYPE_MAX_LENGTH];
|
|
|
|
wsprintf (aszScheme, gszSoundScheme, szKey);
|
|
mregCreateSchemeID (aszScheme, aszSchemeID);
|
|
mregAddIniScheme (aszScheme, aszSchemeID, szKey, aszControlINI);
|
|
|
|
// Erase the entry from the schemes section once
|
|
// it has been migrated
|
|
//
|
|
WritePrivateProfileString (aszSchemesSection,
|
|
szKey, NULL,
|
|
aszControlINI);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( (!GetPrivateProfileString (aszSoundsSection, aszDummySnd, szNull,
|
|
aszEvent, cchLENGTH(aszEvent), aszWinINI)) ||
|
|
(lstrcmp (aszEvent, aszDummySndValue)) ||
|
|
(aszEvent[ lstrlen(aszEvent)+1 ] != TEXT('\0')) )
|
|
{
|
|
TCHAR aszKey[164];
|
|
TCHAR aszAppName[164];
|
|
|
|
mregAddIniScheme (aszSoundsSection, aszCurrent, NULL, aszWinINI);
|
|
|
|
// Make the current scheme be the one we just added (".Current")
|
|
//
|
|
mmRegSetUserValue (gszSchemesRootKey, NULL, aszCurrent);
|
|
|
|
// Make the name of the ".Default" application be "Windows":
|
|
//
|
|
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
|
|
|
|
if (mmRegCreateUserKey (aszKey, aszDefault))
|
|
{
|
|
wsprintf(aszKey, asz3Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey, aszDefault);
|
|
|
|
LoadString (ghInst, STR_WINDOWS_APP_NAME,
|
|
aszAppName, cchLENGTH(aszAppName));
|
|
mmRegSetUserValue (aszKey, NULL, aszAppName);
|
|
}
|
|
|
|
// Make the name of the "Explorer" application be
|
|
// "Windows Explorer":
|
|
//
|
|
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
|
|
|
|
if (mmRegCreateUserKey (aszKey, aszExplorer))
|
|
{
|
|
wsprintf(aszKey, asz3Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey, aszExplorer);
|
|
|
|
LoadString (ghInst, STR_EXPLORER_APP_NAME,
|
|
aszAppName, cchLENGTH(aszAppName));
|
|
mmRegSetUserValue (aszKey, NULL, aszAppName);
|
|
}
|
|
|
|
// Remove current sounds section and add a blank entry
|
|
// to make silly apps work which really need to have
|
|
// this section here.
|
|
//
|
|
WritePrivateProfileString (aszSoundsSection,
|
|
NULL, NULL,
|
|
aszWinINI);
|
|
WritePrivateProfileString (aszSoundsSection,
|
|
aszDummySnd, aszDummySndValue,
|
|
aszWinINI);
|
|
|
|
fPrimaryMigration = TRUE;
|
|
}
|
|
|
|
// If there's no "Migrated Schemes" key, or if its value it
|
|
// describes is < the "current migration level", then we'll
|
|
// need to ensure that all currently-migrated schemes mention
|
|
// each of the known sound events (from gaEventLabels), and
|
|
// that the EventLabels keys are filled out. Note that we'll
|
|
// also do this if we just migrated something for the .Current
|
|
// scheme (above).
|
|
//
|
|
if (!mmRegQueryUserValue (gszAppEventsKey, aszMigration,
|
|
cchLENGTH( aszEvent ), aszEvent))
|
|
{
|
|
fPrimaryMigration = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LONG wInReg = 0;
|
|
TCHAR *pch;
|
|
|
|
for (pch = aszEvent; *pch >= TEXT('0') && *pch <= TEXT('9'); ++pch)
|
|
{
|
|
wInReg *= 10;
|
|
wInReg += (LONG)( *(pch) - TEXT('0') );
|
|
}
|
|
|
|
if (wInReg < wCurrentSchemeMigrationLEVEL)
|
|
{
|
|
fPrimaryMigration = TRUE;
|
|
}
|
|
}
|
|
|
|
if (fPrimaryMigration)
|
|
{
|
|
TCHAR aszKeyParent[SCH_TYPE_MAX_LENGTH];
|
|
TCHAR aszKey[SCH_TYPE_MAX_LENGTH];
|
|
short iEventLabel;
|
|
|
|
// First ensure that all EventLabels exist
|
|
//
|
|
wsprintf (aszKeyParent, asz2Format, gszAppEventsKey, aszSchemeLabelsKey);
|
|
|
|
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
|
|
{
|
|
if (mmRegCreateUserKey (aszKeyParent,
|
|
gaEventLabels[ iEventLabel ].pszEvent))
|
|
{
|
|
wsprintf (aszKey, asz3Format,
|
|
gszAppEventsKey,
|
|
aszSchemeLabelsKey,
|
|
gaEventLabels[ iEventLabel ].pszEvent);
|
|
|
|
LoadString (ghInst, gaEventLabels[ iEventLabel ].idDescription,
|
|
aszEvent, cchLENGTH(aszEvent));
|
|
|
|
mmRegSetUserValue (aszKey, NULL, aszEvent);
|
|
}
|
|
}
|
|
|
|
// Then ensure that the ExtendedSounds key exists; if not,
|
|
// add it and make it say "yes" (so the shell will issue reqs
|
|
// for the new-for-Win95 events)
|
|
//
|
|
wsprintf (aszKeyParent, asz2Format, gszControlPanel, aszSoundSection);
|
|
|
|
if (!mmRegQueryUserValue (aszKeyParent, aszExtendedSounds,
|
|
cchLENGTH( aszEvent ), aszEvent))
|
|
{
|
|
if (mmRegCreateUserKey (gszControlPanel, aszSoundSection))
|
|
{
|
|
mmRegSetUserValue (aszKeyParent,
|
|
aszExtendedSounds,
|
|
aszExtendedSoundsYes);
|
|
}
|
|
}
|
|
|
|
// Then ensure that the appropriate app (.Default or Explorer),
|
|
// for the .Current scheme, has any entry for each of the known
|
|
// events; if we have to create a new entry, don't give it a
|
|
// sound.
|
|
//
|
|
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
|
|
{
|
|
// Does AppEvents\Schemes\Apps\{app}\{event}\.Current
|
|
// have an entry? If not, we need to fill out this key
|
|
// some.
|
|
//
|
|
wsprintf (aszKeyParent, asz5Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp,
|
|
gaEventLabels[ iEventLabel ].pszEvent,
|
|
aszCurrent);
|
|
|
|
if (mmRegQueryUserValue (aszKeyParent, NULL,
|
|
cchLENGTH( aszEvent ), aszEvent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, create the key:
|
|
// AppEvents\Schemes\Apps\{app}
|
|
//
|
|
wsprintf (aszKeyParent, asz2Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey);
|
|
|
|
if (!mmRegCreateUserKey (aszKeyParent,
|
|
gaEventLabels[ iEventLabel ].pszApp))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Create the key:
|
|
// AppEvents\Schemes\Apps\{app}\{event}
|
|
//
|
|
wsprintf (aszKeyParent, asz3Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp);
|
|
|
|
if (!mmRegCreateUserKey (aszKeyParent,
|
|
gaEventLabels[ iEventLabel ].pszEvent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Create the key:
|
|
// AppEvents\Schemes\Apps\{app}\{event}\.Current
|
|
//
|
|
wsprintf (aszKeyParent, asz4Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp,
|
|
gaEventLabels[ iEventLabel ].pszEvent);
|
|
|
|
if (!mmRegCreateUserKey (aszKeyParent, aszCurrent))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Give a value of "" to the key:
|
|
// AppEvents\Schemes\Apps\{app}\{event}\.Current
|
|
//
|
|
wsprintf (aszKeyParent, asz5Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp,
|
|
gaEventLabels[ iEventLabel ].pszEvent,
|
|
aszCurrent);
|
|
|
|
mmRegSetUserValue (aszKeyParent, NULL, TEXT(""));
|
|
}
|
|
|
|
// Record the fact that we're now up-to-date WRT migration.
|
|
//
|
|
wsprintf (aszEvent, TEXT("%lu"), (long)wCurrentSchemeMigrationLEVEL);
|
|
mmRegSetUserValue (gszAppEventsKey, aszMigration, aszEvent);
|
|
}
|
|
|
|
|
|
LocalFree ((HLOCAL)szSectionBuf);
|
|
}
|
|
|
|
/*==========================================================================*/
|
|
/*
|
|
* Description:
|
|
* Parse the inf line containing the event entry
|
|
* The 0th entry is the keyname for the event
|
|
* The 1st entry is the full or relative path name of the file related
|
|
* to the event
|
|
* The 2nd entry is the printable name of the event
|
|
* Once the line is parsed, the file name associated with the event is
|
|
* added to the registry
|
|
* EventKey
|
|
* |
|
|
* ---SchemeKey = FileName
|
|
*
|
|
* The printable event name is added to the registry as follows
|
|
* EventLabels
|
|
* |
|
|
* ---EventKey = Printable Event Name
|
|
*/
|
|
STATIC void NEAR PASCAL mregAddIniScheme(LPTSTR lszSection,
|
|
LPTSTR lszSchemeID,
|
|
LPTSTR lszSchemeName,
|
|
LPTSTR lszINI)
|
|
{
|
|
TCHAR aszKey[164];
|
|
TCHAR szFileName[MAX_PATH];
|
|
LONG cbSize;
|
|
TCHAR aszValue[64];
|
|
LPTSTR szSectionBuf;
|
|
LPTSTR szKnownPrograms;
|
|
LPTSTR lpszFile;
|
|
short iEventLabel;
|
|
|
|
if (lszSchemeName)
|
|
{
|
|
wsprintf(aszKey, asz2Format, gszSchemesRootKey, aszSchemeNamesKey);
|
|
|
|
if (mmRegCreateUserKey (aszKey, lszSchemeID))
|
|
{
|
|
cbSize = cchLENGTH(aszValue);
|
|
if (!mmRegQueryUserValue (aszKey, lszSchemeID, cbSize, aszValue))
|
|
{
|
|
wsprintf(aszKey, asz3Format,
|
|
gszSchemesRootKey, aszSchemeNamesKey, lszSchemeID);
|
|
mmRegSetUserValue (aszKey, NULL, lszSchemeName);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
|
|
{
|
|
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
|
|
if (mmRegCreateUserKey (aszKey, gaEventLabels[ iEventLabel ].pszApp))
|
|
{
|
|
wsprintf(aszKey, asz3Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp);
|
|
|
|
if (!mmRegCreateUserKey (aszKey, gaEventLabels[iEventLabel].pszEvent))
|
|
continue;
|
|
|
|
wsprintf(aszKey, asz4Format,
|
|
gszSchemesRootKey,
|
|
gszSchemeAppsKey,
|
|
gaEventLabels[ iEventLabel ].pszApp,
|
|
gaEventLabels[ iEventLabel ].pszEvent);
|
|
|
|
mmRegCreateUserKey (aszKey, lszSchemeID);
|
|
}
|
|
}
|
|
|
|
szKnownPrograms = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, INISECTION * sizeof(TCHAR));
|
|
if (!szKnownPrograms)
|
|
return;
|
|
szSectionBuf = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, BIGINISECTION * sizeof(TCHAR));
|
|
if (!szSectionBuf)
|
|
{
|
|
LocalFree((HLOCAL)szKnownPrograms);
|
|
return;
|
|
}
|
|
|
|
if (GetPrivateProfileString(lszSection, NULL, szNull, szSectionBuf, BIGINISECTION, lszINI))
|
|
{
|
|
LPTSTR szKey;
|
|
UINT uKeyLen;
|
|
LPTSTR lszNextProg;
|
|
LPTSTR lszTmp;
|
|
TCHAR szKnownWAVPath[MAX_PATH];
|
|
LPTSTR lpszNextFile;
|
|
BOOL fClipsInstalled;
|
|
|
|
// Test to see if Clips are installed
|
|
//
|
|
fClipsInstalled = FALSE;
|
|
|
|
if (mmRegQueryMachineValue (aszOptionalClips, aszInstalled,
|
|
cchLENGTH(aszValue), aszValue))
|
|
{
|
|
if (aszValue[0] == TEXT('1'))
|
|
{
|
|
fClipsInstalled = TRUE;
|
|
}
|
|
}
|
|
|
|
if (fClipsInstalled)
|
|
{
|
|
if (mmRegQueryMachineValue (aszSetup, aszValMedia,
|
|
cchLENGTH(szKnownWAVPath), szKnownWAVPath))
|
|
{
|
|
lpszNextFile = (szKnownWAVPath + lstrlen(szKnownWAVPath));
|
|
*lpszNextFile = TEXT('\\');
|
|
lpszNextFile++;
|
|
*lpszNextFile = TEXT('\0');
|
|
}
|
|
else
|
|
{
|
|
fClipsInstalled = FALSE;
|
|
}
|
|
}
|
|
|
|
lszNextProg = szKnownPrograms;
|
|
|
|
for (szKey = szSectionBuf; *szKey; szKey += uKeyLen + 1)
|
|
{
|
|
UINT uSound;
|
|
|
|
uKeyLen = lstrlen(szKey);
|
|
// skip dummy entry
|
|
//
|
|
if (!lstrcmp(szKey, aszDummySnd)) {
|
|
if (!GetPrivateProfileString(lszSection, szKey, szNull, aszValue, cchLENGTH(aszValue), lszINI) || (aszValue[0] == TEXT(',')))
|
|
continue;
|
|
}
|
|
for (uSound = 0; uSound < (sizeof(gpszSounds) / sizeof(TCHAR*)); uSound++)
|
|
{
|
|
UINT uSoundLen;
|
|
TCHAR szProgram[64];
|
|
|
|
uSoundLen = lstrlen(gpszSounds[uSound]);
|
|
if ((uKeyLen > uSoundLen) && !lstrcmpi(gpszSounds[uSound], (szKey + (uKeyLen - uSoundLen))))
|
|
{
|
|
lstrcpy(szProgram, szKey);
|
|
*(szProgram + (uKeyLen - uSoundLen)) = 0;
|
|
if (*(szProgram + (uKeyLen - uSoundLen - 1)) == TEXT(' '))
|
|
break;
|
|
for (lszTmp = szKnownPrograms; lszTmp < lszNextProg; lszTmp += lstrlen(lszTmp) +1)
|
|
{
|
|
if (!lstrcmpi(lszTmp, szProgram))
|
|
break;
|
|
}
|
|
if (lszTmp >= lszNextProg)
|
|
{
|
|
lstrcpy(lszNextProg, szProgram);
|
|
lszNextProg += lstrlen(lszNextProg)+1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (szKey = szSectionBuf; *szKey; szKey += uKeyLen + 1)
|
|
{
|
|
LPTSTR lszRealEvent;
|
|
LPTSTR lszRealApp;
|
|
TCHAR aszValue[128];
|
|
TCHAR aszEvent[64];
|
|
LPTSTR lszValue;
|
|
UINT uSound;
|
|
|
|
|
|
uKeyLen = lstrlen(szKey);
|
|
if (!GetPrivateProfileString(lszSection, szKey, szNull, aszValue, cchLENGTH(aszValue), lszINI))
|
|
continue;
|
|
if (!lstrcmp(szKey, aszDummySnd) && (aszValue[0] == TEXT(','))) // skip dummy entry
|
|
continue;
|
|
|
|
lszRealEvent = szKey;
|
|
lszRealApp = aszDefault;
|
|
if (!lstrncmpi(szKey, gszApp, lstrlen(gszApp)+1))
|
|
{
|
|
lszRealEvent = aszEvent;
|
|
lstrcpy(aszEvent, (szKey + lstrlen(gszApp)));
|
|
}
|
|
else if (lstrncmpi(szKey, gszSystem, lstrlen(gszSystem)+1))
|
|
{
|
|
for (lszTmp = szKnownPrograms; *lszTmp; lszTmp += lstrlen(lszTmp) +1)
|
|
{
|
|
if (!lstrncmpi(szKey, lszTmp, lstrlen(lszTmp)+1))
|
|
{
|
|
for (uSound = 0; uSound < (sizeof(gpszSounds) / sizeof(TCHAR*)); uSound++)
|
|
{
|
|
if (!lstrcmpi(gpszSounds[uSound], (szKey + lstrlen(lszTmp))))
|
|
{
|
|
lszRealApp = szKey;
|
|
lszRealEvent = aszEvent;
|
|
lstrcpy(aszEvent, (szKey + lstrlen(lszTmp)));
|
|
*(szKey + lstrlen(lszTmp)) = 0;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (lszValue = aszValue; *lszValue && (*lszValue != TEXT(',')); ++lszValue)
|
|
;
|
|
if (*lszValue)
|
|
{
|
|
*(lszValue++) = 0;
|
|
while ((*lszValue == TEXT(' ')) || (*lszValue == TEXT('\t')))
|
|
++lszValue;
|
|
}
|
|
if (!lstrcmpi(aszValue, aszNone))
|
|
aszValue[0] = TEXT('\0');
|
|
|
|
lpszFile = aszValue;
|
|
if (*lpszFile == TEXT('\0'))
|
|
goto ExistCheckDone;
|
|
|
|
if (fClipsInstalled)
|
|
{
|
|
for (uSound = 0; uSound < (sizeof(gpszKnownWAVFiles) / sizeof(TCHAR *)); uSound++)
|
|
{
|
|
if (!lstrcmpi(gpszKnownWAVFiles[uSound], (lpszFile + lstrlen(lpszFile) - lstrlen(gpszKnownWAVFiles[uSound]))))
|
|
{
|
|
lstrcpy(lpszNextFile, gpszKnownWAVFiles[uSound]);
|
|
lpszFile = szKnownWAVPath;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (GetFileAttributes (lpszFile) != (DWORD)-1)
|
|
lpszFile = lpszFile;
|
|
else
|
|
lpszFile = aszValue;
|
|
|
|
//
|
|
// Create AppEvents\Schemes\Apps\[SchemeName]\[Event]
|
|
//
|
|
|
|
ExistCheckDone:
|
|
wsprintf (aszKey, asz2Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey);
|
|
if (!mmRegCreateUserKey (aszKey, lszRealApp))
|
|
continue;
|
|
|
|
wsprintf (aszKey, asz3Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey, lszRealApp);
|
|
if (!mmRegCreateUserKey (aszKey, lszRealEvent))
|
|
continue;
|
|
|
|
wsprintf (aszKey, asz4Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey,
|
|
lszRealApp, lszRealEvent);
|
|
|
|
if (!mmRegCreateUserKey (aszKey, lszSchemeID))
|
|
continue;
|
|
|
|
wsprintf (aszKey, asz5Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey,
|
|
lszRealApp, lszRealEvent, lszSchemeID);
|
|
RemoveMediaPath (szFileName, lpszFile);
|
|
mmRegSetUserValue (aszKey, NULL, szFileName);
|
|
|
|
#if 0 // BUGBUG: Was disabled in Win95 too!
|
|
wsprintf (aszKey, asz6Format,
|
|
gszSchemesRootKey, gszSchemeAppsKey,
|
|
lszRealApp, lszRealEvent, lszSchemeID, aszActiveKey);
|
|
|
|
mmRegSetUserValue (aszKey, NULL, aszBoolOne);
|
|
#endif
|
|
|
|
if (!*lszValue)
|
|
continue;
|
|
|
|
// Ensure AppEvents\EventLabels\[Event] exists
|
|
//
|
|
wsprintf(aszKey, asz2Format, gszAppEventsKey, aszSchemeLabelsKey);
|
|
|
|
if (!mmRegCreateUserKey (aszKey, lszRealEvent))
|
|
continue;
|
|
|
|
cbSize = cchLENGTH(aszValue);
|
|
if (!mmRegQueryUserValue (aszKey, lszRealEvent, cbSize, aszValue))
|
|
{
|
|
wsprintf(aszKey, asz3Format,
|
|
gszAppEventsKey, aszSchemeLabelsKey, lszRealEvent);
|
|
mmRegSetUserValue (aszKey, NULL, lszValue);
|
|
}
|
|
}
|
|
}
|
|
LocalFree((HLOCAL)szSectionBuf);
|
|
LocalFree((HLOCAL)szKnownPrograms);
|
|
}
|
|
|
|
STATIC void NEAR PASCAL mregCreateSchemeID(LPTSTR szSchemeName, LPTSTR szSchemeID)
|
|
{
|
|
UINT uSection;
|
|
UINT uScheme;
|
|
TCHAR aszSchemeID[SCH_TYPE_MAX_LENGTH];
|
|
|
|
lstrcpyn(aszSchemeID, szSchemeName, cchLENGTH(aszSchemeID));
|
|
for (uSection = uScheme = 0; aszSchemeID[uScheme];)
|
|
{
|
|
if ((aszSchemeID[uScheme] == TEXT(' ')) || (aszSchemeID[uScheme] == TEXT('\\')))
|
|
lstrcpyn(&aszSchemeID[uScheme], szSchemeName + ++uSection, cchLENGTH(aszSchemeID) - uScheme);
|
|
else
|
|
{
|
|
++uScheme;
|
|
++uSection;
|
|
}
|
|
}
|
|
lstrcpy(szSchemeID, aszSchemeID);
|
|
}
|
|
|
|
void RemoveMediaPath (LPTSTR pszTarget, LPTSTR pszSource)
|
|
{
|
|
static TCHAR szMediaPath[ MAX_PATH ] = TEXT("");
|
|
|
|
if (szMediaPath[0] == TEXT('\0'))
|
|
{
|
|
mmRegQueryMachineValue (aszSetup, aszValMedia,
|
|
cchLENGTH(szMediaPath), szMediaPath);
|
|
|
|
if ( (szMediaPath[0] != TEXT('\0')) &&
|
|
(szMediaPath[ lstrlen(szMediaPath)-1 ] != TEXT('\\')) )
|
|
{
|
|
lstrcat (szMediaPath, TEXT("\\"));
|
|
}
|
|
}
|
|
|
|
if (szMediaPath[0] == TEXT('\0'))
|
|
{
|
|
lstrcpy (pszTarget, pszSource);
|
|
}
|
|
else
|
|
{
|
|
size_t cch = lstrlen (szMediaPath);
|
|
|
|
if (!lstrncmpi (pszSource, szMediaPath, cch))
|
|
{
|
|
lstrcpy (pszTarget, &pszSource[ cch ]);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy (pszTarget, pszSource);
|
|
}
|
|
}
|
|
}
|
|
|
|
int lstrncmpi (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
|
|
}
|
|
|