brush.c

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

   BrushObject = BRUSHOBJ_LockBrush(hBrush);
   ASSERT(BrushObject != NULL);

   BrushObject->flAttrs |= GDIBRUSH_IS_BITMAP;
   BrushObject->hbmPattern = hPattern;
   /* FIXME: Fill in the rest of fields!!! */

   GDIOBJ_SetOwnership(GdiHandleTable, hPattern, NULL);

   BRUSHOBJ_UnlockBrush(BrushObject);

   return hBrush;
}

HBRUSH STDCALL
IntGdiCreateSolidBrush(
   COLORREF Color)
{
   HBRUSH hBrush;
   PGDIBRUSHOBJ BrushObject;

   hBrush = BRUSHOBJ_AllocBrush();
   if (hBrush == NULL)
   {
      SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
      return NULL;
   }

   BrushObject = BRUSHOBJ_LockBrush(hBrush);
   ASSERT(BrushObject != NULL);

   BrushObject->flAttrs |= GDIBRUSH_IS_SOLID;

   BrushObject->BrushAttr.lbColor = Color;
   /* FIXME: Fill in the rest of fields!!! */

   BRUSHOBJ_UnlockBrush(BrushObject);

   return hBrush;
}

HBRUSH STDCALL
IntGdiCreateNullBrush(VOID)
{
   HBRUSH hBrush;
   PGDIBRUSHOBJ BrushObject;

   hBrush = BRUSHOBJ_AllocBrush();
   if (hBrush == NULL)
   {
      SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
      return NULL;
   }

   BrushObject = BRUSHOBJ_LockBrush(hBrush);
   ASSERT(BrushObject != NULL);
   BrushObject->flAttrs |= GDIBRUSH_IS_NULL;
   BRUSHOBJ_UnlockBrush(BrushObject);

   return hBrush;
}

BOOL FASTCALL
IntPatBlt(
   PDC dc,
   INT XLeft,
   INT YLeft,
   INT Width,
   INT Height,
   DWORD ROP,
   PGDIBRUSHOBJ BrushObj)
{
   RECTL DestRect;
   BITMAPOBJ *BitmapObj;
   GDIBRUSHINST BrushInst;
   POINTL BrushOrigin;
   BOOL ret = TRUE;

   ASSERT(BrushObj);

   BitmapObj = BITMAPOBJ_LockBitmap(dc->w.hBitmap);
   if (BitmapObj == NULL)
   {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
   }

   if (!(BrushObj->flAttrs & GDIBRUSH_IS_NULL))
   {
      if (Width > 0)
      {
         DestRect.left = XLeft + dc->w.DCOrgX;
         DestRect.right = XLeft + Width + dc->w.DCOrgX;
      }
      else
      {
         DestRect.left = XLeft + Width + 1 + dc->w.DCOrgX;
         DestRect.right = XLeft + dc->w.DCOrgX + 1;
      }

      if (Height > 0)
      {
         DestRect.top = YLeft + dc->w.DCOrgY;
         DestRect.bottom = YLeft + Height + dc->w.DCOrgY;
      }
      else
      {
         DestRect.top = YLeft + Height + dc->w.DCOrgY + 1;
         DestRect.bottom = YLeft + dc->w.DCOrgY + 1;
      }

      IntLPtoDP(dc, (LPPOINT)&DestRect, 2);

      BrushOrigin.x = BrushObj->ptOrigin.x + dc->w.DCOrgX;
      BrushOrigin.y = BrushObj->ptOrigin.y + dc->w.DCOrgY;

      IntGdiInitBrushInstance(&BrushInst, BrushObj, dc->XlateBrush);

      ret = IntEngBitBlt(
         &BitmapObj->SurfObj,
         NULL,
         NULL,
         dc->CombinedClip,
         NULL,
         &DestRect,
         NULL,
         NULL,
         &BrushInst.BrushObject,
         &BrushOrigin,
         ROP3_TO_ROP4(ROP));
   }

   BITMAPOBJ_UnlockBitmap(BitmapObj);

   return ret;
}

BOOL FASTCALL
IntGdiPolyPatBlt(
   HDC hDC,
   DWORD dwRop,
   PPATRECT pRects,
   int cRects,
   ULONG Reserved)
{
   int i;
   PPATRECT r;
   PGDIBRUSHOBJ BrushObj;
   DC *dc;

   dc = DC_LockDc(hDC);
   if (dc == NULL)
   {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
   }
   if (dc->IsIC)
   {
      DC_UnlockDc(dc);
      /* Yes, Windows really returns TRUE in this case */
      return TRUE;
   }

   for (r = pRects, i = 0; i < cRects; i++)
   {
      BrushObj = BRUSHOBJ_LockBrush(r->hBrush);
      if(BrushObj != NULL)
      {
        IntPatBlt(
           dc,
           r->r.left,
           r->r.top,
           r->r.right,
           r->r.bottom,
           dwRop,
           BrushObj);
        BRUSHOBJ_UnlockBrush(BrushObj);
      }
      r++;
   }

   DC_UnlockDc(dc);

   return TRUE;
}

/* PUBLIC FUNCTIONS ***********************************************************/

HBRUSH STDCALL
NtGdiCreateDIBBrush(
   IN PVOID BitmapInfoAndData,
   IN FLONG ColorSpec,
   IN UINT BitmapInfoSize,
   IN BOOL  b8X8,
   IN BOOL bPen,
   IN PVOID PackedDIB)
{
   BITMAPINFO *SafeBitmapInfoAndData;
   NTSTATUS Status = STATUS_SUCCESS;
   HBRUSH hBrush;

   SafeBitmapInfoAndData = EngAllocMem(0, BitmapInfoSize, 0);
   if (SafeBitmapInfoAndData == NULL)
   {
      SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
      return NULL;
   }

   _SEH_TRY
   {
      ProbeForRead(BitmapInfoAndData,
                   BitmapInfoSize,
                   1);
      RtlCopyMemory(SafeBitmapInfoAndData,
                    BitmapInfoAndData,
                    BitmapInfoSize);
   }
   _SEH_HANDLE
   {
      Status = _SEH_GetExceptionCode();
   }
   _SEH_END;
   
   if (!NT_SUCCESS(Status))
   {
      EngFreeMem(SafeBitmapInfoAndData);
      SetLastNtError(Status);
      return 0;
   }

   hBrush = IntGdiCreateDIBBrush(SafeBitmapInfoAndData, ColorSpec,
                                 BitmapInfoSize, PackedDIB);

   EngFreeMem(SafeBitmapInfoAndData);

   return hBrush;
}

HBRUSH STDCALL
NtGdiCreateHatchBrushInternal(
   ULONG Style,
   COLORREF Color,
   BOOL bPen)
{
   return IntGdiCreateHatchBrush(Style, Color);
}

HBRUSH STDCALL
NtGdiCreatePatternBrushInternal(
   HBITMAP hBitmap,
   BOOL bPen,
   BOOL b8x8)
{
   return IntGdiCreatePatternBrush(hBitmap);
}

HBRUSH STDCALL
NtGdiCreateSolidBrush(COLORREF Color,
                      IN OPTIONAL HBRUSH hbr)
{
   return IntGdiCreateSolidBrush(Color);
}

/*
 * NtGdiSetBrushOrg
 *
 * The NtGdiSetBrushOrg function sets the brush origin that GDI assigns to
 * the next brush an application selects into the specified device context.
 *
 * Status
 *    @implemented
 */

BOOL STDCALL
NtGdiSetBrushOrg(HDC hDC, INT XOrg, INT YOrg, LPPOINT Point)
{
   PDC dc = DC_LockDc(hDC);
   if (dc == NULL)
   {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
   }

   if (Point != NULL)
   {
      NTSTATUS Status = STATUS_SUCCESS;
      POINT SafePoint;
      SafePoint.x = dc->Dc_Attr.ptlBrushOrigin.x;
      SafePoint.y = dc->Dc_Attr.ptlBrushOrigin.y;
      _SEH_TRY
      {
         ProbeForWrite(Point,
                       sizeof(POINT),
                       1);
         *Point = SafePoint;
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

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

   dc->Dc_Attr.ptlBrushOrigin.x = XOrg;
   dc->Dc_Attr.ptlBrushOrigin.y = YOrg;
   DC_UnlockDc(dc);

   return TRUE;
}

BOOL STDCALL
NtGdiPolyPatBlt(
   HDC hDC,
   DWORD dwRop,
   IN PPOLYPATBLT pRects,
   IN DWORD cRects,
   IN DWORD Mode)
{
   PPATRECT rb = NULL;
   NTSTATUS Status = STATUS_SUCCESS;
   BOOL Ret;

   if (cRects > 0)
   {
      rb = ExAllocatePoolWithTag(PagedPool, sizeof(PATRECT) * cRects, TAG_PATBLT);
      if (!rb)
      {
         SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
         return FALSE;
      }
      _SEH_TRY
      {
         ProbeForRead(pRects,
                      cRects * sizeof(PATRECT),
                      1);
         RtlCopyMemory(rb,
                       pRects,
                       cRects * sizeof(PATRECT));
      }
      _SEH_HANDLE
      {
         Status = _SEH_GetExceptionCode();
      }
      _SEH_END;

      if (!NT_SUCCESS(Status))
      {
         ExFreePool(rb);
         SetLastNtError(Status);
         return FALSE;
      }
   }

   Ret = IntGdiPolyPatBlt(hDC, dwRop, (PPATRECT)pRects, cRects, Mode);

   if (cRects > 0)
      ExFreePool(rb);

   return Ret;
}

BOOL STDCALL
NtGdiPatBlt(
   HDC hDC,
   INT XLeft,
   INT YLeft,
   INT Width,
   INT Height,
   DWORD ROP)
{
   PGDIBRUSHOBJ BrushObj;
   DC *dc = DC_LockDc(hDC);
   BOOL ret;

   if (dc == NULL)
   {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      return FALSE;
   }
   if (dc->IsIC)
   {
      DC_UnlockDc(dc);
      /* Yes, Windows really returns TRUE in this case */
      return TRUE;
   }

   BrushObj = BRUSHOBJ_LockBrush(dc->Dc_Attr.hbrush);
   if (BrushObj == NULL)
   {
      SetLastWin32Error(ERROR_INVALID_HANDLE);
      DC_UnlockDc(dc);
      return FALSE;
   }

   ret = IntPatBlt(
      dc,
      XLeft,
      YLeft,
      Width,
      Height,
      ROP,
      BrushObj);

   BRUSHOBJ_UnlockBrush(BrushObj);
   DC_UnlockDc(dc);

   return ret;
}

VOID FASTCALL
IntGdiSetSolidBrushColor(HBRUSH hBrush, COLORREF Color)
{
  PGDIBRUSHOBJ BrushObject;

  BrushObject = BRUSHOBJ_LockBrush(hBrush);
  if (BrushObject->flAttrs & GDIBRUSH_IS_SOLID)
  {
      BrushObject->BrushAttr.lbColor = Color & 0xFFFFFF;
  }
  BRUSHOBJ_UnlockBrush(BrushObject);
}

/* EOF */