* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* INCLUDES ******************************************************************/
-#include <w32k.h>
+#include <win32k.h>
/* FIXME: find include file for these */
#define MONITORINFOF_PRIMARY 1
/* GLOBALS *******************************************************************/
/* list of monitors */
-static PMONITOR_OBJECT gMonitorList = NULL;
+static PMONITOR gMonitorList = NULL;
/* INITALIZATION FUNCTIONS ****************************************************/
/* IntCreateMonitorObject
*
- * Creates a MONITOR_OBJECT
+ * Creates a MONITOR
*
* Return value
- * If the function succeeds a pointer to a MONITOR_OBJECT is returned. On failure
+ * If the function succeeds a pointer to a MONITOR is returned. On failure
* NULL is returned.
*/
static
-PMONITOR_OBJECT
+PMONITOR
IntCreateMonitorObject()
{
HANDLE Handle;
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
- Monitor = UserCreateObject(gHandleTable, &Handle, otMonitor, sizeof (MONITOR_OBJECT));
+ Monitor = UserCreateObject(gHandleTable, NULL, &Handle, otMonitor, sizeof (MONITOR));
if (Monitor == NULL)
{
return NULL;
}
- Monitor->Handle = Handle;
ExInitializeFastMutex(&Monitor->Lock);
return Monitor;
/* IntDestroyMonitorObject
*
- * Destroys a MONITOR_OBJECT
+ * Destroys a MONITOR
* You have to be the owner of the monitors lock to safely destroy it.
*
* Arguments
*
* pMonitor
- * Pointer to the MONITOR_OBJECT which shall be deleted
+ * Pointer to the MONITOR which shall be deleted
*/
static
void
-IntDestroyMonitorObject(IN PMONITOR_OBJECT pMonitor)
+IntDestroyMonitorObject(IN PMONITOR pMonitor)
{
RtlFreeUnicodeString(&pMonitor->DeviceName);
UserDereferenceObject(pMonitor);
}
-PMONITOR_OBJECT FASTCALL
+PMONITOR FASTCALL
UserGetMonitorObject(IN HMONITOR hMonitor)
{
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
if (!hMonitor)
{
}
- Monitor = (PMONITOR_OBJECT)UserGetObject(gHandleTable, hMonitor, otMonitor);
+ Monitor = (PMONITOR)UserGetObject(gHandleTable, hMonitor, otMonitor);
if (!Monitor)
{
SetLastWin32Error(ERROR_INVALID_MONITOR_HANDLE);
return NULL;
}
- ASSERT(USER_BODY_TO_HEADER(Monitor)->RefCount >= 0);
+ ASSERT(Monitor->head.cLockObj >= 0);
return Monitor;
}
/* IntAttachMonitor
*
- * Creates a new MONITOR_OBJECT and appends it to the list of monitors.
+ * Creates a new MONITOR and appends it to the list of monitors.
*
* Arguments
*
- * pGdiDevice Pointer to the GDIDEVICE onto which the monitor was attached
+ * pGdiDevice Pointer to the PDEVOBJ onto which the monitor was attached
* DisplayNumber Display Number (starting with 0)
*
* Return value
* Returns a NTSTATUS
*/
NTSTATUS
-IntAttachMonitor(IN GDIDEVICE *pGdiDevice,
+IntAttachMonitor(IN PDEVOBJ *pGdiDevice,
IN ULONG DisplayNumber)
{
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
WCHAR Buffer[CCHDEVICENAME];
DPRINT("Attaching monitor...\n");
{
DPRINT("Couldn't duplicate monitor name!\n");
UserDereferenceObject(Monitor);
- UserDeleteObject(Monitor->Handle, otMonitor);
+ UserDeleteObject(UserHMGetHandle(Monitor), otMonitor);
return STATUS_INSUFFICIENT_RESOURCES;
}
Monitor->GdiDevice = pGdiDevice;
+ Monitor->rcMonitor.left = 0;
+ Monitor->rcMonitor.top = 0;
+ Monitor->rcMonitor.right = Monitor->rcMonitor.left + pGdiDevice->gdiinfo.ulHorzRes;
+ Monitor->rcMonitor.bottom = Monitor->rcMonitor.top + pGdiDevice->gdiinfo.ulVertRes;
+ Monitor->rcWork = Monitor->rcMonitor;
+ Monitor->cWndStack = 0;
+
+ Monitor->hrgnMonitor = IntSysCreateRectRgnIndirect( &Monitor->rcMonitor );
+
+ IntGdiSetRegionOwner(Monitor->hrgnMonitor, GDI_OBJ_HMGR_PUBLIC);
+
if (gMonitorList == NULL)
{
DPRINT("Primary monitor is beeing attached\n");
}
else
{
- PMONITOR_OBJECT p;
+ PMONITOR p;
DPRINT("Additional monitor is beeing attached\n");
for (p = gMonitorList; p->Next != NULL; p = p->Next)
- ;
{
p->Next = Monitor;
}
/* IntDetachMonitor
*
- * Deletes a MONITOR_OBJECT and removes it from the list of monitors.
+ * Deletes a MONITOR and removes it from the list of monitors.
*
* Arguments
*
- * pGdiDevice Pointer to the GDIDEVICE from which the monitor was detached
+ * pGdiDevice Pointer to the PDEVOBJ from which the monitor was detached
*
* Return value
* Returns a NTSTATUS
*/
NTSTATUS
-IntDetachMonitor(IN GDIDEVICE *pGdiDevice)
+IntDetachMonitor(IN PDEVOBJ *pGdiDevice)
{
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
if (Monitor->IsPrimary && (Monitor->Next != NULL || Monitor->Prev != NULL))
{
- PMONITOR_OBJECT NewPrimaryMonitor = (Monitor->Prev != NULL) ? (Monitor->Prev) : (Monitor->Next);
+ PMONITOR NewPrimaryMonitor = (Monitor->Prev != NULL) ? (Monitor->Prev) : (Monitor->Next);
ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&NewPrimaryMonitor->Lock);
NewPrimaryMonitor->IsPrimary = TRUE;
Monitor->Next->Prev = Monitor->Prev;
}
+ if (Monitor->hrgnMonitor)
+ REGION_FreeRgnByHandle(Monitor->hrgnMonitor);
+
IntDestroyMonitorObject(Monitor);
return STATUS_SUCCESS;
/* IntGetPrimaryMonitor
*
- * Returns a PMONITOR_OBJECT for the primary monitor
+ * Returns a PMONITOR for the primary monitor
*
* Return value
- * PMONITOR_OBJECT
+ * PMONITOR
*/
-static
-PMONITOR_OBJECT
+PMONITOR
+FASTCALL
IntGetPrimaryMonitor()
{
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
*/
static
UINT
-IntGetMonitorsFromRect(OPTIONAL IN LPCRECT pRect,
+IntGetMonitorsFromRect(OPTIONAL IN LPCRECTL pRect,
OPTIONAL OUT HMONITOR *hMonitorList,
- OPTIONAL OUT LPRECT monitorRectList,
+ OPTIONAL OUT PRECTL monitorRectList,
OPTIONAL IN DWORD listSize,
OPTIONAL IN DWORD flags)
{
- PMONITOR_OBJECT Monitor, NearestMonitor = NULL, PrimaryMonitor = NULL;
+ PMONITOR Monitor, NearestMonitor = NULL, PrimaryMonitor = NULL;
UINT iCount = 0;
LONG iNearestDistanceX = 0x7fffffff, iNearestDistanceY = 0x7fffffff;
/* find monitors which intersect the rectangle */
for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
- RECT MonitorRect, IntersectionRect;
+ RECTL MonitorRect, IntersectionRect;
ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&Monitor->Lock);
- MonitorRect.left = 0; /* FIXME: get origin */
- MonitorRect.top = 0; /* FIXME: get origin */
- MonitorRect.right = MonitorRect.left + Monitor->GdiDevice->GDIInfo.ulHorzRes;
- MonitorRect.bottom = MonitorRect.top + Monitor->GdiDevice->GDIInfo.ulVertRes;
+ MonitorRect = Monitor->rcMonitor;
ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&Monitor->Lock);
DPRINT("MonitorRect: left = %d, top = %d, right = %d, bottom = %d\n",
if (iCount < listSize)
{
if (hMonitorList != NULL)
- hMonitorList[iCount] = Monitor->Handle;
+ hMonitorList[iCount] = UserHMGetHandle(Monitor);
if (monitorRectList != NULL)
monitorRectList[iCount] = IntersectionRect;
}
if (iCount < listSize)
{
if (hMonitorList != NULL)
- hMonitorList[iCount] = NearestMonitor->Handle;
+ hMonitorList[iCount] = UserHMGetHandle(NearestMonitor);
}
iCount++;
}
if (iCount < listSize)
{
if (hMonitorList != NULL)
- hMonitorList[iCount] = PrimaryMonitor->Handle;
+ hMonitorList[iCount] = UserHMGetHandle(PrimaryMonitor);
}
iCount++;
}
* The number of monitors which intersect the specified region or -1 on failure.
*/
INT
-STDCALL
+APIENTRY
NtUserEnumDisplayMonitors(
OPTIONAL IN HDC hDC,
- OPTIONAL IN LPCRECT pRect,
+ OPTIONAL IN LPCRECTL pRect,
OPTIONAL OUT HMONITOR *hMonitorList,
- OPTIONAL OUT LPRECT monitorRectList,
+ OPTIONAL OUT PRECTL monitorRectList,
OPTIONAL IN DWORD listSize)
{
INT numMonitors, i;
HMONITOR *safeHMonitorList = NULL;
- LPRECT safeRectList = NULL;
- RECT rect, *myRect;
- RECT dcRect;
+ PRECTL safeRectList = NULL;
+ RECTL rect, *myRect;
+ RECTL dcRect;
NTSTATUS status;
/* get rect */
/* FIXME: setlasterror? */
return -1;
}
- dcVisRgn = dc->w.hVisRgn;
+ dcVisRgn = dc->rosdc.hVisRgn;
DC_UnlockDc(dc);
regionType = NtGdiGetRgnBox(dcVisRgn, &dcRect);
}
if (monitorRectList != NULL && listSize != 0)
{
- safeRectList = ExAllocatePool(PagedPool, sizeof (RECT) * listSize);
+ safeRectList = ExAllocatePoolWithTag(PagedPool, sizeof (RECT) * listSize, USERTAG_MONITORRECTS);
if (safeRectList == NULL)
{
ExFreePool(safeHMonitorList);
*
*/
BOOL
-STDCALL
+APIENTRY
NtUserGetMonitorInfo(
IN HMONITOR hMonitor,
OUT LPMONITORINFO pMonitorInfo)
{
- PMONITOR_OBJECT Monitor;
+ PMONITOR Monitor;
MONITORINFOEXW MonitorInfo;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
}
/* fill monitor info */
- MonitorInfo.rcMonitor.left = 0; /* FIXME: get origin */
- MonitorInfo.rcMonitor.top = 0; /* FIXME: get origin */
- MonitorInfo.rcMonitor.right = MonitorInfo.rcMonitor.left + Monitor->GdiDevice->GDIInfo.ulHorzRes;
- MonitorInfo.rcMonitor.bottom = MonitorInfo.rcMonitor.top + Monitor->GdiDevice->GDIInfo.ulVertRes;
- MonitorInfo.rcWork = MonitorInfo.rcMonitor; /* FIXME: use DEVMODE panning to calculate work area? */
+ MonitorInfo.rcMonitor = Monitor->rcMonitor;
+ MonitorInfo.rcWork = Monitor->rcWork;
MonitorInfo.dwFlags = 0;
if (Monitor->IsPrimary)
* return value depends on dwFlags
*/
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromPoint(
IN POINT point,
IN DWORD dwFlags)
{
INT NumMonitors;
- RECT InRect;
+ RECTL InRect;
HMONITOR hMonitor = NULL;
/* fill inRect */
{
if (dwFlags == MONITOR_DEFAULTTOPRIMARY)
{
- PMONITOR_OBJECT MonitorObj = IntGetPrimaryMonitor();
+ PMONITOR MonitorObj = IntGetPrimaryMonitor();
if (MonitorObj)
- hMonitor = MonitorObj->Handle;
+ hMonitor = UserHMGetHandle(MonitorObj);
}
else if (dwFlags == MONITOR_DEFAULTTONEAREST)
{
* return value depends on dwFlags
*/
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromRect(
- IN LPCRECT pRect,
+ IN LPCRECTL pRect,
IN DWORD dwFlags)
{
INT numMonitors, iLargestArea = -1, i;
- LPRECT rectList;
+ PRECTL rectList;
HMONITOR *hMonitorList;
HMONITOR hMonitor = NULL;
- RECT rect;
+ RECTL rect;
NTSTATUS status;
/* get rect */
{
if (dwFlags == MONITOR_DEFAULTTOPRIMARY)
{
- PMONITOR_OBJECT monitorObj = IntGetPrimaryMonitor();
+ PMONITOR monitorObj = IntGetPrimaryMonitor();
if (monitorObj)
- return monitorObj->Handle;
+ return UserHMGetHandle(monitorObj);
}
else if (dwFlags == MONITOR_DEFAULTTONEAREST)
{
/* FIXME: SetLastWin32Error? */
return (HMONITOR)NULL;
}
- rectList = ExAllocatePool(PagedPool, sizeof (RECT) * numMonitors);
+ rectList = ExAllocatePoolWithTag(PagedPool, sizeof (RECT) * numMonitors, USERTAG_MONITORRECTS);
if (rectList == NULL)
{
ExFreePool(hMonitorList);
HMONITOR
-STDCALL
+APIENTRY
NtUserMonitorFromWindow(
IN HWND hWnd,
IN DWORD dwFlags)
{
PWINDOW_OBJECT Window;
HMONITOR hMonitor = NULL;
- RECT Rect;
+ RECTL Rect;
DECLARE_RETURN(HMONITOR);
DPRINT("Enter NtUserMonitorFromWindow\n");
if (!Window->Wnd)
RETURN(hMonitor);
- Rect.left = Rect.right = Window->Wnd->WindowRect.left;
- Rect.top = Rect.bottom = Window->Wnd->WindowRect.bottom;
+ Rect.left = Rect.right = Window->Wnd->rcWindow.left;
+ Rect.top = Rect.bottom = Window->Wnd->rcWindow.bottom;
IntGetMonitorsFromRect(&Rect, &hMonitor, NULL, 1, dwFlags);
projects / reactos.git / blobdiff