coord.c

winNT技术操作系统,国外开放的原代码和LIUX一样

  NTSTATUS Status = STATUS_SUCCESS;

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

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

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

  dc->vportOrgX += XOffset;
  dc->vportOrgY += 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->wndOrgX;
         Point->y = dc->wndOrgY;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->wndOrgX += XOffset;
  dc->wndOrgY += 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->w.GraphicsMode;
  dc->w.GraphicsMode = 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->w.MapMode;

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

    switch (MapMode)
    {
      case MM_TEXT:
        dc->wndExtX = 1;
        dc->wndExtY = 1;
        dc->vportExtX = 1;
        dc->vportExtY = 1;
        break;

      case MM_LOMETRIC:
      case MM_ISOTROPIC:
        dc->wndExtX = dc->GDIInfo->ulHorzSize * 10;
        dc->wndExtY = dc->GDIInfo->ulVertSize * 10;
        dc->vportExtX = dc->GDIInfo->ulHorzRes;
        dc->vportExtY = -dc->GDIInfo->ulVertRes;
        break;

      case MM_HIMETRIC:
        dc->wndExtX = dc->GDIInfo->ulHorzSize * 100;
        dc->wndExtY = dc->GDIInfo->ulVertSize * 100;
        dc->vportExtX = dc->GDIInfo->ulHorzRes;
        dc->vportExtY = -dc->GDIInfo->ulVertRes;
        break;

      case MM_LOENGLISH:
        dc->wndExtX = EngMulDiv(1000, dc->GDIInfo->ulHorzSize, 254);
        dc->wndExtY = EngMulDiv(1000, dc->GDIInfo->ulVertSize, 254);
        dc->vportExtX = dc->GDIInfo->ulHorzRes;
        dc->vportExtY = -dc->GDIInfo->ulVertRes;
        break;

      case MM_HIENGLISH:
        dc->wndExtX = EngMulDiv(10000, dc->GDIInfo->ulHorzSize, 254);
        dc->wndExtY = EngMulDiv(10000, dc->GDIInfo->ulVertSize, 254);
        dc->vportExtX = dc->GDIInfo->ulHorzRes;
        dc->vportExtY = -dc->GDIInfo->ulVertRes;
        break;

      case MM_TWIPS:
        dc->wndExtX = EngMulDiv(14400, dc->GDIInfo->ulHorzSize, 254);
        dc->wndExtY = EngMulDiv(14400, dc->GDIInfo->ulVertSize, 254);
        dc->vportExtX = dc->GDIInfo->ulHorzRes;
        dc->vportExtY = -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->w.MapMode)
    {
      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->vportExtX;
         Size->cy = dc->vportExtY;

		 dc->vportExtX = XExtent;
         dc->vportExtY = YExtent;

         if (dc->w.MapMode == 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->vportOrgX;
         Point->y = dc->vportOrgY;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->vportOrgX = X;
  dc->vportOrgY = 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->w.MapMode)
    {
      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->wndExtX;
         Size->cy = dc->wndExtY;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->wndExtX = XExtent;
  dc->wndExtY = 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->wndOrgX;
         Point->y = dc->wndOrgY;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

  dc->wndOrgX = X;
  dc->wndOrgY = Y;

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);

  return TRUE;
}

BOOL
STDCALL
NtGdiSetWorldTransform(HDC  hDC,
                      CONST LPXFORM  XForm)
{
  PDC  dc;
  NTSTATUS Status = STATUS_SUCCESS;

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

  if (!XForm)
  {
    DC_UnlockDc(dc);
    /* Win doesn't set LastError */
    return  FALSE;
  }

  /* Check that graphics mode is GM_ADVANCED */
  if ( dc->w.GraphicsMode != GM_ADVANCED )
  {
    DC_UnlockDc(dc);
    return  FALSE;
  }

  _SEH_TRY
  {
    ProbeForRead(XForm,
                 sizeof(XFORM),
                 1);
    dc->w.xformWorld2Wnd = *XForm;
  }
  _SEH_HANDLE
  {
    Status = _SEH_GetExceptionCode();
  }
  _SEH_END;

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

  DC_UpdateXforms(dc);
  DC_UnlockDc(dc);
  return  TRUE;
}

/* EOF */