coord.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

    return FALSE;
  }

  if (UnsafePoint)
    {
        _SEH_TRY
        {
            ProbeForWrite(UnsafePoint,
                          sizeof(POINT),
                          1);
            UnsafePoint->x = dc->Dc_Attr.ptlViewportOrg.x;
            UnsafePoint->y = dc->Dc_Attr.ptlViewportOrg.y;
        }
        _SEH_HANDLE
        {
            Status = _SEH_GetExceptionCode();
        }
        _SEH_END;

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

  dc->Dc_Attr.ptlViewportOrg.x += XOffset;
  dc->Dc_Attr.ptlViewportOrg.y += YOffset;
  DC_UpdateXforms(dc);

  DC_UnlockDc(dc);
  return TRUE;
}

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

  dc = DC_LockDc(hDC);
  if (!dc)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  if (Point)
    {
      NTSTATUS Status = STATUS_SUCCESS;
      
      _SEH_TRY
      {
         ProbeForWrite(Point,
                       sizeof(POINT),
                       1);
         Point->x = dc->Dc_Attr.ptlWindowOrg.x;
         Point->y = dc->Dc_Attr.ptlWindowOrg.y;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->Dc_Attr.ptlWindowOrg.x += XOffset;
  dc->Dc_Attr.ptlWindowOrg.y += YOffset;

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}

BOOL
STDCALL
NtGdiScaleViewportExtEx(HDC  hDC,
                             int  Xnum,
                             int  Xdenom,
                             int  Ynum,
                             int  Ydenom,
                             LPSIZE  Size)
{
   UNIMPLEMENTED;
   return FALSE;
}

BOOL
STDCALL
NtGdiScaleWindowExtEx(HDC  hDC,
                           int  Xnum,
                           int  Xdenom,
                           int  Ynum,
                           int  Ydenom,
                           LPSIZE  Size)
{
   UNIMPLEMENTED;
   return FALSE;
}

int
STDCALL
NtGdiSetGraphicsMode(HDC  hDC,
                    int  Mode)
{
  INT ret;
  PDC dc;

  dc = DC_LockDc (hDC);
  if (!dc)
  {
    SetLastWin32Error(ERROR_INVALID_HANDLE);
    return 0;
  }

  /* One would think that setting the graphics mode to GM_COMPATIBLE
   * would also reset the world transformation matrix to the unity
   * matrix. However, in Windows, this is not the case. This doesn't
   * make a lot of sense to me, but that's the way it is.
   */

  if ((Mode != GM_COMPATIBLE) && (Mode != GM_ADVANCED))
    {
      DC_UnlockDc(dc);
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      return 0;
    }

  ret = dc->Dc_Attr.iGraphicsMode;
  dc->Dc_Attr.iGraphicsMode = Mode;
  DC_UnlockDc(dc);
  return  ret;
}

int
STDCALL
NtGdiSetMapMode(HDC  hDC,
                int  MapMode)
{
  int PrevMapMode;
  PDC dc;

  dc = DC_LockDc(hDC);
  if (!dc)
  {
    SetLastWin32Error(ERROR_INVALID_HANDLE);
    return 0;
  }

  PrevMapMode = dc->Dc_Attr.iMapMode;

  if (MapMode != dc->Dc_Attr.iMapMode || (MapMode != MM_ISOTROPIC && MapMode != MM_ANISOTROPIC))
  {
    dc->Dc_Attr.iMapMode = MapMode;

    switch (MapMode)
    {
      case MM_TEXT:
        dc->Dc_Attr.szlWindowExt.cx = 1;
        dc->Dc_Attr.szlWindowExt.cy = 1;
        dc->Dc_Attr.szlViewportExt.cx = 1;
        dc->Dc_Attr.szlViewportExt.cy = 1;
        break;

      case MM_LOMETRIC:
      case MM_ISOTROPIC:
        dc->Dc_Attr.szlWindowExt.cx = dc->GDIInfo->ulHorzSize * 10;
        dc->Dc_Attr.szlWindowExt.cy = dc->GDIInfo->ulVertSize * 10;
        dc->Dc_Attr.szlViewportExt.cx = dc->GDIInfo->ulHorzRes;
        dc->Dc_Attr.szlViewportExt.cy = -dc->GDIInfo->ulVertRes;
        break;

      case MM_HIMETRIC:
        dc->Dc_Attr.szlWindowExt.cx = dc->GDIInfo->ulHorzSize * 100;
        dc->Dc_Attr.szlWindowExt.cy = dc->GDIInfo->ulVertSize * 100;
        dc->Dc_Attr.szlViewportExt.cx = dc->GDIInfo->ulHorzRes;
        dc->Dc_Attr.szlViewportExt.cy = -dc->GDIInfo->ulVertRes;
        break;

      case MM_LOENGLISH:
        dc->Dc_Attr.szlWindowExt.cx = EngMulDiv(1000, dc->GDIInfo->ulHorzSize, 254);
        dc->Dc_Attr.szlWindowExt.cy = EngMulDiv(1000, dc->GDIInfo->ulVertSize, 254);
        dc->Dc_Attr.szlViewportExt.cx = dc->GDIInfo->ulHorzRes;
        dc->Dc_Attr.szlViewportExt.cy = -dc->GDIInfo->ulVertRes;
        break;

      case MM_HIENGLISH:
        dc->Dc_Attr.szlWindowExt.cx = EngMulDiv(10000, dc->GDIInfo->ulHorzSize, 254);
        dc->Dc_Attr.szlWindowExt.cy = EngMulDiv(10000, dc->GDIInfo->ulVertSize, 254);
        dc->Dc_Attr.szlViewportExt.cx = dc->GDIInfo->ulHorzRes;
        dc->Dc_Attr.szlViewportExt.cy = -dc->GDIInfo->ulVertRes;
        break;

      case MM_TWIPS:
        dc->Dc_Attr.szlWindowExt.cx = EngMulDiv(14400, dc->GDIInfo->ulHorzSize, 254);
        dc->Dc_Attr.szlWindowExt.cy = EngMulDiv(14400, dc->GDIInfo->ulVertSize, 254);
        dc->Dc_Attr.szlViewportExt.cx = dc->GDIInfo->ulHorzRes;
        dc->Dc_Attr.szlViewportExt.cy = -dc->GDIInfo->ulVertRes;
        break;

      case MM_ANISOTROPIC:
        break;
    }

    DC_UpdateXforms(dc);
  }

  DC_UnlockDc(dc);

  return PrevMapMode;
}

BOOL
STDCALL
NtGdiSetViewportExtEx(HDC  hDC,
                      int  XExtent,
                      int  YExtent,
                      LPSIZE  Size)
{
  PDC dc;

  dc = DC_LockDc(hDC);
  if ( !dc )
  {
    SetLastWin32Error(ERROR_INVALID_HANDLE);
    return FALSE;
  }

  switch (dc->Dc_Attr.iMapMode)
    {
      case MM_HIENGLISH:
      case MM_HIMETRIC:
      case MM_LOENGLISH:
      case MM_LOMETRIC:
      case MM_TEXT:
      case MM_TWIPS:
	DC_UnlockDc(dc);
	return FALSE;

      case MM_ISOTROPIC:
	// Here we should (probably) check that SetWindowExtEx *really* has
	// been called
	break;
    }

  if (Size)
    {
      NTSTATUS Status = STATUS_SUCCESS;

      _SEH_TRY
      {
         ProbeForWrite(Size,
                       sizeof(SIZE),
                       1);
         Size->cx = dc->Dc_Attr.szlViewportExt.cx;
         Size->cy = dc->Dc_Attr.szlViewportExt.cy;

		 dc->Dc_Attr.szlViewportExt.cx = XExtent;
         dc->Dc_Attr.szlViewportExt.cy = YExtent;

         if (dc->Dc_Attr.iMapMode == MM_ISOTROPIC)
             IntFixIsotropicMapping(dc);
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  
  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}

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

  dc = DC_LockDc(hDC);
  if (!dc)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  if (Point)
    {
      NTSTATUS Status = STATUS_SUCCESS;
      
      _SEH_TRY
      {
         ProbeForWrite(Point,
                       sizeof(POINT),
                       1);
         Point->x = dc->Dc_Attr.ptlViewportOrg.x;
         Point->y = dc->Dc_Attr.ptlViewportOrg.y;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->Dc_Attr.ptlViewportOrg.x = X;
  dc->Dc_Attr.ptlViewportOrg.y = Y;

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}

BOOL
STDCALL
NtGdiSetWindowExtEx(HDC  hDC,
                   int  XExtent,
                   int  YExtent,
                   LPSIZE  Size)
{
  PDC dc;

  dc = DC_LockDc(hDC);
  if (!dc)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  switch (dc->Dc_Attr.iMapMode)
    {
      case MM_HIENGLISH:
      case MM_HIMETRIC:
      case MM_LOENGLISH:
      case MM_LOMETRIC:
      case MM_TEXT:
      case MM_TWIPS:
	DC_UnlockDc(dc);
	return FALSE;
    }

  if (Size)
    {
      NTSTATUS Status = STATUS_SUCCESS;
      
      _SEH_TRY
      {
         ProbeForWrite(Size,
                       sizeof(SIZE),
                       1);
         Size->cx = dc->Dc_Attr.szlWindowExt.cx;
         Size->cy = dc->Dc_Attr.szlWindowExt.cy;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->Dc_Attr.szlWindowExt.cx = XExtent;
  dc->Dc_Attr.szlWindowExt.cy = YExtent;

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}

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

  dc = DC_LockDc(hDC);
  if (!dc)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  if (Point)
    {
      NTSTATUS Status = STATUS_SUCCESS;
      
      _SEH_TRY
      {
         ProbeForWrite(Point,
                       sizeof(POINT),
                       1);
         Point->x = dc->Dc_Attr.ptlWindowOrg.x;
         Point->y = dc->Dc_Attr.ptlWindowOrg.y;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->Dc_Attr.ptlWindowOrg.x = X;
  dc->Dc_Attr.ptlWindowOrg.y = Y;

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}


/* EOF */