archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/shell/osshell/control/mmsys/video.c

709 lines
21 KiB
Raw Blame History

/*
***************************************************************
* video.c
*
* Copyright (C) Microsoft, 1990, All Rights Reserved.
*
* Displays the Simple media properties
*
* History:
*
* July 1994 -by- VijR (Created)
*
***************************************************************
*/
#include "mmcpl.h"
#include <windowsx.h>
#ifdef DEBUG
#undef DEBUG
#include <mmsystem.h>
#define DEBUG
#else
#include <mmsystem.h>
#endif
#include <commctrl.h>
#include <prsht.h>
#include "utils.h"
#include "medhelp.h"
#include "profile.key" // For ROOTKEY and KEYNAME etc
#define Assert(f)
/*
***************************************************************
* Defines
***************************************************************
*/
//
// !!! These actually live in mciavi\graphic.h
// !!! If MCIAVI changes these, we're hosed!
//
#define MCIAVIO_ZOOMBY2 0x00000100
#define MCIAVIO_USEVGABYDEFAULT 0x00000200
#define MCIAVIO_1QSCREENSIZE 0x00010000
#define MCIAVIO_2QSCREENSIZE 0x00020000
#define MCIAVIO_3QSCREENSIZE 0x00040000
#define MCIAVIO_MAXWINDOWSIZE 0x00080000
#define MCIAVIO_DEFWINDOWSIZE 0x00000000
#define MCIAVIO_WINDOWSIZEMASK 0x000f0000
// This bit is set in dwOptions if f16BitCompat, but doesn't get written back
// directly into the registry's version of that DWORD.
//
#define MCIAVIO_F16BITCOMPAT 0x00000001
/*
***************************************************************
* File Globals
***************************************************************
*/
static SZCODE aszMCIAVIOpt[] = TEXT("Software\\Microsoft\\Multimedia\\Video For Windows\\MCIAVI");
static SZCODE aszDefVideoOpt[] = TEXT("DefaultOptions");
static SZCODE aszReject[] = TEXT("RejectWOWOpenCalls");
static SZCODE aszRejectSection[] = TEXT("MCIAVI");
HBITMAP g_hbmMonitor = NULL; // monitor bitmap (original)
HBITMAP g_hbmScrSample = NULL; // bitmap used for IDC_SCREENSAMPLE
HBITMAP g_hbmDefault = NULL;
HDC g_hdcMem = NULL;
/*
***************************************************************
* Prototypes
***************************************************************
*/
BOOL PASCAL DoVideoCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify);
/*
***************************************************************
***************************************************************
*/
// mmGetProfileInt/mmWriteProfileInt snitched from MCIAVI32
UINT
mmGetProfileInt(LPCTSTR appname, LPCTSTR valuename, INT uDefault)
{
TCHAR achName[MAX_PATH];
HKEY hkey;
DWORD dwType;
INT value = uDefault;
DWORD dwData;
int cbData;
lstrcpy(achName, KEYNAME);
if (appname)
{
if ((lstrlen(achName)+lstrlen(appname))<ARRAYSIZE(achName))
{
lstrcat(achName, appname);
if (RegOpenKey(ROOTKEY, achName, &hkey) == ERROR_SUCCESS)
{
cbData = sizeof(dwData);
if (RegQueryValueEx(
hkey,
(LPTSTR)valuename,
NULL,
&dwType,
(PBYTE) &dwData,
&cbData) == ERROR_SUCCESS)
{
if (dwType == REG_DWORD)
{
value = (INT)dwData;
}
}
RegCloseKey(hkey);
}
}
}
return((UINT)value);
}
/*
* write a UINT to the profile, if it is not the
* same as the default or the value already there
*/
VOID
mmWriteProfileInt(LPCTSTR appname, LPCTSTR valuename, INT Value)
{
// If we would write the same as already there... return.
if (mmGetProfileInt(appname, valuename, !Value) == (UINT)Value) {
return;
}
{
TCHAR achName[MAX_PATH];
HKEY hkey = NULL;
lstrcpy(achName, KEYNAME);
lstrcat(achName, appname);
if ((RegCreateKey (ROOTKEY, achName, &hkey) == ERROR_SUCCESS) && hkey)
{
RegSetValueEx(
hkey,
valuename,
0,
REG_DWORD,
(PBYTE) &Value,
sizeof(Value)
);
RegCloseKey(hkey);
}
}
}
/*
***************************************************************
***************************************************************
*/
STATIC void WriteVideoOptions(DWORD dwOpt)
{
HKEY hkVideoOpt;
BOOL f16BitCompat;
f16BitCompat = (dwOpt & MCIAVIO_F16BITCOMPAT) ? TRUE : FALSE;
dwOpt &= ~MCIAVIO_F16BITCOMPAT;
if(RegCreateKeyEx( HKEY_CURRENT_USER, (LPTSTR)aszMCIAVIOpt, 0, NULL, 0,KEY_WRITE | KEY_READ, NULL, &hkVideoOpt, NULL ))
return;
RegSetValueEx( hkVideoOpt, (LPTSTR)aszDefVideoOpt, 0, REG_DWORD,(LPBYTE)&dwOpt, sizeof(DWORD) );
mmWriteProfileInt (aszRejectSection, aszReject, (int)f16BitCompat);
RegCloseKey(hkVideoOpt);
}
STATIC DWORD ReadVideoOptions(void)
{
HKEY hkVideoOpt;
DWORD dwType;
DWORD dwOpt;
DWORD cbSize;
if(RegCreateKeyEx( HKEY_CURRENT_USER, (LPTSTR)aszMCIAVIOpt, 0, NULL, 0,KEY_WRITE | KEY_READ, NULL, &hkVideoOpt, NULL ))
return 0 ;
cbSize = sizeof(DWORD);
if (RegQueryValueEx( hkVideoOpt,(LPTSTR)aszDefVideoOpt,NULL,&dwType,(LPBYTE)&dwOpt,&cbSize ))
{
dwOpt = 0;
RegSetValueEx( hkVideoOpt, (LPTSTR)aszDefVideoOpt, 0, REG_DWORD,(LPBYTE)&dwOpt, sizeof(DWORD) );
}
if (mmGetProfileInt (aszRejectSection, aszReject, 0))
{
dwOpt |= MCIAVIO_F16BITCOMPAT;
}
RegCloseKey(hkVideoOpt);
return dwOpt;
}
STATIC void FillWindowSizeCB(DWORD dwOptions, HWND hCBWinSize)
{
TCHAR sz1QScreenSize[64];
TCHAR sz2QScreenSize[64];
TCHAR sz3QScreenSize[64];
TCHAR szMaxSize[64];
TCHAR szOriginalSize[64];
TCHAR szZoomedSize[64];
int iIndex;
LPTSTR lpszCurDefSize;
LoadString(ghInstance, IDS_NORMALSIZE, szOriginalSize, sizeof(szOriginalSize)/sizeof(TCHAR));
LoadString(ghInstance, IDS_ZOOMEDSIZE, szZoomedSize, sizeof(szZoomedSize)/sizeof(TCHAR));
LoadString(ghInstance, IDS_1QSCREENSIZE, sz1QScreenSize, sizeof(sz1QScreenSize)/sizeof(TCHAR));
LoadString(ghInstance, IDS_2QSCREENSIZE, sz2QScreenSize, sizeof(sz2QScreenSize)/sizeof(TCHAR));
LoadString(ghInstance, IDS_3QSCREENSIZE, sz3QScreenSize, sizeof(sz3QScreenSize)/sizeof(TCHAR));
LoadString(ghInstance, IDS_VIDEOMAXIMIZED, szMaxSize, sizeof(szMaxSize)/sizeof(TCHAR));
iIndex = ComboBox_AddString(hCBWinSize, szOriginalSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_DEFWINDOWSIZE);
iIndex = ComboBox_AddString(hCBWinSize, szZoomedSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_ZOOMBY2);
iIndex = ComboBox_AddString(hCBWinSize, sz1QScreenSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_1QSCREENSIZE);
iIndex = ComboBox_AddString(hCBWinSize, sz2QScreenSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_2QSCREENSIZE);
iIndex = ComboBox_AddString(hCBWinSize, sz3QScreenSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_3QSCREENSIZE);
iIndex = ComboBox_AddString(hCBWinSize, szMaxSize);
ComboBox_SetItemData(hCBWinSize, iIndex, (LPARAM)MCIAVIO_MAXWINDOWSIZE);
switch(dwOptions & MCIAVIO_WINDOWSIZEMASK)
{
case MCIAVIO_DEFWINDOWSIZE:
if (dwOptions & MCIAVIO_ZOOMBY2)
lpszCurDefSize = szZoomedSize;
else
lpszCurDefSize = szOriginalSize;
break;
case MCIAVIO_1QSCREENSIZE:
lpszCurDefSize = sz1QScreenSize;
break;
case MCIAVIO_2QSCREENSIZE:
lpszCurDefSize = sz2QScreenSize;
break;
case MCIAVIO_3QSCREENSIZE:
lpszCurDefSize = sz3QScreenSize;
break;
case MCIAVIO_MAXWINDOWSIZE:
lpszCurDefSize = szMaxSize;
break;
}
//
// We should select string that matches exactly.
//
iIndex = ComboBox_FindStringExact(hCBWinSize, 0, lpszCurDefSize);
ComboBox_SetCurSel(hCBWinSize, iIndex);
}
/*---------------------------------------------------------
**
**---------------------------------------------------------*/
// information about the monitor bitmap
// x, y, dx, dy define the size of the "screen" part of the bitmap
// the RGB is the color of the screen's desktop
// these numbers are VERY hard-coded to a monitor bitmap
#define MON_X 16
#define MON_Y 17
#define MON_DX 152
#define MON_DY 112
#define MON_IMAGE_X (MON_X + 46)
#define MON_IMAGE_Y (MON_Y + 33)
#define MON_IMAGE_DX 59
#define MON_IMAGE_DY 44
#define MON_TITLE 10
#define MON_BORDER 2
#define MON_TRAY 8
STATIC HBITMAP FAR LoadMonitorBitmap( BOOL bFillDesktop )
{
HBITMAP hbm;
hbm = (HBITMAP) LoadImage(ghInstance,MAKEINTATOM(IDB_MONITOR), IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
Assert(hbm);
return hbm;
}
/*------------------------pixel resolution---------------------------
**
** show the sample screen with proper sizing
*/
STATIC void NEAR PASCAL ShowSampleScreen(HWND hDlg, int iMCIWindowSize)
{
HBITMAP hbmOld;
HBRUSH hbr;
HDC hdcMem2;
SIZE dSrc = {MON_IMAGE_DX, MON_IMAGE_DY};
POINT ptSrc = {MON_IMAGE_X, MON_IMAGE_Y};
SIZE dDst;
POINT ptDst;
RECT rcImage = {MON_IMAGE_X, MON_IMAGE_Y, MON_IMAGE_X + MON_IMAGE_DX, MON_IMAGE_Y + MON_IMAGE_DY};
if (!g_hbmMonitor || !g_hbmScrSample)
return;
switch(iMCIWindowSize)
{
case MCIAVIO_DEFWINDOWSIZE:
dDst = dSrc;
ptDst = ptSrc;
break;
case MCIAVIO_ZOOMBY2:
dDst.cx = 2 * dSrc.cx;
dDst.cy = 2 * dSrc.cy;
ptDst.x = ptSrc.x - (int)(dSrc.cx/2);
ptDst.y = ptSrc.y - (int)(dSrc.cy/2);
break;
case MCIAVIO_MAXWINDOWSIZE:
ptDst.x = MON_X;
ptDst.y = MON_Y;
dDst.cx = MON_DX;
dDst.cy = MON_DY - MON_TRAY;
break;
case MCIAVIO_1QSCREENSIZE:
dDst.cx = MulDiv(MON_DX, 1, 4);
dDst.cy = MulDiv(MON_DY, 1, 4);
ptDst.x = MON_X + MulDiv((MON_DX - dDst.cx), 1 , 2);
ptDst.y = MON_Y + MulDiv((MON_DY - dDst.cy - MON_TRAY), 1 , 2);
break;
case MCIAVIO_2QSCREENSIZE:
dDst.cx = MulDiv(MON_DX, 1, 2);
dDst.cy = MulDiv(MON_DY, 1, 2);
ptDst.x = MON_X + MulDiv((MON_DX - dDst.cx), 1 , 2);
ptDst.y = MON_Y + MulDiv((MON_DY - dDst.cy - MON_TRAY), 1 , 2);
break;
case MCIAVIO_3QSCREENSIZE:
dDst.cx = MulDiv(MON_DX, 3, 4);
dDst.cy = MulDiv(MON_DY, 3, 4);
ptDst.x = MON_X + MulDiv((MON_DX - dDst.cx), 1 , 2);
ptDst.y = MON_Y + MulDiv((MON_DY - dDst.cy - MON_TRAY), 1 , 2);
break;
case MCIAVIO_USEVGABYDEFAULT:
dDst.cx = MON_DX;
dDst.cy = MON_DY;
ptDst.x = MON_X;
ptDst.y = MON_Y;
dSrc.cx = MON_IMAGE_DX - (2 * MON_BORDER);
dSrc.cy = MON_IMAGE_DY - MON_TITLE - MON_BORDER;
ptSrc.x = MON_IMAGE_X + MON_BORDER;
ptSrc.y = MON_IMAGE_Y + MON_TITLE + MON_BORDER;
break;
}
// set up a work area to play in
hdcMem2 = CreateCompatibleDC(g_hdcMem);
if (!hdcMem2)
return;
SelectObject(hdcMem2, g_hbmScrSample);
hbmOld = SelectObject(g_hdcMem, g_hbmMonitor);
//copy the whole bmp first and then start stretching
BitBlt(hdcMem2, MON_X, MON_Y, MON_DX, MON_DY, g_hdcMem, MON_X, MON_Y, SRCCOPY);
//Wipe out the existing Image
hbr = CreateSolidBrush( GetPixel( g_hdcMem, MON_X + 1, MON_Y + 1 ) );
if (!hbr)
{
DeleteObject( hdcMem2 );
return;
}
FillRect(hdcMem2, &rcImage, hbr);
DeleteObject( hbr );
// stretch the image to reflect the new size
SetStretchBltMode( hdcMem2, COLORONCOLOR );
StretchBlt( hdcMem2, ptDst.x, ptDst.y, dDst.cx, dDst.cy,
g_hdcMem, ptSrc.x, ptSrc.y, dSrc.cx, dSrc.cy, SRCCOPY );
SelectObject( hdcMem2, g_hbmDefault );
DeleteObject( hdcMem2 );
SelectObject( g_hdcMem, hbmOld );
InvalidateRect(GetDlgItem(hDlg, IDC_SCREENSAMPLE), NULL, FALSE);
}
STATIC void DoMonitorBmp(HWND hDlg)
{
HDC hdc = GetDC(NULL);
HBITMAP hbm;
g_hdcMem = CreateCompatibleDC(hdc);
ReleaseDC(NULL, hdc);
if (!g_hdcMem)
return;
hbm = CreateBitmap(1,1,1,1,NULL);
if (!hbm) return;
g_hbmDefault = SelectObject(g_hdcMem, hbm);
SelectObject(g_hdcMem, g_hbmDefault);
DeleteObject(hbm);
// set up bitmaps for sample screen
g_hbmScrSample = LoadMonitorBitmap( TRUE ); // let them do the desktop
SendDlgItemMessage(hDlg, IDC_SCREENSAMPLE, STM_SETIMAGE, IMAGE_BITMAP, (DWORD_PTR)g_hbmScrSample);
// get a base copy of the bitmap for when the "internals" change
g_hbmMonitor = LoadMonitorBitmap( FALSE ); // we'll do the desktop
}
const static DWORD aAdvVideoDlgHelpIds[] = { // Context Help IDs
(DWORD)IDC_STATIC, IDH_VIDEO_ADVANCED_COMPAT,
ID_ADVVIDEO_COMPAT, IDH_VIDEO_ADVANCED_COMPAT,
0, 0
};
INT_PTR AdvancedVideoDlgProc (HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
static BOOL *pfCompat = NULL;
switch (wMsg)
{
case WM_INITDIALOG:
{
if ((pfCompat = (BOOL *)lParam) == NULL)
return -1;
CheckDlgButton (hDlg, ID_ADVVIDEO_COMPAT, (*pfCompat));
break;
}
case WM_COMMAND:
{
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDOK:
*pfCompat = IsDlgButtonChecked (hDlg, ID_ADVVIDEO_COMPAT);
// fall through
case IDCANCEL:
EndDialog (hDlg, GET_WM_COMMAND_ID(wParam, lParam));
break;
}
break;
}
case WM_CONTEXTMENU:
{
WinHelp ((HWND)wParam, NULL, HELP_CONTEXTMENU,
(UINT_PTR)aAdvVideoDlgHelpIds);
return TRUE;
}
case WM_HELP:
{
WinHelp (((LPHELPINFO)lParam)->hItemHandle, NULL,
HELP_WM_HELP, (UINT_PTR)aAdvVideoDlgHelpIds);
return TRUE;
}
}
return FALSE;
}
const static DWORD aVideoDlgHelpIds[] = { // Context Help IDs
IDC_GROUPBOX, IDH_COMM_GROUPBOX,
IDC_SCREENSAMPLE, IDH_VIDEO_GRAPHIC,
IDC_VIDEO_FULLSCREEN, IDH_VIDEO_FULL_SCREEN,
IDC_VIDEO_INWINDOW, IDH_VIDEO_FIXED_WINDOW,
IDC_VIDEO_CB_SIZE, IDH_VIDEO_FIXED_WINDOW,
ID_VIDEO_ADVANCED, IDH_VIDEO_ADVANCED_BUTTON,
0, 0
};
BOOL CALLBACK VideoDlg(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
NMHDR FAR *lpnm;
switch (uMsg)
{
case WM_NOTIFY:
lpnm = (NMHDR FAR *)lParam;
switch(lpnm->code)
{
case PSN_KILLACTIVE:
FORWARD_WM_COMMAND(hDlg, IDOK, 0, 0, SendMessage);
break;
case PSN_APPLY:
FORWARD_WM_COMMAND(hDlg, ID_APPLY, 0, 0, SendMessage);
break;
case PSN_SETACTIVE:
FORWARD_WM_COMMAND(hDlg, ID_INIT, 0, 0, SendMessage);
break;
case PSN_RESET:
FORWARD_WM_COMMAND(hDlg, IDCANCEL, 0, 0, SendMessage);
break;
}
break;
case WM_INITDIALOG:
{
DWORD dwOptions;
dwOptions = ReadVideoOptions();
FillWindowSizeCB(dwOptions, GetDlgItem(hDlg, IDC_VIDEO_CB_SIZE));
SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)dwOptions);
DoMonitorBmp(hDlg);
if (IsFlagSet(dwOptions, MCIAVIO_USEVGABYDEFAULT))
{
CheckRadioButton(hDlg, IDC_VIDEO_INWINDOW, IDC_VIDEO_FULLSCREEN, IDC_VIDEO_FULLSCREEN);
EnableWindow(GetDlgItem(hDlg, IDC_VIDEO_CB_SIZE), FALSE);
ShowSampleScreen(hDlg, MCIAVIO_USEVGABYDEFAULT);
break;
}
else
{
CheckRadioButton(hDlg, IDC_VIDEO_INWINDOW, IDC_VIDEO_FULLSCREEN, IDC_VIDEO_INWINDOW);
EnableWindow(GetDlgItem(hDlg, IDC_VIDEO_CB_SIZE), TRUE);
}
ShowSampleScreen(hDlg, dwOptions & (MCIAVIO_WINDOWSIZEMASK|MCIAVIO_ZOOMBY2));
break;
}
case WM_DESTROY:
if (g_hbmScrSample)
{
DeleteObject(g_hbmScrSample);
g_hbmScrSample = NULL;
}
if (g_hbmMonitor)
{
DeleteObject(g_hbmMonitor);
g_hbmMonitor = NULL;
}
if (g_hbmDefault)
{
DeleteObject(g_hbmDefault);
g_hbmDefault = NULL;
}
if (g_hdcMem)
{
DeleteDC(g_hdcMem);
g_hdcMem = NULL;
}
break;
case WM_DROPFILES:
break;
case WM_CONTEXTMENU:
WinHelp ((HWND) wParam, NULL, HELP_CONTEXTMENU,
(UINT_PTR) (LPTSTR) aVideoDlgHelpIds);
return TRUE;
case WM_HELP:
{
LPHELPINFO lphi = (LPVOID) lParam;
WinHelp (lphi->hItemHandle, NULL, HELP_WM_HELP,
(UINT_PTR) (LPTSTR) aVideoDlgHelpIds);
return TRUE;
}
case WM_COMMAND:
HANDLE_WM_COMMAND(hDlg, wParam, lParam, DoVideoCommand);
break;
}
return FALSE;
}
BOOL PASCAL DoVideoCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify)
{
switch (id)
{
case ID_APPLY:
{
int iIndex;
HWND hCBWinSize = GetDlgItem(hDlg,IDC_VIDEO_CB_SIZE);
DWORD dwOldOpt;
DWORD dwNewOpt;
dwOldOpt = (DWORD)GetWindowLongPtr(hDlg, DWLP_USER);
if(Button_GetCheck(GetDlgItem(hDlg, IDC_VIDEO_FULLSCREEN)))
{
dwNewOpt = MCIAVIO_USEVGABYDEFAULT;
}
else
{
iIndex = ComboBox_GetCurSel(hCBWinSize);
dwNewOpt = (DWORD)ComboBox_GetItemData(hCBWinSize, iIndex);
}
ClearFlag(dwOldOpt,MCIAVIO_WINDOWSIZEMASK|MCIAVIO_USEVGABYDEFAULT|MCIAVIO_ZOOMBY2);
SetFlag(dwOldOpt, dwNewOpt);
WriteVideoOptions(dwOldOpt);
SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)dwOldOpt);
return TRUE;
}
case IDOK:
break;
case IDCANCEL:
break;
case IDC_VIDEO_FULLSCREEN:
EnableWindow(GetDlgItem(hDlg, IDC_VIDEO_CB_SIZE), FALSE);
PropSheet_Changed(GetParent(hDlg),hDlg);
ShowSampleScreen(hDlg, MCIAVIO_USEVGABYDEFAULT);
break;
case IDC_VIDEO_INWINDOW:
{
HWND hwndCB = GetDlgItem(hDlg,IDC_VIDEO_CB_SIZE);
int iIndex = ComboBox_GetCurSel(hwndCB);
int iOpt = (int)ComboBox_GetItemData(hwndCB, iIndex);
EnableWindow(GetDlgItem(hDlg, IDC_VIDEO_CB_SIZE), TRUE);
PropSheet_Changed(GetParent(hDlg),hDlg);
ShowSampleScreen(hDlg, iOpt);
break;
}
case IDC_VIDEO_CB_SIZE:
switch (codeNotify)
{
case CBN_SELCHANGE:
{
int iIndex = ComboBox_GetCurSel(hwndCtl);
int iOpt = (int)ComboBox_GetItemData(hwndCtl, iIndex);
PropSheet_Changed(GetParent(hDlg),hDlg);
ShowSampleScreen(hDlg, iOpt);
break;
}
default:
break;
}
break;
case ID_VIDEO_ADVANCED:
{
INT_PTR f16BitCompat;
f16BitCompat = (GetWindowLongPtr(hDlg, DWLP_USER) & MCIAVIO_F16BITCOMPAT);
if (DialogBoxParam (ghInstance,
MAKEINTRESOURCE(ADVVIDEODLG),
hDlg,
AdvancedVideoDlgProc,
(LPARAM)&f16BitCompat) == IDOK)
{
SetWindowLongPtr (hDlg, DWLP_USER,
GetWindowLongPtr (hDlg, DWLP_USER)
& (~MCIAVIO_F16BITCOMPAT)
| ((f16BitCompat) ? (MCIAVIO_F16BITCOMPAT) : 0));
PropSheet_Changed(GetParent(hDlg),hDlg);
}
break;
}
case ID_INIT:
break;
}
return FALSE;
}