dc.c

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

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

      case GDI_OBJECT_TYPE_PEN:
        Result = PEN_GetObject((PGDIBRUSHOBJ) GdiObject, Count, (PLOGPEN) Buffer); // IntGdiCreatePenIndirect
        break;

      case GDI_OBJECT_TYPE_BRUSH:
        Result = BRUSH_GetObject((PGDIBRUSHOBJ ) GdiObject, Count, (LPLOGBRUSH)Buffer);
        break;

      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 = 0;
  LPVOID SafeBuf;
  NTSTATUS Status = STATUS_SUCCESS;
  INT RetCount = 0;

  /* From Wine: GetObject does not SetLastError() on a null object */
  if (!handle) return Ret;

  RetCount = IntGdiGetObject(handle, 0, NULL);
  if ((count <= 0) || (!buffer))
  {
    return RetCount;
  }

  _SEH_TRY
  {
    ProbeForWrite(buffer, count, 1);
  }
  _SEH_HANDLE
  {
    Status = _SEH_GetExceptionCode();
  }
  _SEH_END;

  if(!NT_SUCCESS(Status))
  {
    SetLastNtError(Status);
    return Ret;
  }

  if (RetCount >= count)
  {
    SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
    if(!SafeBuf)
    {
        SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
        return Ret;
    }
    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(abs(SaveLevel) > dc->saveLevel || SaveLevel == 0)
  {
    DC_UnlockDc(dc);
    return FALSE;
  }

  /* FIXME this calc are not 100% correct I think ??*/
  if (SaveLevel < 0) SaveLevel = dc->saveLevel + SaveLevel + 1;
  
  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 (dc, DC_GetNextDC (dcs));
	 dcs->hNext = 0;
		 
	 if (--dc->saveLevel < SaveLevel)
	 {
		 DC_UnlockDc( dc );
         DC_UnlockDc( dcs );

	     NtGdiSetDCState(hDC, hdcs);
         //if (!PATH_AssignGdiPath( &dc->path, &dcs->path ))
		 /* FIXME: This might not be quite right, since we're 
		  * returning FALSE but still destroying the saved DC state 
		  */
	     success=FALSE;
	     dc = DC_LockDc(hDC);
         if(!dc)
         {
            return FALSE;
         }
       }
       else
       {
         DC_UnlockDc( dcs );