コード例 #1
1
ファイル: wf_interface.c プロジェクト: 10084462/FreeRDP
int get_screen_info(int id, _TCHAR* name, int* width, int* height, int* bpp)
{
	DISPLAY_DEVICE dd;

	memset(&dd, 0, sizeof(DISPLAY_DEVICE));
	dd.cb = sizeof(DISPLAY_DEVICE);

	if (EnumDisplayDevices(NULL, id, &dd, 0) != 0)
	{
		HDC dc;

		if (name != NULL)
			_stprintf(name, _T("%s (%s)"), dd.DeviceName, dd.DeviceString);

		dc = CreateDC(dd.DeviceName, NULL, NULL, NULL);
		*width = GetDeviceCaps(dc, HORZRES);
		*height = GetDeviceCaps(dc, VERTRES);
		*bpp = GetDeviceCaps(dc, BITSPIXEL);
		//ReleaseDC(NULL, dc);
		DeleteDC(dc);

	}
	else
	{
		return 0;
	}

	return 1;
}
コード例 #2
0
ファイル: setbpp.cpp プロジェクト: pysysops/setbpp
int _tmain(int argc, _TCHAR* argv[])
{
	int deviceIndex=0;
	int result;
	DWORD bpp=16;

	do
	{
		PDISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();
		displayDevice->cb = sizeof(DISPLAY_DEVICE);

		result = EnumDisplayDevices(NULL, 
			deviceIndex++, displayDevice, 0);
		if (displayDevice->StateFlags & DISPLAY_DEVICE_ACTIVE)
		{
			PDISPLAY_DEVICE monitor = new DISPLAY_DEVICE();
			monitor->cb = sizeof(DISPLAY_DEVICE);

			EnumDisplayDevices(displayDevice->DeviceName, 
				0, monitor, 0);
			
			PDEVMODE dm = new DEVMODE();
			
			if ( EnumDisplaySettings(displayDevice->DeviceName,
				ENUM_CURRENT_SETTINGS, dm) )
			{
				dm->dmBitsPerPel=(DWORD)bpp;
				ChangeDisplaySettingsEx(displayDevice->DeviceName, dm,  \
                                     NULL, (CDS_GLOBAL | CDS_UPDATEREGISTRY | CDS_RESET), NULL);
			}
		}
	} while (result);
	return 0;
}
コード例 #3
0
ファイル: win_glimp.cpp プロジェクト: neilogd/DOOM-3-BFG
/*
========================
GetDisplayCoordinates
========================
*/
static bool GetDisplayCoordinates( const int deviceNum, int & x, int & y, int & width, int & height, int & displayHz ) {
    idStr deviceName = GetDeviceName( deviceNum );
    if ( deviceName.Length() == 0 ) {
        return false;
    }

    DISPLAY_DEVICE	device = {};
    device.cb = sizeof( device );
    if ( !EnumDisplayDevices(
                0,			// lpDevice
                deviceNum,
                &device,
                0 /* dwFlags */ ) ) {
        return false;
    }

    DISPLAY_DEVICE	monitor;
    monitor.cb = sizeof( monitor );
    if ( !EnumDisplayDevices(
                deviceName.c_str(),
                0,
                &monitor,
                0 /* dwFlags */ ) ) {
        return false;
    }

    DEVMODE	devmode;
    devmode.dmSize = sizeof( devmode );
    if ( !EnumDisplaySettings( deviceName.c_str(),ENUM_CURRENT_SETTINGS, &devmode ) ) {
        return false;
    }

    common->Printf( "display device: %i\n", deviceNum );
    common->Printf( "  DeviceName  : %s\n", device.DeviceName );
    common->Printf( "  DeviceString: %s\n", device.DeviceString );
    common->Printf( "  StateFlags  : 0x%x\n", device.StateFlags );
    common->Printf( "  DeviceID    : %s\n", device.DeviceID );
    common->Printf( "  DeviceKey   : %s\n", device.DeviceKey );
    common->Printf( "      DeviceName  : %s\n", monitor.DeviceName );
    common->Printf( "      DeviceString: %s\n", monitor.DeviceString );
    common->Printf( "      StateFlags  : 0x%x\n", monitor.StateFlags );
    common->Printf( "      DeviceID    : %s\n", monitor.DeviceID );
    common->Printf( "      DeviceKey   : %s\n", monitor.DeviceKey );
    common->Printf( "          dmPosition.x      : %i\n", devmode.dmPosition.x );
    common->Printf( "          dmPosition.y      : %i\n", devmode.dmPosition.y );
    common->Printf( "          dmBitsPerPel      : %i\n", devmode.dmBitsPerPel );
    common->Printf( "          dmPelsWidth       : %i\n", devmode.dmPelsWidth );
    common->Printf( "          dmPelsHeight      : %i\n", devmode.dmPelsHeight );
    common->Printf( "          dmDisplayFlags    : 0x%x\n", devmode.dmDisplayFlags );
    common->Printf( "          dmDisplayFrequency: %i\n", devmode.dmDisplayFrequency );

    x = devmode.dmPosition.x;
    y = devmode.dmPosition.y;
    width = devmode.dmPelsWidth;
    height = devmode.dmPelsHeight;
    displayHz = devmode.dmDisplayFrequency;

    return true;
}
コード例 #4
0
ファイル: OCPNPlatform.cpp プロジェクト: vonwenm/OpenCPN
bool GetWindowsMonitorSize( int *width, int *height)
{
    int WidthMm = 0;
    int HeightMm = 0;
    
    DISPLAY_DEVICE dd;
    dd.cb = sizeof(dd);
    DWORD dev = 0; // device index
    int id = 1; // monitor number, as used by Display Properties > Settings
    
    wxString DeviceID;
    bool bFoundDevice = false;
    while (EnumDisplayDevices(0, dev, &dd, 0) && !bFoundDevice)
    {
        DISPLAY_DEVICE ddMon;
        ZeroMemory(&ddMon, sizeof(ddMon));
        ddMon.cb = sizeof(ddMon);
        DWORD devMon = 0;
        
        while (EnumDisplayDevices(dd.DeviceName, devMon, &ddMon, 0) && !bFoundDevice)
        {
            if (ddMon.StateFlags & DISPLAY_DEVICE_ACTIVE &&
                !(ddMon.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER))
            {
                DeviceID = wxString(ddMon.DeviceID, wxConvUTF8);
                DeviceID = DeviceID.Mid (8);
                DeviceID = DeviceID.Mid (0, DeviceID.Find ( '\\' ));
                
                bFoundDevice = GetSizeForDevID(DeviceID, &WidthMm, &HeightMm);
            }
            devMon++;
            
            ZeroMemory(&ddMon, sizeof(ddMon));
            ddMon.cb = sizeof(ddMon);
        }
        
        ZeroMemory(&dd, sizeof(dd));
        dd.cb = sizeof(dd);
        dev++;
    }
    
    if(width)
        *width = WidthMm;
    if(height)
        *height = HeightMm;
    
    return bFoundDevice;
}
コード例 #5
0
BOOL CMonitorManager::GetMonitorResolution(HWND hWnd, long *lResoluteW, long *lResoluteH)
{
	HMONITOR hm = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
	
	BOOL bFindMonitor = FALSE;

	for(int i = 0; i < m_MonitorList.size(); i++)
	{
		if (hm == m_MonitorList[i].hMonitor)
		{
			bFindMonitor = TRUE;
			break;
		}
	}

	if (!bFindMonitor) return FALSE;
	
	DISPLAY_DEVICE dd;
	ZeroMemory(&dd, sizeof(DISPLAY_DEVICE));
	dd.cb = sizeof(DISPLAY_DEVICE);
	bFindMonitor = EnumDisplayDevices(NULL, i, &dd, 0);
	if (!bFindMonitor) return FALSE;
	
	DEVMODE dm;
	ZeroMemory(&dm, sizeof(DEVMODE));
	dm.dmSize = sizeof(dm);
	bFindMonitor = EnumDisplaySettings((char*)dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm);
	if (!bFindMonitor) return FALSE;
	
	*lResoluteW = dm.dmPelsWidth;
	*lResoluteH = dm.dmPelsHeight;
	
	return TRUE;
}
コード例 #6
0
ファイル: _VeWindows.cpp プロジェクト: Napoleon314/Venus2D
//--------------------------------------------------------------------------
VE_BOOL VeWindows::AddDisplay(LPSTR DeviceName)
{
	VeDevice::VideoDisplay kDisplay;
	DisplayData* pkDisplayData;
	VeDevice::DisplayMode kMode;
	DISPLAY_DEVICE kDevice;
	if(!GetDisplayMode(DeviceName, ENUM_CURRENT_SETTINGS, &kMode))
	{
		return VE_FALSE;
	}
	pkDisplayData = VE_NEW DisplayData;
	if(!pkDisplayData)
	{
		return VE_FALSE;
	}
	VeStrcpy(pkDisplayData->m_acDeviceName, DeviceName);
	
	kDevice.cb = sizeof(kDevice);
	if (EnumDisplayDevices(DeviceName, 0, &kDevice, 0))
	{
		kDisplay.m_kName = kDevice.DeviceString;
	}
	kDisplay.m_kDesktopMode = kMode;
	kDisplay.m_kCurrentMode = kMode;
	kDisplay.m_spDriverData = pkDisplayData;
	m_kDisplays.PushBack(kDisplay);
	return VE_TRUE;
}
コード例 #7
0
static BOOL Rotate( int iDevNum,  SHORT dmOrientation )
{
    DISPLAY_DEVICE d;
    DEVMODE dm;
    int w;
    LONG r;

    ZeroMemory( &d, sizeof( d ) );
    d.cb = sizeof( d );

    if( !EnumDisplayDevices( NULL, iDevNum, &d, 0 ) ) {
        DebugMsg( _T("EnumDisplayDevices failed:%d\r\n" ), GetLastError() );
        return FALSE;
    }

    if( !EnumDisplaySettings( d.DeviceName, ENUM_CURRENT_SETTINGS, &dm ) ){
        DebugMsg( _T("EnumDisplaySettings(\"%s\") failed:%d\r\n" ), d.DeviceName, GetLastError() );
        return FALSE;
    }

	if( dm.dmDisplayOrientation == dmOrientation ) return TRUE;
    w = dm.dmPelsHeight;
    dm.dmPelsHeight = dm.dmPelsWidth;
    dm.dmPelsWidth = w;

    dm.dmDisplayOrientation = dmOrientation;

    r = ChangeDisplaySettingsEx( d.DeviceName, &dm, NULL, CDS_UPDATEREGISTRY, NULL );
    if( r != DISP_CHANGE_SUCCESSFUL ){
        DebugMsg( _T("ChangeDisplaySettingsEx failed:%d\r\n"), r );
        return FALSE;
    }
    return TRUE;
}
コード例 #8
0
    bool output_device_enumerator_win32::enumerate_device(gl::output_device_descriptor& desc, const std::string& name)
    {
        _issues.push_back(std::string("output_device_enumerator_win32::enumerate_device(): {"));

        DISPLAY_DEVICE               disp_device;

        disp_device.cb = sizeof(DISPLAY_DEVICE);

        unsigned            dev_index = 0;
        bool                found_dev = false;

        while (!found_dev && EnumDisplayDevices(NULL, dev_index, &disp_device, 0))  {
            if (name == std::string(disp_device.DeviceName)) {
                found_dev = true;
            }
            else {
                dev_index++;
            }
        }

        if (found_dev) {
            return (this->enumerate_device(desc, dev_index));
        }
        else {
            _issues.push_back(std::string("\tError: unable to find device: ") + name);
            return (false);
        }
    }
コード例 #9
0
ファイル: win_shadow.c プロジェクト: jat255/FreeRDP
int win_shadow_enum_monitors(MONITOR_DEF* monitors, int maxMonitors)
{
	HDC hdc;
	int index;
	int desktopWidth;
	int desktopHeight;
	DWORD iDevNum = 0;
	int numMonitors = 0;
	MONITOR_DEF* monitor;
	DISPLAY_DEVICE displayDevice;
	ZeroMemory(&displayDevice, sizeof(DISPLAY_DEVICE));
	displayDevice.cb = sizeof(DISPLAY_DEVICE);

	if (EnumDisplayDevices(NULL, iDevNum, &displayDevice, 0))
	{
		hdc = CreateDC(displayDevice.DeviceName, NULL, NULL, NULL);
		desktopWidth = GetDeviceCaps(hdc, HORZRES);
		desktopHeight = GetDeviceCaps(hdc, VERTRES);
		index = 0;
		numMonitors = 1;
		monitor = &monitors[index];
		monitor->left = 0;
		monitor->top = 0;
		monitor->right = desktopWidth;
		monitor->bottom = desktopHeight;
		monitor->flags = 1;
		DeleteDC(hdc);
	}

	return numMonitors;
}
コード例 #10
0
ファイル: SystemInfo.cpp プロジェクト: viticm/pap2
HRESULT CSystemInfo::GetDisplayInfo(CString& strDisplay)
{
	DISPLAY_DEVICE displayInfo;
	DWORD		   dwIndex = 0;

	displayInfo.cb		   = sizeof(DISPLAY_DEVICE);
	displayInfo.StateFlags = 0;

	while (EnumDisplayDevices(NULL, dwIndex, &displayInfo, NULL))
	{
		dwIndex++;
		
		if (0 == _tcslen(displayInfo.DeviceID))
		{
			continue;
		}

		if (strDisplay.GetLength() > 0)
		{
			strDisplay.Append("&");
		}

		strDisplay.Append(displayInfo.DeviceString);
	}
	
	return S_OK;
}
コード例 #11
0
ファイル: MirageManager.cpp プロジェクト: AsherBond/DimSim
BOOL CMirageManager::LookupDisplayDevices(DISPLAY_DEVICE& deviceInfo, DWORD& deviceNumber, bool bShouldLog)
{
	memset(&deviceInfo, 0, sizeof(deviceInfo));
	deviceInfo.cb = sizeof(deviceInfo);

	deviceNumber = 0;
	BOOL result = FALSE;

	std::wstring dataStream(_T(""));
	while (result = EnumDisplayDevices(NULL, deviceNumber, &deviceInfo, 0))
	{
		if (bShouldLog)
		{
			dataStream.append(_T("Detected Device :: "));
			dataStream.append(deviceInfo.DeviceName);
			dataStream.append(_T(" - "));
			dataStream.append(deviceInfo.DeviceString);
			CMirageManager::WriteDiagnostics(dataStream);
			dataStream.clear();
		}
		if (wcscmp(deviceInfo.DeviceString, DRIVER_NAME) == 0)
		{
			result = TRUE;
			break;
		}
		++deviceNumber;
	}
	return result;
}
コード例 #12
0
ファイル: win32_gamma.c プロジェクト: Cloudef/glfw
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
    HDC dc;
    WORD values[768];
    DISPLAY_DEVICE display;

    if (ramp->size != 256)
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "Win32: Gamma ramp size must be 256");
        return;
    }

    memcpy(values +   0, ramp->red,   256 * sizeof(unsigned short));
    memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short));
    memcpy(values + 512, ramp->blue,  256 * sizeof(unsigned short));

    ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
    display.cb = sizeof(DISPLAY_DEVICE);
    EnumDisplayDevices(monitor->win32.name, 0, &display, 0);

    dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
    SetDeviceGammaRamp(dc, values);
    DeleteDC(dc);
}
コード例 #13
0
	//************************************
	// 函数名称: GetMonitorDisplayDevice
	// 返回类型: DISPLAY_DEVICE&
	// 参数信息: DWORD _MonitorIndex
	// 函数说明: 
	//************************************
	DISPLAY_DEVICE& DuiMonitor::GetMonitorDisplayDevice( DWORD _MonitorIndex /*= 1*/ )
	{
		static DISPLAY_DEVICE mDisplayDevice;
		memset(&mDisplayDevice,0, sizeof(mDisplayDevice));

		if(_MonitorIndex <= 0 || _MonitorIndex > GetMonitorCount())
			return mDisplayDevice;

		DEVMODE mDevMode;
		memset(&mDevMode,0, sizeof(mDevMode));
		DWORD mCheckCount = 0,mMonitorCount = 0;

		while(mMonitorCount != _MonitorIndex)
		{
			mDisplayDevice.cb = sizeof(DISPLAY_DEVICE);
			if(EnumDisplayDevices(NULL, mCheckCount, &mDisplayDevice,0) == FALSE)
				break;

			if(EnumDisplaySettings(mDisplayDevice.DeviceName,ENUM_CURRENT_SETTINGS,&mDevMode))
				mMonitorCount++;
			
			mCheckCount++;
		}

		return mDisplayDevice;
	}
コード例 #14
0
BOOL DetectVirtualMonitor(BOOL log)
{
    INT devNum = 0;
    DISPLAY_DEVICE displayDevice;
    BOOL result;
    BOOL bFound = FALSE;

    FillMemory(&displayDevice, sizeof(DISPLAY_DEVICE), 0);
    displayDevice.cb = sizeof(DISPLAY_DEVICE);

    // First enumerate for Primary display device:
    while ((result = EnumDisplayDevices(NULL, devNum, &displayDevice, 0))) {
		if (log) {
			logInfo("%s, %s %s \n",
					&displayDevice.DeviceString[0],
					&displayDevice.DeviceName[0],
					&displayDevice.DeviceID[0]/*,
					&displayDevice.DeviceKey[0]*/);
		}
        if (strcmp(&displayDevice.DeviceID[0], DRIVER_NAME) == 0) {
            bFound = TRUE;
			if (!log)
            	break;  
        }
        devNum++;
    }
    return bFound;
}
コード例 #15
0
static SDL_bool
WIN_AddDisplay(_THIS, LPTSTR DeviceName)
{
    SDL_VideoDisplay display;
    SDL_DisplayData *displaydata;
    SDL_DisplayMode mode;
    DISPLAY_DEVICE device;

#ifdef DEBUG_MODES
    printf("Display: %s\n", WIN_StringToUTF8(DeviceName));
#endif
    if (!WIN_GetDisplayMode(_this, DeviceName, ENUM_CURRENT_SETTINGS, &mode)) {
        return SDL_FALSE;
    }

    displaydata = (SDL_DisplayData *) SDL_malloc(sizeof(*displaydata));
    if (!displaydata) {
        return SDL_FALSE;
    }
    SDL_memcpy(displaydata->DeviceName, DeviceName,
               sizeof(displaydata->DeviceName));

    SDL_zero(display);
    device.cb = sizeof(device);
    if (EnumDisplayDevices(DeviceName, 0, &device, 0)) {
        display.name = WIN_StringToUTF8(device.DeviceString);
    }
    display.desktop_mode = mode;
    display.current_mode = mode;
    display.driverdata = displaydata;
    SDL_AddVideoDisplay(&display);
    SDL_free(display.name);
    return SDL_TRUE;
}
コード例 #16
0
// set fullscreen (for opengl)
int scrnSetFull(const bool& full)
{
    if (full) {
        DISPLAY_DEVICE dev;
        memset(&dev, 0, sizeof(dev));
        dev.cb = sizeof(dev);
        EnumDisplayDevices(NULL, nVidAdapter, &dev, 0);

        DEVMODE mode;
        memset(&mode, 0, sizeof(mode));
        mode.dmSize = sizeof(mode);
        mode.dmBitsPerPel = nVidScrnDepth;
        mode.dmPelsWidth = nVidScrnWidth;
        mode.dmPelsHeight = nVidScrnHeight;
        mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        LONG ret = ChangeDisplaySettingsEx(dev.DeviceName, &mode, NULL, CDS_FULLSCREEN, NULL);
        if (ret != DISP_CHANGE_SUCCESSFUL) {
            return 1;
        }

        SetWindowPos(hScrnWnd, NULL, 0, 0, nVidScrnWidth, nVidScrnHeight, SWP_NOZORDER | SWP_NOACTIVATE);
//		MoveWindow(hScrnWnd, 0, 0, nVidScrnWidth, nVidScrnHeight, FALSE);

        ShowWindow(hScrnWnd, SW_NORMAL);
        bFakeFullscreen = false;
    } else {
        ChangeDisplaySettingsEx(NULL, NULL, NULL, 0, NULL);
    }

    return 0;
}
コード例 #17
0
	//************************************
	// 函数名称: GetMonitorCount
	// 返回类型: DWORD
	// 参数信息: bool _bReCheck
	// 函数说明: 
	//************************************
	DWORD DuiMonitor::GetMonitorCount(bool _bReCheck/* = false*/)
	{
		static DWORD mMonitorCount = 0;

		if(mMonitorCount && !_bReCheck)
			return mMonitorCount;

		DEVMODE mDevMode;
		memset(&mDevMode,0, sizeof(mDevMode));
		DISPLAY_DEVICE mDisplayDevice;
		DWORD mCheckCount = 0;

		while(true)
		{
			memset(&mDisplayDevice,0, sizeof(mDisplayDevice));
			mDisplayDevice.cb = sizeof(DISPLAY_DEVICE);
			if(EnumDisplayDevices(NULL, mCheckCount, &mDisplayDevice,0) == FALSE)
				break;

			if(EnumDisplaySettings(mDisplayDevice.DeviceName,ENUM_CURRENT_SETTINGS,&mDevMode))
				mMonitorCount++;

			mCheckCount++;
		}

		return mMonitorCount;
	}
コード例 #18
0
ファイル: pipe.cpp プロジェクト: MichaelVlad/Equalizer
HDC Pipe::createWGLDisplayDC()
{
    uint32_t device = getPipe()->getDevice();
    if( device == EQ_UNDEFINED_UINT32 )
        device = 0;

    DISPLAY_DEVICE devInfo;
    devInfo.cb = sizeof( devInfo );

    if( !EnumDisplayDevices( 0, device, &devInfo, 0 ))
    {
        setError( ERROR_WGLPIPE_ENUMDISPLAYS_FAILED );
        EQWARN << getError() << ": " << co::base::sysError << std::endl;
        return 0;
    }

    const HDC displayDC = CreateDC( "DISPLAY", devInfo.DeviceName, 0, 0 );
    if( !displayDC )
    {
        setError( ERROR_WGLPIPE_CREATEDC_FAILED );
        EQWARN << getError() << ": " << co::base::sysError << std::endl;
        return 0;
    }

    return displayDC;
}
コード例 #19
0
ファイル: COpenGL.cpp プロジェクト: chuckries/snes9x
void COpenGL::EnumModes(std::vector<dMode> *modeVector)
{
	DISPLAY_DEVICE dd;
	dd.cb = sizeof(dd);
	DWORD dev = 0;
	int iMode = 0;
	dMode mode;

	while (EnumDisplayDevices(0, dev, &dd, 0))
	{
		if (!(dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) && (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE))
		{
			DEVMODE dm;
			memset(&dm, 0, sizeof(dm));
			dm.dmSize = sizeof(dm);
			iMode = 0;
			while(EnumDisplaySettings(dd.DeviceName,iMode,&dm)) {
				if(dm.dmBitsPerPel>=16) {
					mode.width = dm.dmPelsWidth;
					mode.height = dm.dmPelsHeight;
					mode.rate = dm.dmDisplayFrequency;
					mode.depth = dm.dmBitsPerPel;
					modeVector->push_back(mode);
				}
				iMode++;
			}
		}
		dev++;
	}
}
コード例 #20
0
nsresult nsSystemInfo::Init() 
{
  DISPLAY_DEVICE lpDisplayDevice;
  lpDisplayDevice.cb = sizeof(lpDisplayDevice);
  int deviceIndex = 0;
  
  while (EnumDisplayDevices(NULL, deviceIndex, &lpDisplayDevice, 0)) {
    if (lpDisplayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
      break;
    deviceIndex++;
  }
  mDeviceKey = lpDisplayDevice.DeviceKey;
  mDeviceID = lpDisplayDevice.DeviceID;
  mDeviceString.AssignLiteral(lpDisplayDevice.DeviceString);

  DEVMODE dm;
  dm.dmSize = sizeof(dm);
  EnumDisplaySettings(lpDisplayDevice.DeviceName, ENUM_CURRENT_SETTINGS, &dm);
  mBitsPerPixel = dm.dmBitsPerPel;
  mPixelWidth = dm.dmPelsWidth;
  mPixelHeight = dm.dmPelsHeight;
  
  getDriverDetails(mDeviceID, mDriverVersion, mDriverDate);
  return NS_OK;
}
コード例 #21
0
ファイル: wsystem.c プロジェクト: BorisCarvajal/allegro5
static bool win_get_monitor_info(int adapter, ALLEGRO_MONITOR_INFO *info)
{
    DISPLAY_DEVICE dd;
    DEVMODE dm;

    memset(&dd, 0, sizeof(dd));
    dd.cb = sizeof(dd);
    if (!EnumDisplayDevices(NULL, adapter, &dd, 0)) {
        return false;
    }

    memset(&dm, 0, sizeof(dm));
    dm.dmSize = sizeof(dm);
    if (!EnumDisplaySettings(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) {
        return false;
    }

    ASSERT(dm.dmFields & DM_PELSHEIGHT);
    ASSERT(dm.dmFields & DM_PELSWIDTH);
    /* Disabled this assertion for now as it fails under Wine 1.2. */
    /* ASSERT(dm.dmFields & DM_POSITION); */

    info->x1 = dm.dmPosition.x;
    info->y1 = dm.dmPosition.y;
    info->x2 = info->x1 + dm.dmPelsWidth;
    info->y2 = info->y1 + dm.dmPelsHeight;
    return true;
}
コード例 #22
0
static int dispApapterInit()
{
	if (!hVideoDlg) {
		return 1;
	}

	unsigned int count = 0;
	int ret = 0;
	DISPLAY_DEVICE dev;
	memset(&dev, 0, sizeof(dev));
	dev.cb = sizeof(dev);

	do {
		ret = EnumDisplayDevices(NULL, count, &dev, 0);
		if (ret) {
			if (dev.StateFlags & DISPLAY_DEVICE_ACTIVE) {
				SendDlgItemMessage(hVideoDlg, IDC_PREF_DISPADAPTER, CB_ADDSTRING, 0, (LPARAM)dev.DeviceName);
			}
			count++;
		}
	} while (ret);

	SendDlgItemMessage(hVideoDlg, IDC_PREF_DISPADAPTER, CB_SETCURSEL, (WPARAM)nVidAdapter, 0);

	return 0;
}
コード例 #23
0
__declspec(dllexport) void GetNumberofDisplays(UINT *NumDisplays)
{
    *NumDisplays = 0;
    BOOL retval;
    DEVMODE StoredDevMode;
    DISPLAY_DEVICE TempDisplayDeviceStruct;
    LPCWSTR AdapterName;
    DWORD count = 0;
    DWORD modecount = 0;

    TempDisplayDeviceStruct.cb = sizeof(DISPLAY_DEVICE);
    retval = EnumDisplayDevices(NULL, count, &TempDisplayDeviceStruct, EDD_GET_DEVICE_INTERFACE_NAME);
    while (retval)
    {
        if (TempDisplayDeviceStruct.StateFlags != DISPLAY_DEVICE_MIRRORING_DRIVER)
        {
            // A mirroring driver is just a pseudo display device that is used internally want to ignore them
            
            // The current display device is at least known to the system.  However, if you pull the plug on a 
            // device, it will still have a DisplayDeviceStruct.  But it seems that it has no modes 
            // associated with it when it cannot be accessed.  So, before we know that the device is really available
            // make sure that there are some modes that are available.
            modecount = 0;
            AdapterName = (WCHAR *)&TempDisplayDeviceStruct.DeviceName;
            StoredDevMode.dmSize = sizeof(DEVMODE);
            StoredDevMode.dmDriverExtra = 0;
            retval = EnumDisplaySettings(AdapterName, modecount, (DEVMODE *)&StoredDevMode);
            // see if there are at least a couple of modes for this display device  
            while (retval && modecount <= 2)
            {
                modecount++;
                retval = EnumDisplaySettings(AdapterName, modecount, (DEVMODE *)&StoredDevMode);
            }
            // If we exited the above loop and were still getting good data, then we have found
            // a viable display device
            if (retval)
                (*NumDisplays)++;
        }

        // Get the next display device
        count++;
        TempDisplayDeviceStruct.cb = sizeof(DISPLAY_DEVICE);
        retval = EnumDisplayDevices(NULL, count, &TempDisplayDeviceStruct, 0);
    }

    return;
}
コード例 #24
0
ファイル: cutil_interop.cpp プロジェクト: htruong/cuda
/////////////////////////////////////////////////////////////////////////////
//! Tests if graphics interop is supported on the current system
//! @return  CUTTrue if graphics interop is supported
//////////////////////////////////////////////////////////////////////////////
CUTBoolean CUTIL_API
isInteropSupported() {
#ifdef _WIN32
    int num_devices = 0;
    int dev = 0;

    do {
        DISPLAY_DEVICE dispDevice;
        memset(&dispDevice, 0, sizeof(dispDevice));
        dispDevice.cb = sizeof(dispDevice);
        if (!EnumDisplayDevices(NULL, dev, &dispDevice, 0))
            break;
        if ((dispDevice.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) ||
            (!(dispDevice.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) &&
            !(dispDevice.StateFlags & DISPLAY_DEVICE_MODESPRUNED)))
            ++num_devices;
        ++dev;
    } while (dev);

#else // Linux

    void* handle = 0;

    // NvCfgBool (*ptr_nvCfgGetDevices)( int*, NvCfgDevice**);
    typedef NvCfgBool (*nvCfgGetDevicesType)( int*, NvCfgDevice**);
    nvCfgGetDevicesType ptr_nvCfgGetDevices;

    // acquire handle to shared library
    handle = dlopen( "libnvidia-cfg.so", RTLD_LAZY);
    if( ! handle) {
        // no NVIDIA driver installed
        fprintf( stderr, "Cannot find NVIDIA driver.\n" );
        fprintf( stderr, "Graphics interoperability not supported.\n" );
        return CUTFalse;
    }

    ptr_nvCfgGetDevices = (nvCfgGetDevicesType) 
                                        dlsym( handle, "nvCfgGetDevices");
    char* error = 0;
    if( 0 != (error = dlerror())) {
        fprintf( stderr, "Cannot query number of devices in the system.\n" );
        fprintf( stderr, "Graphics interoperability not supported.\n" );
        return CUTFalse;
     }

     // call function
     int num_devices;
     NvCfgDevice* devs;
   
     (*ptr_nvCfgGetDevices)( &num_devices, &devs);

#endif // _WIN32
    if( 1 != num_devices) {
        fprintf( stderr, "Graphics interoperability on multi GPU systems currently not supported.\n" );
        return CUTFalse;

    }
    return CUTTrue;
}
コード例 #25
0
ファイル: w32_common.c プロジェクト: hanyong/mplayer-kovensky
/**
 * \brief return the name of the selected device if it is indepedant
 */
static char *get_display_name(void) {
    DISPLAY_DEVICE disp;
    disp.cb = sizeof(disp);
    EnumDisplayDevices(NULL, vo_adapter_num, &disp, 0);
    if (disp.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)
        return NULL;
    return disp.DeviceName;
}
コード例 #26
0
// static
HRESULT
D3DPipelineManager::GDICheckForBadHardware()
{
    DISPLAY_DEVICE dd;
    dd.cb = sizeof(DISPLAY_DEVICE);

    int failedDevices = 0;
    int attachedDevices = 0;
    int i = 0;
    WCHAR *id;
    WCHAR vendorId[5];
    WCHAR deviceId[5];
    DWORD dwDId, dwVId;

    J2dTraceLn(J2D_TRACE_INFO, "D3DPPLM::GDICheckForBadHardware");

    // i<20 is to guard against buggy drivers
    while (EnumDisplayDevices(NULL, i, &dd, 0) && i < 20) {
        if (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) {
            attachedDevices++;
            id = dd.DeviceID;
            if (wcslen(id) > 21) {
                // get vendor ID
                wcsncpy(vendorId, id+8, 4);
                int args1 = swscanf(vendorId, L"%X", &dwVId);

                // get device ID
                wcsncpy(deviceId, id+17, 4);
                int args2 = swscanf(deviceId, L"%X", &dwDId);

                if (args1 == 1 && args2 == 1) {
                    J2dTraceLn2(J2D_TRACE_VERBOSE,
                                "  device: vendorID=0x%04x, deviceId=0x%04x",
                                dwVId, dwDId);
                    // since we don't have a driver version here we will
                    // just ask to ignore the version for now; bad hw
                    // entries with specific drivers information will be
                    // processed later when d3d is initialized and we can
                    // obtain a driver version
                    if (FAILED(CheckForBadHardware(dwVId, dwDId, MAX_VERSION))){
                        failedDevices++;
                    }
                }
            }
        }

        i++;
    }

    if (failedDevices == attachedDevices) {
        J2dRlsTraceLn(J2D_TRACE_ERROR,
            "D3DPPLM::GDICheckForBadHardware: no suitable devices found");
        return E_FAIL;
    }

    return S_OK;
}
コード例 #27
0
static int fullResInit()
{
	if (!hVideoDlg) {
		return 1;
	}

	DEVMODE devMode;
	devMode.dmSize = sizeof(DEVMODE);
	devMode.dmDriverExtra = 0;

	DISPLAY_DEVICE device;
	device.cb = sizeof(DISPLAY_DEVICE);
	EnumDisplayDevices(NULL, nVidAdapter, &device, 0);

	// fullscreen res box
	// Run through all possible screenmodes and fill the combobox
	for (int i = 0; EnumDisplaySettings(device.DeviceName, i, &devMode); i++) {
		// We're only interested in 16, 24, or 32 bit modes.
		if (devMode.dmBitsPerPel & 0x30) {
			long item = 0, itemValue;
			long newRes = (devMode.dmPelsWidth << 16) | devMode.dmPelsHeight;

			// See if the resolution is already in the combobox
			do {
				itemValue = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETITEMDATA, item, 0);
				item++;
			} while ((itemValue != CB_ERR) && (itemValue != newRes));

			// If not, add it
			if (itemValue == CB_ERR) {
				TCHAR szRes[MAX_PATH];
				_stprintf(szRes, _T("%li x %li"), devMode.dmPelsWidth, devMode.dmPelsHeight);
				item = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_ADDSTRING, 0, (LPARAM)&szRes);
				SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_SETITEMDATA, item, newRes);
			}
		}
	}

	// set select
	long myRes = (nVidWidth << 16) | nVidHeight;
	long count = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETCOUNT, 0, 0);
	long item = 0;
	for (long i = 0; i < count; i++) {
		item = SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_GETITEMDATA, i, 0);
		if (myRes == item) {
			SendDlgItemMessage(hVideoDlg, IDC_PREF_FULLSCREENRES, CB_SETCURSEL, (WPARAM)i, 0);
			break;
		}
	}

	// depth
	SendDlgItemMessage(hVideoDlg, IDC_PREF_16BIT, BM_SETCHECK, (nVidDepth == 16) ? BST_CHECKED : BST_UNCHECKED, 0);
	SendDlgItemMessage(hVideoDlg, IDC_PREF_32BIT, BM_SETCHECK, (nVidDepth == 32) ? BST_CHECKED : BST_UNCHECKED, 0);

	return 0;
}
コード例 #28
0
ファイル: Window.cpp プロジェクト: HirokiMiyaoka/Mikan
// ディスプレイの位置とサイズを返す
int Window::GetDisplayRect( long displaynum, int *x, int *y, int *width, int *height )
{
	DISPLAY_DEVICE disdev;
	DEVMODE devmode;

	if ( x )
	{
		*x = 0;
	}
	if ( y )
	{
		*y = 0;
	}
	if ( width )
	{
		*width = 0;
	}
	if ( height )
	{
		*height = 0;
	}

	memset( &disdev, 0, sizeof( DISPLAY_DEVICE ) );
	disdev.cb = sizeof( DISPLAY_DEVICE );
	if ( EnumDisplayDevices( NULL, displaynum, &disdev, 0 ) == 0 )
	{
		// 不正なディスプレイ番号
		return 1;
	}

	memset( &devmode, 0, sizeof( DEVMODE ) );
	devmode.dmSize = sizeof( DEVMODE );
	if ( EnumDisplaySettingsEx( disdev.DeviceName, /*ENUM_CURRENT_SETTINGS*/ENUM_REGISTRY_SETTINGS, &devmode, EDS_RAWMODE ) == 0 )
	{
		// 設定を取得できなかった
		return 2;
	}
	if ( x )
	{
		*x = devmode.dmPosition.x;
	}
	if ( y )
	{
		*y = devmode.dmPosition.y;
	}
	if ( width )
	{
		*width = devmode.dmPelsWidth;
	}
	if ( height )
	{
		*height = devmode.dmPelsHeight;
	}

	return 0;
}
コード例 #29
0
ファイル: DisplayManager.cpp プロジェクト: malensek/3RVX
std::list<DISPLAY_DEVICE> DisplayManager::ListAllDevices() {
    std::list<DISPLAY_DEVICE> devs;
    DISPLAY_DEVICE dev = {};
    dev.cb = sizeof(DISPLAY_DEVICE);
    for (int i = 0; EnumDisplayDevices(NULL, i, &dev, NULL) != 0; ++i) {
        if (dev.StateFlags & DISPLAY_DEVICE_ACTIVE) {
            devs.push_back(dev);
        }
    }
    return devs;
}
コード例 #30
0
ファイル: SDL_win32modes.c プロジェクト: Avin15/dospad
int
WIN_InitModes(_THIS)
{
    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
    DWORD i, j, count;
    DISPLAY_DEVICE device;

    device.cb = sizeof(device);
    for (i = 0;; ++i) {
        TCHAR DeviceName[32];

        if (!EnumDisplayDevices(NULL, i, &device, 0)) {
            break;
        }
        if (!(device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) {
            continue;
        }
        SDL_memcpy(DeviceName, device.DeviceName, sizeof(DeviceName));
#ifdef DEBUG_MODES
        printf("Device: %s\n", WIN_StringToUTF8(DeviceName));
#endif
        count = 0;
        for (j = 0;; ++j) {
            if (!EnumDisplayDevices(DeviceName, j, &device, 0)) {
                break;
            }
            if (!(device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) {
                continue;
            }
            count += WIN_AddDisplay(device.DeviceName);
        }
        if (count == 0) {
            WIN_AddDisplay(DeviceName);
        }
    }
    if (_this->num_displays == 0) {
        SDL_SetError("No displays available");
        return -1;
    }
    return 0;
}