2291 lines
65 KiB
C++
2291 lines
65 KiB
C++
/**************************************************************************\
|
|
* Module Name: settings.cpp
|
|
*
|
|
* Contains Implementation of the CDisplaySettings class who is in charge of
|
|
* the settings of a single display. This is the data base class who does the
|
|
* real change display settings work
|
|
*
|
|
* Copyright (c) Microsoft Corp. 1992-1998 All Rights Reserved
|
|
*
|
|
\**************************************************************************/
|
|
|
|
|
|
#include "priv.h"
|
|
|
|
#include "DisplaySettings.h"
|
|
#include "ntreg.hxx"
|
|
|
|
extern int AskDynaCDS(HWND hDlg);
|
|
INT_PTR CALLBACK KeepNewDlgProc(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam);
|
|
|
|
UINT g_cfDisplayDevice = 0;
|
|
UINT g_cfDisplayName = 0;
|
|
UINT g_cfDisplayDeviceID = 0;
|
|
UINT g_cfMonitorDevice = 0;
|
|
UINT g_cfMonitorName = 0;
|
|
UINT g_cfMonitorDeviceID = 0;
|
|
UINT g_cfExtensionInterface = 0;
|
|
UINT g_cfDisplayDeviceKey = 0;
|
|
UINT g_cfDisplayStateFlags = 0;
|
|
UINT g_cfDisplayPruningMode = 0;
|
|
|
|
#define TF_DISPLAYSETTINGS 0
|
|
|
|
/*****************************************************************\
|
|
*
|
|
* helper routine
|
|
*
|
|
\*****************************************************************/
|
|
|
|
int CDisplaySettings::_InsertSortedDwords(
|
|
int val1,
|
|
int val2,
|
|
int cval,
|
|
int **ppval)
|
|
{
|
|
int *oldpval = *ppval;
|
|
int *tmppval;
|
|
int i;
|
|
|
|
for (i=0; i<cval; i++)
|
|
{
|
|
tmppval = (*ppval) + (i * 2);
|
|
|
|
if (*tmppval == val1)
|
|
{
|
|
if (*(tmppval + 1) == val2)
|
|
{
|
|
return cval;
|
|
}
|
|
else if (*(tmppval + 1) > val2)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if (*tmppval > val1)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
TraceMsg(TF_FUNC,"_InsertSortedDword, vals = %d %d, cval = %d, index = %d", val1, val2, cval, i);
|
|
|
|
*ppval = (int *) LocalAlloc(LPTR, (cval + 1) * 2 * sizeof(DWORD));
|
|
|
|
if (*ppval)
|
|
{
|
|
//
|
|
// Insert the items at the right location in the array
|
|
//
|
|
if (oldpval) {
|
|
CopyMemory(*ppval,
|
|
oldpval,
|
|
i * 2 * sizeof(DWORD));
|
|
}
|
|
|
|
*(*ppval + (i * 2)) = val1;
|
|
*(*ppval + (i * 2) + 1) = val2;
|
|
|
|
if (oldpval) {
|
|
CopyMemory((*ppval) + 2 * (i + 1),
|
|
oldpval+ (i * 2),
|
|
(cval-i) * 2 * sizeof(DWORD));
|
|
|
|
LocalFree(oldpval);
|
|
}
|
|
|
|
return (cval + 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************\
|
|
*
|
|
* debug routine
|
|
*
|
|
\*****************************************************************/
|
|
|
|
|
|
void CDisplaySettings::_Dump_CDisplaySettings(BOOL bAll)
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS,"Dump of CDisplaySettings structure");
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _DisplayDevice = %s", _pDisplayDevice->DeviceName);
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _cpdm = %d", _cpdm );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _apdm = %08lx", _apdm );
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t OrgResolution = %d, %d", _ORGXRES, _ORGYRES );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _ptOrgPos = %d, %d", _ptOrgPos.x ,_ptOrgPos.y);
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t OrgColor = %d", _ORGCOLOR );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t OrgFrequency = %d", _ORGFREQ );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _pOrgDevmode = %08lx", _pOrgDevmode );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _fOrgAttached = %d", _fOrgAttached );
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t CurResolution = %d, %d", _CURXRES, _CURYRES );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _ptCurPos = %d, %d", _ptCurPos.x ,_ptCurPos.y);
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t CurColor = %d", _CURCOLOR );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t CurFrequency = %d", _CURFREQ );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _pCurDevmode = %08lx", _pCurDevmode );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _fCurAttached = %d", _fCurAttached );
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _fUsingDefault = %d", _fUsingDefault );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _fPrimary = %d", _fPrimary );
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t _cRef = %d", _cRef );
|
|
|
|
if (bAll)
|
|
{
|
|
_Dump_CDevmodeList();
|
|
}
|
|
}
|
|
|
|
void CDisplaySettings::_Dump_CDevmodeList(VOID)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i=0; _apdm && (i<_cpdm); i++)
|
|
{
|
|
LPDEVMODE lpdm = (_apdm + i)->lpdm;
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t\t mode %d, %08lx, Flags %08lx, X=%d Y=%d C=%d F=%d O=%d FO=%d",
|
|
i, lpdm, (_apdm + i)->dwFlags,
|
|
lpdm->dmPelsWidth, lpdm->dmPelsHeight, lpdm->dmBitsPerPel, lpdm->dmDisplayFrequency,
|
|
lpdm->dmDisplayOrientation, lpdm->dmDisplayFixedOutput);
|
|
}
|
|
}
|
|
|
|
void CDisplaySettings::_Dump_CDevmode(LPDEVMODE pdm)
|
|
{
|
|
TraceMsg(TF_DUMP_DEVMODE," Size = %d", pdm->dmSize);
|
|
TraceMsg(TF_DUMP_DEVMODE," Fields = %08lx", pdm->dmFields);
|
|
TraceMsg(TF_DUMP_DEVMODE," XPosition = %d", pdm->dmPosition.x);
|
|
TraceMsg(TF_DUMP_DEVMODE," YPosition = %d", pdm->dmPosition.y);
|
|
TraceMsg(TF_DUMP_DEVMODE," XResolution = %d", pdm->dmPelsWidth);
|
|
TraceMsg(TF_DUMP_DEVMODE," YResolution = %d", pdm->dmPelsHeight);
|
|
TraceMsg(TF_DUMP_DEVMODE," Bpp = %d", pdm->dmBitsPerPel);
|
|
TraceMsg(TF_DUMP_DEVMODE," Frequency = %d", pdm->dmDisplayFrequency);
|
|
TraceMsg(TF_DUMP_DEVMODE," Flags = %d", pdm->dmDisplayFlags);
|
|
TraceMsg(TF_DUMP_DEVMODE," XPanning = %d", pdm->dmPanningWidth);
|
|
TraceMsg(TF_DUMP_DEVMODE," YPanning = %d", pdm->dmPanningHeight);
|
|
TraceMsg(TF_DUMP_DEVMODE," DPI = %d", pdm->dmLogPixels);
|
|
TraceMsg(TF_DUMP_DEVMODE," DriverExtra = %d", pdm->dmDriverExtra);
|
|
TraceMsg(TF_DUMP_DEVMODE," Orientation = %d", pdm->dmDisplayOrientation);
|
|
TraceMsg(TF_DUMP_DEVMODE," FixedOutput = %d", pdm->dmDisplayFixedOutput);
|
|
if (pdm->dmDriverExtra)
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS,"\t - %08lx %08lx",
|
|
*(PULONG)(((PUCHAR)pdm)+pdm->dmSize),
|
|
*(PULONG)(((PUCHAR)pdm)+pdm->dmSize + 4));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Lets perform the following operations on the list
|
|
//
|
|
// (1) Remove identical modes
|
|
// (2) Remove 16 color modes for which there is a 256
|
|
// color equivalent.
|
|
// (3) Remove modes with any dimension less than 640x480
|
|
//
|
|
|
|
void CDisplaySettings::_FilterModes()
|
|
{
|
|
DWORD i, j;
|
|
LPDEVMODE pdm, pdm2;
|
|
PMODEARRAY pMode, pMode2;
|
|
|
|
for (i = 0; _apdm && i < _cpdm; i++)
|
|
{
|
|
pMode = _apdm + i;
|
|
pdm = pMode->lpdm;
|
|
|
|
// Skip any invalid modes
|
|
if (pMode->dwFlags & MODE_INVALID)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// If any of the following conditions are true, then we want to
|
|
// remove the current mode.
|
|
//
|
|
|
|
// Remove any modes that are too small
|
|
if (pdm->dmPelsHeight < 480 || pdm->dmPelsWidth < 640)
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS,"_FilterModes: Mode %d - resolution too small", i);
|
|
pMode->dwFlags |= MODE_INVALID;
|
|
continue;
|
|
}
|
|
|
|
// Remove any modes that would change the orientation
|
|
if (_bFilterOrientation)
|
|
{
|
|
if (pdm->dmFields & DM_DISPLAYORIENTATION &&
|
|
pdm->dmDisplayOrientation != _dwOrientation)
|
|
{
|
|
pMode->dwFlags |= MODE_INVALID;
|
|
TraceMsg(TF_DUMP_CSETTINGS,"_FilterModes: Mode %d - Wrong Orientation", i);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Remove any modes that would change fixed output unless our current mode is
|
|
// native resolution
|
|
if (_bFilterFixedOutput && _dwFixedOutput != DMDFO_DEFAULT)
|
|
{
|
|
if (pdm->dmFields & DM_DISPLAYFIXEDOUTPUT &&
|
|
pdm->dmDisplayFixedOutput != _dwFixedOutput)
|
|
{
|
|
pMode->dwFlags |= MODE_INVALID;
|
|
TraceMsg(TF_DUMP_CSETTINGS,"_FilterModes: Mode %d - Wrong FixedOutput", i);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Remove any duplicate modes
|
|
for (j = i + 1; j < _cpdm; j++)
|
|
{
|
|
pMode2 = _apdm + j;
|
|
pdm2 = pMode2->lpdm;
|
|
|
|
if (!(pMode2->dwFlags & MODE_INVALID) &&
|
|
pdm2->dmBitsPerPel == pdm->dmBitsPerPel &&
|
|
pdm2->dmPelsWidth == pdm->dmPelsWidth &&
|
|
pdm2->dmPelsHeight == pdm->dmPelsHeight &&
|
|
pdm2->dmDisplayFrequency == pdm->dmDisplayFrequency)
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS,"_FilterModes: Mode %d - Duplicate Mode", i);
|
|
pMode2->dwFlags |= MODE_INVALID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// _AddDevMode method
|
|
//
|
|
// This method builds the index lists for the matrix. There is one
|
|
// index list for each axes of the three dimemsional matrix of device
|
|
// modes.
|
|
//
|
|
// The entry is also automatically added to the linked list of modes if
|
|
// it is not alreay present in the list.
|
|
//
|
|
|
|
BOOL CDisplaySettings::_AddDevMode(LPDEVMODE lpdm)
|
|
{
|
|
if (lpdm)
|
|
{
|
|
PMODEARRAY newapdm, tempapdm;
|
|
|
|
//
|
|
// Set the height for the test of the 1152 mode
|
|
//
|
|
|
|
if (lpdm->dmPelsWidth == 1152) {
|
|
|
|
// Set1152Mode(lpdm->dmPelsHeight);
|
|
}
|
|
|
|
newapdm = (PMODEARRAY) LocalAlloc(LPTR, (_cpdm + 1) * sizeof(MODEARRAY));
|
|
if (newapdm)
|
|
{
|
|
CopyMemory(newapdm, _apdm, _cpdm * sizeof(MODEARRAY));
|
|
|
|
(newapdm + _cpdm)->dwFlags &= ~MODE_INVALID;
|
|
(newapdm + _cpdm)->dwFlags |= MODE_RAW;
|
|
(newapdm + _cpdm)->lpdm = lpdm;
|
|
|
|
}
|
|
|
|
tempapdm = _apdm;
|
|
_apdm = newapdm;
|
|
_cpdm++;
|
|
|
|
if (tempapdm)
|
|
{
|
|
LocalFree(tempapdm);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Return a list of Resolutions supported, given a color depth
|
|
//
|
|
|
|
int CDisplaySettings::GetResolutionList(
|
|
int Color,
|
|
PPOINT *ppRes)
|
|
{
|
|
DWORD i;
|
|
int cRes = 0;
|
|
int *pResTmp = NULL;
|
|
LPDEVMODE pdm;
|
|
|
|
*ppRes = NULL;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(!_IsModePreferred(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if ((Color == -1) ||
|
|
(Color == (int)pdm->dmBitsPerPel))
|
|
{
|
|
cRes = _InsertSortedDwords(pdm->dmPelsWidth,
|
|
pdm->dmPelsHeight,
|
|
cRes,
|
|
&pResTmp);
|
|
}
|
|
}
|
|
|
|
*ppRes = (PPOINT) pResTmp;
|
|
|
|
return cRes;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Return a list of color depths supported
|
|
//
|
|
|
|
int CDisplaySettings::GetColorList(
|
|
LPPOINT Res,
|
|
PLONGLONG *ppColor)
|
|
{
|
|
DWORD i;
|
|
int cColor = 0;
|
|
int *pColorTmp = NULL;
|
|
LPDEVMODE pdm;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(!_IsModePreferred(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if ((Res == NULL) ||
|
|
(Res->x == -1) ||
|
|
(Res->y == -1) ||
|
|
(Res->x == (int)pdm->dmPelsWidth) ||
|
|
(Res->y == (int)pdm->dmPelsHeight))
|
|
{
|
|
cColor = _InsertSortedDwords(pdm->dmBitsPerPel,
|
|
0,
|
|
cColor,
|
|
&pColorTmp);
|
|
}
|
|
}
|
|
|
|
*ppColor = (PLONGLONG) pColorTmp;
|
|
|
|
return cColor;
|
|
}
|
|
|
|
int CDisplaySettings::GetFrequencyList(int Color, LPPOINT Res, PLONGLONG *ppFreq)
|
|
{
|
|
DWORD i;
|
|
int cFreq = 0;
|
|
int *pFreqTmp = NULL;
|
|
LPDEVMODE pdm;
|
|
POINT res;
|
|
|
|
if (Color == -1) {
|
|
Color = _CURCOLOR;
|
|
}
|
|
|
|
if (Res == NULL)
|
|
{
|
|
MAKEXYRES(&res, _CURXRES, _CURYRES);
|
|
}
|
|
else
|
|
{
|
|
res = *Res;
|
|
}
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if (res.x == (int)pdm->dmPelsWidth &&
|
|
res.y == (int)pdm->dmPelsHeight &&
|
|
Color == (int)pdm->dmBitsPerPel)
|
|
{
|
|
cFreq = _InsertSortedDwords(pdm->dmDisplayFrequency,
|
|
0,
|
|
cFreq,
|
|
&pFreqTmp);
|
|
}
|
|
}
|
|
|
|
*ppFreq = (PLONGLONG) pFreqTmp;
|
|
|
|
return cFreq;
|
|
}
|
|
|
|
void CDisplaySettings::SetCurFrequency(int Frequency)
|
|
{
|
|
LPDEVMODE pdm;
|
|
LPDEVMODE pdmMatch = NULL;
|
|
ULONG i;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
//
|
|
// Find the exact match.
|
|
//
|
|
if (_CURCOLOR == (int) pdm->dmBitsPerPel &&
|
|
_CURXRES == (int) pdm->dmPelsWidth &&
|
|
_CURYRES == (int) pdm->dmPelsHeight &&
|
|
Frequency == (int) pdm->dmDisplayFrequency)
|
|
{
|
|
pdmMatch = pdm;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We should always make a match because the list of frequencies shown to
|
|
// the user is only for the current color & resolution
|
|
//
|
|
ASSERT(pdmMatch);
|
|
if (pdmMatch) {
|
|
_SetCurrentValues(pdmMatch);
|
|
}
|
|
}
|
|
|
|
LPDEVMODE CDisplaySettings::GetCurrentDevMode(void)
|
|
{
|
|
ULONG dmSize = _pCurDevmode->dmSize + _pCurDevmode->dmDriverExtra;
|
|
PDEVMODE pdevmode = (LPDEVMODE) LocalAlloc(LPTR, dmSize);
|
|
|
|
if (pdevmode) {
|
|
CopyMemory(pdevmode, _pCurDevmode, dmSize);
|
|
}
|
|
|
|
return pdevmode;
|
|
}
|
|
|
|
void CDisplaySettings::_SetCurrentValues(LPDEVMODE lpdm)
|
|
{
|
|
_pCurDevmode = lpdm;
|
|
|
|
//
|
|
// Don't save the other fields (like position) as they are programmed by
|
|
// the UI separately.
|
|
//
|
|
// This should only save hardware specific fields.
|
|
//
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS,"");
|
|
TraceMsg(TF_DUMP_CSETTINGS,"_SetCurrentValues complete");
|
|
_Dump_CDisplaySettings(FALSE);
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::_PerfectMatch(LPDEVMODE lpdm)
|
|
{
|
|
for (DWORD i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ((_apdm + i)->lpdm == lpdm)
|
|
{
|
|
_SetCurrentValues((_apdm + i)->lpdm);
|
|
|
|
TraceMsg(TF_DISPLAYSETTINGS, "_PerfectMatch -- return TRUE");
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
TraceMsg(TF_DISPLAYSETTINGS, "_PerfectMatch -- return FALSE");
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CDisplaySettings::_ExactMatch(LPDEVMODE lpdm, BOOL bForceVisible)
|
|
{
|
|
LPDEVMODE pdm;
|
|
ULONG i;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if (
|
|
((lpdm->dmFields & DM_BITSPERPEL) &&
|
|
(pdm->dmBitsPerPel != lpdm->dmBitsPerPel))
|
|
|
|
||
|
|
|
|
((lpdm->dmFields & DM_PELSWIDTH) &&
|
|
(pdm->dmPelsWidth != lpdm->dmPelsWidth))
|
|
|
|
||
|
|
|
|
((lpdm->dmFields & DM_PELSHEIGHT) &&
|
|
(pdm->dmPelsHeight != lpdm->dmPelsHeight))
|
|
|
|
||
|
|
|
|
((lpdm->dmFields & DM_DISPLAYFREQUENCY) &&
|
|
(pdm->dmDisplayFrequency != lpdm->dmDisplayFrequency))
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!_IsModeVisible(i))
|
|
{
|
|
if (bForceVisible &&
|
|
((((_apdm + i)->dwFlags) & MODE_INVALID) == 0) &&
|
|
_bIsPruningOn &&
|
|
((((_apdm + i)->dwFlags) & MODE_RAW) == MODE_RAW))
|
|
{
|
|
(_apdm + i)->dwFlags &= ~MODE_RAW;
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
_SetCurrentValues(pdm);
|
|
|
|
TraceMsg(TF_DISPLAYSETTINGS, "_ExactMatch -- return TRUE");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
TraceMsg(TF_DISPLAYSETTINGS, "_ExactMatch -- return FALSE");
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// JoelGros defined a feature where we prefer to give the user
|
|
// a color depth of at least 32-bit, or as close to that as the
|
|
// display supports. Bryan Starbuck (BryanSt) 3/9/2000
|
|
#define MAX_PREFERED_COLOR_DEPTH 32
|
|
|
|
void CDisplaySettings::_BestMatch(LPPOINT Res, int Color, IN BOOL fAutoSetColorDepth)
|
|
{
|
|
// -1 means match loosely, based on current _xxx value
|
|
LPDEVMODE pdm;
|
|
LPDEVMODE pdmMatch = NULL;
|
|
ULONG i;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
// Take care of exact matches
|
|
if ((Color != -1) &&
|
|
(Color != (int)pdm->dmBitsPerPel))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ((Res != NULL) &&
|
|
(Res->x != -1) &&
|
|
( (Res->x != (int)pdm->dmPelsWidth) ||
|
|
(Res->y != (int)pdm->dmPelsHeight)) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Find Best Match
|
|
if (pdmMatch == NULL)
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
|
|
// Find best Color.
|
|
if (Color == -1) // Do they want best color matching?
|
|
{
|
|
if (fAutoSetColorDepth)
|
|
{
|
|
// This will use the "auto-set a good color depth" feature.
|
|
|
|
// The best match color depth will not equal the current color depth if
|
|
// we are going to need to work closer and closer to our desired color depth.
|
|
// (We may never reach it because the user may just have increased the resolution
|
|
// so the current color depth isn't supported)
|
|
|
|
// We prefer keep increasing the color depth to at least the current color depth.
|
|
// That may not be possible if that depth isn't supported at this resolution.
|
|
// We also would like to keep increasing it until we hit MAX_PREFERED_COLOR_DEPTH
|
|
// because colors of at least that deep benefit users.
|
|
|
|
// Do we need to decrease the color depth? Yes if
|
|
if (((int)pdmMatch->dmBitsPerPel > _CURCOLOR) && // the match is more than the current, and
|
|
((int)pdmMatch->dmBitsPerPel > MAX_PREFERED_COLOR_DEPTH)) // the match is more than the prefered max
|
|
{
|
|
// We will want to decrease it if this entry is smaller than our match.
|
|
if ((int)pdm->dmBitsPerPel < (int)pdmMatch->dmBitsPerPel)
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We want to increase it if:
|
|
if (((int)pdm->dmBitsPerPel > (int)pdmMatch->dmBitsPerPel) && // this entry is larger than our match, and
|
|
((int)pdm->dmBitsPerPel <= max(_CURCOLOR, MAX_PREFERED_COLOR_DEPTH))) // this doesn't take us over our prefered max or current depth (which ever is higher).
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This falls back to the old behavior.
|
|
if ((int)pdmMatch->dmBitsPerPel > _CURCOLOR)
|
|
{
|
|
if ((int)pdm->dmBitsPerPel < (int)pdmMatch->dmBitsPerPel)
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (((int)pdm->dmBitsPerPel > (int)pdmMatch->dmBitsPerPel) &&
|
|
((int)pdm->dmBitsPerPel <= _CURCOLOR))
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find best Resolution.
|
|
if (((Res == NULL) || (Res->x == -1)) &&
|
|
(((int)pdmMatch->dmPelsWidth != _CURXRES) ||
|
|
((int)pdmMatch->dmPelsHeight != _CURYRES)))
|
|
{
|
|
if (((int)pdmMatch->dmPelsWidth > _CURXRES) ||
|
|
(((int)pdmMatch->dmPelsWidth == _CURXRES) &&
|
|
((int)pdmMatch->dmPelsHeight > _CURYRES)))
|
|
{
|
|
if (((int)pdm->dmPelsWidth < (int)pdmMatch->dmPelsWidth) ||
|
|
(((int)pdm->dmPelsWidth == (int)pdmMatch->dmPelsWidth) &&
|
|
((int)pdm->dmPelsHeight < (int)pdmMatch->dmPelsHeight)))
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (((int)pdm->dmPelsWidth > (int)pdmMatch->dmPelsWidth) ||
|
|
(((int)pdm->dmPelsWidth == (int)pdmMatch->dmPelsWidth) &&
|
|
((int)pdm->dmPelsHeight > (int)pdmMatch->dmPelsHeight)))
|
|
{
|
|
if (((int)pdm->dmPelsWidth <= _CURXRES) ||
|
|
(((int)pdm->dmPelsWidth == _CURXRES) &&
|
|
((int)pdm->dmPelsHeight <= _CURYRES)))
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find best Frequency.
|
|
if (((int)pdmMatch->dmDisplayFrequency != _CURFREQ) &&
|
|
(!((Res == NULL) &&
|
|
((int)pdmMatch->dmPelsWidth == _CURXRES) &&
|
|
((int)pdmMatch->dmPelsHeight == _CURYRES) &&
|
|
(((int)pdm->dmPelsWidth != _CURXRES) ||
|
|
((int)pdm->dmPelsHeight != _CURYRES)))) &&
|
|
(!((Color == -1) &&
|
|
((int)pdmMatch->dmBitsPerPel == _CURCOLOR) &&
|
|
((int)pdm->dmBitsPerPel != _CURCOLOR))))
|
|
{
|
|
if ((int)pdmMatch->dmDisplayFrequency > _CURFREQ)
|
|
{
|
|
if ((int)pdm->dmDisplayFrequency < (int)pdmMatch->dmDisplayFrequency)
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (((int)pdm->dmDisplayFrequency > (int)pdmMatch->dmDisplayFrequency) &&
|
|
((int)pdm->dmDisplayFrequency <= _CURFREQ))
|
|
{
|
|
pdmMatch = pdm;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_SetCurrentValues(pdmMatch);
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::GetMonitorName(LPTSTR pszName, DWORD cchSize)
|
|
{
|
|
DISPLAY_DEVICE ddTmp;
|
|
DWORD cAttachedMonitors = 0, nMonitor = 0;
|
|
|
|
ZeroMemory(&ddTmp, sizeof(ddTmp));
|
|
ddTmp.cb = sizeof(DISPLAY_DEVICE);
|
|
|
|
while (EnumDisplayDevices(_pDisplayDevice->DeviceName, nMonitor, &ddTmp, 0))
|
|
{
|
|
if (ddTmp.StateFlags & DISPLAY_DEVICE_ATTACHED)
|
|
{
|
|
++cAttachedMonitors;
|
|
if (cAttachedMonitors > 1)
|
|
break;
|
|
|
|
// Single monitor
|
|
StrCpyN(pszName, (LPTSTR)ddTmp.DeviceString, cchSize);
|
|
}
|
|
|
|
++nMonitor;
|
|
|
|
ZeroMemory(&ddTmp, sizeof(ddTmp));
|
|
ddTmp.cb = sizeof(DISPLAY_DEVICE);
|
|
}
|
|
|
|
if (cAttachedMonitors == 0)
|
|
{
|
|
// No monitors
|
|
LoadString(HINST_THISDLL, IDS_UNKNOWNMONITOR, pszName, cchSize);
|
|
}
|
|
else if (cAttachedMonitors > 1)
|
|
{
|
|
// Multiple monitors
|
|
LoadString(HINST_THISDLL, IDS_MULTIPLEMONITORS, pszName, cchSize);
|
|
}
|
|
|
|
return (cAttachedMonitors != 0);
|
|
}
|
|
|
|
BOOL CDisplaySettings::GetMonitorDevice(LPTSTR pszDevice)
|
|
{
|
|
DISPLAY_DEVICE ddTmp;
|
|
|
|
ZeroMemory(&ddTmp, sizeof(ddTmp));
|
|
ddTmp.cb = sizeof(DISPLAY_DEVICE);
|
|
|
|
if (EnumDisplayDevices(_pDisplayDevice->DeviceName, 0, &ddTmp, 0))
|
|
{
|
|
lstrcpy(pszDevice, (LPTSTR)ddTmp.DeviceName);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::GetData(FORMATETC *pfmtetc, STGMEDIUM *pstgmed)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(this);
|
|
ASSERT(pfmtetc);
|
|
ASSERT(pstgmed);
|
|
|
|
// Ignore pfmtetc.ptd. All supported data formats are device-independent.
|
|
|
|
ZeroMemory(pstgmed, SIZEOF(*pstgmed));
|
|
|
|
if ((hr = QueryGetData(pfmtetc)) == S_OK)
|
|
{
|
|
LPTSTR pszOut = NULL;
|
|
TCHAR szMonitorName[130];
|
|
TCHAR szMonitorDevice[40];
|
|
|
|
if (pfmtetc->cfFormat == g_cfExtensionInterface)
|
|
{
|
|
//
|
|
// Get the array of information back to the device
|
|
//
|
|
// Allocate a buffer large enough to store all of the information
|
|
//
|
|
|
|
PDESK_EXTENSION_INTERFACE pInterface;
|
|
|
|
pInterface = (PDESK_EXTENSION_INTERFACE)
|
|
GlobalAlloc(GPTR, sizeof(DESK_EXTENSION_INTERFACE));
|
|
|
|
if (pInterface)
|
|
{
|
|
CRegistrySettings * RegSettings = new CRegistrySettings(_pDisplayDevice->DeviceKey);
|
|
|
|
if (RegSettings)
|
|
{
|
|
pInterface->cbSize = sizeof(DESK_EXTENSION_INTERFACE);
|
|
pInterface->pContext = this;
|
|
|
|
pInterface->lpfnEnumAllModes = CDisplaySettings::_lpfnEnumAllModes;
|
|
pInterface->lpfnSetSelectedMode = CDisplaySettings::_lpfnSetSelectedMode;
|
|
pInterface->lpfnGetSelectedMode = CDisplaySettings::_lpfnGetSelectedMode;
|
|
pInterface->lpfnSetPruningMode = CDisplaySettings::_lpfnSetPruningMode;
|
|
pInterface->lpfnGetPruningMode = CDisplaySettings::_lpfnGetPruningMode;
|
|
|
|
RegSettings->GetHardwareInformation(&pInterface->Info);
|
|
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = pInterface;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
|
|
hr = S_OK;
|
|
|
|
delete RegSettings;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfMonitorDeviceID)
|
|
{
|
|
//
|
|
//! This code is broken. It must be removed.
|
|
//
|
|
|
|
/*
|
|
DISPLAY_DEVICE ddTmp;
|
|
BOOL fKnownMonitor;
|
|
|
|
ZeroMemory(&ddTmp, sizeof(ddTmp));
|
|
ddTmp.cb = sizeof(DISPLAY_DEVICE);
|
|
|
|
fKnownMonitor = EnumDisplayDevices(_pDisplayDevice->DeviceName, 0, &ddTmp, 0);
|
|
hr = GetDevInstID((LPTSTR)(fKnownMonitor ? ddTmp.DeviceKey : TEXT("")), pstgmed);
|
|
*/
|
|
|
|
hr = E_UNEXPECTED;
|
|
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfDisplayStateFlags)
|
|
{
|
|
DWORD* pdwStateFlags = (DWORD*)GlobalAlloc(GPTR, sizeof(DWORD));
|
|
if (pdwStateFlags)
|
|
{
|
|
*pdwStateFlags = _pDisplayDevice->StateFlags;
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = pdwStateFlags;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfDisplayPruningMode)
|
|
{
|
|
BYTE* pPruningMode = (BYTE*)GlobalAlloc(GPTR, sizeof(BYTE));
|
|
if (pPruningMode)
|
|
{
|
|
*pPruningMode = (BYTE)(_bCanBePruned && _bIsPruningOn ? 1 : 0);
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = pPruningMode;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfDisplayDeviceID)
|
|
{
|
|
{
|
|
CRegistrySettings *pRegSettings = new CRegistrySettings(_pDisplayDevice->DeviceKey);
|
|
if (pRegSettings)
|
|
{
|
|
pszOut = pRegSettings->GetDeviceInstanceId();
|
|
hr = CopyDataToStorage(pstgmed, pszOut);
|
|
delete pRegSettings;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (pfmtetc->cfFormat == g_cfMonitorName)
|
|
{
|
|
GetMonitorName(szMonitorName, ARRAYSIZE(szMonitorName));
|
|
pszOut = szMonitorName;
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfMonitorDevice)
|
|
{
|
|
GetMonitorDevice(szMonitorDevice);
|
|
pszOut = szMonitorDevice;
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfDisplayDevice)
|
|
{
|
|
pszOut = (LPTSTR)_pDisplayDevice->DeviceName;
|
|
}
|
|
else if (pfmtetc->cfFormat == g_cfDisplayDeviceKey)
|
|
{
|
|
pszOut = (LPTSTR)_pDisplayDevice->DeviceKey;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(pfmtetc->cfFormat == g_cfDisplayName);
|
|
|
|
pszOut = (LPTSTR)_pDisplayDevice->DeviceString;
|
|
}
|
|
|
|
hr = CopyDataToStorage(pstgmed, pszOut);
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::CopyDataToStorage(STGMEDIUM *pstgmed, LPTSTR pszOut)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
int cch;
|
|
|
|
if (NULL != pszOut)
|
|
{
|
|
cch = lstrlen(pszOut) + 1;
|
|
|
|
LPWSTR pwszDevice = (LPWSTR)GlobalAlloc(GPTR, cch * SIZEOF(WCHAR));
|
|
if (pwszDevice)
|
|
{
|
|
//
|
|
// We always return UNICODE string
|
|
//
|
|
|
|
#ifdef UNICODE
|
|
lstrcpy(pwszDevice, pszOut);
|
|
#else
|
|
int cchConverted = MultiByteToWideChar(CP_ACP, 0, pszOut , -1, pwszDevice, cch);
|
|
ASSERT(cchConverted == cch);
|
|
#endif
|
|
pstgmed->tymed = TYMED_HGLOBAL;
|
|
pstgmed->hGlobal = pwszDevice;
|
|
pstgmed->pUnkForRelease = NULL;
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDisplaySettings::GetDataHere(FORMATETC *pfmtetc, STGMEDIUM *pstgpmed)
|
|
{
|
|
ZeroMemory(pfmtetc, SIZEOF(pfmtetc));
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//
|
|
// Check that all the parameters to the interface are appropriately
|
|
//
|
|
|
|
STDMETHODIMP CDisplaySettings::QueryGetData(FORMATETC *pfmtetc)
|
|
{
|
|
CLIPFORMAT cfFormat;
|
|
|
|
if (pfmtetc->dwAspect != DVASPECT_CONTENT)
|
|
{
|
|
return DV_E_DVASPECT;
|
|
}
|
|
|
|
if ((pfmtetc->tymed & TYMED_HGLOBAL) == 0)
|
|
{
|
|
return DV_E_TYMED;
|
|
}
|
|
|
|
cfFormat = pfmtetc->cfFormat;
|
|
|
|
if ((cfFormat != g_cfDisplayDevice) &&
|
|
(cfFormat != g_cfDisplayName) &&
|
|
(cfFormat != g_cfDisplayDeviceID) &&
|
|
(cfFormat != g_cfMonitorDevice) &&
|
|
(cfFormat != g_cfMonitorName) &&
|
|
(cfFormat != g_cfMonitorDeviceID) &&
|
|
(cfFormat != g_cfExtensionInterface) &&
|
|
(cfFormat != g_cfDisplayDeviceKey) &&
|
|
(cfFormat != g_cfDisplayStateFlags) &&
|
|
(cfFormat != g_cfDisplayPruningMode))
|
|
{
|
|
return DV_E_FORMATETC;
|
|
}
|
|
|
|
if (pfmtetc->lindex != -1)
|
|
{
|
|
return DV_E_LINDEX;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::GetCanonicalFormatEtc(FORMATETC *pfmtetcIn, FORMATETC *pfmtetcOut)
|
|
{
|
|
HRESULT hr;
|
|
ASSERT(pfmtetcIn);
|
|
ASSERT(pfmtetcOut);
|
|
|
|
hr = QueryGetData(pfmtetcIn);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
*pfmtetcOut = *pfmtetcIn;
|
|
|
|
if (pfmtetcIn->ptd == NULL)
|
|
hr = DATA_S_SAMEFORMATETC;
|
|
else
|
|
{
|
|
pfmtetcIn->ptd = NULL;
|
|
ASSERT(hr == S_OK);
|
|
}
|
|
}
|
|
else
|
|
ZeroMemory(pfmtetcOut, SIZEOF(*pfmtetcOut));
|
|
return(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP CDisplaySettings::SetData(FORMATETC *pfmtetc, STGMEDIUM *pstgmed, BOOL bRelease)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::EnumFormatEtc(DWORD dwDirFlags, IEnumFORMATETC ** ppiefe)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(ppiefe);
|
|
*ppiefe = NULL;
|
|
|
|
if (dwDirFlags == DATADIR_GET)
|
|
{
|
|
FORMATETC rgfmtetc[] =
|
|
{
|
|
{ (CLIPFORMAT)g_cfDisplayDevice, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfDisplayName, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfMonitorDevice, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfMonitorName, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfExtensionInterface, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfDisplayDeviceID, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfMonitorDeviceID, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfDisplayDeviceKey, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfDisplayStateFlags, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
{ (CLIPFORMAT)g_cfDisplayPruningMode, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL },
|
|
};
|
|
|
|
hr = SHCreateStdEnumFmtEtc(ARRAYSIZE(rgfmtetc), rgfmtetc, ppiefe);
|
|
}
|
|
else
|
|
hr = E_NOTIMPL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::DAdvise(FORMATETC *pfmtetc, DWORD dwAdviseFlags, IAdviseSink * piadvsink, DWORD * pdwConnection)
|
|
{
|
|
ASSERT(pfmtetc);
|
|
ASSERT(pdwConnection);
|
|
|
|
*pdwConnection = 0;
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::DUnadvise(DWORD dwConnection)
|
|
{
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
STDMETHODIMP CDisplaySettings::EnumDAdvise(IEnumSTATDATA ** ppiesd)
|
|
{
|
|
ASSERT(ppiesd);
|
|
*ppiesd = NULL;
|
|
return OLE_E_ADVISENOTSUPPORTED;
|
|
}
|
|
|
|
|
|
void CDisplaySettings::_InitClipboardFormats()
|
|
{
|
|
if (g_cfDisplayDevice == 0)
|
|
g_cfDisplayDevice = RegisterClipboardFormat(DESKCPLEXT_DISPLAY_DEVICE);
|
|
|
|
if (g_cfDisplayDeviceID == 0)
|
|
g_cfDisplayDeviceID = RegisterClipboardFormat(DESKCPLEXT_DISPLAY_ID);
|
|
|
|
if (g_cfDisplayName == 0)
|
|
g_cfDisplayName = RegisterClipboardFormat(DESKCPLEXT_DISPLAY_NAME);
|
|
|
|
if (g_cfMonitorDevice == 0)
|
|
g_cfMonitorDevice = RegisterClipboardFormat(DESKCPLEXT_MONITOR_DEVICE);
|
|
|
|
if (g_cfMonitorDeviceID == 0)
|
|
g_cfMonitorDeviceID = RegisterClipboardFormat(DESKCPLEXT_MONITOR_ID);
|
|
|
|
if (g_cfMonitorName == 0)
|
|
g_cfMonitorName = RegisterClipboardFormat(DESKCPLEXT_MONITOR_NAME);
|
|
|
|
if (g_cfExtensionInterface == 0)
|
|
g_cfExtensionInterface = RegisterClipboardFormat(DESKCPLEXT_INTERFACE);
|
|
|
|
if (g_cfDisplayDeviceKey == 0)
|
|
g_cfDisplayDeviceKey = RegisterClipboardFormat(DESKCPLEXT_DISPLAY_DEVICE_KEY);
|
|
|
|
if (g_cfDisplayStateFlags == 0)
|
|
g_cfDisplayStateFlags = RegisterClipboardFormat(DESKCPLEXT_DISPLAY_STATE_FLAGS);
|
|
|
|
if (g_cfDisplayPruningMode == 0)
|
|
g_cfDisplayPruningMode = RegisterClipboardFormat(DESKCPLEXT_PRUNING_MODE);
|
|
}
|
|
|
|
HRESULT CDisplaySettings::QueryInterface(REFIID riid, LPVOID * ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CDisplaySettings, IDataObject),
|
|
QITABENT(CDisplaySettings, IDisplaySettings),
|
|
{ 0 },
|
|
};
|
|
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
|
|
ULONG CDisplaySettings::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG CDisplaySettings::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(LPDEVMODEW)
|
|
CDisplaySettings::_lpfnEnumAllModes(
|
|
LPVOID pContext,
|
|
DWORD iMode)
|
|
{
|
|
DWORD cCount = 0;
|
|
DWORD i;
|
|
|
|
CDisplaySettings *pSettings = (CDisplaySettings *) pContext;
|
|
|
|
for (i = 0; pSettings->_apdm && (i < pSettings->_cpdm); i++)
|
|
{
|
|
// Don't show invalid modes or raw modes if pruning is on;
|
|
|
|
if(!_IsModeVisible(pSettings, i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (cCount == iMode)
|
|
{
|
|
return (pSettings->_apdm + i)->lpdm;
|
|
}
|
|
|
|
cCount++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL)
|
|
CDisplaySettings::_lpfnSetSelectedMode(
|
|
LPVOID pContext,
|
|
LPDEVMODEW lpdm)
|
|
{
|
|
CDisplaySettings *pSettings = (CDisplaySettings *) pContext;
|
|
|
|
return pSettings->_PerfectMatch(lpdm);
|
|
}
|
|
|
|
STDMETHODIMP_(LPDEVMODEW)
|
|
CDisplaySettings::_lpfnGetSelectedMode(
|
|
LPVOID pContext
|
|
)
|
|
{
|
|
CDisplaySettings *pSettings = (CDisplaySettings *) pContext;
|
|
|
|
return pSettings->_pCurDevmode;
|
|
}
|
|
|
|
STDMETHODIMP_(VOID)
|
|
CDisplaySettings::_lpfnSetPruningMode(
|
|
LPVOID pContext,
|
|
BOOL bIsPruningOn)
|
|
{
|
|
CDisplaySettings *pSettings = (CDisplaySettings *) pContext;
|
|
pSettings->SetPruningMode(bIsPruningOn);
|
|
}
|
|
|
|
STDMETHODIMP_(VOID)
|
|
CDisplaySettings::_lpfnGetPruningMode(
|
|
LPVOID pContext,
|
|
BOOL* pbCanBePruned,
|
|
BOOL* pbIsPruningReadOnly,
|
|
BOOL* pbIsPruningOn)
|
|
{
|
|
CDisplaySettings *pSettings = (CDisplaySettings *) pContext;
|
|
pSettings->GetPruningMode(pbCanBePruned,
|
|
pbIsPruningReadOnly,
|
|
pbIsPruningOn);
|
|
}
|
|
|
|
// If any attached device is at 640x480, we want to force small font
|
|
BOOL CDisplaySettings::IsSmallFontNecessary()
|
|
{
|
|
if (_fOrgAttached || _fCurAttached)
|
|
{
|
|
//
|
|
// Force Small fonts at 640x480
|
|
//
|
|
if (_CURXRES < 800 || _CURYRES < 600)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// Constructor for CDisplaySettings
|
|
//
|
|
// (gets called when ever a CDisplaySettings object is created)
|
|
//
|
|
|
|
CDisplaySettings::CDisplaySettings()
|
|
: _cRef(1)
|
|
, _cpdm(0)
|
|
, _apdm(0)
|
|
, _hPruningRegKey(NULL)
|
|
, _bCanBePruned(FALSE)
|
|
, _bIsPruningReadOnly(TRUE)
|
|
, _bIsPruningOn(FALSE)
|
|
, _pOrgDevmode(NULL)
|
|
, _pCurDevmode(NULL)
|
|
, _fOrgAttached(FALSE)
|
|
, _fCurAttached(FALSE)
|
|
, _bFilterOrientation(FALSE)
|
|
, _bFilterFixedOutput(FALSE)
|
|
{
|
|
SetRectEmpty(&_rcPreview);
|
|
}
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
CDisplaySettings::~CDisplaySettings() {
|
|
|
|
TraceMsg(TF_DISPLAYSETTINGS, "**** Destructing %s", _pDisplayDevice->DeviceName);
|
|
|
|
if (_apdm)
|
|
{
|
|
while(_cpdm--)
|
|
{
|
|
LocalFree((_apdm + _cpdm)->lpdm);
|
|
}
|
|
LocalFree(_apdm);
|
|
_apdm = NULL;
|
|
}
|
|
|
|
_cpdm = 0;
|
|
|
|
if(NULL != _hPruningRegKey)
|
|
RegCloseKey(_hPruningRegKey);
|
|
}
|
|
|
|
|
|
//
|
|
// _SetFilterOptions -- determine if display modes should be filtered
|
|
// by orientation and/or fixed output (centered/stretched)
|
|
//
|
|
|
|
void CDisplaySettings::_SetFilterOptions(LPCTSTR pszDeviceName, LPDEVMODEW pdevmode)
|
|
{
|
|
BOOL bCurrent = FALSE;
|
|
BOOL bRegistry = FALSE;
|
|
|
|
// See if we need to filter modes by orientation and/or stretched/centered
|
|
ZeroMemory(pdevmode, sizeof(DEVMODE));
|
|
pdevmode->dmSize = sizeof(DEVMODE);
|
|
|
|
bCurrent = EnumDisplaySettingsExWrap(pszDeviceName,
|
|
ENUM_CURRENT_SETTINGS,
|
|
pdevmode,
|
|
0);
|
|
if (!bCurrent)
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS, "_SetFilterOptions -- No Current Mode. Try to use registry settings.");
|
|
bRegistry = EnumDisplaySettingsExWrap(pszDeviceName,
|
|
ENUM_REGISTRY_SETTINGS,
|
|
pdevmode,
|
|
0);
|
|
}
|
|
|
|
if (bCurrent || bRegistry)
|
|
{
|
|
if (pdevmode->dmFields & DM_DISPLAYORIENTATION)
|
|
{
|
|
_bFilterOrientation = TRUE;
|
|
_dwOrientation = pdevmode->dmDisplayOrientation;
|
|
TraceMsg(TF_DUMP_CSETTINGS, "Filtering modes on orientation %d", _dwOrientation);
|
|
}
|
|
if (pdevmode->dmFields & DM_DISPLAYFIXEDOUTPUT)
|
|
{
|
|
_bFilterFixedOutput = TRUE;
|
|
_dwFixedOutput = pdevmode->dmDisplayFixedOutput;
|
|
TraceMsg(TF_DUMP_CSETTINGS, "Filtering modes on fixed output %d", _dwFixedOutput);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TraceMsg(TF_DUMP_CSETTINGS, "_SetFilterOptions -- No settings, forcing default");
|
|
_bFilterOrientation = TRUE;
|
|
_dwOrientation = DMDO_DEFAULT;
|
|
}
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS, "Filter mode settings for: %s", pszDeviceName);
|
|
TraceMsg(TF_DUMP_CSETTINGS, " _bFilterOrientation: %d, _dwOrientation: %d", _bFilterOrientation, _dwOrientation);
|
|
TraceMsg(TF_DUMP_CSETTINGS, " _bFilterFixedOutput: %d, _dwFixedOutput: %d", _bFilterFixedOutput, _dwFixedOutput);
|
|
}
|
|
|
|
|
|
//
|
|
// InitSettings -- Enumerate the settings, and build the mode list when
|
|
//
|
|
|
|
BOOL CDisplaySettings::InitSettings(LPDISPLAY_DEVICE pDisplay)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
LPDEVMODE pdevmode = (LPDEVMODE) LocalAlloc(LPTR, (sizeof(DEVMODE) + 0xFFFF));
|
|
|
|
if (pdevmode)
|
|
{
|
|
ULONG i = 0;
|
|
BOOL bCurrent = FALSE;
|
|
BOOL bRegistry = FALSE;
|
|
BOOL bExact = FALSE;
|
|
|
|
fReturn = TRUE;
|
|
|
|
// Set the cached values for modes.
|
|
MAKEXYRES(&_ptCurPos, 0, 0);
|
|
_fCurAttached = FALSE;
|
|
_pCurDevmode = NULL;
|
|
|
|
// Save the display name
|
|
ASSERT(pDisplay);
|
|
|
|
_pDisplayDevice = pDisplay;
|
|
|
|
TraceMsg(TF_GENERAL, "Initializing CDisplaySettings for %s", _pDisplayDevice->DeviceName);
|
|
|
|
// Pruning Mode
|
|
_bCanBePruned = ((_pDisplayDevice->StateFlags & DISPLAY_DEVICE_MODESPRUNED) != 0);
|
|
_bIsPruningReadOnly = TRUE;
|
|
_bIsPruningOn = FALSE;
|
|
if (_bCanBePruned)
|
|
{
|
|
_bIsPruningOn = TRUE; // if can be pruned, by default pruning is on
|
|
GetDeviceRegKey(_pDisplayDevice->DeviceKey, &_hPruningRegKey, &_bIsPruningReadOnly);
|
|
if (_hPruningRegKey)
|
|
{
|
|
DWORD dwIsPruningOn = 1;
|
|
DWORD cb = sizeof(dwIsPruningOn);
|
|
RegQueryValueEx(_hPruningRegKey,
|
|
SZ_PRUNNING_MODE,
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)&dwIsPruningOn,
|
|
&cb);
|
|
_bIsPruningOn = (dwIsPruningOn != 0);
|
|
}
|
|
}
|
|
|
|
// See if we need to filter modes by orientation and/or stretched/centered
|
|
_SetFilterOptions(_pDisplayDevice->DeviceName, pdevmode);
|
|
|
|
// Lets generate a list with all the possible modes.
|
|
ZeroMemory(pdevmode, sizeof(DEVMODE));
|
|
pdevmode->dmSize = sizeof(DEVMODE);
|
|
|
|
// Enum the raw list of modes
|
|
while (EnumDisplaySettingsExWrap(_pDisplayDevice->DeviceName, i++, pdevmode, EDS_RAWMODE))
|
|
{
|
|
WORD dmsize = pdevmode->dmSize + pdevmode->dmDriverExtra;
|
|
LPDEVMODE lpdm = (LPDEVMODE) LocalAlloc(LPTR, dmsize);
|
|
|
|
if (lpdm)
|
|
{
|
|
CopyMemory(lpdm, pdevmode, dmsize);
|
|
_AddDevMode(lpdm);
|
|
}
|
|
|
|
pdevmode->dmDriverExtra = 0;
|
|
}
|
|
|
|
// Filter the list of modes
|
|
|
|
_FilterModes();
|
|
if(_bCanBePruned)
|
|
{
|
|
// Enum pruned list of modes
|
|
i = 0;
|
|
_bCanBePruned = FALSE;
|
|
|
|
while (EnumDisplaySettingsExWrap(_pDisplayDevice->DeviceName, i++, pdevmode, 0))
|
|
{
|
|
if(_MarkMode(pdevmode))
|
|
_bCanBePruned = TRUE; // at least one non-raw mode
|
|
pdevmode->dmDriverExtra = 0;
|
|
}
|
|
|
|
if(!_bCanBePruned)
|
|
{
|
|
_bIsPruningReadOnly = TRUE;
|
|
_bIsPruningOn = FALSE;
|
|
}
|
|
}
|
|
|
|
// Debug
|
|
_Dump_CDisplaySettings(TRUE);
|
|
|
|
// Get the current mode
|
|
ZeroMemory(pdevmode,sizeof(DEVMODE));
|
|
pdevmode->dmSize = sizeof(DEVMODE);
|
|
|
|
bCurrent = EnumDisplaySettingsExWrap(_pDisplayDevice->DeviceName,
|
|
ENUM_CURRENT_SETTINGS,
|
|
pdevmode,
|
|
0);
|
|
|
|
if (!bCurrent)
|
|
{
|
|
TraceMsg(TF_DISPLAYSETTINGS, "InitSettings -- No Current Mode. Try to use registry settings.");
|
|
|
|
ZeroMemory(pdevmode,sizeof(DEVMODE));
|
|
pdevmode->dmSize = sizeof(DEVMODE);
|
|
|
|
bRegistry = EnumDisplaySettingsExWrap(_pDisplayDevice->DeviceName,
|
|
ENUM_REGISTRY_SETTINGS,
|
|
pdevmode,
|
|
0);
|
|
}
|
|
|
|
// Set the default values based on registry or current settings.
|
|
if (bCurrent || bRegistry)
|
|
{
|
|
// Check if this DEVMODE is in the list
|
|
TraceMsg(TF_FUNC, "Devmode for Exact Matching");
|
|
_Dump_CDevmode(pdevmode);
|
|
TraceMsg(TF_FUNC, "");
|
|
|
|
// If the current mode is not in the list of modes supported by
|
|
// the monitor, we want to show it anyway.
|
|
//
|
|
// Consider the following scenario: the user sets the display
|
|
// to 1024x768 and after that it goes to DevManager and selects
|
|
// a monitor type that can not do that mode. When the user
|
|
// reopens the applet the current mode will be pruned out.
|
|
// In such a case we want the current mode to be visible.
|
|
bExact = _ExactMatch(pdevmode, TRUE);
|
|
|
|
if (!bExact && bCurrent)
|
|
{
|
|
// If the current mode is not in the list, we may have a problem.
|
|
}
|
|
|
|
// Is attached?
|
|
if(bCurrent)
|
|
{
|
|
_fOrgAttached = _fCurAttached = ((pdevmode->dmFields & DM_POSITION) ? 1 : 0);
|
|
}
|
|
|
|
// Set the original values
|
|
if (bExact == TRUE)
|
|
{
|
|
MAKEXYRES(&_ptCurPos, pdevmode->dmPosition.x, pdevmode->dmPosition.y);
|
|
ConfirmChangeSettings();
|
|
}
|
|
}
|
|
|
|
// If we have no modes, return FALSE.
|
|
if (_cpdm == 0)
|
|
{
|
|
FmtMessageBox(ghwndPropSheet,
|
|
MB_ICONEXCLAMATION,
|
|
MSG_CONFIGURATION_PROBLEM,
|
|
MSG_INVALID_OLD_DISPLAY_DRIVER);
|
|
|
|
fReturn = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// If there were no current values, set some now
|
|
// But don't confirm them ...
|
|
if (bExact == FALSE)
|
|
{
|
|
TraceMsg(TF_DISPLAYSETTINGS, "InitSettings -- No Current OR Registry Mode");
|
|
|
|
i = 0;
|
|
// Try setting any mode as the current.
|
|
while (_apdm && (_PerfectMatch((_apdm + i++)->lpdm) == FALSE))
|
|
{
|
|
if (i > _cpdm)
|
|
{
|
|
FmtMessageBox(ghwndPropSheet,
|
|
MB_ICONEXCLAMATION,
|
|
MSG_CONFIGURATION_PROBLEM,
|
|
MSG_INVALID_OLD_DISPLAY_DRIVER);
|
|
|
|
fReturn = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fReturn && _fCurAttached)
|
|
{
|
|
MAKEXYRES(&_ptCurPos, _pCurDevmode->dmPosition.x, _pCurDevmode->dmPosition.y);
|
|
}
|
|
}
|
|
|
|
if (fReturn)
|
|
{
|
|
// Export our interfaces for extended properly pages.
|
|
_InitClipboardFormats();
|
|
|
|
// Final debug output
|
|
TraceMsg(TF_DUMP_CSETTINGS," InitSettings successful - current values :");
|
|
_Dump_CDisplaySettings(FALSE);
|
|
}
|
|
}
|
|
|
|
LocalFree(pdevmode);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// SaveSettings
|
|
//
|
|
// Writes the new display parameters to the proper place in the
|
|
// registry.
|
|
int CDisplaySettings::SaveSettings(DWORD dwSet)
|
|
{
|
|
int iResult = 0;
|
|
|
|
if (_pCurDevmode)
|
|
{
|
|
// Make a copy of the current devmode
|
|
ULONG dmSize = _pCurDevmode->dmSize + _pCurDevmode->dmDriverExtra;
|
|
PDEVMODE pdevmode = (LPDEVMODE) LocalAlloc(LPTR, dmSize);
|
|
|
|
if (pdevmode)
|
|
{
|
|
CopyMemory(pdevmode, _pCurDevmode, dmSize);
|
|
|
|
// Save all of the new values out to the registry
|
|
// Resolution color bits and frequency
|
|
//
|
|
// We always have to set DM_POSITION when calling the API.
|
|
// In order to remove a device from the desktop, what actually needs
|
|
// to be done is provide an empty rectangle.
|
|
pdevmode->dmFields |= DM_POSITION;
|
|
|
|
if (!_fCurAttached)
|
|
{
|
|
pdevmode->dmPelsWidth = 0;
|
|
pdevmode->dmPelsHeight = 0;
|
|
}
|
|
else
|
|
{
|
|
pdevmode->dmPosition.x = _ptCurPos.x;
|
|
pdevmode->dmPosition.y = _ptCurPos.y;
|
|
}
|
|
|
|
TraceMsg(TF_GENERAL, "SaveSettings:: Display: %s", _pDisplayDevice->DeviceName);
|
|
_Dump_CDevmode(pdevmode);
|
|
|
|
// These calls have NORESET flag set so that it only goes to
|
|
// change the registry settings, it does not refresh the display
|
|
|
|
// If EnumDisplaySettings was called with EDS_RAWMODE, we need CDS_RAWMODE below.
|
|
// Otherwise, it's harmless.
|
|
iResult = ChangeDisplaySettingsEx(_pDisplayDevice->DeviceName,
|
|
pdevmode,
|
|
NULL,
|
|
CDS_RAWMODE | dwSet | ( _fPrimary ? CDS_SET_PRIMARY : 0),
|
|
NULL);
|
|
|
|
if (iResult < 0)
|
|
{
|
|
TraceMsg(TF_DISPLAYSETTINGS, "**** SaveSettings:: ChangeDisplaySettingsEx not successful on %s", _pDisplayDevice->DeviceName);
|
|
}
|
|
|
|
LocalFree(pdevmode);
|
|
}
|
|
}
|
|
|
|
return iResult;
|
|
}
|
|
|
|
|
|
HRESULT CDisplaySettings::GetDevInstID(LPTSTR lpszDeviceKey, STGMEDIUM *pstgmed)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
return hr;
|
|
}
|
|
|
|
|
|
void ConvertStrToToken(LPTSTR pszString, DWORD cchSize)
|
|
{
|
|
while (pszString[0])
|
|
{
|
|
if (TEXT('\\') == pszString[0])
|
|
{
|
|
pszString[0] = TEXT(':');
|
|
}
|
|
|
|
pszString++;
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT CDisplaySettings::_GetRegKey(LPDEVMODE pDevmode, int * pnIndex, LPTSTR pszRegKey, DWORD cchSize,
|
|
LPTSTR pszRegValue, DWORD cchValueSize)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DISPLAY_DEVICE ddMonitor = {0};
|
|
|
|
ddMonitor.cb = sizeof(ddMonitor);
|
|
if (pDevmode && pDevmode->dmDeviceName && _pDisplayDevice &&
|
|
EnumDisplayDevices(_pDisplayDevice->DeviceName, *pnIndex, &ddMonitor, 0))
|
|
{
|
|
TCHAR szMonitor[MAX_PATH];
|
|
TCHAR szVideoAdapter[MAX_PATH];
|
|
|
|
StrCpyN(szMonitor, ddMonitor.DeviceID, ARRAYSIZE(szMonitor));
|
|
StrCpyN(szVideoAdapter, _pDisplayDevice->DeviceID, ARRAYSIZE(szVideoAdapter));
|
|
ConvertStrToToken(szMonitor, ARRAYSIZE(szMonitor));
|
|
ConvertStrToToken(szVideoAdapter, ARRAYSIZE(szVideoAdapter));
|
|
|
|
wnsprintf(pszRegKey, cchSize, TEXT("%s\\%s\\%s,%d\\%dx%d x %dHz"), SZ_CP_SETTINGS_VIDEO,
|
|
szVideoAdapter, szMonitor, *pnIndex, pDevmode->dmPelsWidth, pDevmode->dmPelsHeight,
|
|
pDevmode->dmDisplayFrequency);
|
|
|
|
wnsprintf(pszRegValue, cchValueSize, TEXT("%d bpp"), pDevmode->dmBitsPerPel);
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::ConfirmChangeSettings()
|
|
{
|
|
// Succeeded, so, reset the original settings
|
|
_ptOrgPos = _ptCurPos;
|
|
_pOrgDevmode = _pCurDevmode;
|
|
_fOrgAttached = _fCurAttached;
|
|
|
|
// Now write the results to the registry so we know this is safe and can use it later.
|
|
TCHAR szRegKey[2*MAX_PATH];
|
|
TCHAR szRegValue[20];
|
|
int nIndex = 0;
|
|
|
|
while (SUCCEEDED(_GetRegKey(_pCurDevmode, &nIndex, szRegKey, ARRAYSIZE(szRegKey), szRegValue, ARRAYSIZE(szRegValue))))
|
|
{
|
|
HKEY hKey;
|
|
|
|
if (SUCCEEDED(HrRegCreateKeyEx(HKEY_LOCAL_MACHINE, szRegKey, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL)))
|
|
{
|
|
RegCloseKey(hKey);
|
|
}
|
|
HrRegSetDWORD(HKEY_LOCAL_MACHINE, szRegKey, szRegValue, 1);
|
|
nIndex++;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::IsKnownSafe(void)
|
|
{
|
|
TCHAR szRegKey[2*MAX_PATH];
|
|
TCHAR szRegValue[20];
|
|
BOOL fIsSafe = FALSE;
|
|
int nIndex = 0;
|
|
|
|
while (SUCCEEDED(_GetRegKey(_pCurDevmode, &nIndex, szRegKey, ARRAYSIZE(szRegKey), szRegValue, ARRAYSIZE(szRegValue))))
|
|
{
|
|
fIsSafe = HrRegGetDWORD(HKEY_LOCAL_MACHINE, szRegKey, szRegValue, 0);
|
|
if (!fIsSafe)
|
|
{
|
|
break;
|
|
}
|
|
|
|
nIndex++;
|
|
}
|
|
|
|
// TODO: In blackcomb, just return TRUE as long as long as we were able to prune the list. If we could prune the list,
|
|
// then the driver dudes where able to get PnP IDs from the video cards (adapters) and monitors, so the list of
|
|
// supported modes should be accurate. If not, the drivers guys (ErickS) will fix. -BryanSt
|
|
return fIsSafe;
|
|
}
|
|
|
|
|
|
int CDisplaySettings::RestoreSettings()
|
|
{
|
|
//
|
|
// Test failed, so restore the old settings, only restore the color and resolution
|
|
// information, and do restore the monitor position and its attached status
|
|
// Although this function is currently only called when restoring resolution
|
|
// the user could have changed position, then resolution and then clicked 'Apply,'
|
|
// in which case we want to revert position as well.
|
|
//
|
|
|
|
int iResult = DISP_CHANGE_SUCCESSFUL;
|
|
PDEVMODE pdevmode;
|
|
|
|
//
|
|
// If this display was originally turned off, don't bother
|
|
//
|
|
|
|
if ((_pOrgDevmode != NULL) &&
|
|
//(_pOrgDevmode != _pCurDevmode))
|
|
((_pOrgDevmode != _pCurDevmode) || (_ptOrgPos.x != _ptCurPos.x) || (_ptOrgPos.y != _ptCurPos.y) ))
|
|
{
|
|
iResult = DISP_CHANGE_NOTUPDATED;
|
|
|
|
// Make a copy of the original devmode
|
|
ULONG dmSize = _pOrgDevmode->dmSize + _pOrgDevmode->dmDriverExtra;
|
|
pdevmode = (LPDEVMODE) LocalAlloc(LPTR, dmSize);
|
|
|
|
if (pdevmode)
|
|
{
|
|
CopyMemory(pdevmode, _pOrgDevmode, dmSize);
|
|
|
|
pdevmode->dmFields |= DM_POSITION;
|
|
pdevmode->dmPosition.x = _ptOrgPos.x;
|
|
pdevmode->dmPosition.y = _ptOrgPos.y;
|
|
|
|
if (!_fOrgAttached)
|
|
{
|
|
pdevmode->dmPelsWidth = 0;
|
|
pdevmode->dmPelsHeight = 0;
|
|
}
|
|
|
|
TraceMsg(TF_GENERAL, "RestoreSettings:: Display: %s", _pDisplayDevice->DeviceName);
|
|
_Dump_CDevmode(pdevmode);
|
|
|
|
// If EnumDisplaySettings was called with EDS_RAWMODE, we need CDS_RAWMODE below.
|
|
// Otherwise, it's harmless.
|
|
iResult = ChangeDisplaySettingsEx(_pDisplayDevice->DeviceName,
|
|
pdevmode,
|
|
NULL,
|
|
CDS_RAWMODE | CDS_UPDATEREGISTRY | CDS_NORESET | ( _fPrimary ? CDS_SET_PRIMARY : 0),
|
|
NULL);
|
|
if (iResult < 0 )
|
|
{
|
|
TraceMsg(TF_DISPLAYSETTINGS, "**** RestoreSettings:: ChangeDisplaySettingsEx not successful on %s", _pDisplayDevice->DeviceName);
|
|
ASSERT(FALSE);
|
|
LocalFree(pdevmode);
|
|
return iResult;
|
|
}
|
|
else
|
|
{
|
|
// Succeeded, so, reset the original settings
|
|
_ptCurPos = _ptOrgPos;
|
|
_pCurDevmode = _pOrgDevmode;
|
|
_fCurAttached = _fOrgAttached;
|
|
|
|
if(_bCanBePruned && !_bIsPruningReadOnly && _bIsPruningOn && _IsCurDevmodeRaw())
|
|
SetPruningMode(FALSE);
|
|
}
|
|
|
|
LocalFree(pdevmode);
|
|
}
|
|
}
|
|
|
|
return iResult;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL CDisplaySettings::_IsModeVisible(int i)
|
|
{
|
|
return _IsModeVisible(this, i);
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::_IsModeVisible(CDisplaySettings* pSettings, int i)
|
|
{
|
|
ASSERT(pSettings);
|
|
|
|
if (!pSettings->_apdm)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// (the mode is valid) AND
|
|
// ((pruning mode is off) OR (mode is not raw))
|
|
return ((!((pSettings->_apdm + i)->dwFlags & MODE_INVALID)) &&
|
|
((!pSettings->_bIsPruningOn) ||
|
|
(!((pSettings->_apdm + i)->dwFlags & MODE_RAW))
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::_IsModePreferred(int i)
|
|
{
|
|
LPDEVMODE pDevMode = ((PMODEARRAY)(_apdm + i))->lpdm;
|
|
|
|
if (_pCurDevmode == pDevMode)
|
|
return TRUE;
|
|
|
|
BOOL bLandscape = (pDevMode->dmPelsWidth >= pDevMode->dmPelsHeight);
|
|
|
|
TraceMsg(TF_DUMP_CSETTINGS, "_IsModePreferred: %d x %d - landscape mode: %d",
|
|
pDevMode->dmPelsWidth, pDevMode->dmPelsHeight, bLandscape);
|
|
|
|
// (the mode is valid) AND
|
|
// ((pruning mode is off) OR (mode is not raw))
|
|
return (pDevMode->dmBitsPerPel >= 15 &&
|
|
((bLandscape && pDevMode->dmPelsWidth >= 800 && pDevMode->dmPelsHeight >= 600) ||
|
|
(!bLandscape && pDevMode->dmPelsWidth >= 600 && pDevMode->dmPelsHeight >= 800)));
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::_MarkMode(LPDEVMODE lpdm)
|
|
{
|
|
LPDEVMODE pdm;
|
|
ULONG i;
|
|
BOOL bMark = FALSE;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if (!((_apdm + i)->dwFlags & MODE_INVALID))
|
|
{
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if (
|
|
((lpdm->dmFields & DM_BITSPERPEL) &&
|
|
(pdm->dmBitsPerPel == lpdm->dmBitsPerPel))
|
|
|
|
&&
|
|
|
|
((lpdm->dmFields & DM_PELSWIDTH) &&
|
|
(pdm->dmPelsWidth == lpdm->dmPelsWidth))
|
|
|
|
&&
|
|
|
|
((lpdm->dmFields & DM_PELSHEIGHT) &&
|
|
(pdm->dmPelsHeight == lpdm->dmPelsHeight))
|
|
|
|
&&
|
|
|
|
((lpdm->dmFields & DM_DISPLAYFREQUENCY) &&
|
|
(pdm->dmDisplayFrequency == lpdm->dmDisplayFrequency))
|
|
)
|
|
{
|
|
(_apdm + i)->dwFlags &= ~MODE_RAW;
|
|
bMark = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bMark;
|
|
}
|
|
|
|
|
|
BOOL CDisplaySettings::_IsCurDevmodeRaw()
|
|
{
|
|
LPDEVMODE pdm;
|
|
ULONG i;
|
|
BOOL bCurrentAndPruned = FALSE;
|
|
|
|
for (i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
if (!((_apdm + i)->dwFlags & MODE_INVALID) &&
|
|
((_apdm + i)->dwFlags & MODE_RAW))
|
|
{
|
|
pdm = (_apdm + i)->lpdm;
|
|
|
|
if (
|
|
((_pCurDevmode->dmFields & DM_BITSPERPEL) &&
|
|
(pdm->dmBitsPerPel == _pCurDevmode->dmBitsPerPel))
|
|
|
|
&&
|
|
|
|
((_pCurDevmode->dmFields & DM_PELSWIDTH) &&
|
|
(pdm->dmPelsWidth == _pCurDevmode->dmPelsWidth))
|
|
|
|
&&
|
|
|
|
((_pCurDevmode->dmFields & DM_PELSHEIGHT) &&
|
|
(pdm->dmPelsHeight == _pCurDevmode->dmPelsHeight))
|
|
|
|
&&
|
|
|
|
((_pCurDevmode->dmFields & DM_DISPLAYFREQUENCY) &&
|
|
(pdm->dmDisplayFrequency == _pCurDevmode->dmDisplayFrequency))
|
|
)
|
|
{
|
|
bCurrentAndPruned = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bCurrentAndPruned;
|
|
}
|
|
|
|
DISPLAY_DEVICE dd;
|
|
|
|
HRESULT CDisplaySettings::SetMonitor(DWORD dwMonitor)
|
|
{
|
|
ZeroMemory(&dd, sizeof(DISPLAY_DEVICE));
|
|
dd.cb = sizeof(DISPLAY_DEVICE);
|
|
|
|
DWORD dwMon = 0;
|
|
for (DWORD dwCount = 0; EnumDisplayDevices(NULL, dwCount, &dd, 0); dwCount++)
|
|
{
|
|
if (!(dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
|
|
{
|
|
if (dwMon == dwMonitor)
|
|
{
|
|
InitSettings(&dd);
|
|
_fPrimary = (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE);
|
|
return S_OK;
|
|
}
|
|
dwMon++;
|
|
}
|
|
}
|
|
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HRESULT CDisplaySettings::GetModeCount(DWORD* pdwCount, BOOL fOnlyPreferredModes)
|
|
{
|
|
DWORD cCount = 0;
|
|
|
|
for (DWORD i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
// Don't show invalid modes or raw modes if pruning is on;
|
|
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(fOnlyPreferredModes && (!_IsModePreferred(i)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
cCount++;
|
|
}
|
|
|
|
*pdwCount = cCount;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CDisplaySettings::GetMode(DWORD dwMode, BOOL fOnlyPreferredModes, DWORD* pdwWidth, DWORD* pdwHeight, DWORD* pdwColor)
|
|
{
|
|
DWORD cCount = 0;
|
|
|
|
for (DWORD i = 0; _apdm && (i < _cpdm); i++)
|
|
{
|
|
// Don't show invalid modes or raw modes if pruning is on;
|
|
|
|
if(!_IsModeVisible(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(fOnlyPreferredModes && (!_IsModePreferred(i)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (cCount == dwMode)
|
|
{
|
|
LPDEVMODE lpdm = (_apdm + i)->lpdm;
|
|
*pdwWidth = lpdm->dmPelsWidth;
|
|
*pdwHeight = lpdm->dmPelsHeight;
|
|
*pdwColor = lpdm->dmBitsPerPel;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
cCount++;
|
|
}
|
|
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
DEVMODE dm;
|
|
|
|
HRESULT CDisplaySettings::SetSelectedMode(HWND hwnd, DWORD dwWidth, DWORD dwHeight, DWORD dwColor, BOOL* pfApplied, DWORD dwFlags)
|
|
{
|
|
dm.dmBitsPerPel = dwColor;
|
|
dm.dmPelsWidth = dwWidth;
|
|
dm.dmPelsHeight = dwHeight;
|
|
dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
|
|
|
|
*pfApplied = FALSE;
|
|
|
|
POINT res = {dwWidth, dwHeight};
|
|
PLONGLONG freq = NULL;
|
|
int cFreq = GetFrequencyList(dwColor, &res, &freq);
|
|
if (cFreq)
|
|
{
|
|
dm.dmFields |= DM_DISPLAYFREQUENCY;
|
|
// Default to lowest frequency
|
|
dm.dmDisplayFrequency = (DWORD)freq[0];
|
|
|
|
// Try to find a good frequency
|
|
for (int i = cFreq - 1; i >= 0; i--)
|
|
{
|
|
if ((freq[i] >= 60) && (freq[i] <= 72))
|
|
{
|
|
dm.dmDisplayFrequency = (DWORD)freq[i];
|
|
}
|
|
}
|
|
}
|
|
LocalFree(freq);
|
|
|
|
ULONG dmSize = _pCurDevmode->dmSize + _pCurDevmode->dmDriverExtra;
|
|
PDEVMODE pOldDevMode = (LPDEVMODE) LocalAlloc(LPTR, dmSize);
|
|
|
|
if (pOldDevMode)
|
|
{
|
|
CopyMemory(pOldDevMode, _pCurDevmode, dmSize);
|
|
|
|
if (_ExactMatch(&dm, FALSE))
|
|
{
|
|
// Verify that the mode actually works
|
|
if (SaveSettings(CDS_TEST) == DISP_CHANGE_SUCCESSFUL)
|
|
{
|
|
// Update the registry to specify the new display settings
|
|
if (SaveSettings(CDS_UPDATEREGISTRY | CDS_NORESET) == DISP_CHANGE_SUCCESSFUL)
|
|
{
|
|
// Refresh the display info from the registry, if you update directly ChangeDisplaySettings will do weird things in the fringe cases
|
|
if (ChangeDisplaySettings(NULL, CDS_RAWMODE) == DISP_CHANGE_SUCCESSFUL)
|
|
{
|
|
if (IsKnownSafe())
|
|
{
|
|
// No need to warn, this is known to be a good value.
|
|
*pfApplied = TRUE;
|
|
}
|
|
else
|
|
{
|
|
INT_PTR iRet = DialogBoxParam(HINST_THISDLL,
|
|
MAKEINTRESOURCE((dwFlags & DS_BACKUPDISPLAYCPL) ? DLG_KEEPNEW2 : DLG_KEEPNEW3),
|
|
hwnd,
|
|
KeepNewDlgProc,
|
|
(dwFlags & DS_BACKUPDISPLAYCPL) ? 15 : 30);
|
|
|
|
if ((IDYES == iRet) || (IDOK == iRet))
|
|
{
|
|
*pfApplied = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (_ExactMatch(pOldDevMode, FALSE))
|
|
{
|
|
SaveSettings(CDS_UPDATEREGISTRY | CDS_NORESET);
|
|
ChangeDisplaySettings(NULL, CDS_RAWMODE);
|
|
}
|
|
|
|
if (dwFlags & DS_BACKUPDISPLAYCPL)
|
|
{
|
|
// Use shellexecuteex to run the display CPL
|
|
SHELLEXECUTEINFO shexinfo = {0};
|
|
shexinfo.cbSize = sizeof (shexinfo);
|
|
shexinfo.fMask = SEE_MASK_FLAG_NO_UI;
|
|
shexinfo.nShow = SW_SHOWNORMAL;
|
|
shexinfo.lpFile = L"desk.cpl";
|
|
|
|
ShellExecuteEx(&shexinfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree(pOldDevMode);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CDisplaySettings::GetSelectedMode(DWORD* pdwWidth, DWORD* pdwHeight, DWORD* pdwColor)
|
|
{
|
|
if (pdwWidth && pdwHeight && pdwColor)
|
|
{
|
|
if (_pCurDevmode)
|
|
{
|
|
*pdwWidth = _pCurDevmode->dmPelsWidth;
|
|
*pdwHeight = _pCurDevmode->dmPelsHeight;
|
|
*pdwColor = _pCurDevmode->dmBitsPerPel;
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
HRESULT CDisplaySettings::GetAttached(BOOL* pfAttached)
|
|
{
|
|
if (pfAttached)
|
|
{
|
|
*pfAttached = _fCurAttached;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HRESULT CDisplaySettings::SetPruningMode(BOOL fIsPruningOn)
|
|
{
|
|
ASSERT (_bCanBePruned && !_bIsPruningReadOnly);
|
|
|
|
if (_bCanBePruned &&
|
|
!_bIsPruningReadOnly &&
|
|
((fIsPruningOn != 0) != _bIsPruningOn))
|
|
{
|
|
_bIsPruningOn = (fIsPruningOn != 0);
|
|
|
|
DWORD dwIsPruningOn = (DWORD)_bIsPruningOn;
|
|
RegSetValueEx(_hPruningRegKey,
|
|
SZ_PRUNNING_MODE,
|
|
NULL,
|
|
REG_DWORD,
|
|
(LPBYTE) &dwIsPruningOn,
|
|
sizeof(dwIsPruningOn));
|
|
|
|
//
|
|
// handle the special case when we pruned out the current mode
|
|
//
|
|
if(_bIsPruningOn && _IsCurDevmodeRaw())
|
|
{
|
|
//
|
|
// switch to the closest mode
|
|
//
|
|
_BestMatch(NULL, -1, TRUE);
|
|
}
|
|
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CDisplaySettings::GetPruningMode(BOOL* pfCanBePruned, BOOL* pfIsPruningReadOnly, BOOL* pfIsPruningOn)
|
|
{
|
|
if (pfCanBePruned && pfIsPruningReadOnly && pfIsPruningOn)
|
|
{
|
|
*pfCanBePruned = _bCanBePruned;
|
|
*pfIsPruningReadOnly = _bIsPruningReadOnly;
|
|
*pfIsPruningOn = _bIsPruningOn;
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
}
|
|
|
|
HRESULT CDisplaySettings_CreateInstance(IN IUnknown * punkOuter, IN REFIID riid, OUT LPVOID * ppvObj)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (!punkOuter && ppvObj)
|
|
{
|
|
CDisplaySettings * pThis = new CDisplaySettings();
|
|
|
|
*ppvObj = NULL;
|
|
if (pThis)
|
|
{
|
|
hr = pThis->QueryInterface(riid, ppvObj);
|
|
pThis->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|