void ViewerWindow::setSizeFullScreenWindow() { // Save position of window. GetWindowPlacement(m_hWnd, &m_workArea); // Get size of desktop. HMONITOR hmon = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST); MONITORINFO mi; mi.cbSize = sizeof(mi); RECT fullScreenWindowsRect; if (!!GetMonitorInfo(hmon, &mi)) { fullScreenWindowsRect = mi.rcMonitor; } else { m_logWriter.warning(_T("Get monitor info is failed. Use second method (no multi-screen).")); GetWindowRect(GetDesktopWindow(), &fullScreenWindowsRect); } Rect fullScreenRect; fullScreenRect.fromWindowsRect(&fullScreenWindowsRect); m_logWriter.detail(_T("full screen window rect: %d, %d; %d, %d"), fullScreenRect.left, fullScreenRect.top, fullScreenRect.getWidth(), fullScreenRect.getHeight()); setStyle((getStyle() | WS_MAXIMIZE) & ~(WS_CAPTION | WS_BORDER | WS_THICKFRAME | WS_MAXIMIZEBOX)); setExStyle(getExStyle() | WS_EX_TOPMOST); SetWindowPos(m_hWnd, 0, fullScreenRect.left, fullScreenRect.top, fullScreenRect.getWidth(), fullScreenRect.getHeight(), SWP_SHOWWINDOW); }
static void Manage(vout_display_t *vd) { vout_display_sys_t *sys = vd->sys; CommonManage(vd); if (sys->changes & DX_POSITION_CHANGE) { /* Update overlay */ if (sys->use_overlay) DirectXUpdateOverlay(vd, NULL); /* Check if we are still on the same monitor */ HMONITOR hmon = MonitorFromWindow(sys->hwnd, MONITOR_DEFAULTTONEAREST); if (sys->hmonitor != hmon) { vout_display_SendEventPicturesInvalid(vd); } /* */ sys->changes &= ~DX_POSITION_CHANGE; } /* Wallpaper mode change */ vlc_mutex_lock(&sys->lock); const bool ch_wallpaper = sys->ch_wallpaper; const bool wallpaper_requested = sys->wallpaper_requested; sys->ch_wallpaper = false; vlc_mutex_unlock(&sys->lock); if (ch_wallpaper) WallpaperChange(vd, wallpaper_requested); /* */ if (sys->restore_overlay) DirectXUpdateOverlay(vd, NULL); }
void D3D9RenderWindow::adjustWindow(unsigned int clientWidth, unsigned int clientHeight, unsigned int* winWidth, unsigned int* winHeight) { // NB only call this for non full screen RECT rc; SetRect(&rc, 0, 0, clientWidth, clientHeight); AdjustWindowRect(&rc, WS_VISIBLE | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW, false); *winWidth = rc.right - rc.left; *winHeight = rc.bottom - rc.top; // adjust to monitor HMONITOR hMonitor = MonitorFromWindow(mHWnd, MONITOR_DEFAULTTONEAREST); // Get monitor info MONITORINFO monitorInfo; memset(&monitorInfo, 0, sizeof(MONITORINFO)); monitorInfo.cbSize = sizeof(MONITORINFO); GetMonitorInfo(hMonitor, &monitorInfo); LONG maxW = monitorInfo.rcWork.right - monitorInfo.rcWork.left; LONG maxH = monitorInfo.rcWork.bottom - monitorInfo.rcWork.top; if (*winWidth > (unsigned int)maxW) *winWidth = maxW; if (*winHeight > (unsigned int)maxH) *winHeight = maxH; }
BOOL CMonitorManager::GetMonitorResolution(HWND hWnd, long *lResoluteW, long *lResoluteH) { HMONITOR hm = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST); BOOL bFindMonitor = FALSE; for(int i = 0; i < m_MonitorList.size(); i++) { if (hm == m_MonitorList[i].hMonitor) { bFindMonitor = TRUE; break; } } if (!bFindMonitor) return FALSE; DISPLAY_DEVICE dd; ZeroMemory(&dd, sizeof(DISPLAY_DEVICE)); dd.cb = sizeof(DISPLAY_DEVICE); bFindMonitor = EnumDisplayDevices(NULL, i, &dd, 0); if (!bFindMonitor) return FALSE; DEVMODE dm; ZeroMemory(&dm, sizeof(DEVMODE)); dm.dmSize = sizeof(dm); bFindMonitor = EnumDisplaySettings((char*)dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm); if (!bFindMonitor) return FALSE; *lResoluteW = dm.dmPelsWidth; *lResoluteH = dm.dmPelsHeight; return TRUE; }
static void d3d_free(void *data) { d3d_video_t *d3d = (d3d_video_t*)data; d3d_deinitialize(d3d); #ifdef _XBOX if (d3d->ctx_driver && d3d->ctx_driver->destroy) d3d->ctx_driver->destroy(d3d); d3d->ctx_driver = NULL; #endif if (d3d->dev) d3d->dev->Release(); if (d3d->g_pD3D) d3d->g_pD3D->Release(); #ifdef HAVE_MONITOR Monitor::last_hm = MonitorFromWindow(d3d->hWnd, MONITOR_DEFAULTTONEAREST); DestroyWindow(d3d->hWnd); #endif if (d3d) delete d3d; #ifndef _XBOX UnregisterClass("RetroArch", GetModuleHandle(NULL)); #endif }
static void gfx_ctx_destroy(void) { if (g_hrc) { wglMakeCurrent(NULL, NULL); wglDeleteContext(g_hrc); g_hrc = NULL; } if (g_hwnd && g_hdc) { ReleaseDC(g_hwnd, g_hdc); g_hdc = NULL; } if (g_hwnd) { g_last_hm = MonitorFromWindow(g_hwnd, MONITOR_DEFAULTTONEAREST); DestroyWindow(g_hwnd); UnregisterClass("RetroArch", GetModuleHandle(NULL)); g_hwnd = NULL; } if (g_restore_desktop) { MONITORINFOEX current_mon; memset(¤t_mon, 0, sizeof(current_mon)); current_mon.cbSize = sizeof(MONITORINFOEX); GetMonitorInfo(g_last_hm, (MONITORINFO*)¤t_mon); ChangeDisplaySettingsEx(current_mon.szDevice, NULL, NULL, 0, NULL); g_restore_desktop = false; } g_inited = false; }
void ConfigFileManager::CreateInstallerWindow(const std::wstring& title) { if (m_pInstallerWindow != NULL) { delete m_pInstallerWindow; m_pInstallerWindow = NULL; } MONITORINFO mi = { 0 }; mi.cbSize = sizeof(mi); CHECK_WIN32_BOOL(GetMonitorInfo(MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY), & mi), L"GetMonitorInfo"); int cx = 640; int cy = 480; m_pInstallerWindow = new InstallerWindow(); // deletes itself m_pInstallerWindow->Create( (mi.rcWork.left + mi.rcWork.right) / 2 - cx / 2, (mi.rcWork.top + mi.rcWork.bottom) / 2 - cy / 2, cx, cy, title.c_str()); CHECK_BOOL(m_pInstallerWindow->hwnd != NULL, L"InstallerWindow::Create"); }
static void SetWindowMode(window_data Data, int Width, int Height) { MONITORINFO MonitorInfo = {}; MonitorInfo.cbSize = sizeof(MonitorInfo); if(GetMonitorInfo(MonitorFromWindow(Data.Window, MONITOR_DEFAULTTONEAREST), &MonitorInfo)) { RECT Rect = MonitorInfo.rcMonitor; int MonitorWidth = Rect.right - Rect.left; int MonitorHeight = Rect.bottom - Rect.top; int X = Rect.left; int Y = Rect.top; if(MonitorWidth > Width) { X = (MonitorWidth - Width) / 2; } if(MonitorHeight > Height) { Y = (MonitorHeight - Height) / 2; } SetWindowDimensions(Data, X, Y, Width, Height); } else { PRINT_ERR("Could not get monitor info.\n"); } SetBorderlessWindowStyle(Data); }
void WindowManager::toggleBorderlessFullscreen() { borderlessFullscreen = !borderlessFullscreen; HWND hwnd = ::GetActiveWindow(); if(borderlessFullscreen) { // store previous rect ::GetClientRect(hwnd, &prevWindowRect); // set styles LONG lStyle = ::GetWindowLong(hwnd, GWL_STYLE); prevStyle = lStyle; lStyle &= ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU); ::SetWindowLong(hwnd, GWL_STYLE, lStyle); LONG lExStyle = ::GetWindowLong(hwnd, GWL_EXSTYLE); prevExStyle = lExStyle; lExStyle &= ~(WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE); ::SetWindowLong(hwnd, GWL_EXSTYLE, lExStyle); // adjust size & position HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST); MONITORINFO info; info.cbSize = sizeof(MONITORINFO); GetMonitorInfo(monitor, &info); int monitorWidth = info.rcMonitor.right - info.rcMonitor.left; int monitorHeight = info.rcMonitor.bottom - info.rcMonitor.top; ::SetWindowPos(hwnd, NULL, info.rcMonitor.left, info.rcMonitor.top, monitorWidth, monitorHeight, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER); } else { // restore previous window ::SetWindowLong(hwnd, GWL_STYLE, prevStyle); ::SetWindowLong(hwnd, GWL_EXSTYLE, prevExStyle); RECT desiredRect = prevWindowRect; ::AdjustWindowRect(&desiredRect, prevStyle, false); int wWidth = desiredRect.right - desiredRect.left, wHeight = desiredRect.bottom - desiredRect.top; ::SetWindowPos(hwnd, NULL, prevWindowRect.left, prevWindowRect.top, wWidth, wHeight, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER); } }
// Thank you Raymond Chen!! void Win32FullscreenToggle(HWND window) { DWORD style = GetWindowLong(window, GWL_STYLE); if (style & WS_OVERLAPPEDWINDOW) { MONITORINFO monitorInfo = { sizeof(monitorInfo) }; if (GetWindowPlacement(window, &globalWindowPos) && GetMonitorInfo(MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY), &monitorInfo)) {//NOT BITWISE OPERATOR SetWindowLong(window, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW); SetWindowPos(window, HWND_TOP, monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED); } } else { SetWindowLong(window, GWL_STYLE, style | WS_OVERLAPPEDWINDOW); SetWindowPlacement(window, &globalWindowPos); SetWindowPos(window, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED); } }
void DXContext::MinimizeWinamp(HMONITOR hPluginMonitor) { // minimize Winamp window HMONITOR hWinampMon = MonitorFromWindow(m_hwnd_winamp, MONITOR_DEFAULTTONEAREST); HMONITOR hPluginMon = hPluginMonitor;//MonitorFromWindow(m_hwnd, MONITOR_DEFAULTTONEAREST);//m_lpD3D->GetAdapterMonitor(ordinal_adapter); if ((m_current_mode.screenmode == FULLSCREEN || m_current_mode.screenmode == FAKE_FULLSCREEN) && (m_minimize_winamp) && (hWinampMon && hPluginMon && hPluginMon==hWinampMon) && (!m_winamp_minimized) ) { // nitpicky check: if we're in fake fullscreen mode // and are only going to display on half the screen, // don't minimize Winamp. if (m_current_mode.screenmode == FAKE_FULLSCREEN) { int x = m_monitor_rect.right - m_monitor_rect.left; int y = m_monitor_rect.bottom - m_monitor_rect.top; if ((x >= y*2 && m_current_mode.m_dualhead_horz != 0) || (y > x*4/3 && m_current_mode.m_dualhead_vert != 0)) { return; } } ShowWindow(m_hwnd_winamp, SW_MINIMIZE); // also restore the focus to the plugin window, since this will steal it: SetFocus(m_hwnd); SetActiveWindow(m_hwnd); SetForegroundWindow(m_hwnd); m_winamp_minimized = 1; } }
bool D3D9Device::validateDisplayMonitor(D3D9RenderWindowCore* renderWindow) { // Ignore full screen since it doesn't really move and it is possible // that it created using multi-head adapter so for a subordinate the // native monitor handle and this device handle will be different. if (renderWindow->getProperties().isFullScreen()) return true; HMONITOR hRenderWindowMonitor = NULL; // Find the monitor this render window belongs to. hRenderWindowMonitor = MonitorFromWindow(renderWindow->_getWindowHandle(), MONITOR_DEFAULTTONULL); // This window doesn't intersect with any of the display monitor if (hRenderWindowMonitor == NULL) return false; // Case this window changed monitor. if (hRenderWindowMonitor != mMonitor) { // Lock access to rendering device. D3D9RenderAPI::getResourceManager()->lockDeviceAccess(); mpDeviceManager->linkRenderWindow(renderWindow); // UnLock access to rendering device. D3D9RenderAPI::getResourceManager()->unlockDeviceAccess(); return false; } return true; }
void CorrectConsolePos(HWND hConWnd) { RECT rcNew = {}; if (GetWindowRect(hConWnd, &rcNew)) { HMONITOR hMon = MonitorFromWindow(hConWnd, MONITOR_DEFAULTTOPRIMARY); MONITORINFO mi = {sizeof(mi)}; //int nMaxX = 0, nMaxY = 0; if (GetMonitorInfo(hMon, &mi)) { int newW = (rcNew.right-rcNew.left), newH = (rcNew.bottom-rcNew.top); int newX = rcNew.left, newY = rcNew.top; if (newX < mi.rcWork.left) newX = mi.rcWork.left; else if (rcNew.right > mi.rcWork.right) newX = max(mi.rcWork.left,(mi.rcWork.right-newW)); if (newY < mi.rcWork.top) newY = mi.rcWork.top; else if (rcNew.bottom > mi.rcWork.bottom) newY = max(mi.rcWork.top,(mi.rcWork.bottom-newH)); if ((newX != rcNew.left) || (newY != rcNew.top)) SetWindowPos(hConWnd, HWND_TOP, newX, newY,0,0, SWP_NOSIZE); } } }
void Dialog::SnapToEdges(LPWINDOWPOS window_pos) { if (!snap_gap_) return; RECT rc_monitor = {0}; SystemParametersInfo(SPI_GETWORKAREA, 0, &rc_monitor, 0); if (GetSystemMetrics(SM_CMONITORS) > 1) { HMONITOR monitor = MonitorFromWindow(window_, MONITOR_DEFAULTTONEAREST); if (monitor) { MONITORINFO mi; mi.cbSize = sizeof(mi); GetMonitorInfo(monitor, &mi); rc_monitor = mi.rcWork; } } // Snap X axis if (abs(window_pos->x - rc_monitor.left) <= snap_gap_) { window_pos->x = rc_monitor.left; } else if (abs(window_pos->x + window_pos->cx - rc_monitor.right) <= snap_gap_) { window_pos->x = rc_monitor.right - window_pos->cx; } // Snap Y axis if (abs(window_pos->y - rc_monitor.top) <= snap_gap_) { window_pos->y = rc_monitor.top; } else if (abs(window_pos->y + window_pos->cy - rc_monitor.bottom) <= snap_gap_) { window_pos->y = rc_monitor.bottom - window_pos->cy; } }
void CDpiAware::GetCenteredRect(HWND hWnd, RECT& rcCentered, HMONITOR hDefault /*= NULL*/) { bool lbCentered = false; HMONITOR hMon; if (hWnd) hMon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST); else hMon = MonitorFromRect(&rcCentered, MONITOR_DEFAULTTONEAREST); MONITORINFO mi = {}; GetNearestMonitorInfo(&mi, hDefault, hWnd ? NULL : &rcCentered, hWnd); int iWidth = rcCentered.right - rcCentered.left; int iHeight = rcCentered.bottom - rcCentered.top; RECT rcNew = { (mi.rcWork.left + mi.rcWork.right - iWidth)/2, (mi.rcWork.top + mi.rcWork.bottom - iHeight)/2 }; rcNew.right = rcNew.left + iWidth; rcNew.bottom = rcNew.top + iHeight; rcCentered = rcNew; }
void WindowManager::resize(unsigned clientW, unsigned clientH) { HWND hwnd = ::GetActiveWindow(); // Store current window rect ::GetClientRect(hwnd, &prevWindowRect); // Get monitor size HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST); MONITORINFO info; info.cbSize = sizeof(MONITORINFO); GetMonitorInfo(monitor, &info); int monitorWidth = info.rcMonitor.right - info.rcMonitor.left; int monitorHeight = info.rcMonitor.bottom - info.rcMonitor.top; // How much do we overlap or are smaller than the actual screen size int widthDiff = monitorWidth - (clientW ? clientW : prevWindowRect.right); int heightDiff = monitorHeight - (clientH ? clientH : prevWindowRect.bottom); RECT desiredRect; desiredRect.left = widthDiff / 2; desiredRect.top = heightDiff / 2; desiredRect.right = monitorWidth - (widthDiff / 2); desiredRect.bottom = monitorHeight - (heightDiff / 2); LONG lStyle = ::GetWindowLong(hwnd, GWL_STYLE); ::AdjustWindowRect(&desiredRect, lStyle, false); ::SetWindowPos(hwnd, NULL, desiredRect.left, desiredRect.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE); }
void Win32WindowManager::lowerCurtain() { if(mCurtainWindow) return; // For now just grab monitor of the first window... we may need to // beef this up later on, maybe by passing in the window that's entering // leaving full-screen to lowerCurtain. HMONITOR hMon = MonitorFromWindow(mWindowListHead->getHWND(), MONITOR_DEFAULTTOPRIMARY); // Get the monitor's extents. MONITORINFO monInfo; dMemset(&monInfo, 0, sizeof MONITORINFO); monInfo.cbSize = sizeof MONITORINFO; GetMonitorInfo(hMon, &monInfo); mCurtainWindow = CreateWindow(Win32Window::getCurtainWindowClassName(), dT(""), (WS_POPUP | WS_MAXIMIZE | WS_VISIBLE), monInfo.rcWork.left, monInfo.rcWork.top, monInfo.rcWork.right - monInfo.rcWork.left, monInfo.rcWork.bottom - monInfo.rcWork.top, NULL, NULL, NULL, NULL); if (!mOffscreenRender) SetWindowPos(mCurtainWindow, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); }
void CResizableStandAloneDialog::OnNcMButtonUp(UINT nHitTest, CPoint point) { WINDOWPLACEMENT windowPlacement; if ((nHitTest == HTMAXBUTTON) && GetWindowPlacement(&windowPlacement) && windowPlacement.showCmd == SW_SHOWNORMAL) { CRect rcWindowRect; GetWindowRect(&rcWindowRect); MONITORINFO mi = {0}; mi.cbSize = sizeof(MONITORINFO); if (m_bVertical) { rcWindowRect.top = m_rcOrgWindowRect.top; rcWindowRect.bottom = m_rcOrgWindowRect.bottom; } else if (GetMonitorInfo(MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST), &mi)) { m_rcOrgWindowRect.top = rcWindowRect.top; m_rcOrgWindowRect.bottom = rcWindowRect.bottom; rcWindowRect.top = mi.rcWork.top; rcWindowRect.bottom = mi.rcWork.bottom; } m_bVertical = !m_bVertical; //m_bHorizontal = m_bHorizontal; MoveWindow(&rcWindowRect); } CStandAloneDialogTmpl<CResizableDialog>::OnNcMButtonUp(nHitTest, point); }
void ConfigFileManager::CreateDownloadWindow(const DownloadDialogPtr& dialog) { if (m_pDownloadWindow != NULL) { delete m_pDownloadWindow; m_pDownloadWindow = NULL; } MONITORINFO mi = { 0 }; mi.cbSize = sizeof(mi); CHECK_WIN32_BOOL(GetMonitorInfo(MonitorFromWindow(NULL, MONITOR_DEFAULTTOPRIMARY), & mi), L"GetMonitorInfo"); int cx = 550; int cy = 250; m_pDownloadWindow = new DownloadWindow(dialog); // deletes itself m_pDownloadWindow->Create( (mi.rcWork.left + mi.rcWork.right) / 2 - cx / 2, (mi.rcWork.top + mi.rcWork.bottom) / 2 - cy / 2, cx, cy, dialog->caption.GetValue().c_str()); CHECK_BOOL(m_pDownloadWindow->hwnd != NULL, L"DownloadWindow::Create"); }
void CResizableStandAloneDialog::OnNcRButtonUp(UINT nHitTest, CPoint point) { WINDOWPLACEMENT windowPlacement; if ((nHitTest == HTMAXBUTTON) && GetWindowPlacement(&windowPlacement) && windowPlacement.showCmd == SW_SHOWNORMAL) { CRect rcWindowRect; GetWindowRect(&rcWindowRect); MONITORINFO mi = {0}; mi.cbSize = sizeof(MONITORINFO); if (m_bHorizontal) { rcWindowRect.left = m_rcOrgWindowRect.left; rcWindowRect.right = m_rcOrgWindowRect.right; } else if (GetMonitorInfo(MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST), &mi)) { m_rcOrgWindowRect.left = rcWindowRect.left; m_rcOrgWindowRect.right = rcWindowRect.right; rcWindowRect.left = mi.rcWork.left; rcWindowRect.right = mi.rcWork.right; } //m_bVertical = m_bVertical; m_bHorizontal = !m_bHorizontal; MoveWindow(&rcWindowRect); // WORKAROUND // for some reasons, when the window is resized horizontally, its menu size is not get adjusted. // so, we force it to happen. SetMenu(GetMenu()); } CStandAloneDialogTmpl<CResizableDialog>::OnNcRButtonUp(nHitTest, point); }
NS_IMETHODIMP nsScreenManagerWin :: ScreenForNativeWidget(void *aWidget, nsIScreen **outScreen) { HMONITOR mon = MonitorFromWindow ((HWND) aWidget, MONITOR_DEFAULTTOPRIMARY); *outScreen = CreateNewScreenObject (mon); return NS_OK; }
void win32_monitor_info(void *data, void *hm_data, unsigned *mon_id) { unsigned i, fs_monitor; settings_t *settings = config_get_ptr(); MONITORINFOEX *mon = (MONITORINFOEX*)data; HMONITOR *hm_to_use = (HMONITOR*)hm_data; if (!win32_monitor_last) win32_monitor_last = MonitorFromWindow(GetDesktopWindow(), MONITOR_DEFAULTTONEAREST); *hm_to_use = win32_monitor_last; fs_monitor = settings->video.monitor_index; if (fs_monitor && fs_monitor <= win32_monitor_count && win32_monitor_all[fs_monitor - 1]) { *hm_to_use = win32_monitor_all[fs_monitor - 1]; *mon_id = fs_monitor - 1; } else { for (i = 0; i < win32_monitor_count; i++) { if (win32_monitor_all[i] != *hm_to_use) continue; *mon_id = i; break; } } memset(mon, 0, sizeof(*mon)); mon->cbSize = sizeof(MONITORINFOEX); GetMonitorInfo(*hm_to_use, (MONITORINFO*)mon); }
void toggleFullscreen(bool isFullscreen) { MONITORINFO monitorInfo; dwStyle = GetWindowLong(hWindow, GWL_STYLE); if(isFullscreen) { if(dwStyle & WS_OVERLAPPEDWINDOW) { monitorInfo = { sizeof(MONITORINFO) }; if(GetWindowPlacement(hWindow, &wpPrev) && GetMonitorInfo(MonitorFromWindow(hWindow, MONITORINFOF_PRIMARY), &monitorInfo)) { SetWindowLong(hWindow, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW); SetWindowPos(hWindow, HWND_TOP, monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top, SWP_NOZORDER | SWP_FRAMECHANGED); } } ShowCursor(FALSE); } else { SetWindowLong(hWindow, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW); SetWindowPlacement(hWindow, &wpPrev); SetWindowPos(hWindow, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_FRAMECHANGED); ShowCursor(TRUE); } }
// Multi-monitor support. RECT d3d_monitor_rect(void *data) { d3d_video_t *d3d = (d3d_video_t*)data; Monitor::num_mons = 0; EnumDisplayMonitors(NULL, NULL, monitor_enum_proc, 0); if (!Monitor::last_hm) Monitor::last_hm = MonitorFromWindow(GetDesktopWindow(), MONITOR_DEFAULTTONEAREST); HMONITOR hm_to_use = Monitor::last_hm; unsigned fs_monitor = g_settings.video.monitor_index; if (fs_monitor && fs_monitor <= Monitor::num_mons && Monitor::all_hms[fs_monitor - 1]) { hm_to_use = Monitor::all_hms[fs_monitor - 1]; d3d->cur_mon_id = fs_monitor - 1; } else { for (unsigned i = 0; i < Monitor::num_mons; i++) { if (Monitor::all_hms[i] == hm_to_use) { d3d->cur_mon_id = i; break; } } } MONITORINFOEX current_mon; memset(¤t_mon, 0, sizeof(current_mon)); current_mon.cbSize = sizeof(MONITORINFOEX); GetMonitorInfo(hm_to_use, (MONITORINFO*)¤t_mon); return current_mon.rcMonitor; }
/** * \brief Update screen information. * * This function should be called in libvo's "control" callback * with parameter VOCTRL_UPDATE_SCREENINFO. * Note that this also enables the new API where geometry and aspect * calculations are done in video_out.c:config_video_out * * Global libvo variables changed: * xinerama_x * xinerama_y * vo_screenwidth * vo_screenheight */ static void w32_update_xinerama_info(struct vo *vo) { struct vo_w32_state *w32 = vo->w32; struct mp_vo_opts *opts = vo->opts; int screen = opts->fullscreen ? opts->fsscreen_id : opts->screen_id; vo->xinerama_x = vo->xinerama_y = 0; if (opts->fullscreen && screen == -2) { int tmp; vo->xinerama_x = GetSystemMetrics(SM_XVIRTUALSCREEN); vo->xinerama_y = GetSystemMetrics(SM_YVIRTUALSCREEN); tmp = GetSystemMetrics(SM_CXVIRTUALSCREEN); if (tmp) vo->opts->screenwidth = tmp; tmp = GetSystemMetrics(SM_CYVIRTUALSCREEN); if (tmp) vo->opts->screenheight = tmp; } else if (screen == -1) { MONITORINFO mi; HMONITOR m = MonitorFromWindow(w32->window, MONITOR_DEFAULTTOPRIMARY); mi.cbSize = sizeof(mi); GetMonitorInfoW(m, &mi); vo->xinerama_x = mi.rcMonitor.left; vo->xinerama_y = mi.rcMonitor.top; vo->opts->screenwidth = mi.rcMonitor.right - mi.rcMonitor.left; vo->opts->screenheight = mi.rcMonitor.bottom - mi.rcMonitor.top; } else if (screen >= 0) { w32->mon_cnt = 0; w32->mon_id = screen; EnumDisplayMonitors(NULL, NULL, mon_enum, (LONG_PTR)vo); } aspect_save_screenres(vo, vo->opts->screenwidth, vo->opts->screenheight); }
static void d3d_free(void *data) { d3d_video_t *d3d = (d3d_video_t*)data; d3d_deinitialize(d3d); #ifdef HAVE_OVERLAY d3d_free_overlays(d3d); #endif #ifdef HAVE_MENU d3d_free_overlay(d3d, d3d->rgui); #endif if (d3d->dev) d3d->dev->Release(); if (d3d->g_pD3D) d3d->g_pD3D->Release(); #ifdef HAVE_MONITOR Monitor::last_hm = MonitorFromWindow(d3d->hWnd, MONITOR_DEFAULTTONEAREST); #endif DestroyWindow(d3d->hWnd); if (d3d) free(d3d); #ifndef _XBOX UnregisterClass("RetroArch", GetModuleHandle(NULL)); #endif }
void Init() { CIniReader iniReader(""); res_x = iniReader.ReadInteger("MAIN", "ResX", 0); res_y = iniReader.ReadInteger("MAIN", "ResY", 0); hud_patch = iniReader.ReadInteger("MAIN", "FixHUD", 0); if (!res_x || !res_y) { HMONITOR monitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST); MONITORINFO info; info.cbSize = sizeof(MONITORINFO); GetMonitorInfo(monitor, &info); res_x = info.rcMonitor.right - info.rcMonitor.left; res_y = info.rcMonitor.bottom - info.rcMonitor.top; } CPatch::Nop(0x7A3B5E, 7); CPatch::SetUInt(0x7A3B72 + 0x2, res_x); CPatch::SetUInt(0x7A3B7B + 0x2, res_y); if (hud_patch) { fHudPos = (-1.0f * (4.0f / 3.0f)) / (static_cast<float>(res_x) / static_cast<float>(res_y)); fHudScale = (2.0f * (4.0f / 3.0f)) / (static_cast<float>(res_x) / static_cast<float>(res_y)); CPatch::SetFloat(0x756CF8 + 0x1, fHudPos); CPatch::SetPointer(0x756D23 + 0x2, &fHudScale); } }
/** * Resize the GL context. */ void PlatformResizeGLContext( FPlatformOpenGLDevice* Device, FPlatformOpenGLContext* Context, uint32 SizeX, uint32 SizeY, bool bFullscreen, bool bWasFullscreen, GLenum BackBufferTarget, GLuint BackBufferResource) { FScopeLock ScopeLock(Device->ContextUsageGuard); { uint32 WindowStyle = WS_CAPTION | WS_SYSMENU; uint32 WindowStyleEx = 0; HWND InsertAfter = HWND_NOTOPMOST; if (bFullscreen) { // Get the monitor info from the window handle. HMONITOR hMonitor = MonitorFromWindow(Context->WindowHandle, MONITOR_DEFAULTTOPRIMARY); MONITORINFOEX MonitorInfo; memset(&MonitorInfo, 0, sizeof(MONITORINFOEX)); MonitorInfo.cbSize = sizeof(MONITORINFOEX); GetMonitorInfo(hMonitor, &MonitorInfo); DEVMODE Mode; Mode.dmSize = sizeof(DEVMODE); Mode.dmBitsPerPel = 32; Mode.dmPelsWidth = SizeX; Mode.dmPelsHeight = SizeY; Mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; // Turn on fullscreen mode for the current monitor ChangeDisplaySettingsEx(MonitorInfo.szDevice, &Mode, NULL, CDS_FULLSCREEN, NULL); WindowStyle = WS_POPUP; WindowStyleEx = WS_EX_APPWINDOW | WS_EX_TOPMOST; InsertAfter = HWND_TOPMOST; } else if (bWasFullscreen) { ChangeDisplaySettings(NULL, 0); } //SetWindowLong(Context->WindowHandle, GWL_STYLE, WindowStyle); //SetWindowLong(Context->WindowHandle, GWL_EXSTYLE, WindowStyleEx); { FScopeContext ScopeContext(Context); if (Context->ViewportFramebuffer == 0) { glGenFramebuffers(1, &Context->ViewportFramebuffer); } glBindFramebuffer(GL_FRAMEBUFFER, Context->ViewportFramebuffer); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, BackBufferTarget, BackBufferResource, 0); #if UE_BUILD_DEBUG glReadBuffer(GL_COLOR_ATTACHMENT0); glDrawBuffer(GL_COLOR_ATTACHMENT0); #endif FOpenGL::CheckFrameBuffer(); glViewport(0, 0, SizeX, SizeY); static GLfloat ZeroColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; glClearBufferfv(GL_COLOR, 0, ZeroColor ); } } }
void ToggleFullscreen(HWND Window) { //WINDOWPLACEMENT WindowPosition = { sizeof(WINDOWPLACEMENT) }; //GetWindowPlacement(Window, &WindowPosition); // This follows Raymond Chen's prescription // for fullscreen toggling, see: // http://blogs.msdn.com/b/oldnewthing/archive/2010/04/12/9994016.aspx DWORD Style = GetWindowLongW(Window, GWL_STYLE); if (Style & WS_OVERLAPPEDWINDOW) { MONITORINFO MonitorInfo = { sizeof(MonitorInfo) }; if (GetWindowPlacement(Window, &WindowPosition) && GetMonitorInfoW(MonitorFromWindow(Window, MONITOR_DEFAULTTOPRIMARY), &MonitorInfo)) { SetWindowLongW(Window, GWL_STYLE, Style & ~WS_OVERLAPPEDWINDOW); SetWindowPos(Window, HWND_TOP, MonitorInfo.rcMonitor.left, MonitorInfo.rcMonitor.top, MonitorInfo.rcMonitor.right - MonitorInfo.rcMonitor.left, MonitorInfo.rcMonitor.bottom - MonitorInfo.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED); } } else { SetWindowLongW(Window, GWL_STYLE, Style | WS_OVERLAPPEDWINDOW); SetWindowPlacement(Window, &WindowPosition); SetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED); } }
LONG WINAPI ChangeDisplaySettingsHook(LPDEVMODEA lpDevMode, DWORD dwFlags) { DWORD pCaller; __asm {mov eax, [ebp+0x4]} __asm {mov pCaller, eax} fprintf(logFile, "* ChangeDisplaySettings: %x, caller: %x\n", dwFlags, pCaller); fprintf(logFile, "hWnd: %x\n", *g_hWnd); fprintf(logFile, "hRenderWnd: %x\n", *g_hRenderWnd); fprintf(logFile, "GetForegroundWindow: %x\n", GetForegroundWindow()); HWND hWnd = *g_hRenderWnd; char sWindowCaption[64]; sWindowCaption[0] = 0; GetWindowText(hWnd, sWindowCaption, 64); fprintf(logFile, "Window caption: %s\n", sWindowCaption); HMONITOR hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST); fprintf(logFile, "hMonitor: %x\n", hMonitor); MONITORINFOEX stMonitorInfo; memset(&stMonitorInfo, 0, sizeof(MONITORINFOEX)); stMonitorInfo.cbSize = sizeof(MONITORINFOEX); if(GetMonitorInfo(hMonitor, &stMonitorInfo)) { fprintf(logFile, "Got monitor info\n"); fprintf(logFile, "Device: %s\n", stMonitorInfo.szDevice); } else { fprintf(logFile, "MONITORINFO is NULL\n"); } fflush(logFile); return ChangeDisplaySettingsEx(NULL, lpDevMode, NULL, dwFlags, NULL); }