mplay32.c File Reference

#include "mplay32.h"

Include dependency graph for mplay32.c:

Go to the source code of this file.

Macros
#define	IDT_PLAYTIMER   1000
#define	MAIN_WINDOW_HEIGHT   125
#define	MAIN_WINDOW_MIN_WIDTH   250
#define	MAX_MCISTR   256
#define	argv   __argv

Functions
static DWORD	GetDeviceMode (HWND hwnd)
void	EnableMenuItems (HWND hwnd)
void	DisableMenuItems (void)
void	ResizeClientArea (HWND hwnd, int nWidth, int nHeight)
void	UpdateWindowCaption (HWND hwnd)
void	UpdateTimeDisplay (HWND hwnd)
static VOID	ShowLastWin32Error (HWND hwnd)
static VOID	SetImageList (HWND hwnd)
static VOID	ShowMCIError (HWND hwnd, MCIERROR mciError)
static VOID	InitControls (HWND hwnd)
static VOID	SwitchViewMode (HWND hwnd)
static DWORD	GetNumDevices (VOID)
static DWORD	GetDeviceName (DWORD dwDeviceIndex, LPTSTR lpDeviceName, DWORD dwDeviceNameSize)
static DWORD	GetDeviceFriendlyName (LPTSTR lpDeviceName, LPTSTR lpFriendlyName, DWORD dwFriendlyNameSize)
static BOOL	DeviceUsesFiles (LPTSTR lpDeviceName)
static MCIERROR	CloseMciDevice (VOID)
static MCIERROR	OpenMciDevice (HWND hwnd, LPTSTR lpType, LPTSTR lpFileName)
static VOID	StopPlayback (HWND hwnd)
static VOID	SeekPlayback (HWND hwnd, DWORD dwNewPos)
static VOID	SeekBackPlayback (HWND hwnd)
static VOID	SeekForwPlayback (HWND hwnd)
VOID CALLBACK	PlayTimerProc (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
static VOID	StartPlayback (HWND hwnd)
static VOID	TogglePlaybackState (HWND hwnd)
static VOID	ShowDeviceProperties (HWND hwnd)
static VOID	CloseMediaFile (HWND hwnd)
static VOID	OpenMediaFile (HWND hwnd, LPTSTR lpFileName, LPTSTR lpType)
static DWORD	InsertDeviceMenuItem (HMENU hMenu, UINT uItem, BOOL fByPosition, UINT uItemID, DWORD dwDeviceIndex)
static VOID	BuildFileFilterAndDeviceMenu (VOID)
static VOID	CleanupFileFilter (VOID)
static VOID	OpenFileDialog (HWND hwnd, DWORD dwFilterIndex, LPTSTR lpType)
static VOID	HandleDeviceMenuItem (HWND hwnd, UINT uItem)
LRESULT CALLBACK	MainWndProc (HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
INT WINAPI	_tWinMain (HINSTANCE hInst, HINSTANCE hPrevInst, LPTSTR lpCmdLine, INT nCmdShow)

Variables
HINSTANCE	hInstance = NULL
HWND	hTrackBar = NULL
HWND	hToolBar = NULL
HWND	hTimeDisplay = NULL
HMENU	hMainMenu = NULL
TCHAR	szAppTitle [256] = _T("")
TCHAR	szDefaultFilter [MAX_PATH] = _T("")
TCHAR	szCurrentFile [MAX_PATH] = _T("")
LPTSTR	szFilter = NULL
WORD	wDeviceId = 0
BOOL	bRepeat = FALSE
BOOL	bIsSingleWindow = FALSE
UINT	MaxFilePos = 0
RECT	PrevWindowPos
static const TBBUTTON	Buttons []

Macro Definition Documentation

argv

#define argv   __argv

Definition at line 18 of file mplay32.c.

IDT_PLAYTIMER

#define IDT_PLAYTIMER   1000

Definition at line 9 of file mplay32.c.

MAIN_WINDOW_HEIGHT

#define MAIN_WINDOW_HEIGHT   125

Definition at line 11 of file mplay32.c.

MAIN_WINDOW_MIN_WIDTH

#define MAIN_WINDOW_MIN_WIDTH   250

Definition at line 12 of file mplay32.c.

MAX_MCISTR

#define MAX_MCISTR   256

Definition at line 13 of file mplay32.c.

Function Documentation

_tWinMain()

INT WINAPI _tWinMain	(	HINSTANCE	hInst,
		HINSTANCE	hPrevInst,
		LPTSTR	lpCmdLine,
		INT	nCmdShow
	)

Definition at line 1464 of file mplay32.c.

{
    WNDCLASSEX WndClass = {0};
    TCHAR szClassName[] = _T("ROSMPLAY32");
    HWND hwnd;
    MSG msg;
    DWORD dwError;
    HANDLE hAccel;
 
    hInstance = hInst;
 
    switch (GetUserDefaultUILanguage())
    {
        case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
            SetProcessDefaultLayout(LAYOUT_RTL);
            break;
 
        default:
            break;
    }
 
    LoadString(hInstance, IDS_APPTITLE, szAppTitle, ARRAYSIZE(szAppTitle));
 
    WndClass.cbSize            = sizeof(WndClass);
    WndClass.lpszClassName     = szClassName;
    WndClass.lpfnWndProc       = MainWndProc;
    WndClass.hInstance         = hInstance;
    WndClass.style             = CS_HREDRAW | CS_VREDRAW;
    WndClass.hIcon             = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN));
    WndClass.hCursor           = LoadCursor(NULL, IDC_ARROW);
    WndClass.hbrBackground     = (HBRUSH)(COLOR_BTNFACE + 1);
    WndClass.lpszMenuName      = MAKEINTRESOURCE(IDR_MAINMENU);
 
    if (!RegisterClassEx(&WndClass))
    {
        ShowLastWin32Error(NULL);
        return 0;
    }
 
    hwnd = CreateWindow(szClassName,
                        szAppTitle,
                        WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME | WS_OVERLAPPED | WS_CAPTION | WS_CLIPCHILDREN,
                        CW_USEDEFAULT,
                        CW_USEDEFAULT,
                        350,
                        MAIN_WINDOW_HEIGHT,
                        NULL,
                        NULL,
                        hInstance,
                        NULL);
    if (!hwnd)
    {
        ShowLastWin32Error(NULL);
        return 0;
    }
 
    hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(ID_ACCELERATORS));
 
    BuildFileFilterAndDeviceMenu();
 
    DragAcceptFiles(hwnd, TRUE);
 
    DisableMenuItems();
 
    dwError = SearchPath(NULL, _T("SNDVOL32.EXE"), NULL, 0, NULL, NULL);
    if (dwError == 0)
    {
        EnableMenuItem(hMainMenu, IDM_VOLUMECTL, MF_BYCOMMAND | MF_GRAYED);
    }
 
    /* Show it */
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
 
    if (*lpCmdLine == _T('"'))
    {
        OpenMediaFile(hwnd, argv[1], NULL);
    }
    else
    {
        OpenMediaFile(hwnd, lpCmdLine, NULL);
    }
 
    /* Message Loop */
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(hwnd, hAccel, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    CleanupFileFilter();
 
    DestroyAcceleratorTable(hAccel);
 
    return (INT)msg.wParam;
}

BuildFileFilterAndDeviceMenu()

static VOID BuildFileFilterAndDeviceMenu ( VOID  )

static

Definition at line 951 of file mplay32.c.

{
    TCHAR szDeviceName[MAX_MCISTR];
    TCHAR szFriendlyName[MAX_MCISTR];
    TCHAR *szDevice = NULL;
    static TCHAR szDefaultExtension[] = _T("*.*");
    TCHAR *szExtensionList = NULL;
    TCHAR *szExtension = NULL;
    TCHAR *c = NULL;
    TCHAR *d = NULL;
    DWORD dwNumValues;
    DWORD dwNumDevices;
    DWORD dwValueNameLen;
    DWORD dwValueDataSize;
    DWORD dwMaskLen;
    DWORD dwFilterSize;
    DWORD dwDeviceSize;
    DWORD dwExtensionLen;
    DWORD dwPosition = 0;
    DWORD i;
    DWORD j;
    size_t uSizeRemain;
    size_t uMaskRemain;
    HKEY hKey = NULL;
 
    /* Always load the default (all files) filter */
    LoadString(hInstance, IDS_ALL_TYPES_FILTER, szDefaultFilter, ARRAYSIZE(szDefaultFilter));
 
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\MCI Extensions"), 0, KEY_READ, &hKey) != ERROR_SUCCESS)
    {
        goto Failure;
    }
 
    if (RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &dwNumValues, &dwValueNameLen, &dwValueDataSize, NULL, NULL) != ERROR_SUCCESS)
    {
        goto Failure;
    }
 
    dwMaskLen = ((dwValueNameLen + 3) * dwNumValues) + 1;
 
    szExtensionList = malloc(dwMaskLen * sizeof(TCHAR));
    if (!szExtensionList)
        goto Failure;
 
    dwNumDevices = GetNumDevices();
 
    /* Allocate space for every pair of Device and Extension Filter */
    dwFilterSize = (MAX_MCISTR + (dwMaskLen * 2) + 5) * dwNumDevices;
 
    /* Add space for the "All supported" entry */
    dwFilterSize = (dwFilterSize + (dwMaskLen * 2) + 7) * sizeof(TCHAR) + sizeof(szDefaultFilter);
 
    szFilter = malloc(dwFilterSize);
    if (!szFilter)
        goto Failure;
 
    szExtension = malloc((dwValueNameLen + 1) * sizeof(TCHAR));
    if (!szExtension)
        goto Failure;
 
    szDevice = malloc(dwValueDataSize + sizeof(TCHAR));
    if (!szDevice)
        goto Failure;
 
    ZeroMemory(szFilter, dwFilterSize);
 
    uSizeRemain = dwFilterSize;
    c = szFilter;
 
    for (j = 1; j <= dwNumDevices; j++)
    {
        if (GetDeviceName(j, szDeviceName, sizeof(szDeviceName)))
        {
            continue;
        }
 
        if (GetDeviceFriendlyName(szDeviceName, szFriendlyName, sizeof(szFriendlyName)))
        {
            continue;
        }
 
        /* Insert a menu item under the "Device" menu for every found MCI device */
        InsertDeviceMenuItem(GetSubMenu(hMainMenu, 3), dwPosition, TRUE, IDM_DEVICE_FIRST + dwPosition, j);
        dwPosition++;
 
        /* Copy the default extension list, that may be overwritten after... */
        StringCbCopy(szExtensionList, dwMaskLen * sizeof(TCHAR), szDefaultExtension);
 
        /* Try to determine the real extension list */
        uMaskRemain = dwMaskLen * sizeof(TCHAR);
        d = szExtensionList;
 
        for (i = 0; i < dwNumValues; i++)
        {
            dwExtensionLen = dwValueNameLen + 1;
            dwDeviceSize   = dwValueDataSize + sizeof(TCHAR);
 
            ZeroMemory(szDevice, dwDeviceSize);
 
            if (RegEnumValue(hKey, i, szExtension, &dwExtensionLen, NULL, NULL, (LPBYTE)szDevice, &dwDeviceSize) == ERROR_SUCCESS)
            {
                CharLowerBuff(szDevice, dwDeviceSize / sizeof(TCHAR));
                CharLowerBuff(szDeviceName, ARRAYSIZE(szDeviceName));
                if (_tcscmp(szDeviceName, szDevice) == 0)
                {
                     CharLowerBuff(szExtension, dwExtensionLen);
                     StringCbPrintfEx(d, uMaskRemain, &d, &uMaskRemain, 0, _T("%s%s%s"), _T("*."), szExtension, _T(";"));
                }
            }
        }
 
        /* Remove the last separator */
        d--;
        uSizeRemain += sizeof(*d);
        *d = _T('\0');
 
        /* Add the description */
        StringCbPrintfEx(c, uSizeRemain, &c, &uSizeRemain, 0, _T("%s (%s)"), szFriendlyName, szExtensionList);
 
        /* Skip one char to separate the description from the filter mask */
        c++;
        uSizeRemain -= sizeof(*c);
 
        /* Append the filter mask */
        StringCbCopyEx(c, uSizeRemain, szExtensionList, &c, &uSizeRemain, 0);
 
        /* Skip another char to separate the elements of the filter mask */
        c++;
        uSizeRemain -= sizeof(*c);
    }
 
    /* Build the full list of supported extensions */
    uMaskRemain = dwMaskLen * sizeof(TCHAR);
    d = szExtensionList;
 
    for (i = 0; i < dwNumValues; i++)
    {
        dwExtensionLen = dwValueNameLen + 1;
 
        if (RegEnumValue(hKey, i, szExtension, &dwExtensionLen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
        {
            CharLowerBuff(szExtension, dwExtensionLen);
            StringCbPrintfEx(d, uMaskRemain, &d, &uMaskRemain, 0, _T("%s%s%s"), _T("*."), szExtension, _T(";"));
        }
    }
 
    /* Remove the last separator */
    d--;
    uSizeRemain += sizeof(*d);
    *d = _T('\0');
 
    /* Add the default (all files) description */
    StringCbPrintfEx(c, uSizeRemain, &c, &uSizeRemain, 0, _T("%s (%s)"), szDefaultFilter, szExtensionList);
 
    /* Skip one char to separate the description from the filter mask */
    c++;
    uSizeRemain -= sizeof(*c);
 
    /* Append the filter mask */
    StringCbCopyEx(c, uSizeRemain, szExtensionList, &c, &uSizeRemain, 0);
 
Cleanup:
    if (szExtensionList) free(szExtensionList);
    if (szExtension)     free(szExtension);
    if (szDevice)        free(szDevice);
    RegCloseKey(hKey);
 
    return;
 
Failure:
    /* We failed at retrieving the supported files, so use the default filter */
    if (szFilter) free(szFilter);
    szFilter = szDefaultFilter;
 
    uSizeRemain = sizeof(szDefaultFilter);
    c = szFilter;
 
    /* Add the default (all files) description */
    StringCbPrintfEx(c, uSizeRemain, &c, &uSizeRemain, 0, _T("%s (%s)"), szDefaultFilter, szDefaultExtension);
 
    /* Skip one char to separate the description from the filter mask */
    c++;
    uSizeRemain -= sizeof(*c);
 
    /* Append the filter mask */
    StringCbCopyEx(c, uSizeRemain, szDefaultExtension, &c, &uSizeRemain, 0);
 
    goto Cleanup;
}

Referenced by _tWinMain().

CleanupFileFilter()

static VOID CleanupFileFilter ( VOID  )

static

Definition at line 1142 of file mplay32.c.

{
    if (szFilter && szFilter != szDefaultFilter) free(szFilter);
}

Referenced by _tWinMain().

CloseMciDevice()

static MCIERROR CloseMciDevice ( VOID  )

static

Definition at line 532 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_GENERIC_PARMS mciGeneric;
 
    if (wDeviceId)
    {
        mciError = mciSendCommand(wDeviceId, MCI_CLOSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
        if (mciError != 0) return mciError;
        wDeviceId = 0;
    }
 
    UpdateTimeDisplay(hTimeDisplay);
 
    DisableMenuItems();
 
    return 0;
}

Referenced by CloseMediaFile(), and OpenMciDevice().

CloseMediaFile()

static VOID CloseMediaFile ( HWND  hwnd )

static

Definition at line 881 of file mplay32.c.

{
    StopPlayback(hwnd);
 
    if (bIsSingleWindow)
        SwitchViewMode(hwnd);
 
    CloseMciDevice();
    UpdateWindowCaption(hwnd);
}

Referenced by MainWndProc(), and OpenMediaFile().

DeviceUsesFiles()

static BOOL DeviceUsesFiles ( LPTSTR  lpDeviceName )

static

Definition at line 500 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_OPEN_PARMS mciOpen;
    MCI_GETDEVCAPS_PARMS mciDevCaps;
    MCI_GENERIC_PARMS mciGeneric;
 
    mciOpen.dwCallback = 0;
    mciOpen.wDeviceID  = 0;
    mciOpen.lpstrDeviceType  = lpDeviceName;
    mciOpen.lpstrElementName = NULL;
    mciOpen.lpstrAlias = NULL;
 
    mciError = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_WAIT, (DWORD_PTR)&mciOpen);
    if (mciError != 0)
        return FALSE;
 
    mciDevCaps.dwCallback  = 0;
    mciDevCaps.dwReturn = 0;
    mciDevCaps.dwItem = MCI_GETDEVCAPS_USES_FILES;
 
    mciError = mciSendCommand(mciOpen.wDeviceID, MCI_GETDEVCAPS, MCI_WAIT | MCI_GETDEVCAPS_ITEM, (DWORD_PTR)&mciDevCaps);
    if (mciError != 0)
        return FALSE;
 
    mciGeneric.dwCallback = 0;
    mciSendCommand(mciOpen.wDeviceID, MCI_CLOSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
 
    return (BOOL)mciDevCaps.dwReturn;
}

Referenced by HandleDeviceMenuItem(), and InsertDeviceMenuItem().

DisableMenuItems()

void DisableMenuItems

(

void

)

Definition at line 82 of file mplay32.c.

{
    EnableMenuItem(hMainMenu, IDM_CLOSE_FILE, MF_BYCOMMAND | MF_GRAYED);
    EnableMenuItem(hMainMenu, IDM_DEVPROPS, MF_BYCOMMAND | MF_GRAYED);
    EnableMenuItem(hMainMenu, IDM_SWITCHVIEW, MF_BYCOMMAND | MF_GRAYED);
}

Referenced by _tWinMain(), and CloseMciDevice().

EnableMenuItems()

void EnableMenuItems

(

HWND

hwnd

)

Definition at line 54 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_GENERIC_PARMS mciGeneric;
    MCI_DGV_RECT_PARMS mciVideoRect;
    MCI_DGV_WINDOW_PARMSW mciVideoWindow;
 
    EnableMenuItem(hMainMenu, IDM_CLOSE_FILE, MF_BYCOMMAND | MF_ENABLED);
 
    mciError = mciSendCommand(wDeviceId, MCI_CONFIGURE, MCI_TEST, (DWORD_PTR)&mciGeneric);
    if (mciError == 0)
    {
        EnableMenuItem(hMainMenu, IDM_DEVPROPS, MF_BYCOMMAND | MF_ENABLED);
    }
 
    mciVideoWindow.hWnd = hwnd;
 
    mciError = mciSendCommand(wDeviceId, MCI_WINDOW, MCI_DGV_WINDOW_HWND | MCI_TEST, (DWORD_PTR)&mciVideoWindow);
    if (!mciError)
    {
        mciError = mciSendCommand(wDeviceId, MCI_WHERE, MCI_DGV_WHERE_SOURCE | MCI_TEST, (DWORD_PTR)&mciVideoRect);
        if (!mciError)
        {
            EnableMenuItem(hMainMenu, IDM_SWITCHVIEW, MF_BYCOMMAND | MF_ENABLED);
        }
    }
}

Referenced by OpenMciDevice().

GetDeviceFriendlyName()

static DWORD GetDeviceFriendlyName ( LPTSTR  lpDeviceName, LPTSTR  lpFriendlyName, DWORD  dwFriendlyNameSize  )

static

Definition at line 470 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_OPEN_PARMS mciOpen;
    MCI_INFO_PARMS mciInfo;
    MCI_GENERIC_PARMS mciGeneric;
 
    mciOpen.dwCallback = 0;
    mciOpen.wDeviceID  = 0;
    mciOpen.lpstrDeviceType  = lpDeviceName;
    mciOpen.lpstrElementName = NULL;
    mciOpen.lpstrAlias = NULL;
 
    mciError = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_WAIT, (DWORD_PTR)&mciOpen);
    if (mciError != 0)
        return mciError;
 
    mciInfo.dwCallback  = 0;
    mciInfo.lpstrReturn = lpFriendlyName;
    mciInfo.dwRetSize   = dwFriendlyNameSize;
 
    mciError = mciSendCommand(mciOpen.wDeviceID, MCI_INFO, MCI_INFO_PRODUCT, (DWORD_PTR)&mciInfo);
 
    mciGeneric.dwCallback = 0;
    mciSendCommand(mciOpen.wDeviceID, MCI_CLOSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
 
    return mciError;
}

Referenced by BuildFileFilterAndDeviceMenu(), and InsertDeviceMenuItem().

GetDeviceMode()

static DWORD GetDeviceMode ( HWND  hwnd )

static

Definition at line 635 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_STATUS_PARMS mciStatus;
 
    mciStatus.dwItem = MCI_STATUS_MODE;
    mciError = mciSendCommand(wDeviceId, MCI_STATUS, MCI_WAIT | MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
        return MCI_MODE_NOT_READY;
    }
 
    return mciStatus.dwReturn;
}

Referenced by TogglePlaybackState(), and UpdateWindowCaption().

GetDeviceName()

static DWORD GetDeviceName ( DWORD  dwDeviceIndex, LPTSTR  lpDeviceName, DWORD  dwDeviceNameSize  )

static

Definition at line 456 of file mplay32.c.

{
    MCI_SYSINFO_PARMS mciSysInfo;
 
    mciSysInfo.dwCallback  = 0;
    mciSysInfo.lpstrReturn = lpDeviceName;
    mciSysInfo.dwRetSize   = dwDeviceNameSize;
    mciSysInfo.dwNumber    = dwDeviceIndex;
    mciSysInfo.wDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
 
    return mciSendCommand(MCI_ALL_DEVICE_ID, MCI_SYSINFO, MCI_SYSINFO_NAME, (DWORD_PTR)&mciSysInfo);
}

Referenced by BuildFileFilterAndDeviceMenu(), HandleDeviceMenuItem(), and InsertDeviceMenuItem().

GetNumDevices()

static DWORD GetNumDevices ( VOID  )

static

Definition at line 439 of file mplay32.c.

{
    MCI_SYSINFO_PARMS mciSysInfo;
    DWORD dwNumDevices = 0;
 
    mciSysInfo.dwCallback  = 0;
    mciSysInfo.lpstrReturn = (LPTSTR)&dwNumDevices;
    mciSysInfo.dwRetSize   = sizeof(dwNumDevices);
    mciSysInfo.dwNumber    = 0;
    mciSysInfo.wDeviceType = MCI_ALL_DEVICE_ID;
 
    mciSendCommand(MCI_ALL_DEVICE_ID, MCI_SYSINFO, MCI_SYSINFO_QUANTITY, (DWORD_PTR)&mciSysInfo);
 
    return *(DWORD*)mciSysInfo.lpstrReturn;
}

Referenced by BuildFileFilterAndDeviceMenu().

HandleDeviceMenuItem()

static VOID HandleDeviceMenuItem ( HWND  hwnd, UINT  uItem  )

static

Definition at line 1172 of file mplay32.c.

{
    MENUITEMINFO lpmii;
    TCHAR szDeviceName[MAX_MCISTR];
    MCIERROR mciError;
 
    ZeroMemory(&lpmii, sizeof(MENUITEMINFO));
    lpmii.cbSize = sizeof(lpmii);
    lpmii.fMask = MIIM_DATA;
    GetMenuItemInfo(hMainMenu, uItem, FALSE, &lpmii);
 
    mciError = GetDeviceName(lpmii.dwItemData, szDeviceName, sizeof(szDeviceName));
    if (mciError)
    {
        ShowMCIError(hwnd, mciError);
        return;
    }
 
    if (DeviceUsesFiles(szDeviceName))
    {
        OpenFileDialog(hwnd, uItem - IDM_DEVICE_FIRST + 1, szDeviceName);
        return;
    }
 
    mciError = OpenMciDevice(hwnd, szDeviceName, NULL);
    if (mciError)
    {
        ShowMCIError(hwnd, mciError);
    }
 
    return;
}

Referenced by MainWndProc().

InitControls()

static VOID InitControls ( HWND  hwnd )

static

Definition at line 303 of file mplay32.c.

{
    INT NumButtons = ARRAYSIZE(Buttons);
 
    InitCommonControls();
 
    /* Create trackbar */
    hTrackBar = CreateWindowEx(0,
                               TRACKBAR_CLASS,
                               NULL,
                               TBS_ENABLESELRANGE | WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPSIBLINGS,
                               0,
                               0,
                               340,
                               20,
                               hwnd,
                               NULL,
                               hInstance,
                               NULL);
    if (!hTrackBar)
    {
        ShowLastWin32Error(hwnd);
        return;
    }
 
    /* Create toolbar */
    hToolBar = CreateWindowEx(0,
                              TOOLBARCLASSNAME,
                              NULL,
                              WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPSIBLINGS |
                              TBSTYLE_FLAT | CCS_BOTTOM | TBSTYLE_TOOLTIPS,
                              0,
                              40,
                              340,
                              30,
                              hwnd,
                              NULL,
                              hInstance,
                              NULL);
    if (!hToolBar)
    {
        ShowLastWin32Error(hwnd);
        return;
    }
 
    hTimeDisplay = CreateWindowEx(0,
                                  L"STATIC",
                                  NULL,
                                  WS_CHILD | WS_VISIBLE | SS_CENTER | SS_SUNKEN,
                                  195,
                                  4,
                                  135,
                                  18,
                                  hToolBar,
                                  NULL,
                                  hInstance,
                                  NULL);
    if (!hTimeDisplay)
    {
        ShowLastWin32Error(hwnd);
        return;
    }
 
    SetImageList(hwnd);
    SendMessage(hToolBar, TB_ADDBUTTONS, NumButtons, (LPARAM)Buttons);
}

Referenced by _tWinMain(), DllMain(), Initialize(), MainWndProc(), and wWinMain().

InsertDeviceMenuItem()

static DWORD InsertDeviceMenuItem ( HMENU  hMenu, UINT  uItem, BOOL  fByPosition, UINT  uItemID, DWORD  dwDeviceIndex  )

static

Definition at line 914 of file mplay32.c.

{
    MENUITEMINFO lpmii;
    MCIERROR mciError;
    TCHAR szDeviceName[MAX_MCISTR];
    TCHAR szFriendlyName[MAX_MCISTR];
 
    mciError = GetDeviceName(dwDeviceIndex, szDeviceName, sizeof(szDeviceName));
    if (mciError)
    {
        return mciError;
    }
 
    mciError = GetDeviceFriendlyName(szDeviceName, szFriendlyName, sizeof(szFriendlyName));
    if (mciError)
    {
        return mciError;
    }
 
    if (DeviceUsesFiles(szDeviceName))
    {
        StringCbCat(szFriendlyName, sizeof(szFriendlyName), _T("..."));
    }
 
    ZeroMemory(&lpmii, sizeof(MENUITEMINFO));
    lpmii.cbSize = sizeof(lpmii);
    lpmii.fMask = MIIM_DATA | MIIM_TYPE | MIIM_ID;
    lpmii.wID = uItemID;
    lpmii.fType = MF_STRING;
    lpmii.dwTypeData = szFriendlyName;
    lpmii.dwItemData = dwDeviceIndex;
    InsertMenuItem(hMenu, uItem, fByPosition, &lpmii);
 
    return 0;
}

Referenced by BuildFileFilterAndDeviceMenu().

MainWndProc()

LRESULT CALLBACK MainWndProc	(	HWND	hwnd,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1206 of file mplay32.c.

{
    switch (Message)
    {
        case WM_CREATE:
        {
            InitControls(hwnd);
            hMainMenu = GetMenu(hwnd);
            break;
        }
 
        case WM_DROPFILES:
        {
            HDROP drophandle;
            TCHAR droppedfile[MAX_PATH];
 
            drophandle = (HDROP)wParam;
            DragQueryFile(drophandle, 0, droppedfile, ARRAYSIZE(droppedfile));
            DragFinish(drophandle);
            OpenMediaFile(hwnd, droppedfile, NULL);
            break;
        }
 
        case MM_MCINOTIFY:
        {
            if (wParam == MCI_NOTIFY_SUCCESSFUL)
            {
                StopPlayback(hwnd);
                if (bRepeat)
                {
                    StartPlayback(hwnd);
                }
            }
            break;
        }
 
        case WM_NOTIFY:
        {
            LPNMHDR pnmhdr = (LPNMHDR)lParam;
 
            switch (pnmhdr->code)
            {
                case TTN_GETDISPINFO:
                {
                    LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT)lParam;
                    UINT idButton = (UINT)lpttt->hdr.idFrom;
 
                    switch (idButton)
                    {
                        case IDC_PLAY:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PLAY);
                            break;
                        case IDC_STOP:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
                            break;
                        case IDC_EJECT:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EJECT);
                            break;
                        case IDC_BACKWARD:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_BACKWARD);
                            break;
                        case IDC_SEEKBACK:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_SEEKBACK);
                            break;
                        case IDC_SEEKFORW:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_SEEKFORW);
                            break;
                        case IDC_FORWARD:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_FORWARD);
                            break;
                        case IDC_PAUSE:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PAUSE);
                            break;
                    }
                    break;
                }
            }
        }
        break;
 
        case WM_SIZING:
        {
            LPRECT pRect = (LPRECT)lParam;
 
            if (!bIsSingleWindow)
            {
                if (pRect->right - pRect->left < MAIN_WINDOW_MIN_WIDTH)
                    pRect->right = pRect->left + MAIN_WINDOW_MIN_WIDTH;
 
                if (pRect->bottom - pRect->top != MAIN_WINDOW_HEIGHT)
                    pRect->bottom = pRect->top + MAIN_WINDOW_HEIGHT;
            }
            return TRUE;
        }
 
        case WM_SIZE:
        {
            RECT Rect;
 
            if (hToolBar && hTrackBar)
            {
                SendMessage(hToolBar, TB_AUTOSIZE, 0, 0);
                SendMessage(hToolBar, TB_GETITEMRECT, 1, (LPARAM)&Rect);
                MoveWindow(hTimeDisplay, LOWORD(lParam) - 140, 4, 135, 18, TRUE);
 
                if (!bIsSingleWindow)
                {
                    UINT Size = GetSystemMetrics(SM_CYMENU) + Rect.bottom;
                    MoveWindow(hTrackBar, 0, 0, LOWORD(lParam), HIWORD(lParam) - Size, TRUE);
                }
                else
                {
                    RECT ToolbarRect;
                    MCI_DGV_PUT_PARMS mciPut;
 
                    MoveWindow(hTrackBar, 180, 0, LOWORD(lParam) - 322, 25, TRUE);
 
                    GetClientRect(hwnd, &Rect);
                    GetClientRect(hToolBar, &ToolbarRect);
 
                    mciPut.rc.top = 0;
                    mciPut.rc.left = 0;
                    mciPut.rc.right = Rect.right;
                    mciPut.rc.bottom = Rect.bottom - (ToolbarRect.bottom - ToolbarRect.top) - 2;
 
                    mciSendCommand(wDeviceId, MCI_PUT, MCI_DGV_PUT_DESTINATION | MCI_DGV_RECT | MCI_WAIT, (DWORD_PTR)&mciPut);
                }
            }
            return 0L;
        }
 
        case WM_HSCROLL:
        {
            if (hTrackBar == (HWND)lParam)
            {
                if (wDeviceId)
                {
                    DWORD dwNewPos = (DWORD)SendMessage(hTrackBar, TBM_GETPOS, 0, 0);
                    SeekPlayback(hwnd, dwNewPos);
                }
                else
                {
                    SendMessage(hTrackBar, TBM_SETPOS, TRUE, 0);
                }
            }
        }
        break;
 
        case WM_NCLBUTTONDBLCLK:
        {
            if (wParam == HTCAPTION)
            {
                SwitchViewMode(hwnd);
            }
        }
        break;
 
        case WM_COMMAND:
        {
            if (LOWORD(wParam) >= IDM_DEVICE_FIRST)
            {
                HandleDeviceMenuItem(hwnd, LOWORD(wParam));
                break;
            }
 
            switch (LOWORD(wParam))
            {
                case IDC_PLAY:
                case IDC_PAUSE:
                {
                    if (wDeviceId)
                        TogglePlaybackState(hwnd);
                    else
                        OpenFileDialog(hwnd, 1, NULL);
 
                    break;
                }
 
                case IDC_STOP:
                    StopPlayback(hwnd);
                    break;
 
                case IDC_EJECT:
                    break;
 
                case IDC_BACKWARD:
                    break;
 
                case IDC_SEEKBACK:
                    SeekBackPlayback(hwnd);
                    break;
 
                case IDC_SEEKFORW:
                    SeekForwPlayback(hwnd);
                    break;
 
                case IDC_FORWARD:
                    break;
 
                case IDM_OPEN_FILE:
                    OpenFileDialog(hwnd, 1, NULL);
                    return 0;
 
                case IDM_CLOSE_FILE:
                    CloseMediaFile(hwnd);
                    break;
 
                case IDM_REPEAT:
                {
                    if (!bRepeat)
                    {
                        CheckMenuItem(hMainMenu, IDM_REPEAT, MF_BYCOMMAND | MF_CHECKED);
                        bRepeat = TRUE;
                    }
                    else
                    {
                        CheckMenuItem(hMainMenu, IDM_REPEAT, MF_BYCOMMAND | MF_UNCHECKED);
                        bRepeat = FALSE;
                    }
                    break;
                }
 
                case IDM_SWITCHVIEW:
                    SwitchViewMode(hwnd);
                    break;
 
                case IDM_DEVPROPS:
                    ShowDeviceProperties(hwnd);
                    break;
 
                case IDM_VOLUMECTL:
                    ShellExecute(hwnd, NULL, _T("SNDVOL32.EXE"), NULL, NULL, SW_SHOWNORMAL);
                    break;
 
                case IDM_ABOUT:
                {
                    ShellAbout(hwnd, szAppTitle, NULL,
                               LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN)));
                    break;
                }
 
                case IDM_EXIT:
                    PostMessage(hwnd, WM_CLOSE, 0, 0);
                    return 0;
            }
            break;
        }
 
        case WM_DESTROY:
            CloseMediaFile(hwnd);
            PostQuitMessage(0);
            return 0;
    }
 
    return DefWindowProc(hwnd, Message, wParam, lParam);
}

Referenced by _tWinMain().

OpenFileDialog()

static VOID OpenFileDialog ( HWND  hwnd, DWORD  dwFilterIndex, LPTSTR  lpType  )

static

Definition at line 1148 of file mplay32.c.

{
    OPENFILENAME OpenFileName;
    TCHAR szFile[MAX_PATH + 1] = _T("");
 
    ZeroMemory(&OpenFileName, sizeof(OpenFileName));
 
    OpenFileName.lStructSize     = sizeof(OpenFileName);
    OpenFileName.hwndOwner       = hwnd;
    OpenFileName.hInstance       = hInstance;
    OpenFileName.lpstrFilter     = szFilter;
    OpenFileName.lpstrFile       = szFile;
    OpenFileName.nMaxFile        = ARRAYSIZE(szFile);
    OpenFileName.Flags           = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_SHAREAWARE;
    OpenFileName.lpstrDefExt     = _T("\0");
    OpenFileName.nFilterIndex = dwFilterIndex;
 
    if (!GetOpenFileName(&OpenFileName))
        return;
 
    OpenMediaFile(hwnd, OpenFileName.lpstrFile, lpType);
}

Referenced by HandleDeviceMenuItem(), and MainWndProc().

OpenMciDevice()

static MCIERROR OpenMciDevice ( HWND  hwnd, LPTSTR  lpType, LPTSTR  lpFileName  )

static

Definition at line 552 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_STATUS_PARMS mciStatus;
    MCI_OPEN_PARMS mciOpen;
    DWORD dwFlags = MCI_WAIT;
    LPTSTR lpStr;
 
    if (wDeviceId)
        CloseMciDevice();
 
    mciOpen.lpstrDeviceType = lpType;
    mciOpen.lpstrElementName = lpFileName;
    mciOpen.dwCallback = 0;
    mciOpen.wDeviceID = 0;
    mciOpen.lpstrAlias = NULL;
 
    if (lpType)
        dwFlags |= MCI_OPEN_TYPE;
 
    if (lpFileName)
        dwFlags |= MCI_OPEN_ELEMENT;
 
    mciError = mciSendCommand(0, MCI_OPEN, dwFlags, (DWORD_PTR)&mciOpen);
    if (mciError != 0)
        return mciError;
 
    mciStatus.dwItem = MCI_STATUS_LENGTH;
 
    mciError = mciSendCommand(mciOpen.wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_WAIT, (DWORD_PTR)&mciStatus);
    if (mciError != 0)
        return mciError;
 
    SendMessage(hTrackBar, TBM_SETRANGEMIN, (WPARAM)TRUE, (LPARAM)1);
    SendMessage(hTrackBar, TBM_SETRANGEMAX, (WPARAM)TRUE, (LPARAM)mciStatus.dwReturn);
    SendMessage(hTrackBar, TBM_SETPAGESIZE, 0, 10);
    SendMessage(hTrackBar, TBM_SETLINESIZE, 0, 1);
    SendMessage(hTrackBar, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)1);
 
    if (mciStatus.dwReturn < 10000)
    {
        SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM)100, (LPARAM)0);
    }
    else if (mciStatus.dwReturn < 100000)
    {
        SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM)1000, (LPARAM)0);
    }
    else if (mciStatus.dwReturn < 1000000)
    {
        SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM)10000, (LPARAM)0);
    }
    else
    {
        SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM)100000, (LPARAM)0);
    }
 
    MaxFilePos = mciStatus.dwReturn;
    wDeviceId = mciOpen.wDeviceID;
 
    /* NOTE: Everything above this line may be done instead in OpenMediaFile() */
 
    if (lpFileName)
    {
        lpStr = _tcsrchr(lpFileName, _T('\\'));
        if (lpStr) // Get only the file name (skip the last path separator)
            lpStr++;
        else
            lpStr = lpFileName;
    }
    else
        lpStr = lpType;
 
    StringCbCopy(szCurrentFile, sizeof(szCurrentFile), lpStr);
 
    EnableMenuItems(hwnd);
 
    UpdateTimeDisplay(hTimeDisplay);
    UpdateWindowCaption(hwnd);
 
    return 0;
}

Referenced by HandleDeviceMenuItem(), and OpenMediaFile().

OpenMediaFile()

static VOID OpenMediaFile ( HWND  hwnd, LPTSTR  lpFileName, LPTSTR  lpType  )

static

Definition at line 893 of file mplay32.c.

{
    MCIERROR mciError;
 
    if (GetFileAttributes(lpFileName) == INVALID_FILE_ATTRIBUTES)
        return;
 
    if (wDeviceId)
        CloseMediaFile(hwnd);
 
    mciError = OpenMciDevice(hwnd, lpType, lpFileName);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
        return;
    }
 
    StartPlayback(hwnd);
}

Referenced by _tWinMain(), MainWndProc(), and OpenFileDialog().

PlayTimerProc()

VOID CALLBACK PlayTimerProc	(	HWND	hwnd,
		UINT	uMsg,
		UINT_PTR	idEvent,
		DWORD	dwTime
	)

Definition at line 757 of file mplay32.c.

{
    MCI_STATUS_PARMS mciStatus;
    DWORD dwPos;
 
    if (wDeviceId == 0) KillTimer(hwnd, IDT_PLAYTIMER);
 
    mciStatus.dwItem = MCI_STATUS_POSITION;
    mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
    dwPos = mciStatus.dwReturn;
 
    SendMessage(hTrackBar, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)dwPos);
    UpdateTimeDisplay(hTimeDisplay);
}

Referenced by StartPlayback().

ResizeClientArea()

void ResizeClientArea	(	HWND	hwnd,
		int	nWidth,
		int	nHeight
	)

Definition at line 89 of file mplay32.c.

{
    RECT rcClientRect;
    RECT rcWindowRect;
    POINT ptDifference;
 
    GetClientRect(hwnd, &rcClientRect);
    GetWindowRect(hwnd, &rcWindowRect);
    ptDifference.x = (rcWindowRect.right - rcWindowRect.left) - rcClientRect.right;
    ptDifference.y = (rcWindowRect.bottom - rcWindowRect.top) - rcClientRect.bottom;
    MoveWindow(hwnd, rcWindowRect.left, rcWindowRect.top, nWidth + ptDifference.x, nHeight + ptDifference.y, TRUE);
}

Referenced by SwitchViewMode().

SeekBackPlayback()

static VOID SeekBackPlayback ( HWND  hwnd )

static

Definition at line 711 of file mplay32.c.

{
    MCI_STATUS_PARMS mciStatus;
    DWORD dwNewPos;
 
    if (wDeviceId == 0) return;
 
    mciStatus.dwItem = MCI_STATUS_POSITION;
    mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
 
    dwNewPos = mciStatus.dwReturn - 1;
 
    if ((UINT)dwNewPos <= 1)
    {
        StopPlayback(hwnd);
    }
    else
    {
        SeekPlayback(hwnd, dwNewPos);
    }
}

Referenced by MainWndProc().

SeekForwPlayback()

static VOID SeekForwPlayback ( HWND  hwnd )

static

Definition at line 734 of file mplay32.c.

{
    MCI_STATUS_PARMS mciStatus;
    DWORD dwNewPos;
 
    if (wDeviceId == 0) return;
 
    mciStatus.dwItem = MCI_STATUS_POSITION;
    mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
 
    dwNewPos = mciStatus.dwReturn + 1;
 
    if ((UINT)dwNewPos >= MaxFilePos)
    {
        StopPlayback(hwnd);
    }
    else
    {
        SeekPlayback(hwnd, dwNewPos);
    }
}

Referenced by MainWndProc().

SeekPlayback()

static VOID SeekPlayback ( HWND  hwnd, DWORD  dwNewPos  )

static

Definition at line 687 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_SEEK_PARMS mciSeek;
    MCI_PLAY_PARMS mciPlay;
 
    if (wDeviceId == 0) return;
 
    mciSeek.dwTo = (DWORD_PTR)dwNewPos;
    mciError = mciSendCommand(wDeviceId, MCI_SEEK, MCI_WAIT | MCI_TO, (DWORD_PTR)&mciSeek);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
    }
 
    mciPlay.dwCallback = (DWORD_PTR)hwnd;
    mciError = mciSendCommand(wDeviceId, MCI_PLAY, MCI_NOTIFY, (DWORD_PTR)&mciPlay);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
    }
}

Referenced by MainWndProc(), SeekBackPlayback(), and SeekForwPlayback().

SetImageList()

static VOID SetImageList ( HWND  hwnd )

static

Definition at line 238 of file mplay32.c.

{
    HIMAGELIST hImageList;
 
    hImageList = ImageList_Create(16, 16, ILC_MASK | ILC_COLOR24, 1, 1);
    if (!hImageList)
    {
        ShowLastWin32Error(hwnd);
        return;
    }
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_PLAYICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_STOPICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_EJECTICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_BACKWARDICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_SEEKBACKICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_SEEKFORWICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_FORWARDICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_AddMasked(hImageList,
                        LoadImage(hInstance, MAKEINTRESOURCE(IDB_PAUSEICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
                        RGB(255, 255, 255));
 
    ImageList_Destroy((HIMAGELIST)SendMessage(hToolBar,
                                              TB_SETIMAGELIST,
                                              0,
                                              (LPARAM)hImageList));
}

Referenced by DECLARE_INTERFACE_(), InitControls(), CNotifyToolbar::Initialize(), CNotifyToolbar::ResizeImagelist(), CAppsListView::SetDisplayAppType(), and CMenuToolbarBase::UpdateImageLists().

ShowDeviceProperties()

static VOID ShowDeviceProperties ( HWND  hwnd )

static

Definition at line 868 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_GENERIC_PARMS mciGeneric;
 
    mciError = mciSendCommand(wDeviceId, MCI_CONFIGURE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
    }
}

Referenced by MainWndProc().

ShowLastWin32Error()

static VOID ShowLastWin32Error ( HWND  hwnd )

static

Definition at line 213 of file mplay32.c.

{
    LPTSTR lpMessageBuffer;
    DWORD dwError = GetLastError();
 
    if (dwError == ERROR_SUCCESS)
        return;
 
    if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                       FORMAT_MESSAGE_FROM_SYSTEM |
                       FORMAT_MESSAGE_IGNORE_INSERTS,
                       NULL,
                       dwError,
                       LANG_USER_DEFAULT,
                       (LPTSTR)&lpMessageBuffer,
                       0, NULL))
    {
        return;
    }
 
    MessageBox(hwnd, lpMessageBuffer, szAppTitle, MB_OK | MB_ICONERROR);
    LocalFree(lpMessageBuffer);
}

Referenced by _tWinMain(), InitControls(), and SetImageList().

ShowMCIError()

static VOID ShowMCIError ( HWND  hwnd, MCIERROR  mciError  )

static

Definition at line 288 of file mplay32.c.

{
    TCHAR szErrorMessage[MAX_MCISTR];
    TCHAR szTempMessage[MAX_MCISTR + 44];
 
    if (mciGetErrorString(mciError, szErrorMessage, ARRAYSIZE(szErrorMessage)) == FALSE)
    {
        LoadString(hInstance, IDS_DEFAULTMCIERRMSG, szErrorMessage, ARRAYSIZE(szErrorMessage));
    }
 
    StringCbPrintf(szTempMessage, sizeof(szTempMessage), _T("MMSYS%lu: %s"), mciError, szErrorMessage);
    MessageBox(hwnd, szTempMessage, szAppTitle, MB_OK | MB_ICONEXCLAMATION);
}

Referenced by GetDeviceMode(), HandleDeviceMenuItem(), OpenMediaFile(), SeekPlayback(), ShowDeviceProperties(), StartPlayback(), StopPlayback(), SwitchViewMode(), and TogglePlaybackState().

StartPlayback()

static VOID StartPlayback ( HWND  hwnd )

static

Definition at line 773 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_PLAY_PARMS mciPlay;
    MCI_SEEK_PARMS mciSeek;
 
    SetTimer(hwnd, IDT_PLAYTIMER, 100, (TIMERPROC)PlayTimerProc);
 
    mciSendCommand(wDeviceId, MCI_SEEK, MCI_WAIT | MCI_SEEK_TO_START, (DWORD_PTR)&mciSeek);
 
    mciPlay.dwCallback = (DWORD_PTR)hwnd;
    mciPlay.dwFrom = 0;
    mciPlay.dwTo = MaxFilePos;
 
    mciError = mciSendCommand(wDeviceId, MCI_PLAY, MCI_NOTIFY | MCI_FROM /*| MCI_TO*/, (DWORD_PTR)&mciPlay);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
        return;
    }
 
    UpdateWindowCaption(hwnd);
 
    SendMessage(hToolBar,
                TB_SETCMDID,
                0,
                IDC_PAUSE);
    SendMessage(hToolBar,
                TB_CHANGEBITMAP,
                IDC_PAUSE,
                IDB_PAUSEICON - IDB_PLAYICON);
}

Referenced by MainWndProc(), OpenMediaFile(), and TogglePlaybackState().

StopPlayback()

static VOID StopPlayback ( HWND  hwnd )

static

Definition at line 652 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_GENERIC_PARMS mciGeneric;
    MCI_SEEK_PARMS mciSeek;
 
    if (wDeviceId == 0) return;
 
    KillTimer(hwnd, IDT_PLAYTIMER);
    SendMessage(hTrackBar, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)1);
 
    mciGeneric.dwCallback = (DWORD_PTR)hwnd;
    mciError = mciSendCommand(wDeviceId, MCI_STOP, MCI_WAIT, (DWORD_PTR)&mciGeneric);
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
        return;
    }
 
    mciSendCommand(wDeviceId, MCI_SEEK, MCI_WAIT | MCI_SEEK_TO_START, (DWORD_PTR)&mciSeek);
 
    UpdateTimeDisplay(hTimeDisplay);
    UpdateWindowCaption(hwnd);
 
    SendMessage(hToolBar,
                TB_SETCMDID,
                0,
                IDC_PLAY);
    SendMessage(hToolBar,
                TB_CHANGEBITMAP,
                IDC_PLAY,
                IDB_PLAYICON - IDB_PLAYICON);
}

Referenced by CloseMediaFile(), MainWndProc(), SeekBackPlayback(), and SeekForwPlayback().

SwitchViewMode()

static VOID SwitchViewMode ( HWND  hwnd )

static

Definition at line 371 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_DGV_RECT_PARMS mciVideoRect;
    MCI_DGV_WINDOW_PARMSW mciVideoWindow;
    RECT rcToolbarRect;
    RECT rcTempRect;
 
    mciVideoWindow.hWnd = hwnd;
 
    mciError = mciSendCommand(wDeviceId, MCI_WINDOW, MCI_DGV_WINDOW_HWND | MCI_TEST, (DWORD_PTR)&mciVideoWindow);
    if (mciError != 0)
        return;
 
    mciError = mciSendCommand(wDeviceId, MCI_WHERE, MCI_DGV_WHERE_SOURCE | MCI_TEST, (DWORD_PTR)&mciVideoRect);
    if (mciError != 0)
        return;
 
    if (!bIsSingleWindow)
    {
        GetWindowRect(hwnd, &PrevWindowPos);
 
        SetParent(hTrackBar, hToolBar);
 
        mciError = mciSendCommand(wDeviceId, MCI_WHERE, MCI_DGV_WHERE_SOURCE, (DWORD_PTR)&mciVideoRect);
        if (mciError != 0)
        {
            ShowMCIError(hwnd, mciError);
            return;
        }
 
        GetWindowRect(hToolBar, &rcToolbarRect);
        ResizeClientArea(hwnd, mciVideoRect.rc.right, mciVideoRect.rc.bottom + (rcToolbarRect.bottom - rcToolbarRect.top));
 
        mciError = mciSendCommand(wDeviceId, MCI_WINDOW, MCI_DGV_WINDOW_HWND, (DWORD_PTR)&mciVideoWindow);
        if (mciError != 0)
        {
            ShowMCIError(hwnd, mciError);
            return;
        }
 
        GetWindowRect(hToolBar, &rcTempRect);
        MoveWindow(hTrackBar, 180, 0, rcTempRect.right - rcTempRect.left - 322, 25, TRUE);
        MoveWindow(hTimeDisplay, rcTempRect.right - rcTempRect.left - 140, 4, 135, 18, TRUE);
 
        CheckMenuItem(hMainMenu, IDM_SWITCHVIEW, MF_BYCOMMAND | MF_CHECKED);
        bIsSingleWindow = TRUE;
    }
    else
    {
        bIsSingleWindow = FALSE;
        CheckMenuItem(hMainMenu, IDM_SWITCHVIEW, MF_BYCOMMAND | MF_UNCHECKED);
 
        mciVideoWindow.hWnd = MCI_DGV_WINDOW_DEFAULT;
        mciError = mciSendCommand(wDeviceId, MCI_WINDOW, MCI_DGV_WINDOW_HWND, (DWORD_PTR)&mciVideoWindow);
        if (mciError != 0)
        {
            ShowMCIError(hwnd, mciError);
            return;
        }
 
        SetParent(hTrackBar, hwnd);
 
        MoveWindow(hwnd, PrevWindowPos.left, PrevWindowPos.top, PrevWindowPos.right - PrevWindowPos.left, PrevWindowPos.bottom - PrevWindowPos.top, TRUE);
    }
}

Referenced by CloseMediaFile(), and MainWndProc().

TogglePlaybackState()

static VOID TogglePlaybackState ( HWND  hwnd )

static

Definition at line 807 of file mplay32.c.

{
    MCIERROR mciError;
    MCI_GENERIC_PARMS mciGeneric;
    ULONG idBmp = IDB_PLAYICON;
    ULONG idCmd = IDC_PLAY;
 
    if (wDeviceId == 0) return;
 
    switch (GetDeviceMode(hwnd))
    {
        case MCI_MODE_OPEN:
        case MCI_MODE_STOP:
        {
            StartPlayback(hwnd);
            return;
        }
 
        case MCI_MODE_PLAY:
        {
            mciGeneric.dwCallback = (DWORD_PTR)hwnd;
            mciError = mciSendCommand(wDeviceId, MCI_PAUSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
            idBmp = IDB_PLAYICON;
            idCmd = IDC_PLAY;
            break;
        }
 
        case MCI_MODE_PAUSE:
        {
            mciGeneric.dwCallback = (DWORD_PTR)hwnd;
            mciError = mciSendCommand(wDeviceId, MCI_RESUME, MCI_WAIT, (DWORD_PTR)&mciGeneric);
            idBmp = IDB_PAUSEICON;
            idCmd = IDC_PAUSE;
            break;
        }
 
        default:
        {
            return;
        }
    }
 
    if (mciError != 0)
    {
        ShowMCIError(hwnd, mciError);
        return;
    }
 
    UpdateWindowCaption(hwnd);
 
    SendMessage(hToolBar,
                TB_SETCMDID,
                0,
                idCmd);
    SendMessage(hToolBar,
                TB_CHANGEBITMAP,
                idCmd,
                idBmp - IDB_PLAYICON);
}

Referenced by MainWndProc().

UpdateTimeDisplay()

void UpdateTimeDisplay

(

HWND

hwnd

)

Definition at line 167 of file mplay32.c.

{
    MCI_STATUS_PARMS mciStatus;
    TCHAR szTime[MAX_MCISTR];
    DWORD dwTimeFormat;
 
    if (!wDeviceId)
    {
        SetWindowText(hwnd, _T(""));
        return;
    }
 
    mciStatus.dwItem = MCI_STATUS_TIME_FORMAT;
    mciStatus.dwReturn = 0;
    mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
    dwTimeFormat = mciStatus.dwReturn;
 
    mciStatus.dwItem = MCI_STATUS_POSITION;
    mciStatus.dwReturn = 0;
    mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
 
    switch(dwTimeFormat)
    {
        case MCI_FORMAT_MILLISECONDS:
        {
            int s, m, h;
 
            s = (mciStatus.dwReturn / 1000) % 60;
            m = ((mciStatus.dwReturn / (1000*60)) % 60);
            h = ((mciStatus.dwReturn / (1000*60*60)) % 24);
            StringCbPrintf(szTime, sizeof(szTime), _T("%02lu:%02lu:%02lu"), h, m, s);
            break;
        }
 
        /* The time format is unknown, so use the returned position as is */
        default:
        {
            StringCbPrintf(szTime, sizeof(szTime), _T("%lu"), mciStatus.dwReturn);
            break;
        }
    }
 
    SetWindowText(hwnd, szTime);
}

Referenced by CloseMciDevice(), OpenMciDevice(), PlayTimerProc(), and StopPlayback().

UpdateWindowCaption()

void UpdateWindowCaption

(

HWND

hwnd

)

Definition at line 102 of file mplay32.c.

{
    TCHAR szNewTitle[MAX_PATH + 3 + 256];
    TCHAR szStatus[128];
 
    if (wDeviceId == 0)
    {
        SetWindowText(hwnd, szAppTitle);
        return;
    }
 
    switch (GetDeviceMode(hwnd))
    {
        case MCI_MODE_PAUSE:
        {
            LoadString(hInstance, IDS_MODE_PAUSE, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_STOP:
        {
            LoadString(hInstance, IDS_MODE_STOP, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_PLAY:
        {
            LoadString(hInstance, IDS_MODE_PLAY, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_OPEN:
        {
            LoadString(hInstance, IDS_MODE_OPEN, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_RECORD:
        {
            LoadString(hInstance, IDS_MODE_RECORD, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_SEEK:
        {
            LoadString(hInstance, IDS_MODE_SEEK, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        case MCI_MODE_NOT_READY:
        {
            LoadString(hInstance, IDS_MODE_NOT_READY, szStatus, ARRAYSIZE(szStatus));
            break;
        }
 
        default:
        {
            LoadString(hInstance, IDS_MODE_UNKNOWN, szStatus, ARRAYSIZE(szStatus));
        }
    }
 
    StringCbPrintf(szNewTitle, sizeof(szNewTitle), _T("%s - %s (%s)"), szAppTitle, szCurrentFile, szStatus);
    SetWindowText(hwnd, szNewTitle);
}

Referenced by CloseMediaFile(), EDIT_WndProc(), OpenMciDevice(), StartPlayback(), StopPlayback(), and TogglePlaybackState().

Variable Documentation

bIsSingleWindow

BOOL bIsSingleWindow = FALSE

Definition at line 34 of file mplay32.c.

Referenced by CloseMediaFile(), MainWndProc(), and SwitchViewMode().

bRepeat

BOOL bRepeat = FALSE

Definition at line 33 of file mplay32.c.

Referenced by MainWndProc().

Buttons

const TBBUTTON Buttons[]

static

Initial value:

=
{   
    {TBICON_PLAY,      IDC_PLAY,     TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {TBICON_STOP,      IDC_STOP,     TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {TBICON_EJECT,     IDC_EJECT,    TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {15,               0,            TBSTATE_ENABLED, BTNS_SEP,    {0}, 0, 0},
    {TBICON_BACKWARD,  IDC_BACKWARD, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {TBICON_SEEKBACK,  IDC_SEEKBACK, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {TBICON_SEEKFORW,  IDC_SEEKFORW, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
    {TBICON_FORWARD,   IDC_FORWARD,  TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
 
}

Definition at line 41 of file mplay32.c.

Referenced by CMainToolbar::Create(), HEXEDIT_WM_LBUTTONDOWN(), InitControls(), InPortIsr(), KbdHid_StartDevice(), MessageBoxTimeoutIndirectW(), and MouHid_StartDevice().

hInstance

HINSTANCE hInstance = NULL

Definition at line 21 of file mplay32.c.

Referenced by _tWinMain(), BuildFileFilterAndDeviceMenu(), InitControls(), MainWndProc(), OpenFileDialog(), SetImageList(), ShowMCIError(), and UpdateWindowCaption().

hMainMenu

HMENU hMainMenu = NULL

Definition at line 25 of file mplay32.c.

Referenced by _tWinMain(), BuildFileFilterAndDeviceMenu(), DisableMenuItems(), EnableMenuItems(), HandleDeviceMenuItem(), InitMainWnd(), ListViewSelectionChanged(), MainWndProc(), OLEMenu_FindMainMenuIndex(), SetMenuAndButtonStates(), STRING_LoadMenus(), and SwitchViewMode().

hTimeDisplay

HWND hTimeDisplay = NULL

Definition at line 24 of file mplay32.c.

Referenced by CloseMciDevice(), InitControls(), MainWndProc(), OpenMciDevice(), PlayTimerProc(), StopPlayback(), and SwitchViewMode().

hToolBar

HWND hToolBar = NULL

Definition at line 23 of file mplay32.c.

Referenced by _CmdWndProc(), InitControls(), MainWndProc(), Preview_OnSize(), Preview_UpdateZoom(), resize_frame_rect(), SetImageList(), StartPlayback(), StopPlayback(), SwitchViewMode(), and TogglePlaybackState().

hTrackBar

HWND hTrackBar = NULL

Definition at line 22 of file mplay32.c.

Referenced by InitControls(), MainWndProc(), OpenMciDevice(), PlayTimerProc(), StopPlayback(), and SwitchViewMode().

MaxFilePos

UINT MaxFilePos = 0

Definition at line 35 of file mplay32.c.

Referenced by OpenMciDevice(), SeekForwPlayback(), and StartPlayback().

PrevWindowPos

RECT PrevWindowPos

Definition at line 36 of file mplay32.c.

Referenced by SwitchViewMode().

szAppTitle

TCHAR szAppTitle[256] = _T("")

Definition at line 27 of file mplay32.c.

Referenced by _tWinMain(), AboutDlgProc(), MainWndProc(), ShowLastWin32Error(), ShowMCIError(), and UpdateWindowCaption().

szCurrentFile

TCHAR szCurrentFile[MAX_PATH] = _T("")

Definition at line 29 of file mplay32.c.

Referenced by OpenMciDevice(), and UpdateWindowCaption().

szDefaultFilter

TCHAR szDefaultFilter[MAX_PATH] = _T("")

Definition at line 28 of file mplay32.c.

Referenced by BuildFileFilterAndDeviceMenu(), and CleanupFileFilter().

szFilter

LPTSTR szFilter = NULL

Definition at line 30 of file mplay32.c.

Referenced by ActionDlg_OnBrowse(), AVIBuildFilterA(), AVIBuildFilterW(), BrowseCursor(), BrowseRequiredFile(), BuildFileFilterAndDeviceMenu(), CleanupFileFilter(), DoOpenFile(), DoSaveAs(), MountImage(), OpenFileDialog(), PickIconProc(), and SoundsDlgProc().

wDeviceId

WORD wDeviceId = 0

Definition at line 32 of file mplay32.c.

Referenced by CloseMciDevice(), EnableMenuItems(), GetDeviceMode(), MainWndProc(), OpenMciDevice(), OpenMediaFile(), PlayTimerProc(), SeekBackPlayback(), SeekForwPlayback(), SeekPlayback(), ShowDeviceProperties(), StartPlayback(), StopPlayback(), SwitchViewMode(), TogglePlaybackState(), UpdateTimeDisplay(), and UpdateWindowCaption().