Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-27 09:34:43 +00:00
Code Issues Projects Releases Packages Wiki Activity

add sndvol32 to the build system and reformat the code

Browse source 
svn path=/trunk/; revision=18102
This commit is contained in:
Thomas Bluemel 2005-09-26 19:15:27 +00:00
parent 469b041e51
commit d286c03c70
7 changed files with 816 additions and 528 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
reactos/subsys/system/directory.xml
View file

@ -55,6 +55,9 @@
<directory name="sm">
<xi:include href="sm/sm.xml" />
</directory>
<directory name="sndvol32">
<xi:include href="sndvol32/sndvol32.xml" />
</directory>
<directory name="taskmgr">
<xi:include href="taskmgr/taskmgr.xml" />
</directory>

2
reactos/subsys/system/sndvol32/En.rc
View file

@ -13,7 +13,7 @@ BEGIN
BEGIN
MENUITEM "&Help Topics", IDC_HELP_TOPICS
MENUITEM SEPARATOR
MENUITEM "&About ...", IDC_ABOUT
MENUITEM "&About Volume Control", IDC_ABOUT
END
END

129
reactos/subsys/system/sndvol32/misc.c Normal file
View file

@ -0,0 +1,129 @@
/*
* ReactOS Sound Volume Control
* Copyright (C) 2004-2005 Thomas Weidenmueller
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* VMware is a registered trademark of VMware, Inc.
*/
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Sound Volume Control
* FILE: subsys/system/sndvol32/misc.c
* PROGRAMMERS: Thomas Weidenmueller <w3seek@reactos.com>
*/
#include <sndvol32.h>
static INT
LengthOfStrResource(IN HINSTANCE hInst,
IN UINT uID)
{
HRSRC hrSrc;
HGLOBAL hRes;
LPWSTR lpName, lpStr;
if (hInst == NULL)
{
return -1;
}
/* There are always blocks of 16 strings */
lpName = (LPWSTR)MAKEINTRESOURCE((uID >> 4) + 1);
/* Find the string table block */
if ((hrSrc = FindResourceW(hInst,
lpName,
(LPWSTR)RT_STRING)) &&
(hRes = LoadResource(hInst,
hrSrc)) &&
(lpStr = LockResource(hRes)))
{
UINT x;
/* Find the string we're looking for */
uID &= 0xF; /* position in the block, same as % 16 */
for (x = 0; x < uID; x++)
{
lpStr += (*lpStr) + 1;
}
/* Found the string */
return (int)(*lpStr);
}
return -1;
}
INT
AllocAndLoadString(OUT LPWSTR *lpTarget,
IN HINSTANCE hInst,
IN UINT uID)
{
INT ln;
ln = LengthOfStrResource(hInst,
uID);
if (ln++ > 0)
{
(*lpTarget) = (LPWSTR)LocalAlloc(LMEM_FIXED,
ln * sizeof(WCHAR));
if ((*lpTarget) != NULL)
{
INT Ret;
if (!(Ret = LoadStringW(hInst,
uID,
*lpTarget,
ln)))
{
LocalFree((HLOCAL)(*lpTarget));
}
return Ret;
}
}
return 0;
}
DWORD
LoadAndFormatString(IN HINSTANCE hInstance,
IN UINT uID,
OUT LPWSTR *lpTarget,
...)
{
DWORD Ret = 0;
LPWSTR lpFormat;
va_list lArgs;
if (AllocAndLoadString(&lpFormat,
hInstance,
uID) > 0)
{
va_start(lArgs, lpTarget);
/* let's use FormatMessage to format it because it has the ability to
allocate memory automatically */
Ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
lpFormat,
0,
0,
(LPWSTR)lpTarget,
0,
&lArgs);
va_end(lArgs);
LocalFree((HLOCAL)lpFormat);
}
return Ret;
}

577
reactos/subsys/system/sndvol32/mixer.c
View file

@ -1,6 +1,6 @@
/*
* ReactOS Sound Volume Control
* Copyright (C) 2004 Thomas Weidenmueller
* Copyright (C) 2004-2005 Thomas Weidenmueller
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -25,354 +25,423 @@
* FILE: subsys/system/sndvol32/mixer.c
* PROGRAMMERS: Thomas Weidenmueller <w3seek@reactos.com>
*/
#include "sndvol32.h"
#include <sndvol32.h>
#define NO_MIXER_SELECTED (~0)
static VOID
ClearMixerCache(PSND_MIXER Mixer)
{
PSND_MIXER_DESTINATION Line, NextLine;
PSND_MIXER_CONNECTION Con, NextCon;
PSND_MIXER_DESTINATION Line, NextLine;
PSND_MIXER_CONNECTION Con, NextCon;
for(Line = Mixer->Lines; Line != NULL; Line = NextLine)
{
if(Line->Controls != NULL)
for (Line = Mixer->Lines; Line != NULL; Line = NextLine)
{
HeapFree(GetProcessHeap(), 0, Line->Controls);
if (Line->Controls != NULL)
{
HeapFree(GetProcessHeap(),
0,
Line->Controls);
}
for (Con = Line->Connections; Con != NULL; Con = NextCon)
{
if (Con->Controls != NULL)
{
HeapFree(GetProcessHeap(),
0,
Con->Controls);
}
NextCon = Con->Next;
HeapFree(GetProcessHeap(),
0,
Con);
}
NextLine = Line->Next;
HeapFree(GetProcessHeap(),
0,
Line);
}
for(Con = Line->Connections; Con != NULL; Con = NextCon)
{
if(Con->Controls != NULL)
{
HeapFree(GetProcessHeap(), 0, Con->Controls);
}
NextCon = Con->Next;
HeapFree(GetProcessHeap(), 0, Con);
}
NextLine = Line->Next;
HeapFree(GetProcessHeap(), 0, Line);
}
Mixer->Lines = NULL;
Mixer->Lines = NULL;
}
PSND_MIXER
SndMixerCreate(HWND hWndNotification)
{
PSND_MIXER Mixer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SND_MIXER));
if(Mixer != NULL)
{
Mixer->hWndNotification = hWndNotification;
Mixer->MixersCount = mixerGetNumDevs();
Mixer->MixerId = NO_MIXER_SELECTED;
if(Mixer->MixersCount > 0)
PSND_MIXER Mixer = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(SND_MIXER));
if (Mixer != NULL)
{
/* select the first mixer by default */
SndMixerSelect(Mixer, 0);
}
}
Mixer->hWndNotification = hWndNotification;
Mixer->MixersCount = mixerGetNumDevs();
Mixer->MixerId = NO_MIXER_SELECTED;
return Mixer;
if (Mixer->MixersCount > 0)
{
/* select the first mixer by default */
SndMixerSelect(Mixer, 0);
}
}
return Mixer;
}
VOID
SndMixerDestroy(PSND_MIXER Mixer)
{
SndMixerClose(Mixer);
HeapFree(GetProcessHeap(), 0, Mixer);
SndMixerClose(Mixer);
HeapFree(GetProcessHeap(),
0,
Mixer);
}
VOID
SndMixerClose(PSND_MIXER Mixer)
{
if(Mixer->hmx != NULL)
{
mixerClose(Mixer->hmx);
Mixer->hmx = NULL;
Mixer->MixerId = NO_MIXER_SELECTED;
}
if (Mixer->hmx != NULL)
{
mixerClose(Mixer->hmx);
Mixer->hmx = NULL;
Mixer->MixerId = NO_MIXER_SELECTED;
}
}
static BOOL
SndMixerQueryControls(PSND_MIXER Mixer, LPMIXERLINE LineInfo, LPMIXERCONTROL *Controls)
SndMixerQueryControls(PSND_MIXER Mixer,
LPMIXERLINE LineInfo,
LPMIXERCONTROL *Controls)
{
if(LineInfo->cControls > 0)
{
*Controls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, LineInfo->cControls * sizeof(MIXERCONTROL));
if(*Controls != NULL)
if (LineInfo->cControls > 0)
{
MIXERLINECONTROLS LineControls;
UINT j;
LineControls.cbStruct = sizeof(LineControls);
LineControls.dwLineID = LineInfo->dwLineID;
LineControls.cControls = LineInfo->cControls;
LineControls.cbmxctrl = sizeof(MIXERCONTROL);
LineControls.pamxctrl = (PVOID)(*Controls);
for(j = 0; j < LineInfo->cControls; j++)
{
(*Controls)[j].cbStruct = sizeof(MIXERCONTROL);
}
if(mixerGetLineControls((HMIXEROBJ)Mixer->hmx, &LineControls, MIXER_GETLINECONTROLSF_ALL) == MMSYSERR_NOERROR)
{
for(j = 0; j < LineInfo->cControls; j++)
*Controls = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
LineInfo->cControls * sizeof(MIXERCONTROL));
if (*Controls != NULL)
{
DBG("Line control: %ws", (*Controls)[j].szName);
MIXERLINECONTROLS LineControls;
UINT j;
LineControls.cbStruct = sizeof(LineControls);
LineControls.dwLineID = LineInfo->dwLineID;
LineControls.cControls = LineInfo->cControls;
LineControls.cbmxctrl = sizeof(MIXERCONTROL);
LineControls.pamxctrl = (PVOID)(*Controls);
for (j = 0; j < LineInfo->cControls; j++)
{
(*Controls)[j].cbStruct = sizeof(MIXERCONTROL);
}
if (mixerGetLineControls((HMIXEROBJ)Mixer->hmx,
&LineControls,
MIXER_GETLINECONTROLSF_ALL) == MMSYSERR_NOERROR)
{
for (j = 0; j < LineInfo->cControls; j++)
{
DPRINT("Line control: %ws", (*Controls)[j].szName);
}
return TRUE;
}
else
{
HeapFree(GetProcessHeap(),
0,
*Controls);
*Controls = NULL;
DPRINT("Failed to get line controls!\n");
}
}
else
{
DPRINT("Failed to allocate memory for %d line controls!\n", LineInfo->cControls);
}
return TRUE;
}
else
{
HeapFree(GetProcessHeap(), 0, *Controls);
*Controls = NULL;
DBG("Failed to get line controls!\n");
}
return FALSE;
}
else
{
DBG("Failed to allocate memory for %d line controls!\n", LineInfo->cControls);
return TRUE;
}
return FALSE;
}
else
{
return TRUE;
}
}
static BOOL
SndMixerQueryConnections(PSND_MIXER Mixer, PSND_MIXER_DESTINATION Line)
SndMixerQueryConnections(PSND_MIXER Mixer,
PSND_MIXER_DESTINATION Line)
{
UINT i;
MIXERLINE LineInfo;
BOOL Ret = TRUE;
UINT i;
MIXERLINE LineInfo;
BOOL Ret = TRUE;
LineInfo.cbStruct = sizeof(LineInfo);
LineInfo.dwDestination = Line->Info.dwDestination;
for(i = Line->Info.cConnections; i > 0; i--)
{
LineInfo.dwSource = i - 1;
if(mixerGetLineInfo((HMIXEROBJ)Mixer->hmx, &LineInfo, MIXER_GETLINEINFOF_SOURCE) == MMSYSERR_NOERROR)
LineInfo.cbStruct = sizeof(LineInfo);
LineInfo.dwDestination = Line->Info.dwDestination;
for (i = Line->Info.cConnections; i > 0; i--)
{
LPMIXERCONTROL Controls;
PSND_MIXER_CONNECTION Con;
LineInfo.dwSource = i - 1;
if (mixerGetLineInfo((HMIXEROBJ)Mixer->hmx,
&LineInfo,
MIXER_GETLINEINFOF_SOURCE) == MMSYSERR_NOERROR)
{
LPMIXERCONTROL Controls;
PSND_MIXER_CONNECTION Con;
if(!SndMixerQueryControls(Mixer, &LineInfo, &Controls))
{
DBG("Failed to query connection controls\n");
Ret = FALSE;
break;
}
if (!SndMixerQueryControls(Mixer,
&LineInfo,
&Controls))
{
DPRINT("Failed to query connection controls\n");
Ret = FALSE;
break;
}
Con = HeapAlloc(GetProcessHeap(), 0, sizeof(SND_MIXER_CONNECTION));
if(Con != NULL)
{
Con->Info = LineInfo;
Con->Controls = Controls;
Con->Next = Line->Connections;
Line->Connections = Con;
}
else
{
HeapFree(GetProcessHeap(), 0, Controls);
}
Con = HeapAlloc(GetProcessHeap(),
0,
sizeof(SND_MIXER_CONNECTION));
if (Con != NULL)
{
Con->Info = LineInfo;
Con->Controls = Controls;
Con->Next = Line->Connections;
Line->Connections = Con;
}
else
{
HeapFree(GetProcessHeap(),
0,
Controls);
}
}
else
{
DPRINT("Failed to get connection information!\n");
Ret = FALSE;
break;
}
}
else
{
DBG("Failed to get connection information!\n");
Ret = FALSE;
break;
}
}
return Ret;
return Ret;
}
static BOOL
SndMixerQueryDestinations(PSND_MIXER Mixer)
{
UINT i;
BOOL Ret = TRUE;
UINT i;
BOOL Ret = TRUE;
for(i = Mixer->Caps.cDestinations; i > 0; i--)
{
PSND_MIXER_DESTINATION Line;
Line = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SND_MIXER_DESTINATION));
if(Line != NULL)
for (i = Mixer->Caps.cDestinations; i > 0; i--)
{
Line->Info.cbStruct = sizeof(Line->Info);
Line->Info.dwDestination = i - 1;
if(mixerGetLineInfo((HMIXEROBJ)Mixer->hmx, &Line->Info, MIXER_GETLINEINFOF_DESTINATION) == MMSYSERR_NOERROR)
{
if(!SndMixerQueryConnections(Mixer, Line))
{
DBG("Failed to query mixer connections!\n");
Ret = FALSE;
break;
}
if(!SndMixerQueryControls(Mixer, &Line->Info, &Line->Controls))
{
DBG("Failed to query mixer controls!\n");
Ret = FALSE;
break;
}
PSND_MIXER_DESTINATION Line;
Line->Next = Mixer->Lines;
Mixer->Lines = Line;
}
else
{
DBG("Failed to get line information for id %d!\n", i);
HeapFree(GetProcessHeap(), 0, Line);
Ret = FALSE;
break;
}
}
else
{
DBG("Allocation of SND_MIXER_DEST structure for id %d failed!\n", i);
Ret = FALSE;
break;
}
}
Line = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(SND_MIXER_DESTINATION));
if (Line != NULL)
{
Line->Info.cbStruct = sizeof(Line->Info);
Line->Info.dwDestination = i - 1;
if (mixerGetLineInfo((HMIXEROBJ)Mixer->hmx,
&Line->Info,
MIXER_GETLINEINFOF_DESTINATION) == MMSYSERR_NOERROR)
{
if (!SndMixerQueryConnections(Mixer, Line))
{
DPRINT("Failed to query mixer connections!\n");
Ret = FALSE;
break;
}
if (!SndMixerQueryControls(Mixer,
&Line->Info,
&Line->Controls))
{
DPRINT("Failed to query mixer controls!\n");
Ret = FALSE;
break;
}
return Ret;
Line->Next = Mixer->Lines;
Mixer->Lines = Line;
}
else
{
DPRINT("Failed to get line information for id %d!\n", i);
HeapFree(GetProcessHeap(),
0,
Line);
Ret = FALSE;
break;
}
}
else
{
DPRINT("Allocation of SND_MIXER_DEST structure for id %d failed!\n", i);
Ret = FALSE;
break;
}
}
return Ret;
}
BOOL
SndMixerSelect(PSND_MIXER Mixer, UINT MixerId)
SndMixerSelect(PSND_MIXER Mixer,
UINT MixerId)
{
if(MixerId >= Mixer->MixersCount)
{
if (MixerId >= Mixer->MixersCount)
{
return FALSE;
}
SndMixerClose(Mixer);
if (mixerOpen(&Mixer->hmx,
MixerId,
(DWORD_PTR)Mixer->hWndNotification,
0,
CALLBACK_WINDOW | MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR ||
mixerOpen(&Mixer->hmx,
MixerId,
(DWORD_PTR)Mixer->hWndNotification,
0,
CALLBACK_WINDOW) == MMSYSERR_NOERROR ||
mixerOpen(&Mixer->hmx,
MixerId,
0,
0,
0) == MMSYSERR_NOERROR)
{
if (mixerGetDevCaps(MixerId,
&Mixer->Caps,
sizeof(Mixer->Caps)) == MMSYSERR_NOERROR)
{
BOOL Ret = FALSE;
Mixer->MixerId = MixerId;
ClearMixerCache(Mixer);
Ret = SndMixerQueryDestinations(Mixer);
if (!Ret)
{
ClearMixerCache(Mixer);
}
return Ret;
}
else
{
mixerClose(Mixer->hmx);
}
}
Mixer->hmx = NULL;
Mixer->MixerId = NO_MIXER_SELECTED;
return FALSE;
}
SndMixerClose(Mixer);
if(mixerOpen(&Mixer->hmx, MixerId, (DWORD_PTR)Mixer->hWndNotification, 0, CALLBACK_WINDOW | MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR ||
mixerOpen(&Mixer->hmx, MixerId, (DWORD_PTR)Mixer->hWndNotification, 0, CALLBACK_WINDOW) == MMSYSERR_NOERROR ||
mixerOpen(&Mixer->hmx, MixerId, 0, 0, 0) == MMSYSERR_NOERROR)
{
if(mixerGetDevCaps(MixerId, &Mixer->Caps, sizeof(Mixer->Caps)) == MMSYSERR_NOERROR)
{
BOOL Ret = FALSE;
Mixer->MixerId = MixerId;
ClearMixerCache(Mixer);
Ret = SndMixerQueryDestinations(Mixer);
if(!Ret)
{
ClearMixerCache(Mixer);
}
return Ret;
}
else
{
mixerClose(Mixer->hmx);
}
}
Mixer->hmx = NULL;
Mixer->MixerId = NO_MIXER_SELECTED;
return FALSE;
}
UINT
SndMixerGetSelection(PSND_MIXER Mixer)
{
return Mixer->MixerId;
return Mixer->MixerId;
}
INT
SndMixerGetProductName(PSND_MIXER Mixer, LPTSTR lpBuffer, UINT uSize)
SndMixerGetProductName(PSND_MIXER Mixer,
LPTSTR lpBuffer,
UINT uSize)
{
if(Mixer->hmx)
{
int lnsz = lstrlen(Mixer->Caps.szPname);
if(lnsz + 1 > uSize)
if (Mixer->hmx)
{
return lnsz + 1;
int lnsz = lstrlen(Mixer->Caps.szPname);
if(lnsz + 1 > uSize)
{
return lnsz + 1;
}
else
{
memcpy(lpBuffer, Mixer->Caps.szPname, lnsz * sizeof(TCHAR));
lpBuffer[lnsz] = _T('\0');
return lnsz;
}
}
else
{
memcpy(lpBuffer, Mixer->Caps.szPname, lnsz * sizeof(TCHAR));
lpBuffer[lnsz] = _T('\0');
return lnsz;
}
}
return -1;
return -1;
}
BOOL
SndMixerEnumProducts(PSND_MIXER Mixer, PFNSNDMIXENUMPRODUCTS EnumProc, PVOID Context)
SndMixerEnumProducts(PSND_MIXER Mixer,
PFNSNDMIXENUMPRODUCTS EnumProc,
PVOID Context)
{
MIXERCAPS Caps;
HMIXER hMixer;
UINT i;
BOOL Ret = TRUE;
MIXERCAPS Caps;
HMIXER hMixer;
UINT i;
BOOL Ret = TRUE;
for(i = 0; i < Mixer->MixersCount; i++)
{
if(mixerOpen(&hMixer, i, 0, 0, 0) == MMSYSERR_NOERROR)
for (i = 0; i < Mixer->MixersCount; i++)
{
if(mixerGetDevCaps(i, &Caps, sizeof(Caps)) == MMSYSERR_NOERROR)
{
if(!EnumProc(Mixer, i, Caps.szPname, Context))
if (mixerOpen(&hMixer,
i,
0,
0,
0) == MMSYSERR_NOERROR)
{
mixerClose(hMixer);
Ret = FALSE;
break;
if (mixerGetDevCaps(i,
&Caps,
sizeof(Caps)) == MMSYSERR_NOERROR)
{
if (!EnumProc(Mixer,
i,
Caps.szPname,
Context))
{
mixerClose(hMixer);
Ret = FALSE;
break;
}
}
else
{
DPRINT("Failed to get device capabilities for mixer id %d!\n", i);
}
mixerClose(hMixer);
}
}
else
{
DBG("Failed to get device capabilities for mixer id %d!\n", i);
}
mixerClose(hMixer);
}
}
return Ret;
return Ret;
}
INT
SndMixerGetDestinationCount(PSND_MIXER Mixer)
{
return (Mixer->hmx ? Mixer->Caps.cDestinations : -1);
return (Mixer->hmx ? Mixer->Caps.cDestinations : -1);
}
BOOL
SndMixerEnumLines(PSND_MIXER Mixer, PFNSNDMIXENUMLINES EnumProc, PVOID Context)
SndMixerEnumLines(PSND_MIXER Mixer,
PFNSNDMIXENUMLINES EnumProc,
PVOID Context)
{
if(Mixer->hmx)
{
PSND_MIXER_DESTINATION Line;
for(Line = Mixer->Lines; Line != NULL; Line = Line->Next)
if (Mixer->hmx)
{
if(!EnumProc(Mixer, &Line->Info, Context))
{
return FALSE;
}
PSND_MIXER_DESTINATION Line;
for (Line = Mixer->Lines; Line != NULL; Line = Line->Next)
{
if (!EnumProc(Mixer,
&Line->Info,
Context))
{
return FALSE;
}
}
return TRUE;
}
return TRUE;
}
return FALSE;
return FALSE;
}

597
reactos/subsys/system/sndvol32/sndvol32.c
View file

@ -1,6 +1,6 @@
/*
* ReactOS Sound Volume Control
* Copyright (C) 2004 Thomas Weidenmueller
* Copyright (C) 2004-2005 Thomas Weidenmueller
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -25,7 +25,7 @@
* FILE: subsys/system/sndvol32/sndvol32.c
* PROGRAMMERS: Thomas Weidenmueller <w3seek@reactos.com>
*/
#include "sndvol32.h"
#include <sndvol32.h>
HINSTANCE hAppInstance;
ATOM MainWindowClass;
@ -33,116 +33,137 @@ HWND hMainWnd;
HANDLE hAppHeap;
#define GetDialogData(hwndDlg, type) \
( P##type )GetWindowLongPtr((hwndDlg), DWLP_USER)
( P##type )GetWindowLongPtr((hwndDlg), DWLP_USER)
#define GetWindowData(hwnd, type) \
( P##type )GetWindowLongPtr((hwnd), GWL_USERDATA)
( P##type )GetWindowLongPtr((hwnd), GWL_USERDATA)
/******************************************************************************/
typedef struct _PREFERENCES_CONTEXT
{
PMIXER_WINDOW MixerWindow;
PSND_MIXER Mixer;
HWND hwndDlg;
PMIXER_WINDOW MixerWindow;
PSND_MIXER Mixer;
HWND hwndDlg;
} PREFERENCES_CONTEXT, *PPREFERENCES_CONTEXT;
typedef struct _PREFERENCES_FILL_DEVICES
{
PPREFERENCES_CONTEXT PrefContext;
HWND hComboBox;
UINT Selected;
PPREFERENCES_CONTEXT PrefContext;
HWND hComboBox;
UINT Selected;
} PREFERENCES_FILL_DEVICES, *PPREFERENCES_FILL_DEVICES;
static BOOL CALLBACK
FillDeviceComboBox(PSND_MIXER Mixer, UINT Id, LPCTSTR ProductName, PVOID Context)
FillDeviceComboBox(PSND_MIXER Mixer,
UINT Id,
LPCTSTR ProductName,
PVOID Context)
{
LRESULT lres;
PPREFERENCES_FILL_DEVICES FillContext = (PPREFERENCES_FILL_DEVICES)Context;
LRESULT lres;
PPREFERENCES_FILL_DEVICES FillContext = (PPREFERENCES_FILL_DEVICES)Context;
lres = SendMessage(FillContext->hComboBox, CB_ADDSTRING, 0, (LPARAM)ProductName);
if(lres != CB_ERR)
{
/* save the index so we don't screw stuff when the combobox is sorted... */
SendMessage(FillContext->hComboBox, CB_SETITEMDATA, (WPARAM)lres, Id);
if(Id == FillContext->Selected)
lres = SendMessage(FillContext->hComboBox,
CB_ADDSTRING,
0,
(LPARAM)ProductName);
if (lres != CB_ERR)
{
SendMessage(FillContext->hComboBox, CB_SETCURSEL, (WPARAM)lres, 0);
}
}
/* save the index so we don't screw stuff when the combobox is sorted... */
SendMessage(FillContext->hComboBox,
CB_SETITEMDATA,
(WPARAM)lres,
Id);
return TRUE;
if (Id == FillContext->Selected)
{
SendMessage(FillContext->hComboBox,
CB_SETCURSEL,
(WPARAM)lres,
0);
}
}
return TRUE;
}
static INT_PTR CALLBACK
DlgPreferencesProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
DlgPreferencesProc(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PPREFERENCES_CONTEXT Context;
PPREFERENCES_CONTEXT Context;
switch(uMsg)
{
case WM_COMMAND:
switch (uMsg)
{
switch(LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
case WM_COMMAND:
{
EndDialog(hwndDlg, LOWORD(wParam));
break;
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
{
EndDialog(hwndDlg,
LOWORD(wParam));
break;
}
}
break;
}
case MM_MIXM_LINE_CHANGE:
{
DPRINT("MM_MIXM_LINE_CHANGE\n");
break;
}
case MM_MIXM_CONTROL_CHANGE:
{
DPRINT("MM_MIXM_CONTROL_CHANGE\n");
break;
}
case WM_INITDIALOG:
{
PREFERENCES_FILL_DEVICES FillDevContext;
SetWindowLongPtr(hwndDlg,
DWLP_USER,
(LONG_PTR)lParam);
Context = (PPREFERENCES_CONTEXT)((LONG_PTR)lParam);
Context->hwndDlg = hwndDlg;
Context->Mixer = SndMixerCreate(hwndDlg);
FillDevContext.PrefContext = Context;
FillDevContext.hComboBox = GetDlgItem(hwndDlg,
IDC_MIXERDEVICE);
FillDevContext.Selected = SndMixerGetSelection(Context->Mixer);
SndMixerEnumProducts(Context->Mixer,
FillDeviceComboBox,
&FillDevContext);
return TRUE;
}
case WM_DESTROY:
{
Context = GetDialogData(hwndDlg,
PREFERENCES_CONTEXT);
if (Context->Mixer != NULL)
{
SndMixerDestroy(Context->Mixer);
}
break;
}
case WM_CLOSE:
{
EndDialog(hwndDlg,
IDCANCEL);
break;
}
}
break;
}
case MM_MIXM_LINE_CHANGE:
{
DBG("MM_MIXM_LINE_CHANGE\n");
break;
}
case MM_MIXM_CONTROL_CHANGE:
{
DBG("MM_MIXM_CONTROL_CHANGE\n");
break;
}
case WM_INITDIALOG:
{
PREFERENCES_FILL_DEVICES FillDevContext;
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)lParam);
Context = (PPREFERENCES_CONTEXT)((LONG_PTR)lParam);
Context->hwndDlg = hwndDlg;
Context->Mixer = SndMixerCreate(hwndDlg);
FillDevContext.PrefContext = Context;
FillDevContext.hComboBox = GetDlgItem(hwndDlg, IDC_MIXERDEVICE);
FillDevContext.Selected = SndMixerGetSelection(Context->Mixer);
SndMixerEnumProducts(Context->Mixer,
FillDeviceComboBox,
&FillDevContext);
return TRUE;
}
case WM_DESTROY:
{
Context = GetDialogData(hwndDlg, PREFERENCES_CONTEXT);
if(Context->Mixer != NULL)
{
SndMixerDestroy(Context->Mixer);
}
break;
}
case WM_CLOSE:
{
EndDialog(hwndDlg, IDCANCEL);
break;
}
}
return 0;
return 0;
}
/******************************************************************************/
@ -155,253 +176,285 @@ DeleteMixerWindowControls(PMIXER_WINDOW MixerWindow)
BOOL
RebuildMixerWindowControls(PMIXER_WINDOW MixerWindow)
{
DeleteMixerWindowControls(MixerWindow);
DeleteMixerWindowControls(MixerWindow);
return TRUE;
return TRUE;
}
LRESULT CALLBACK
MainWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
MainWindowProc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PMIXER_WINDOW MixerWindow;
LRESULT Result = 0;
PMIXER_WINDOW MixerWindow;
LRESULT Result = 0;
switch(uMsg)
{
case WM_COMMAND:
switch (uMsg)
{
MixerWindow = GetWindowData(hwnd, MIXER_WINDOW);
switch(LOWORD(wParam))
{
case IDC_PROPERTIES:
case WM_COMMAND:
{
PREFERENCES_CONTEXT Preferences;
MixerWindow = GetWindowData(hwnd,
MIXER_WINDOW);
Preferences.MixerWindow = MixerWindow;
Preferences.Mixer = NULL;
switch (LOWORD(wParam))
{
case IDC_PROPERTIES:
{
PREFERENCES_CONTEXT Preferences;
if(DialogBoxParam(hAppInstance,
MAKEINTRESOURCE(IDD_PREFERENCES),
hwnd,
DlgPreferencesProc,
(LPARAM)&Preferences) == IDOK)
{
/* FIXME - update window */
}
break;
Preferences.MixerWindow = MixerWindow;
Preferences.Mixer = NULL;
if (DialogBoxParam(hAppInstance,
MAKEINTRESOURCE(IDD_PREFERENCES),
hwnd,
DlgPreferencesProc,
(LPARAM)&Preferences) == IDOK)
{
/* FIXME - update window */
}
break;
}
case IDC_EXIT:
{
PostQuitMessage(0);
break;
}
}
break;
}
case IDC_EXIT:
case MM_MIXM_LINE_CHANGE:
{
PostQuitMessage(0);
break;
DPRINT("MM_MIXM_LINE_CHANGE\n");
break;
}
}
break;
}
case MM_MIXM_LINE_CHANGE:
{
DBG("MM_MIXM_LINE_CHANGE\n");
break;
}
case MM_MIXM_CONTROL_CHANGE:
{
DBG("MM_MIXM_CONTROL_CHANGE\n");
break;
}
case WM_CREATE:
{
MixerWindow = ((LPCREATESTRUCT)lParam)->lpCreateParams;
SetWindowLongPtr(hwnd, GWL_USERDATA, (LONG_PTR)MixerWindow);
MixerWindow->hWnd = hwnd;
MixerWindow->hStatusBar = CreateStatusWindow(WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS,
NULL, hwnd, 0);
if(MixerWindow->hStatusBar != NULL)
{
MixerWindow->Mixer = SndMixerCreate(MixerWindow->hWnd);
if(MixerWindow->Mixer != NULL)
case MM_MIXM_CONTROL_CHANGE:
{
TCHAR szProduct[MAXPNAMELEN];
if(SndMixerGetProductName(MixerWindow->Mixer, szProduct, sizeof(szProduct) / sizeof(szProduct[0])) > 0)
{
SendMessage(MixerWindow->hStatusBar, WM_SETTEXT, 0, (LPARAM)szProduct);
}
if(!RebuildMixerWindowControls(MixerWindow))
{
DBG("Rebuilding mixer window controls failed!\n");
SndMixerDestroy(MixerWindow->Mixer);
Result = -1;
}
DPRINT("MM_MIXM_CONTROL_CHANGE\n");
break;
}
else
case WM_CREATE:
{
Result = -1;
MixerWindow = ((LPCREATESTRUCT)lParam)->lpCreateParams;
SetWindowLongPtr(hwnd,
GWL_USERDATA,
(LONG_PTR)MixerWindow);
MixerWindow->hWnd = hwnd;
MixerWindow->hStatusBar = CreateStatusWindow(WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS,
NULL,
hwnd,
0);
if (MixerWindow->hStatusBar != NULL)
{
MixerWindow->Mixer = SndMixerCreate(MixerWindow->hWnd);
if (MixerWindow->Mixer != NULL)
{
TCHAR szProduct[MAXPNAMELEN];
if (SndMixerGetProductName(MixerWindow->Mixer,
szProduct,
sizeof(szProduct) / sizeof(szProduct[0])) > 0)
{
SendMessage(MixerWindow->hStatusBar,
WM_SETTEXT,
0,
(LPARAM)szProduct);
}
if (!RebuildMixerWindowControls(MixerWindow))
{
DPRINT("Rebuilding mixer window controls failed!\n");
SndMixerDestroy(MixerWindow->Mixer);
Result = -1;
}
}
else
{
Result = -1;
}
}
else
{
DPRINT("Failed to create status window!\n");
Result = -1;
}
break;
}
case WM_DESTROY:
{
MixerWindow = GetWindowData(hwnd,
MIXER_WINDOW);
if (MixerWindow->Mixer != NULL)
{
SndMixerDestroy(MixerWindow->Mixer);
}
break;
}
case WM_CLOSE:
{
PostQuitMessage(0);
break;
}
default:
{
Result = DefWindowProc(hwnd,
uMsg,
wParam,
lParam);
break;
}
}
else
{
DBG("Failed to create status window!\n");
Result = -1;
}
break;
}
case WM_DESTROY:
{
MixerWindow = GetWindowData(hwnd, MIXER_WINDOW);
if(MixerWindow->Mixer != NULL)
{
SndMixerDestroy(MixerWindow->Mixer);
}
break;
}
case WM_CLOSE:
{
PostQuitMessage(0);
break;
}
default:
{
Result = DefWindowProc(hwnd, uMsg, wParam, lParam);
}
}
return Result;
return Result;
}
static BOOL
RegisterApplicationClasses(VOID)
{
WNDCLASSEX wc;
WNDCLASSEX wc;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = MainWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(PMIXER_WINDOW);
wc.hInstance = hAppInstance;
wc.hIcon = LoadIcon(hAppInstance, MAKEINTRESOURCE(IDI_MAINAPP));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = SZ_APP_CLASS;
wc.hIconSm = NULL;
MainWindowClass = RegisterClassEx(&wc);
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = MainWindowProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(PMIXER_WINDOW);
wc.hInstance = hAppInstance;
wc.hIcon = LoadIcon(hAppInstance,
MAKEINTRESOURCE(IDI_MAINAPP));
wc.hCursor = LoadCursor(NULL,
IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = SZ_APP_CLASS;
wc.hIconSm = NULL;
MainWindowClass = RegisterClassEx(&wc);
return MainWindowClass != 0;
return MainWindowClass != 0;
}
static VOID
UnregisterApplicationClasses(VOID)
{
UnregisterClass(SZ_APP_CLASS, hAppInstance);
UnregisterClass(SZ_APP_CLASS,
hAppInstance);
}
static HWND
CreateApplicationWindow(VOID)
{
LPTSTR lpAppTitle;
HWND hWnd;
LPTSTR lpAppTitle;
HWND hWnd;
PMIXER_WINDOW MixerWindow = HeapAlloc(hAppHeap, 0, sizeof(MIXER_WINDOW));
if(MixerWindow == NULL)
{
return NULL;
}
PMIXER_WINDOW MixerWindow = HeapAlloc(hAppHeap,
0,
sizeof(MIXER_WINDOW));
if (MixerWindow == NULL)
{
return NULL;
}
/* load the application title */
if(RosAllocAndLoadString(&lpAppTitle,
/* load the application title */
if (AllocAndLoadString(&lpAppTitle,
hAppInstance,
IDS_SNDVOL32) == 0)
{
lpAppTitle = NULL;
}
{
lpAppTitle = NULL;
}
if(mixerGetNumDevs() > 0)
{
hWnd = CreateWindowEx(WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT,
SZ_APP_CLASS,
lpAppTitle,
WS_DLGFRAME | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL,
LoadMenu(hAppInstance, MAKEINTRESOURCE(IDM_MAINMENU)),
hAppInstance,
MixerWindow);
}
else
{
LPTSTR lpErrMessage;
if (mixerGetNumDevs() > 0)
{
hWnd = CreateWindowEx(WS_EX_WINDOWEDGE | WS_EX_CONTROLPARENT,
SZ_APP_CLASS,
lpAppTitle,
WS_DLGFRAME | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
NULL,
LoadMenu(hAppInstance,
MAKEINTRESOURCE(IDM_MAINMENU)),
hAppInstance,
MixerWindow);
}
else
{
LPTSTR lpErrMessage;
/*
* no mixer devices are available!
*/
/*
* no mixer devices are available!
*/
hWnd = NULL;
RosAllocAndLoadString(&lpErrMessage,
hAppInstance,
IDS_NOMIXERDEVICES);
MessageBox(NULL, lpErrMessage, lpAppTitle, MB_ICONINFORMATION);
LocalFree(lpErrMessage);
}
hWnd = NULL;
AllocAndLoadString(&lpErrMessage,
hAppInstance,
IDS_NOMIXERDEVICES);
MessageBox(NULL,
lpErrMessage,
lpAppTitle,
MB_ICONINFORMATION);
LocalFree(lpErrMessage);
}
if(lpAppTitle != NULL)
{
LocalFree(lpAppTitle);
}
if (lpAppTitle != NULL)
{
LocalFree(lpAppTitle);
}
if(hWnd == NULL)
{
HeapFree(hAppHeap, 0, MixerWindow);
}
if (hWnd == NULL)
{
HeapFree(hAppHeap,
0,
MixerWindow);
}
return hWnd;
return hWnd;
}
int WINAPI
WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow)
{
MSG Msg;
MSG Msg;
hAppInstance = hInstance;
hAppHeap = GetProcessHeap();
hAppInstance = hInstance;
hAppHeap = GetProcessHeap();
InitCommonControls();
InitCommonControls();
if(!RegisterApplicationClasses())
{
DBG("Failed to register application classes (LastError: %d)!\n", GetLastError());
return 1;
}
if (!RegisterApplicationClasses())
{
DPRINT("Failed to register application classes (LastError: %d)!\n", GetLastError());
return 1;
}
hMainWnd = CreateApplicationWindow();
if(hMainWnd == NULL)
{
DBG("Failed to creat application window (LastError: %d)!\n", GetLastError());
return 1;
}
hMainWnd = CreateApplicationWindow();
if (hMainWnd == NULL)
{
DPRINT("Failed to creat application window (LastError: %d)!\n", GetLastError());
return 1;
}
while(GetMessage(&Msg, NULL, 0, 0))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
while (GetMessage(&Msg,
NULL,
0,
0))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
DestroyWindow(hMainWnd);
DestroyWindow(hMainWnd);
UnregisterApplicationClasses();
UnregisterApplicationClasses();
return 0;
return 0;
}

17
reactos/subsys/system/sndvol32/sndvol32.h
View file

@ -28,7 +28,8 @@ extern HANDLE hAppHeap;
#define SZ_APP_CLASS TEXT("Volume Control")
#define DBG DbgPrint("SNDVOL32: %s:%i: ", __FILE__, __LINE__); DbgPrint
ULONG DbgPrint(PCH , ...);
#define DPRINT DbgPrint("SNDVOL32: %s:%i: ", __FILE__, __LINE__); DbgPrint
/*
@ -74,4 +75,18 @@ BOOL SndMixerEnumProducts(PSND_MIXER Mixer, PFNSNDMIXENUMPRODUCTS EnumProc, PVOI
INT SndMixerGetDestinationCount(PSND_MIXER Mixer);
BOOL SndMixerEnumDestinationLines(PSND_MIXER Mixer, PFNSNDMIXENUMLINES EnumProc, PVOID Context);
/*
* MISC
*/
INT
AllocAndLoadString(OUT LPWSTR *lpTarget,
IN HINSTANCE hInst,
IN UINT uID);
DWORD
LoadAndFormatString(IN HINSTANCE hInstance,
IN UINT uID,
OUT LPWSTR *lpTarget,
...);
#endif /* __SNDVOL32_H */

19
reactos/subsys/system/sndvol32/sndvol32.xml Normal file
View file

@ -0,0 +1,19 @@
<module name="sndvol32" type="win32gui" installbase="system32" installname="sndvol32.exe">
<include base="ReactOS">include/wine</include>
<include base="sndvol32">.</include>
<define name="__USE_W32API" />
<define name="UNICODE" />
<define name="_UNICODE" />
<define name="_WIN32_WINNT">0x6501</define>
<library>ntdll</library>
<library>user32</library>
<library>gdi32</library>
<library>kernel32</library>
<library>comctl32</library>
<library>shell32</library>
<library>winmm</library>
<pch>sndvol32.h</pch>
<file>misc.c</file>
<file>mixer.c</file>
<file>sndvol32.c</file>
</module>