コード例 #1
0
ファイル: video.c プロジェクト: macressler/mame
void sdl_monitor_info::refresh()
{
	#if (SDLMAME_SDL2)
	SDL_DisplayMode dmode;

	#if defined(SDLMAME_WIN32)
	SDL_GetDesktopDisplayMode(m_handle, &dmode);
	#else
	SDL_GetCurrentDisplayMode(m_handle, &dmode);
	#endif
	SDL_Rect dimensions;
	SDL_GetDisplayBounds(m_handle, &dimensions);

	m_pos_size = SDL_Rect_to_osd_rect(dimensions);
	m_usuable_pos_size = SDL_Rect_to_osd_rect(dimensions);
	m_is_primary = (m_handle == 0);

	#else
	#if defined(SDLMAME_WIN32)  // Win32 version
	MONITORINFOEX info;
	info.cbSize = sizeof(info);
	GetMonitorInfo((HMONITOR)m_handle, (LPMONITORINFO)&info);
	m_pos_size = RECT_to_osd_rect(info.rcMonitor);
	m_usuable_pos_size = RECT_to_osd_rect(info.rcWork);
	m_is_primary = ((info.dwFlags & MONITORINFOF_PRIMARY) != 0);
	char *temp = utf8_from_wstring(info.szDevice);
	strncpy(m_name, temp, ARRAY_LENGTH(m_name) - 1);
	osd_free(temp);
	#elif defined(SDLMAME_MACOSX)   // Mac OS X Core Imaging version
	CGDirectDisplayID primary;
	CGRect dbounds;

	// get the main display
	primary = CGMainDisplayID();
	dbounds = CGDisplayBounds(primary);

	m_is_primary = (m_handle == 0);
	m_pos_size = osd_rect(0, 0, dbounds.size.width - dbounds.origin.x, dbounds.size.height - dbounds.origin.y);
	m_usuable_pos_size = m_pos_size;
	strncpy(m_name, "Mac OS X display", ARRAY_LENGTH(m_name) - 1);
	#elif defined(SDLMAME_X11) || defined(SDLMAME_NO_X11)       // X11 version
	{
		#if defined(SDLMAME_X11)
		// X11 version
		int screen;
		SDL_SysWMinfo info;
		SDL_VERSION(&info.version);

		if ( SDL_GetWMInfo(&info) && (info.subsystem == SDL_SYSWM_X11) )
		{
			screen = DefaultScreen(info.info.x11.display);
			SDL_VideoDriverName(m_name, ARRAY_LENGTH(m_name) - 1);
			m_pos_size = osd_rect(0, 0,
					DisplayWidth(info.info.x11.display, screen),
					DisplayHeight(info.info.x11.display, screen));

			/* FIXME: If Xinerame is used we should compile a list of monitors
			 * like we do for other targets and ignore SDL.
			 */
			if ((XineramaIsActive(info.info.x11.display)) && video_config.restrictonemonitor)
			{
				XineramaScreenInfo *xineinfo;
				int numscreens;

				xineinfo = XineramaQueryScreens(info.info.x11.display, &numscreens);

				m_pos_size = osd_rect(0, 0, xineinfo[0].width, xineinfo[0].height);

				XFree(xineinfo);
			}
			m_usuable_pos_size = m_pos_size;
			m_is_primary = (m_handle == 0);
		}
		else
		#endif // defined(SDLMAME_X11)
		{
			static int first_call=0;
			static int cw = 0, ch = 0;

			SDL_VideoDriverName(m_name, ARRAY_LENGTH(m_name) - 1);
			if (first_call==0)
			{
				const char *dimstr = osd_getenv(SDLENV_DESKTOPDIM);
				const SDL_VideoInfo *sdl_vi;

				sdl_vi = SDL_GetVideoInfo();
				#if (SDL_VERSION_ATLEAST(1,2,10))
				cw = sdl_vi->current_w;
				ch = sdl_vi->current_h;
				#endif
				first_call=1;
				if ((cw==0) || (ch==0))
				{
					if (dimstr != NULL)
					{
						sscanf(dimstr, "%dx%d", &cw, &ch);
					}
					if ((cw==0) || (ch==0))
					{
						osd_printf_warning("WARNING: SDL_GetVideoInfo() for driver <%s> is broken.\n", m_name);
						osd_printf_warning("         You should set SDLMAME_DESKTOPDIM to your desktop size.\n");
						osd_printf_warning("            e.g. export SDLMAME_DESKTOPDIM=800x600\n");
						osd_printf_warning("         Assuming 1024x768 now!\n");
						cw=1024;
						ch=768;
					}
				}
			}
			m_pos_size = osd_rect(0, 0, cw, ch);
			m_usuable_pos_size = m_pos_size;
			m_is_primary = (m_handle == 0);
		}
	}
	#elif defined(SDLMAME_OS2)      // OS2 version
	m_pos_size = osd_rect(0, 0,
			WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
			WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ) );
	m_usuable_pos_size = m_pos_size;
	m_is_primary = (m_handle == 0);
	strncpy(m_name, "OS/2 display", ARRAY_LENGTH(m_name) - 1);
	#else
	#error Unknown SDLMAME_xx OS type!
	#endif

	{
		static int info_shown=0;
		if (!info_shown)
		{
			osd_printf_verbose("SDL Device Driver     : %s\n", m_name);
			osd_printf_verbose("SDL Monitor Dimensions: %d x %d\n", m_pos_size.width(), m_pos_size.height());
			info_shown = 1;
		}
	}
	#endif //  (SDLMAME_SDL2)
}
コード例 #2
0
ファイル: BCGPDropDown.cpp プロジェクト: iclosure/jframework
//****************************************************************************************
void CBCGPDropDownFrame::RecalcLayout (BOOL /*bNotify*/) 
{
#ifdef _DEBUG
	if (m_pParentBtn != NULL)
	{
		ASSERT_VALID (m_pParentBtn);
		ASSERT (m_pParentBtn->m_pPopupMenu == this);
	}
#endif // _DEBUG
	
	if (!::IsWindow (m_hWnd) ||
		!::IsWindow (m_wndToolBar.m_hWnd))
	{
		return;
	}
	
	CBCGPToolBar* pParentBar = m_pParentBtn == NULL ? NULL :
	DYNAMIC_DOWNCAST (CBCGPToolBar, m_pParentBtn->m_pWndParent);
	
	BOOL bHorz = pParentBar->IsHorizontal ();
	
	CSize size = m_wndToolBar.CalcSize(bHorz);
	size.cx += iBorderSize * 3;
	size.cy += iBorderSize * 4;
	
	//---------------------------------------------
	// Adjust the menu position by the screen size:
	//---------------------------------------------
	CRect rectScreen;

	MONITORINFO mi;
	mi.cbSize = sizeof (MONITORINFO);
	if (GetMonitorInfo (MonitorFromPoint (CPoint (m_x, m_y), MONITOR_DEFAULTTONEAREST),
		&mi))
	{
		rectScreen = mi.rcWork;
	}
	else
	{
		::SystemParametersInfo (SPI_GETWORKAREA, 0, &rectScreen, 0);
	}

	if (m_x + size.cx > rectScreen.right)
	{
		//-----------------------------------------------------
		// Menu can't be overlapped with the parent popup menu!
		//-----------------------------------------------------
		CBCGPToolBar* pParentBar = m_pParentBtn == NULL ? NULL :
			DYNAMIC_DOWNCAST (CBCGPToolBar, m_pParentBtn->m_pWndParent);
		
		if (pParentBar != NULL && 
			(pParentBar->IsHorizontal ()) == 0)
		{
			//------------------------------------------------
			// Parent menu bar is docked vertical, place menu 
			// in the left or right side of the parent frame:
			//------------------------------------------------
			CRect rectParent;
			pParentBar->GetWindowRect (rectParent);
			
			m_x = rectParent.left - size.cx;
		}
		else
		{
			m_x = rectScreen.Width () - size.cx - 1;
		}
	}
	
	if (m_y + size.cy > rectScreen.bottom)
	{
		m_y -= size.cy;
		
		if (m_pParentBtn != NULL)
		{
			m_y -= m_pParentBtn->m_rect.Height () + 4;
		}
		else if (m_y < 0)
		{
			m_y = 0;
		}
	}
	
	SetWindowPos (NULL, m_x, m_y, size.cx, size.cy,
		SWP_NOZORDER | SWP_NOACTIVATE);
}
コード例 #3
0
ファイル: popup_thread.cpp プロジェクト: kmdtukl/miranda-ng
bool UpdatePopupPosition(PopupWnd2 *prev, PopupWnd2 *wnd)
{
    if (!wnd) return false;
    if (!PopupOptions.ReorderPopups && wnd->isPositioned()) return false;

    int POPUP_SPACING = PopupOptions.spacing;

    POINT pos = { 0 };
    SIZE prevSize = { 0 };
    if (prev)
        prevSize = prev->getSize();

    // we have only one monitor (cant check it together with 1.if)
    RECT rc;
    if (GetSystemMetrics(SM_CMONITORS) == 1)
        SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0);
    else { // Multimonitor stuff (we have more then 1)
        HWND hWnd;
        if (PopupOptions.Monitor == MN_MIRANDA)
            hWnd = pcli->hwndContactList;
        else //  PopupOptions.Monitor == MN_ACTIVE
            hWnd = GetForegroundWindow();

        HMONITOR hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTOPRIMARY);

        MONITORINFOEX mnti;
        mnti.cbSize = sizeof(MONITORINFOEX);
        if (GetMonitorInfo(hMonitor, &mnti) == TRUE)
            memcpy(&rc, &(mnti.rcWork), sizeof(RECT));
        else
            SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0);
    }

    rc.left += PopupOptions.gapLeft - POPUP_SPACING;
    rc.right -= PopupOptions.gapRight - POPUP_SPACING;
    rc.top += PopupOptions.gapTop - POPUP_SPACING;
    rc.bottom -= PopupOptions.gapBottom - POPUP_SPACING;
    if (PopupOptions.Spreading == SPREADING_VERTICAL) {
        switch (PopupOptions.Position) {
        case POS_UPPERLEFT:
            pos.x = rc.left + POPUP_SPACING;
            pos.y = (prev ? (prev->getPosition().y + prev->getSize().cy) : rc.top) + POPUP_SPACING;
            break;
        case POS_LOWERLEFT:
            pos.x = rc.left + POPUP_SPACING;
            pos.y = (prev ? prev->getPosition().y : rc.bottom) - wnd->getSize().cy - POPUP_SPACING;
            break;
        case POS_LOWERRIGHT:
            pos.x = rc.right - wnd->getSize().cx - POPUP_SPACING;
            pos.y = (prev ? prev->getPosition().y : rc.bottom) - wnd->getSize().cy - POPUP_SPACING;
            break;
        case POS_UPPERRIGHT:
            pos.x = rc.right - wnd->getSize().cx - POPUP_SPACING;
            pos.y = (prev ? (prev->getPosition().y + prev->getSize().cy) : rc.top) + POPUP_SPACING;
            break;
        }
    }
    else {
        switch (PopupOptions.Position) {
        case POS_UPPERLEFT:
            pos.x = (prev ? (prev->getPosition().x + prev->getSize().cx) : rc.left) + POPUP_SPACING;
            pos.y = rc.top + POPUP_SPACING;
            break;
        case POS_LOWERLEFT:
            pos.x = (prev ? (prev->getPosition().x + prev->getSize().cx) : rc.left) + POPUP_SPACING;
            pos.y = rc.bottom - wnd->getSize().cy - POPUP_SPACING;
            break;
        case POS_LOWERRIGHT:
            pos.x = (prev ? prev->getPosition().x : rc.right) - wnd->getSize().cx - POPUP_SPACING;
            pos.y = rc.bottom - wnd->getSize().cy - POPUP_SPACING;
            break;
        case POS_UPPERRIGHT:
            pos.x = (prev ? prev->getPosition().x : rc.right) - wnd->getSize().cx - POPUP_SPACING;
            pos.y = rc.top + POPUP_SPACING;
            break;
        }
    }
    wnd->setPosition(pos);
    return true;
}
コード例 #4
0
	void Win32EGLWindow::createNativeWindow( int &left, int &top, uint &width, uint &height, String &title )
	{
		// destroy current window, if any
		if (mWindow)
			destroy();

#ifdef OGRE_STATIC_LIB
		HINSTANCE hInst = GetModuleHandle( NULL );
#else
#  if OGRE_DEBUG_MODE == 1
		HINSTANCE hInst = GetModuleHandle("RenderSystem_GLES_d.dll");
#  else
		HINSTANCE hInst = GetModuleHandle("RenderSystem_GLES.dll");
#  endif
#endif

		mWindow = 0;
		mClosed = false;		
		mIsDepthBuffered = true;
		mColourDepth = mIsFullScreen? 32 : GetDeviceCaps(GetDC(0), BITSPIXEL);
		HWND parent = 0;
		bool vsync = false;
		String border;
		bool outerSize = false;
		bool hwGamma = false;
		int monitorIndex = -1;
		HMONITOR hMonitor = NULL;


		if (!mIsExternal)
		{
			DWORD		  dwStyle = WS_VISIBLE | WS_CLIPCHILDREN;
			DWORD		  dwStyleEx = 0;					
			MONITORINFOEX monitorInfoEx;
			RECT		  rc;

			// If we didn't specified the adapter index, or if it didn't find it
			if (hMonitor == NULL)
			{
				POINT windowAnchorPoint;

				// Fill in anchor point.
				windowAnchorPoint.x = left;
				windowAnchorPoint.y = top;


				// Get the nearest monitor to this window.
				hMonitor = MonitorFromPoint(windowAnchorPoint, MONITOR_DEFAULTTONEAREST);
			}

			// Get the target monitor info		
			memset(&monitorInfoEx, 0, sizeof(MONITORINFOEX));
			monitorInfoEx.cbSize = sizeof(MONITORINFOEX);
			GetMonitorInfo(hMonitor, &monitorInfoEx);

			//size_t devNameLen = strlen(monitorInfoEx.szDevice);
			//mDeviceName = new char[devNameLen + 1];

			//strcpy(mDeviceName, monitorInfoEx.szDevice);			


			// No specified top left -> Center the window in the middle of the monitor
			if (left == -1 || top == -1)
			{				
				int screenw = monitorInfoEx.rcMonitor.right  - monitorInfoEx.rcMonitor.left;
				int screenh = monitorInfoEx.rcMonitor.bottom - monitorInfoEx.rcMonitor.top;

				SetRect(&rc, 0, 0, width, height);
				AdjustWindowRect(&rc, dwStyle, false);

				// clamp window dimensions to screen size
				int outerw = (rc.right-rc.left < screenw)? rc.right-rc.left : screenw;
				int outerh = (rc.bottom-rc.top < screenh)? rc.bottom-rc.top : screenh;

				if (left == -1)
					left = monitorInfoEx.rcMonitor.left + (screenw - outerw) / 2;
				else if (monitorIndex != -1)
					left += monitorInfoEx.rcMonitor.left;

				if (top == -1)
					top = monitorInfoEx.rcMonitor.top + (screenh - outerh) / 2;
				else if (monitorIndex != -1)
					top += monitorInfoEx.rcMonitor.top;
			}
			else if (monitorIndex != -1)
			{
				left += monitorInfoEx.rcMonitor.left;
				top += monitorInfoEx.rcMonitor.top;
			}

			mWidth = width;
			mHeight = height;
			mTop = top;
			mLeft = left;

			if (mIsFullScreen)
			{
				dwStyle |= WS_POPUP;
				dwStyleEx |= WS_EX_TOPMOST;
				mTop = monitorInfoEx.rcMonitor.top;
				mLeft = monitorInfoEx.rcMonitor.left;											
			}
			else
			{				
				if (parent)
				{
					dwStyle |= WS_CHILD;
				}
				else
				{
					if (border == "none")
						dwStyle |= WS_POPUP;
					else if (border == "fixed")
						dwStyle |= WS_OVERLAPPED | WS_BORDER | WS_CAPTION |
						WS_SYSMENU | WS_MINIMIZEBOX;
					else
						dwStyle |= WS_OVERLAPPEDWINDOW;
				}

				int screenw = GetSystemMetrics(SM_CXSCREEN);
				int screenh = GetSystemMetrics(SM_CYSCREEN);

				if (!outerSize)
				{
					// Calculate window dimensions required
					// to get the requested client area
					SetRect(&rc, 0, 0, mWidth, mHeight);
					AdjustWindowRect(&rc, dwStyle, false);
					mWidth = rc.right - rc.left;
					mHeight = rc.bottom - rc.top;

					// Clamp window rect to the nearest display monitor.
					if (mLeft < monitorInfoEx.rcMonitor.left)
						mLeft = monitorInfoEx.rcMonitor.left;		

					if (mTop < monitorInfoEx.rcMonitor.top)					
						mTop = monitorInfoEx.rcMonitor.top;					

					if ((int)mWidth > monitorInfoEx.rcMonitor.right - mLeft)					
						mWidth = monitorInfoEx.rcMonitor.right - mLeft;	

					if ((int)mHeight > monitorInfoEx.rcMonitor.bottom - mTop)					
						mHeight = monitorInfoEx.rcMonitor.bottom - mTop;		
				}			
			}

			// register class and create window
			WNDCLASS wc = { CS_OWNDC, WindowEventUtilities::_WndProc, 0, 0, hInst,
				LoadIcon(NULL, IDI_APPLICATION), LoadCursor(NULL, IDC_ARROW),
				(HBRUSH)GetStockObject(BLACK_BRUSH), NULL, "OgreGLWindow" };
			RegisterClass(&wc);

			if (mIsFullScreen)
			{
				DEVMODE displayDeviceMode;

				memset(&displayDeviceMode, 0, sizeof(displayDeviceMode));
				displayDeviceMode.dmSize = sizeof(DEVMODE);
				displayDeviceMode.dmBitsPerPel = mColourDepth;
				displayDeviceMode.dmPelsWidth = mWidth;
				displayDeviceMode.dmPelsHeight = mHeight;
				displayDeviceMode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
/*
				if (mDisplayFrequency)
				{
					displayDeviceMode.dmDisplayFrequency = mDisplayFrequency;
					displayDeviceMode.dmFields |= DM_DISPLAYFREQUENCY;
					if (ChangeDisplaySettingsEx(mDeviceName, &displayDeviceMode, NULL, CDS_FULLSCREEN | CDS_TEST, NULL) != DISP_CHANGE_SUCCESSFUL)
					{
						LogManager::getSingleton().logMessage(LML_NORMAL, "ChangeDisplaySettings with user display frequency failed");
						displayDeviceMode.dmFields ^= DM_DISPLAYFREQUENCY;
					}
				}
				if (ChangeDisplaySettingsEx(mDeviceName, &displayDeviceMode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL)								
					LogManager::getSingleton().logMessage(LML_CRITICAL, "ChangeDisplaySettings failed");
*/

			}
			// Pass pointer to self as WM_CREATE parameter
			mWindow = CreateWindowEx(dwStyleEx, "OgreGLWindow", title.c_str(),
				dwStyle, mLeft, mTop, mWidth, mHeight, parent, 0, hInst, this);

			WindowEventUtilities::_addRenderWindow(this);

			LogManager::getSingleton().stream()
				<< "Created Win32Window '"
				<< mName << "' : " << mWidth << "x" << mHeight
				<< ", " << mColourDepth << "bpp";

		}

		RECT rc;
		// top and left represent outer window position
		GetWindowRect(mWindow, &rc);
		mTop = rc.top;
		mLeft = rc.left;
		// width and height represent drawable area only
		GetClientRect(mWindow, &rc);
		mWidth = rc.right;
		mHeight = rc.bottom;

		mNativeDisplay = GetDC(mWindow);
		mEglDisplay = eglGetDisplay(mNativeDisplay);
		mGLSupport->setGLDisplay(mEglDisplay);
		mEglSurface = createSurfaceFromWindow(mEglDisplay, mWindow);


	}
コード例 #5
0
ファイル: InitOutput.c プロジェクト: osch/cygwin-xserver
void
InitOutput(ScreenInfo * pScreenInfo, int argc, char *argv[])
{
    int i;

    if (serverGeneration == 1)
        XwinExtensionInit();

    /* Log the command line */
    winLogCommandLine(argc, argv);

#if CYGDEBUG
    winDebug("InitOutput\n");
#endif

    /* Validate command-line arguments */
    if (serverGeneration == 1 && !winValidateArgs()) {
        FatalError("InitOutput - Invalid command-line arguments found.  "
                   "Exiting.\n");
    }

#ifdef XWIN_XF86CONFIG
    /* Try to read the xorg.conf-style configuration file */
    if (!winReadConfigfile())
        winErrorFVerb(1, "InitOutput - Error reading config file\n");
#else
    winMsg(X_INFO, "xorg.conf is not supported\n");
    winMsg(X_INFO, "See http://x.cygwin.com/docs/faq/cygwin-x-faq.html "
           "for more information\n");
    winConfigFiles();
#endif

    /* Load preferences from XWinrc file */
    LoadPreferences();

    /* Setup global screen info parameters */
    pScreenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
    pScreenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
    pScreenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
    pScreenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
    pScreenInfo->numPixmapFormats = NUMFORMATS;

    /* Describe how we want common pixmap formats padded */
    for (i = 0; i < NUMFORMATS; i++) {
        pScreenInfo->formats[i] = g_PixmapFormats[i];
    }

    /* Load pointers to DirectDraw functions */
    winGetDDProcAddresses();

    /* Detect supported engines */
    winDetectSupportedEngines();
#ifdef XWIN_MULTIWINDOW
    /* Load libraries for taskbar grouping */
    winPropertyStoreInit();
#endif

    /* Store the instance handle */
    g_hInstance = GetModuleHandle(NULL);

    /* Create the messaging window */
    if (serverGeneration == 1)
        winCreateMsgWindowThread();

    /* Initialize each screen */
    for (i = 0; i < g_iNumScreens; ++i) {
        /* Initialize the screen */
        if (-1 == AddScreen(winScreenInit, argc, argv)) {
            FatalError("InitOutput - Couldn't add screen %d", i);
        }
    }

  /*
     Unless full xinerama has been explicitly enabled, register all native screens with pseudoramiX
  */
  if (!noPanoramiXExtension)
      noPseudoramiXExtension = TRUE;

  if ((g_ScreenInfo[0].fMultipleMonitors) && !noPseudoramiXExtension)
    {
      int pass;

      noRRXineramaExtension = TRUE;

      PseudoramiXExtensionInit();

      /* Add primary monitor on pass 0, other monitors on pass 1, to ensure
       the primary monitor is first in XINERAMA list */
      for (pass = 0; pass < 2; pass++)
        {
          int iMonitor;

          for (iMonitor = 1; ; iMonitor++)
            {
              struct GetMonitorInfoData data;
              QueryMonitor(iMonitor, &data);
              if (data.bMonitorSpecifiedExists)
                {
                  MONITORINFO mi;
                  mi.cbSize = sizeof(MONITORINFO);

                  if (GetMonitorInfo(data.monitorHandle, &mi))
                    {
                      /* pass == 1 XOR primary monitor flags is set */
                      if ((!(pass == 1)) != (!(mi.dwFlags & MONITORINFOF_PRIMARY)))
                        {
                          /*
                            Note the screen origin in a normalized coordinate space where (0,0) is at the top left
                            of the native virtual desktop area
                          */
                          data.monitorOffsetX = data.monitorOffsetX - GetSystemMetrics(SM_XVIRTUALSCREEN);
                          data.monitorOffsetY = data.monitorOffsetY - GetSystemMetrics(SM_YVIRTUALSCREEN);

                          winDebug ("InitOutput - screen %d added at virtual desktop coordinate (%d,%d) (pseudoramiX) \n",
                                    iMonitor-1, data.monitorOffsetX, data.monitorOffsetY);

                          PseudoramiXAddScreen(data.monitorOffsetX, data.monitorOffsetY,
                                               data.monitorWidth, data.monitorHeight);
                        }
                    }
                }
              else
                break;
            }
        }
    }

#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)

    /* Generate a cookie used by internal clients for authorization */
    if (g_fXdmcpEnabled || g_fAuthEnabled)
        winGenerateAuthorization();

    /* Perform some one time initialization */
    if (1 == serverGeneration) {
        /* Allow multiple threads to access Xlib */
        if (XInitThreads() == 0) {
            ErrorF("XInitThreads failed.\n");
        }

        /*
         * setlocale applies to all threads in the current process.
         * Apply locale specified in LANG environment variable.
         */
        if (!setlocale(LC_ALL, "")) {
            ErrorF("setlocale failed.\n");
        }

        /* See if X supports the current locale */
        if (XSupportsLocale() == FALSE) {
            ErrorF("Warning: Locale not supported by X, falling back to 'C' locale.\n");
            setlocale(LC_ALL, "C");
        }
    }
#endif

#if CYGDEBUG || YES
    winDebug("InitOutput - Returning.\n");
#endif
}
コード例 #6
0
ファイル: DisplayManager.cpp プロジェクト: malensek/3RVX
MONITORINFO DisplayManager::Info(HMONITOR monitor) {
    MONITORINFO mInfo = {};
    mInfo.cbSize = sizeof(MONITORINFO);
    GetMonitorInfo(monitor, &mInfo);
    return mInfo;
}
コード例 #7
0
ファイル: InternalWindow.cpp プロジェクト: k3a/Panther3D-2
//---------------------------------------------------------------------------
bool CInternalWindow::BeginSplash()
{
#ifdef _WIN32
	// load bitmap
	HANDLE hbmpSplash = LoadImage(GetModuleHandle( NULL ), _W("splash.bmp"), IMAGE_BITMAP, 0,0,
		LR_DEFAULTSIZE | LR_LOADFROMFILE); 
	if (!hbmpSplash) return false;

	// Register splash class
	WNDCLASS wc = { 0 };
	wc.lpfnWndProc = DefWindowProc;
	wc.hInstance = GetModuleHandle( NULL );
	wc.hIcon = NULL;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.lpszClassName = _W("P3DSplash");
	RegisterClass(&wc);

	// Create splash window and layered content widget
	m_hsplash = CreateWindow(_W("P3DSplash"), NULL, WS_POPUP,
		0, 0, 0, 0, NULL, NULL, wc.hInstance, NULL);
	HWND m_hlayered = CreateWindowEx(WS_EX_LAYERED, _W("P3DSplash"), NULL, WS_POPUP | WS_VISIBLE,
		0, 0, 0, 0, m_hsplash, NULL, wc.hInstance, NULL);

	// get the size of the bitmap
	BITMAP bm;
	GetObjectW(hbmpSplash, sizeof(bm), &bm);
	SIZE sizeSplash = { bm.bmWidth, bm.bmHeight };


	// get the primary monitor's info
	POINT ptZero = { 0 };
	HMONITOR hmonPrimary = MonitorFromPoint(ptZero, MONITOR_DEFAULTTOPRIMARY);
	MONITORINFO monitorinfo = { 0 };
	monitorinfo.cbSize = sizeof(monitorinfo);
	GetMonitorInfo(hmonPrimary, &monitorinfo);

	// center the splash screen in the middle of the primary work area
	const RECT & rcWork = monitorinfo.rcWork;

	POINT ptOrigin;
	ptOrigin.x = rcWork.left + (rcWork.right - rcWork.left - sizeSplash.cx) / 2;
	ptOrigin.y = rcWork.top + (rcWork.bottom - rcWork.top - sizeSplash.cy) / 2;

	// create a memory DC holding the splash bitmap
	HDC hdcScreen = GetDC(NULL);
	HDC hdcMem = CreateCompatibleDC(hdcScreen);
	HBITMAP hbmpOld = (HBITMAP) SelectObject(hdcMem, hbmpSplash);

	// use the source image's alpha channel for blending
	BLENDFUNCTION blend = { 0 };
	blend.BlendOp = AC_SRC_OVER;
	blend.SourceConstantAlpha = 255;
	blend.AlphaFormat = AC_SRC_ALPHA;

	// paint the window (in the right location) with the alpha-blended bitmap
	UpdateLayeredWindow(m_hlayered, hdcScreen, &ptOrigin, &sizeSplash,
		hdcMem, &ptZero, RGB(0, 0, 0), &blend, ULW_ALPHA);

	// delete temporary objects
	SelectObject(hdcMem, hbmpOld);
	DeleteDC(hdcMem);
	ReleaseDC(NULL, hdcScreen);
#elif defined(X_WIN_PRESENT)
	//load the splash image using Imlib2
	Imlib_Image image = imlib_load_image("splash.bmp");
	if(!image) return false;
	imlib_context_set_image(image);

	//obtain root window (current screen) attributes
	int screen = DefaultScreen(m_display);
	XWindowAttributes rootWinAttribs;
	XGetWindowAttributes
#endif
return true;
}
コード例 #8
0
int _tmain(int argc, _TCHAR* argv[])
{
	//----------------
	hLog = fopen("log.txt", "w");
	LPCTSTR path = L".\\options.ini";

	TCHAR stecilPicturePathResult[4096];
	TCHAR maskedPicturePathResult[4096];
	TCHAR serverPortResult[255];
	TCHAR serverIPResult[255];
	TCHAR listenUDPPortResult[255];
	TCHAR listenUDPIPResult[255];
	TCHAR colorResult[255];
	TCHAR shiftXResult[255];
	TCHAR shiftYResult[255];
	TCHAR isEyeWindowShowResult[255];
	TCHAR isEyePositionWindowShowResult[255];
	TCHAR isCalibrateResult[255];

	char buffer[4096];

	GetPrivateProfileString(_T("Base"), _T("stecilPicturePath"), _T(""), stecilPicturePathResult, sizeof(buffer), path);
	GetPrivateProfileString(_T("Base"), _T("maskedPicturePath"), _T(""), maskedPicturePathResult, sizeof(buffer), path);
	GetPrivateProfileString(_T("Base"), _T("serverPort"), _T(""), serverPortResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("serverIP"), _T(""), serverIPResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("listenUDPPort"), _T(""), listenUDPPortResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("listenUDPIP"), _T(""), listenUDPIPResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("color"), _T(""), colorResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("shiftX"), _T(""), shiftXResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("shiftY"), _T(""), shiftYResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("isEyeWindowShow"), _T(""), isEyeWindowShowResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("isEyePositionWindowShow"), _T(""), isEyePositionWindowShowResult, 255, path);
	GetPrivateProfileString(_T("Base"), _T("isCalibrate"), _T(""), isCalibrateResult, 255, path);

	int shiftXint = _ttoi(shiftXResult);
	int shiftYint = _ttoi(shiftYResult);
	int serverPortint = _ttoi(serverPortResult);
	int listenUDPPortint = _ttoi(listenUDPPortResult);
	desiredColor = wcstoul(colorResult, NULL, 0x10);

	char serverIPChar[255];
	wcstombs(serverIPChar, serverIPResult, wcslen(serverIPResult) + 1);

	char listenUDPIPChar[255];
	wcstombs(listenUDPIPChar, listenUDPIPResult, wcslen(listenUDPIPResult) + 1);

	bool isEyeWindowShowBool = false;
	bool isEyePositionWindowShow = false;
	bool isCalibrate = false;

	if(_tcscmp(isEyeWindowShowResult, L"true") == 0){
		isEyeWindowShowBool = true;
	} 
	if(_tcscmp(isEyePositionWindowShowResult, L"true") == 0){
		isEyePositionWindowShow = true;
	}
	if(_tcscmp(isCalibrateResult, L"true") == 0){
		isCalibrate = true;
	}
	
	//getchar();
    //return 0;

	// screenMasker.exe 757575 checker4px.pgm stencil.pgm 23 45 Y"
	// parse arguments
	//E:\OrlovPA\screenMasker\screenmasker\screenMasker_bin\screenMasker_bin\screenMasker.exe 757575 bg.pgm stencil.pgm 0
	//LPWSTR *argc;
	//LPWSTR bgPath;
	//wchar_t newBgPath[] = L"E:\\OrlovPA\\screenMasker\\screenmasker\\screenMasker_bin\\screenMasker_bin\\bg.pgm";
	//wchar_t newBgPath[] = maskedPicturePathResult;
	//LPWSTR stencilPath;
	//wchar_t newStencilPath[] = L"E:\\OrlovPA\\screenMasker\\screenmasker\\screenMasker_bin\\screenMasker_bin\\stencil.pgm";

	//int localstencilX, localstencilY, localCoursor;

	//wchar_t myColor = '757575';
	//const wchar_t * myColorAdress = &myColor;
	
	
	//desiredColor = wcstoul(L"1a3399", NULL, 0x10);

	//desiredColor = 757575;

	isCoursor = 1;

	// read background and stencil to buffers
	UINT8 *bytes;
	int width;
	int height;

	//bytes = readPGM(bgPath, &width, &height);
	bytes = readPGM(maskedPicturePathResult, &width, &height);
	//bytes = readPGM(newBgPath, &width, &height);

	if(bytes == NULL)
	{
		return 1;
	}

	bgBmpBytes = bytes;
	bgBmpWidth = width;
	bgBmpHeight = height;

	//bytes = readPGM(newStencilPath, &width, &height);
	bytes = readPGM(stecilPicturePathResult, &width, &height);
	
	if(bytes == NULL){
		return 1;
	}

	stencilBmpBytes = bytes;
	stencilBmpWidth = width;
	stencilBmpHeight = height;
	//----------------

	POINT pt = {};
	HMONITOR hMon;
	MONITORINFO monitorInfo = {};
	GetCursorPos(&pt); 
	hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);

	monitorInfo.cbSize = sizeof(MONITORINFO);
	GetMonitorInfo(hMon, &monitorInfo);

	mX = monitorInfo.rcMonitor.left;
	mY = monitorInfo.rcMonitor.top;
	mW = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
	mH = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;

	WNDCLASSEX wc;
	MSG msg;
	// Init wc
	wc.cbSize = sizeof( WNDCLASSEX );
	wc.style = 0;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = GetModuleHandle(0);
	wc.hIcon = NULL;
	wc.hCursor = LoadCursor( NULL, IDC_ARROW );
	wc.hbrBackground = NULL;
	wc.hIconSm = NULL;
	wc.lpszClassName = toString("animation_class");
	wc.lpszMenuName = NULL;

	// Register wc
	if ( !RegisterClassEx(&wc) ) {
		MessageBox( NULL, toString("Failed to register window class."), toString("Error"), MB_OK );
		return 0;
	}
	// Make window
	hwnd = CreateWindowEx(
		//WS_EX_APPWINDOW,
		WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TRANSPARENT,
		toString("animation_class"),
		toString("Animation"),
		WS_POPUP | WS_SYSMENU,
		mX, mY, mW, mH,
		NULL, NULL, GetModuleHandle(0), NULL );

	assert(hwnd);


	/*
	RECT rcClient, rcWindow;
	POINT ptDiff;
	// Get window and client sizes
	GetClientRect( hwnd, &rcClient );
	GetWindowRect( hwnd, &rcWindow );
	// Find offset between window size and client size
	ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
	ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
	// Resize client
	MoveWindow( hwnd, rcWindow.left, rcWindow.top, width + ptDiff.x, height + ptDiff.y, false);
	

	//UpdateLayeredWindow(hwnd, NULL, &ptDst, &siz, hdcOutBmp, &ptZero, 0, &blendFunc, ULW_ALPHA);

	//SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), 0x0, LWA_COLORKEY);
	*/

	ShowWindow( hwnd, SW_SHOWDEFAULT );
	UpdateWindow( hwnd );

	initGpuResources(	bgBmpBytes, 
		stencilBmpBytes, 
		bgBmpWidth, 
		bgBmpHeight, 
		stencilBmpHeight, 
		stencilBmpWidth, 
		mW, 
		mH	);


	//****************************
	AccuracyStruct accuracyData; 
	SystemInfoStruct systemInfoData; 
	CalibrationStruct calibrationData;
	int ret_calibrate = 0, ret_validate = 0, ret_connect = 0; 
	char c = ' ';
	char repeat = ' ';

	std::cout << "Output from iViewXAPI Demo"<< std::endl;

	// define logger 
	iV_SetLogger(1, "ScreenMasker.txt");
	std::cout << "ScreenMasker on iViewX API" << std::endl;

	// connect to iViewX 
	ret_connect = iV_Connect(serverIPChar, serverPortint, listenUDPIPChar, listenUDPPortint);
	

	switch(ret_connect)
	{
		case RET_SUCCESS:
			std::cout <<  "Connection was established successfully" << std::endl;

			// read out meta data from iViewX 
			std::cout << "GetSystemInfo: " << iV_GetSystemInfo(&systemInfoData) << std::endl;
			std::cout << "SystemInfo ETSystem: " << systemInfoData.iV_ETDevice << std::endl;
			std::cout << "SystemInfo iV_Version: " << systemInfoData.iV_MajorVersion << "." << systemInfoData.iV_MinorVersion << "." << systemInfoData.iV_Buildnumber << std::endl;
			std::cout << "SystemInfo API_Version: " << systemInfoData.API_MajorVersion << "." << systemInfoData.API_MinorVersion << "." << systemInfoData.API_Buildnumber << std::endl;
			std::cout << "SystemInfo samplerate: " << systemInfoData.samplerate << std::endl;

			break;
		case ERR_COULD_NOT_CONNECT:
			std::cout <<  "Connection could not be established" << std::endl;
			break;
		case ERR_WRONG_PARAMETER:
			std::cout <<  "Wrong Parameter used" << std::endl;
			break;
		default:
			std::cout <<  "Any other error appeared" << std::endl;
			return 0;
	}

	if(ret_connect == RET_SUCCESS)
	{
		calibrationData.method = 5;
		calibrationData.speed = 0;
		calibrationData.displayDevice = 0;
		calibrationData.targetShape = 20;
		calibrationData.foregroundBrightness = 250;
		calibrationData.backgroundBrightness = 100;
		calibrationData.autoAccept = 1;
		calibrationData.targetSize = 10;
		calibrationData.visualization = 1;
		strcpy(calibrationData.targetFilename, "");

		iV_SetupCalibration(&calibrationData);

		// start calibration
		//std::cout <<  "Do you want to calibrate? (y)es | (n)o" << std::endl;
		//c = getchar();

		if(isCalibrate){
			ret_calibrate = iV_Calibrate();

			switch(ret_calibrate){
				case RET_SUCCESS:
					std::cout <<  "Calibration done successfully" << std::endl;
					
					// start validation
					ret_validate = iV_Validate();

					break;
				case ERR_NOT_CONNECTED:
					std::cout <<  "iViewX is not reachable" << std::endl;
					break;
				case ERR_WRONG_PARAMETER:
					std::cout <<  "Wrong Parameter used" << std::endl;
					break;
				case ERR_WRONG_DEVICE:
					std::cout <<  "Not possible to calibrate connected Eye Tracking System" << std::endl;
					break;
				default:
					std::cout <<  "An unknown error appeared" << std::endl;
					break;
			}

		}

		// show accuracy only if validation was successful
		if(ret_validate == RET_SUCCESS){
			std::cout << "iV_GetAccuracy: " << iV_GetAccuracy(&accuracyData, 0) << std::endl;
			std::cout << "AccuracyData DevX: " << accuracyData.deviationLX << " DevY: " << accuracyData.deviationLY << std::endl;
			//getchar();

		}

		if(isEyeWindowShowBool){
			iV_ShowEyeImageMonitor();
		}
		
		if(isEyePositionWindowShow){
			iV_ShowTrackingMonitor();
			iV_ShowSceneVideoMonitor();
		}

		// start data output via callback function
		// define a callback function for receiving samples 
		iV_SetSampleCallback(SampleCallbackFunction);
		iV_SetTrackingMonitorCallback(TrackingMonitorCallbackFunction);

		while ( GetMessage(&msg, 0, 0, NULL) > 0 ) {
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		/*
		getchar();

		iV_SetSampleCallback(NULL);
		iV_SetTrackingMonitorCallback(NULL);

		std::cout << "iV_Disconnect: " << iV_Disconnect() << std::endl;

		getchar();
		*/
	}

	freeGpuResources();
	fclose(hLog);

	return 0;
}
コード例 #9
0
ファイル: DisplayDX.cpp プロジェクト: Requaos/electricsheep
/*
	createwindow().
	Creates a new window, _w * _h in size, optionally fullscreen.
*/
HWND CDisplayDX::createwindow( uint32 _w, uint32 _h, const bool _bFullscreen )
{
    m_bFullScreen = _bFullscreen;
    HMODULE    hInstance = GetModuleHandle(NULL);

    EnumMonitors();

    WNDCLASS   wndclass = {0};
    RECT       windowRect;
    SetRect( &windowRect, 0, 0, _w, _h );
    g_Log->Info( "CDisplayDX::createwindow x=%u y=%u w=%u h=%u", 0, 0, _w, _h);
    wndclass.style         = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc   = (WNDPROC)CDisplayDX::wndProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 0;
    wndclass.hInstance     = hInstance;
    wndclass.hIcon         = LoadIcon (GetModuleHandle(NULL), MAKEINTRESOURCE(1));
    wndclass.hCursor       = NULL;//LoadCursor (NULL, IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
    wndclass.lpszMenuName  = NULL;
    wndclass.lpszClassName = L"ElectricsheepWndClass";

    static bool wndclassAlreadyRegistered = false;
    if( wndclassAlreadyRegistered == false && !RegisterClass (&wndclass) )
    {
        return 0;
    }
    wndclassAlreadyRegistered = true;

    /*if( _bFullscreen )
    {
    	DEVMODE dmScreenSettings;
    	memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
    	dmScreenSettings.dmSize = sizeof(dmScreenSettings);
    	dmScreenSettings.dmPelsWidth	= _w;
    	dmScreenSettings.dmPelsHeight	= _h;
    	dmScreenSettings.dmBitsPerPel	= 32;
    	dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

    	if( ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL )
    		OutputDebugString("Failed to change display settings");
    }*/

    unsigned long exStyle;
    unsigned long style;
    if( _bFullscreen )
    {
        exStyle = WS_EX_APPWINDOW | WS_EX_TOPMOST;
        style = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    }
    else
    {
        exStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        style =  WS_OVERLAPPEDWINDOW |
                 WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    }

    AdjustWindowRectEx( &windowRect, style, false, exStyle );
    int ww = windowRect.right - windowRect.left;
    int hh = windowRect.bottom - windowRect.top;
    int xx = 0;
    int yy = 0;
    g_Log->Info( "CDisplayDX::createwindow AdjustWindowRectEx x=%u y=%u w=%u h=%u", 0, 0, ww, hh);
    MONITORINFO monitorInfo;

    for( DWORD iMonitor = 0; iMonitor < m_dwNumMonitors; iMonitor++ )
    {
        if (iMonitor == m_DesiredScreenID && _bFullscreen)
        {
            MonitorInfo *pMonitorInfo = &m_Monitors[iMonitor];
            monitorInfo.cbSize = sizeof(MONITORINFO);
            GetMonitorInfo( pMonitorInfo->hMonitor, &monitorInfo );
            pMonitorInfo->rcScreen = monitorInfo.rcMonitor;
            //SetWindowPos( hWnd, HWND_TOPMOST, monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top, SWP_NOACTIVATE );
            xx = monitorInfo.rcMonitor.left;
            yy = monitorInfo.rcMonitor.top;
            ww = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
            hh = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;
            g_Log->Info( "CDisplayDX::createwindow SetWindowPos x=%u y=%u w=%u h=%u",  monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.top, monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left, monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top);
        }
    }

    HWND hWnd = CreateWindowEx( exStyle, L"ElectricsheepWndClass", L"Electricsheep", style, xx, yy, ww, hh, NULL, NULL, hInstance, NULL );
    BlankUnusedMonitors(wndclass, hWnd, hInstance);
    return hWnd;
}
コード例 #10
0
static bool gfx_ctx_wgl_set_video_mode(void *data,
      unsigned width, unsigned height,
      bool fullscreen)
{
   DWORD style;
   MSG msg;
   RECT mon_rect;
   MONITORINFOEX current_mon;
   bool windowed_full;
   RECT rect   = {0};
   HMONITOR hm_to_use = NULL;
   driver_t *driver     = driver_get_ptr();
   settings_t *settings = config_get_ptr();

   monitor_info(&current_mon, &hm_to_use);

   mon_rect        = current_mon.rcMonitor;
   g_resize_width  = width;
   g_resize_height = height;
   windowed_full   = settings->video.windowed_fullscreen;

   if (fullscreen)
   {
      if (windowed_full)
      {
         style = WS_EX_TOPMOST | WS_POPUP;
         g_resize_width  = width  = mon_rect.right - mon_rect.left;
         g_resize_height = height = mon_rect.bottom - mon_rect.top;
      }
      else
      {
         style = WS_POPUP | WS_VISIBLE;

         if (!set_fullscreen(width, height, current_mon.szDevice))
            goto error;

         /* Display settings might have changed, get new coordinates. */
         GetMonitorInfo(hm_to_use, (MONITORINFO*)&current_mon);
         mon_rect = current_mon.rcMonitor;
         g_restore_desktop = true;
      }
   }
   else
   {
      style = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
      rect.right  = width;
      rect.bottom = height;
      AdjustWindowRect(&rect, style, FALSE);
      g_resize_width  = width  = rect.right - rect.left;
      g_resize_height = height = rect.bottom - rect.top;
   }

   g_hwnd = CreateWindowEx(0, "RetroArch", "RetroArch", style,
         fullscreen ? mon_rect.left : g_pos_x,
         fullscreen ? mon_rect.top  : g_pos_y,
         width, height,
         NULL, NULL, NULL, NULL);

   if (!g_hwnd)
      goto error;

   if (!fullscreen || windowed_full)
   {
      if (!fullscreen && settings->ui.menubar_enable)
      {
         RECT rc_temp = {0, 0, height, 0x7FFF};
         SetMenu(g_hwnd, LoadMenu(GetModuleHandle(NULL),MAKEINTRESOURCE(IDR_MENU)));
         SendMessage(g_hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&rc_temp);
         g_resize_height = height += rc_temp.top + rect.top;
         SetWindowPos(g_hwnd, NULL, 0, 0, width, height, SWP_NOMOVE);
      }

      ShowWindow(g_hwnd, SW_RESTORE);
      UpdateWindow(g_hwnd);
      SetForegroundWindow(g_hwnd);
      SetFocus(g_hwnd);
   }

   win32_show_cursor(!fullscreen);

   /* Wait until GL context is created (or failed to do so ...) */
   while (!g_inited && !g_quit && GetMessage(&msg, g_hwnd, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }

   if (g_quit)
      goto error;

   p_swap_interval = (BOOL (APIENTRY *)(int))wglGetProcAddress("wglSwapIntervalEXT");

   gfx_ctx_wgl_swap_interval(data, g_interval);

   driver->display_type  = RARCH_DISPLAY_WIN32;
   driver->video_display = 0;
   driver->video_window  = (uintptr_t)g_hwnd;

   return true;

error:
   gfx_ctx_wgl_destroy(data);
   return false;
}
コード例 #11
0
ファイル: common.c プロジェクト: BossKing/vlc
static int CommonControlSetFullscreen(vout_display_t *vd, bool is_fullscreen)
{
    vout_display_sys_t *sys = vd->sys;

#ifdef MODULE_NAME_IS_direct3d9
    if (sys->use_desktop && is_fullscreen)
        return VLC_EGENERIC;
#endif

    /* */
    if (sys->parent_window)
        return VLC_EGENERIC;

    /* */
    HWND hwnd = sys->hparent && sys->hfswnd ? sys->hfswnd : sys->hwnd;

    /* Save the current windows placement/placement to restore
       when fullscreen is over */
    WINDOWPLACEMENT window_placement;
    window_placement.length = sizeof(WINDOWPLACEMENT);
    GetWindowPlacement(hwnd, &window_placement);

    if (is_fullscreen) {
        msg_Dbg(vd, "entering fullscreen mode");

        /* Change window style, no borders and no title bar */
        SetWindowLong(hwnd, GWL_STYLE, WS_CLIPCHILDREN | WS_VISIBLE);

        if (sys->hparent) {
            /* Retrieve current window position so fullscreen will happen
            *on the right screen */
            HMONITOR hmon = MonitorFromWindow(sys->hparent,
                                              MONITOR_DEFAULTTONEAREST);
            MONITORINFO mi;
            mi.cbSize = sizeof(MONITORINFO);
            if (GetMonitorInfo(hmon, &mi))
                SetWindowPos(hwnd, 0,
                             mi.rcMonitor.left,
                             mi.rcMonitor.top,
                             mi.rcMonitor.right - mi.rcMonitor.left,
                             mi.rcMonitor.bottom - mi.rcMonitor.top,
                             SWP_NOZORDER|SWP_FRAMECHANGED);
        } else {
            /* Maximize non embedded window */
            ShowWindow(hwnd, SW_SHOWMAXIMIZED);
        }

        if (sys->hparent) {
            /* Hide the previous window */
            RECT rect;
            GetClientRect(hwnd, &rect);
            SetParent(sys->hwnd, hwnd);
            SetWindowPos(sys->hwnd, 0, 0, 0,
                         rect.right, rect.bottom,
                         SWP_NOZORDER|SWP_FRAMECHANGED);

            HWND topLevelParent = GetAncestor(sys->hparent, GA_ROOT);
            ShowWindow(topLevelParent, SW_HIDE);
        }
        SetForegroundWindow(hwnd);
    } else {
        msg_Dbg(vd, "leaving fullscreen mode");

        /* Change window style, no borders and no title bar */
        SetWindowLong(hwnd, GWL_STYLE, EventThreadGetWindowStyle(sys->event));

        if (sys->hparent) {
            RECT rect;
            GetClientRect(sys->hparent, &rect);
            SetParent(sys->hwnd, sys->hparent);
            SetWindowPos(sys->hwnd, 0, 0, 0,
                         rect.right, rect.bottom,
                         SWP_NOZORDER|SWP_FRAMECHANGED);

            HWND topLevelParent = GetAncestor(sys->hparent, GA_ROOT);
            ShowWindow(topLevelParent, SW_SHOW);
            SetForegroundWindow(sys->hparent);
            ShowWindow(hwnd, SW_HIDE);
        } else {
            /* return to normal window for non embedded vout */
            SetWindowPlacement(hwnd, &window_placement);
            ShowWindow(hwnd, SW_SHOWNORMAL);
        }
    }
    return VLC_SUCCESS;
}
コード例 #12
0
ファイル: removefriend.c プロジェクト: twonds/chesspark
struct Box_s *RemoveFriend_Create(struct Box_s *roster, char *name, char *group)
{
	struct Box_s *dialog;
	struct Box_s *pbox;
	struct removefrienddata_s *data = malloc(sizeof(*data));
	char gonnaremove[256];
	int x, y;

	{
		RECT windowrect;
		HMONITOR hm;
		MONITORINFO mi;

		windowrect.left = roster->x;
		windowrect.right = windowrect.left + roster->w - 1;
		windowrect.top = roster->y;
		windowrect.bottom = windowrect.top + roster->h - 1;

		hm = MonitorFromRect(&windowrect, MONITOR_DEFAULTTONEAREST);

		mi.cbSize = sizeof(mi);
		GetMonitorInfo(hm, &mi);

		x = mi.rcWork.left + (mi.rcWork.right - mi.rcWork.left - 432) / 2;
		y = mi.rcWork.top  + (mi.rcWork.bottom - mi.rcWork.top - 128) / 2;
	}

	dialog = Box_Create(x, y, 520, 128, BOX_VISIBLE);
	dialog->bgcol = DefaultBG;
	dialog->focus = dialog;
	dialog->OnKeyDown = RemoveFriend_OnKeyDown;

	i18n_stringsub(gonnaremove, 256, _("Remove %1 from Friends List?"), Model_GetFriendNick(name));
	
	dialog->titlebar = TitleBarOnly_Add(dialog, gonnaremove);
	dialog->OnActive = TitleBarRoot_OnActive;
	dialog->OnInactive = TitleBarRoot_OnInactive;

	gonnaremove[0] = 0;
	i18n_stringsub(gonnaremove, 256, _("Are you sure that you want to remove %1 from your friends list?"), Model_GetFriendNick(name));
	
	pbox = Box_Create(32, 48, 400, 16, BOX_TRANSPARENT | BOX_VISIBLE);
	pbox->fgcol = PresenceFG;
	Box_SetText(pbox, gonnaremove);
	Box_AddChild(dialog, pbox);

	if (group)
	{
		pbox = StdButton_Create(dialog->w - 500, 128 - 32, 170, _("Remove from all groups"), 0);
		Button2_SetOnButtonHit(pbox, RemoveFriend_OnRemoveAll);
		Box_AddChild(dialog, pbox);
	
		pbox = StdButton_Create(dialog->w - 310, 128 - 32, 170, _("Remove from this group"), 0);
		Button2_SetOnButtonHit(pbox, RemoveFriend_OnRemoveGroup);
		Box_AddChild(dialog, pbox);
	
		pbox = StdButton_Create(dialog->w - 120, 128 - 32, 100, _("Don't Remove"), 0);
		Button2_SetOnButtonHit(pbox, RemoveFriend_OnCancel);
		Box_AddChild(dialog, pbox);
	}
	else
	{
		pbox = StdButton_Create(dialog->w - 310, 128 - 32, 170, _("Remove from all groups"), 0);
		Button2_SetOnButtonHit(pbox, RemoveFriend_OnRemoveAll);
		Box_AddChild(dialog, pbox);
		
		pbox = StdButton_Create(dialog->w - 120, 128 - 32, 100, _("Don't Remove"), 0);
		Button2_SetOnButtonHit(pbox, RemoveFriend_OnCancel);
		Box_AddChild(dialog, pbox);
	}

	data->name = strdup(name);
	data->group = strdup(group);
	dialog->boxdata = data;

	Box_CreateWndCustom(dialog, _("Remove Friend"), roster->hwnd);
	
	BringWindowToTop(dialog->hwnd);

	return dialog;
}
コード例 #13
0
void Init()
{
	CIniReader iniReader("");
	res_x = iniReader.ReadInteger("MAIN", "X", 0);
	res_y = iniReader.ReadInteger("MAIN", "Y", 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;
	}

	if ((*(DWORD*)0x45E93B == 640))
	{
		CPatch::SetUInt(0x45E939 + 0x2, res_x);
		CPatch::SetUInt(0x45E93F + 0x3, res_y);

		CPatch::SetUInt(0x45E9A1 + 0x2, res_x);
		CPatch::SetUInt(0x45E9A7 + 0x3, res_y);

		CPatch::SetUInt(0x45EA09 + 0x2, res_x);
		CPatch::SetUInt(0x45EA0F + 0x3, res_y);

		CPatch::SetUInt(0x45EA71 + 0x2, res_x);
		CPatch::SetUInt(0x45EA77 + 0x3, res_y);

		CPatch::SetUInt(0x45EAD9 + 0x2, res_x);
		CPatch::SetUInt(0x45EADF + 0x3, res_y);


		CPatch::SetUInt(0x45EB3D + 0x1, res_x);
		CPatch::SetUInt(0x45EB48 + 0x1, res_y);

		CPatch::SetFloat(0x9B38EC, static_cast<float>(res_x) / static_cast<float>(res_y));
	}
	else
	{
		/*CPatch::SetUInt(0x946A37 + 0x4, res_x);
		CPatch::SetUInt(0x946A3F + 0x4, res_y);

		CPatch::SetUInt(0x9469FE + 0x4, res_x);
		CPatch::SetUInt(0x946A06 + 0x4, res_y);

		CPatch::SetUInt(0x9469C5 + 0x4, res_x);
		CPatch::SetUInt(0x9469CD + 0x4, res_y);

		CPatch::SetUInt(0x946995 + 0x4, res_x);
		CPatch::SetUInt(0x94699D + 0x4, res_y);

		CPatch::SetUInt(0x946964 + 0x4, res_x);
		CPatch::SetUInt(0x94696C + 0x4, res_y);


		//CPatch::SetUInt(0x45EB3D + 0x1, res_x);
		//CPatch::SetUInt(0x45EB48 + 0x1, res_y);
		CPatch::RedirectJump(0x41FD70, asm_patch);

		CPatch::SetFloat(0x9B38EC, static_cast<float>(res_x) / static_cast<float>(res_y));*/
	}
}
コード例 #14
0
ファイル: ConEmuCtrl.cpp プロジェクト: alexlav/conemu
void CConEmuCtrl::MakeScreenshot(bool abFullscreen /*= false*/)
{
	BOOL lbRc = FALSE;
	HDC hScreen = NULL;
	RECT rcWnd = {};
	HWND hWnd = GetForegroundWindow();

	if (!hWnd)
	{
		DisplayLastError(L"GetForegroundWindow() == NULL");
		return;
	}

	HMONITOR hMon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
	MONITORINFO mi = {sizeof(mi)};
	if (!GetMonitorInfo(hMon, &mi))
	{
		DisplayLastError(L"GetMonitorInfo() failed");
		return;
	}

	if (!abFullscreen)
	{
		GetWindowRect(hWnd, &rcWnd);
		bool bDlg = ((GetWindowLongPtr(hWnd, GWL_STYLE) & DS_MODALFRAME) == DS_MODALFRAME);
		if (gpConEmu->IsGlass())
		{
			if (bDlg && (gnOsVer == 0x601))
			{
				rcWnd.top -= 5;
				rcWnd.left -= 5;
				rcWnd.right += 3;
				rcWnd.bottom += 5;
			}
			else if (gnOsVer >= 0x602)
			{
				if (bDlg)
				{
					rcWnd.top -= 5;
					rcWnd.left -= 5;
					rcWnd.right += 3;
					rcWnd.bottom += 5;
				}
				else
				{
					rcWnd.left += 2;
					rcWnd.right -= 2;
					rcWnd.bottom -= 2;
				}
			}
		}

		// Отрезать края при Zoomed/Fullscreen
		RECT rcVisible = {};
		if (!IntersectRect(&rcVisible, &rcWnd, gpConEmu->isFullScreen() ? &mi.rcMonitor : &mi.rcWork))
		{
			DisplayLastError(L"Window out of monitor rectangle");
			return;
		}
		rcWnd = rcVisible;
	}
	else
	{
		rcWnd = mi.rcMonitor;
	}

	hScreen = GetDC(NULL);

	lbRc = DumpImage(hScreen, NULL, rcWnd.left, rcWnd.top, rcWnd.right-rcWnd.left, rcWnd.bottom-rcWnd.top, NULL, FALSE/*NoTransparency, 24bit*/);

	if (!lbRc)
	{
		DisplayLastError(L"Creating screenshot failed!");
	}

	ReleaseDC(NULL, hScreen);
}
コード例 #15
0
ファイル: SnapPlus.cpp プロジェクト: ggponti/SnapPlus
int CALLBACK WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,	LPSTR lpCmdLine,int nCmdShow )
{
	HWND hwnd = NULL;
	
	RegisterHotKey( hwnd, TOP_LEFT, MOD_CONTROL|MOD_WIN, VK_NUMPAD7 );
	RegisterHotKey( hwnd, TOP, MOD_CONTROL|MOD_WIN, VK_NUMPAD8 );
	RegisterHotKey( hwnd, TOP_RIGHT, MOD_CONTROL|MOD_WIN, VK_NUMPAD9 );

	RegisterHotKey( hwnd, CENTER_LEFT, MOD_CONTROL|MOD_WIN, VK_NUMPAD4 );
	RegisterHotKey( hwnd, CENTER, MOD_CONTROL|MOD_WIN, VK_NUMPAD5 );
	RegisterHotKey( hwnd, CENTER_RIGHT, MOD_CONTROL|MOD_WIN, VK_NUMPAD6 );

	RegisterHotKey( hwnd, BOTTOM_LEFT, MOD_CONTROL|MOD_WIN, VK_NUMPAD1 );
	RegisterHotKey( hwnd, BOTTOM, MOD_CONTROL|MOD_WIN, VK_NUMPAD2 );
	RegisterHotKey( hwnd, BOTTOM_RIGHT, MOD_CONTROL|MOD_WIN, VK_NUMPAD3 );
	

	if( RegisterHotKey( hwnd, EXIT, MOD_CONTROL|MOD_WIN, VK_NUMPAD0 ) )
	{
		MSG msg;
		while( GetMessage( &msg, NULL, 0, 0 ) != 0 )
		{
			if( msg.message = WM_HOTKEY )
			{
				HWND hwndActive = GetForegroundWindow();
				RECT rect;
				GetWindowRect( hwndActive, &rect );
				HMONITOR hmonitor = MonitorFromWindow( hwndActive, MONITOR_DEFAULTTONULL );
				MONITORINFO mi;
				mi.cbSize = sizeof( MONITORINFO );
				GetMonitorInfo( hmonitor, &mi );
				
				int x = rect.left;
				int y = rect.top;

				switch( ( WINDOW_POSITION )msg.wParam )
				{
					case TOP_LEFT:
						x = mi.rcWork.left;
						y = mi.rcWork.top;
						break;

					case TOP:
						x = mi.rcWork.left + ( ( ( mi.rcWork.right - mi.rcWork.left ) - ( rect.right - rect.left ) ) / 2 );
						y = mi.rcWork.top;
						break;

					case TOP_RIGHT:
						x = mi.rcWork.right - ( rect.right - rect.left );
						y = mi.rcWork.top;
						break;

					case CENTER_LEFT:
						x = mi.rcWork.left;
						y = mi.rcWork.top + ( ( ( mi.rcWork.bottom - mi.rcWork.top ) - ( rect.bottom - rect.top ) ) / 2 );
						break;

					case CENTER:
						x = mi.rcWork.left + ( ( ( mi.rcWork.right - mi.rcWork.left ) - ( rect.right - rect.left ) ) / 2 );
						y = mi.rcWork.top + ( ( ( mi.rcWork.bottom - mi.rcWork.top ) - ( rect.bottom - rect.top ) ) / 2 );
						break;

					case CENTER_RIGHT:
						x = mi.rcWork.right - ( rect.right - rect.left );
						y = mi.rcWork.top + ( ( ( mi.rcWork.bottom - mi.rcWork.top ) - ( rect.bottom - rect.top ) ) / 2 );
						break;

					case BOTTOM_LEFT:
						x = mi.rcWork.left;
						y = mi.rcWork.bottom - ( rect.bottom - rect.top );
						break;

					case BOTTOM:
						x = mi.rcWork.left + ( ( ( mi.rcWork.right - mi.rcWork.left ) - ( rect.right - rect.left ) ) / 2 );
						y = mi.rcWork.bottom - ( rect.bottom - rect.top );
						break;

					case BOTTOM_RIGHT:
						x = mi.rcWork.right - ( rect.right - rect.left );
						y = mi.rcWork.bottom - ( rect.bottom - rect.top );
						break;
				}

				SetWindowPos( hwndActive, HWND_TOP, x, y, 0, 0, SWP_NOSIZE );
				if(  msg.message == WM_QUIT	 || msg.wParam == EXIT ) break;
			}
		}
		UnregisterHotKey( hwnd, TOP_LEFT );
		UnregisterHotKey( hwnd, TOP );
		UnregisterHotKey( hwnd, TOP_RIGHT );
		UnregisterHotKey( hwnd, CENTER_LEFT );
		UnregisterHotKey( hwnd, CENTER );
		UnregisterHotKey( hwnd, CENTER_RIGHT );
		UnregisterHotKey( hwnd, BOTTOM_LEFT );
		UnregisterHotKey( hwnd, BOTTOM );
		UnregisterHotKey( hwnd, BOTTOM_RIGHT );
		UnregisterHotKey( hwnd, EXIT );
	}
}
コード例 #16
0
void HMDDeviceFactory::EnumerateDevices(EnumerateVisitor& visitor)
{
    MonitorSet monitors;
    monitors.MonitorCount = 0;
    // Get all the monitor handles 
    EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
    
   // DeviceManager* manager = getManager();
    DISPLAY_DEVICE dd, ddm;
    UINT           i, j;    

    for (i = 0; 
        (ZeroMemory(&dd, sizeof(dd)), dd.cb = sizeof(dd),
        EnumDisplayDevices(0, i, &dd, 0)) != 0;  i++)
    {
        
        /*
        wchar_t buff[500], flagsBuff[200];
        
        swprintf_s(buff, 500, L"\nDEV: \"%s\" \"%s\" 0x%08x=%s\n     \"%s\" \"%s\"\n",
            dd.DeviceName, dd.DeviceString,
            dd.StateFlags, FormatDisplayStateFlags(flagsBuff, 200, dd.StateFlags),
            dd.DeviceID, dd.DeviceKey);
        ::OutputDebugString(buff);
        */

        for (j = 0; 
            (ZeroMemory(&ddm, sizeof(ddm)), ddm.cb = sizeof(ddm),
            EnumDisplayDevices(dd.DeviceName, j, &ddm, 0)) != 0;  j++)
        {
            /*
            wchar_t mbuff[500];
            swprintf_s(mbuff, 500, L"MON: \"%s\" \"%s\" 0x%08x=%s\n     \"%s\" \"%s\"\n",
                ddm.DeviceName, ddm.DeviceString,
                ddm.StateFlags, FormatDisplayStateFlags(flagsBuff, 200, ddm.StateFlags),
                ddm.DeviceID, ddm.DeviceKey);
            ::OutputDebugString(mbuff);
            */

            // Our monitor hardware has string "RTD2205" in it
            // Nate's device "CVT0003"
            if (wcsstr(ddm.DeviceID, L"RTD2205") || 
                wcsstr(ddm.DeviceID, L"CVT0003") || 
                wcsstr(ddm.DeviceID, L"MST0030") ||
                wcsstr(ddm.DeviceID, L"OVR00") ) // Part of Oculus EDID.
            {
                String deviceId(ddm.DeviceID);
                String displayDeviceName(ddm.DeviceName);

                // The default monitor coordinates
                int mx      = 0;
                int my      = 0;
                int mwidth  = 1280;
                int mheight = 800;

                // Find the matching MONITORINFOEX for this device so we can get the 
                // screen coordinates
                MONITORINFOEX info;
                for (int m=0; m < monitors.MonitorCount; m++)
                {
                    info.cbSize = sizeof(MONITORINFOEX);
                    GetMonitorInfo(monitors.Monitors[m], &info);
                    if (_tcsstr(ddm.DeviceName, info.szDevice) == ddm.DeviceName)
                    {   // If the device name starts with the monitor name
                        // then we found the matching DISPLAY_DEVICE and MONITORINFO
                        // so we can gather the monitor coordinates
                        mx = info.rcMonitor.left;
                        my = info.rcMonitor.top;
                        //mwidth = info.rcMonitor.right - info.rcMonitor.left;
                        //mheight = info.rcMonitor.bottom - info.rcMonitor.top;
                        break;
                    }
                }

                HMDDeviceCreateDesc hmdCreateDesc(this, deviceId, displayDeviceName);

                if (hmdCreateDesc.Is7Inch())
                {
                    // Physical dimension of SLA screen.
                    hmdCreateDesc.SetScreenParameters(mx, my, mwidth, mheight, 0.14976f, 0.0936f);
                }
                else
                {
                    hmdCreateDesc.SetScreenParameters(mx, my, mwidth, mheight, 0.12096f, 0.0756f);
                }

                OVR_DEBUG_LOG_TEXT(("DeviceManager - HMD Found %s - %s\n",
                                    deviceId.ToCStr(), displayDeviceName.ToCStr()));

                // Notify caller about detected device. This will call EnumerateAddDevice
                // if the this is the first time device was detected.
                visitor.Visit(hmdCreateDesc);
                break;
            }

          
            
        }
    }

}
コード例 #17
0
ファイル: common.c プロジェクト: FLYKingdom/vlc
void Win32ToggleFullscreen( vout_thread_t *p_vout )
{
    HWND hwnd = (p_vout->p_sys->hparent && p_vout->p_sys->hfswnd) ?
        p_vout->p_sys->hfswnd : p_vout->p_sys->hwnd;

    /* Save the current windows placement/placement to restore
       when fullscreen is over */
    WINDOWPLACEMENT window_placement = getWindowState( hwnd );

    p_vout->b_fullscreen = ! p_vout->b_fullscreen;

    /* We want to go to Fullscreen */
    if( p_vout->b_fullscreen )
    {
        msg_Dbg( p_vout, "entering fullscreen mode" );

        /* Change window style, no borders and no title bar */
        int i_style = WS_CLIPCHILDREN | WS_VISIBLE;
        SetWindowLong( hwnd, GWL_STYLE, i_style );

        if( p_vout->p_sys->hparent )
        {
#ifdef UNDER_CE
            POINT point = {0,0};
            RECT rect;
            ClientToScreen( p_vout->p_sys->hwnd, &point );
            GetClientRect( p_vout->p_sys->hwnd, &rect );
            SetWindowPos( hwnd, 0, point.x, point.y,
                          rect.right, rect.bottom,
                          SWP_NOZORDER|SWP_FRAMECHANGED );
#else
            /* Retrieve current window position so fullscreen will happen
            *on the right screen */
            HMONITOR hmon = MonitorFromWindow(p_vout->p_sys->hparent,
                                            MONITOR_DEFAULTTONEAREST);
            MONITORINFO mi;
            if (GetMonitorInfo(hmon, &mi))
            SetWindowPos( hwnd, 0,
                            mi.rcMonitor.left,
                            mi.rcMonitor.top,
                            mi.rcMonitor.right - mi.rcMonitor.left,
                            mi.rcMonitor.bottom - mi.rcMonitor.top,
                            SWP_NOZORDER|SWP_FRAMECHANGED );
#endif
        }
        else
        {
            /* Maximize non embedded window */
            ShowWindow( hwnd, SW_SHOWMAXIMIZED );
        }

        if( p_vout->p_sys->hparent )
        {
            /* Hide the previous window */
            RECT rect;
            GetClientRect( hwnd, &rect );
            SetParent( p_vout->p_sys->hwnd, hwnd );
            SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
                          rect.right, rect.bottom,
                          SWP_NOZORDER|SWP_FRAMECHANGED );

#ifdef UNDER_CE
            HWND topLevelParent = GetParent( p_vout->p_sys->hparent );
#else
            HWND topLevelParent = GetAncestor( p_vout->p_sys->hparent, GA_ROOT );
#endif
            ShowWindow( topLevelParent, SW_HIDE );
        }

        SetForegroundWindow( hwnd );
    }
    else
    {
        msg_Dbg( p_vout, "leaving fullscreen mode" );
        /* Change window style, no borders and no title bar */
        SetWindowLong( hwnd, GWL_STYLE, p_vout->p_sys->i_window_style );

        if( p_vout->p_sys->hparent )
        {
            RECT rect;
            GetClientRect( p_vout->p_sys->hparent, &rect );
            SetParent( p_vout->p_sys->hwnd, p_vout->p_sys->hparent );
            SetWindowPos( p_vout->p_sys->hwnd, 0, 0, 0,
                          rect.right, rect.bottom,
                          SWP_NOZORDER|SWP_FRAMECHANGED );

#ifdef UNDER_CE
            HWND topLevelParent = GetParent( p_vout->p_sys->hparent );
#else
            HWND topLevelParent = GetAncestor( p_vout->p_sys->hparent, GA_ROOT );
#endif
            ShowWindow( topLevelParent, SW_SHOW );
            SetForegroundWindow( p_vout->p_sys->hparent );
            ShowWindow( hwnd, SW_HIDE );
        }
        else
        {
            /* return to normal window for non embedded vout */
            SetWindowPlacement( hwnd, &window_placement );
            ShowWindow( hwnd, SW_SHOWNORMAL );
        }

        /* Make sure the mouse cursor is displayed */
        PostMessage( p_vout->p_sys->hwnd, WM_VLC_SHOW_MOUSE, 0, 0 );
    }

    /* Update the object variable and trigger callback */
    var_SetBool( p_vout, "fullscreen", p_vout->b_fullscreen );
}
コード例 #18
0
// ----------------------------------------------------------------------
//  Windows proc for the one and only window in this app.
//
// ----------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HBRUSH   hbrLit = NULL;
    static HBRUSH   hbrUnlit = NULL;
    static HFONT    hFont = NULL;
    static UINT_PTR nTimerId = 101;

    switch (message)
    {
        case WM_CREATE:
        {
            // Make BLACK the transparency color
            SetLayeredWindowAttributes(hWnd, RGB(0,0,0), 0, LWA_COLORKEY);

            // Initialize the DPI scalar.
            InitializeDPIScale(hWnd);

            // Create brushes and font that will be used in WM_PAINT
            hbrLit = CreateSolidBrush(RGB(0,128,255));
            hbrUnlit = CreateSolidBrush(RGB(0,64,128));
            hFont = CreateFont(DPIScale(64), 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, 0, 0, 0, 0, 0, L"Segoe UI");

            // Position at the center of the primary monitor
            POINT const ptZeroZero = {};
            HMONITOR hMonitor = MonitorFromPoint(ptZeroZero, MONITOR_DEFAULTTOPRIMARY);
            MONITORINFO mi = {sizeof(mi)};
            GetMonitorInfo(hMonitor, &mi);

            SIZE const size = { g_currentVolume.cSteps * DPIScale(10), DPIScale(60) };

            POINT const pt = 
            {
                mi.rcMonitor.left + (mi.rcMonitor.left + mi.rcMonitor.right - size.cx) / 2, 
                mi.rcMonitor.top + (mi.rcMonitor.top + mi.rcMonitor.bottom - size.cy) / 2
            };

            SetWindowPos(hWnd, HWND_TOPMOST, pt.x, pt.y, size.cx, size.cy, SWP_SHOWWINDOW);

            break;
        }

        case WM_DESTROY:
        {
            DeleteObject(hbrLit);
            DeleteObject(hbrUnlit);
            DeleteObject(hFont);

            PostQuitMessage(0);
            return 0;
        }

        case WM_ERASEBKGND:
        {
            // Don't do any erasing here.  It's done in WM_PAINT to avoid flicker.
            return 1;
        }

        case WM_VOLUMECHANGE:
        {
            // get the new volume level
            g_pVolumeMonitor->GetLevelInfo(&g_currentVolume);

            // make window visible for 2 seconds
            ShowWindow(hWnd, SW_SHOW);
            InvalidateRect(hWnd, NULL, TRUE);

            nTimerId = SetTimer(hWnd, 101, 2000, NULL);

            return 0;
        }

        case WM_ENDPOINTCHANGE:
        {
            g_pVolumeMonitor->ChangeEndpoint();
            return 0;
        }

        case WM_TIMER:
        {
            // make the window go away
            ShowWindow(hWnd, SW_HIDE);
            KillTimer(hWnd, nTimerId);

            return 0;
        }

        case WM_PAINT:
        {
            PAINTSTRUCT     ps;
            HPAINTBUFFER    hBufferedPaint = NULL;
            RECT            rc;

            GetClientRect(hWnd, &rc);
            HDC hdc = BeginPaint(hWnd, &ps);

            if (g_bDblBuffered)
            {
                // Get doublebuffered DC
                HDC hdcMem;
                hBufferedPaint = BeginBufferedPaint(hdc, &rc, BPBF_COMPOSITED, NULL, &hdcMem);
                if (hBufferedPaint)
                {
                    hdc = hdcMem;
                }
            }

            // black background (transparency color)
            FillRect(hdc, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));

            // Draw LEDs
            for (UINT i = 0; i < (g_currentVolume.cSteps-1); i++)
            {
                RECT const rcLed = { DPIScale(i * 10), DPIScale(10), DPIScale(i * 10 + 8), rc.bottom-DPIScale(15) };

                if ((i < g_currentVolume.nStep) && (!g_currentVolume.bMuted))
                    FillRect(hdc, &rcLed, hbrLit);
                else
                    FillRect(hdc, &rcLed, hbrUnlit);
            }

            if (g_currentVolume.bMuted)
            {
                HGDIOBJ hof = SelectObject(hdc, hFont);
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(255, 64, 64));
                RECT rcText = rc;
                rcText.bottom -= DPIScale(11);
                DrawText(hdc, L"MUTED", -1, &rcText, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
                SelectObject(hdc, hof);
            }

            if (hBufferedPaint)
            {
                // end painting
                BufferedPaintMakeOpaque(hBufferedPaint, NULL);
                EndBufferedPaint(hBufferedPaint, TRUE);
            }

            EndPaint(hWnd, &ps);
            return 0;
        }
    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}
コード例 #19
0
ファイル: ViWm.win32.cpp プロジェクト: Twinside/ViWm
    BOOL ViWmManager::monitorEnumerator( HMONITOR hMonitor
        , HDC    /* hdcMonitor */
        , LPRECT /* intersectionRect */
        , LPARAM userData
        )
    {
        static int      monitorCount = 0;
        ViWmManager     &instance = *reinterpret_cast<ViWmManager*>( userData );
        DesktopLayout   &myLayout = instance.currentLayout;
        MONITORINFOEX   minfo;

        minfo.cbSize = sizeof( MONITORINFOEX );
        GetMonitorInfo( hMonitor, &minfo );

        // as MSDN state that some value may be negative for non-primary
        // displays, we abs the width & height to get correct value to
        // work on.
        int winWidth = abs(minfo.rcWork.right - minfo.rcWork.left);
        int winHeight = abs(minfo.rcWork.bottom - minfo.rcWork.top);

        // yeah our nice window...
        HWND fullScreenWin =
            CreateWindowEx ( WS_EX_LAYERED | WS_EX_NOACTIVATE
                                | (monitorCount == 0 ? WS_EX_APPWINDOW : 0)
                           , fullScreenWindowClassName
                           , TEXT("ABack")
                           , WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS 
                            /* style */
                           , minfo.rcWork.left
                           , minfo.rcWork.top
                           , winWidth
                           , winHeight
                           , NULL
                           , NULL /* menu */
                           , GetModuleHandle(0)
                           , NULL
                           );

        if (!fullScreenWin) {
            int err = GetLastError();
            MessageBox( NULL
                      , TEXT("Error Creating Background Window")
                      , TEXT("Error")
                      , MB_OK | MB_ICONERROR);
            exit( err ); /* Bail */
        }

        // if NULL, we need to create the menu action
        // a bit hugly :s
        if ( monitorCount++ == 0 )
        {
            instance.hotkeysDefinition.push_back(
                HotKey( 'Z', new Actions::ActionMenu( instance.globalHotkeyListener
                                                    , instance.hotkeysDefinition )));
        }

        // ok we need our window to be always on bottom, let's hack to get that
        // we also specify our really wanted size =)
        SetWindowPos( fullScreenWin
                    , HWND_BOTTOM
                    , minfo.rcWork.left
                    , minfo.rcWork.top
                    , winWidth
                    , winHeight
                    , /*SWP_NOACTIVATE | */SWP_NOMOVE | SWP_NOSIZE
                    );

        Renderer::RenderWindow    *newWindow =
            new Renderer::RenderWindow( fullScreenWin
                                      , minfo.rcWork.left
                                      , minfo.rcWork.top
                                      , winWidth
                                      , winHeight );

        Screen          newScreen
            ( *newWindow
            , minfo.rcWork.left
            , minfo.rcWork.top
            , winWidth
            , winHeight
            );

        myLayout.push_back( newScreen );

        // we make the window transparent here
        newWindow->begin( true );
        newWindow->end();

        assert( myLayout.size() >= 1 );
        return TRUE;
    }
コード例 #20
0
ファイル: wincreatewnd.c プロジェクト: AmesianX/xorg-server
static Bool
winGetWorkArea(RECT * prcWorkArea, winScreenInfo * pScreenInfo)
{
    int iPrimaryWidth, iPrimaryHeight;
    int iWidth, iHeight;
    int iLeft, iTop;
    int iPrimaryNonWorkAreaWidth, iPrimaryNonWorkAreaHeight;

    /* Use GetMonitorInfo to get work area for monitor */
    if (!pScreenInfo->fMultipleMonitors) {
        MONITORINFO mi;

        mi.cbSize = sizeof(MONITORINFO);
        if (GetMonitorInfo(pScreenInfo->hMonitor, &mi)) {
            *prcWorkArea = mi.rcWork;

            winDebug("winGetWorkArea - Monitor %d WorkArea: %d %d %d %d\n",
                     pScreenInfo->iMonitor,
                     (int) prcWorkArea->top, (int) prcWorkArea->left,
                     (int) prcWorkArea->bottom, (int) prcWorkArea->right);
        }
        else {
            ErrorF("winGetWorkArea - GetMonitorInfo() failed for monitor %d\n",
                   pScreenInfo->iMonitor);
        }

        /* Bail out here if we aren't using multiple monitors */
        return TRUE;
    }

    /* SPI_GETWORKAREA only gets the work area of the primary screen. */
    SystemParametersInfo(SPI_GETWORKAREA, 0, prcWorkArea, 0);

    winDebug("winGetWorkArea - Primary Monitor WorkArea: %d %d %d %d\n",
             (int) prcWorkArea->top, (int) prcWorkArea->left,
             (int) prcWorkArea->bottom, (int) prcWorkArea->right);

    /* Get size of full virtual screen */
    iWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    iHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);

    winDebug("winGetWorkArea - Virtual screen is %d x %d\n", iWidth, iHeight);

    /* Get origin of full virtual screen */
    iLeft = GetSystemMetrics(SM_XVIRTUALSCREEN);
    iTop = GetSystemMetrics(SM_YVIRTUALSCREEN);

    winDebug("winGetWorkArea - Virtual screen origin is %d, %d\n", iLeft, iTop);

    /* Get size of primary screen */
    iPrimaryWidth = GetSystemMetrics(SM_CXSCREEN);
    iPrimaryHeight = GetSystemMetrics(SM_CYSCREEN);

    winDebug("winGetWorkArea - Primary screen is %d x %d\n",
             iPrimaryWidth, iPrimaryHeight);

    /* Work out how much of the primary screen we aren't using */
    iPrimaryNonWorkAreaWidth = iPrimaryWidth - (prcWorkArea->right -
                                                prcWorkArea->left);
    iPrimaryNonWorkAreaHeight = iPrimaryHeight - (prcWorkArea->bottom
                                                  - prcWorkArea->top);

    /* Update the rectangle to include all monitors */
    if (iLeft < 0) {
        prcWorkArea->left = iLeft;
    }
    if (iTop < 0) {
        prcWorkArea->top = iTop;
    }
    prcWorkArea->right = prcWorkArea->left + iWidth - iPrimaryNonWorkAreaWidth;
    prcWorkArea->bottom = prcWorkArea->top + iHeight -
        iPrimaryNonWorkAreaHeight;

    winDebug("winGetWorkArea - Adjusted WorkArea for multiple "
             "monitors: %d %d %d %d\n",
             (int) prcWorkArea->top, (int) prcWorkArea->left,
             (int) prcWorkArea->bottom, (int) prcWorkArea->right);

    return TRUE;
}
コード例 #21
0
ファイル: video.c プロジェクト: CJBass/mame2013-libretro
void sdlvideo_monitor_refresh(sdl_monitor_info *monitor)
{
	#if (SDLMAME_SDL2)
	SDL_DisplayMode dmode;

	SDL_GetDesktopDisplayMode(monitor->handle, &dmode);
	monitor->monitor_width = dmode.w;
	monitor->monitor_height = dmode.h;
	monitor->center_width = dmode.w;
	monitor->center_height = dmode.h;
	#else
	#if defined(SDLMAME_WIN32)  // Win32 version
	MONITORINFOEX info;
	info.cbSize = sizeof(info);
	GetMonitorInfo((HMONITOR)monitor->handle, (LPMONITORINFO)&info);
	monitor->center_width = monitor->monitor_width = info.rcMonitor.right - info.rcMonitor.left;
	monitor->center_height = monitor->monitor_height = info.rcMonitor.bottom - info.rcMonitor.top;
	char *temp = utf8_from_wstring(info.szDevice);
	strcpy(monitor->monitor_device, temp);
	osd_free(temp);
	#elif defined(SDLMAME_MACOSX)   // Mac OS X Core Imaging version
	CGDirectDisplayID primary;
	CGRect dbounds;

	// get the main display
	primary = CGMainDisplayID();
	dbounds = CGDisplayBounds(primary);

	monitor->center_width = monitor->monitor_width = dbounds.size.width - dbounds.origin.x;
	monitor->center_height = monitor->monitor_height = dbounds.size.height - dbounds.origin.y;
	strcpy(monitor->monitor_device, "Mac OS X display");
	#elif defined(SDLMAME_X11) || defined(SDLMAME_NO_X11)       // X11 version
	{
		#if defined(SDLMAME_X11)
		// X11 version
		int screen;
		SDL_SysWMinfo info;
		SDL_VERSION(&info.version);

		if ( SDL_GetWMInfo(&info) && (info.subsystem == SDL_SYSWM_X11) )
		{
			screen = DefaultScreen(info.info.x11.display);
			SDL_VideoDriverName(monitor->monitor_device, sizeof(monitor->monitor_device)-1);
			monitor->monitor_width = DisplayWidth(info.info.x11.display, screen);
			monitor->monitor_height = DisplayHeight(info.info.x11.display, screen);

			if ((XineramaIsActive(info.info.x11.display)) && video_config.restrictonemonitor)
			{
				XineramaScreenInfo *xineinfo;
				int numscreens;

					xineinfo = XineramaQueryScreens(info.info.x11.display, &numscreens);

				monitor->center_width = xineinfo[0].width;
				monitor->center_height = xineinfo[0].height;

				XFree(xineinfo);
			}
			else
			{
				monitor->center_width = monitor->monitor_width;
				monitor->center_height = monitor->monitor_height;
			}
		}
		else
		#endif // defined(SDLMAME_X11)
		{
			static int first_call=0;
			static int cw, ch;

			SDL_VideoDriverName(monitor->monitor_device, sizeof(monitor->monitor_device)-1);
			if (first_call==0)
			{
				char *dimstr = osd_getenv(SDLENV_DESKTOPDIM);
				const SDL_VideoInfo *sdl_vi;

				sdl_vi = SDL_GetVideoInfo();
				#if (SDL_VERSION_ATLEAST(1,2,10))
				cw = sdl_vi->current_w;
				ch = sdl_vi->current_h;
				#endif
				first_call=1;
				if ((cw==0) || (ch==0))
				{
					if (dimstr != NULL)
					{
						sscanf(dimstr, "%dx%d", &cw, &ch);
					}
					if ((cw==0) || (ch==0))
					{
						mame_printf_warning("WARNING: SDL_GetVideoInfo() for driver <%s> is broken.\n", monitor->monitor_device);
						mame_printf_warning("         You should set SDLMAME_DESKTOPDIM to your desktop size.\n");
						mame_printf_warning("            e.g. export SDLMAME_DESKTOPDIM=800x600\n");
						mame_printf_warning("         Assuming 1024x768 now!\n");
						cw=1024;
						ch=768;
					}
				}
			}
			monitor->monitor_width = cw;
			monitor->monitor_height = ch;
			monitor->center_width = cw;
			monitor->center_height = ch;
		}
	}
	#elif defined(SDLMAME_OS2)      // OS2 version
	monitor->center_width = monitor->monitor_width = WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN );
	monitor->center_height = monitor->monitor_height = WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN );
	strcpy(monitor->monitor_device, "OS/2 display");
	#else
	#error Unknown SDLMAME_xx OS type!
	#endif

	{
		static int info_shown=0;
		if (!info_shown)
		{
			mame_printf_verbose("SDL Device Driver     : %s\n", monitor->monitor_device);
			mame_printf_verbose("SDL Monitor Dimensions: %d x %d\n", monitor->monitor_width, monitor->monitor_height);
			info_shown = 1;
		}
	}
	#endif //  (SDLMAME_SDL2)
}
コード例 #22
0
ファイル: mainwnd.c プロジェクト: Brainiarc7/pbis
void
khm_adjust_window_dimensions_for_display(RECT * pr, int dock) {

    HMONITOR hmon;
    RECT     rm;
    long x, y, width, height;

    x = pr->left;
    y = pr->top;
    width = pr->right - pr->left;
    height = pr->bottom - pr->top;

    /* if the rect doesn't intersect with the display area of any
       monitor, we just default to the primary monitor. */
    hmon = MonitorFromRect(pr, MONITOR_DEFAULTTOPRIMARY);

    if (hmon == NULL) {
        /* huh? we'll just center this on the primary screen */
        goto nomonitor;
    } else {
        MONITORINFO mi;

        ZeroMemory(&mi, sizeof(mi));
        mi.cbSize = sizeof(mi);

        if (!GetMonitorInfo(hmon, &mi))
            goto nomonitor;

        CopyRect(&rm, &mi.rcWork);

        goto adjust_dims;
    }

 nomonitor:
    /* for some reason we couldn't get a handle on a monitor or we
       couldn't get the metrics for that monitor.  We default to
       setting things up on the primary monitor. */

    SetRectEmpty(&rm);
    if (!SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID) &rm, 0))
        goto done_with_monitor;

 adjust_dims:

    if (width > (rm.right - rm.left))
        width = rm.right - rm.left;
    if (height > (rm.bottom - rm.top))
        height = rm.bottom - rm.top;

    switch (dock & KHM_DOCKF_DOCKHINT) {
    case KHM_DOCK_TOPLEFT:
        x = rm.left;
        y = rm.top;
        break;

    case KHM_DOCK_TOPRIGHT:
        x = rm.right - width;
        y = rm.top;
        break;

    case KHM_DOCK_BOTTOMRIGHT:
        x = rm.right - width;
        y = rm.bottom - height;
        break;

    case KHM_DOCK_BOTTOMLEFT:
        x = rm.left;
        y = rm.bottom - height;
        break;

    case KHM_DOCK_AUTO:
        {
            int cxt, cyt;

            cxt = GetSystemMetrics(SM_CXDRAG);
            cyt = GetSystemMetrics(SM_CYDRAG);

            if (x > rm.left && (x - rm.left) < cxt)
                x = rm.left;
            else if ((x + width) < rm.right && (rm.right - (x + width)) < cxt)
                x = rm.right - width;

            if (y > rm.top && (y - rm.top) < cyt)
                y = rm.top;
            else if ((y + height) < rm.bottom && (rm.bottom - (y + height)) < cyt)
                y = rm.bottom - height;
        }
        break;
    }

    if (!(dock & KHM_DOCKF_XBORDER)) {
        if (x < rm.left)
            x = rm.left;
        if (x + width > rm.right)
            x = rm.right - width;
        if (y < rm.top)
            y = rm.top;
        if (y + height > rm.bottom)
            y = rm.bottom - height;
    }

 done_with_monitor:
    pr->left = x;
    pr->top = y;
    pr->right = x + width;
    pr->bottom = y + height;

}
コード例 #23
0
BOOL DXContext::Internal_Init(DXCONTEXT_PARAMS *pParams, BOOL bFirstInit)
{
	memcpy(&m_current_mode, pParams, sizeof(DXCONTEXT_PARAMS));
	memset(&myWindowState,0,sizeof(myWindowState));

	// various checks
	if (m_current_mode.screenmode != WINDOWED)
		m_current_mode.m_skin = 0;

	// 1. destroy old window
	if (m_hwnd)
	{
		m_ignore_wm_destroy = 1;
		DestroyWindow(m_hwnd);
		m_ignore_wm_destroy = 0;
		m_hwnd = NULL;
	}

	// 2. CHECK TO MAKE SURE DIRECTX/DDRAW IS INSTALLED
	if (bFirstInit)
	{
		// Test for DirectX 9 + start it
		// note: if you don't call LoadLibrary here, and you're on a system
		//       where DX9 is missing, Direct3DCreate8() might crash; so call it.
		int d3d9_already_loaded = (GetModuleHandle("d3d9.dll") != NULL) ? 1 : 0;
		if (!d3d9_already_loaded)
			m_hmod_d3d9 = LoadLibrary("d3d9.dll");

		if ((!d3d9_already_loaded && !m_hmod_d3d9) ||
		    !(m_lpD3D = Direct3DCreate9(D3D_SDK_VERSION))
		   )
		{
			MissingDirectX(NULL);
			m_lastErr = DXC_ERR_CREATE3D;
			return FALSE;
		}

		if (!m_hmod_d3dx9)
			m_hmod_d3dx9 = FindD3DX9(m_hwnd_winamp);

		if ((!m_hmod_d3dx9))
		{
			MissingDirectX(NULL);
			m_lastErr = DXC_ERR_CREATE3D;
			return FALSE;
		}
	}

	// 3. get the smallest single rectangle that encloses ALL the monitors on the desktop:
	SetRect(&m_all_monitors_rect, 0, 0, 0, 0);
	EnumDisplayMonitors(NULL, NULL, MyMonitorEnumProc, (LPARAM)&m_all_monitors_rect);

	// 4. some DirectX- / DDraw-specific stuff.  Also determine hPluginMonitor.
	HMONITOR hPluginMonitor = NULL;
	{
		D3DADAPTER_IDENTIFIER9 temp;

		// find the ordinal # of the adapter whose GUID matches what the user picked from the config panel,
		// and whose DeviceName matches as well.
		// if no match found, use D3DADAPTER_DEFAULT.
		m_ordinal_adapter = D3DADAPTER_DEFAULT;
		int nAdapters = m_lpD3D->GetAdapterCount();
		{
			for (int i=0; i<nAdapters; i++)
			{
				if ((m_lpD3D->GetAdapterIdentifier(i, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &temp) == D3D_OK) &&
				    (memcmp(&temp.DeviceIdentifier, &m_current_mode.adapter_guid, sizeof(GUID))==0) &&
				    !strcmp(temp.DeviceName, m_current_mode.adapter_devicename)
				   )
				{
					m_ordinal_adapter = i;
					break;
				}
			}
		}

		if (m_lpD3D->GetAdapterIdentifier(m_ordinal_adapter, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &temp) == D3D_OK)
		{
			StringCbCopy(m_szDriver, sizeof(m_szDriver), temp.Driver);
			StringCbCopy(m_szDesc, sizeof(m_szDesc), temp.Description);
		}

		int caps_ok = 0;
		int caps_tries = 0;
		int changed_fs_disp_mode;

		// try to get the device caps for the adapter selected from the config panel.
		// if GetDeviceCaps() fails, it's probably because the adapter has been
		// removed from the system (or disabled), so we try again with other adapter(s).
		do
		{
			changed_fs_disp_mode = 0;

			SetRect(&m_monitor_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));

			// get bounding rect of the monitor attached to the adapter (to assist w/window positioning)
			// note: in vert/horz span setups (psuedo-multimon),
			//       this will be 2048x768 or 1024x1536 or something like that.
			hPluginMonitor = m_lpD3D->GetAdapterMonitor(m_ordinal_adapter);
			/*if (hPluginMonitor)
			{
			    MONITORINFO mi;
			    mi.cbSize = sizeof(mi);
			    if (GetMonitorInfo(hPluginMonitor, &mi))
			    {
			        memcpy(&m_monitor_rect, &mi.rcMonitor, sizeof(RECT));
			        memcpy(&m_monitor_work_rect, &mi.rcWork, sizeof(RECT));
			    }
			}*/

			if (bFirstInit)
			{
				for (int i=0; i<min(nAdapters, MAX_DXC_ADAPTERS); i++)
				{
					// if this is the first call to Init, get the display mode's original color format,
					// before we go changing it:
					D3DDISPLAYMODE d3ddm;
					if (FAILED(m_lpD3D->GetAdapterDisplayMode(i, &d3ddm)))
					{
						d3ddm.Format = D3DFMT_UNKNOWN;
					}
					m_orig_windowed_mode_format[i] = d3ddm.Format;
				}
			}

			// figure out pixel (color) format for back buffer: (m_current_mode.display_mode.Format)
			if (m_current_mode.screenmode!=FULLSCREEN && m_ordinal_adapter < MAX_DXC_ADAPTERS)
				m_current_mode.display_mode.Format = m_orig_windowed_mode_format[m_ordinal_adapter];
			// else
			// for fullscreen, use what they gave us

			if (m_current_mode.display_mode.Format == D3DFMT_UNKNOWN ||
			    !TestFormat(m_ordinal_adapter, m_current_mode.display_mode.Format))
			{
				// if they try to run the plugin without ever running the config panel
				// first (& pressing OK), then the fullscreen pixelformat hasn't been
				// chosen... so we try all the possilibities until one works:
				if (TestFormat(m_ordinal_adapter,D3DFMT_A8R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_A8R8G8B8;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_X8R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_X8R8G8B8;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_R8G8B8  ;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_R5G6B5)) m_current_mode.display_mode.Format = D3DFMT_R5G6B5  ;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_X1R5G5B5)) m_current_mode.display_mode.Format = D3DFMT_X1R5G5B5;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_A1R5G5B5)) m_current_mode.display_mode.Format = D3DFMT_A1R5G5B5;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_A4R4G4B4)) m_current_mode.display_mode.Format = D3DFMT_A4R4G4B4;
				else if (TestFormat(m_ordinal_adapter,D3DFMT_X4R4G4B4)) m_current_mode.display_mode.Format = D3DFMT_X4R4G4B4;
			}

			if (m_current_mode.display_mode.Format==D3DFMT_UNKNOWN)
			{
				wchar_t title[64];
				m_lastErr = DXC_ERR_FORMAT;
				MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_DIRECTX_INIT_FAILED),
						    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
						    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
				return FALSE;
			}

			if (m_current_mode.screenmode == FULLSCREEN)
				changed_fs_disp_mode = CheckAndCorrectFullscreenDispMode(m_ordinal_adapter, &m_current_mode.display_mode);

			// figure out pixel format of the z-buffer: (m_zFormat)
			m_zFormat = D3DFMT_UNKNOWN;
			/*
			if      (TestDepth(m_ordinal_adapter,D3DFMT_D32         )) m_zFormat=D3DFMT_D32;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D24S8       )) m_zFormat=D3DFMT_D24S8;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D24X4S4     )) m_zFormat=D3DFMT_D24X4S4;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D24X8       )) m_zFormat=D3DFMT_D24X8;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D16         )) m_zFormat=D3DFMT_D16;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D15S1       )) m_zFormat=D3DFMT_D15S1;
			else if (TestDepth(m_ordinal_adapter,D3DFMT_D16_LOCKABLE)) m_zFormat=D3DFMT_D16_LOCKABLE;
			*/

			// get device caps:
			memset(&m_caps, 0, sizeof(m_caps));
			if (FAILED(m_lpD3D->GetDeviceCaps(m_ordinal_adapter, D3DDEVTYPE_HAL, &m_caps)))
			{
				// that adapter was found in the system, but it might be disabled
				// (i.e. 'extend my Windows desktop onto this monitor') is unchecked)
				// so, try other adapters (try all sequentially).

				if (caps_tries < nAdapters)
				{
					// try again, this time using the default adapter:
					m_ordinal_adapter = caps_tries;
					caps_tries++;
				}
				else
				{
					wchar_t title[64];
					m_lastErr = DXC_ERR_CAPSFAIL;
					MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_DXC_ERR_CAPSFAIL),
							    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
							    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
					return FALSE;
				}
			}
			else
			{
				caps_ok = 1;
			}
		}
		while (!caps_ok);

		if (changed_fs_disp_mode)
		{
			wchar_t title[64];
			MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_FS_DISPLAY_MODE_SELECTED_IS_INVALID),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_WARNING, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
		}

		switch (m_current_mode.display_mode.Format)
		{
		case D3DFMT_R8G8B8  : m_bpp = 32; break;
		case D3DFMT_A8R8G8B8: m_bpp = 32; break;
		case D3DFMT_X8R8G8B8: m_bpp = 32; break;
		case D3DFMT_R5G6B5  : m_bpp = 16; break;
		case D3DFMT_X1R5G5B5: m_bpp = 16; break;
		case D3DFMT_A1R5G5B5: m_bpp = 16; break;
		case D3DFMT_A8R3G3B2: m_bpp = 16; break;
		case D3DFMT_A4R4G4B4: m_bpp = 16; break;
		case D3DFMT_X4R4G4B4: m_bpp = 16; break;
		case D3DFMT_R3G3B2  : m_bpp =  8; break; // misleading?  implies a palette...
		}
	}

	// 5. set m_monitor_rect and m_monitor_work_rect.
	if (hPluginMonitor)
	{
		MONITORINFO mi;
		mi.cbSize = sizeof(mi);
		if (GetMonitorInfo(hPluginMonitor, &mi))
		{
			m_monitor_rect = mi.rcMonitor;
			m_monitor_rect_orig = mi.rcMonitor;
			m_monitor_work_rect = mi.rcWork;
			m_monitor_work_rect_orig = mi.rcWork;
		}
	}

	// 6. embedded window stuff [where the plugin window is integrated w/winamp]
	if (m_current_mode.m_skin)
	{
		// set up the window's position on screen
		// note that we'd prefer to set the CLIENT size we want, but we can't, so we'll just do
		// this here, and later, adjust the client rect size to what's left...
		int size = GetWindowedModeAutoSize(0);  // note: requires 'm_monitor_rect' has been set!
		myWindowState.r.left   = GetPrivateProfileIntW(L"settings",L"avs_wx",64,m_szIniFile);
		myWindowState.r.top    = GetPrivateProfileIntW(L"settings",L"avs_wy",64,m_szIniFile);
		myWindowState.r.right  = myWindowState.r.left + GetPrivateProfileIntW(L"settings",L"avs_ww",size+24,m_szIniFile);
		myWindowState.r.bottom = myWindowState.r.top  + GetPrivateProfileIntW(L"settings",L"avs_wh",size+40,m_szIniFile);

		// only works on winamp 2.90+!
		int success = 0;
		if (GetWinampVersion(mod1.hwndParent) >= 0x2900)
		{
			SET_EMBED_GUID((&myWindowState), avs_guid);
			myWindowState.flags |= EMBED_FLAGS_NOTRANSPARENCY;
			HWND (*e)(embedWindowState *v);
			*(void**)&e = (void *)SendMessage(mod1.hwndParent,WM_WA_IPC,(LPARAM)0,IPC_GET_EMBEDIF);
			if (e)
			{
				m_current_mode.parent_window = e(&myWindowState);
				if (m_current_mode.parent_window)
				{
					SetWindowText(m_current_mode.parent_window, m_szWindowCaption);
					success = 1;
				}
			}
		}

		if (!success)
			m_current_mode.m_skin = 0;
	}

	// remember the client rect that was originally desired...
	RECT windowed_mode_desired_client_rect;
	windowed_mode_desired_client_rect.top    = GetPrivateProfileIntW(L"settings",L"nMainWndTop",-1,m_szIniFile);
	windowed_mode_desired_client_rect.left   = GetPrivateProfileIntW(L"settings",L"nMainWndLeft",-1,m_szIniFile);
	windowed_mode_desired_client_rect.right  = GetPrivateProfileIntW(L"settings",L"nMainWndRight",-1,m_szIniFile);
	windowed_mode_desired_client_rect.bottom = GetPrivateProfileIntW(L"settings",L"nMainWndBottom",-1,m_szIniFile);

	// ...and in case windowed mode init fails severely,
	// set it up to try next time for a simple 256x256 window.
	WriteSafeWindowPos();

	// 7. create the window, if not already created
	if (!m_hwnd)
	{
		m_hwnd = CreateWindowEx(
		           MY_EXT_WINDOW_STYLE, // extended style
		           MAKEINTATOM(m_classAtom), // class
		           m_szWindowCaption, // caption
		           MY_WINDOW_STYLE, // style
		           0, // left
		           0, // top
		           256,  // temporary width
		           256,  // temporary height
		           m_current_mode.parent_window,  // parent window
		           NULL, // menu
		           m_hInstance, // instance
		           (LPVOID)m_uWindowLong
		         ); // parms

		if (!m_hwnd)
		{
			wchar_t title[64];
			m_lastErr = DXC_ERR_CREATEWIN;
			MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_CREATEWINDOW_FAILED),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return FALSE;
		}

		SendMessage(m_hwnd_winamp, WM_WA_IPC, (WPARAM)m_hwnd, IPC_SETVISWND);

		if (m_current_mode.m_skin)
		{
			if (GetWinampVersion(mod1.hwndParent) < 0x5051)
				ShowWindow(m_current_mode.parent_window,SW_SHOWNA); // showing the parent wnd will make it size the child, too
			else
				SendMessage(m_current_mode.parent_window, WM_USER+102, 0, 0); // benski> major hack alert. winamp's embedwnd will call ShowWindow in response.  SendMessage moves us over to the main thread (we're currently sitting on the viz thread)
		}		
	}

	// 8. minimize winamp before creating devices & such, so there aren't
	//    any confusing window-focus issues
	MinimizeWinamp(hPluginMonitor);

	// 9. loop to try and create the window.
	//      if in windowed mode and not enough vidmem, it will try again w/smaller window
	//      (repeatedly, until window client size would be < 64)
	int iteration = 0;
	int device_ok = 0;
	do
	{
		// set the window position
		if (m_current_mode.screenmode==DESKTOP ||
		    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)
			{
				// (pseudo-multimon modes like 2048x768)
				int mid = (m_monitor_rect.left + m_monitor_rect.right)/2;
				if (m_current_mode.m_dualhead_horz==1) // show on left side
					m_monitor_rect.right = mid;
				else if (m_current_mode.m_dualhead_horz==2) // show on right side
					m_monitor_rect.left = mid;
			}
			else if (y > x*4/3)
			{
				// (pseudo-multimon modes like 1024x1536)
				int mid = (m_monitor_rect.top + m_monitor_rect.bottom)/2;
				if (m_current_mode.m_dualhead_vert==1) // show on top half
					m_monitor_rect.bottom = mid;
				else if (m_current_mode.m_dualhead_vert==2) // show on bottom half
					m_monitor_rect.top = mid;
			}

			// recompute width & height (into x,y):
			x = m_monitor_rect.right - m_monitor_rect.left;
			y = m_monitor_rect.bottom - m_monitor_rect.top;

			m_client_width  = x;
			m_client_height = y;
			m_window_width  = x;
			m_window_height = y;

			if (m_current_mode.screenmode == DESKTOP)
			{
				// note: we initially hide the window, and then
				// only display it once the desktop is all nice & ready.
				// see CPluginShell::DrawAndDisplay().

				RECT r = m_monitor_rect;

				// if possible, shrink the desktop window so it doesn't cover the taskbar.
				HWND hTaskbar = FindWindow("Shell_TrayWnd", "");
				if (hTaskbar)
				{
					RECT taskbar;
					GetWindowRect(hTaskbar, &taskbar);
					int tbw = taskbar.right - taskbar.left;
					int tbh = taskbar.bottom-taskbar.top;

					if (taskbar.bottom == m_monitor_rect.bottom &&
					    taskbar.left == m_monitor_rect.left &&
					    taskbar.right == m_monitor_rect.right)
					{
						r.bottom -= tbh;
					}
					else if (taskbar.top == m_monitor_rect.top &&
					         taskbar.left == m_monitor_rect.left &&
					         taskbar.right == m_monitor_rect.right)
					{
						r.top += tbh;
					}
					else if (taskbar.left == m_monitor_rect.left &&
					         taskbar.top == m_monitor_rect.top &&
					         taskbar.bottom == m_monitor_rect.bottom)
					{
						r.left += tbw;
					}
					else if (taskbar.right == m_monitor_rect.right &&
					         taskbar.top == m_monitor_rect.top &&
					         taskbar.bottom == m_monitor_rect.bottom)
					{
						r.right -= tbw;
					}

					m_client_width  = r.right - r.left;
					m_client_height = r.bottom - r.top;
					m_REAL_client_width = m_client_width;
					m_REAL_client_height = m_client_height;
					m_window_width  = m_client_width;
					m_window_height = m_client_height;

					//...ok, but text is squished - some w/h is not right...

				}

				SetWindowPos(m_hwnd,HWND_BOTTOM,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_HIDEWINDOW);
			}
			else // FAKE_FULLSCREEN
			{
				if (memcmp(&m_all_monitors_rect, &m_monitor_rect, sizeof(RECT))==0)
				{
					// there's only one display, and it's entirely covered
					// by the plugin -> PUT THE PLUGIN ABOVE THE TASKBAR
					// -> normally, if the user clicked another window,
					//      it would pop the taskbar to the top; but we don't
					//      have to worry about that here, since we're taking
					//      up the whole screen.
					// -> don't worry about making the text, etc. avoid
					//      the taskbar in this case (see DrawAndDisplay())
					// -> DO worry about hiding the mouse cursor in this case
					//      (see WM_SETCURSOR handler)

					m_fake_fs_covers_all = 1;
					//SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
				}
				else
				{
					// there is space to work outside of the plugin window.
					// -> here we pretty much have to let the taskbar stay on
					//   top, because it really likes to be there; i.e.,
					//   if you click any other window, it automatically
					//   pops up again.
					// -> therefore, TRY TO KEEP THE WINDOW ON BOTTOM
					//      (below the taskbar). (see PushWindowToBack)
					// -> don't worry about hiding the mouse cursor in this case
					//      (see WM_SETCURSOR handler)
					// -> DO worry about making the text, etc. avoid
					//      the taskbar in this case (see DrawAndDisplay())

					// (note that if taskbar is in the way, they can move it,
					//   since there are other monitors available)

					m_fake_fs_covers_all = 0;
					//SetWindowPos(m_hwnd,HWND_TOP,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
				}

				SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
			}
		}
		else if (m_current_mode.screenmode == FULLSCREEN)
		{
			int x = m_current_mode.display_mode.Width ;
			int y = m_current_mode.display_mode.Height;
			int cx = m_monitor_rect.right - m_monitor_rect.left;
			int cy = m_monitor_rect.bottom - m_monitor_rect.top;

			// test #1
			if (x >= y*2 || y > x*4/3)     // tackle problem of vert/horz spans
			{
				wchar_t title[64];
				int ret = MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_TRYING_TO_ENTER_FS_MODE_WITH_MULTIPLE_DISPLAYS),
									  WASABI_API_LNGSTRINGW_BUF(IDS_TIP, title, 64),
									  MB_OKCANCEL|MB_SETFOREGROUND|MB_TOPMOST);
				if (ret==IDCANCEL)
				{
					m_lastErr = DXC_ERR_USER_CANCELED;
					return FALSE;
				}
			}

			// test #2
			if ((cx >= cy*2 && x < y*2) || (cy > cx*4/3 && y <= x*4/3))
			{
				wchar_t title[64];
				int ret = MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_TRYING_TO_ENTER_FS_MODE_WITH_MULTIPLE_DISPLAYS_2),
									  WASABI_API_LNGSTRINGW_BUF(IDS_TIP, title, 64),
									  MB_OKCANCEL|MB_SETFOREGROUND|MB_TOPMOST);
				if (ret==IDCANCEL)
				{
					m_lastErr = DXC_ERR_USER_CANCELED;
					return FALSE;
				}
			}

			m_client_width  = x;
			m_client_height = y;
			m_window_width  = x;
			m_window_height = y;
			SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
		}
		else // WINDOWED
		{
			RECT margin;
			if (m_current_mode.m_skin)
			{
				RECT r1, r2;
				GetWindowRect(m_current_mode.parent_window, &r1);
				GetWindowRect(m_hwnd , &r2);
				margin.left  = r2.left - r1.left;
				margin.right = r1.right - r2.right;
				margin.top   = r2.top - r1.top;
				margin.bottom= r1.bottom - r2.bottom;
			}
			else
			{
				RECT r1;
				SetRect(&r1, 0, 0, 256, 256);
				AdjustWindowRect(&r1, MY_WINDOW_STYLE, 0);
				margin.left  = 0 - r1.left;
				margin.right = r1.right - 256;
				margin.top   = 0 - r1.top;
				margin.bottom= r1.bottom - 256;
			}

			int autosize = 1;

			RECT r = windowed_mode_desired_client_rect;
			if (iteration==0 && r.top != -1 && r.left != -1 && r.bottom != -1 && r.right != -1)
			{
				// use prev. window coordinates:
				m_REAL_client_width  = r.right - r.left;
				m_REAL_client_height = r.bottom - r.top;
				GetSnappedClientSize();
				if (m_current_mode.m_skin) // check this here in case they got a non-aligned size by resizing when "integrated with winamp" was unchecked, then checked it & ran the plugin...
				{
					// STRANGE ALIGNMENTS FOR THE WINDOW FRAME: (required by winamp 2):
					// the window frame's width must be divisible by 25, and height by 29.
					if (GetWinampVersion(mod1.hwndParent) < 0x4000) // ... winamp 5 doesn't have this prob.  (test vs. 0x4000 because winamp5 betas have version tags like 0x4987)
					{
						m_REAL_client_width  = ((m_client_width + margin.left + margin.right)/25)*25 - margin.left - margin.right;
						m_REAL_client_height = ((m_client_height + margin.top + margin.bottom)/29)*29 - margin.top - margin.bottom;
						GetSnappedClientSize();
					}
				}

				// transform screen-space CLIENT rect into screen-space WINDOW rect
				r.top    = windowed_mode_desired_client_rect.top    - margin.top;
				r.left   = windowed_mode_desired_client_rect.left   - margin.left;
				r.right  = r.left + margin.left + m_REAL_client_width  + margin.right;
				r.bottom = r.top  + margin.top  + m_REAL_client_height + margin.bottom;

				// make sure the window is entirely visible on the selected monitor;
				//   otherwise, autosize/place it.
				// (note that this test is only appled 1) at startup, and 2) after a resize/max/restore.
				//  this test is not applied when merely moving the window.)
				if (r.top    >= m_monitor_work_rect.top &&
				    r.left   >= m_monitor_work_rect.left &&
				    r.right  <= m_monitor_work_rect.right &&
				    r.bottom <= m_monitor_work_rect.bottom)
				{
					if (m_current_mode.m_skin)
					{
						m_window_width  = m_REAL_client_width ; // m_window_width/height are for OUR borderless window, not the embedwnd parent frame.
						m_window_height = m_REAL_client_height;
						SetWindowPos(m_current_mode.parent_window,HWND_NOTOPMOST, r.left, r.top, r.right-r.left, r.bottom-r.top, /*SWP_SHOWWINDOW|*//*SWP_ASYNCWINDOWPOS*/0);
						SetWindowPos(m_hwnd ,HWND_NOTOPMOST, windowed_mode_desired_client_rect.left,
						             windowed_mode_desired_client_rect.top,
						             m_REAL_client_width,
						             m_REAL_client_height,
						             SWP_SHOWWINDOW);
					}
					else
					{
						m_window_width  = r.right - r.left;
						m_window_height = r.bottom - r.top;
						SetWindowPos(m_hwnd,HWND_NOTOPMOST,r.left,r.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
					}

					autosize = 0;
				}
			}

			if (autosize)
			{
				int size = GetWindowedModeAutoSize(iteration); // note: requires 'm_monitor_rect' has been set!

				m_REAL_client_width  = size;
				m_REAL_client_height = size;
				GetSnappedClientSize();

				if (m_current_mode.m_skin)
				{
					// STRANGE ALIGNMENTS FOR THE WINDOW FRAME: (required by winamp 2):
					// the window frame's width must be divisible by 25, and height by 29.
					if (GetWinampVersion(mod1.hwndParent) < 0x4000) // ... winamp 5 doesn't have this prob.  (test vs. 0x4000 because winamp5 betas have version tags like 0x4987)
					{
						m_REAL_client_width  = ((m_client_width + margin.left + margin.right)/25)*25 - margin.left - margin.right;
						m_REAL_client_height = ((m_client_height + margin.top + margin.bottom)/29)*29 - margin.top - margin.bottom;
						GetSnappedClientSize();
					}

					m_window_width  = m_client_width ; // m_window_width/height are for OUR [borderless] window, not the parent window (which is the embedwnd frame).
					m_window_height = m_client_height;
					SetWindowPos(m_current_mode.parent_window,HWND_NOTOPMOST, m_monitor_work_rect.left+32, m_monitor_work_rect.top+32, m_client_width + margin.left + margin.right, m_client_height + margin.top + margin.bottom, /*SWP_SHOWWINDOW|*//*SWP_ASYNCWINDOWPOS*/0);
					SetWindowPos(m_hwnd ,HWND_NOTOPMOST, m_monitor_work_rect.left+32 + margin.left, m_monitor_work_rect.top+32 + margin.top, m_client_width, m_client_height, SWP_SHOWWINDOW);
				}
				else
				{
					SetRect(&r, 0, 0, size, size);
					AdjustWindowRect(&r, MY_WINDOW_STYLE, 0);

					m_window_width  = r.right - r.left;
					m_window_height = r.bottom - r.top;

					SetWindowPos(m_hwnd,HWND_NOTOPMOST, m_monitor_work_rect.left+32, m_monitor_work_rect.top+32, m_window_width, m_window_height, SWP_SHOWWINDOW);
				}
			}
		}

		m_frame_delay = 1;      // set this to 2 if you use triple buffering!

		{
			m_current_mode.display_mode.Width  = m_client_width;
			m_current_mode.display_mode.Height = m_client_height;

			// set up m_d3dpp (presentation parameters):
			ZeroMemory(&m_d3dpp,sizeof(m_d3dpp));
			m_d3dpp.Windowed         = (m_current_mode.screenmode==FULLSCREEN) ? 0 : 1;
			m_d3dpp.BackBufferFormat = m_current_mode.display_mode.Format;
			m_d3dpp.BackBufferWidth  = m_client_width;
			m_d3dpp.BackBufferHeight = m_client_height;
			m_d3dpp.BackBufferCount  = m_current_mode.nbackbuf;
			if (m_current_mode.screenmode==FULLSCREEN)
				m_d3dpp.SwapEffect   = D3DSWAPEFFECT_DISCARD;//D3DSWAPEFFECT_FLIP;
			else    // windowed or fake FS
				m_d3dpp.SwapEffect   = (m_current_mode.allow_page_tearing) ? D3DSWAPEFFECT_DISCARD : D3DSWAPEFFECT_COPY;//D3DSWAPEFFECT_DISCARD;//D3DSWAPEFFECT_FLIP;
			// note: multisampling is only allowed if swapeffect is DISCARD!
			m_d3dpp.MultiSampleType  = (m_d3dpp.SwapEffect==D3DSWAPEFFECT_DISCARD) ? m_current_mode.multisamp : D3DMULTISAMPLE_NONE;
			//m_d3dpp.hDeviceWindow  = m_hwnd;
			if (m_current_mode.screenmode==FULLSCREEN)
			{
				m_d3dpp.FullScreen_RefreshRateInHz = m_current_mode.display_mode.RefreshRate;//D3DPRESENT_RATE_DEFAULT;
				m_d3dpp.PresentationInterval       = m_current_mode.allow_page_tearing ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;//D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_ONE;
			}
			if (m_zFormat != D3DFMT_UNKNOWN)
			{
				m_d3dpp.EnableAutoDepthStencil=TRUE;
				m_d3dpp.AutoDepthStencilFormat=m_zFormat;
			}

			// finally, create the device:
			HRESULT hRes;
			if (FAILED(hRes = m_lpD3D->CreateDevice(
			                    m_ordinal_adapter,
			                    D3DDEVTYPE_HAL,
			                    m_hwnd,
			                    (m_caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) ? D3DCREATE_MIXED_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING,
			                    &m_d3dpp,
			                    &m_lpDevice)))
			{
				int code = LOWORD(hRes);

				wchar_t str[1024];
				if (code==2156) //D3DERR_NOTAVAILABLE
				{
					m_lastErr = DXC_ERR_CREATEDEV_NOT_AVAIL;

					wchar_t str[2048];
					WASABI_API_LNGSTRINGW_BUF(IDS_UNABLE_TO_CREATE_DIRECTX_DEVICE, str, 2048);

					if (m_current_mode.screenmode == FULLSCREEN)
						StringCbCatW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_OLDER_DISPLAY_ADAPTER_CATENATION));
					else
						StringCbCatW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_OLDER_DISPLAY_ADAPTER_CATENATION_2));

					MessageBoxW(m_hwnd,str,
							   WASABI_API_LNGSTRINGW(IDS_MILKDROP_ERROR),
							   MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
					return FALSE;
				}
				else if (m_current_mode.screenmode==WINDOWED && m_client_width>64)
				{
					// DO NOTHING; try again w/smaller window
				}
				else if (m_current_mode.screenmode != WINDOWED || m_client_width <= 64)
				{
					// usually, code==2154 here, which is D3DERR_OUTOFVIDEOMEMORY
					m_lastErr = DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY;
					StringCbPrintfW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_DIRECTX_INIT_FAILED_X), LOWORD(hRes));

					// NOTE: *A 'SUGGESTION' SCREEN SHOULD APPEAR NEXT, PROVIDED BY THE CALLER*
					MessageBoxW(m_hwnd, str,
							    WASABI_API_LNGSTRINGW(IDS_MILKDROP_ERROR),
							    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
					return FALSE;
				}
			}
			else
			{
				device_ok = 1;
			}
		}

		iteration++;
	}
	while (!device_ok);

	// set initial viewport
	SetViewport();

	// for desktop mode, push window to back again:
	if (m_current_mode.screenmode==DESKTOP)
		SetWindowPos(m_hwnd,HWND_BOTTOM,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);

	if (m_current_mode.m_skin)
	{
		if (GetWinampVersion(mod1.hwndParent) < 0x5051) 
			SetFocus(m_current_mode.parent_window);
		else
			PostMessage(m_current_mode.parent_window, WM_USER+103, 0, 0); 
		
		//SetActiveWindow(m_current_mode.parent_window);
		//SetForegroundWindow(m_current_mode.parent_window);
	}

	/*if (m_current_mode.screenmode == WINDOWED)
		SaveWindow();*/

	// return success
	m_ready = TRUE;
	// benski> a little hack to get the window size correct. it seems to work
	if (m_current_mode.screenmode==WINDOWED)
		PostMessage(m_hwnd, WM_USER+555, 0, 0);
	return TRUE;
}
コード例 #24
0
void RestoreWindowRect(int& left, int& top, int& width, int& height, int& showCmd)
{
	// Start with Registry data
	GetRegistryInt(PREF_WINPOS_FOLDER, PREF_LEFT,		NULL, left);
	GetRegistryInt(PREF_WINPOS_FOLDER, PREF_TOP,		NULL, top);
	GetRegistryInt(PREF_WINPOS_FOLDER, PREF_WIDTH,		NULL, width);
	GetRegistryInt(PREF_WINPOS_FOLDER, PREF_HEIGHT,		NULL, height);
	GetRegistryInt(PREF_WINPOS_FOLDER, PREF_SHOWSTATE,  NULL, showCmd);

	// If window size has changed, we may need to alter window size
	HMONITOR	hMonitor;
	MONITORINFO	mi;
	RECT		rcOrig, rcMax;

	// Get the nearest monitor to the passed rect
	rcOrig.left   = left;
	rcOrig.top    = top;
	rcOrig.right  = left + width;
	rcOrig.bottom = top  + height;
	hMonitor = MonitorFromRect(&rcOrig, MONITOR_DEFAULTTONEAREST);

	// Get the monitor rect
	mi.cbSize = sizeof(mi);
	GetMonitorInfo(hMonitor, &mi);
	rcMax = mi.rcMonitor;

	if (showCmd == SW_MAXIMIZE)
	{
		// For maximized case, just use monitor dimensions
		left   = rcMax.left;
		top    = rcMax.top;
		width  = rcMax.right  - rcMax.left;
		height = rcMax.bottom - rcMax.top;
	}
	else
	{
		// For non-maximized case, adjust window to fit on screen

		// make sure width fits
		int rcMaxWidth = static_cast<int>(rcMax.right - rcMax.left);
		if (width > rcMaxWidth)
			width = rcMaxWidth;

		// make sure left is on screen
		if (left < rcMax.left)
			left = static_cast<int>(rcMax.left);

		// make sure right is on screen
		if ((left + width) > rcMax.right)
			left = static_cast<int>(rcMax.right) - width;

		// make sure height fits
		int rcMaxHeight = static_cast<int>(rcMax.bottom - rcMax.top);
		if (height > rcMaxHeight)
			height = rcMaxHeight;

		// make sure top is on screen
		if (top < rcMax.top)
			top = static_cast<int>(rcMax.top);

		// make sure bottom is on screen
		if ((top + height) > rcMax.bottom)
			top = static_cast<int>(rcMax.bottom) - height;
	}
}
コード例 #25
0
ファイル: GHOST_WindowWin32.cpp プロジェクト: pawkoz/dyplom
GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system,
        const STR_String &title,
        GHOST_TInt32 left,
        GHOST_TInt32 top,
        GHOST_TUns32 width,
        GHOST_TUns32 height,
        GHOST_TWindowState state,
        GHOST_TDrawingContextType type,
        bool wantStereoVisual,
        GHOST_TUns16 wantNumOfAASamples,
        GHOST_TEmbedderWindowID parentwindowhwnd,
        bool is_debug)
    : GHOST_Window(width, height, state,
                   wantStereoVisual, false, wantNumOfAASamples),
      m_inLiveResize(false),
      m_system(system),
      m_hDC(0),
      m_hasMouseCaptured(false),
      m_hasGrabMouse(false),
      m_nPressedButtons(0),
      m_customCursor(0),
      m_wintab(NULL),
      m_tabletData(NULL),
      m_tablet(0),
      m_maxPressure(0),
      m_normal_state(GHOST_kWindowStateNormal),
      m_parentWindowHwnd(parentwindowhwnd),
      m_debug_context(is_debug)
{
	OSVERSIONINFOEX versionInfo;
	bool hasMinVersionForTaskbar = false;
	
	ZeroMemory(&versionInfo, sizeof(OSVERSIONINFOEX));
	
	versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
	
	if (!GetVersionEx((OSVERSIONINFO *)&versionInfo)) {
		versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
		if (GetVersionEx((OSVERSIONINFO *)&versionInfo)) {
			if ((versionInfo.dwMajorVersion == 6 && versionInfo.dwMinorVersion >= 1) ||
			    (versionInfo.dwMajorVersion >= 7))
			{
				hasMinVersionForTaskbar = true;
			}
		}
	}
	else {
		if ((versionInfo.dwMajorVersion == 6 && versionInfo.dwMinorVersion >= 1) ||
		    (versionInfo.dwMajorVersion >= 7))
		{
			hasMinVersionForTaskbar = true;
		}
	}

	if (state != GHOST_kWindowStateFullScreen) {
		RECT rect;
		MONITORINFO monitor;
		GHOST_TUns32 tw, th; 

#ifndef _MSC_VER
		int cxsizeframe = GetSystemMetrics(SM_CXSIZEFRAME);
		int cysizeframe = GetSystemMetrics(SM_CYSIZEFRAME);
#else
		// MSVC 2012+ returns bogus values from GetSystemMetrics, bug in Windows
		// http://connect.microsoft.com/VisualStudio/feedback/details/753224/regression-getsystemmetrics-delivers-different-values
		RECT cxrect = {0, 0, 0, 0};
		AdjustWindowRectEx(&cxrect, WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_THICKFRAME | WS_DLGFRAME, FALSE, 0);

		int cxsizeframe = abs(cxrect.bottom);
		int cysizeframe = abs(cxrect.left);
#endif

		width += cxsizeframe * 2;
		height += cysizeframe * 2 + GetSystemMetrics(SM_CYCAPTION);

		rect.left = left;
		rect.right = left + width;
		rect.top = top;
		rect.bottom = top + height;

		monitor.cbSize = sizeof(monitor);
		monitor.dwFlags = 0;

		// take taskbar into account
		GetMonitorInfo(MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST), &monitor);

		th = monitor.rcWork.bottom - monitor.rcWork.top;
		tw = monitor.rcWork.right - monitor.rcWork.left;

		if (tw < width) {
			width = tw;
			left = monitor.rcWork.left;
		}
		else if (monitor.rcWork.right < left + (int)width)
			left = monitor.rcWork.right - width;
		else if (left < monitor.rcWork.left)
			left = monitor.rcWork.left;

		if (th < height) {
			height = th;
			top = monitor.rcWork.top;
		}
		else if (monitor.rcWork.bottom < top + (int)height)
			top = monitor.rcWork.bottom - height;
		else if (top < monitor.rcWork.top)
			top = monitor.rcWork.top;

		int wintype = WS_OVERLAPPEDWINDOW;
		if (m_parentWindowHwnd != 0) {
			wintype = WS_CHILD;
			GetWindowRect((HWND)m_parentWindowHwnd, &rect);
			left = 0;
			top = 0;
			width = rect.right - rect.left;
			height = rect.bottom - rect.top;
		}
		
		wchar_t *title_16 = alloc_utf16_from_8((char *)(const char *)title, 0);
		m_hWnd = ::CreateWindowW(
		    s_windowClassName,          // pointer to registered class name
		    title_16,                   // pointer to window name
		    wintype,                    // window style
		    left,                       // horizontal position of window
		    top,                        // vertical position of window
		    width,                      // window width
		    height,                     // window height
		    (HWND) m_parentWindowHwnd,  // handle to parent or owner window
		    0,                          // handle to menu or child-window identifier
		    ::GetModuleHandle(0),       // handle to application instance
		    0);                         // pointer to window-creation data
		free(title_16);
	}
	else {
		wchar_t *title_16 = alloc_utf16_from_8((char *)(const char *)title, 0);
		m_hWnd = ::CreateWindowW(
		    s_windowClassName,          // pointer to registered class name
		    title_16,                   // pointer to window name
		    WS_POPUP | WS_MAXIMIZE,     // window style
		    left,                       // horizontal position of window
		    top,                        // vertical position of window
		    width,                      // window width
		    height,                     // window height
		    HWND_DESKTOP,               // handle to parent or owner window
		    0,                          // handle to menu or child-window identifier
		    ::GetModuleHandle(0),       // handle to application instance
		    0);                         // pointer to window-creation data
		free(title_16);
	}
	if (m_hWnd) {
		// Register this window as a droptarget. Requires m_hWnd to be valid.
		// Note that OleInitialize(0) has to be called prior to this. Done in GHOST_SystemWin32.
		m_dropTarget = new GHOST_DropTargetWin32(this, m_system);
		if (m_dropTarget) {
			::RegisterDragDrop(m_hWnd, m_dropTarget);
		}

		// Store a pointer to this class in the window structure
		::SetWindowLongPtr(m_hWnd, GWLP_USERDATA, (LONG_PTR) this);

		// Store the device context
		m_hDC = ::GetDC(m_hWnd);

		GHOST_TSuccess success = setDrawingContextType(type);

		if (success) {
			// Show the window
			int nCmdShow;
			switch (state) {
				case GHOST_kWindowStateMaximized:
					nCmdShow = SW_SHOWMAXIMIZED;
					break;
				case GHOST_kWindowStateMinimized:
					nCmdShow = SW_SHOWMINIMIZED;
					break;
				case GHOST_kWindowStateNormal:
				default:
					nCmdShow = SW_SHOWNORMAL;
					break;
			}

			::ShowWindow(m_hWnd, nCmdShow);
			// Force an initial paint of the window
			::UpdateWindow(m_hWnd);
		}
		else {
			//invalidate the window
			::DestroyWindow(m_hWnd);
			m_hWnd = NULL;
		}
	}

	if (parentwindowhwnd != 0) {
		RAWINPUTDEVICE device = {0};
		device.usUsagePage  = 0x01; /* usUsagePage & usUsage for keyboard*/
		device.usUsage      = 0x06; /* http://msdn.microsoft.com/en-us/windows/hardware/gg487473.aspx */
		device.dwFlags |= RIDEV_INPUTSINK; // makes WM_INPUT is visible for ghost when has parent window
		device.hwndTarget = m_hWnd;
		RegisterRawInputDevices(&device, 1, sizeof(device));
	}

	m_wintab = ::LoadLibrary("Wintab32.dll");
	if (m_wintab) {
		GHOST_WIN32_WTInfo fpWTInfo = (GHOST_WIN32_WTInfo) ::GetProcAddress(m_wintab, "WTInfoA");
		GHOST_WIN32_WTOpen fpWTOpen = (GHOST_WIN32_WTOpen) ::GetProcAddress(m_wintab, "WTOpenA");

		// let's see if we can initialize tablet here
		/* check if WinTab available. */
		if (fpWTInfo && fpWTInfo(0, 0, NULL)) {
			// Now init the tablet
			LOGCONTEXT lc;
			/* The maximum tablet size, pressure and orientation (tilt) */
			AXIS TabletX, TabletY, Pressure, Orientation[3];

			// Open a Wintab context

			// Get default context information
			fpWTInfo(WTI_DEFCONTEXT, 0, &lc);

			// Open the context
			lc.lcPktData = PACKETDATA;
			lc.lcPktMode = PACKETMODE;
			lc.lcOptions |= CXO_MESSAGES | CXO_SYSTEM;

			/* Set the entire tablet as active */
			fpWTInfo(WTI_DEVICES, DVC_X, &TabletX);
			fpWTInfo(WTI_DEVICES, DVC_Y, &TabletY);

			/* get the max pressure, to divide into a float */
			BOOL pressureSupport = fpWTInfo(WTI_DEVICES, DVC_NPRESSURE, &Pressure);
			if (pressureSupport)
				m_maxPressure = Pressure.axMax;
			else
				m_maxPressure = 0;

			/* get the max tilt axes, to divide into floats */
			BOOL tiltSupport = fpWTInfo(WTI_DEVICES, DVC_ORIENTATION, &Orientation);
			if (tiltSupport) {
				/* does the tablet support azimuth ([0]) and altitude ([1]) */
				if (Orientation[0].axResolution && Orientation[1].axResolution) {
					/* all this assumes the minimum is 0 */
					m_maxAzimuth = Orientation[0].axMax;
					m_maxAltitude = Orientation[1].axMax;
				}
				else {  /* no so dont do tilt stuff */
					m_maxAzimuth = m_maxAltitude = 0;
				}
			}

			if (fpWTOpen) {
				m_tablet = fpWTOpen(m_hWnd, &lc, TRUE);
				if (m_tablet) {
					m_tabletData = new GHOST_TabletData();
					m_tabletData->Active = GHOST_kTabletModeNone;
				}
			}
		}
	}

	if (hasMinVersionForTaskbar)
		CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_ITaskbarList, (LPVOID *)&m_Bar);
	else
		m_Bar = NULL;
}
コード例 #26
0
ファイル: EmergencyShow.cpp プロジェクト: qyqx/ConEmu
void SetUserFriendlyFont(HWND hConWnd, int newFontY = 0, int newFontX = 0)
{
	// Соответствующие функции появились только в API Vista
	// Win2k & WinXP - доступны только хаки, что не подходит
	_ASSERTE(_WIN32_WINNT_VISTA==0x600);
	OSVERSIONINFOEXW osvi = {sizeof(osvi), HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA)};
	DWORDLONG const dwlConditionMask = VerSetConditionMask(VerSetConditionMask(0, VER_MAJORVERSION, VER_GREATER_EQUAL), VER_MINORVERSION, VER_GREATER_EQUAL);
	if (!VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION, dwlConditionMask))
		return;

	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD crVisibleSize = {};
	CONSOLE_SCREEN_BUFFER_INFO csbi = {};
	if (GetConsoleScreenBufferInfo(hOutput, &csbi))
	{
		crVisibleSize.X = csbi.srWindow.Right - csbi.srWindow.Left + 1;
		crVisibleSize.Y = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
	}

	if ((crVisibleSize.X <= 0) || (crVisibleSize.Y <= 0))
	{
		_ASSERTE((crVisibleSize.X > 0) && (crVisibleSize.Y > 0));
		return;
	}

	int curSizeY = 0, curSizeX = 0;
	wchar_t sFontName[LF_FACESIZE] = L"";

	if (apiGetConsoleFontSize(hOutput, curSizeY, curSizeX, sFontName) && curSizeY && curSizeX)
	{
		if (newFontY <= 0 || newFontX <= 0)
		{
			DEBUGTEST(COORD crLargest = MyGetLargestConsoleWindowSize(hOutput));

			HMONITOR hMon = MonitorFromWindow(hConWnd, MONITOR_DEFAULTTOPRIMARY);
			MONITORINFO mi = {sizeof(mi)};
			int nMaxX = 0, nMaxY = 0;
			if (GetMonitorInfo(hMon, &mi))
			{
				nMaxX = mi.rcWork.right - mi.rcWork.left - 2*GetSystemMetrics(SM_CXSIZEFRAME) - GetSystemMetrics(SM_CYCAPTION);
				nMaxY = mi.rcWork.bottom - mi.rcWork.top - 2*GetSystemMetrics(SM_CYSIZEFRAME);
			}

			if ((nMaxX > 0) && (nMaxY > 0))
			{
				int nFontX = nMaxX  / crVisibleSize.X;
				int nFontY = nMaxY / crVisibleSize.Y;
				// Too large height?
				if (nFontY > 28)
				{
					nFontX = 28 * nFontX / nFontY;
					nFontY = 28;
				}

				// Evaluate default width for the font
				int nEvalX = EvaluateDefaultFontWidth(nFontY, sFontName);
				if (nEvalX > 0)
				{
					if ((nEvalX > nFontX) && (nFontX > 0))
						nFontY = nFontX * nFontY / nEvalX;
					else
						nFontX = nEvalX;
				}

				// Look in the registry?
				HKEY hk;
				DWORD nRegSize = 0, nLen;
				if (!RegOpenKeyEx(HKEY_CURRENT_USER, L"Console", 0, KEY_READ, &hk))
				{
					if (RegQueryValueEx(hk, L"FontSize", NULL, NULL, (LPBYTE)&nRegSize, &(nLen=sizeof(nRegSize))) || nLen!=sizeof(nRegSize))
						nRegSize = 0;
					RegCloseKey(hk);
				}
				if (!nRegSize && !RegOpenKeyEx(HKEY_CURRENT_USER, L"Console\\%SystemRoot%_system32_cmd.exe", 0, KEY_READ, &hk))
				{
					if (RegQueryValueEx(hk, L"FontSize", NULL, NULL, (LPBYTE)&nRegSize, &(nLen=sizeof(nRegSize))) || nLen!=sizeof(nRegSize))
						nRegSize = 0;
					RegCloseKey(hk);
				}
				if ((HIWORD(nRegSize) > curSizeY) && (HIWORD(nRegSize) < nFontY)
					&& (LOWORD(nRegSize) > curSizeX) && (LOWORD(nRegSize) < nFontX))
				{
					nFontY = HIWORD(nRegSize);
					nFontX = LOWORD(nRegSize);
				}

				if ((nFontX > curSizeX) || (nFontY > curSizeY))
				{
					newFontY = nFontY; newFontX = nFontX;
				}
			}
		}
	}

	if ((newFontY > 0) && (newFontX > 0))
	{
		if (!*sFontName)
			lstrcpyn(sFontName, L"Lucida Console", countof(sFontName));
		apiSetConsoleFontSize(hOutput, newFontY, newFontX, sFontName);
	}
}
コード例 #27
0
bool Win32Factory::init()
{
    const char* vlc_name = "VLC Media Player";
    const char* vlc_icon = "VLC_ICON";
    const char* vlc_class = "SkinWindowClass";

    // Get instance handle
    m_hInst = GetModuleHandle( NULL );
    if( m_hInst == NULL )
    {
        msg_Err( getIntf(), "Cannot get module handle" );
    }

    // Create window class
    WNDCLASS skinWindowClass;
    skinWindowClass.style = CS_DBLCLKS;
    skinWindowClass.lpfnWndProc = (WNDPROC)Win32Factory::Win32Proc;
    skinWindowClass.lpszClassName = _T(vlc_class);
    skinWindowClass.lpszMenuName = NULL;
    skinWindowClass.cbClsExtra = 0;
    skinWindowClass.cbWndExtra = 0;
    skinWindowClass.hbrBackground = NULL;
    skinWindowClass.hCursor = LoadCursor( NULL, IDC_ARROW );
    skinWindowClass.hIcon = LoadIcon( m_hInst, _T(vlc_icon) );
    skinWindowClass.hInstance = m_hInst;

    // Register class and check it
    if( !RegisterClass( &skinWindowClass ) )
    {
        WNDCLASS wndclass;

        // Check why it failed. If it's because the class already exists
        // then fine, otherwise return with an error.
        if( !GetClassInfo( m_hInst, _T(vlc_class), &wndclass ) )
        {
            msg_Err( getIntf(), "cannot register window class" );
            return false;
        }
    }

    // Create Window
    m_hParentWindow = CreateWindowEx( WS_EX_TOOLWINDOW, _T(vlc_class),
        _T(vlc_name), WS_POPUP | WS_SYSMENU | WS_MINIMIZEBOX,
        -200, -200, 0, 0, 0, 0, m_hInst, 0 );
    if( m_hParentWindow == NULL )
    {
        msg_Err( getIntf(), "cannot create parent window" );
        return false;
    }

    // Store with it a pointer to the interface thread
    SetWindowLongPtr( m_hParentWindow, GWLP_USERDATA, (LONG_PTR)getIntf() );

    // We do it this way otherwise CreateWindowEx will fail
    // if WS_EX_LAYERED is not supported
    SetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE,
                      GetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE ) |
                      WS_EX_LAYERED );

    ShowWindow( m_hParentWindow, SW_SHOW );

    // Initialize the systray icon
    m_trayIcon.cbSize = sizeof( NOTIFYICONDATA );
    m_trayIcon.hWnd = m_hParentWindow;
    m_trayIcon.uID = 42;
    m_trayIcon.uFlags = NIF_ICON|NIF_TIP|NIF_MESSAGE;
    m_trayIcon.uCallbackMessage = MY_WM_TRAYACTION;
    m_trayIcon.hIcon = LoadIcon( m_hInst, _T(vlc_icon) );
    strcpy( m_trayIcon.szTip, vlc_name );

    // Show the systray icon if needed
    if( var_InheritBool( getIntf(), "skins2-systray" ) )
    {
        addInTray();
    }

    // Show the task in the task bar if needed
    if( var_InheritBool( getIntf(), "skins2-taskbar" ) )
    {
        addInTaskBar();
    }

    // Initialize the OLE library (for drag & drop)
    OleInitialize( NULL );

    // Initialize the resource path
    char *datadir = config_GetUserDir( VLC_DATA_DIR );
    m_resourcePath.push_back( (string)datadir + "\\skins" );
    free( datadir );
    datadir = config_GetDataDir( getIntf() );
    m_resourcePath.push_back( (string)datadir + "\\skins" );
    m_resourcePath.push_back( (string)datadir + "\\skins2" );
    m_resourcePath.push_back( (string)datadir + "\\share\\skins" );
    m_resourcePath.push_back( (string)datadir + "\\share\\skins2" );
    free( datadir );

    // Enumerate all monitors available
    EnumDisplayMonitors( NULL, NULL, MonitorEnumProc, (LPARAM)&m_monitorList );
    int num = 0;
    for( list<HMONITOR>::iterator it = m_monitorList.begin();
         it != m_monitorList.end(); ++it, num++ )
    {
        MONITORINFO mi;
        mi.cbSize = sizeof( MONITORINFO );
        if( GetMonitorInfo( *it, &mi ) )
        {
            msg_Dbg( getIntf(), "monitor #%i, %ldx%ld at +%ld+%ld", num,
                        mi.rcMonitor.right - mi.rcMonitor.left,
                        mi.rcMonitor.bottom - mi.rcMonitor.top,
                        mi.rcMonitor.left,
                        mi.rcMonitor.top );
        }
    }

    // All went well
    return true;
}
コード例 #28
0
/** Toggle native window between fullscreen and normal mode */
void FWindowsWindow::SetWindowMode( EWindowMode::Type NewWindowMode )
{
	EWindowMode::Type InNewWindowMode = NewWindowMode;

	if (InNewWindowMode == EWindowMode::WindowedMirror)
	{
		// treat WindowedMirror as a regular Windowed mode here
		InNewWindowMode = EWindowMode::Windowed;
	}

	if( InNewWindowMode != WindowMode )
	{
		bool bTrueFullscreen = NewWindowMode == EWindowMode::Fullscreen;

		// Setup Win32 Flags to be used for Fullscreen mode
		LONG WindowFlags = GetWindowLong(HWnd, GWL_STYLE);
		const LONG FullscreenFlags = WS_POPUP;
		const LONG RestoredFlags = WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_OVERLAPPED | WS_BORDER;

		// If we're not in fullscreen, make it so
		if( NewWindowMode == EWindowMode::WindowedFullscreen || NewWindowMode == EWindowMode::Fullscreen)
		{
			::GetWindowPlacement(HWnd, &PreFullscreenWindowPlacement);

			// Setup Win32 flags for fullscreen window
			WindowFlags &= ~RestoredFlags;
			WindowFlags |= FullscreenFlags;

			SetWindowLong(HWnd, GWL_STYLE, WindowFlags);
			::SetWindowPos(HWnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

			if (!bTrueFullscreen)
			{
				// Ensure the window is restored if we are going for WindowedFullscreen
				ShowWindow(HWnd, SW_RESTORE);
			}

			// Get the current window position.
			RECT ClientRect;
			GetClientRect(HWnd, &ClientRect);

			// Grab current monitor data for sizing
			HMONITOR Monitor = MonitorFromWindow( HWnd, bTrueFullscreen ? MONITOR_DEFAULTTOPRIMARY : MONITOR_DEFAULTTONEAREST );
			MONITORINFO MonitorInfo;
			MonitorInfo.cbSize = sizeof(MONITORINFO);
			GetMonitorInfo( Monitor, &MonitorInfo );

			// Get the target client width to send to ReshapeWindow.
			// Preserve the current res if going to true fullscreen and the monitor supports it and allow the calling code
			// to resize if required.
			// Else, use the monitor's res for windowed fullscreen.
			LONG MonitorWidth  = MonitorInfo.rcMonitor.right - MonitorInfo.rcMonitor.left;
			LONG TargetClientWidth = bTrueFullscreen ?
				FMath::Min(MonitorWidth, ClientRect.right - ClientRect.left) :
				MonitorWidth;

			LONG MonitorHeight = MonitorInfo.rcMonitor.bottom - MonitorInfo.rcMonitor.top;
			LONG TargetClientHeight = bTrueFullscreen ?
				FMath::Min(MonitorHeight, ClientRect.bottom - ClientRect.top) :
				MonitorHeight;


			// Resize and position fullscreen window
			ReshapeWindow(
				MonitorInfo.rcMonitor.left,
				MonitorInfo.rcMonitor.top,
				TargetClientWidth,
				TargetClientHeight);
		}
		else
		{
			// Windowed:

			// Setup Win32 flags for restored window
			WindowFlags &= ~FullscreenFlags;
			WindowFlags |= RestoredFlags;
			SetWindowLong(HWnd, GWL_STYLE, WindowFlags);
			::SetWindowPos(HWnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

			::SetWindowPlacement(HWnd, &PreFullscreenWindowPlacement);
		}

		WindowMode = NewWindowMode;
	}
}
コード例 #29
0
	D3D11VideoOutputInfo::D3D11VideoOutputInfo(IDXGIOutput* output, UINT32 outputIdx)
		:mDXGIOutput(output)
	{
		DXGI_OUTPUT_DESC outputDesc;
		output->GetDesc(&outputDesc);
		mName = UTF8::fromWide(WString(outputDesc.DeviceName));

		UINT32 numModes = 0;

		HRESULT hr = output->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, 0, &numModes, nullptr);
		if (FAILED(hr))
		{
			SAFE_RELEASE(output);
			BS_EXCEPT(InternalErrorException, "Error while enumerating adapter output video modes.");
		}

		DXGI_MODE_DESC* modeDesc = bs_newN<DXGI_MODE_DESC>(numModes);

		hr = output->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, 0, &numModes, modeDesc);
		if (FAILED(hr))
		{
			bs_deleteN(modeDesc, numModes);

			SAFE_RELEASE(output);
			BS_EXCEPT(InternalErrorException, "Error while enumerating adapter output video modes.");
		}

		for (UINT32 i = 0; i < numModes; i++)
		{
			DXGI_MODE_DESC displayMode = modeDesc[i];

			bool foundVideoMode = false;
			for (auto videoMode : mVideoModes)
			{
				D3D11VideoMode* d3d11videoMode = static_cast<D3D11VideoMode*>(videoMode);

				if (d3d11videoMode->mWidth == displayMode.Width && d3d11videoMode->mHeight == displayMode.Height &&
					d3d11videoMode->mRefreshRateNumerator == displayMode.RefreshRate.Numerator &&
					d3d11videoMode->mRefreshRateDenominator == displayMode.RefreshRate.Denominator)
				{
					foundVideoMode = true;
					break;
				}
			}

			if (!foundVideoMode)
			{
				float refreshRate = displayMode.RefreshRate.Numerator / (float)displayMode.RefreshRate.Denominator;
				D3D11VideoMode* videoMode = bs_new<D3D11VideoMode>(displayMode.Width, displayMode.Height, refreshRate,
					outputIdx, displayMode.RefreshRate.Numerator, displayMode.RefreshRate.Denominator, displayMode);

				mVideoModes.push_back(videoMode);
			}
		}

		bs_deleteN(modeDesc, numModes);

		// Get desktop display mode
		HMONITOR hMonitor = outputDesc.Monitor;
		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);

		DXGI_MODE_DESC currentMode;
		currentMode.Width = devMode.dmPelsWidth;
		currentMode.Height = devMode.dmPelsHeight;
		bool useDefaultRefreshRate = 1 == devMode.dmDisplayFrequency || 0 == devMode.dmDisplayFrequency;
		currentMode.RefreshRate.Numerator = useDefaultRefreshRate ? 0 : devMode.dmDisplayFrequency;
		currentMode.RefreshRate.Denominator = useDefaultRefreshRate ? 0 : 1;
		currentMode.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
		currentMode.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
		currentMode.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

		DXGI_MODE_DESC nearestMode;
		ZeroMemory(&nearestMode, sizeof(nearestMode));

		output->FindClosestMatchingMode(&currentMode, &nearestMode, nullptr);

		float refreshRate = nearestMode.RefreshRate.Numerator / (float)nearestMode.RefreshRate.Denominator;
		mDesktopVideoMode = bs_new<D3D11VideoMode>(nearestMode.Width, nearestMode.Height, refreshRate, 
			outputIdx, nearestMode.RefreshRate.Numerator, nearestMode.RefreshRate.Denominator, nearestMode);
	}
コード例 #30
0
/*****************************Private*Routine******************************\
* GetAMDDrawMonitorInfo
*
*
*
* History:
* Tue 08/17/1999 - StEstrop - Created
*
\**************************************************************************/
BOOL CMonitorArray::GetAMDDrawMonitorInfo(
    UINT uDevID,
    _Out_ CAMDDrawMonitorInfo* lpmi,
    _In_ HMONITOR hm
    )
{
    MONITORINFOEX miInfoEx;
    miInfoEx.cbSize = sizeof(miInfoEx);

    lpmi->hMon = NULL;
    lpmi->uDevID = 0;
    lpmi->physMonDim.cx = 0;
    lpmi->physMonDim.cy = 0;
    lpmi->dwRefreshRate = DEFAULT_DENSITY_LIMIT;

    if (GetMonitorInfo(hm, &miInfoEx))
    {
        HRESULT hr = StringCchCopy(lpmi->szDevice, sizeof(lpmi->szDevice)/sizeof(lpmi->szDevice[0]), miInfoEx.szDevice);

        if ( FAILED( hr ) )
        {
            return FALSE;
        }

        lpmi->hMon = hm;
        lpmi->uDevID = uDevID;
        lpmi->physMonDim.cx = WIDTH(&miInfoEx.rcMonitor);
        lpmi->physMonDim.cy = HEIGHT(&miInfoEx.rcMonitor);

        int j = 0;
        DISPLAY_DEVICE ddMonitor;

        ddMonitor.cb = sizeof(ddMonitor);
        while (EnumDisplayDevices(lpmi->szDevice, j, &ddMonitor, 0))
        {
            if (ddMonitor.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
            {
                DEVMODE     dm;

                ZeroMemory(&dm, sizeof(dm));
                dm.dmSize = sizeof(dm);
                if (EnumDisplaySettings(lpmi->szDevice, ENUM_CURRENT_SETTINGS, &dm))
                {
                    lpmi->dwRefreshRate = dm.dmDisplayFrequency == 0 ? lpmi->dwRefreshRate : dm.dmDisplayFrequency;
                }

                // Remove registry snooping for monitor dimensions, as this is not supported by LDDM.
                // if (!FindMonitorDimensions(ddMonitor.DeviceID, &lpmi->physMonDim.cx, &lpmi->physMonDim.cy))
                {
                    lpmi->physMonDim.cx = WIDTH(&miInfoEx.rcMonitor);
                    lpmi->physMonDim.cy = HEIGHT(&miInfoEx.rcMonitor);
                }
            }
            j++;
        }

        return TRUE;
    }

    return FALSE;
}