sndvol32.c File Reference

#include "sndvol32.h"
#include <shellapi.h>

Include dependency graph for sndvol32.c:

Go to the source code of this file.

Classes
struct	_PREFERENCES_FILL_DEVICES

Macros
#define	GetDialogData(hwndDlg, type)    ( P##type )GetWindowLongPtr((hwndDlg), DWLP_USER)
#define	GetWindowData(hwnd, type)    ( P##type )GetWindowLongPtr((hwnd), GWL_USERDATA)

Typedefs
typedef struct _PREFERENCES_FILL_DEVICES	PREFERENCES_FILL_DEVICES
typedef struct _PREFERENCES_FILL_DEVICES *	PPREFERENCES_FILL_DEVICES

Functions
static BOOL CALLBACK	FillDeviceComboBox (PSND_MIXER Mixer, UINT Id, LPCTSTR ProductName, PVOID Context)
static BOOL CALLBACK	PrefDlgAddLine (PSND_MIXER Mixer, LPMIXERLINE Line, UINT DisplayControls, PVOID Context)
static BOOL CALLBACK	PrefDlgAddConnection (PSND_MIXER Mixer, DWORD LineID, LPMIXERLINE Line, PVOID Context)
static VOID	UpdatePrefDlgControls (PPREFERENCES_CONTEXT Context, DWORD LineID)
static VOID	WriteLineSettings (PPREFERENCES_CONTEXT Context, HWND hwndDlg)
static INT_PTR CALLBACK	DlgPreferencesProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	DeleteMixerWindowControls (PMIXER_WINDOW MixerWindow)
static BOOL	RebuildMixerWindowControls (PPREFERENCES_CONTEXT PrefContext)
static BOOL CALLBACK	SetVolumeCallback (PSND_MIXER Mixer, DWORD LineID, LPMIXERLINE Line, PVOID Ctx)
static BOOL CALLBACK	MixerControlChangeCallback (PSND_MIXER Mixer, DWORD LineID, LPMIXERLINE Line, PVOID Context)
static LRESULT CALLBACK	MainWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	RegisterApplicationClasses (VOID)
static VOID	UnregisterApplicationClasses (VOID)
static HWND	CreateApplicationWindow (WINDOW_MODE WindowMode, UINT MixerId)
static BOOL	HandleCommandLine (LPTSTR cmdline, DWORD dwStyle, PWINDOW_MODE pMode, PUINT pMixerId)
int WINAPI	_tWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpszCmdLine, int nCmdShow)

Variables
HINSTANCE	hAppInstance
ATOM	MainWindowClass
HWND	hMainWnd
HANDLE	hAppHeap
LPTSTR	lpAppTitle
PREFERENCES_CONTEXT	Preferences

Macro Definition Documentation

GetDialogData

#define GetDialogData	(		hwndDlg,
			type
	)		( P##type )GetWindowLongPtr((hwndDlg), DWLP_USER)

Definition at line 21 of file sndvol32.c.

GetWindowData

#define GetWindowData	(		hwnd,
			type
	)		( P##type )GetWindowLongPtr((hwnd), GWL_USERDATA)

Definition at line 23 of file sndvol32.c.

Typedef Documentation

PPREFERENCES_FILL_DEVICES

typedef struct _PREFERENCES_FILL_DEVICES * PPREFERENCES_FILL_DEVICES

PREFERENCES_FILL_DEVICES

typedef struct _PREFERENCES_FILL_DEVICES PREFERENCES_FILL_DEVICES

Function Documentation

_tWinMain()

int WINAPI _tWinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		LPTSTR	lpszCmdLine,
		int	nCmdShow
	)

Definition at line 1444 of file sndvol32.c.

{
    MSG Msg;
    int Ret = 1;
    INITCOMMONCONTROLSEX Controls;
    WINDOW_MODE WindowMode = SMALL_MODE;
    UINT MixerId = 0;
    DWORD dwStyle;
 
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(nCmdShow);
 
    hAppInstance = hInstance;
    hAppHeap = GetProcessHeap();
 
    if (InitAppConfig())
    {
        dwStyle = GetStyleValue();
        HandleCommandLine(lpszCmdLine, dwStyle, &WindowMode, &MixerId);
 
        /* load the application title */
        if (!AllocAndLoadString(&lpAppTitle,
                                hAppInstance,
                                IDS_SNDVOL32))
        {
            lpAppTitle = NULL;
        }
 
        Controls.dwSize = sizeof(INITCOMMONCONTROLSEX);
        Controls.dwICC = ICC_BAR_CLASSES | ICC_STANDARD_CLASSES;
 
        InitCommonControlsEx(&Controls);
 
        if (WindowMode == TRAY_MODE)
        {
            DialogBoxParam(hAppInstance,
                           MAKEINTRESOURCE(IDD_TRAY_MASTER),
                           NULL,
                           TrayDlgProc,
                           0);
        }
        else
        {
            if (RegisterApplicationClasses())
            {
                hMainWnd = CreateApplicationWindow(WindowMode, MixerId);
                if (hMainWnd != NULL)
                {
                    BOOL bRet;
                    while ((bRet =GetMessage(&Msg,
                                             NULL,
                                             0,
                                             0)) != 0)
                    {
                        if (bRet != -1)
                        {
                            TranslateMessage(&Msg);
                            DispatchMessage(&Msg);
                        }
                    }
 
                    DestroyWindow(hMainWnd);
                    Ret = 0;
                }
                else
                {
                    DPRINT("Failed to create application window (LastError: %d)!\n", GetLastError());
                }
 
                UnregisterApplicationClasses();
            }
            else
            {
                DPRINT("Failed to register application classes (LastError: %d)!\n", GetLastError());
            }
        }
 
        if (lpAppTitle != NULL)
        {
            LocalFree(lpAppTitle);
        }
 
        CloseAppConfig();
    }
    else
    {
        DPRINT("Unable to open the Volume Control registry key!\n");
    }
 
    return Ret;
}

CreateApplicationWindow()

static HWND CreateApplicationWindow ( WINDOW_MODE  WindowMode, UINT  MixerId  )

static

Definition at line 1320 of file sndvol32.c.

{
    HWND hWnd;
 
    PMIXER_WINDOW MixerWindow = HeapAlloc(hAppHeap,
                                          HEAP_ZERO_MEMORY,
                                          sizeof(MIXER_WINDOW));
    if (MixerWindow == NULL)
    {
        return NULL;
    }
 
    MixerWindow->Mode = WindowMode;
    MixerWindow->MixerId = MixerId;
 
    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,
                              0, 0, 300, 315,
                              NULL,
                              LoadMenu(hAppInstance,
                                       MAKEINTRESOURCE(IDM_MAINMENU)),
                              hAppInstance,
                              MixerWindow);
    }
    else
    {
        LPTSTR lpErrMessage;
 
        /*
         * no mixer devices are available!
         */
 
        hWnd = NULL;
        if (AllocAndLoadString(&lpErrMessage,
                               hAppInstance,
                               IDS_NOMIXERDEVICES))
        {
            MessageBox(NULL,
                       lpErrMessage,
                       lpAppTitle,
                       MB_ICONINFORMATION);
            LocalFree(lpErrMessage);
        }
    }
 
    if (hWnd == NULL)
    {
        HeapFree(hAppHeap,
                 0,
                 MixerWindow);
    }
 
    return hWnd;
}

Referenced by _tWinMain().

DeleteMixerWindowControls()

static VOID DeleteMixerWindowControls ( PMIXER_WINDOW  MixerWindow )

static

Definition at line 581 of file sndvol32.c.

{
    DWORD Index;
 
    for(Index = 0; Index < MixerWindow->WindowCount; Index++)
    {
        /* destroys the window */
        DestroyWindow(MixerWindow->Window[Index]);
    }
 
    /* free memory */
    HeapFree(GetProcessHeap(), 0, MixerWindow->Window);
 
    /* set to null */
    MixerWindow->Window = NULL;
    MixerWindow->WindowCount = 0;
}

Referenced by RebuildMixerWindowControls().

DlgPreferencesProc()

static INT_PTR CALLBACK DlgPreferencesProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 391 of file sndvol32.c.

{
    PPREFERENCES_CONTEXT Context;
 
    switch (uMsg)
    {
        case WM_COMMAND:
        {
            Context = GetDialogData(hwndDlg,
                                    PREFERENCES_CONTEXT);
            switch (LOWORD(wParam))
            {
                case IDC_MIXERDEVICE:
                {
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        UpdatePrefDlgControls(Context,
                                              (DWORD)-1);
                    }
                    break;
                }
 
                case IDC_LINE:
                {
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        INT LineID;
                        INT Index;
 
                        Index = SendDlgItemMessage(hwndDlg,
                                                   IDC_LINE,
                                                   CB_GETCURSEL,
                                                   0,
                                                   0);
                        if (Index != CB_ERR)
                        {
                            LineID = SendDlgItemMessage(hwndDlg,
                                                        IDC_LINE,
                                                        CB_GETITEMDATA,
                                                        Index,
                                                        0);
                            if (LineID != CB_ERR)
                            {
                                UpdatePrefDlgControls(Context,
                                                      LineID);
                            }
                        }
                    }
                    break;
                }
 
                case IDC_PLAYBACK:
                {
                    UpdatePrefDlgControls(Context,
                                          Context->PlaybackID);
                    EnableWindow(GetDlgItem(hwndDlg,
                                            IDC_LINE),
                                 FALSE);
                    break;
                }
 
                case IDC_RECORDING:
                {
                    UpdatePrefDlgControls(Context,
                                          Context->RecordingID);
                    EnableWindow(GetDlgItem(hwndDlg,
                                            IDC_LINE),
                                 FALSE);
                    break;
                }
 
                case IDC_OTHER:
                {
                    INT LineCbIndex;
                    INT LineID;
 
                    EnableWindow(GetDlgItem(hwndDlg,
                                            IDC_LINE),
                                 TRUE);
 
                    LineCbIndex = SendDlgItemMessage(hwndDlg,
                                                     IDC_LINE,
                                                     CB_GETCURSEL,
                                                     0,
                                                     0);
                    if (LineCbIndex != CB_ERR)
                    {
                        LineID = SendDlgItemMessage(hwndDlg,
                                                    IDC_LINE,
                                                    CB_GETITEMDATA,
                                                    LineCbIndex,
                                                    0);
                        if (LineID != CB_ERR)
                        {
                            UpdatePrefDlgControls(Context,
                                                  LineID);
                        }
                    }
                    break;
                }
 
                case IDOK:
                {
                    /* write line settings */
                    WriteLineSettings(Context, hwndDlg);
 
                    /* fall through */
                }
                case IDCANCEL:
                {
                    EndDialog(hwndDlg,
                              LOWORD(wParam));
                    break;
                }
            }
            break;
        }
 
        case WM_INITDIALOG:
        {
            PREFERENCES_FILL_DEVICES FillDevContext;
            LVCOLUMN lvc;
            RECT rcClient;
            HWND hwndControls;
 
            SetWindowLongPtr(hwndDlg,
                             DWLP_USER,
                             (LONG_PTR)lParam);
            Context = (PPREFERENCES_CONTEXT)((LONG_PTR)lParam);
            Context->hwndDlg = hwndDlg;
            Context->Mixer = SndMixerCreate(hwndDlg, Context->MixerWindow->MixerId);
            Context->Selected = (UINT)-1;
 
            FillDevContext.PrefContext = Context;
            FillDevContext.hComboBox = GetDlgItem(hwndDlg,
                                                  IDC_MIXERDEVICE);
            FillDevContext.Selected = SndMixerGetSelection(Context->Mixer);
            SndMixerEnumProducts(Context->Mixer,
                                 FillDeviceComboBox,
                                 &FillDevContext);
 
            /* initialize the list view control */
            hwndControls = GetDlgItem(hwndDlg,
                                      IDC_CONTROLS);
            (void)ListView_SetExtendedListViewStyle(hwndControls,
                                                    LVS_EX_CHECKBOXES);
 
            GetClientRect(hwndControls,
                          &rcClient);
            lvc.mask = LVCF_TEXT | LVCF_WIDTH;
            lvc.pszText = TEXT("");
            lvc.cx = rcClient.right;
            SendMessage(hwndControls,
                        LVM_INSERTCOLUMN,
                        0,
                        (LPARAM)&lvc);
 
            /* update all controls */
            UpdatePrefDlgControls(Context,
                                  (DWORD)Context->SelectedLine);
            return TRUE;
        }
 
        case WM_CLOSE:
        {
            EndDialog(hwndDlg,
                      IDCANCEL);
            break;
        }
 
        case WM_SYSCOLORCHANGE:
        {
            HWND hwndControls;
 
            /* Forward WM_SYSCOLORCHANGE */
            hwndControls = GetDlgItem(hwndDlg, IDC_CONTROLS);
            SendMessage(hwndControls, WM_SYSCOLORCHANGE, 0, 0);
            break;
        }
    }
 
    return 0;
}

Referenced by MainWindowProc().

FillDeviceComboBox()

static BOOL CALLBACK FillDeviceComboBox ( PSND_MIXER  Mixer, UINT  Id, LPCTSTR  ProductName, PVOID  Context  )

static

Definition at line 38 of file sndvol32.c.

{
    LRESULT lres;
    PPREFERENCES_FILL_DEVICES FillContext = (PPREFERENCES_FILL_DEVICES)Context;
 
    UNREFERENCED_PARAMETER(Mixer);
 
    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)
        {
            SendMessage(FillContext->hComboBox,
                        CB_SETCURSEL,
                        (WPARAM)lres,
                        0);
        }
    }
 
    return TRUE;
}

Referenced by DlgPreferencesProc().

HandleCommandLine()

static BOOL HandleCommandLine ( LPTSTR  cmdline, DWORD  dwStyle, PWINDOW_MODE  pMode, PUINT  pMixerId  )

static

Definition at line 1383 of file sndvol32.c.

{
    TCHAR option;
 
    *pMixerId = PLAY_MIXER;
    *pMode = (dwStyle & 0x20) ? SMALL_MODE : NORMAL_MODE;
 
    while (*cmdline == _T(' ') || *cmdline == _T('-') || *cmdline == _T('/'))
    {
        if (*cmdline++ == _T(' '))
            continue;
 
        option = *cmdline;
        if (option)
            cmdline++;
        while (*cmdline == _T(' '))
            cmdline++;
 
        switch (option)
        {
            case 'd': /* Device */
            case 'D':
                break;
 
            case 'n': /* Small size */
            case 'N':
                *pMode = NORMAL_MODE;
                break;
 
            case 's': /* Small size */
            case 'S':
                *pMode = SMALL_MODE;
                break;
 
            case 't': /* Tray size */
            case 'T':
                *pMode = TRAY_MODE;
                break;
 
            case 'p': /* Play mode */
            case 'P':
                *pMixerId = PLAY_MIXER;
                break;
 
            case 'r': /* Record mode */
            case 'R':
                *pMixerId = RECORD_MIXER;
                break;
 
            default:
                return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by _tWinMain().

MainWindowProc()

static LRESULT CALLBACK MainWindowProc ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 860 of file sndvol32.c.

{
    PMIXER_WINDOW MixerWindow;
    DWORD CtrlID, LineOffset;
    BOOL bRet;
    LRESULT Result = 0;
    SET_VOLUME_CONTEXT Context;
 
    switch (uMsg)
    {
        case WM_COMMAND:
        {
            MixerWindow = GetWindowData(hwnd,
                                        MIXER_WINDOW);
 
            switch (LOWORD(wParam))
            {
                case IDM_PROPERTIES:
                {
                    PREFERENCES_CONTEXT Pref;
 
                    Pref.MixerWindow = MixerWindow;
                    Pref.Mixer = NULL;
                    Pref.SelectedLine = Preferences.SelectedLine;
 
                    if (DialogBoxParam(hAppInstance,
                                       MAKEINTRESOURCE(IDD_PREFERENCES),
                                       hwnd,
                                       DlgPreferencesProc,
                                       (LPARAM)&Pref) == IDOK)
                    {
                        /* update window */
                        TCHAR szProduct[MAXPNAMELEN];
 
                        /* get mixer product name */
                        if (SndMixerGetProductName(Pref.Mixer,
                                                   szProduct,
                                                   sizeof(szProduct) / sizeof(szProduct[0])) == -1)
                        {
                            /* failed to get name */
                            szProduct[0] = L'\0';
                        }
                        else
                        {
                            /* copy product */
                            wcscpy(Preferences.DeviceName, szProduct);
                        }
 
                        /* destroy old status bar */
                        if (MixerWindow->Mode == NORMAL_MODE)
                            DestroyWindow(MixerWindow->hStatusBar);
 
                        /* update details */
                        Preferences.SelectedLine = Pref.SelectedLine;
 
                        /* destroy old mixer */
                        SndMixerDestroy(Preferences.MixerWindow->Mixer);
 
                        /* use new selected mixer */
                        Preferences.MixerWindow->Mixer = Pref.Mixer;
 
                        /* create status window */
                        if (MixerWindow->Mode == NORMAL_MODE)
                        {
                            MixerWindow->hStatusBar = CreateStatusWindow(WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS,
                                                                         NULL,
                                                                         hwnd,
                                                                         0);
                            if (MixerWindow->hStatusBar)
                            {
                                /* Set status bar */
                                SendMessage(MixerWindow->hStatusBar,
                                    WM_SETTEXT,
                                    0,
                                    (LPARAM)szProduct);
                            }
                        }
 
                        /* rebuild dialog controls */
                        RebuildMixerWindowControls(&Preferences);
                    }
                    break;
                }
 
                case IDM_ADVANCED_CONTROLS:
                    MixerWindow->bShowExtendedControls = !MixerWindow->bShowExtendedControls;
                    CheckMenuItem(GetMenu(hwnd),
                                  IDM_ADVANCED_CONTROLS,
                                  MF_BYCOMMAND | (MixerWindow->bShowExtendedControls ? MF_CHECKED : MF_UNCHECKED));
                    RebuildMixerWindowControls(&Preferences);
                    break;
 
                case IDM_EXIT:
                {
                    PostQuitMessage(0);
                    UnregisterHotKey(hwnd, HOTKEY_CTRL_S);
                    break;
                }
 
                case IDM_ABOUT:
                {
                    HICON hAppIcon = (HICON)GetClassLongPtrW(hwnd,
                                                             GCLP_HICON);
                    ShellAbout(hwnd,
                               lpAppTitle,
                               NULL,
                               hAppIcon);
                    break;
                }
 
                default:
                {
                    /* get button id */
                    CtrlID = LOWORD(wParam);
 
                    /* check if the message is from the line switch */
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        if (CtrlID % IDC_LINE_SWITCH == 0)
                        {
                            /* compute line offset */
                            LineOffset = CtrlID / IDC_LINE_SWITCH;
 
                            /* compute window id of line name static control */
                            CtrlID = LineOffset * IDC_LINE_NAME;
 
                            if (Preferences.MixerWindow->Mixer->MixerId == PLAY_MIXER)
                            {
                                /* get line name */
                                if (GetDlgItemTextW(hwnd, CtrlID, Context.LineName, MIXER_LONG_NAME_CHARS) != 0)
                                {
                                    /* setup context */
                                    Context.SliderPos = SendMessage((HWND)lParam, BM_GETCHECK, 0, 0);
                                    Context.bVertical = FALSE;
                                    Context.bSwitch = TRUE;
 
                                    /* set volume */
                                    SndMixerEnumConnections(Preferences.MixerWindow->Mixer, Preferences.SelectedLine, SetVolumeCallback, (LPVOID)&Context);
                                }
                            }
                            else if (Preferences.MixerWindow->Mixer->MixerId == RECORD_MIXER)
                            {
                                UINT i;
 
                                for (i = 0; i < Preferences.MixerWindow->DialogCount; i++)
                                {
                                    SendDlgItemMessageW(hwnd, (i + 1) * IDC_LINE_SWITCH, BM_SETCHECK, (WPARAM)((i + 1) == LineOffset), 0);
                                }
                            }
                        }
                        else if (CtrlID % IDC_LINE_ADVANCED == 0)
                        {
                            ADVANCED_CONTEXT AdvancedContext;
 
                            /* compute line offset */
                            LineOffset = CtrlID / IDC_LINE_ADVANCED;
 
                            /* compute window id of line name static control */
                            CtrlID = LineOffset * IDC_LINE_NAME;
 
                            /* get line name */
                            if (GetDlgItemTextW(hwnd, CtrlID, AdvancedContext.LineName, MIXER_LONG_NAME_CHARS) != 0)
                            {
                                AdvancedContext.MixerWindow = Preferences.MixerWindow;
                                AdvancedContext.Mixer = Preferences.MixerWindow->Mixer;
                                AdvancedContext.Line = SndMixerGetLineByName(Preferences.MixerWindow->Mixer,
                                                                             Preferences.SelectedLine,
                                                                             AdvancedContext.LineName);
                                if (AdvancedContext.Line)
                                {
                                    DialogBoxParam(hAppInstance,
                                                   MAKEINTRESOURCE(IDD_ADVANCED),
                                                   hwnd,
                                                   AdvancedDlgProc,
                                                   (LPARAM)&AdvancedContext);
                                }
                            }
                        }
                    }
                }
            }
            break;
        }
 
        case MM_MIXM_LINE_CHANGE:
        {
            DPRINT("MM_MIXM_LINE_CHANGE\n");
            break;
        }
 
        case MM_MIXM_CONTROL_CHANGE:
        {
            DPRINT("MM_MIXM_CONTROL_CHANGE\n");
 
            /* get mixer window */
            MixerWindow = GetWindowData(hwnd,
                                        MIXER_WINDOW);
 
            /* sanity checks */
            assert(MixerWindow);
            assert(MixerWindow->Mixer->hmx == (HMIXER)wParam);
 
            SndMixerEnumConnections(MixerWindow->Mixer, Preferences.SelectedLine, MixerControlChangeCallback, (PVOID)lParam);
            break;
        }
 
        case WM_VSCROLL:
            switch (LOWORD(wParam))
            {
                case TB_THUMBTRACK:
                    /* get dialog item ctrl */
                    CtrlID = GetDlgCtrlID((HWND)lParam);
 
                    /* get line index */
                    LineOffset = CtrlID / IDC_LINE_SLIDER_VERT;
 
                    /* compute window id of line name static control */
                    CtrlID = LineOffset * IDC_LINE_NAME;
 
                    /* get line name */
                    if (GetDlgItemTextW(hwnd, CtrlID, Context.LineName, MIXER_LONG_NAME_CHARS) != 0)
                    {
                        /* setup context */
                        Context.SliderPos = LineOffset;
                        Context.bVertical = TRUE;
                        Context.bSwitch = FALSE;
 
                        /* set volume */
                        SndMixerEnumConnections(Preferences.MixerWindow->Mixer, Preferences.SelectedLine, SetVolumeCallback, (LPVOID)&Context);
                    }
                    break;
 
                case TB_ENDTRACK:
                    MixerWindow = GetWindowData(hwnd,
                                                MIXER_WINDOW);
 
                    /* get dialog item ctrl */
                    CtrlID = GetDlgCtrlID((HWND)lParam);
 
                    /* get line index */
                    LineOffset = CtrlID / IDC_LINE_SLIDER_VERT;
 
                    if (LineOffset == 1 && MixerWindow->Mixer->MixerId == 0)
                        PlaySound((LPCTSTR)SND_ALIAS_SYSTEMDEFAULT, NULL, SND_ASYNC | SND_ALIAS_ID);
                    break;
 
                default:
                    break;
            }
            break;
 
        case WM_HSCROLL:
            switch (LOWORD(wParam))
            {
                case TB_THUMBTRACK:
                    /* get dialog item ctrl */
                    CtrlID = GetDlgCtrlID((HWND)lParam);
 
                    /* get line index */
                    LineOffset = CtrlID / IDC_LINE_SLIDER_HORZ;
 
                    /* compute window id of line name static control */
                    CtrlID = LineOffset * IDC_LINE_NAME;
 
                    /* get line name */
                    if (GetDlgItemTextW(hwnd, CtrlID, Context.LineName, MIXER_LONG_NAME_CHARS) != 0)
                    {
                        /* setup context */
                        Context.SliderPos = LineOffset;
                        Context.bVertical = TRUE;
                        Context.bSwitch = FALSE;
 
                        /* set volume */
                        SndMixerEnumConnections(Preferences.MixerWindow->Mixer, Preferences.SelectedLine, SetVolumeCallback, (LPVOID)&Context);
                    }
                    break;
 
                case TB_ENDTRACK:
                    MixerWindow = GetWindowData(hwnd,
                                                MIXER_WINDOW);
 
                    /* get dialog item ctrl */
                    CtrlID = GetDlgCtrlID((HWND)lParam);
 
                    /* get line index */
                    LineOffset = CtrlID / IDC_LINE_SLIDER_HORZ;
 
                    if (LineOffset == 1 && MixerWindow->Mixer->MixerId == 0)
                        PlaySound((LPCTSTR)SND_ALIAS_SYSTEMDEFAULT, NULL, SND_ASYNC | SND_ALIAS_ID);
                    break;
 
                default:
                    break;
            }
            break;
 
 
        case WM_CREATE:
        {
            MixerWindow = ((LPCREATESTRUCT)lParam)->lpCreateParams;
            SetWindowLongPtr(hwnd,
                             GWL_USERDATA,
                             (LONG_PTR)MixerWindow);
            MixerWindow->hWnd = hwnd;
            MixerWindow->Mixer = SndMixerCreate(MixerWindow->hWnd, MixerWindow->MixerId);
            if (MixerWindow->Mixer != NULL)
            {
                TCHAR szProduct[MAXPNAMELEN];
 
                /* get mixer product name */
                if (SndMixerGetProductName(MixerWindow->Mixer,
                                           szProduct,
                                           sizeof(szProduct) / sizeof(szProduct[0])) == -1)
                {
                    /* failed to get name */
                    szProduct[0] = L'\0';
                }
 
 
                /* initialize preferences */
                ZeroMemory(&Preferences, sizeof(Preferences));
 
                /* store mixer */
                Preferences.Mixer = MixerWindow->Mixer;
 
                /* store mixer window */
                Preferences.MixerWindow = MixerWindow;
 
                /* first destination line id */
                Preferences.SelectedLine = 0xFFFF0000;
 
                /* copy product */
                wcscpy(Preferences.DeviceName, szProduct);
 
                /* Disable the 'Advanced Controls' menu item */
                EnableMenuItem(GetMenu(hwnd), IDM_ADVANCED_CONTROLS, MF_BYCOMMAND | MF_GRAYED);
 
                /* Load the placement coordinate data of the window */
                bRet = LoadXYCoordWnd(&Preferences);
                if (bRet)
                {
                    /*
                     * LoadXYCoordWnd() might fail for the first time of opening the application which is normal as
                     * the Sound Control's applet settings haven't been saved yet to the Registry. At this point SetWindowPos()
                     * call is skipped.
                     */
                    SetWindowPos(hwnd, NULL, MixerWindow->WndPosX, MixerWindow->WndPosY, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
                }
 
                /* create status window */
                if (MixerWindow->Mode == NORMAL_MODE)
                {
                    MixerWindow->hStatusBar = CreateStatusWindow(WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS,
                                                                 NULL,
                                                                 hwnd,
                                                                 0);
                    if (MixerWindow->hStatusBar)
                    {
                        SendMessage(MixerWindow->hStatusBar,
                                    WM_SETTEXT,
                                    0,
                                   (LPARAM)szProduct);
                    }
                }
 
                if (!RebuildMixerWindowControls(&Preferences))
                {
                    DPRINT("Rebuilding mixer window controls failed!\n");
                    SndMixerDestroy(MixerWindow->Mixer);
                    MixerWindow->Mixer = NULL;
                    Result = -1;
                }
            }
 
            RegisterHotKey(hwnd, HOTKEY_CTRL_S, MOD_CONTROL, 'S');
            break;
        }
 
        case WM_DESTROY:
        {
            MixerWindow = GetWindowData(hwnd,
                                        MIXER_WINDOW);
            if (MixerWindow != NULL)
            {
                if (MixerWindow->Mixer != NULL)
                {
                    SndMixerDestroy(MixerWindow->Mixer);
                }
                if (MixerWindow->hFont)
                    DeleteObject(MixerWindow->hFont);
                HeapFree(hAppHeap, 0, MixerWindow);
            }
            break;
        }
 
        case WM_CLOSE:
        {
            SaveXYCoordWnd(hwnd, &Preferences);
            PostQuitMessage(0);
            break;
        }
 
        case WM_HOTKEY:
        {
            if (wParam == HOTKEY_CTRL_S) 
            {
                Preferences.MixerWindow->Mode = (Preferences.MixerWindow->Mode == NORMAL_MODE ? SMALL_MODE : NORMAL_MODE);
                RebuildMixerWindowControls(&Preferences);
            }
            break;
        }
 
        default:
        {
            Result = DefWindowProc(hwnd,
                                   uMsg,
                                   wParam,
                                   lParam);
            break;
        }
    }
 
    return Result;
}

Referenced by RegisterApplicationClasses().

MixerControlChangeCallback()

static BOOL CALLBACK MixerControlChangeCallback ( PSND_MIXER  Mixer, DWORD  LineID, LPMIXERLINE  Line, PVOID  Context  )

static

Definition at line 739 of file sndvol32.c.

{
    PMIXERCONTROLDETAILS_UNSIGNED pVolumeDetails = NULL;
    UINT ControlCount = 0, Index;
    LPMIXERCONTROL Control = NULL;
 
    /* check if the line has controls */
    if (Line->cControls == 0)
    {
        /* no controls */
        return TRUE;
    }
 
    /* query controls */
    if (SndMixerQueryControls(Mixer, &ControlCount, Line, &Control) == FALSE)
    {
        /* failed to query for controls */
        return FALSE;
    }
 
    pVolumeDetails = HeapAlloc(GetProcessHeap(),
                               0,
                               Line->cChannels * sizeof(MIXERCONTROLDETAILS_UNSIGNED));
    if (pVolumeDetails == NULL)
        goto done;
 
    /* now go through all controls and compare control ids */
    for (Index = 0; Index < ControlCount; Index++)
    {
        if (Control[Index].dwControlID == PtrToUlong(Context))
        {
            if (Control[Index].dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
            {
                MIXERCONTROLDETAILS_BOOLEAN Details;
 
                /* get volume control details */
                if (SndMixerGetVolumeControlDetails(Preferences.MixerWindow->Mixer, Control[Index].dwControlID, 1, sizeof(MIXERCONTROLDETAILS_BOOLEAN), (LPVOID)&Details) != -1)
                {
                    /* update dialog control */
                    UpdateDialogLineSwitchControl(&Preferences, Line, Details.fValue);
                }
            }
            else if (Control[Index].dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
            {
                /* get volume control details */
                if (SndMixerGetVolumeControlDetails(Preferences.MixerWindow->Mixer, Control[Index].dwControlID, Line->cChannels, sizeof(MIXERCONTROLDETAILS_UNSIGNED), (LPVOID)pVolumeDetails) != -1)
                {
                    /* update dialog control */
                    DWORD volumePosition, volumeStep, maxVolume, i;
                    DWORD balancePosition, balanceStep;
 
                    volumeStep = (Control[Index].Bounds.dwMaximum - Control[Index].Bounds.dwMinimum) / (VOLUME_MAX - VOLUME_MIN);
 
                    maxVolume = 0;
                    for (i = 0; i < Line->cChannels; i++)
                    {
                        if (pVolumeDetails[i].dwValue > maxVolume)
                            maxVolume = pVolumeDetails[i].dwValue;
                    }
 
                    volumePosition = (maxVolume - Control[Index].Bounds.dwMinimum) / volumeStep;
 
                    if (Line->cChannels == 1)
                    {
                        balancePosition = BALANCE_CENTER;
                    }
                    else if (Line->cChannels == 2)
                    {
                        if (pVolumeDetails[0].dwValue == pVolumeDetails[1].dwValue)
                        {
                            balancePosition = BALANCE_CENTER;
                        }
                        else if (pVolumeDetails[0].dwValue == Control[Index].Bounds.dwMinimum)
                        {
                            balancePosition = BALANCE_RIGHT;
                        }
                        else if (pVolumeDetails[1].dwValue == Control[Index].Bounds.dwMinimum)
                        {
                            balancePosition = BALANCE_LEFT;
                        }
                        else
                        {
                            balanceStep = (maxVolume - Control[Index].Bounds.dwMinimum) / (BALANCE_STEPS / 2);
 
                            if (pVolumeDetails[0].dwValue < pVolumeDetails[1].dwValue)
                            {
                                balancePosition = (pVolumeDetails[0].dwValue - Control[Index].Bounds.dwMinimum) / balanceStep;
                                balancePosition = BALANCE_RIGHT - balancePosition;
                            }
                            else if (pVolumeDetails[1].dwValue < pVolumeDetails[0].dwValue)
                            {
                                balancePosition = (pVolumeDetails[1].dwValue - Control[Index].Bounds.dwMinimum) / balanceStep;
                                balancePosition = BALANCE_LEFT + balancePosition;
                            }
                        }
                    }
 
                    /* Update the volume control slider */
                    UpdateDialogLineSliderControl(&Preferences, Line, IDC_LINE_SLIDER_VERT, VOLUME_MAX - volumePosition);
 
                    /* Update the balance control slider */
                    UpdateDialogLineSliderControl(&Preferences, Line, IDC_LINE_SLIDER_HORZ, balancePosition);
                }
            }
            break;
        }
    }
 
done:
    /* Free the volume details */
    if (pVolumeDetails)
        HeapFree(GetProcessHeap(), 0, pVolumeDetails);
 
    /* free controls */
    HeapFree(GetProcessHeap(), 0, Control);
 
    /* done */
    return TRUE;
}

Referenced by MainWindowProc().

PrefDlgAddConnection()

static BOOL CALLBACK PrefDlgAddConnection ( PSND_MIXER  Mixer, DWORD  LineID, LPMIXERLINE  Line, PVOID  Context  )

static

Definition at line 150 of file sndvol32.c.

{
    PPREFERENCES_CONTEXT PrefContext = (PPREFERENCES_CONTEXT)Context;
    HWND hwndControls;
    LVITEM lvi;
    UINT i;
 
    UNREFERENCED_PARAMETER(Mixer);
    UNREFERENCED_PARAMETER(LineID);
 
    if (Line->cControls != 0)
    {
        hwndControls = GetDlgItem(PrefContext->hwndDlg,
                                  IDC_CONTROLS);
 
        lvi.mask = LVIF_TEXT | LVIF_PARAM;
        lvi.iItem = PrefContext->tmp++;
        lvi.iSubItem = 0;
        lvi.pszText = Line->szName;
        lvi.lParam = (LPARAM)Line->dwSource;
 
        i = SendMessage(hwndControls,
                        LVM_INSERTITEM,
                        0,
                        (LPARAM)&lvi);
        if (i != (UINT)-1)
        {
            TCHAR LineName[MIXER_LONG_NAME_CHARS];
            DWORD Flags;
            BOOL SelLine = FALSE;
 
            if (SndMixerGetLineName(PrefContext->Mixer,
                                    PrefContext->SelectedLine,
                                    LineName,
                                    MIXER_LONG_NAME_CHARS,
                                    TRUE) == -1)
            {
                LineName[0] = TEXT('\0');
            }
 
            if (ReadLineConfig(PrefContext->DeviceName,
                               LineName,
                               Line->szName,
                               &Flags))
            {
                if (Flags != 0x4)
                {
                    SelLine = TRUE;
                }
            }
 
            ListView_SetCheckState(hwndControls,
                                   i,
                                   SelLine);
        }
    }
 
    return TRUE;
}

Referenced by UpdatePrefDlgControls().

PrefDlgAddLine()

static BOOL CALLBACK PrefDlgAddLine ( PSND_MIXER  Mixer, LPMIXERLINE  Line, UINT  DisplayControls, PVOID  Context  )

static

Definition at line 73 of file sndvol32.c.

{
    PPREFERENCES_CONTEXT PrefContext = (PPREFERENCES_CONTEXT)Context;
 
    UNREFERENCED_PARAMETER(Mixer);
    UNREFERENCED_PARAMETER(DisplayControls);
 
    switch (Line->dwComponentType)
    {
        case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS:
            if (PrefContext->PlaybackID == (DWORD)-1)
            {
                PrefContext->PlaybackID = Line->dwLineID;
 
                if (PrefContext->SelectedLine == (DWORD)-1)
                {
                    PrefContext->SelectedLine = Line->dwLineID;
                }
            }
            else
                goto AddToOthersLines;
 
            break;
 
        case MIXERLINE_COMPONENTTYPE_DST_WAVEIN:
            if (PrefContext->RecordingID == (DWORD)-1)
            {
                PrefContext->RecordingID = Line->dwLineID;
 
                if (PrefContext->SelectedLine == (DWORD)-1)
                {
                    PrefContext->SelectedLine = Line->dwLineID;
                }
            }
            else
                goto AddToOthersLines;
 
            break;
 
        default:
        {
            LRESULT lres;
            HWND hwndCbOthers;
 
            if (PrefContext->SelectedLine == (DWORD)-1)
            {
                PrefContext->SelectedLine = Line->dwLineID;
            }
 
AddToOthersLines:
            hwndCbOthers = GetDlgItem(PrefContext->hwndDlg,
                                      IDC_LINE);
 
            lres = SendMessage(hwndCbOthers,
                               CB_ADDSTRING,
                               0,
                               (LPARAM)Line->szName);
            if (lres != CB_ERR)
            {
                SendMessage(hwndCbOthers,
                            CB_SETITEMDATA,
                            (WPARAM)lres,
                            Line->dwLineID);
 
                PrefContext->OtherLines++;
            }
            break;
        }
    }
 
    return TRUE;
}

Referenced by UpdatePrefDlgControls().

RebuildMixerWindowControls()

static BOOL RebuildMixerWindowControls ( PPREFERENCES_CONTEXT  PrefContext )

static

Definition at line 600 of file sndvol32.c.

{
    /* delete existing mixer controls */
    DeleteMixerWindowControls(PrefContext->MixerWindow);
 
    /* load new mixer controls */
    LoadDialogCtrls(PrefContext);
 
    return TRUE;
}

Referenced by MainWindowProc().

RegisterApplicationClasses()

static BOOL RegisterApplicationClasses ( VOID  )

static

Definition at line 1289 of file sndvol32.c.

{
    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);
 
    return MainWindowClass != 0;
}

Referenced by _tWinMain().

SetVolumeCallback()

static BOOL CALLBACK SetVolumeCallback ( PSND_MIXER  Mixer, DWORD  LineID, LPMIXERLINE  Line, PVOID  Ctx  )

static

Definition at line 614 of file sndvol32.c.

{
    UINT ControlCount = 0, Index;
    LPMIXERCONTROL Control = NULL;
    PMIXERCONTROLDETAILS_UNSIGNED puDetails = NULL;
    MIXERCONTROLDETAILS_BOOLEAN bDetails;
    PSET_VOLUME_CONTEXT Context = (PSET_VOLUME_CONTEXT)Ctx;
 
    /* check if the line name is equal */
    if (_wcsicmp(Line->szName, Context->LineName))
    {
        /* it is not */
        return TRUE;
    }
 
    /* query controls */
    if (SndMixerQueryControls(Mixer, &ControlCount, Line, &Control) == FALSE)
    {
        /* failed to query for controls */
        return FALSE;
    }
 
    puDetails = HeapAlloc(GetProcessHeap(), 0, Line->cChannels * sizeof(MIXERCONTROLDETAILS_UNSIGNED));
    if (puDetails == NULL)
        return FALSE;
 
    /* now go through all controls and compare control ids */
    for (Index = 0; Index < ControlCount; Index++)
    {
        if (Context->bVertical)
        {
            if (Control[Index].dwControlType == MIXERCONTROL_CONTROLTYPE_VOLUME)
            {
                DWORD LineOffset, volumePosition, balancePosition;
                DWORD volumeStep, balanceStep;
 
                LineOffset = Context->SliderPos;
 
                volumePosition = (DWORD)SendDlgItemMessage(Preferences.MixerWindow->hWnd, LineOffset * IDC_LINE_SLIDER_VERT, TBM_GETPOS, 0, 0);
                volumeStep = (Control[Index].Bounds.dwMaximum - Control[Index].Bounds.dwMinimum) / (VOLUME_MAX - VOLUME_MIN);
 
                if (Line->cChannels == 1)
                {
                    /* set up details */
                    puDetails[0].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
                }
                else if (Line->cChannels == 2)
                {
                    balancePosition = (DWORD)SendDlgItemMessage(Preferences.MixerWindow->hWnd, LineOffset * IDC_LINE_SLIDER_HORZ, TBM_GETPOS, 0, 0);
                    if (balancePosition == BALANCE_CENTER)
                    {
                        puDetails[0].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
                        puDetails[1].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
                    }
                    else if (balancePosition == BALANCE_LEFT)
                    {
                        puDetails[0].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
                        puDetails[1].dwValue = Control[Index].Bounds.dwMinimum;
                    }
                    else if (balancePosition == BALANCE_RIGHT)
                    {
                        puDetails[0].dwValue = Control[Index].Bounds.dwMinimum;
                        puDetails[1].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
                    }
                    else if (balancePosition < BALANCE_CENTER) // Left
                    {
                        puDetails[0].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
 
                        balanceStep = (puDetails[0].dwValue - Control[Index].Bounds.dwMinimum) / (BALANCE_STEPS / 2);
 
                        puDetails[1].dwValue = (balancePosition * balanceStep) + Control[Index].Bounds.dwMinimum;
                    }
                    else if (balancePosition > BALANCE_CENTER) // Right
                    {
                        puDetails[1].dwValue = ((VOLUME_MAX - volumePosition) * volumeStep) + Control[Index].Bounds.dwMinimum;
 
                        balanceStep = (puDetails[1].dwValue - Control[Index].Bounds.dwMinimum) / (BALANCE_STEPS / 2);
 
                        puDetails[0].dwValue = ((BALANCE_RIGHT - balancePosition) * balanceStep) + Control[Index].Bounds.dwMinimum;
                    }
                }
                else
                {
                    SndMixerGetVolumeControlDetails(Preferences.MixerWindow->Mixer, Control[Index].dwControlID, Line->cChannels, sizeof(MIXERCONTROLDETAILS_UNSIGNED), (LPVOID)puDetails);
 
                    /* FIXME */
                }
 
                /* set volume */
                SndMixerSetVolumeControlDetails(Preferences.MixerWindow->Mixer, Control[Index].dwControlID, Line->cChannels, sizeof(MIXERCONTROLDETAILS_UNSIGNED), (LPVOID)puDetails);
 
                /* done */
                break;
            }
        }
        else if (Context->bSwitch)
        {
            if (Control[Index].dwControlType == MIXERCONTROL_CONTROLTYPE_MUTE)
            {
                /* set up details */
                bDetails.fValue = Context->SliderPos;
 
                /* set volume */
                SndMixerSetVolumeControlDetails(Preferences.MixerWindow->Mixer, Control[Index].dwControlID, 1, sizeof(MIXERCONTROLDETAILS_BOOLEAN), (LPVOID)&bDetails);
 
                /* done */
                break;
            }
        }
    }
 
    if (puDetails != NULL)
        HeapFree(GetProcessHeap(), 0, puDetails);
 
    /* free controls */
    HeapFree(GetProcessHeap(), 0, Control);
 
 
    /* done */
    return TRUE;
}

Referenced by MainWindowProc().

UnregisterApplicationClasses()

static VOID UnregisterApplicationClasses ( VOID  )

static

Definition at line 1313 of file sndvol32.c.

{
    UnregisterClass(SZ_APP_CLASS,
                    hAppInstance);
}

Referenced by _tWinMain().

UpdatePrefDlgControls()

static VOID UpdatePrefDlgControls ( PPREFERENCES_CONTEXT  Context, DWORD  LineID  )

static

Definition at line 214 of file sndvol32.c.

{
    INT OldID, MixerID = 0;
    INT DeviceCbIndex;
 
    /* select the mixer */
    DeviceCbIndex = SendDlgItemMessage(Context->hwndDlg,
                                       IDC_MIXERDEVICE,
                                       CB_GETCURSEL,
                                       0,
                                       0);
    if (DeviceCbIndex != CB_ERR)
    {
        MixerID = SendDlgItemMessage(Context->hwndDlg,
                                     IDC_MIXERDEVICE,
                                     CB_GETITEMDATA,
                                     DeviceCbIndex,
                                     0);
        if (MixerID == CB_ERR)
        {
            MixerID = 0;
        }
    }
 
    OldID = Context->Selected;
    if (MixerID != OldID &&
        SndMixerSelect(Context->Mixer,
                       MixerID))
    {
        Context->Selected = SndMixerGetSelection(Context->Mixer);
 
        /* update the controls */
        Context->PlaybackID = (DWORD)-1;
        Context->RecordingID = (DWORD)-1;
        Context->OtherLines = 0;
        Context->SelectedLine = (DWORD)-1;
 
        SndMixerGetProductName(Context->Mixer,
                               Context->DeviceName,
                               sizeof(Context->DeviceName) / sizeof(Context->DeviceName[0]));
 
        if (SndMixerEnumLines(Context->Mixer,
                              PrefDlgAddLine,
                              Context))
        {
            UINT SelBox = 0;
 
            /* enable/disable controls and make default selection */
            EnableWindow(GetDlgItem(Context->hwndDlg,
                                    IDC_PLAYBACK),
                         Context->PlaybackID != (DWORD)-1);
            CheckDlgButton(Context->hwndDlg,
                           IDC_PLAYBACK,
                           (Context->PlaybackID != (DWORD)-1 && SelBox++ == 0) ?
                               BST_CHECKED : BST_UNCHECKED);
 
            EnableWindow(GetDlgItem(Context->hwndDlg,
                                    IDC_RECORDING),
                         Context->RecordingID != (DWORD)-1);
            CheckDlgButton(Context->hwndDlg,
                           IDC_RECORDING,
                           (Context->RecordingID != (DWORD)-1 && SelBox++ == 0) ?
                               BST_CHECKED : BST_UNCHECKED);
 
            if (Context->OtherLines != 0)
            {
                /* select the first item in the other lines combo box by default */
                SendDlgItemMessage(Context->hwndDlg,
                                   IDC_LINE,
                                   CB_SETCURSEL,
                                   0,
                                   0);
            }
            EnableWindow(GetDlgItem(Context->hwndDlg,
                                    IDC_LINE),
                         FALSE);
            EnableWindow(GetDlgItem(Context->hwndDlg,
                                    IDC_OTHER),
                         Context->OtherLines != 0);
            CheckDlgButton(Context->hwndDlg,
                           IDC_LINE,
                           (Context->OtherLines != 0 && SelBox++ == 0) ?
                               BST_CHECKED : BST_UNCHECKED);
 
            /* disable the OK button if the device doesn't have any lines */
            EnableWindow(GetDlgItem(Context->hwndDlg,
                                    IDOK),
                         Context->PlaybackID != (DWORD)-1 ||
                         Context->RecordingID != (DWORD)-1 ||
                         Context->OtherLines != 0);
 
            LineID = Context->SelectedLine;
        }
    }
 
    /* update the line sources list */
    if ((MixerID != OldID && Context->SelectedLine != (DWORD)-1) ||
        (Context->SelectedLine != LineID && LineID != (DWORD)-1))
    {
        Context->SelectedLine = LineID;
 
        (void)ListView_DeleteAllItems(GetDlgItem(Context->hwndDlg,
                                      IDC_CONTROLS));
 
        Context->tmp = 0;
        SndMixerEnumConnections(Context->Mixer,
                                LineID,
                                PrefDlgAddConnection,
                                Context);
    }
}

Referenced by DlgPreferencesProc().

WriteLineSettings()

static VOID WriteLineSettings ( PPREFERENCES_CONTEXT  Context, HWND  hwndDlg  )

static

Definition at line 329 of file sndvol32.c.

{
    HWND hwndControls;
    INT Count, Index;
    WCHAR LineName[MIXER_LONG_NAME_CHARS];
    WCHAR DestinationName[MIXER_LONG_NAME_CHARS];
    DWORD Flags;
    PSNDVOL_REG_LINESTATE LineStates;
 
    /* get list view */
    hwndControls = GetDlgItem(hwndDlg, IDC_CONTROLS);
 
    /* get list item count */
    Count = ListView_GetItemCount(hwndControls);
 
    /* sanity check */
    assert(Count);
 
    if (SndMixerGetLineName(Context->Mixer, Context->SelectedLine, DestinationName, MIXER_LONG_NAME_CHARS, TRUE) == -1)
    {
        /* failed to get destination line name */
        return;
    }
 
    /* allocate line states array */
    LineStates = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SNDVOL_REG_LINESTATE) * Count);
    if (LineStates == NULL)
    {
        /* failed to allocate line states array */
        return;
    }
 
 
    for(Index = 0; Index < Count; Index++)
    {
        /* set to empty */
        LineName[0] = L'\0';
 
        /* get item text */
        ListView_GetItemText(hwndControls, Index, 0, LineName, MIXER_LONG_NAME_CHARS);
 
        /* make sure it is null terminated */
        LineName[MIXER_LONG_NAME_CHARS-1] = L'\0';
 
        /* get check state */
        Flags = (ListView_GetCheckState(hwndControls, Index) == 0 ? 0x4 : 0);
 
        /* copy line name */
        wcscpy(LineStates[Index].LineName, LineName);
 
        /* store flags */
        LineStates[Index].Flags = Flags;
    }
 
    /* now write the line config */
    WriteLineConfig(Context->DeviceName, DestinationName, LineStates, sizeof(SNDVOL_REG_LINESTATE) * Count);
 
    /* free line states */
    HeapFree(GetProcessHeap(), 0, LineStates);
}

Referenced by DlgPreferencesProc().

Variable Documentation

hAppHeap

HANDLE hAppHeap

Definition at line 17 of file sndvol32.c.

Referenced by _tWinMain(), CreateApplicationWindow(), and MainWindowProc().

hAppInstance

HINSTANCE hAppInstance

Definition at line 14 of file sndvol32.c.

Referenced by _tWinMain(), CreateApplicationWindow(), MainWindowProc(), RegisterApplicationClasses(), and UnregisterApplicationClasses().

hMainWnd

HWND hMainWnd

Definition at line 16 of file sndvol32.c.

Referenced by _tWinMain().

lpAppTitle

LPTSTR lpAppTitle

Definition at line 18 of file sndvol32.c.

Referenced by _tWinMain(), CreateApplicationWindow(), and MainWindowProc().

MainWindowClass

ATOM MainWindowClass

Definition at line 15 of file sndvol32.c.

Referenced by RegisterApplicationClasses().

Preferences

PREFERENCES_CONTEXT Preferences

Definition at line 19 of file sndvol32.c.

Referenced by MainWindowProc(), MixerControlChangeCallback(), and SetVolumeCallback().