// 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 changeDisplayRes(int displayIndex) { DEVMODE dm; EnumDisplaySettings(NULL, displayIndex, &dm); if (ChangeDisplaySettings(&dm, CDS_TEST) != DISP_CHANGE_SUCCESSFUL) return; ChangeDisplaySettings(&dm, 0); }
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(); }
static int fullResInit() { if (!hVideoDlg) { return 1; } DEVMODE devMode; devMode.dmSize = sizeof(DEVMODE); devMode.dmDriverExtra = 0; DISPLAY_DEVICE device; device.cb = sizeof(DISPLAY_DEVICE); EnumDisplayDevices(NULL, nVidAdapter, &device, 0); // fullscreen res box // Run through all possible screenmodes and fill the combobox for (int i = 0; EnumDisplaySettings(device.DeviceName, i, &devMode); i++) { // We're only interested in 16, 24, or 32 bit modes. if (devMode.dmBitsPerPel & 0x30) { long item = 0, itemValue; long newRes = (devMode.dmPelsWidth << 16) | devMode.dmPelsHeight; // See if the resolution is already in the combobox do { itemValue = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETITEMDATA, item, 0); item++; } while ((itemValue != CB_ERR) && (itemValue != newRes)); // If not, add it if (itemValue == CB_ERR) { TCHAR szRes[MAX_PATH]; _stprintf(szRes, _T("%li x %li"), devMode.dmPelsWidth, devMode.dmPelsHeight); item = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_ADDSTRING, 0, (LPARAM)&szRes); SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_SETITEMDATA, item, newRes); } } } // set select long myRes = (nVidWidth << 16) | nVidHeight; long count = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETCOUNT, 0, 0); long item = 0; for (long i = 0; i < count; i++) { item = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETITEMDATA, i, 0); if (myRes == item) { SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_SETCURSEL, (WPARAM)i, 0); break; } } // depth SendDlgItemMessage(hVideoDlg, IDC_PREF_16BIT, BM_SETCHECK, (nVidDepth == 16) ? BST_CHECKED : BST_UNCHECKED, 0); SendDlgItemMessage(hVideoDlg, IDC_PREF_32BIT, BM_SETCHECK, (nVidDepth == 32) ? BST_CHECKED : BST_UNCHECKED, 0); return 0; }
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); } } }
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; }
int Window::GetDesktopWidth() const { DEVMODE mode; memset(&mode, 0, sizeof(mode)); mode.dmSize = sizeof(mode); if (!EnumDisplaySettings(0, ENUM_CURRENT_SETTINGS, &mode)) return 480; return mode.dmPelsWidth; }
int Window::GetDesktopBitsPerPixel() const { DEVMODE mode; memset(&mode, 0, sizeof(mode)); mode.dmSize = sizeof(mode); if (!EnumDisplaySettings(0, ENUM_CURRENT_SETTINGS, &mode)) return 16; return mode.dmBitsPerPel; }
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::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; }
// Search for avaliable resolutions - TODO: Move to Common? wxArrayString GetListOfResolutions() { wxArrayString retlist; #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(wxString::FromAscii(res)); } ZeroMemory(&dmi, sizeof(dmi)); } #elif defined(HAVE_XRANDR) && HAVE_XRANDR main_frame->m_XRRConfig->AddResolutions(retlist); #elif defined(__APPLE__) CFArrayRef modes = CGDisplayAvailableModes(CGMainDisplayID()); for (CFIndex i = 0; i < CFArrayGetCount(modes); i++) { std::stringstream res; CFDictionaryRef mode; CFNumberRef ref; int w, h, d; mode = (CFDictionaryRef)CFArrayGetValueAtIndex(modes, i); ref = (CFNumberRef)CFDictionaryGetValue(mode, kCGDisplayWidth); CFNumberGetValue(ref, kCFNumberIntType, &w); ref = (CFNumberRef)CFDictionaryGetValue(mode, kCGDisplayHeight); CFNumberGetValue(ref, kCFNumberIntType, &h); ref = (CFNumberRef)CFDictionaryGetValue(mode, kCGDisplayBitsPerPixel); CFNumberGetValue(ref, kCFNumberIntType, &d); if (CFDictionaryContainsKey(mode, kCGDisplayModeIsStretched)) continue; if (d != 32) continue; res << w << "x" << h; retlist.Add(res.str()); } #endif return retlist; }
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 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 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 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 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 int get_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; }