dc.c

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

  if(InitData)
  {
    _SEH_TRY
    {
      ProbeForRead(InitData,
                   sizeof(DEVMODEW),
                   1);
      RtlCopyMemory(&SafeInitData,
                    InitData,
                    sizeof(DEVMODEW));
    }
    _SEH_HANDLE
    {
      Status = _SEH_GetExceptionCode();
    }
    _SEH_END;
    if(!NT_SUCCESS(Status))
    {
      SetLastNtError(Status);
      return NULL;
    }
    /* FIXME - InitData can have some more bytes! */
  }

  if(Driver)
  {
    Status = IntSafeCopyUnicodeString(&SafeDriver, Driver);
    if(!NT_SUCCESS(Status))
    {
      SetLastNtError(Status);
      return NULL;
    }
  }

  if(Device)
  {
    Status = IntSafeCopyUnicodeString(&SafeDevice, Device);
    if(!NT_SUCCESS(Status))
    {
      RtlFreeUnicodeString(&SafeDriver);
      SetLastNtError(Status);
      return NULL;
    }
  }

  Ret = IntGdiCreateDC(NULL == Driver ? NULL : &SafeDriver,
                       NULL == Device ? NULL : &SafeDevice, NULL,
                       NULL == InitData ? NULL : &SafeInitData, TRUE);

  return Ret;
}

HDC STDCALL
NtGdiOpenDCW( PUNICODE_STRING pustrDevice,
              DEVMODEW *pdm,
              PUNICODE_STRING pustrLogAddr,
              ULONG iType,
              HANDLE hspool,
              VOID *pDriverInfo2,
              VOID *pUMdhpdev )
{
  UNIMPLEMENTED;
  return 0;
}

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, w.backgroundColor )
DC_GET_VAL( INT, NtGdiGetBkMode, w.backgroundMode )
DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT, x, y )
DC_GET_VAL( HRGN, NtGdiGetClipRgn, w.hClipRgn )

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:
      SelObject = dc->w.hPen;
      break;
    case OBJ_BRUSH:
      SelObject = dc->w.hBrush;
      break;
    case OBJ_PAL:
      DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_PAL not supported yet!\n");
      SelObject = NULL;
      break;
    case OBJ_FONT:
      SelObject = dc->w.hFont;
      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, w.CursPosX, w.CursPosY, POINT, x, y )

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

  return  TRUE;
}

BOOL STDCALL
NtGdiGetDCOrgEx(HDC  hDC, LPPOINT  Point)
{
  BOOL Ret;
  DC *dc;
  POINT SafePoint;
  NTSTATUS Status = STATUS_SUCCESS;

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

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

  Ret = IntGdiGetDCOrgEx(dc, &SafePoint);

  _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->w.backgroundColor;
  dc->w.backgroundColor = color;
  hBrush = dc->w.hBrush;
  DC_UnlockDc(dc);
  NtGdiSelectObject(hDC, hBrush);
  return oldColor;
}

HDC STDCALL
NtGdiGetDCState(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->w.hPen             = dc->w.hPen;
  newdc->w.hBrush           = dc->w.hBrush;
  newdc->w.hFont            = dc->w.hFont;
  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->w.ROPmode          = dc->w.ROPmode;
  newdc->w.polyFillMode     = dc->w.polyFillMode;
  newdc->w.stretchBltMode   = dc->w.stretchBltMode;
  newdc->w.relAbsMode       = dc->w.relAbsMode;
  newdc->w.backgroundMode   = dc->w.backgroundMode;
  newdc->w.backgroundColor  = dc->w.backgroundColor;
  newdc->w.textColor        = dc->w.textColor;
  newdc->w.brushOrgX        = dc->w.brushOrgX;
  newdc->w.brushOrgY        = dc->w.brushOrgY;
  newdc->w.textAlign        = dc->w.textAlign;
  newdc->w.charExtra        = dc->w.charExtra;
  newdc->w.breakTotalExtra  = dc->w.breakTotalExtra;
  newdc->w.breakCount       = dc->w.breakCount;
  newdc->w.breakExtra       = dc->w.breakExtra;
  newdc->w.breakRem         = dc->w.breakRem;
  newdc->w.MapMode          = dc->w.MapMode;
  newdc->w.GraphicsMode     = dc->w.GraphicsMode;
#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->w.CursPosX         = dc->w.CursPosX;
  newdc->w.CursPosY         = dc->w.CursPosY;
  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->wndOrgX            = dc->wndOrgX;
  newdc->wndOrgY            = dc->wndOrgY;
  newdc->wndExtX            = dc->wndExtX;
  newdc->wndExtY            = dc->wndExtY;
  newdc->vportOrgX          = dc->vportOrgX;
  newdc->vportOrgY          = dc->vportOrgY;
  newdc->vportExtX          = dc->vportExtX;
  newdc->vportExtY          = dc->vportExtY;

  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
NtGdiSetDCState ( 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->w.ROPmode          = dcs->w.ROPmode;
        dc->w.polyFillMode     = dcs->w.polyFillMode;
        dc->w.stretchBltMode   = dcs->w.stretchBltMode;
        dc->w.relAbsMode       = dcs->w.relAbsMode;
        dc->w.backgroundMode   = dcs->w.backgroundMode;
        dc->w.backgroundColor  = dcs->w.backgroundColor;
        dc->w.textColor        = dcs->w.textColor;
        dc->w.brushOrgX        = dcs->w.brushOrgX;
        dc->w.brushOrgY        = dcs->w.brushOrgY;
        dc->w.textAlign        = dcs->w.textAlign;
        dc->w.charExtra        = dcs->w.charExtra;
        dc->w.breakTotalExtra  = dcs->w.breakTotalExtra;
        dc->w.breakCount       = dcs->w.breakCount;
        dc->w.breakExtra       = dcs->w.breakExtra;
        dc->w.breakRem         = dcs->w.breakRem;
        dc->w.MapMode          = dcs->w.MapMode;
        dc->w.GraphicsMode     = dcs->w.GraphicsMode;
#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->w.CursPosX         = dcs->w.CursPosX;
        dc->w.CursPosY         = dcs->w.CursPosY;
        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->wndOrgX            = dcs->wndOrgX;
        dc->wndOrgY            = dcs->wndOrgY;
        dc->wndExtX            = dcs->wndExtX;
        dc->wndExtY            = dcs->wndExtY;
        dc->vportOrgX          = dcs->vportOrgX;
        dc->vportOrgY          = dcs->vportOrgY;
        dc->vportExtX          = dcs->vportExtX;
        dc->vportExtY          = dcs->vportExtY;
        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
        DC_UnlockDc ( dc );
        NtGdiSelectClipRgn(hDC, dcs->w.hClipRgn);
#endif

        NtGdiSelectObject( hDC, dcs->w.hBitmap );
        NtGdiSelectObject( hDC, dcs->w.hBrush );
        NtGdiSelectObject( hDC, dcs->w.hFont );
        NtGdiSelectObject( hDC, dcs->w.hPen );
        NtGdiSetBkColor( hDC, dcs->w.backgroundColor);
        NtGdiSetTextColor( hDC, dcs->w.textColor);

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