自学教程：C++ EnumDisplaySettings函数代码示例

// Search for available resolutions - TODO: Move to Common?wxArrayString GetListOfResolutions(){	wxArrayString retlist;	retlist.Add("Auto");#ifdef _WIN32	DWORD iModeNum = 0;	DEVMODE dmi;	ZeroMemory(&dmi, sizeof(dmi));	dmi.dmSize = sizeof(dmi);	std::vector<std::string> resos;	while (EnumDisplaySettings(NULL, iModeNum++, &dmi) != 0)	{		char res[100];		sprintf(res, "%dx%d", dmi.dmPelsWidth, dmi.dmPelsHeight);		std::string strRes(res);		// Only add unique resolutions		if (std::find(resos.begin(), resos.end(), strRes) == resos.end())		{			resos.push_back(strRes);			retlist.Add(StrToWxStr(res));		}		ZeroMemory(&dmi, sizeof(dmi));	}#elif defined(HAVE_XRANDR) && HAVE_XRANDR	main_frame->m_XRRConfig->AddResolutions(retlist);#elif defined(__APPLE__)	CFArrayRef modes = CGDisplayCopyAllDisplayModes(CGMainDisplayID(), NULL);	for (CFIndex i = 0; i < CFArrayGetCount(modes); i++)	{		std::stringstream res;		CGDisplayModeRef mode;		CFStringRef encoding;		size_t w, h;		bool is32;		mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);		w = CGDisplayModeGetWidth(mode);		h = CGDisplayModeGetHeight(mode);		encoding = CGDisplayModeCopyPixelEncoding(mode);		is32 = CFEqual(encoding, CFSTR(IO32BitDirectPixels));		CFRelease(encoding);		if (!is32)			continue;		if (CGDisplayModeGetIOFlags(mode) & kDisplayModeStretchedFlag)			continue;		res << w << "x" << h;		retlist.Add(res.str());	}	CFRelease(modes);#endif	return retlist;}

void Window::GetScreenMode(){    std::cout<<"Get Screen INfo"<<std::endl;      DEVMODE Screen;      Screen.dmSize=sizeof(DEVMODE);      for(int i=0;EnumDisplaySettings(NULL,i,&Screen);i++){          //LPDWORD BitRequired=0;          //LPDWORD StructNb;          //EnumMonitorsW(NULL,1,NULL,0,BitRequired,StructNb);          //LPBYTE Buffer[(long)*BitRequired];          //EnumMonitorsW(NULL,1,*Buffer,*BitRequired,BitRequired,StructNb);          char buff[255];          char buff2[20];          strcpy(buff,"Device:");          strcat(buff,(const char*)Screen.dmDeviceName);          std::cout<<buff<<std::endl;          WriteToLog(buff,"DEVMOD");          strcpy(buff,"extra bit driver:");          sprintf(buff2,"%i",Screen.dmDriverExtra);          strcat(buff,buff2);          std::cout<<buff<<std::endl;          WriteToLog(buff,"DEVMOD");        //withd et height          strcpy(buff,"Width/Height:");          sprintf(buff2,"%u",Screen.dmPelsWidth);          strcat(buff,buff2);          strcat(buff,"/");          sprintf(buff2,"%u",Screen.dmPelsHeight);          strcat(buff,buff2);          std::cout<<buff<<std::endl;        WriteToLog(buff,"DEVMOD");          //bit par pixel          strcpy(buff,"Bit per pixel:");          sprintf(buff2,"%u",Screen.dmBitsPerPel);          strcat(buff,buff2);          std::cout<<buff<<std::endl;          WriteToLog(buff,"DEVMOD");          strcpy(buff,"FramePerSecond:");          sprintf(buff2,"%u",Screen.dmDisplayFrequency);          strcat(buff,buff2);          std::cout<<buff<<std::endl;          WriteToLog(buff,"DEVMOD");          int* Res=new int[2];          Res[0]=Screen.dmPelsWidth;          Res[1]=Screen.dmPelsHeight;          ResolutionList.push_back(Res);          FrameRateList.push_back(Screen.dmDisplayFrequency);      }      ResolutionList.sort(SortResolution);      FrameRateList.sort();}

	int Window::GetDesktopRefreshRate() const	{		DEVMODE mode;		memset(&mode, 0, sizeof(mode));		mode.dmSize = sizeof(mode);		if (!EnumDisplaySettings(0, ENUM_CURRENT_SETTINGS, &mode))			return 60;		return mode.dmDisplayFrequency;	}

void getPossibleScreenModes(vector<VideoMode> &out_modes) {	DEVMODE dm = {0};	dm.dmSize = sizeof(dm);	for (int iModeNum = 0; EnumDisplaySettings(NULL, iModeNum, &dm) != 0; ++iModeNum) {		if (dm.dmBitsPerPel == 32/* || dm.dmBitsPerPel == 16*/) {			VideoMode mode(dm.dmPelsWidth, dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency);			out_modes.push_back(mode);		}	}}

static DEVMODE deviceInfoForWidget(Widget* widget){    DEVMODE deviceInfo;    deviceInfo.dmSize = sizeof(DEVMODE);    deviceInfo.dmDriverExtra = 0;    MONITORINFOEX monitorInfo = monitorInfoForWidget(widget);    EnumDisplaySettings(monitorInfo.szDevice, ENUM_CURRENT_SETTINGS, &deviceInfo);    return deviceInfo;}

double getrefresh() {  DEVMODE DevMode;  DevMode.dmDriverExtra = 0;  if (EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&DevMode)) {    return (double)DevMode.dmDisplayFrequency;  } else {    return 0;  }}

BOOL Window::IsResolutionSupported(int width, int height) {	DEVMODE mode;	for (int i = 0; EnumDisplaySettings(0, i, &mode); i++) {		if (ChangeDisplaySettings(&mode, CDS_TEST) == DISP_CHANGE_SUCCESSFUL)			if (width == mode.dmPelsWidth && height == mode.dmPelsHeight) {				return TRUE;			}	}	return FALSE;}

VideoModeInfo DisplayWrapper::dwrapperCurrentVideoMode() {	DEVMODE devmode;	EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);	VideoModeInfo videoModeInfo;	videoModeInfo.width = devmode.dmPelsWidth;	videoModeInfo.height = devmode.dmPelsHeight;	videoModeInfo.bpp = devmode.dmBitsPerPel;	return videoModeInfo;}

VideoModeInfo DisplayWrapper::dw_currentMode(){  DEVMODE devmode;  EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);  VideoModeInfo mode;  mode.width = devmode.dmPelsWidth;  mode.height = devmode.dmPelsHeight;  mode.bpp = devmode.dmBitsPerPel;  return mode;}

void adjustWindow(WindowsDesc* winDesc){	HWND hwnd = (HWND)winDesc->handle;	if (winDesc->fullScreen)	{		RECT windowedRect = {};		// Save the old window rect so we can restore it when exiting fullscreen mode.		GetWindowRect(hwnd, &windowedRect);		winDesc->windowedRect = { (int)windowedRect.left, (int)windowedRect.top, (int)windowedRect.right, (int)windowedRect.bottom };		// Make the window borderless so that the client area can fill the screen.		SetWindowLong(hwnd, GWL_STYLE, WS_SYSMENU | WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE);		// Get the settings of the primary display. We want the app to go into		// fullscreen mode on the display that supports Independent Flip.		DEVMODE devMode = {};		devMode.dmSize = sizeof(DEVMODE);		EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devMode);		SetWindowPos(			hwnd,			HWND_TOPMOST,			devMode.dmPosition.x,			devMode.dmPosition.y,			devMode.dmPosition.x + devMode.dmPelsWidth,			devMode.dmPosition.y + devMode.dmPelsHeight,			SWP_FRAMECHANGED | SWP_NOACTIVATE);		ShowWindow(hwnd, SW_MAXIMIZE);	}	else	{		// Restore the window's attributes and size.		SetWindowLong(hwnd, GWL_STYLE, WS_OVERLAPPEDWINDOW);		SetWindowPos(			hwnd,			HWND_NOTOPMOST,			winDesc->windowedRect.left,			winDesc->windowedRect.top,			winDesc->windowedRect.right - winDesc->windowedRect.left,			winDesc->windowedRect.bottom - winDesc->windowedRect.top,			SWP_FRAMECHANGED | SWP_NOACTIVATE);		if (winDesc->maximized)		{			ShowWindow(hwnd, SW_MAXIMIZE);		}		else		{			ShowWindow(hwnd, SW_NORMAL);		}	}}

/*** GLimp_GetCurrentMode*/int GLimp_GetCurrentMode( void ){	DEVMODE dm;			memset( &dm, 0, sizeof( dm ) );	dm.dmSize = sizeof( dm );	EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm );	return VID_GetModeNum( dm.dmPelsWidth, dm.dmPelsHeight );}

void changeDisplayRes(int displayIndex){	DEVMODE dm;      EnumDisplaySettings(NULL, displayIndex, &dm);      if (ChangeDisplaySettings(&dm, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)   return;      ChangeDisplaySettings(&dm, 0);}

void s_video_gdi_server_fullscreen (void){	RECT rect;        DEVMODE settings;	s_video_gdi_data_t *priv = (s_video_gdi_data_t *) xynth_server->driver->driver_data;		if (priv->fullscreen == 0) {                EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &priv->dmode);                memset(&settings, 0, sizeof(DEVMODE));                settings.dmSize = sizeof(DEVMODE);                settings.dmBitsPerPel = priv->bpp_windows;                settings.dmPelsWidth = xynth_server->window->surface->width;                settings.dmPelsHeight = xynth_server->window->surface->height;                settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;        } else {                settings.dmSize = sizeof(DEVMODE);                settings.dmBitsPerPel = priv->dmode.dmBitsPerPel;                settings.dmPelsWidth = priv->dmode.dmPelsWidth;                settings.dmPelsHeight = priv->dmode.dmPelsHeight;                settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;        }        switch (ChangeDisplaySettings(&settings, CDS_FULLSCREEN)) {                case DISP_CHANGE_SUCCESSFUL:                        break;                case DISP_CHANGE_BADFLAGS:                case DISP_CHANGE_BADMODE:                case DISP_CHANGE_BADPARAM:                case DISP_CHANGE_FAILED:                case DISP_CHANGE_NOTUPDATED:                case DISP_CHANGE_RESTART:                        break;        }	if (priv->fullscreen == 0) {        	rect.left = 0;        	rect.right = xynth_server->window->surface->width;        	rect.top = 0;        	rect.bottom = xynth_server->window->surface->height;                AdjustWindowRect(&rect, GetWindowLong(priv->hwndMain, GWL_STYLE), FALSE);                SetWindowPos(priv->hwndMain, HWND_TOPMOST, rect.left, rect.top, rect.right + 100, rect.bottom + 100, 0);                priv->fullscreen = 1;        } else {        	rect.left = 0;        	rect.right = xynth_server->window->surface->width;        	rect.top = 0;        	rect.bottom = xynth_server->window->surface->height;                AdjustWindowRect(&rect, GetWindowLong(priv->hwndMain, GWL_STYLE), FALSE);                SetWindowPos(priv->hwndMain, HWND_NOTOPMOST, 0, 0, rect.right - rect.left, rect.bottom - rect.top, 0);                priv->fullscreen = 0;        }	UpdateWindow(priv->hwndMain);}

void GLWindow::changeDisplaySettings(){	RECT screenRect = { };	GetClientRect(GetDesktopWindow(), &screenRect);	DEVMODE deviceMode = { };	EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &deviceMode);	deviceMode.dmSize = sizeof(DEVMODE);	deviceMode.dmPelsWidth = screenRect.right;	deviceMode.dmPelsHeight = screenRect.bottom;	ChangeDisplaySettings(&deviceMode, CDS_FULLSCREEN);}

void CFixApp::PopulateDialog(){    //Populate the GUI scale combobox    for (size_t i = 1; i < 6; i++)    {        wchar_t szBuf[3];        swprintf_s(szBuf, L"x%Iu", i);        ComboBox_AddString(m_hWndCBGUIScales, szBuf);    }    ComboBox_SetCurSel(m_hWndCBGUIScales, 0);    //Populate the resolution combobox    DEVMODE dm = {};    dm.dmSize = sizeof(dm);    Resolution r= {};    for(DWORD iModeNum = 0; EnumDisplaySettings(NULL, iModeNum, &dm) != FALSE; iModeNum++)    {        if((dm.dmPelsWidth != r.iX || dm.dmPelsHeight != r.iY) && dm.dmBitsPerPel == 32) //Only add each res once, but don't actually check if it matches the current color depth/refresh rate        {            r.iX = dm.dmPelsWidth;            r.iY = dm.dmPelsHeight;            m_Resolutions.push_back(r);            wchar_t szBuffer[20];            _snwprintf_s(szBuffer, _TRUNCATE, L"%Iux%Iu", r.iX, r.iY);            int iIndex = ComboBox_AddString(m_hWndCBResolutions, szBuffer);            ComboBox_SetItemData(m_hWndCBResolutions, iIndex, &(m_Resolutions.back()));        }    }    ComboBox_SetCurSel(m_hWndCBResolutions, 0);    //Renderers (based on UnEngineWin.h), requires appInit() to have been called    TArray<FRegistryObjectInfo> Classes;    Classes.Empty();    UObject::GetRegistryObjects( Classes, UClass::StaticClass(), URenderDevice::StaticClass(), 0 );    for( TArray<FRegistryObjectInfo>::TIterator It(Classes); It; ++It )    {        FString Path = It->Object, Left, Right;        if( Path.Split(L".",&Left,&Right)  )        {            const wchar_t* pszDesc = Localize(*Right,L"ClassCaption",*Left);            assert(pszDesc);            if(ComboBox_FindStringExact(m_hWndCBRenderers, -1, pszDesc) == CB_ERR)            {                ComboBox_AddString(m_hWndCBRenderers, pszDesc);                m_Renderers.emplace_back(static_cast<wchar_t*>(Path.GetCharArray().GetData()));            }        }    }}

void DisplayWrapper::dw_init(bool filter, int minWidth, int minHeight){  base_height = base_width = 0;  base_bpp = 0;  DEVMODE devmode;  DWORD modenum = 0;  VideoModeInfo mode;  modes.clear();  modeNames.clear();  // get current display  wchar_t *device = NULL;  DISPLAY_DEVICE display_device;  display_device.cb = sizeof(DISPLAY_DEVICE);  if (base_widget)  {    QDesktopWidget desktop;    int screen = desktop.screenNumber(base_widget);    if (screen >= 0)    {      if (EnumDisplayDevices(NULL, screen, &display_device, 0))      {        device = display_device.DeviceName;        //qDebug() << QString::fromWCharArray(device);      }    }  }  // enumerate display modes  while (EnumDisplaySettings(device, modenum, &devmode))  {    if (devmode.dmPelsWidth >= minWidth && devmode.dmPelsHeight >= minHeight)    {      modeNames.append(QString("%1 x %2")                       .arg(devmode.dmPelsWidth)                       .arg(devmode.dmPelsHeight)                       );      mode.width = devmode.dmPelsWidth;      mode.height = devmode.dmPelsHeight;      mode.bpp = devmode.dmBitsPerPel;      modes.append(mode);    }    modenum++;  }  if (filter)    modeNames.removeDuplicates();}

/** * Choose displaymodes using extended codepath (multiple displaydevices) */jobjectArray getAvailableDisplayModes(JNIEnv * env) {	int i = 0, j = 0, n = 0;//	DISPLAY_DEVICE DisplayDevice;	DEVMODE DevMode;	jobject *display_mode_objects = NULL;	int list_size = 0;	jclass displayModeClass;	jobjectArray ret;	displayModeClass = (*env)->FindClass(env, "org/lwjgl/opengl/DisplayMode");	ZeroMemory(&DevMode, sizeof(DEVMODE));//	ZeroMemory(&DisplayDevice, sizeof(DISPLAY_DEVICE));	DevMode.dmSize = sizeof(DEVMODE);//	DisplayDevice.cb = sizeof(DISPLAY_DEVICE);	/* Multi-monitor stuff commented out since we're only really interested in the primary monitor *//*	while(EnumDisplayDevices(NULL, i++, &DisplayDevice, 0) != 0) {		// continue if mirroring device		if((DisplayDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) != 0) {			continue;		}		j = 0;		while(EnumDisplaySettings((const char *) DisplayDevice.DeviceName, j++, &DevMode) != 0) {*/		while(EnumDisplaySettings(NULL, j++, &DevMode) != 0) {			// Filter out indexed modes			if (DevMode.dmBitsPerPel > 8 && ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN | CDS_TEST) == DISP_CHANGE_SUCCESSFUL) {				jobject displayMode;				if (list_size <= n) {					list_size += 1;					display_mode_objects = (jobject *)realloc(display_mode_objects, sizeof(jobject)*list_size);					if (display_mode_objects == NULL)						return NULL;				}				displayMode = createDisplayMode(env, &DevMode);				display_mode_objects[n++] = displayMode;			}		}//	}	printfDebugJava(env, "Found %d displaymodes", n);	ret = (*env)->NewObjectArray(env, n, displayModeClass, NULL);	for (i = 0; i < n; i++) {		(*env)->SetObjectArrayElement(env, ret, i, display_mode_objects[i]);	}	free(display_mode_objects);   	return ret;}

DisplayModeManagerPimpl::DisplayModeManagerPimpl(){	std::set<std::pair<int, int> > unique_resolutions;	std::vector<std::pair<int, int> > sorted_modes;	DEVMODE display_setting;	display_setting.dmSize = sizeof(DEVMODE);		EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &display_setting);	int i = 0;	int bpp;	bpp = display_setting.dmBitsPerPel;	sorted_modes.push_back(std::make_pair(display_setting.dmPelsWidth, display_setting.dmPelsHeight));	while (EnumDisplaySettings(NULL, i, &display_setting))	{		if (display_setting.dmBitsPerPel == bpp)		{			unique_resolutions.insert(std::make_pair(display_setting.dmPelsWidth, display_setting.dmPelsHeight));		}		++i;	}	for (std::set<std::pair<int, int> >::iterator it = unique_resolutions.begin(); it != unique_resolutions.end(); ++it)	{		sorted_modes.push_back(*it);	}	std::sort(sorted_modes.begin()+1, sorted_modes.end());	mode_count = sorted_modes.size();	modes = new DisplayMode[mode_count];	for (unsigned int i = 0; i < sorted_modes.size(); ++i)	{		modes[i].width = sorted_modes[i].first;		modes[i].height = sorted_modes[i].second;	}}

void NzVideoModeImpl::GetFullscreenModes(std::vector<NzVideoMode>& modes){	DEVMODE win32Mode;	win32Mode.dmSize = sizeof(DEVMODE);	for (unsigned int i = 0; EnumDisplaySettings(nullptr, i, &win32Mode); ++i)	{		NzVideoMode mode(win32Mode.dmPelsWidth, win32Mode.dmPelsHeight, static_cast<nzUInt8>(win32Mode.dmBitsPerPel));		// Il existe plusieurs modes avec ces trois caractéristques identiques		if (std::find(modes.begin(), modes.end(), mode) == modes.end())			modes.push_back(mode);	}}

//! /return Returns a pointer to a list with all video modes supported//! by the gfx adapter.video::IVideoModeList* CIrrDeviceWin32::getVideoModeList(){	if (!VideoModeList.getVideoModeCount())	{		// enumerate video modes.		DWORD i=0;		DEVMODE mode;		while (EnumDisplaySettings(NULL, i, &mode))		{			VideoModeList.addMode(core::dimension2d<s32>(mode.dmPelsWidth, mode.dmPelsHeight),				mode.dmBitsPerPel);			++i;		}		if (EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &mode))			VideoModeList.setDesktop(mode.dmBitsPerPel, core::dimension2d<s32>(mode.dmPelsWidth, mode.dmPelsHeight));	}	return &VideoModeList;}

void GLWindow::initialize(){	isActive			= true;	isFullscreen		= false;	windowedMode	= 1; 	fullscreenMode = 0; 	EnumDisplaySettings (NULL, ENUM_CURRENT_SETTINGS, &nativeMode);	videoModes[0] = VideoMode(4*nativeMode.dmPelsWidth/4, 4*nativeMode.dmPelsHeight/4, 32);	videoModes[1] = VideoMode(3*nativeMode.dmPelsWidth/4, 3*nativeMode.dmPelsHeight/4, 32);	videoModes[2] = VideoMode(2*nativeMode.dmPelsWidth/4, 2*nativeMode.dmPelsHeight/4, 32);}

// 获得最大显示模式时屏幕的宽度和高度（以像素为单位）void CContourView::GetLargestDisplayMode( int* pcxBitmap, int* pcyBitmap ){    DEVMODE devmode;    int iModeNum = 0;    ZeroMemory( &devmode, sizeof( DEVMODE ) );    devmode.dmSize = sizeof( DEVMODE );    while( EnumDisplaySettings( NULL, iModeNum++, &devmode ) )    {        *pcxBitmap = max( *pcxBitmap, ( int )devmode.dmPelsWidth );        *pcyBitmap = max( *pcyBitmap, ( int )devmode.dmPelsHeight );    }}

	D3D9VideoOutputInfo::D3D9VideoOutputInfo(IDirect3D9* d3d9device, UINT32 adapterIdx)		:mMonitorHandle(0)	{		IDirect3D9* pD3D = D3D9RenderAPI::getDirect3D9();		D3DADAPTER_IDENTIFIER9 adapterIdentifier;		pD3D->GetAdapterIdentifier(adapterIdx, 0, &adapterIdentifier);		mName = adapterIdentifier.DeviceName;		for (UINT32 i = 0; i < pD3D->GetAdapterModeCount(adapterIdx, D3DFMT_X8R8G8B8); i++)		{			D3DDISPLAYMODE displayMode;			pD3D->EnumAdapterModes(adapterIdx, D3DFMT_X8R8G8B8, i, &displayMode);			bool foundVideoMode = false;			for (auto videoMode : mVideoModes)			{				D3D9VideoMode* d3d9videoMode = static_cast<D3D9VideoMode*>(videoMode);				UINT32 intRefresh = Math::roundToInt(d3d9videoMode->mRefreshRate);				if (d3d9videoMode->mWidth == displayMode.Width && d3d9videoMode->mHeight == displayMode.Height && intRefresh == displayMode.RefreshRate)				{					foundVideoMode = true;					break;				}			}			if (!foundVideoMode)			{				D3D9VideoMode* videoMode = bs_new<D3D9VideoMode>(displayMode.Width, displayMode.Height, (float)displayMode.RefreshRate, adapterIdx);				mVideoModes.push_back(videoMode);			}		}		// Get desktop display mode		HMONITOR hMonitor = pD3D->GetAdapterMonitor(adapterIdx);		MONITORINFOEX monitorInfo;		monitorInfo.cbSize = sizeof(MONITORINFOEX);		GetMonitorInfo(hMonitor, &monitorInfo);		DEVMODE devMode;		devMode.dmSize = sizeof(DEVMODE);		devMode.dmDriverExtra = 0;		EnumDisplaySettings(monitorInfo.szDevice, ENUM_CURRENT_SETTINGS, &devMode);		D3D9VideoMode* desktopVideoMode = bs_new<D3D9VideoMode>(devMode.dmPelsWidth, devMode.dmPelsHeight, (float)devMode.dmDisplayFrequency, adapterIdx);		mDesktopVideoMode = desktopVideoMode;	}

/** Get the refresh rate for the monitor, in Hz */static intget_refresh_rate(void){   DEVMODE devModes;   if (EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devModes)) {      /* clamp the value, just in case we get garbage */      return CLAMP(devModes.dmDisplayFrequency, 30, 120);   }   else {      /* reasonable default */      return 60;   }}

int getNextDisplayResDown(int *xScrnRes, int *yScrnRes, int colorDepth){	DEVMODE dm;   int displayFound = 0;	int i;   	i = 0;	while (EnumDisplaySettings(NULL, i++, &dm))    {      if (dm.dmBitsPerPel == colorDepth)      if ((dm.dmPelsWidth == *xScrnRes) && (dm.dmPelsHeight == *yScrnRes))      {         displayFound = 1;         break;      }   }      if (!displayFound)   return -1;      while (EnumDisplaySettings(NULL, i++, &dm))    {      if (dm.dmBitsPerPel == colorDepth)      if ((dm.dmPelsWidth < *xScrnRes) || (dm.dmPelsHeight < *yScrnRes))      break;   }      if ((dm.dmBitsPerPel != colorDepth) ||      ((dm.dmPelsWidth >= *xScrnRes) && (dm.dmPelsHeight >= *yScrnRes)))   return -1;      *xScrnRes = dm.dmPelsWidth;   *yScrnRes = dm.dmPelsHeight;   i--;   	return i;}

bool CScreenManager::SetLowResolution(){	if(!m_bInit)	{		return false;	}	DEVMODE DevMod;    DevMod.dmSize = sizeof(DEVMODE);    if (!EnumDisplaySettings(m_MainDevice.DeviceName, ENUM_CURRENT_SETTINGS, &DevMod))    {		DoLog("Failed to enum display settings, low resolution canceled", MSG_ERROR);        return false;    } 	if( (DevMod.dmPelsWidth <= 1366) || (DevMod.dmPelsWidth <= 768) )	{		DoLog("Screen has already a low res, ignore resolution change", MSG_WARNING);		return true;	}	// Flag for what we want to set	DevMod.dmFields = (DM_PELSWIDTH | DM_PELSHEIGHT);	// Try a 19/9 low res    DevMod.dmPelsWidth = 1366;    DevMod.dmPelsHeight = 768;       if (ChangeDisplaySettings(&DevMod, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)    {		// Try a 4/3 low res		DevMod.dmPelsWidth = 1024;		DevMod.dmPelsHeight = 768;		if (ChangeDisplaySettings(&DevMod, CDS_TEST) != DISP_CHANGE_SUCCESSFUL)		{			DoLog("Low resolution display settings not supported, canceled", MSG_ERROR);			return false;		 }    }     if(ChangeDisplaySettings(&DevMod, 0) != DISP_CHANGE_SUCCESSFUL)	{		DoLog("Failed to apply low resolution display settings", MSG_ERROR);        return false;	}	m_bIsLowRes = true;		return true;}