dc.c

一个类似windows

#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 );

#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:
      ret = dc->GDIInfo->ulVersion;
      break;

    case TECHNOLOGY:
      ret = dc->GDIInfo->ulTechnology;
      break;

    case HORZSIZE:
      ret = dc->GDIInfo->ulHorzSize;
      break;

    case VERTSIZE:
      ret = dc->GDIInfo->ulVertSize;
      break;

    case HORZRES:
      ret = dc->GDIInfo->ulHorzRes;
      break;

    case VERTRES:
      ret = dc->GDIInfo->ulVertRes;
      break;

    case LOGPIXELSX:
      ret = dc->GDIInfo->ulLogPixelsX;
      break;

    case LOGPIXELSY:
      ret = dc->GDIInfo->ulLogPixelsY;
      break;

    case BITSPIXEL:
      ret = dc->GDIInfo->cBitsPixel;
      break;

    case PLANES:
      ret = dc->GDIInfo->cPlanes;
      break;

    case NUMBRUSHES:
      UNIMPLEMENTED; /* FIXME */
      break;

    case NUMPENS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case NUMFONTS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case NUMCOLORS:
      ret = dc->GDIInfo->ulNumColors;
      break;

    case ASPECTX:
      ret = dc->GDIInfo->ulAspectX;
      break;

    case ASPECTY:
      ret = dc->GDIInfo->ulAspectY;
      break;

    case ASPECTXY:
      ret = dc->GDIInfo->ulAspectXY;
      break;

    case PDEVICESIZE:
      UNIMPLEMENTED; /* FIXME */
      break;

    case CLIPCAPS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case SIZEPALETTE:
      ret = dc->GDIInfo->ulNumPalReg; /* FIXME not sure */
      break;

    case NUMRESERVED:
      ret = 0;
      break;

    case COLORRES:
      UNIMPLEMENTED; /* FIXME */
      break;

    case PHYSICALWIDTH:
      if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.x;
      }
      else
      {
	ret = 0;
      }
      break;

    case PHYSICALHEIGHT:
      if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.y;
      }
      else
      {
	ret = 0;
      }
      break;

    case PHYSICALOFFSETX:
      if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.x;
      }
      else
      {
	ret = 0;
      }
      break;

    case PHYSICALOFFSETY:
      if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.y;
      }
      else
      {
	ret = 0;
      }
      break;

    case VREFRESH:
      UNIMPLEMENTED; /* FIXME */
      break;

    case SCALINGFACTORX:
      if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.x;
      }
      else
      {
	ret = 0;
      }
      break;

    case SCALINGFACTORY:
      if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
      {
        ret = pt.y;
      }
      else
      {
	ret = 0;
      }
      break;

    case RASTERCAPS:
      ret = dc->GDIInfo->flRaster;
      break;

    case CURVECAPS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case LINECAPS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case POLYGONALCAPS:
      UNIMPLEMENTED; /* FIXME */
      break;

    case TEXTCAPS:
      ret = dc->GDIInfo->flTextCaps;
      break;

    default:
      ret = 0;
      break;
  }

  return ret;
}

INT STDCALL
NtGdiGetDeviceCaps(HDC  hDC,
                  INT  Index)
{
  PDC  dc;
  INT  ret;

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

  ret = IntGdiGetDeviceCaps(dc, Index);

  DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);

  DC_UnlockDc( dc );
  return ret;
}

DC_GET_VAL( INT, NtGdiGetMapMode, w.MapMode )
DC_GET_VAL( INT, NtGdiGetPolyFillMode, w.polyFillMode )

INT FASTCALL
IntGdiGetObject(HANDLE Handle, INT Count, LPVOID Buffer)
{
  PVOID GdiObject;
  INT Result = 0;
  DWORD ObjectType;

  GdiObject = GDIOBJ_LockObj(GdiHandleTable, Handle, GDI_OBJECT_TYPE_DONTCARE);
  if (NULL == GdiObject)
    {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return 0;
    }

  ObjectType = GDIOBJ_GetObjectType(Handle);
  switch (ObjectType)
    {
#if 0
      case GDI_OBJECT_TYPE_PEN:
        Result = PEN_GetObject((PENOBJ *) GdiObject, Count, Buffer);
        break;
      case GDI_OBJECT_TYPE_BRUSH:
        Result = BRUSH_GetObject((BRUSHOBJ *) GdiObject, Count, Buffer);
        break;
#endif
      case GDI_OBJECT_TYPE_BITMAP:
        Result = BITMAP_GetObject((BITMAPOBJ *) GdiObject, Count, Buffer);
        break;
      case GDI_OBJECT_TYPE_FONT:
        Result = FontGetObject((PTEXTOBJ) GdiObject, Count, Buffer);
#if 0
        // Fix the LOGFONT structure for the stock fonts
        if (FIRST_STOCK_HANDLE <= Handle && Handle <= LAST_STOCK_HANDLE)
          {
            FixStockFontSizeW(Handle, Count, Buffer);
          }
#endif
        break;
#if 0
      case GDI_OBJECT_TYPE_PALETTE:
        Result = PALETTE_GetObject((PALETTEOBJ *) GdiObject, Count, Buffer);
        break;
#endif
      default:
        DPRINT1("GDI object type 0x%08x not implemented\n", ObjectType);
        break;
    }

  GDIOBJ_UnlockObjByPtr(GdiHandleTable, GdiObject);

  return Result;
}

INT STDCALL
NtGdiGetObject(HANDLE handle, INT count, LPVOID buffer)
{
  INT Ret;
  LPVOID SafeBuf;
  NTSTATUS Status = STATUS_SUCCESS;

  /* From Wine: GetObject does not SetLastError() on a null object */
  if (!handle) return 0;
  
  if (count <= 0)
  {
    return 0;
  }
  
  _SEH_TRY
  {
    ProbeForWrite(buffer,
                  count,
                  1);
  }
  _SEH_HANDLE
  {
    Status = _SEH_GetExceptionCode();
  }
  _SEH_END;
  
  if(!NT_SUCCESS(Status))
  {
    SetLastNtError(Status);
    return 0;
  }

  SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
  if(!SafeBuf)
  {
    SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
    return 0;
  }

  Ret = IntGdiGetObject(handle, count, SafeBuf);

  _SEH_TRY
  {
    /* pointer already probed! */
    RtlCopyMemory(buffer,
                  SafeBuf,
                  count);
  }
  _SEH_HANDLE
  {
    Status = _SEH_GetExceptionCode();
  }
  _SEH_END;

  ExFreePool(SafeBuf);
  if(!NT_SUCCESS(Status))
  {
    SetLastNtError(Status);
    return 0;
  }

  return Ret;
}

DWORD STDCALL
NtGdiGetObjectType(HANDLE handle)
{
  GDIOBJHDR * ptr;
  INT result;
  DWORD objectType;

  ptr = GDIOBJ_LockObj(GdiHandleTable, handle, GDI_OBJECT_TYPE_DONTCARE);
  if (ptr == 0)
  {
    SetLastWin32Error(ERROR_INVALID_HANDLE);
    return 0;
  }

  objectType = GDIOBJ_GetObjectType(handle);
  switch(objectType)
  {
    case GDI_OBJECT_TYPE_PEN:
      result = OBJ_PEN;
      break;
    case GDI_OBJECT_TYPE_BRUSH:
      result = OBJ_BRUSH;
      break;
    case GDI_OBJECT_TYPE_BITMAP:
      result = OBJ_BITMAP;
      break;
    case GDI_OBJECT_TYPE_FONT:
      result = OBJ_FONT;
      break;
    case GDI_OBJECT_TYPE_PALETTE:
      result = OBJ_PAL;
      break;
    case GDI_OBJECT_TYPE_REGION:
      result = OBJ_REGION;
      break;
    case GDI_OBJECT_TYPE_DC:
      result = OBJ_DC;
      break;
    case GDI_OBJECT_TYPE_METADC:
      result = OBJ_METADC;
      break;
    case GDI_OBJECT_TYPE_METAFILE:
      result = OBJ_METAFILE;
      break;
    case GDI_OBJECT_TYPE_ENHMETAFILE:
      result = OBJ_ENHMETAFILE;
      break;
    case GDI_OBJECT_TYPE_ENHMETADC:
      result = OBJ_ENHMETADC;
      break;
    case GDI_OBJECT_TYPE_EXTPEN:
      result = OBJ_EXTPEN;
      break;
    case GDI_OBJECT_TYPE_MEMDC:
      result = OBJ_MEMDC;
      break;

    default:
      DPRINT1("Magic 0x%08x not implemented\n", objectType);
      result = 0;
      break;
  }
  GDIOBJ_UnlockObjByPtr(GdiHandleTable, ptr);
  return result;
}

DC_GET_VAL( INT, NtGdiGetRelAbs, w.relAbsMode )
DC_GET_VAL( INT, NtGdiGetROP2, w.ROPmode )
DC_GET_VAL( INT, NtGdiGetStretchBltMode, w.stretchBltMode )
DC_GET_VAL( UINT, NtGdiGetTextAlign, w.textAlign )
DC_GET_VAL( COLORREF, NtGdiGetTextColor, w.textColor )
DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY, SIZE, cx, cy )
DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT, x, y )
DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE, cx, cy )
DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT, x, y )

BOOL
APIENTRY
NtGdiResetDC(
    IN HDC hdc,
    IN LPDEVMODEW pdm,
    OUT PBOOL pbBanding,
    IN OPTIONAL VOID *pDriverInfo2,
    OUT VOID *ppUMdhpdev)
{
  UNIMPLEMENTED;
  return 0;
}

BOOL STDCALL
NtGdiRestoreDC(HDC  hDC, INT  SaveLevel)
{
  PDC dc, dcs;
  BOOL success;

  DPRINT("NtGdiRestoreDC(%lx, %d)\n", hDC, SaveLevel);

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

  if (SaveLevel == -1)
    SaveLevel = dc->saveLevel;

  if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
  {
    DC_UnlockDc(dc);
    return FALSE;
  }

  success = TRUE;
  while (dc->saveLevel >= SaveLevel)
  {
    HDC hdcs = DC_GetNextDC (dc);

    dcs = DC_LockDc (hdcs);
    if (dcs == NULL)
    {
      DC_UnlockDc(dc);
      return FALSE;
    }
    DC_SetNextDC (dcs, DC_GetNextDC (dcs));
    if (--dc->saveLevel < SaveLevel)
      {
	DC_UnlockDc( dc );
        DC_UnlockDc( dcs );
        NtGdiSetDCState(hDC, hdcs);
#if 0
        if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
        {
          /* FIXME: This might not be quite right, since we're
           * returning FALSE but still destroying the saved DC state */