monitor.c File Reference

#include <win32k.h>
#include <debug.h>

Include dependency graph for monitor.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	DBG_DEFAULT_CHANNEL (UserMonitor)
static PMONITOR	IntCreateMonitorObject (VOID)
static void	IntDestroyMonitorObject (IN PMONITOR pMonitor)
PMONITOR NTAPI	UserGetMonitorObject (IN HMONITOR hMonitor)
PMONITOR NTAPI	UserGetPrimaryMonitor (VOID)
NTSTATUS NTAPI	UserAttachMonitor (IN HDEV hDev)
NTSTATUS NTAPI	UserDetachMonitor (IN HDEV hDev)
NTSTATUS NTAPI	UserUpdateMonitorSize (IN HDEV hDev)
static UINT	IntGetMonitorsFromRect (OPTIONAL IN LPCRECTL pRect, OPTIONAL OUT HMONITOR *phMonitorList, OPTIONAL OUT PRECTL prcMonitorList, OPTIONAL IN DWORD dwListSize, OPTIONAL IN DWORD dwFlags)
HMONITOR FASTCALL	IntGetMonitorFromRect (_In_ LPCRECTL pRect, _In_ DWORD dwFlags)
PMONITOR NTAPI	UserMonitorFromRect (PRECTL pRect, DWORD dwFlags)
PMONITOR FASTCALL	UserMonitorFromPoint (IN POINT pt, IN DWORD dwFlags)
INT APIENTRY	NtUserEnumDisplayMonitors (OPTIONAL IN HDC hdc, OPTIONAL IN LPCRECTL pUnsafeRect, OPTIONAL OUT HMONITOR *phUnsafeMonitorList, OPTIONAL OUT PRECTL prcUnsafeMonitorList, OPTIONAL IN DWORD dwListSize)
BOOL APIENTRY	NtUserGetMonitorInfo (IN HMONITOR hMonitor, OUT LPMONITORINFO pMonitorInfoUnsafe)
HMONITOR APIENTRY	NtUserMonitorFromPoint (_In_ POINT pt, _In_ DWORD dwFlags)
HMONITOR APIENTRY	NtUserMonitorFromRect (_In_ LPCRECTL pRectUnsafe, _In_ DWORD dwFlags)
HMONITOR APIENTRY	NtUserMonitorFromWindow (_In_ HWND hWnd, _In_ DWORD dwFlags)

Variables
static PMONITOR	gMonitorList = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file monitor.c.

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserMonitor

)

IntCreateMonitorObject()

static PMONITOR IntCreateMonitorObject ( VOID  )

static

Definition at line 33 of file monitor.c.

{
    return UserCreateObject(gHandleTable, NULL, NULL, NULL, TYPE_MONITOR, sizeof(MONITOR));
}

Referenced by UserAttachMonitor().

IntDestroyMonitorObject()

static void IntDestroyMonitorObject ( IN PMONITOR  pMonitor )

static

Definition at line 50 of file monitor.c.

{
    /* Remove monitor region */
    if (pMonitor->hrgnMonitor)
    {
        GreSetObjectOwner(pMonitor->hrgnMonitor, GDI_OBJ_HMGR_POWNED);
        GreDeleteObject(pMonitor->hrgnMonitor);
    }
 
    /* Destroy monitor object */
    UserDereferenceObject(pMonitor);
    UserDeleteObject(UserHMGetHandle(pMonitor), TYPE_MONITOR);
}

Referenced by UserDetachMonitor().

IntGetMonitorFromRect()

HMONITOR FASTCALL IntGetMonitorFromRect	(	_In_ LPCRECTL	pRect,
		_In_ DWORD	dwFlags
	)

Definition at line 405 of file monitor.c.

{
    ULONG cMonitors, LargestArea = 0, i;
    PRECTL prcMonitorList = NULL;
    HMONITOR *phMonitorList = NULL;
    HMONITOR hMonitor = NULL;
 
    /* Find intersecting monitors */
    cMonitors = IntGetMonitorsFromRect(pRect, &hMonitor, NULL, 1, dwFlags);
    if (cMonitors <= 1)
    {
        /* No or one monitor found. Just return handle. */
        goto cleanup;
    }
 
    /* There is more than one monitor. Find monitor with largest intersection.
       Temporary reset hMonitor */
    hMonitor = NULL;
 
    /* Allocate helper buffers */
    phMonitorList = ExAllocatePoolWithTag(PagedPool,
                                          sizeof(HMONITOR) * cMonitors,
                                          USERTAG_MONITORRECTS);
    if (phMonitorList == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto cleanup;
    }
 
    prcMonitorList = ExAllocatePoolWithTag(PagedPool,
                                           sizeof(RECT) * cMonitors,
                                           USERTAG_MONITORRECTS);
    if (prcMonitorList == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto cleanup;
    }
 
    /* Get intersecting monitors again but now with rectangle list */
    cMonitors = IntGetMonitorsFromRect(pRect, phMonitorList, prcMonitorList, cMonitors, 0);
 
    /* Find largest intersection */
    for (i = 0; i < cMonitors; i++)
    {
        ULONG Area = (prcMonitorList[i].right - prcMonitorList[i].left) *
                     (prcMonitorList[i].bottom - prcMonitorList[i].top);
        if (Area >= LargestArea)
        {
            hMonitor = phMonitorList[i];
            LargestArea = Area;
        }
    }
 
cleanup:
    if (phMonitorList)
        ExFreePoolWithTag(phMonitorList, USERTAG_MONITORRECTS);
    if (prcMonitorList)
        ExFreePoolWithTag(prcMonitorList, USERTAG_MONITORRECTS);
    return hMonitor;
}

Referenced by NtUserMonitorFromRect(), NtUserMonitorFromWindow(), and UserMonitorFromRect().

IntGetMonitorsFromRect()

static UINT IntGetMonitorsFromRect ( OPTIONAL IN LPCRECTL  pRect, OPTIONAL OUT HMONITOR *  phMonitorList, OPTIONAL OUT PRECTL  prcMonitorList, OPTIONAL IN DWORD  dwListSize, OPTIONAL IN DWORD  dwFlags  )

static

Definition at line 310 of file monitor.c.

{
    PMONITOR pMonitor, pNearestMonitor = NULL, pPrimaryMonitor = NULL;
    UINT cMonitors = 0;
    ULONG iNearestDistance = 0xffffffff;
 
    /* Find monitors which intersects the rectangle */
    for (pMonitor = gMonitorList; pMonitor != NULL; pMonitor = pMonitor->pMonitorNext)
    {
        RECTL MonitorRect, IntersectionRect;
 
        MonitorRect = pMonitor->rcMonitor;
 
        TRACE("MonitorRect: left = %d, top = %d, right = %d, bottom = %d\n",
               MonitorRect.left, MonitorRect.top, MonitorRect.right, MonitorRect.bottom);
 
        /* Save primary monitor for later usage */
        if (dwFlags == MONITOR_DEFAULTTOPRIMARY && pMonitor->IsPrimary)
            pPrimaryMonitor = pMonitor;
 
        /* Check if a rect is given */
        if (pRect == NULL)
        {
            /* No rect given, so use the full monitor rect */
            IntersectionRect = MonitorRect;
        }
        /* We have a rect, calculate intersection */
        else if (!RECTL_bIntersectRect(&IntersectionRect, &MonitorRect, pRect))
        {
            /* Rects did not intersect */
            if (dwFlags == MONITOR_DEFAULTTONEAREST)
            {
                ULONG cx, cy, iDistance;
 
                /* Get x and y distance */
                cx = min(abs(MonitorRect.left - pRect->right),
                         abs(pRect->left - MonitorRect.right));
                cy = min(abs(MonitorRect.top - pRect->bottom),
                         abs(pRect->top - MonitorRect.bottom));
 
                /* Calculate distance square */
                iDistance = cx * cx + cy * cy;
 
                /* Check if this is the new nearest monitor */
                if (iDistance < iNearestDistance)
                {
                    iNearestDistance = iDistance;
                    pNearestMonitor = pMonitor;
                }
            }
 
            continue;
        }
 
        /* Check if there's space in the buffer */
        if (cMonitors < dwListSize)
        {
            /* Save monitor data */
            if (phMonitorList != NULL)
                phMonitorList[cMonitors] = UserHMGetHandle(pMonitor);
            if (prcMonitorList != NULL)
                prcMonitorList[cMonitors] = IntersectionRect;
        }
 
        /* Increase count of found monitors */
        cMonitors++;
    }
 
    /* Nothing has been found? */
    if (cMonitors == 0)
    {
        /* Check if we shall default to the nearest monitor */
        if (dwFlags == MONITOR_DEFAULTTONEAREST && pNearestMonitor)
        {
            if (phMonitorList && dwListSize > 0)
                phMonitorList[cMonitors] = UserHMGetHandle(pNearestMonitor);
            cMonitors++;
        }
        /* Check if we shall default to the primary monitor */
        else if (dwFlags == MONITOR_DEFAULTTOPRIMARY && pPrimaryMonitor)
        {
            if (phMonitorList != NULL && dwListSize > 0)
                phMonitorList[cMonitors] = UserHMGetHandle(pPrimaryMonitor);
            cMonitors++;
        }
    }
 
    return cMonitors;
}

Referenced by IntGetMonitorFromRect(), NtUserEnumDisplayMonitors(), NtUserMonitorFromPoint(), and UserMonitorFromPoint().

NtUserEnumDisplayMonitors()

INT APIENTRY NtUserEnumDisplayMonitors	(	OPTIONAL IN HDC	hdc,
		OPTIONAL IN LPCRECTL	pUnsafeRect,
		OPTIONAL OUT HMONITOR *	phUnsafeMonitorList,
		OPTIONAL OUT PRECTL	prcUnsafeMonitorList,
		OPTIONAL IN DWORD	dwListSize
	)

Definition at line 552 of file monitor.c.

{
    UINT cMonitors, i;
    INT iRet = -1;
    HMONITOR *phMonitorList = NULL;
    PRECTL prcMonitorList = NULL;
    RECTL rc, *pRect;
    RECTL DcRect = {0};
    NTSTATUS Status;
 
    /* Get rectangle */
    if (pUnsafeRect != NULL)
    {
        Status = MmCopyFromCaller(&rc, pUnsafeRect, sizeof(RECT));
        if (!NT_SUCCESS(Status))
        {
            TRACE("MmCopyFromCaller() failed!\n");
            SetLastNtError(Status);
            return -1;
        }
    }
 
    if (hdc != NULL)
    {
        PDC pDc;
        INT iRgnType;
 
        /* Get visible region bounding rect */
        pDc = DC_LockDc(hdc);
        if (pDc == NULL)
        {
            TRACE("DC_LockDc() failed!\n");
            /* FIXME: setlasterror? */
            return -1;
        }
        iRgnType = REGION_GetRgnBox(pDc->prgnVis, &DcRect);
        DC_UnlockDc(pDc);
 
        if (iRgnType == 0)
        {
            TRACE("NtGdiGetRgnBox() failed!\n");
            return -1;
        }
        if (iRgnType == NULLREGION)
            return 0;
        if (iRgnType == COMPLEXREGION)
        {
            /* TODO: Warning */
        }
 
        /* If hdc and pRect are given the area of interest is pRect with
           coordinate origin at the DC position */
        if (pUnsafeRect != NULL)
        {
            rc.left += DcRect.left;
            rc.right += DcRect.left;
            rc.top += DcRect.top;
            rc.bottom += DcRect.top;
        }
        /* If hdc is given and pRect is not the area of interest is the
           bounding rect of hdc */
        else
        {
            rc = DcRect;
        }
    }
 
    if (hdc == NULL && pUnsafeRect == NULL)
        pRect = NULL;
    else
        pRect = &rc;
 
    UserEnterShared();
 
    /* Find intersecting monitors */
    cMonitors = IntGetMonitorsFromRect(pRect, NULL, NULL, 0, MONITOR_DEFAULTTONULL);
    if (cMonitors == 0 || dwListSize == 0 ||
        (phUnsafeMonitorList == NULL && prcUnsafeMonitorList == NULL))
    {
        /* Simple case - just return monitors count */
        TRACE("cMonitors = %u\n", cMonitors);
        iRet = cMonitors;
        goto cleanup;
    }
 
    /* Allocate safe buffers */
    if (phUnsafeMonitorList != NULL && dwListSize != 0)
    {
        phMonitorList = ExAllocatePoolWithTag(PagedPool, sizeof (HMONITOR) * dwListSize, USERTAG_MONITORRECTS);
        if (phMonitorList == NULL)
        {
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
    }
    if (prcUnsafeMonitorList != NULL && dwListSize != 0)
    {
        prcMonitorList = ExAllocatePoolWithTag(PagedPool, sizeof(RECT) * dwListSize,USERTAG_MONITORRECTS);
        if (prcMonitorList == NULL)
        {
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto cleanup;
        }
    }
 
    /* Get intersecting monitors */
    cMonitors = IntGetMonitorsFromRect(pRect, phMonitorList, prcMonitorList,
                                       dwListSize, MONITOR_DEFAULTTONULL);
 
    if (hdc != NULL && pRect != NULL && prcMonitorList != NULL)
    {
        for (i = 0; i < min(cMonitors, dwListSize); i++)
        {
            _Analysis_assume_(i < dwListSize);
            prcMonitorList[i].left -= DcRect.left;
            prcMonitorList[i].right -= DcRect.left;
            prcMonitorList[i].top -= DcRect.top;
            prcMonitorList[i].bottom -= DcRect.top;
        }
    }
 
    /* Output result */
    if (phUnsafeMonitorList != NULL && dwListSize != 0)
    {
        Status = MmCopyToCaller(phUnsafeMonitorList, phMonitorList, sizeof(HMONITOR) * dwListSize);
        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            goto cleanup;
        }
    }
    if (prcUnsafeMonitorList != NULL && dwListSize != 0)
    {
        Status = MmCopyToCaller(prcUnsafeMonitorList, prcMonitorList, sizeof(RECT) * dwListSize);
        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            goto cleanup;
        }
    }
 
    /* Return monitors count on success */
    iRet = cMonitors;
 
cleanup:
    if (phMonitorList)
        ExFreePoolWithTag(phMonitorList, USERTAG_MONITORRECTS);
    if (prcMonitorList)
        ExFreePoolWithTag(prcMonitorList, USERTAG_MONITORRECTS);
 
    UserLeave();
    return iRet;
}

NtUserGetMonitorInfo()

BOOL APIENTRY NtUserGetMonitorInfo	(	IN HMONITOR	hMonitor,
		OUT LPMONITORINFO	pMonitorInfoUnsafe
	)

Definition at line 737 of file monitor.c.

{
    PMONITOR pMonitor;
    MONITORINFOEXW MonitorInfo;
    NTSTATUS Status;
    BOOL bRet = FALSE;
    PWCHAR pwstrDeviceName;
 
    TRACE("Enter NtUserGetMonitorInfo\n");
    UserEnterShared();
 
    /* Get monitor object */
    pMonitor = UserGetMonitorObject(hMonitor);
    if (!pMonitor)
    {
        TRACE("Couldnt find monitor %p\n", hMonitor);
        goto cleanup;
    }
 
    /* Check if pMonitorInfoUnsafe is valid */
    if(pMonitorInfoUnsafe == NULL)
    {
        SetLastNtError(STATUS_INVALID_PARAMETER);
        goto cleanup;
    }
 
    pwstrDeviceName = ((PPDEVOBJ)(pMonitor->hDev))->pGraphicsDevice->szWinDeviceName;
 
    /* Get size of pMonitorInfoUnsafe */
    Status = MmCopyFromCaller(&MonitorInfo.cbSize, &pMonitorInfoUnsafe->cbSize, sizeof(MonitorInfo.cbSize));
    if (!NT_SUCCESS(Status))
    {
        SetLastNtError(Status);
        goto cleanup;
    }
 
    /* Check if size of struct is valid */
    if (MonitorInfo.cbSize != sizeof(MONITORINFO) &&
        MonitorInfo.cbSize != sizeof(MONITORINFOEXW))
    {
        SetLastNtError(STATUS_INVALID_PARAMETER);
        goto cleanup;
    }
 
    /* Fill monitor info */
    MonitorInfo.rcMonitor = pMonitor->rcMonitor;
    MonitorInfo.rcWork = pMonitor->rcWork;
    MonitorInfo.dwFlags = 0;
    if (pMonitor->IsPrimary)
        MonitorInfo.dwFlags |= MONITORINFOF_PRIMARY;
 
    /* Fill device name */
    if (MonitorInfo.cbSize == sizeof(MONITORINFOEXW))
    {
        RtlStringCbCopyNExW(MonitorInfo.szDevice,
                          sizeof(MonitorInfo.szDevice),
                          pwstrDeviceName,
                          (wcslen(pwstrDeviceName)+1) * sizeof(WCHAR),
                          NULL, NULL, STRSAFE_FILL_BEHIND_NULL);
    }
 
    /* Output data */
    Status = MmCopyToCaller(pMonitorInfoUnsafe, &MonitorInfo, MonitorInfo.cbSize);
    if (!NT_SUCCESS(Status))
    {
        TRACE("GetMonitorInfo: MmCopyToCaller failed\n");
        SetLastNtError(Status);
        goto cleanup;
    }
 
    TRACE("GetMonitorInfo: success\n");
    bRet = TRUE;
 
cleanup:
    TRACE("Leave NtUserGetMonitorInfo, ret=%i\n", bRet);
    UserLeave();
    return bRet;
}

Referenced by GetMonitorInfoA(), and GetMonitorInfoW().

NtUserMonitorFromPoint()

HMONITOR APIENTRY NtUserMonitorFromPoint	(	_In_ POINT	pt,
		_In_ DWORD	dwFlags
	)

Definition at line 836 of file monitor.c.

{
    RECTL rc;
    HMONITOR hMonitor = NULL;
 
    /* Check if flags are valid */
    if (dwFlags != MONITOR_DEFAULTTONULL &&
        dwFlags != MONITOR_DEFAULTTOPRIMARY &&
        dwFlags != MONITOR_DEFAULTTONEAREST)
    {
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    /* Fill rect (bottom-right exclusive) */
    rc.left = pt.x;
    rc.right = pt.x + 1;
    rc.top = pt.y;
    rc.bottom = pt.y + 1;
 
    UserEnterShared();
 
    /* Find intersecting monitor */
    IntGetMonitorsFromRect(&rc, &hMonitor, NULL, 1, dwFlags);
 
    UserLeave();
    return hMonitor;
}

Referenced by MonitorFromPoint().

NtUserMonitorFromRect()

HMONITOR APIENTRY NtUserMonitorFromRect	(	_In_ LPCRECTL	pRectUnsafe,
		_In_ DWORD	dwFlags
	)

Definition at line 886 of file monitor.c.

{
    RECTL Rect;
    NTSTATUS Status;
    HMONITOR hMonitor;
 
    /* Check if flags are valid */
    if (dwFlags != MONITOR_DEFAULTTONULL &&
        dwFlags != MONITOR_DEFAULTTOPRIMARY &&
        dwFlags != MONITOR_DEFAULTTONEAREST)
    {
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    /* Copy rectangle to safe buffer */
    Status = MmCopyFromCaller(&Rect, pRectUnsafe, sizeof (RECT));
    if (!NT_SUCCESS(Status))
    {
        SetLastNtError(Status);
        return NULL;
    }
 
    if (RECTL_bIsEmptyRect(&Rect))
    {
        Rect.right = Rect.left + 1;
        Rect.bottom = Rect.top + 1;
    }
 
    UserEnterShared();
    hMonitor = IntGetMonitorFromRect(&Rect, dwFlags);
    UserLeave();
 
    return hMonitor;
}

NtUserMonitorFromWindow()

HMONITOR APIENTRY NtUserMonitorFromWindow	(	_In_ HWND	hWnd,
		_In_ DWORD	dwFlags
	)

Definition at line 927 of file monitor.c.

{
    PWND pWnd;
    HMONITOR hMonitor = NULL;
    RECTL Rect = {0, 0, 0, 0};
 
    TRACE("Enter NtUserMonitorFromWindow\n");
 
    /* Check if flags are valid */
    if (dwFlags != MONITOR_DEFAULTTONULL &&
        dwFlags != MONITOR_DEFAULTTOPRIMARY &&
        dwFlags != MONITOR_DEFAULTTONEAREST)
    {
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    UserEnterShared();
 
    if (hWnd)
    {
        /* Get window object */
        pWnd = UserGetWindowObject(hWnd);
        if (pWnd)
        {
            Rect = ((pWnd->style & WS_MINIMIZE) ? pWnd->InternalPos.NormalRect : pWnd->rcWindow);
            if (RECTL_bIsEmptyRect(&Rect))
            {
                Rect.right = Rect.left + 1;
                Rect.bottom = Rect.top + 1;
            }
        }
    }
 
    hMonitor = IntGetMonitorFromRect(&Rect, dwFlags);
 
    UserLeave();
 
    TRACE("Leave NtUserMonitorFromWindow, ret=%p\n", hMonitor);
    return hMonitor;
}

Referenced by MonitorFromWindow().

UserAttachMonitor()

NTSTATUS NTAPI UserAttachMonitor

(

IN HDEV

hDev

)

Definition at line 129 of file monitor.c.

{
    PMONITOR pMonitor;
 
    TRACE("Attaching monitor...\n");
 
    /* Create new monitor object */
    pMonitor = IntCreateMonitorObject();
    if (pMonitor == NULL)
    {
        TRACE("Couldnt create monitor object\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    pMonitor->hDev = hDev;
    pMonitor->cWndStack = 0;
 
    if (gMonitorList == NULL)
    {
        TRACE("Primary monitor is beeing attached\n");
        pMonitor->IsPrimary = TRUE;
        gMonitorList = pMonitor;
    }
    else
    {
        PMONITOR pmonLast = gMonitorList;
        TRACE("Additional monitor is beeing attached\n");
        while (pmonLast->pMonitorNext != NULL)
            pmonLast = pmonLast->pMonitorNext;
 
        pmonLast->pMonitorNext = pMonitor;
    }
 
    UserUpdateMonitorSize(hDev);
 
    return STATUS_SUCCESS;
}

Referenced by co_IntInitializeDesktopGraphics().

UserDetachMonitor()

NTSTATUS NTAPI UserDetachMonitor

(

IN HDEV

hDev

)

Definition at line 179 of file monitor.c.

{
    PMONITOR pMonitor = gMonitorList, *pLink = &gMonitorList;
 
    /* Find monitor attached to given device */
    while (pMonitor != NULL)
    {
        if (pMonitor->hDev == hDev)
            break;
 
        pLink = &pMonitor->pMonitorNext;
        pMonitor = pMonitor->pMonitorNext;
    }
 
    if (pMonitor == NULL)
    {
        /* No monitor has been found */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* We destroy primary monitor - set next as primary */
    if (pMonitor->IsPrimary && pMonitor->pMonitorNext != NULL)
        pMonitor->pMonitorNext->IsPrimary = TRUE;
 
    /* Update Next ptr in previous monitor */
    *pLink = pMonitor->pMonitorNext;
 
    /* Finally destroy monitor */
    IntDestroyMonitorObject(pMonitor);
 
    return STATUS_SUCCESS;
}

UserGetMonitorObject()

PMONITOR NTAPI UserGetMonitorObject

(

IN HMONITOR

hMonitor

)

Definition at line 74 of file monitor.c.

{
    PMONITOR pMonitor;
 
    if (!hMonitor)
    {
        EngSetLastError(ERROR_INVALID_MONITOR_HANDLE);
        return NULL;
    }
 
    pMonitor = (PMONITOR)UserGetObject(gHandleTable, hMonitor, TYPE_MONITOR);
    if (!pMonitor)
    {
        EngSetLastError(ERROR_INVALID_MONITOR_HANDLE);
        return NULL;
    }
 
    return pMonitor;
}

Referenced by InitThreadCallback(), IntFixWindowCoordinates(), NtUserGetMonitorInfo(), UserMonitorFromPoint(), and UserMonitorFromRect().

UserGetPrimaryMonitor()

PMONITOR NTAPI UserGetPrimaryMonitor

(

VOID

)

Definition at line 102 of file monitor.c.

{
    PMONITOR pMonitor;
 
    /* Find primary monitor */
    for (pMonitor = gMonitorList; pMonitor != NULL; pMonitor = pMonitor->pMonitorNext)
    {
        if (pMonitor->IsPrimary)
            break;
    }
 
    return pMonitor;
}

Referenced by co_UserExcludeUpdateRgn(), co_WinPosGetMinMaxInfo(), IntFixWindowCoordinates(), IntIsWindowFullscreen(), SpiGetSet(), and UserGetDesktopDC().

UserMonitorFromPoint()

PMONITOR FASTCALL UserMonitorFromPoint	(	IN POINT	pt,
		IN DWORD	dwFlags
	)

Definition at line 490 of file monitor.c.

{
    RECTL rc;
    HMONITOR hMonitor = NULL;
 
    /* Check if flags are valid */
    if (dwFlags != MONITOR_DEFAULTTONULL &&
        dwFlags != MONITOR_DEFAULTTOPRIMARY &&
        dwFlags != MONITOR_DEFAULTTONEAREST)
    {
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    /* Fill rect (bottom-right exclusive) */
    rc.left = pt.x;
    rc.right = pt.x + 1;
    rc.top = pt.y;
    rc.bottom = pt.y + 1;
 
    /* Find intersecting monitor */
    IntGetMonitorsFromRect(&rc, &hMonitor, NULL, 1, dwFlags);
 
    return UserGetMonitorObject(hMonitor);
}

Referenced by MENU_ShowPopup().

UserMonitorFromRect()

PMONITOR NTAPI UserMonitorFromRect	(	PRECTL	pRect,
		DWORD	dwFlags
	)

Definition at line 469 of file monitor.c.

{
    HMONITOR hMonitor;
 
    /* Check if flags are valid */
    if (dwFlags != MONITOR_DEFAULTTONULL &&
        dwFlags != MONITOR_DEFAULTTOPRIMARY &&
        dwFlags != MONITOR_DEFAULTTONEAREST)
    {
        EngSetLastError(ERROR_INVALID_FLAGS);
        return NULL;
    }
 
    hMonitor = IntGetMonitorFromRect(pRect, dwFlags);
    return UserGetMonitorObject(hMonitor);
}

Referenced by IntGetWindowPlacement(), make_rect_onscreen(), SpiGetSet(), and WinPosInitInternalPos().

UserUpdateMonitorSize()

NTSTATUS NTAPI UserUpdateMonitorSize

(

IN HDEV

hDev

)

Definition at line 225 of file monitor.c.

{
    PMONITOR pMonitor;
    SIZEL DeviceSize;
 
    /* Find monitor attached to given device */
    for (pMonitor = gMonitorList; pMonitor != NULL; pMonitor = pMonitor->pMonitorNext)
    {
        if (pMonitor->hDev == hDev)
            break;
    }
 
    if (pMonitor == NULL)
    {
        /* No monitor has been found */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the size of the hdev */
    PDEVOBJ_sizl((PPDEVOBJ)hDev, &DeviceSize);
 
    /* Update monitor size */
    pMonitor->rcMonitor.left  = 0;
    pMonitor->rcMonitor.top   = 0;
    pMonitor->rcMonitor.right  = pMonitor->rcMonitor.left + DeviceSize.cx;
    pMonitor->rcMonitor.bottom = pMonitor->rcMonitor.top + DeviceSize.cy;
    pMonitor->rcWork = pMonitor->rcMonitor;
 
    /* Destroy monitor region... */
    if (pMonitor->hrgnMonitor)
    {
        GreSetObjectOwner(pMonitor->hrgnMonitor, GDI_OBJ_HMGR_POWNED);
        GreDeleteObject(pMonitor->hrgnMonitor);
    }
 
    /* ...and create new one */
    pMonitor->hrgnMonitor = NtGdiCreateRectRgn(
        pMonitor->rcMonitor.left,
        pMonitor->rcMonitor.top,
        pMonitor->rcMonitor.right,
        pMonitor->rcMonitor.bottom);
    if (pMonitor->hrgnMonitor)
        IntGdiSetRegionOwner(pMonitor->hrgnMonitor, GDI_OBJ_HMGR_PUBLIC);
 
    //
    // Should be Virtual accumulation of all the available monitors.
    //
    gpsi->rcScreenReal = pMonitor->rcMonitor;
 
    return STATUS_SUCCESS;
}

Referenced by co_IntInitializeDesktopGraphics(), UserAttachMonitor(), and UserChangeDisplaySettings().

Variable Documentation

gMonitorList

PMONITOR gMonitorList = NULL

static

Definition at line 19 of file monitor.c.

Referenced by IntGetMonitorsFromRect(), UserAttachMonitor(), UserDetachMonitor(), UserGetPrimaryMonitor(), and UserUpdateMonitorSize().