coord.c

Go to the documentation of this file.

/*
 * COPYRIGHT:        GNU GPL, See COPYING in the top level directory
 * PROJECT:          ReactOS kernel
 * PURPOSE:          Coordinate systems
 * FILE:             win32ss/gdi/ntgdi/coord.c
 * PROGRAMERS:       Timo Kreuzer (timo.kreuzer@rectos.org)
 *                   Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
 */

/* Coordinate translation overview
 * -------------------------------
 *
 * Windows uses 3 different coordinate systems, referred to as world space,
 * page space and device space.
 *
 * Device space:
 * This is the coordinate system of the physical device that displays the
 * graphics. One unit matches one pixel of the surface. The coordinate system
 * is always orthogonal.
 *
 * Page space:
 * This is the coordinate system on the screen or on the paper layout for
 * printer devices. The coordinate system is also orthogonal but one unit
 * does not necessarily match one pixel. Instead there are different mapping
 * modes that can be set using SetMapMode() that specify how page space units
 * are transformed into device space units. These mapping modes are:
 * - MM_TEXT: One unit matches one unit in device space (one pixel)
 * - MM_TWIPS One unit matches 1/20 point (1/1440 inch)
 * - MM_LOMETRIC: One unit matches 0.1 millimeter
 * - MM_HIMETRIC: One unit matches 0.01 millimeter
 * - MM_LOENGLISH: One unit matches 0.01 inch
 * - MM_HIENGLISH: One unit matches 0.001 inch
 * - MM_ISOTROPIC:
 * - MM_ANISOTROPIC:
 * If the mapping mode is either MM_ISOTROPIC or MM_ANISOTROPIC, the actual
 * transformation is calculated from the window and viewport extension.
 * The window extension can be set using SetWindowExtEx() and describes the
 * extents of an arbitrary window (not to confuse with the gui element!) in
 * page space coordinates.
 * The viewport extension can be set using SetViewportExtEx() and describes
 * the extent of the same window in device space coordinates. If the mapping
 * mode is MM_ISOTROPIC one of the viewport extensions can be adjusted by GDI
 * to make sure the mapping stays isotropic, i.e. that it has the same x/y
 * ratio as the window extension.
 *
 * World space:
 * World space is the coordinate system that is used for all GDI drawing
 * operations. The metrics of this coordinate system depend on the DCs
 * graphics mode, which can be set using SetGraphicsMode().
 * If the graphics mode is GM_COMPATIBLE, world space is identical to page
 * space and no additional transformation is applied.
 * If the graphics mode is GM_ADVANCED, an arbitrary coordinate transformation
 * can be set using SetWorldTransform(), which is applied to transform world
 * space coordinates into page space coordinates.
 *
 * User mode data:
 * All coordinate translation data is stored in the DC attribute, so the values
 * might be invalid. This has to be taken into account. Values might also be
 * zero, so when a division is made, the value has to be read first and then
 * checked! This is true for both integer and floating point values, even if
 * we cannot get floating point exceptions on x86, we can get them on all other
 * architectures that use the FPU directly instead of emulation.
 * The result of all operations might be completely random and invalid, if it was
 * messed with in an illegal way in user mode. This is not a problem, since the
 * result of coordinate transformations are never expected to be "valid" values.
 * In the worst case, the drawing operation draws rubbish into the DC.
 */

/* INCLUDES ******************************************************************/

#include <win32k.h>

#define NDEBUG
#include <debug.h>
C_ASSERT(sizeof(XFORML) == sizeof(XFORM));


/* GLOBALS *******************************************************************/

const MATRIX gmxIdentity =
{
    FLOATOBJ_1, FLOATOBJ_0,
    FLOATOBJ_0, FLOATOBJ_1,
    FLOATOBJ_0, FLOATOBJ_0,
    0, 0, XFORM_NO_TRANSLATION|XFORM_FORMAT_LTOL|XFORM_UNITY|XFORM_SCALE
};


/* FUNCTIONS *****************************************************************/

VOID
FASTCALL
DC_vFixIsotropicMapping(PDC pdc)
{
    PDC_ATTR pdcattr;
    LONG64 fx, fy;
    LONG s;
    SIZEL szlWindowExt, szlViewportExt;
    ASSERT(pdc->pdcattr->iMapMode == MM_ISOTROPIC);

    /* Get a pointer to the DC_ATTR */
    pdcattr = pdc->pdcattr;

    /* Read the extents, we rely on non-null values */
    szlWindowExt = pdcattr->szlWindowExt;
    szlViewportExt = pdcattr->szlViewportExt;

    /* Check if all values are valid */
    if ((szlWindowExt.cx == 0) || (szlWindowExt.cy == 0) ||
        (szlViewportExt.cx == 0) || (szlViewportExt.cy == 0))
    {
        /* Someone put rubbish into the fields, just ignore it. */
        return;
    }

    fx = abs((LONG64)szlWindowExt.cx * szlViewportExt.cy);
    fy = abs((LONG64)szlWindowExt.cy * szlViewportExt.cx);

    if (fx < fy)
    {
        s = (szlWindowExt.cy ^ szlViewportExt.cx) > 0 ? 1 : -1;
        pdcattr->szlViewportExt.cx = (LONG)(fx * s / szlWindowExt.cy);
    }
    else if (fx > fy)
    {
        s = (szlWindowExt.cx ^ szlViewportExt.cy) > 0 ? 1 : -1;
        pdcattr->szlViewportExt.cy = (LONG)(fy * s / szlWindowExt.cx);
    }

    /* Reset the flag */
    pdc->pdcattr->flXform &= ~PAGE_EXTENTS_CHANGED;
}

VOID
FASTCALL
DC_vGetPageToDevice(PDC pdc, MATRIX *pmx)
{
    PDC_ATTR pdcattr = pdc->pdcattr;
    PSIZEL pszlViewPortExt;
    SIZEL szlWindowExt;

    /* Get the viewport extension */
    pszlViewPortExt = DC_pszlViewportExt(pdc);

    /* Copy the window extension, so no one can mess with it */
    szlWindowExt = pdcattr->szlWindowExt;

    /* No shearing / rotation */
    FLOATOBJ_SetLong(&pmx->efM12, 0);
    FLOATOBJ_SetLong(&pmx->efM21, 0);

    /* Calculate scaling */
    if (szlWindowExt.cx != 0)
    {
        FLOATOBJ_SetLong(&pmx->efM11, pszlViewPortExt->cx);
        FLOATOBJ_DivLong(&pmx->efM11, szlWindowExt.cx);
    }
    else
        FLOATOBJ_SetLong(&pmx->efM11, 1);

    if (szlWindowExt.cy != 0)
    {
        FLOATOBJ_SetLong(&pmx->efM22, pszlViewPortExt->cy);
        FLOATOBJ_DivLong(&pmx->efM22, szlWindowExt.cy);
    }
    else
        FLOATOBJ_SetLong(&pmx->efM22, 1);

    /* Calculate x offset */
    FLOATOBJ_SetLong(&pmx->efDx, -pdcattr->ptlWindowOrg.x);
    FLOATOBJ_Mul(&pmx->efDx, &pmx->efM11);
    FLOATOBJ_AddLong(&pmx->efDx, pdcattr->ptlViewportOrg.x);

    /* Calculate y offset */
    FLOATOBJ_SetLong(&pmx->efDy, -pdcattr->ptlWindowOrg.y);
    FLOATOBJ_Mul(&pmx->efDy, &pmx->efM22);
    FLOATOBJ_AddLong(&pmx->efDy, pdcattr->ptlViewportOrg.y);
}

VOID
FASTCALL
DC_vUpdateWorldToDevice(PDC pdc)
{
    XFORMOBJ xoPageToDevice, xoWorldToPage, xoWorldToDevice;
    MATRIX mxPageToDevice;

    // FIXME: make sure world-to-page is valid!

    /* Construct a transformation to do the page-to-device conversion */
    DC_vGetPageToDevice(pdc, &mxPageToDevice);
    XFORMOBJ_vInit(&xoPageToDevice, &mxPageToDevice);

    /* Recalculate the world-to-device xform */
    XFORMOBJ_vInit(&xoWorldToPage, &pdc->pdcattr->mxWorldToPage);
    XFORMOBJ_vInit(&xoWorldToDevice, &pdc->pdcattr->mxWorldToDevice);
    XFORMOBJ_iCombine(&xoWorldToDevice, &xoWorldToPage, &xoPageToDevice);

    /* Reset the flags */
    pdc->pdcattr->flXform &= ~WORLD_XFORM_CHANGED;
}

VOID
FASTCALL
DC_vUpdateDeviceToWorld(PDC pdc)
{
    XFORMOBJ xoWorldToDevice, xoDeviceToWorld;
    PMATRIX pmxWorldToDevice;

    /* Get the world-to-device translation */
    pmxWorldToDevice = DC_pmxWorldToDevice(pdc);
    XFORMOBJ_vInit(&xoWorldToDevice, pmxWorldToDevice);

    /* Create inverse of world-to-device transformation */
    XFORMOBJ_vInit(&xoDeviceToWorld, &pdc->pdcattr->mxDeviceToWorld);
    if (XFORMOBJ_iInverse(&xoDeviceToWorld, &xoWorldToDevice) == DDI_ERROR)
    {
        MX_Set0(&pdc->pdcattr->mxDeviceToWorld);
        return;
    }

    /* Reset the flag */
    pdc->pdcattr->flXform &= ~DEVICE_TO_WORLD_INVALID;
}

BOOL
NTAPI
GreCombineTransform(
    XFORML *pxformDest,
    XFORML *pxform1,
    XFORML *pxform2)
{
    MATRIX mxDest, mx1, mx2;
    XFORMOBJ xoDest, xo1, xo2;

    /* Check for illegal parameters */
    if (!pxformDest || !pxform1 || !pxform2) return FALSE;

    /* Initialize XFORMOBJs */
    XFORMOBJ_vInit(&xoDest, &mxDest);
    XFORMOBJ_vInit(&xo1, &mx1);
    XFORMOBJ_vInit(&xo2, &mx2);

    /* Convert the XFORMLs into XFORMOBJs */
    XFORMOBJ_iSetXform(&xo1, pxform1);
    XFORMOBJ_iSetXform(&xo2, pxform2);

    /* Combine them */
    XFORMOBJ_iCombine(&xoDest, &xo1, &xo2);

    /* Translate back into XFORML */
    XFORMOBJ_iGetXform(&xoDest, pxformDest);

    return TRUE;
}

BOOL
APIENTRY
NtGdiCombineTransform(
    LPXFORM UnsafeXFormResult,
    LPXFORM Unsafexform1,
    LPXFORM Unsafexform2)
{
    BOOL Ret;

    _SEH2_TRY
    {
        ProbeForWrite(UnsafeXFormResult, sizeof(XFORM), 1);
        ProbeForRead(Unsafexform1, sizeof(XFORM), 1);
        ProbeForRead(Unsafexform2, sizeof(XFORM), 1);
        Ret = GreCombineTransform((XFORML*)UnsafeXFormResult,
                                  (XFORML*)Unsafexform1,
                                  (XFORML*)Unsafexform2);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Ret = FALSE;
    }
    _SEH2_END;

    return Ret;
}

// FIXME: Should be XFORML and use XFORMOBJ functions directly
BOOL
APIENTRY
NtGdiGetTransform(
    HDC hdc,
    DWORD iXform,
    LPXFORM pXForm)
{
    PDC pdc;
    BOOL ret = TRUE;
    MATRIX mxPageToDevice;
    XFORMOBJ xo;
    PMATRIX pmx;

    if (!pXForm)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    switch (iXform)
    {
        case GdiWorldSpaceToPageSpace:
            pmx = DC_pmxWorldToPage(pdc);
            break;

        case GdiWorldSpaceToDeviceSpace:
            pmx = DC_pmxWorldToDevice(pdc);
            break;

        case GdiDeviceSpaceToWorldSpace:
            pmx = DC_pmxDeviceToWorld(pdc);
            break;

        case GdiPageSpaceToDeviceSpace:
            DC_vGetPageToDevice(pdc, &mxPageToDevice);
            pmx = &mxPageToDevice;
            break;

        default:
            DPRINT1("Unknown transform %lu\n", iXform);
            ret = FALSE;
            goto leave;
    }

    /* Initialize an XFORMOBJ */
    XFORMOBJ_vInit(&xo, pmx);

    _SEH2_TRY
    {
        ProbeForWrite(pXForm, sizeof(XFORML), 1);
        XFORMOBJ_iGetXform(&xo, (XFORML*)pXForm);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = FALSE;
    }
    _SEH2_END;

leave:
    DC_UnlockDc(pdc);
    return ret;
}


BOOL
APIENTRY
NtGdiTransformPoints(
    HDC hDC,
    PPOINT UnsafePtsIn,
    PPOINT UnsafePtOut,
    INT Count,
    INT iMode)
{
    PDC pdc;
    LPPOINT Points;
    ULONG Size;
    BOOL ret = TRUE;

    if (Count <= 0)
        return TRUE;

    if (!UnsafePtsIn || !UnsafePtOut)
    {
        return FALSE;
    }

    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        return FALSE;
    }

    Size = Count * sizeof(POINT);

    // FIXME: It would be wise to have a small stack buffer as optimization
    Points = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEMP);
    if (!Points)
    {
        DC_UnlockDc(pdc);
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    _SEH2_TRY
    {
        ProbeForWrite(UnsafePtOut, Size, 1);
        ProbeForRead(UnsafePtsIn, Size, 1);
        RtlCopyMemory(Points, UnsafePtsIn, Size);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Do not set last error */
        _SEH2_YIELD(goto leave;)
    }
    _SEH2_END;

    switch (iMode)
    {
        case GdiDpToLp:
            ret = INTERNAL_APPLY_MATRIX(DC_pmxDeviceToWorld(pdc), Points, Count);
            break;

        case GdiLpToDp:
            ret = INTERNAL_APPLY_MATRIX(DC_pmxWorldToDevice(pdc), Points, Count);
            break;

        case 2: // Not supported yet. Need testing.
        default:
        {
            EngSetLastError(ERROR_INVALID_PARAMETER);
            ret = FALSE;
            goto leave;
        }
    }

    if (ret)
    {
        _SEH2_TRY
        {
            /* Pointer was already probed! */
            RtlCopyMemory(UnsafePtOut, Points, Size);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Do not set last error */
            ret = FALSE;
        }
        _SEH2_END;
    }

//
// If we are getting called that means User XForms is a mess!
//
leave:
    DC_UnlockDc(pdc);
    ExFreePoolWithTag(Points, GDITAG_TEMP);
    return ret;
}

BOOL
NTAPI
GreModifyWorldTransform(
    PDC pdc,
    const XFORML *pxform,
    DWORD dwMode)
{
    MATRIX mxSrc;
    XFORMOBJ xoSrc, xoDC;

    switch (dwMode)
    {
        case MWT_IDENTITY:
            pdc->pdcattr->mxWorldToPage = gmxIdentity;
            break;

        case MWT_LEFTMULTIPLY:
            XFORMOBJ_vInit(&xoDC, &pdc->pdcattr->mxWorldToPage);
            XFORMOBJ_vInit(&xoSrc, &mxSrc);
            if (XFORMOBJ_iSetXform(&xoSrc, pxform) == DDI_ERROR)
                return FALSE;
            XFORMOBJ_iCombine(&xoDC, &xoSrc, &xoDC);
            break;

        case MWT_RIGHTMULTIPLY:
            XFORMOBJ_vInit(&xoDC, &pdc->pdcattr->mxWorldToPage);
            XFORMOBJ_vInit(&xoSrc, &mxSrc);
            if (XFORMOBJ_iSetXform(&xoSrc, pxform) == DDI_ERROR)
                return FALSE;
            XFORMOBJ_iCombine(&xoDC, &xoDC, &xoSrc);
            break;

        case MWT_SET:
            XFORMOBJ_vInit(&xoDC, &pdc->pdcattr->mxWorldToPage);
            if (XFORMOBJ_iSetXform(&xoDC, pxform) == DDI_ERROR)
                return FALSE;
            break;

        default:
            return FALSE;
    }

    /*Set invalidation flags */
    pdc->pdcattr->flXform |= WORLD_XFORM_CHANGED|DEVICE_TO_WORLD_INVALID;

    return TRUE;
}

BOOL
APIENTRY
NtGdiModifyWorldTransform(
    HDC hdc,
    LPXFORM pxformUnsafe,
    DWORD dwMode)
{
    PDC pdc;
    XFORML xformSafe;
    BOOL Ret = TRUE;

    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    /* The xform is permitted to be NULL for MWT_IDENTITY.
     * However, if it is not NULL, then it must be valid even
     * though it is not used. */
    if ((dwMode != MWT_IDENTITY) && (pxformUnsafe == NULL))
    {
        DC_UnlockDc(pdc);
        return FALSE;
    }

    if (pxformUnsafe != NULL)
    {
        _SEH2_TRY
        {
            ProbeForRead(pxformUnsafe, sizeof(XFORML), 1);
            RtlCopyMemory(&xformSafe, pxformUnsafe, sizeof(XFORML));
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Ret = FALSE;
        }
        _SEH2_END;
    }

    /* Safe to handle kernel mode data. */
    if (Ret) Ret = GreModifyWorldTransform(pdc, &xformSafe, dwMode);
    DC_UnlockDc(pdc);
    return Ret;
}

BOOL
APIENTRY
NtGdiOffsetViewportOrgEx(
    HDC hDC,
    int XOffset,
    int YOffset,
    LPPOINT UnsafePoint)
{
    PDC      dc;
    PDC_ATTR pdcattr;
    NTSTATUS Status = STATUS_SUCCESS;

    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;

    if (UnsafePoint)
    {
        _SEH2_TRY
        {
            ProbeForWrite(UnsafePoint, sizeof(POINT), 1);
            UnsafePoint->x = pdcattr->ptlViewportOrg.x;
            UnsafePoint->y = pdcattr->ptlViewportOrg.y;
            if (pdcattr->dwLayout & LAYOUT_RTL)
            {
                UnsafePoint->x = -UnsafePoint->x;
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;

        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            DC_UnlockDc(dc);
            return FALSE;
        }
    }

    if (pdcattr->dwLayout & LAYOUT_RTL)
    {
        XOffset = -XOffset;
    }
    pdcattr->ptlViewportOrg.x += XOffset;
    pdcattr->ptlViewportOrg.y += YOffset;
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    DC_UnlockDc(dc);

    return TRUE;
}

BOOL
APIENTRY
NtGdiOffsetWindowOrgEx(
    HDC hDC,
    int XOffset,
    int YOffset,
    LPPOINT Point)
{
    PDC dc;
    PDC_ATTR pdcattr;

    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;

    if (Point)
    {
        NTSTATUS Status = STATUS_SUCCESS;

        _SEH2_TRY
        {
            ProbeForWrite(Point, sizeof(POINT), 1);
            Point->x = pdcattr->ptlWindowOrg.x;
            Point->y = pdcattr->ptlWindowOrg.y;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;

        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            DC_UnlockDc(dc);
            return FALSE;
        }
    }

    pdcattr->ptlWindowOrg.x += XOffset;
    pdcattr->ptlWindowOrg.y += YOffset;
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    DC_UnlockDc(dc);

    return TRUE;
}

BOOL
APIENTRY
NtGdiScaleViewportExtEx(
    HDC hDC,
    int Xnum,
    int Xdenom,
    int Ynum,
    int Ydenom,
    LPSIZE pSize)
{
    PDC pDC;
    PDC_ATTR pdcattr;
    BOOL Ret = FALSE;
    LONG X, Y;

    pDC = DC_LockDc(hDC);
    if (!pDC)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = pDC->pdcattr;

    if (pdcattr->iMapMode > MM_TWIPS)
    {
        if (Xdenom && Ydenom)
        {
            DC_pszlViewportExt(pDC);
            X = Xnum * pdcattr->szlViewportExt.cx / Xdenom;
            if (X)
            {
                Y = Ynum * pdcattr->szlViewportExt.cy / Ydenom;
                if (Y)
                {
                    pdcattr->szlViewportExt.cx = X;
                    pdcattr->szlViewportExt.cy = Y;
                    pdcattr->flXform |= PAGE_XLATE_CHANGED;

                    IntMirrorWindowOrg(pDC);

                    pdcattr->flXform |= (PAGE_EXTENTS_CHANGED |
                                         INVALIDATE_ATTRIBUTES |
                                         WORLD_XFORM_CHANGED |
                                         DEVICE_TO_WORLD_INVALID);

                    if (pdcattr->iMapMode == MM_ISOTROPIC)
                    {
                        DC_vFixIsotropicMapping(pDC);
                    }

                    Ret = TRUE;
                }
            }
        }
    }
    else
        Ret = TRUE;

    if (pSize)
    {
        _SEH2_TRY
        {
            ProbeForWrite(pSize, sizeof(SIZE), 1);

            pSize->cx = pdcattr->szlViewportExt.cx;
            pSize->cy = pdcattr->szlViewportExt.cy;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            SetLastNtError(_SEH2_GetExceptionCode());
            Ret = FALSE;
        }
        _SEH2_END;
    }

    DC_UnlockDc(pDC);
    return Ret;
}

BOOL
APIENTRY
NtGdiScaleWindowExtEx(
    HDC hDC,
    int Xnum,
    int Xdenom,
    int Ynum,
    int Ydenom,
    LPSIZE pSize)
{
    PDC pDC;
    PDC_ATTR pdcattr;
    BOOL Ret = FALSE;
    LONG X, Y;

    pDC = DC_LockDc(hDC);
    if (!pDC)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = pDC->pdcattr;

    if (pSize)
    {
        NTSTATUS Status = STATUS_SUCCESS;

        _SEH2_TRY
        {
            ProbeForWrite(pSize, sizeof(SIZE), 1);

            X = pdcattr->szlWindowExt.cx;
            if (pdcattr->dwLayout & LAYOUT_RTL) X = -X;
            pSize->cx = X;
            pSize->cy = pdcattr->szlWindowExt.cy;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;

        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            DC_UnlockDc(pDC);
            return FALSE;
        }
    }

    if (pdcattr->iMapMode > MM_TWIPS)
    {
        if (Xdenom && Ydenom)
        {
            X = Xnum * pdcattr->szlWindowExt.cx / Xdenom;
            if (X)
            {
                Y = Ynum * pdcattr->szlWindowExt.cy / Ydenom;
                if (Y)
                {
                    pdcattr->szlWindowExt.cx = X;
                    pdcattr->szlWindowExt.cy = Y;

                    IntMirrorWindowOrg(pDC);

                    pdcattr->flXform |= (PAGE_EXTENTS_CHANGED |
                                         INVALIDATE_ATTRIBUTES |
                                         WORLD_XFORM_CHANGED |
                                         DEVICE_TO_WORLD_INVALID);

                    Ret = TRUE;
                }
            }
        }
    }
    else
        Ret = TRUE;

    DC_UnlockDc(pDC);
    return Ret;
}

int
APIENTRY
IntGdiSetMapMode(
    PDC dc,
    int MapMode)
{
    INT iPrevMapMode;
    FLONG flXform;
    PDC_ATTR pdcattr = dc->pdcattr;

    if (MapMode == pdcattr->iMapMode)
        return MapMode;

    flXform = pdcattr->flXform & ~(ISO_OR_ANISO_MAP_MODE|PTOD_EFM22_NEGATIVE|
        PTOD_EFM11_NEGATIVE|POSITIVE_Y_IS_UP|PAGE_TO_DEVICE_SCALE_IDENTITY|
        PAGE_TO_DEVICE_IDENTITY);

    switch (MapMode)
    {
        case MM_TEXT:
            pdcattr->szlWindowExt.cx = 1;
            pdcattr->szlWindowExt.cy = 1;
            pdcattr->szlViewportExt.cx = 1;
            pdcattr->szlViewportExt.cy = 1;
            flXform |= PAGE_TO_DEVICE_SCALE_IDENTITY;
            break;

        case MM_ISOTROPIC:
            flXform |= ISO_OR_ANISO_MAP_MODE;
            /* Fall through */

        case MM_LOMETRIC:
            pdcattr->szlWindowExt.cx = pdcattr->szlVirtualDeviceMm.cx * 10;
            pdcattr->szlWindowExt.cy = pdcattr->szlVirtualDeviceMm.cy * 10;
            pdcattr->szlViewportExt.cx =  pdcattr->szlVirtualDevicePixel.cx;
            pdcattr->szlViewportExt.cy = -pdcattr->szlVirtualDevicePixel.cy;
            break;

        case MM_HIMETRIC:
            pdcattr->szlWindowExt.cx = pdcattr->szlVirtualDeviceMm.cx * 100;
            pdcattr->szlWindowExt.cy = pdcattr->szlVirtualDeviceMm.cy * 100;
            pdcattr->szlViewportExt.cx =  pdcattr->szlVirtualDevicePixel.cx;
            pdcattr->szlViewportExt.cy = -pdcattr->szlVirtualDevicePixel.cy;
            break;

        case MM_LOENGLISH:
            pdcattr->szlWindowExt.cx = EngMulDiv(1000, pdcattr->szlVirtualDeviceMm.cx, 254);
            pdcattr->szlWindowExt.cy = EngMulDiv(1000, pdcattr->szlVirtualDeviceMm.cy, 254);
            pdcattr->szlViewportExt.cx =  pdcattr->szlVirtualDevicePixel.cx;
            pdcattr->szlViewportExt.cy = -pdcattr->szlVirtualDevicePixel.cy;
            break;

        case MM_HIENGLISH:
            pdcattr->szlWindowExt.cx = EngMulDiv(10000, pdcattr->szlVirtualDeviceMm.cx, 254);
            pdcattr->szlWindowExt.cy = EngMulDiv(10000, pdcattr->szlVirtualDeviceMm.cy, 254);
            pdcattr->szlViewportExt.cx =  pdcattr->szlVirtualDevicePixel.cx;
            pdcattr->szlViewportExt.cy = -pdcattr->szlVirtualDevicePixel.cy;
            break;

        case MM_TWIPS:
            pdcattr->szlWindowExt.cx = EngMulDiv(14400, pdcattr->szlVirtualDeviceMm.cx, 254);
            pdcattr->szlWindowExt.cy = EngMulDiv(14400, pdcattr->szlVirtualDeviceMm.cy, 254);
            pdcattr->szlViewportExt.cx =  pdcattr->szlVirtualDevicePixel.cx;
            pdcattr->szlViewportExt.cy = -pdcattr->szlVirtualDevicePixel.cy;
            break;

        case MM_ANISOTROPIC:
            flXform &= ~(PAGE_TO_DEVICE_IDENTITY|POSITIVE_Y_IS_UP);
            flXform |= ISO_OR_ANISO_MAP_MODE;
            break;

        default:
            return 0;
    }

    /* Save the old map mode and set the new one */
    iPrevMapMode = pdcattr->iMapMode;
    pdcattr->iMapMode = MapMode;

    /* Update xform flags */
    pdcattr->flXform = flXform | (PAGE_XLATE_CHANGED | PAGE_EXTENTS_CHANGED |
                                  INVALIDATE_ATTRIBUTES | DEVICE_TO_PAGE_INVALID |
                                  WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID);

    return iPrevMapMode;
}

BOOL
FASTCALL
GreSetViewportOrgEx(
    HDC hDC,
    int X,
    int Y,
    LPPOINT Point)
{
    PDC dc;
    PDC_ATTR pdcattr;

    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;

    if (Point)
    {
       Point->x = pdcattr->ptlViewportOrg.x;
       Point->y = pdcattr->ptlViewportOrg.y;
    }

    pdcattr->ptlViewportOrg.x = X;
    pdcattr->ptlViewportOrg.y = Y;
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    DC_UnlockDc(dc);
    return TRUE;
}

BOOL
APIENTRY
NtGdiSetViewportOrgEx(
    HDC hDC,
    int X,
    int Y,
    LPPOINT Point)
{
    PDC dc;
    PDC_ATTR pdcattr;

    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;

    if (Point)
    {
        NTSTATUS Status = STATUS_SUCCESS;

        _SEH2_TRY
        {
            ProbeForWrite(Point, sizeof(POINT), 1);
            Point->x = pdcattr->ptlViewportOrg.x;
            Point->y = pdcattr->ptlViewportOrg.y;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;

        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            DC_UnlockDc(dc);
            return FALSE;
        }
    }

    pdcattr->ptlViewportOrg.x = X;
    pdcattr->ptlViewportOrg.y = Y;
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    DC_UnlockDc(dc);

    return TRUE;
}

BOOL
APIENTRY
NtGdiSetWindowOrgEx(
    HDC hDC,
    int X,
    int Y,
    LPPOINT Point)
{
    PDC dc;
    PDC_ATTR pdcattr;

    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;

    if (Point)
    {
        NTSTATUS Status = STATUS_SUCCESS;

        _SEH2_TRY
        {
            ProbeForWrite(Point, sizeof(POINT), 1);
            Point->x = pdcattr->ptlWindowOrg.x;
            Point->y = pdcattr->ptlWindowOrg.y;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;

        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            DC_UnlockDc(dc);
            return FALSE;
        }
    }

    pdcattr->ptlWindowOrg.x = X;
    pdcattr->ptlWindowOrg.y = Y;
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    DC_UnlockDc(dc);

    return TRUE;
}

//
// Mirror Window function.
//
VOID
FASTCALL
IntMirrorWindowOrg(PDC dc)
{
    PDC_ATTR pdcattr;
    LONG X, cx;

    pdcattr = dc->pdcattr;

    if (!(pdcattr->dwLayout & LAYOUT_RTL))
    {
        pdcattr->ptlWindowOrg.x = pdcattr->lWindowOrgx; // Flip it back.
        return;
    }

    /* Copy the window extension, so no one can mess with it */
    cx = pdcattr->szlViewportExt.cx;
    if (cx == 0) return;
    //
    // WOrgx = wox - (Width - 1) * WExtx / VExtx
    //
    X = (dc->erclWindow.right - dc->erclWindow.left) - 1; // Get device width - 1

    X = (X * pdcattr->szlWindowExt.cx) / cx;

    pdcattr->ptlWindowOrg.x = pdcattr->lWindowOrgx - X; // Now set the inverted win origion.
    pdcattr->flXform |= PAGE_XLATE_CHANGED | WORLD_XFORM_CHANGED | DEVICE_TO_WORLD_INVALID;

    return;
}

VOID
NTAPI
DC_vSetLayout(
    IN PDC pdc,
    IN LONG wox,
    IN DWORD dwLayout)
{
    PDC_ATTR pdcattr = pdc->pdcattr;

    pdcattr->dwLayout = dwLayout;

    if (!(dwLayout & LAYOUT_ORIENTATIONMASK)) return;

    if (dwLayout & LAYOUT_RTL)
    {
        pdcattr->iMapMode = MM_ANISOTROPIC;
    }

    //pdcattr->szlWindowExt.cy = -pdcattr->szlWindowExt.cy;
    //pdcattr->ptlWindowOrg.x  = -pdcattr->ptlWindowOrg.x;

    //if (wox == -1)
    //    IntMirrorWindowOrg(pdc);
    //else
    //    pdcattr->ptlWindowOrg.x = wox - pdcattr->ptlWindowOrg.x;

    if (!(pdcattr->flTextAlign & TA_CENTER)) pdcattr->flTextAlign |= TA_RIGHT;

    if (pdc->dclevel.flPath & DCPATH_CLOCKWISE)
        pdc->dclevel.flPath &= ~DCPATH_CLOCKWISE;
    else
        pdc->dclevel.flPath |= DCPATH_CLOCKWISE;

    pdcattr->flXform |= (PAGE_EXTENTS_CHANGED |
                         INVALIDATE_ATTRIBUTES |
                         WORLD_XFORM_CHANGED |
                         DEVICE_TO_WORLD_INVALID);
}

// NtGdiSetLayout
//
// The default is left to right. This function changes it to right to left, which
// is the standard in Arabic and Hebrew cultures.
//
/*
 * @implemented
 */
DWORD
APIENTRY
NtGdiSetLayout(
    IN HDC hdc,
    IN LONG wox,
    IN DWORD dwLayout)
{
    PDC pdc;
    DWORD dwOldLayout;

    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return GDI_ERROR;
    }

    dwOldLayout = pdc->pdcattr->dwLayout;
    DC_vSetLayout(pdc, wox, dwLayout);

    DC_UnlockDc(pdc);
    return dwOldLayout;
}

/*
 * @implemented
 */
LONG
APIENTRY
NtGdiGetDeviceWidth(
    IN HDC hdc)
{
    PDC dc;
    LONG Ret;
    dc = DC_LockDc(hdc);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
    Ret = dc->erclWindow.right - dc->erclWindow.left;
    DC_UnlockDc(dc);
    return Ret;
}

/*
 * @implemented
 */
BOOL
APIENTRY
NtGdiMirrorWindowOrg(
    IN HDC hdc)
{
    PDC dc;
    dc = DC_LockDc(hdc);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    IntMirrorWindowOrg(dc);
    DC_UnlockDc(dc);
    return TRUE;
}

/*
 * @implemented
 */
BOOL
APIENTRY
NtGdiSetSizeDevice(
    IN HDC hdc,
    IN INT cxVirtualDevice,
    IN INT cyVirtualDevice)
{
    PDC dc;
    PDC_ATTR pdcattr;

    if (!cxVirtualDevice || !cyVirtualDevice)
    {
        return FALSE;
    }

    dc = DC_LockDc(hdc);
    if (!dc) return FALSE;

    pdcattr = dc->pdcattr;

    pdcattr->szlVirtualDeviceSize.cx = cxVirtualDevice;
    pdcattr->szlVirtualDeviceSize.cy = cyVirtualDevice;

    DC_UnlockDc(dc);

    return TRUE;
}

/*
 * @implemented
 */
BOOL
APIENTRY
NtGdiSetVirtualResolution(
    IN HDC hdc,
    IN INT cxVirtualDevicePixel,
    IN INT cyVirtualDevicePixel,
    IN INT cxVirtualDeviceMm,
    IN INT cyVirtualDeviceMm)
{
    PDC dc;
    PDC_ATTR pdcattr;

    /* Check parameters (all zeroes resets to real resolution) */
    if (cxVirtualDevicePixel == 0 && cyVirtualDevicePixel == 0 &&
        cxVirtualDeviceMm == 0 && cyVirtualDeviceMm == 0)
    {
        cxVirtualDevicePixel = NtGdiGetDeviceCaps(hdc, HORZRES);
        cyVirtualDevicePixel = NtGdiGetDeviceCaps(hdc, VERTRES);
        cxVirtualDeviceMm = NtGdiGetDeviceCaps(hdc, HORZSIZE);
        cyVirtualDeviceMm = NtGdiGetDeviceCaps(hdc, VERTSIZE);
    }
    else if (cxVirtualDevicePixel == 0 || cyVirtualDevicePixel == 0 ||
             cxVirtualDeviceMm == 0 || cyVirtualDeviceMm == 0)
    {
        return FALSE;
    }

    dc = DC_LockDc(hdc);
    if (!dc) return FALSE;

    pdcattr = dc->pdcattr;

    pdcattr->szlVirtualDevicePixel.cx = cxVirtualDevicePixel;
    pdcattr->szlVirtualDevicePixel.cy = cyVirtualDevicePixel;
    pdcattr->szlVirtualDeviceMm.cx = cxVirtualDeviceMm;
    pdcattr->szlVirtualDeviceMm.cy = cyVirtualDeviceMm;

//    DC_vUpdateXforms(dc);
    DC_UnlockDc(dc);
    return TRUE;
}

static
VOID FASTCALL
DC_vGetAspectRatioFilter(PDC pDC, LPSIZE AspectRatio)
{
    if (pDC->pdcattr->flFontMapper & 1) // TRUE assume 1.
    {
        // "This specifies that Windows should only match fonts that have the
        // same aspect ratio as the display.", Programming Windows, Fifth Ed.
        AspectRatio->cx = pDC->ppdev->gdiinfo.ulLogPixelsX;
        AspectRatio->cy = pDC->ppdev->gdiinfo.ulLogPixelsY;
    }
    else
    {
        AspectRatio->cx = 0;
        AspectRatio->cy = 0;
    }
}

BOOL APIENTRY
GreGetDCPoint(
    HDC hDC,
    UINT iPoint,
    PPOINTL Point)
{
    BOOL Ret = TRUE;
    DC *pdc;
    SIZE Size;
    PSIZEL pszlViewportExt;

    if (!Point)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    switch (iPoint)
    {
        case GdiGetViewPortExt:
            pszlViewportExt = DC_pszlViewportExt(pdc);
            Point->x = pszlViewportExt->cx;
            Point->y = pszlViewportExt->cy;
            break;

        case GdiGetWindowExt:
            Point->x = pdc->pdcattr->szlWindowExt.cx;
            Point->y = pdc->pdcattr->szlWindowExt.cy;
            break;

        case GdiGetViewPortOrg:
            *Point = pdc->pdcattr->ptlViewportOrg;
            break;

        case GdiGetWindowOrg:
            *Point = pdc->pdcattr->ptlWindowOrg;
            break;

        case GdiGetDCOrg:
            *Point = pdc->ptlDCOrig;
            break;

        case GdiGetAspectRatioFilter:
            DC_vGetAspectRatioFilter(pdc, &Size);
            Point->x = Size.cx;
            Point->y = Size.cy;
            break;

        default:
            EngSetLastError(ERROR_INVALID_PARAMETER);
            Ret = FALSE;
            break;
    }

    DC_UnlockDc(pdc);
    return Ret;
}

BOOL
WINAPI
GreSetDCOrg(
    _In_ HDC hdc,
    _In_ LONG x,
    _In_ LONG y,
    _In_opt_ PRECTL Rect)
{
    PDC dc;

    dc = DC_LockDc(hdc);
    if (!dc) return FALSE;

    /* Set DC Origin */
    dc->ptlDCOrig.x = x;
    dc->ptlDCOrig.y = y;

    /* Recalculate Fill Origin */
    dc->ptlFillOrigin.x = dc->dclevel.ptlBrushOrigin.x + x;
    dc->ptlFillOrigin.y = dc->dclevel.ptlBrushOrigin.y + y;

    /* Set DC Window Rectangle */
    if (Rect)
        dc->erclWindow = *Rect;

    DC_UnlockDc(dc);
    return TRUE;
}

BOOL
WINAPI
GreGetDCOrgEx(
    _In_ HDC hdc,
    _Out_ PPOINTL Point,
    _Out_ PRECTL Rect)
{
    PDC dc;

    dc = DC_LockDc(hdc);
    if (!dc) return FALSE;

    /* Retrieve DC Window Rectangle without a check */
    *Rect = dc->erclWindow;

    DC_UnlockDc(dc);

    /* Use default call for DC Origin and parameter checking */
    return GreGetDCPoint( hdc, GdiGetDCOrg, Point);
}

BOOL
WINAPI
GreGetWindowExtEx(
    _In_ HDC hdc,
    _Out_ LPSIZE lpSize)
{
    return GreGetDCPoint(hdc, GdiGetWindowExt, (PPOINTL)lpSize);
}

BOOL
WINAPI
GreGetViewportExtEx(
    _In_ HDC hdc,
    _Out_ LPSIZE lpSize)
{
    return GreGetDCPoint(hdc, GdiGetViewPortExt, (PPOINTL)lpSize);
}

BOOL APIENTRY
NtGdiGetDCPoint(
    HDC hDC,
    UINT iPoint,
    PPOINTL Point)
{
    BOOL Ret;
    POINTL SafePoint;

    if (!Point)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    Ret = GreGetDCPoint(hDC, iPoint, &SafePoint);
    if (Ret)
    {
        _SEH2_TRY
        {
            ProbeForWrite(Point, sizeof(POINT), 1);
            *Point = SafePoint;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Ret = FALSE;
        }
        _SEH2_END;
    }

    return Ret;
}

/* EOF */