dc.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

}

BOOL STDCALL
NtGdiDeleteObjectApp(HANDLE  DCHandle)
{
  PDC  DCToDelete;

  if (!GDIOBJ_OwnedByCurrentProcess(GdiHandleTable, DCHandle))
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  DCToDelete = DC_LockDc(DCHandle);
  if (DCToDelete == NULL)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
    }

  /*  First delete all saved DCs  */
  while (DCToDelete->saveLevel)
  {
    PDC  savedDC;
    HDC  savedHDC;

    savedHDC = DC_GetNextDC (DCToDelete);
    savedDC = DC_LockDc (savedHDC);
    if (savedDC == NULL)
    {
      break;
    }
    DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
    DCToDelete->saveLevel--;
    DC_UnlockDc( savedDC );
    NtGdiDeleteObjectApp (savedHDC);
  }

  /*  Free GDI resources allocated to this DC  */
  if (!(DCToDelete->w.flags & DC_SAVED))
  {
    /*
    NtGdiSelectObject (DCHandle, STOCK_BLACK_PEN);
    NtGdiSelectObject (DCHandle, STOCK_WHITE_BRUSH);
    NtGdiSelectObject (DCHandle, STOCK_SYSTEM_FONT);
    DC_LockDC (DCHandle); NtGdiSelectObject does not recognize stock objects yet  */
    if (DCToDelete->w.flags & DC_MEMORY)
    {
      NtGdiDeleteObject (DCToDelete->w.hFirstBitmap);
    }
    if (DCToDelete->XlateBrush != NULL)
      EngDeleteXlate(DCToDelete->XlateBrush);
    if (DCToDelete->XlatePen != NULL)
      EngDeleteXlate(DCToDelete->XlatePen);
  }
  if (DCToDelete->w.hClipRgn)
  {
    NtGdiDeleteObject (DCToDelete->w.hClipRgn);
  }
  if (DCToDelete->w.hVisRgn)
  {
    NtGdiDeleteObject (DCToDelete->w.hVisRgn);
  }
  if (NULL != DCToDelete->CombinedClip)
    {
      IntEngDeleteClipRegion(DCToDelete->CombinedClip);
    }
  if (DCToDelete->w.hGCClipRgn)
  {
    NtGdiDeleteObject (DCToDelete->w.hGCClipRgn);
  }
#if 0 /* FIXME */
  PATH_DestroyGdiPath (&DCToDelete->w.path);
#endif

  if (DCToDelete->emh)
  {
	 EngFreeMem(DCToDelete->emh);
  }

  DC_UnlockDc( DCToDelete );
  DC_FreeDC ( DCHandle );

  return TRUE;
}

INT
APIENTRY
NtGdiDrawEscape(
    IN HDC hdc,
    IN INT iEsc,
    IN INT cjIn,
    IN OPTIONAL LPSTR pjIn)
{
  UNIMPLEMENTED;
  return 0;
}

ULONG
APIENTRY
NtGdiEnumObjects(
    IN HDC hdc,
    IN INT iObjectType,
    IN ULONG cjBuf,
    OUT OPTIONAL PVOID pvBuf)
{
  UNIMPLEMENTED;
  return 0;
}

DC_GET_VAL( COLORREF, NtGdiGetBkColor, Dc_Attr.crBackgroundClr )
DC_GET_VAL( INT, NtGdiGetBkMode, Dc_Attr.jBkMode )
DC_GET_VAL_EX( GetBrushOrgEx, Dc_Attr.ptlBrushOrigin.x, Dc_Attr.ptlBrushOrigin.y, POINT, x, y )

HGDIOBJ STDCALL
NtGdiGetCurrentObject(HDC  hDC, UINT  ObjectType)
{
  HGDIOBJ SelObject;
  DC *dc;

  /* From Wine: GetCurrentObject does not SetLastError() on a null object */
  if(!hDC) return NULL;

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

  switch(ObjectType)
  {
    case OBJ_PEN:
    case OBJ_EXTPEN:
      SelObject = dc->Dc_Attr.hpen;
      break;
    case OBJ_BRUSH:
      SelObject = dc->Dc_Attr.hbrush;
      break;
    case OBJ_PAL:
      SelObject = dc->w.hPalette;
      break;
    case OBJ_FONT:
      SelObject = dc->Dc_Attr.hlfntNew;
      break;
    case OBJ_BITMAP:
      SelObject = dc->w.hBitmap;
      break;
    case OBJ_COLORSPACE:
      DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
      SelObject = NULL;
      break;
    default:
      SelObject = NULL;
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      break;
  }

  DC_UnlockDc(dc);
  return SelObject;
}

DC_GET_VAL_EX ( GetCurrentPositionEx, Dc_Attr.ptlCurrent.x, Dc_Attr.ptlCurrent.y, POINT, x, y )

BOOL FASTCALL
IntGdiGetDCOrgEx(DC *dc, LPPOINT  Point)
{
  Point->x = dc->w.DCOrgX;
  Point->y = dc->w.DCOrgY;

  return  TRUE;
}

BOOL STDCALL
NtGdiGetDCPoint( HDC hDC, UINT iPoint, PPOINTL Point)
{
  BOOL Ret = TRUE;
  DC *dc;
  POINT SafePoint;
  SIZE Size;
  NTSTATUS Status = STATUS_SUCCESS;

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

  RtlZeroMemory(&SafePoint, sizeof(POINT));

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

  switch (iPoint)
  {
    case GdiGetViewPortExt:
      IntGetViewportExtEx(dc, &Size);
      SafePoint.x = Size.cx;
      SafePoint.y = Size.cy;
      break;
    case GdiGetWindowExt:
      IntGetWindowExtEx(dc, &Size);
      SafePoint.x = Size.cx;
      SafePoint.y = Size.cy;
      break;
    case GdiGetViewPortOrg:
      IntGetViewportOrgEx(dc, &SafePoint);
      break;
    case GdiGetWindowOrg:
      IntGetWindowOrgEx(dc, &SafePoint);
      break;
    case GdiGetDCOrg:
      Ret = IntGdiGetDCOrgEx(dc, &SafePoint);
      break;
    case GdiGetAspectRatioFilter:
    default:
      SetLastWin32Error(ERROR_INVALID_PARAMETER);
      Ret = FALSE;
      break;
  }

  if (Ret)
  {
    _SEH_TRY
    {
      ProbeForWrite(Point,
                    sizeof(POINT),
                    1);
      *Point = SafePoint;
    }
    _SEH_HANDLE
    {
      Status = _SEH_GetExceptionCode();
    }
    _SEH_END;
  }

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

  DC_UnlockDc(dc);
  return Ret;
}

COLORREF STDCALL
NtGdiSetBkColor(HDC hDC, COLORREF color)
{
  COLORREF oldColor;
  PDC dc;
  HBRUSH hBrush;

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

  oldColor = dc->Dc_Attr.crBackgroundClr;
  dc->Dc_Attr.crBackgroundClr = color;
  hBrush = dc->Dc_Attr.hbrush;
  DC_UnlockDc(dc);
  NtGdiSelectObject(hDC, hBrush);
  return oldColor;
}

HDC STDCALL
IntGdiGetDCState(HDC  hDC)
{
  PDC  newdc, dc;
  HDC hnewdc;

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

  hnewdc = DC_AllocDC(NULL);
  if (hnewdc == NULL)
  {
    DC_UnlockDc(dc);
    return 0;
  }
  newdc = DC_LockDc( hnewdc );
  /* FIXME - newdc can be NULL!!!! Don't assert here!!! */
  ASSERT( newdc );

  newdc->w.flags            = dc->w.flags | DC_SAVED;
  newdc->Dc_Attr.hpen             = dc->Dc_Attr.hpen;
  newdc->Dc_Attr.hbrush           = dc->Dc_Attr.hbrush;
  newdc->Dc_Attr.hlfntNew            = dc->Dc_Attr.hlfntNew;
  newdc->w.hBitmap          = dc->w.hBitmap;
  newdc->w.hFirstBitmap     = dc->w.hFirstBitmap;
#if 0
  newdc->w.hDevice          = dc->w.hDevice;
#endif
  newdc->PalIndexed         = dc->PalIndexed;
  newdc->w.hPalette         = dc->w.hPalette;
  newdc->w.totalExtent      = dc->w.totalExtent;
  newdc->w.bitsPerPixel     = dc->w.bitsPerPixel;
  newdc->Dc_Attr.jROP2          = dc->Dc_Attr.jROP2;
  newdc->Dc_Attr.jFillMode     = dc->Dc_Attr.jFillMode;
  newdc->Dc_Attr.jStretchBltMode   = dc->Dc_Attr.jStretchBltMode;
  newdc->Dc_Attr.lRelAbs       = dc->Dc_Attr.lRelAbs;
  newdc->Dc_Attr.jBkMode   = dc->Dc_Attr.jBkMode;
  newdc->Dc_Attr.crBackgroundClr  = dc->Dc_Attr.crBackgroundClr;
  newdc->Dc_Attr.crForegroundClr        = dc->Dc_Attr.crForegroundClr;
  newdc->Dc_Attr.ptlBrushOrigin.x        = dc->Dc_Attr.ptlBrushOrigin.x;
  newdc->Dc_Attr.ptlBrushOrigin.y        = dc->Dc_Attr.ptlBrushOrigin.y;
  newdc->Dc_Attr.lTextAlign        = dc->Dc_Attr.lTextAlign;
  newdc->Dc_Attr.lTextExtra        = dc->Dc_Attr.lTextExtra;
  newdc->Dc_Attr.cBreak       = dc->Dc_Attr.cBreak;
  newdc->Dc_Attr.lBreakExtra       = dc->Dc_Attr.lBreakExtra;
  newdc->Dc_Attr.iMapMode          = dc->Dc_Attr.iMapMode;
  newdc->Dc_Attr.iGraphicsMode     = dc->Dc_Attr.iGraphicsMode;
#if 0
  /* Apparently, the DC origin is not changed by [GS]etDCState */
  newdc->w.DCOrgX           = dc->w.DCOrgX;
  newdc->w.DCOrgY           = dc->w.DCOrgY;
#endif
  newdc->Dc_Attr.ptlCurrent.x         = dc->Dc_Attr.ptlCurrent.x;
  newdc->Dc_Attr.ptlCurrent.y         = dc->Dc_Attr.ptlCurrent.y;
  newdc->w.ArcDirection     = dc->w.ArcDirection;
  newdc->w.xformWorld2Wnd   = dc->w.xformWorld2Wnd;
  newdc->w.xformWorld2Vport = dc->w.xformWorld2Vport;
  newdc->w.xformVport2World = dc->w.xformVport2World;
  newdc->w.vport2WorldValid = dc->w.vport2WorldValid;
  newdc->Dc_Attr.ptlWindowOrg.x            = dc->Dc_Attr.ptlWindowOrg.x;
  newdc->Dc_Attr.ptlWindowOrg.y            = dc->Dc_Attr.ptlWindowOrg.y;
  newdc->Dc_Attr.szlWindowExt.cx            = dc->Dc_Attr.szlWindowExt.cx;
  newdc->Dc_Attr.szlWindowExt.cy            = dc->Dc_Attr.szlWindowExt.cy;
  newdc->Dc_Attr.ptlViewportOrg.x          = dc->Dc_Attr.ptlViewportOrg.x;
  newdc->Dc_Attr.ptlViewportOrg.y          = dc->Dc_Attr.ptlViewportOrg.y;
  newdc->Dc_Attr.szlViewportExt.cx          = dc->Dc_Attr.szlViewportExt.cx;
  newdc->Dc_Attr.szlViewportExt.cy          = dc->Dc_Attr.szlViewportExt.cy;

  newdc->hSelf = hnewdc;
  newdc->saveLevel = 0;
  newdc->IsIC = dc->IsIC;

#if 0
  PATH_InitGdiPath( &newdc->w.path );
#endif

  /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */

  newdc->w.hGCClipRgn = newdc->w.hVisRgn = 0;
  if (dc->w.hClipRgn)
  {
    newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
    NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
  }
  DC_UnlockDc( newdc );
  DC_UnlockDc( dc );
  return  hnewdc;
}


VOID
STDCALL
IntGdiSetDCState ( HDC hDC, HDC hDCSave )
{
  PDC  dc, dcs;

  dc = DC_LockDc ( hDC );
  if ( dc )
  {
    dcs = DC_LockDc ( hDCSave );
    if ( dcs )
    {
      if ( dcs->w.flags & DC_SAVED )
      {
        dc->w.flags            = dcs->w.flags & ~DC_SAVED;

        dc->w.hFirstBitmap     = dcs->w.hFirstBitmap;

#if 0
        dc->w.hDevice          = dcs->w.hDevice;
#endif

        dc->w.totalExtent      = dcs->w.totalExtent;
        dc->Dc_Attr.jROP2          = dcs->Dc_Attr.jROP2;
        dc->Dc_Attr.jFillMode     = dcs->Dc_Attr.jFillMode;
        dc->Dc_Attr.jStretchBltMode   = dcs->Dc_Attr.jStretchBltMode;
        dc->Dc_Attr.lRelAbs       = dcs->Dc_Attr.lRelAbs;
        dc->Dc_Attr.jBkMode   = dcs->Dc_Attr.jBkMode;
        dc->Dc_Attr.crBackgroundClr  = dcs->Dc_Attr.crBackgroundClr;
        dc->Dc_Attr.crForegroundClr        = dcs->Dc_Attr.crForegroundClr;
        dc->Dc_Attr.ptlBrushOrigin.x        = dcs->Dc_Attr.ptlBrushOrigin.x;
        dc->Dc_Attr.ptlBrushOrigin.y        = dcs->Dc_Attr.ptlBrushOrigin.y;
        dc->Dc_Attr.lTextAlign        = dcs->Dc_Attr.lTextAlign;
        dc->Dc_Attr.lTextExtra        = dcs->Dc_Attr.lTextExtra;
        dc->Dc_Attr.cBreak       = dcs->Dc_Attr.cBreak;
        dc->Dc_Attr.lBreakExtra       = dcs->Dc_Attr.lBreakExtra;
        dc->Dc_Attr.iMapMode          = dcs->Dc_Attr.iMapMode;
        dc->Dc_Attr.iGraphicsMode     = dcs->Dc_Attr.iGraphicsMode;
#if 0
        /* Apparently, the DC origin is not changed by [GS]etDCState */
        dc->w.DCOrgX           = dcs->w.DCOrgX;
        dc->w.DCOrgY           = dcs->w.DCOrgY;
#endif
        dc->Dc_Attr.ptlCurrent.x         = dcs->Dc_Attr.ptlCurrent.x;
        dc->Dc_Attr.ptlCurrent.y         = dcs->Dc_Attr.ptlCurrent.y;
        dc->w.ArcDirection     = dcs->w.ArcDirection;

        dc->w.xformWorld2Wnd   = dcs->w.xformWorld2Wnd;
        dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
        dc->w.xformVport2World = dcs->w.xformVport2World;
        dc->w.vport2WorldValid = dcs->w.vport2WorldValid;

        dc->Dc_Attr.ptlWindowOrg.x            = dcs->Dc_Attr.ptlWindowOrg.x;
        dc->Dc_Attr.ptlWindowOrg.y            = dcs->Dc_Attr.ptlWindowOrg.y;
        dc->Dc_Attr.szlWindowExt.cx            = dcs->Dc_Attr.szlWindowExt.cx;
        dc->Dc_Attr.szlWindowExt.cy            = dcs->Dc_Attr.szlWindowExt.cy;
        dc->Dc_Attr.ptlViewportOrg.x          = dcs->Dc_Attr.ptlViewportOrg.x;
        dc->Dc_Attr.ptlViewportOrg.y          = dcs->Dc_Attr.ptlViewportOrg.y;
        dc->Dc_Attr.szlViewportExt.cx          = dcs->Dc_Attr.szlViewportExt.cx;
        dc->Dc_Attr.szlViewportExt.cy          = dcs->Dc_Attr.szlViewportExt.cy;
        dc->PalIndexed         = dcs->PalIndexed;

        if (!(dc->w.flags & DC_MEMORY))
        {
          dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
        }

#if 0
        if (dcs->w.hClipRgn)
        {
          if (!dc->w.hClipRgn)
          {
            dc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
          }
          NtGdiCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
        }
        else
        {
          if (dc->w.hClipRgn)
          {
            NtGdiDeleteObject( dc->w.hClipRgn );
          }

          dc->w.hClipRgn = 0;
        }
        {
          int res;
          res = CLIPPING_UpdateGCRegion( dc );
          ASSERT ( res != ERROR );
        }
        DC_UnlockDc ( dc );
#else
        IntGdiExtSelectClipRgn(dc, dcs->w.hClipRgn, RGN_COPY);
        DC_UnlockDc ( dc );
#endif

        NtGdiSelectObject( hDC, dcs->w.hBitmap );
        NtGdiSelectObject( hDC, dcs->Dc_Attr.hbrush );
        NtGdiSelectObject( hDC, dcs->Dc_Attr.hlfntNew );
        NtGdiSelectObject( hDC, dcs->Dc_Attr.hpen );
        NtGdiSetBkColor( hDC, dcs->Dc_Attr.crBackgroundClr);
        NtGdiSetTextColor( hDC, dcs->Dc_Attr.crForegroundClr);

        NtUserSelectPalette( hDC, dcs->w.hPalette, FALSE );

#if 0
        GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
#endif
      } else {
        DC_UnlockDc(dc);
      }
      DC_UnlockDc ( dcs );
    } else {
      DC_UnlockDc ( dc );
      SetLastWin32Error(ERROR_INVALID_HANDLE);
    }
  }
  else
    SetLastWin32Error(ERROR_INVALID_HANDLE);
}

INT FASTCALL
IntGdiGetDeviceCaps(PDC dc, INT Index)
{
  INT ret = 0;
  POINT  pt;

  /* Retrieve capability */
  switch (Index)
  {
    case DRIVERVERSION: