[ros-diffs] [tkreuzer] 56555: [WIN32K] - Start of the rewrite for DIB bitmaps and sections - Rewrite of brush code

tkreuzer at svn.reactos.org tkreuzer at svn.reactos.org
Wed May 9 20:36:16 UTC 2012


Author: tkreuzer
Date: Wed May  9 20:36:16 2012
New Revision: 56555

URL: http://svn.reactos.org/svn/reactos?rev=56555&view=rev
Log:
[WIN32K]
- Start of the rewrite for DIB bitmaps and sections
- Rewrite of brush code

Added:
    branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c   (with props)
    branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h   (with props)
Modified:
    branches/dib_rewrite/win32ss/CMakeLists.txt
    branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.c
    branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.h
    branches/dib_rewrite/win32ss/gdi/ntgdi/brush.c
    branches/dib_rewrite/win32ss/gdi/ntgdi/brush.h
    branches/dib_rewrite/win32ss/user/ntuser/clipboard.c
    branches/dib_rewrite/win32ss/user/ntuser/misc/file.c
    branches/dib_rewrite/win32ss/win32kp.h

Modified: branches/dib_rewrite/win32ss/CMakeLists.txt
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/CMakeLists.txt?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/CMakeLists.txt [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/CMakeLists.txt [iso-8859-1] Wed May  9 20:36:16 2012
@@ -147,7 +147,7 @@
     gdi/ntgdi/dcstate.c
     gdi/ntgdi/dcutil.c
     gdi/ntgdi/device.c
-    gdi/ntgdi/dibobj.c
+    gdi/ntgdi/dibitmap.c
     gdi/ntgdi/drawing.c
     gdi/ntgdi/fillshap.c
     gdi/ntgdi/font.c

Modified: branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.c
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.c?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.c [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.c [iso-8859-1] Wed May  9 20:36:16 2012
@@ -323,6 +323,8 @@
                 }
             }
 
+            __debugbreak();
+#if 0
             Bmp = DIB_CreateDIBSection(Dc,
                                        bi,
                                        DIB_RGB_COLORS,
@@ -330,6 +332,7 @@
                                        NULL,
                                        0,
                                        0);
+#endif
             return Bmp;
         }
     }

Modified: branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.h
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.h?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.h [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/bitmaps.h [iso-8859-1] Wed May  9 20:36:16 2012
@@ -24,16 +24,3 @@
     _In_opt_ PVOID pvBits,
     _In_ FLONG flags);
 
-HBITMAP
-NTAPI
-GreCreateDIBitmapInternal(
-    IN HDC hDc,
-    IN INT cx,
-    IN INT cy,
-    IN DWORD fInit,
-    IN OPTIONAL LPBYTE pjInit,
-    IN OPTIONAL PBITMAPINFO pbmi,
-    IN DWORD iUsage,
-    IN FLONG fl,
-    IN UINT cjMaxBits,
-    IN HANDLE hcmXform);

Modified: branches/dib_rewrite/win32ss/gdi/ntgdi/brush.c
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/brush.c?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/brush.c [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/brush.c [iso-8859-1] Wed May  9 20:36:16 2012
@@ -3,7 +3,7 @@
  * PROJECT:           ReactOS win32 subsystem
  * PURPOSE:           Functions for brushes
  * FILE:              subsystem/win32/win32k/objects/brush.c
- * PROGRAMER:
+ * PROGRAMER:         Timo Kreuzer (timo.kreuzer at reactos.org)
  */
 
 #include <win32k.h>
@@ -11,58 +11,7 @@
 #define NDEBUG
 #include <debug.h>
 
-#define GDIOBJATTRFREE 170
-
-typedef struct _GDI_OBJ_ATTR_FREELIST
-{
-  LIST_ENTRY Entry;
-  DWORD nEntries;
-  PVOID AttrList[GDIOBJATTRFREE];
-} GDI_OBJ_ATTR_FREELIST, *PGDI_OBJ_ATTR_FREELIST;
-
-typedef struct _GDI_OBJ_ATTR_ENTRY
-{
-  RGN_ATTR Attr[GDIOBJATTRFREE];
-} GDI_OBJ_ATTR_ENTRY, *PGDI_OBJ_ATTR_ENTRY;
-
-BOOL
-FASTCALL
-IntGdiSetBrushOwner(PBRUSH pbr, ULONG ulOwner)
-{
-    // FIXME:
-    if (pbr->flAttrs & BR_IS_GLOBAL) return TRUE;
-
-    if ((ulOwner == GDI_OBJ_HMGR_PUBLIC) || ulOwner == GDI_OBJ_HMGR_NONE)
-    {
-        // Deny user access to User Data.
-        GDIOBJ_vSetObjectAttr(&pbr->BaseObject, NULL);
-        // FIXME: deallocate brush attr
-    }
-
-    if (ulOwner == GDI_OBJ_HMGR_POWNED)
-    {
-        // Allow user access to User Data.
-        GDIOBJ_vSetObjectAttr(&pbr->BaseObject, pbr->pBrushAttr);
-        // FIXME: Allocate brush attr
-    }
-
-    GDIOBJ_vSetObjectOwner(&pbr->BaseObject, ulOwner);
-
-    return TRUE;
-}
-
-BOOL
-FASTCALL
-GreSetBrushOwner(HBRUSH hBrush, ULONG ulOwner)
-{
-    BOOL Ret;
-    PBRUSH pbrush;
-
-    pbrush = BRUSH_ShareLockBrush(hBrush);
-    Ret = IntGdiSetBrushOwner(pbrush, ulOwner);
-    BRUSH_ShareUnlockBrush(pbrush);
-    return Ret;
-}
+ULONG gulBrushUnique;
 
 BOOL
 NTAPI
@@ -71,20 +20,30 @@
     PPROCESSINFO ppi;
     BRUSH_ATTR *pBrushAttr;
 
+    // HACK: this currently does not work
+    return 1;
+
+    /* Get the PROCESSINFO pointer */
     ppi = PsGetCurrentProcessWin32Process();
     ASSERT(ppi);
 
-    pBrushAttr = GdiPoolAllocate(ppi->pPoolDcAttr);
+    /* Allocate a brush attribute from the gdi pool */
+    pBrushAttr = GdiPoolAllocate(ppi->pPoolBrushAttr);
     if (!pBrushAttr)
     {
         DPRINT1("Could not allocate brush attr\n");
         return FALSE;
     }
 
-    /* Copy the content from the kernel mode dc attr */
+    /* Set the new brush attribute and copy the kernel mode data */
     pbr->pBrushAttr = pBrushAttr;
     *pbr->pBrushAttr = pbr->BrushAttr;
 
+    /* Default hatch style is -1 */
+    pbr->ulStyle = -1;
+
+    pbr->ulBrushUnique = InterlockedIncrementUL(&gulBrushUnique);
+
     /* Set the object attribute in the handle table */
     GDIOBJ_vSetObjectAttr(&pbr->BaseObject, pBrushAttr);
 
@@ -92,35 +51,156 @@
     return TRUE;
 }
 
-
 VOID
 NTAPI
 BRUSH_vFreeBrushAttr(PBRUSH pbr)
 {
-#if 0
     PPROCESSINFO ppi;
 
-    if (pbrush->pBrushAttr == &pbrush->BrushAttr) return;
+    /* Don't do anything, when the kernel mode brush attribute is in use */
+    if (pbr->pBrushAttr == &pbr->BrushAttr) return;
+
+    if (pbr->pBrushAttr == NULL) return; // FIXME
 
     /* Reset the object attribute in the handle table */
     GDIOBJ_vSetObjectAttr(&pbr->BaseObject, NULL);
+
+    /* Copy state back from user attribute to kernel */
+    *pbr->pBrushAttr = pbr->BrushAttr;
 
     /* Free memory from the process gdi pool */
     ppi = PsGetCurrentProcessWin32Process();
     ASSERT(ppi);
+
+    /* Free the user mode attribute to the gdi pool */
     GdiPoolFree(ppi->pPoolBrushAttr, pbr->pBrushAttr);
-#endif
+
     /* Reset to kmode brush attribute */
     pbr->pBrushAttr = &pbr->BrushAttr;
 }
 
+PBRUSH
+NTAPI
+BRUSH_AllocBrushOrPen(UCHAR objt)
+{
+    PBRUSH pbrush;
+    ASSERT((objt == GDIObjType_BRUSH_TYPE) ||
+           (objt == GDIObjType_PEN_TYPE) ||
+           (objt == GDIObjType_EXTPEN_TYPE));
+
+    /* Allocate a brush object */
+    pbrush = (PBRUSH)GDIOBJ_AllocateObject(objt, sizeof(BRUSH), 0);
+    if (!pbrush)
+    {
+        return NULL;
+    }
+
+    /* Set the kernel mode brush attribute */
+    pbrush->pBrushAttr = &pbrush->BrushAttr;
+
+    // need more?
+    return pbrush;
+}
+
+PBRUSH
+NTAPI
+BRUSH_AllocBrushOrPenWithHandle(UCHAR objt, ULONG ulOwner)
+{
+    PBRUSH pbrush;
+
+    /* Allocate a brush without a handle */
+    pbrush = BRUSH_AllocBrushOrPen(objt);
+    if (!pbrush)
+    {
+        return NULL;
+    }
+
+    /* Insert the brush into the handle table */
+    if (!GDIOBJ_hInsertObject(&pbrush->BaseObject, ulOwner))
+    {
+        DPRINT1("Could not insert brush into handle table.\n");
+        GDIOBJ_vFreeObject(&pbrush->BaseObject);
+        return NULL;
+    }
+
+    /* Check if a global brush is requested */
+    if (ulOwner == GDI_OBJ_HMGR_PUBLIC)
+    {
+        pbrush->flAttrs |= BR_IS_GLOBAL;
+    }
+    else if (ulOwner == GDI_OBJ_HMGR_POWNED)
+    {
+        /* Allocate a brush attribute */
+        if (!BRUSH_bAllocBrushAttr(pbrush))
+        {
+            DPRINT1("Could not allocate brush attr.\n");
+            GDIOBJ_vDeleteObject(&pbrush->BaseObject);
+            return NULL;
+        }
+    }
+
+    return pbrush;
+}
+
 BOOL
 NTAPI
+BRUSH_bSetBrushOwner(PBRUSH pbr, ULONG ulOwner)
+{
+    // FIXME:
+    if (pbr->flAttrs & BR_IS_GLOBAL) return TRUE;
+
+    /* Set ownership of the pattern bitmap */
+    if (pbr->hbmPattern)
+        GreSetObjectOwner(pbr->hbmPattern, ulOwner);
+
+    if ((ulOwner == GDI_OBJ_HMGR_PUBLIC) || ulOwner == GDI_OBJ_HMGR_NONE)
+    {
+        /* Free the brush attribute */
+        BRUSH_vFreeBrushAttr(pbr);
+    }
+    else if (ulOwner == GDI_OBJ_HMGR_POWNED)
+    {
+        /* Check if there is no usermode attribute */
+        if (pbr->pBrushAttr == &pbr->BrushAttr)
+        {
+            /* Free the brush attribute */
+            BRUSH_bAllocBrushAttr(pbr);
+        }
+    }
+
+    GDIOBJ_vSetObjectOwner(&pbr->BaseObject, ulOwner);
+
+    return TRUE;
+}
+
+BOOL
+NTAPI
+GreSetBrushOwner(HBRUSH hBrush, ULONG ulOwner)
+{
+    BOOL bResult;
+    PBRUSH pbrush;
+
+    /* Reference the brush */
+    pbrush = BRUSH_ShareLockBrush(hBrush);
+
+    /* Set the brush owner */
+    bResult = BRUSH_bSetBrushOwner(pbrush, ulOwner);
+
+    /* Dereference the brush */
+    BRUSH_ShareUnlockBrush(pbrush);
+    return bResult;
+}
+
+BOOL
+NTAPI
 BRUSH_Cleanup(PVOID ObjectBody)
 {
     PBRUSH pbrush = (PBRUSH)ObjectBody;
-    if (pbrush->hbmPattern)
-    {
+
+    /* We need to free bitmaps for pattern brushes, not for hatch brushes */
+    if (pbrush->flAttrs & (BR_IS_BITMAP|BR_IS_DIB))
+    {
+        ASSERT(pbrush->hbmPattern);
         GreSetObjectOwner(pbrush->hbmPattern, GDI_OBJ_HMGR_POWNED);
         GreDeleteObject(pbrush->hbmPattern);
     }
@@ -142,57 +222,53 @@
 
 INT
 FASTCALL
-BRUSH_GetObject(PBRUSH pbrush, INT Count, LPLOGBRUSH Buffer)
-{
-    if (Buffer == NULL) return sizeof(LOGBRUSH);
-    if (Count == 0) return 0;
+BRUSH_GetObject(PBRUSH pbrush, INT cjSize, LPLOGBRUSH plogbrush)
+{
+    /* Check if only size is requested */
+    if ((plogbrush == NULL) || (cjSize == 0)) return sizeof(LOGBRUSH);
 
     /* Set colour */
-    Buffer->lbColor = pbrush->BrushAttr.lbColor;
-
-    /* Set Hatch */
-    if ((pbrush->flAttrs & BR_IS_HATCH)!=0)
-    {
-        /* FIXME: This is not the right value */
-        Buffer->lbHatch = (LONG)pbrush->hbmPattern;
+    plogbrush->lbColor = pbrush->BrushAttr.lbColor;
+
+    /* Default to 0 */
+    plogbrush->lbHatch = 0;
+
+    /* Get the type of style */
+    if (pbrush->flAttrs & BR_IS_SOLID)
+    {
+        plogbrush->lbStyle = BS_SOLID;
+    }
+    else if (pbrush->flAttrs & BR_IS_NULL)
+    {
+        plogbrush->lbStyle = BS_NULL; // BS_HOLLOW
+    }
+    else if (pbrush->flAttrs & BR_IS_HATCH)
+    {
+        plogbrush->lbStyle = BS_HATCHED;
+        plogbrush->lbHatch = pbrush->ulStyle;
+    }
+    else if (pbrush->flAttrs & BR_IS_DIB)
+    {
+        plogbrush->lbStyle = BS_DIBPATTERN;
+        plogbrush->lbHatch = (ULONG_PTR)pbrush->hbmClient;
+    }
+    else if (pbrush->flAttrs & BR_IS_BITMAP)
+    {
+        plogbrush->lbStyle = BS_PATTERN;
     }
     else
     {
-        Buffer->lbHatch = 0;
-    }
-
-    Buffer->lbStyle = 0;
-
-    /* Get the type of style */
-    if ((pbrush->flAttrs & BR_IS_SOLID)!=0)
-    {
-        Buffer->lbStyle = BS_SOLID;
-    }
-    else if ((pbrush->flAttrs & BR_IS_NULL)!=0)
-    {
-        Buffer->lbStyle = BS_NULL; // BS_HOLLOW
-    }
-    else if ((pbrush->flAttrs & BR_IS_HATCH)!=0)
-    {
-        Buffer->lbStyle = BS_HATCHED;
-    }
-    else if ((pbrush->flAttrs & BR_IS_BITMAP)!=0)
-    {
-        Buffer->lbStyle = BS_PATTERN;
-    }
-    else if ((pbrush->flAttrs & BR_IS_DIB)!=0)
-    {
-        Buffer->lbStyle = BS_DIBPATTERN;
+        plogbrush->lbStyle = 0; // ???
     }
 
     /* FIXME
-    else if ((pbrush->flAttrs & )!=0)
-    {
-        Buffer->lbStyle = BS_INDEXED;
-    }
-    else if ((pbrush->flAttrs & )!=0)
-    {
-        Buffer->lbStyle = BS_DIBPATTERNPT;
+    else if (pbrush->flAttrs & )
+    {
+        plogbrush->lbStyle = BS_INDEXED;
+    }
+    else if (pbrush->flAttrs & )
+    {
+        plogbrush->lbStyle = BS_DIBPATTERNPT;
     }
     */
 
@@ -200,266 +276,224 @@
     return sizeof(LOGBRUSH);
 }
 
+VOID
+NTAPI
+GreSetSolidBrushColor(HBRUSH hbr, COLORREF crColor)
+{
+    PBRUSH pbrush;
+
+    pbrush = BRUSH_ShareLockBrush(hbr);
+    if (!pbrush) return;
+
+    if (pbrush->flAttrs & BR_IS_SOLID)
+    {
+        pbrush->BrushAttr.lbColor = crColor & 0xFFFFFF;
+    }
+    BRUSH_ShareUnlockBrush(pbrush);
+}
+
+HBRUSH
+NTAPI
+GreCreateBrushInternal(
+    _In_ ULONG ulStyle,
+    _In_ HBITMAP hbmPattern,
+    _In_ HBITMAP hbmClient,
+    _In_ COLORREF crColor,
+    _In_ FLONG flAttrib)
+{
+    PBRUSH pbr;
+    HBRUSH hbr;
+    ULONG ulOwner;
+    UCHAR objt;
+
+    /* Set the desired object type */
+    if (flAttrib & BR_IS_OLDSTYLEPEN) objt = GDIObjType_PEN_TYPE;
+    else if (flAttrib & BR_IS_PEN) objt = GDIObjType_EXTPEN_TYPE;
+    else objt = GDIObjType_BRUSH_TYPE;
+
+    /* Set object owner */
+    if (flAttrib & BR_IS_GLOBAL) ulOwner = GDI_OBJ_HMGR_PUBLIC;
+    else ulOwner = GDI_OBJ_HMGR_POWNED;
+
+    /* Allocate a brush */
+    pbr = BRUSH_AllocBrushOrPenWithHandle(objt, ulOwner);
+    if (pbr == NULL)
+    {
+        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return NULL;
+    }
+
+    /* Set brush properties */
+    pbr->flAttrs = flAttrib;
+    pbr->hbmPattern = hbmPattern;
+    pbr->hbmClient = hbmClient;
+    pbr->ulStyle = ulStyle;
+    pbr->BrushAttr.lbColor = crColor;
+
+    /* Get the handle and unlock the brush */
+    hbr = pbr->BaseObject.hHmgr;
+    GDIOBJ_vUnlockObject(&pbr->BaseObject);
+
+    return hbr;
+}
+
+HBRUSH
+NTAPI
+GreCreateNullBrush(VOID)
+{
+    /* Call the internal worker function */
+    return GreCreateBrushInternal(0, NULL, NULL, 0, BR_IS_NULL|BR_IS_GLOBAL);
+}
+
+/* SYSTEM CALLS **************************************************************/
+
 HBRUSH
 APIENTRY
-IntGdiCreateDIBBrush(
-    CONST BITMAPINFO *BitmapInfo,
-    UINT ColorSpec,
-    UINT BitmapInfoSize,
-    CONST VOID *PackedDIB)
-{
-    HBRUSH hBrush;
-    PBRUSH pbrush;
-    HBITMAP hPattern;
-    ULONG_PTR DataPtr;
-    PVOID pvDIBits;
-
-    if (BitmapInfo->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
-    {
-        EngSetLastError(ERROR_INVALID_PARAMETER);
-        return NULL;
-    }
-
-    DataPtr = (ULONG_PTR)BitmapInfo + DIB_BitmapInfoSize(BitmapInfo, ColorSpec);
-
-    hPattern = DIB_CreateDIBSection(NULL, BitmapInfo, ColorSpec, &pvDIBits, NULL, 0, 0);
-    if (hPattern == NULL)
-    {
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-	RtlCopyMemory(pvDIBits,
-		          (PVOID)DataPtr,
-				  DIB_GetDIBImageBytes(BitmapInfo->bmiHeader.biWidth,
-                                       BitmapInfo->bmiHeader.biHeight,
-                                       BitmapInfo->bmiHeader.biBitCount * BitmapInfo->bmiHeader.biPlanes));
-
-    pbrush = BRUSH_AllocBrushWithHandle();
-    if (pbrush == NULL)
-    {
-        GreDeleteObject(hPattern);
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-    hBrush = pbrush->BaseObject.hHmgr;
-
-    pbrush->flAttrs |= BR_IS_BITMAP | BR_IS_DIB;
-    pbrush->hbmPattern = hPattern;
-    /* FIXME: Fill in the rest of fields!!! */
-
-    GreSetObjectOwner(hPattern, GDI_OBJ_HMGR_PUBLIC);
-
-    GDIOBJ_vUnlockObject(&pbrush->BaseObject);
-
-    return hBrush;
+NtGdiCreateSolidBrush(
+    _In_ COLORREF crColor,
+    _In_opt_ HBRUSH hbr)
+{
+    /* Call the internal worker function */
+    return GreCreateBrushInternal(0, NULL, NULL, crColor, BR_IS_SOLID);
 }
 
 HBRUSH
 APIENTRY
-IntGdiCreateHatchBrush(
-    INT Style,
-    COLORREF Color)
-{
-    HBRUSH hBrush;
-    PBRUSH pbrush;
-
-    if (Style < 0 || Style >= NB_HATCH_STYLES)
+NtGdiCreateHatchBrushInternal(
+    _In_ ULONG ulStyle,
+    _In_ COLORREF crColor,
+    _In_ BOOL bPen)
+{
+    FLONG flAttr = BR_IS_HATCH | (bPen ? BR_IS_PEN : 0);
+
+    /* Check parameters */
+    if ((ulStyle < 0) || (ulStyle >= HS_DDI_MAX))
     {
         return 0;
     }
 
-    pbrush = BRUSH_AllocBrushWithHandle();
-    if (pbrush == NULL)
-    {
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-    hBrush = pbrush->BaseObject.hHmgr;
-
-    pbrush->flAttrs |= BR_IS_HATCH;
-    pbrush->BrushAttr.lbColor = Color & 0xFFFFFF;
-    pbrush->ulStyle = Style;
-
-    GDIOBJ_vUnlockObject(&pbrush->BaseObject);
-
-    return hBrush;
+    /* Call the internal worker function */
+    return GreCreateBrushInternal(ulStyle, NULL, NULL, crColor, flAttr);
 }
 
 HBRUSH
 APIENTRY
-IntGdiCreatePatternBrush(
-    HBITMAP hBitmap)
-{
-    HBRUSH hBrush;
-    PBRUSH pbrush;
-    HBITMAP hPattern;
-
-    hPattern = BITMAP_CopyBitmap(hBitmap);
-    if (hPattern == NULL)
+NtGdiCreatePatternBrushInternal(
+    _In_ HBITMAP hBitmap,
+    _In_ BOOL bPen,
+    _In_ BOOL b8x8)
+{
+    HBITMAP hbmPattern;
+    FLONG flAttr = BR_IS_BITMAP | (bPen ? BR_IS_PEN : 0);
+
+    /* Make a copy of the given bitmap */
+    hbmPattern = BITMAP_CopyBitmap(hBitmap);
+    if (hbmPattern == NULL)
     {
         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
         return NULL;
     }
 
-    pbrush = BRUSH_AllocBrushWithHandle();
-    if (pbrush == NULL)
-    {
-        GreDeleteObject(hPattern);
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-    hBrush = pbrush->BaseObject.hHmgr;
-
-    pbrush->flAttrs |= BR_IS_BITMAP;
-    pbrush->hbmPattern = hPattern;
-    /* FIXME: Fill in the rest of fields!!! */
-
-    GreSetObjectOwner(hPattern, GDI_OBJ_HMGR_PUBLIC);
-
-    GDIOBJ_vUnlockObject(&pbrush->BaseObject);
-
-    return hBrush;
-}
-
-HBRUSH
-APIENTRY
-IntGdiCreateSolidBrush(
-    COLORREF Color)
-{
-    HBRUSH hBrush;
-    PBRUSH pbrush;
-
-    pbrush = BRUSH_AllocBrushWithHandle();
-    if (pbrush == NULL)
-    {
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-    hBrush = pbrush->BaseObject.hHmgr;
-
-    pbrush->flAttrs |= BR_IS_SOLID;
-
-    pbrush->BrushAttr.lbColor = Color & 0x00FFFFFF;
-    /* FIXME: Fill in the rest of fields!!! */
-
-    GDIOBJ_vUnlockObject(&pbrush->BaseObject);
-
-    return hBrush;
-}
-
-HBRUSH
-APIENTRY
-IntGdiCreateNullBrush(VOID)
-{
-    HBRUSH hBrush;
-    PBRUSH pbrush;
-
-    pbrush = BRUSH_AllocBrushWithHandle();
-    if (pbrush == NULL)
-    {
-        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-        return NULL;
-    }
-    hBrush = pbrush->BaseObject.hHmgr;
-
-    pbrush->flAttrs |= BR_IS_NULL;
-    GDIOBJ_vUnlockObject(&pbrush->BaseObject);
-
-    return hBrush;
-}
-
-VOID
-FASTCALL
-IntGdiSetSolidBrushColor(HBRUSH hBrush, COLORREF Color)
-{
-    PBRUSH pbrush;
-
-    pbrush = BRUSH_ShareLockBrush(hBrush);
-    if (pbrush->flAttrs & BR_IS_SOLID)
-    {
-        pbrush->BrushAttr.lbColor = Color & 0xFFFFFF;
-    }
-    BRUSH_ShareUnlockBrush(pbrush);
-}
-
-
-/* PUBLIC FUNCTIONS ***********************************************************/
+    /* Call the internal worker function */
+    return GreCreateBrushInternal(0, hbmPattern, hBitmap, 0, flAttr);
+}
 
 HBRUSH
 APIENTRY
 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(FL_ZERO_MEMORY, BitmapInfoSize, TAG_DIB);
-    if (SafeBitmapInfoAndData == NULL)
+    _In_ PVOID pvPackedDIB,
+    _In_ ULONG iUsage,// FLONG flColorSpec,
+    _In_ UINT cjDIBSize,
+    _In_ BOOL b8x8,
+    _In_ BOOL bPen,
+    _In_ PVOID pClient)
+{
+    FLONG flAttr = BR_IS_DIB | (bPen ? BR_IS_PEN : 0);
+    PVOID pvSaveDIB, pvSafeBits;
+    PBITMAPINFO pbmi;
+    HBITMAP hbmPattern;
+    ULONG cjInfoSize;
+
+    /* Parameter check */
+    if (iUsage > 2)
+    {
+        EngSetLastError(ERROR_INVALID_PARAMETER);
+        return NULL;
+    }
+
+    /* Allocate a buffer large enough to hold the complete packed DIB */
+    pvSaveDIB = ExAllocatePoolWithTag(PagedPool, cjDIBSize, TAG_DIB);
+    if (pvSaveDIB == NULL)
     {
         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
         return NULL;
     }
 
+    /* Enter SEH for buffer transfer */
     _SEH2_TRY
     {
-        ProbeForRead(BitmapInfoAndData, BitmapInfoSize, 1);
-        RtlCopyMemory(SafeBitmapInfoAndData, BitmapInfoAndData, BitmapInfoSize);
+        /* Probe and copy the whole DIB */
+        ProbeForRead(pvPackedDIB, cjDIBSize, 1);
+        RtlCopyMemory(pvSaveDIB, pvPackedDIB, cjDIBSize);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
-        Status = _SEH2_GetExceptionCode();
+        /* Got an exception, cleanup, set error and return 0 */
+        ExFreePoolWithTag(pvSaveDIB, TAG_DIB);
+        SetLastNtError(_SEH2_GetExceptionCode());
+        _SEH2_YIELD(return 0;)
     }
     _SEH2_END;
 
-    if (!NT_SUCCESS(Status))
-    {
-        EngFreeMem(SafeBitmapInfoAndData);
-        SetLastNtError(Status);
-        return 0;
-    }
-
-    hBrush = IntGdiCreateDIBBrush(SafeBitmapInfoAndData,
-                                  ColorSpec,
-                                  BitmapInfoSize,
-                                  PackedDIB);
-
-    EngFreeMem(SafeBitmapInfoAndData);
-
-    return hBrush;
-}
-
-HBRUSH
-APIENTRY
-NtGdiCreateHatchBrushInternal(
-    ULONG Style,
-    COLORREF Color,
-    BOOL bPen)
-{
-    return IntGdiCreateHatchBrush(Style, Color);
-}
-
-HBRUSH
-APIENTRY
-NtGdiCreatePatternBrushInternal(
-    HBITMAP hBitmap,
-    BOOL bPen,
-    BOOL b8x8)
-{
-    return IntGdiCreatePatternBrush(hBitmap);
-}
-
-HBRUSH
-APIENTRY
-NtGdiCreateSolidBrush(COLORREF Color,
-                      IN OPTIONAL HBRUSH hbr)
-{
-    return IntGdiCreateSolidBrush(Color);
+    /* Calculate the size of the bitmap info */
+    cjInfoSize = GreGetBitmapInfoSize(pvSaveDIB, iUsage);
+
+    /* Check sanity of the sizes */
+    if ((cjInfoSize < sizeof(BITMAPCOREHEADER)) || // info?
+        (cjInfoSize > cjDIBSize))
+    {
+        /* Something is wrong with the bitmap */
+        ExFreePoolWithTag(pvSaveDIB, TAG_DIB);
+        return NULL;
+    }
+
+    /* Get pointers to BITMAPINFO and to the bits */
+    pbmi = pvSaveDIB;
+    pvSafeBits = (PUCHAR)pvSaveDIB + cjInfoSize;
+
+    /* When DIB_PAL_COLORS is requested, we don't create the RGB palette
+       entries directly, instead we need to create a fake palette containing
+       pal indices, which is converted into a real palette when the brush
+       is realized. */
+    if (iUsage == DIB_PAL_COLORS) iUsage = DIB_PAL_BRUSHHACK;
+
+    /* Create the pattern bitmap from the DIB. */
+    hbmPattern = GreCreateDIBitmapInternal(NULL,
+                                           pbmi->bmiHeader.biWidth,
+                                           abs(pbmi->bmiHeader.biHeight),
+                                           CBM_INIT,
+                                           pvSafeBits,
+                                           pbmi,
+                                           iUsage,// FIXME!!!
+                                           0,
+                                           cjDIBSize - cjInfoSize,
+                                           NULL);
+
+    /* Free the buffer already */
+    ExFreePoolWithTag(pvSaveDIB, TAG_DIB);
+
+    /* Check for failure */
+    if (!hbmPattern)
+    {
+        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return NULL;
+    }
+
+    /* Remember if the palette consists of palette indices */
+    if (iUsage == DIB_PAL_COLORS) flAttr |= BR_IS_DIBPALCOLORS;
+
+    /* Call the internal worker function */
+    return GreCreateBrushInternal(0, hbmPattern, pvPackedDIB, 0, flAttr);
 }
 
 

Modified: branches/dib_rewrite/win32ss/gdi/ntgdi/brush.h
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/brush.h?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/brush.h [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/brush.h [iso-8859-1] Wed May  9 20:36:16 2012
@@ -1,8 +1,4 @@
 #pragma once
-
-/* Internal interface */
-
-#define NB_HATCH_STYLES  6
 
 /*
  * The layout of this structure is taken from "Windows Graphics Programming"
@@ -19,7 +15,7 @@
 
    ULONG ulStyle;
    HBITMAP hbmPattern;
-   HBITMAP hbmClient;
+   HANDLE hbmClient;
    ULONG flAttrs;
 
    ULONG ulBrushUnique;
@@ -55,9 +51,9 @@
 //    DWORD       dwUnknown2c;
 //    DWORD       dwUnknown30;
     SURFACE *   psurfTrg;
-    struct _PALETTE *   ppalSurf;
-    struct _PALETTE *   ppalDC;
-    struct _PALETTE *   ppalDIB;
+    PPALETTE    ppalSurf;
+    PPALETTE    ppalDC;
+    PPALETTE    ppalDIB;
 //    DWORD       dwUnknown44;
     BRUSH *     pbrush;
     FLONG       flattrs;
@@ -86,15 +82,14 @@
 #define BR_CACHED_ENGINE    0x00040000
 #define BR_CACHED_IS_SOLID  0x80000000
 
-#define  BRUSH_AllocBrush() ((PBRUSH) GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE))
-#define  BRUSH_AllocBrushWithHandle() ((PBRUSH) GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_BRUSH, sizeof(BRUSH)))
-#define  BRUSH_FreeBrush(pBrush) GDIOBJ_FreeObj((POBJ)pBrush, GDIObjType_BRUSH_TYPE)
-#define  BRUSH_FreeBrushByHandle(hBrush) GDIOBJ_FreeObjByHandle((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)
 #define  BRUSH_ShareLockBrush(hBrush) ((PBRUSH)GDIOBJ_ShareLockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
 #define  BRUSH_ShareUnlockBrush(pBrush) GDIOBJ_vDereferenceObject((POBJ)pBrush)
 
-INT FASTCALL BRUSH_GetObject (PBRUSH GdiObject, INT Count, LPLOGBRUSH Buffer);
-BOOL NTAPI BRUSH_Cleanup(PVOID ObjectBody);
+#define GDIObjType_PEN_TYPE 0x30
+#define GDIObjType_EXTPEN_TYPE 0x50
+
+#define DIB_DEFPAL_COLORS 2 /* Colors are indices into the default palette */
+#define DIB_PAL_BRUSHHACK 3 /* Used as iUsage to create a PAL_BRUSHHACK palete */
 
 extern HSURF gahsurfHatch[HS_DDI_MAX];
 
@@ -145,19 +140,69 @@
     return iOldColor;
 }
 
-BOOL FASTCALL IntGdiSetBrushOwner(PBRUSH,DWORD);
-BOOL FASTCALL GreSetBrushOwner(HBRUSH,DWORD);
-
-HBRUSH APIENTRY
-IntGdiCreatePatternBrush(
-   HBITMAP hBitmap);
-
-HBRUSH APIENTRY
-IntGdiCreateSolidBrush(
-   COLORREF Color);
-
-HBRUSH APIENTRY
-IntGdiCreateNullBrush(VOID);
-
-VOID FASTCALL
-IntGdiSetSolidBrushColor(HBRUSH hBrush, COLORREF Color);
+
+PBRUSH
+NTAPI
+BRUSH_AllocBrushOrPen(UCHAR objt);
+
+#define BRUSH_AllocBrush() \
+    BRUSH_AllocBrushOrPen(GDIObjType_BRUSH_TYPE)
+
+PBRUSH
+NTAPI
+BRUSH_AllocBrushOrPenWithHandle(UCHAR objt, ULONG ulOwner);
+
+#define BRUSH_AllocBrushWithHandle(ulOwner) \
+    BRUSH_AllocBrushOrPenWithHandle(GDIObjType_BRUSH_TYPE, ulOwner)
+
+INT
+FASTCALL
+BRUSH_GetObject(PBRUSH GdiObject, INT Count, LPLOGBRUSH Buffer);
+
+BOOL
+NTAPI
+BRUSH_Cleanup(PVOID ObjectBody);
+
+BOOL
+NTAPI
+BRUSH_bSetBrushOwner(PBRUSH pbr, ULONG ulOwner);
+
+BOOL
+NTAPI
+GreSetBrushOwner(HBRUSH,DWORD);
+
+HBRUSH
+NTAPI
+GreCreatePatternBrushEx(
+    _In_ HBITMAP hbmPattern,
+    _In_ FLONG flAttrs,
+    _In_ BOOL bPen,
+    _In_ BOOL b8X8, // FIXME: do we need this?
+    _In_ BOOL bGlobal);
+
+HBRUSH
+FORCEINLINE
+GreCreatePatternBrush(
+    _In_ HBITMAP hbmPattern,
+    _In_ BOOL bGlobal)
+{
+    return GreCreatePatternBrushEx(hbmPattern, 0, 0, 0, bGlobal);
+}
+
+HBRUSH
+NTAPI
+GreCreateNullBrush(VOID);
+
+VOID
+NTAPI
+GreSetSolidBrushColor(HBRUSH hbr, COLORREF crColor);
+
+#define InterlockedIncrementUL(x) InterlockedIncrement((LONG*)(x))
+#define GreGetBitmapInfoSize(pbmi, iUsage) DIB_BitmapInfoSize(pbmi, (WORD)iUsage)
+
+#define IntGdiSetBrushOwner BRUSH_bSetBrushOwner
+#define IntGdiCreatePatternBrush(hbmp) NtGdiCreatePatternBrushInternal(hbmp, 0, 0)
+#define IntGdiCreateSolidBrush(color) NtGdiCreateSolidBrush(color, 0)
+#define IntGdiSetSolidBrushColor GreSetSolidBrushColor
+#define IntGdiCreateNullBrush GreCreateNullBrush
+

Added: branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c?rev=56555&view=auto
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c (added)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c [iso-8859-1] Wed May  9 20:36:16 2012
@@ -1,0 +1,979 @@
+/*
+ * COPYRIGHT:        GNU GPL, see COPYING in the top level directory
+ * PROJECT:          ReactOS Win32 kernelmode subsystem
+ * PURPOSE:          GDI functions for device independent bitmaps
+ * FILE:             subsystems/win32/win32k/objects/dibitmap.c
+ * PROGRAMER:        Timo Kreuzer
+ */
+
+#include <win32k.h>
+
+#define NDEBUG
+#include <debug.h>
+
+static
+BOOL
+DibGetBitmapFormat(
+    _In_ const BITMAPINFO *pbmi,
+    _Out_ PBITMAPFORMAT pbmf)
+{
+    /* Check for BITMAPCOREINFO */
+    if (pbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
+    {
+        PBITMAPCOREHEADER pbch = (PBITMAPCOREHEADER)pbmi;
+
+        pbmf->sizel.cx = pbch->bcWidth;
+        pbmf->sizel.cy = pbch->bcHeight;
+        pbmf->cBitsPixel = pbch->bcBitCount * pbch->bcPlanes;
+        pbmf->iCompression = BI_RGB;
+    }
+    else
+    {
+        pbmf->sizel.cx = pbmi->bmiHeader.biWidth;
+        pbmf->sizel.cy = pbmi->bmiHeader.biHeight;
+        pbmf->cBitsPixel = pbmi->bmiHeader.biBitCount * pbmi->bmiHeader.biPlanes;
+        pbmf->iCompression = pbmi->bmiHeader.biCompression;
+    }
+
+    /* Get the bitmap format */
+    pbmf->iFormat = BitmapFormat(pbmf->cBitsPixel, pbmf->iCompression);
+
+    /* Check if we have a valid bitmap format */
+    if (pbmf->iFormat == 0)
+    {
+        DPRINT1("Invalid format\n");
+        return FALSE;
+    }
+
+    /* Check compressed format and top-down */
+    if ((pbmf->iFormat > BMF_32BPP) && (pbmf->sizel.cy < 0))
+    {
+        DPRINT1("Compressed bitmaps cannot be top-down.\n");
+        return FALSE;
+    }
+
+    // FIXME: check bitmap extensions / size
+
+    return TRUE;
+}
+
+static
+ULONG
+DibGetImageSize(
+    _In_ const BITMAPINFO *pbmi)
+{
+    LONG lWidth, lHeight;
+    ULONG cBitsPixel;
+
+    /* Check for BITMAPCOREINFO */
+    if (pbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
+    {
+        PBITMAPCOREHEADER pbch = (PBITMAPCOREHEADER)pbmi;
+        lWidth = pbch->bcWidth;
+        lHeight = pbch->bcHeight;
+        cBitsPixel = pbch->bcBitCount * pbch->bcPlanes;
+    }
+    else
+    {
+        lWidth = pbmi->bmiHeader.biWidth;
+        lHeight = pbmi->bmiHeader.biHeight;
+        cBitsPixel = pbmi->bmiHeader.biBitCount * pbmi->bmiHeader.biPlanes;
+    }
+
+    return WIDTH_BYTES_ALIGN32(lWidth, cBitsPixel) * abs(lHeight);
+}
+
+ULONG
+NTAPI
+DibGetBitmapInfoSize(
+    _In_ const BITMAPINFO *pbmi,
+    _In_ ULONG iUsage)
+{
+    ULONG cjHeaderSize, cBitsPixel, cColors, cMaxColors;
+
+    cjHeaderSize = pbmi->bmiHeader.biSize;
+
+    if ((cjHeaderSize < sizeof(BITMAPCOREHEADER)) ||
+        ((LONG)cjHeaderSize < 0))
+    {
+        return 0;
+    }
+
+    /* Check for BITMAPCOREINFO */
+    if (cjHeaderSize < sizeof(BITMAPINFOHEADER))
+    {
+        PBITMAPCOREHEADER pbch = (PBITMAPCOREHEADER)pbmi;
+
+        cBitsPixel = pbch->bcBitCount;
+        cColors = (cBitsPixel <= 8) ? (1 << cBitsPixel) : 0;
+        return sizeof(BITMAPCOREHEADER) + cColors *
+               ((iUsage == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
+    }
+    else  /* Use BITMAPINFOHEADER */
+    {
+        /* Check if the DIB uses bitfields */
+        if (pbmi->bmiHeader.biCompression == BI_BITFIELDS)
+        {
+            /* Check for V4/v5 info */
+            if (cjHeaderSize >= sizeof(BITMAPV4HEADER))
+            {
+                /* There are no colors or masks */
+                return cjHeaderSize;
+            }
+            else
+            {
+                /* The color table is 3 masks */
+                return cjHeaderSize + 3 * sizeof(RGBQUAD);
+            }
+        }
+
+        cBitsPixel = pbmi->bmiHeader.biBitCount;
+        if (cBitsPixel > 8)
+            return cjHeaderSize;
+
+        cMaxColors = (1 << cBitsPixel);
+        cColors = pbmi->bmiHeader.biClrUsed;
+        if ((cColors == 0) || (cColors > cMaxColors)) cColors = cMaxColors;
+
+        if (iUsage == DIB_RGB_COLORS)
+            return cjHeaderSize + cColors * sizeof(RGBQUAD);
+        else
+            return cjHeaderSize + cColors * sizeof(WORD);
+    }
+}
+
+PBITMAPINFO
+NTAPI
+DibProbeAndCaptureBitmapInfo(
+    _In_ const BITMAPINFO *pbmiUnsafe,
+    _In_ ULONG iUsage,
+    _In_ PULONG pcjInfo)
+{
+    BITMAPINFO *pbmi;
+    ULONG cjInfo = *pcjInfo;
+
+    /* Normalize the size to the maximum possible */
+    cjInfo = min(cjInfo, sizeof(BITMAPV5HEADER) + 256 * sizeof(RGBQUAD));
+
+    /* Check if the size is at least big enough for a core info */
+    if (cjInfo < sizeof(BITMAPCOREHEADER))
+    {
+        return NULL;
+    }
+
+    /* Allocate a buffer for the bitmap info */
+    pbmi = ExAllocatePoolWithTag(PagedPool, cjInfo, GDITAG_BITMAPINFO);
+    if (!pbmi)
+    {
+        return NULL;
+    }
+
+    /* Enter SEH for copy */
+    _SEH2_TRY
+    {
+        /* Probe and copy the data from user mode */
+        ProbeForRead(pbmiUnsafe, cjInfo, 1);
+        RtlCopyMemory(pbmi, pbmiUnsafe, cjInfo);
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        _SEH2_YIELD(return NULL);
+    }
+    _SEH2_END;
+
+    /* Check if we have at least as much as the actual header size */
+    if (cjInfo >= pbmi->bmiHeader.biSize)
+    {
+        /* Calculate the real size of the bitmap info */
+        cjInfo = DibGetBitmapInfoSize(pbmi, iUsage);
+
+        /* Make sure the real size is not larger than our buffer */
+        if (cjInfo <= *pcjInfo)
+        {
+            /* Update the real info size */
+            *pcjInfo = cjInfo;
+
+            /* Return the new bitmap info */
+            return pbmi;
+        }
+    }
+
+    /* Failure, free the buffer and return NULL */
+    ExFreePoolWithTag(pbmi, GDITAG_BITMAPINFO);
+    return NULL;
+}
+
+VOID
+FORCEINLINE
+DibFreeBitmapInfo(
+    _In_ PBITMAPINFO pbmi)
+{
+    ExFreePoolWithTag(pbmi, GDITAG_BITMAPINFO);
+}
+
+PPALETTE
+NTAPI
+CreateDIBPalette(
+    _In_ const BITMAPINFO *pbmi,
+    _In_ PDC pdc,
+    _In_ ULONG iUsage)
+{
+    PPALETTE ppal;
+    ULONG i, cBitsPixel, cColors;
+
+    if (pbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
+    {
+        PBITMAPCOREINFO pbci = (PBITMAPCOREINFO)pbmi;
+        cBitsPixel = pbci->bmciHeader.bcBitCount;
+    }
+    else
+    {
+        cBitsPixel = pbmi->bmiHeader.biBitCount;
+    }
+
+    /* Check if the colors are indexed */
+    if (cBitsPixel <= 8)
+    {
+        /* We create a "full" palette */
+        cColors = 1 << cBitsPixel;
+
+        /* Allocate the palette */
+        ppal = PALETTE_AllocPalette(PAL_INDEXED,
+                                    cColors,
+                                    NULL,
+                                    0,
+                                    0,
+                                    0);
+
+        /* Check if the BITMAPINFO specifies how many colors to use */
+        if ((pbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
+            (pbmi->bmiHeader.biClrUsed != 0))
+        {
+            /* This is how many colors we can actually process */
+            cColors = min(cColors, pbmi->bmiHeader.biClrUsed);
+        }
+
+        /* Check how to use the colors */
+        if (iUsage == DIB_PAL_COLORS)
+        {
+            COLORREF crColor;
+
+            /* The colors are an array of WORD indices into the DC palette */
+            PWORD pwColors = (PWORD)((PCHAR)pbmi + pbmi->bmiHeader.biSize);
+
+            /* Use the DCs palette or, if no DC is given, the default one */
+            PPALETTE ppalDC = pdc ? pdc->dclevel.ppal : gppalDefault;
+
+            /* Loop all color indices in the DIB */
+            for (i = 0; i < cColors; i++)
+            {
+                /* Get the palette index and handle wraparound when exceeding
+                   the number of colors in the DC palette */
+                WORD wIndex = pwColors[i] % ppalDC->NumColors;
+
+                /* USe the RGB value from the DC palette */
+                crColor = PALETTE_ulGetRGBColorFromIndex(ppalDC, wIndex);
+                PALETTE_vSetRGBColorForIndex(ppal, i, crColor);
+            }
+        }
+        else if (iUsage == DIB_PAL_BRUSHHACK)
+        {
+            /* The colors are an array of WORD indices into the DC palette */
+            PWORD pwColors = (PWORD)((PCHAR)pbmi + pbmi->bmiHeader.biSize);
+
+            /* Loop all color indices in the DIB */
+            for (i = 0; i < cColors; i++)
+            {
+                /* Set the index directly as the RGB color, the real palette
+                   containing RGB values will be calculated when the brush is
+                   realized */
+                PALETTE_vSetRGBColorForIndex(ppal, i, pwColors[i]);
+            }
+
+            /* Mark the palette as a brush hack palette */
+            ppal->flFlags |= PAL_BRUSHHACK;
+        }
+//        else if (iUsage == 2)
+//        {
+            // FIXME: this one is undocumented
+//            ASSERT(FALSE);
+//        }
+        else if (pbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
+        {
+            /* The colors are an array of RGBQUAD values */
+            RGBQUAD *prgb = (RGBQUAD*)((PCHAR)pbmi + pbmi->bmiHeader.biSize);
+
+            // FIXME: do we need to handle PALETTEINDEX / PALETTERGB macro?
+
+            /* Loop all color indices in the DIB */
+            for (i = 0; i < cColors; i++)
+            {
+                /* Get the color value and translate it to a COLORREF */
+                RGBQUAD rgb = prgb[i];
+                COLORREF crColor = RGB(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
+
+                /* Set the RGB value in the palette */
+                PALETTE_vSetRGBColorForIndex(ppal, i, crColor);
+            }
+        }
+        else
+        {
+            /* The colors are an array of RGBTRIPLE values */
+            RGBTRIPLE *prgb = (RGBTRIPLE*)((PCHAR)pbmi + pbmi->bmiHeader.biSize);
+
+            /* Loop all color indices in the DIB */
+            for (i = 0; i < cColors; i++)
+            {
+                /* Get the color value and translate it to a COLORREF */
+                RGBTRIPLE rgb = prgb[i];
+                COLORREF crColor = RGB(rgb.rgbtRed, rgb.rgbtGreen, rgb.rgbtBlue);
+
+                /* Set the RGB value in the palette */
+                PALETTE_vSetRGBColorForIndex(ppal, i, crColor);
+            }
+        }
+    }
+    else
+    {
+        /* This is a bitfield / RGB palette */
+        ULONG flRedMask, flGreenMask, flBlueMask;
+
+        /* Check if the DIB contains bitfield values */
+        if ((pbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
+            (pbmi->bmiHeader.biCompression == BI_BITFIELDS))
+        {
+            /* Check if we have a v4/v5 header */
+            if (pbmi->bmiHeader.biSize >= sizeof(BITMAPV4HEADER))
+            {
+                /* The masks are dedicated fields in the header */
+                PBITMAPV4HEADER pbmV4Header = (PBITMAPV4HEADER)&pbmi->bmiHeader;
+                flRedMask = pbmV4Header->bV4RedMask;
+                flGreenMask = pbmV4Header->bV4GreenMask;
+                flBlueMask = pbmV4Header->bV4BlueMask;
+            }
+            else
+            {
+                /* The masks are the first 3 values in the DIB color table */
+                PDWORD pdwColors = (PVOID)((PCHAR)pbmi + pbmi->bmiHeader.biSize);
+                flRedMask = pdwColors[0];
+                flGreenMask = pdwColors[1];
+                flBlueMask = pdwColors[2];
+            }
+        }
+        else
+        {
+            /* Check what bit depth we have. Note: optimization flags are
+               calculated in PALETTE_AllocPalette()  */
+            if (cBitsPixel == 16)
+            {
+                /* This is an RGB 555 palette */
+                flRedMask = 0x7C00;
+                flGreenMask = 0x03E0;
+                flBlueMask = 0x001F;
+            }
+            else
+            {
+                /* This is an RGB 888 palette */
+                flRedMask = 0xFF0000;
+                flGreenMask = 0x00FF00;
+                flBlueMask = 0x0000FF;
+            }
+        }
+
+        /* Allocate the bitfield palette */
+        ppal = PALETTE_AllocPalette(PAL_BITFIELDS,
+                                    0,
+                                    NULL,
+                                    flRedMask,
+                                    flGreenMask,
+                                    flBlueMask);
+    }
+
+    /* We're done, return the palette */
+    return ppal;
+}
+
+PSURFACE
+NTAPI
+DibCreateDIBSurface(
+    _In_ const BITMAPINFO *pbmi,
+    _In_opt_ PDC pdc,
+    _In_ ULONG iUsage,
+    _In_ ULONG fjBitmap,
+    _In_ PVOID pvBits,
+    _In_ ULONG cjMaxBits)
+{
+    BITMAPFORMAT bitmapformat;
+    PSURFACE psurf;
+    PPALETTE ppal;
+
+    /* Get the format of the DIB */
+    if (!DibGetBitmapFormat(pbmi, &bitmapformat))
+    {
+        /* Invalid BITMAPINFO */
+        return NULL;
+    }
+
+    /* Handle top-down bitmaps */
+    if (bitmapformat.sizel.cy < 0) fjBitmap |= BMF_TOPDOWN;
+
+    /* Allocate a surface for the DIB */
+    psurf = SURFACE_AllocSurface(STYPE_BITMAP,
+                                 bitmapformat.sizel.cx,
+                                 abs(bitmapformat.sizel.cy),
+                                 bitmapformat.iFormat,
+                                 fjBitmap,
+                                 0,
+                                 pvBits);
+    if (!psurf)
+    {
+        return NULL;
+    }
+
+    /* Create a palette from the color info */
+    ppal = CreateDIBPalette(pbmi, pdc, iUsage);
+    if (!ppal)
+    {
+        /* Free the surface and return NULL */
+        GDIOBJ_vDeleteObject(&psurf->BaseObject);
+        return NULL;
+    }
+
+    /* Dereference the old palette and set the new */
+    PALETTE_ShareUnlockPalette(psurf->ppal);
+    psurf->ppal = ppal;
+
+    /* Return the surface */
+    return psurf;
+}
+
+
+/* SYSTEM CALLS **************************************************************/
+
+HBITMAP
+APIENTRY
+NtGdiCreateDIBSection(
+    _In_ HDC hdc,
+    _In_ OPTIONAL HANDLE hSectionApp,
+    _In_ DWORD dwOffset,
+    _In_ LPBITMAPINFO pbmiUser,
+    _In_ DWORD iUsage,
+    _In_ UINT cjInfo,
+    _In_ FLONG fl,
+    _In_ ULONG_PTR dwColorSpace,
+    _Out_opt_ PVOID *ppvBits)
+{
+    PBITMAPINFO pbmi;
+    PSURFACE psurfDIBSection;
+    PVOID pvBits = NULL;
+    PDC pdc;
+    HANDLE hSecure;
+    HBITMAP hbmp = NULL;
+
+    /* Capture a safe copy of the bitmap info */
+    pbmi = DibProbeAndCaptureBitmapInfo(pbmiUser, iUsage, &cjInfo);
+    if (!pbmi)
+    {
+        /* Could not get bitmapinfo, fail. */
+        return NULL;
+    }
+
+    /* Check if we got a DC */
+    if (hdc)
+    {
+        /* Lock the DC */
+        pdc = DC_LockDc(hdc);
+        if (!pdc)
+        {
+            /* Fail */
+            goto cleanup;
+        }
+    }
+    else
+    {
+        /* No DC */
+        pdc = NULL;
+    }
+
+    /* Check if the caller passed a section handle */
+    if (hSectionApp)
+    {
+        /* Get the size of the image */
+        SIZE_T cjSize = DibGetImageSize(pbmi);
+
+        /* Map the section */
+        pvBits = EngMapSectionView(hSectionApp, cjSize, dwOffset, &hSecure);
+        if (!pvBits)
+        {
+            /* Fail */
+            goto cleanup;
+        }
+    }
+
+    /* Create the DIB section surface */
+    psurfDIBSection = DibCreateDIBSurface(pbmi,
+                                          pdc,
+                                          iUsage,
+                                          BMF_USERMEM,
+                                          pvBits,
+                                          0);
+    if (psurfDIBSection)
+    {
+        /* Check if we used a section */
+        if (hSectionApp)
+        {
+            /* Update section and secure handle */
+            psurfDIBSection->hDIBSection = hSectionApp;
+            psurfDIBSection->hSecure = hSecure;
+        }
+
+        /* Return the base address if requested */
+        if (ppvBits) *ppvBits = psurfDIBSection->SurfObj.pvBits;
+
+        /* Save the handle and unlock the bitmap */
+        hbmp = psurfDIBSection->BaseObject.hHmgr;
+        SURFACE_UnlockSurface(psurfDIBSection);
+    }
+    else
+    {
+        /* Unmap the section view, if we had any */
+        if (hSectionApp) EngUnmapSectionView(pvBits, dwOffset, hSecure);
+    }
+
+cleanup:
+    /* Unlock the DC */
+    if (pdc) DC_UnlockDc(pdc);
+
+    /* Free the bitmap info buffer */
+    DibFreeBitmapInfo(pbmi);
+
+    return hbmp;
+}
+
+HBITMAP
+NTAPI
+GreCreateDIBitmapInternal(
+    _In_ HDC hdc,
+    _In_ INT cx,
+    _In_ INT cy,
+    _In_ DWORD fInit,
+    _In_opt_ LPBYTE pjInit,
+    _In_opt_ PBITMAPINFO pbmi,
+    _In_ DWORD iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ FLONG fl,
+    _In_ HANDLE hcmXform)
+{
+    PDC pdc;
+    PSURFACE psurfDIB;
+
+    /* Check if we got a DC */
+    if (hdc)
+    {
+        /* Lock the DC */
+        pdc = DC_LockDc(hdc);
+        if (!pdc)
+        {
+            return NULL;
+        }
+    }
+    else
+    {
+        /* No DC */
+        pdc = NULL;
+    }
+
+    if (pjInit)
+    {
+        psurfDIB = DibCreateDIBSurface(pbmi,
+                                       pdc,
+                                       iUsage,
+                                       0,
+                                       pjInit,
+                                       cjMaxBits);
+    }
+
+
+    return 0;
+}
+
+HBITMAP
+APIENTRY
+NtGdiCreateDIBitmapInternal(
+    _In_ HDC hdc,
+    _In_ INT cx,
+    _In_ INT cy,
+    _In_ DWORD fInit,
+    _In_opt_ LPBYTE pjInit,
+    _In_opt_ LPBITMAPINFO pbmiUser,
+    _In_ DWORD iUsage,
+    _In_ UINT cjMaxInitInfo,
+    _In_ UINT cjMaxBits,
+    _In_ FLONG fl,
+    _In_ HANDLE hcmXform)
+{
+    PBITMAPINFO pbmi = NULL;
+    HANDLE hSecure;
+    HBITMAP hbmp;
+
+    if (fInit & CBM_INIT)
+    {
+        if (pjInit)
+        {
+            hSecure = EngSecureMem(pjInit, cjMaxBits);
+            if (!hSecure)
+                return NULL;
+        }
+    }
+    else
+    {
+        pjInit = NULL;
+    }
+
+    if (pbmiUser)
+    {
+        pbmi = DibProbeAndCaptureBitmapInfo(pbmiUser, iUsage, &cjMaxInitInfo);
+        if (!pbmi) goto cleanup;
+    }
+
+
+    hbmp = GreCreateDIBitmapInternal(hdc,
+                                     cx,
+                                     cy,
+                                     fInit,
+                                     pjInit,
+                                     pbmi,
+                                     iUsage,
+                                     cjMaxBits,
+                                     fl,
+                                     hcmXform);
+
+    if (pbmi)
+    {
+        DibFreeBitmapInfo(pbmi);
+    }
+
+cleanup:
+
+    if (fInit & CBM_INIT)
+    {
+        EngUnsecureMem(hSecure);
+    }
+
+    return hbmp;
+}
+
+INT
+APIENTRY
+GreGetDIBitsInternal(
+    _In_ HDC hdc,
+    _In_ HBITMAP hbm,
+    _In_ UINT iStartScan,
+    _In_ UINT cScans,
+    _Out_opt_ LPBYTE pjBits,
+    _Inout_ LPBITMAPINFO pbmi,
+    _In_ UINT iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ UINT cjMaxInfo)
+{
+
+    __debugbreak();
+
+
+    return 0;
+}
+
+INT
+APIENTRY
+NtGdiGetDIBitsInternal(
+    _In_ HDC hdc,
+    _In_ HBITMAP hbm,
+    _In_ UINT iStartScan,
+    _In_ UINT cScans,
+    _Out_opt_ LPBYTE pjBits,
+    _Inout_ LPBITMAPINFO pbmi,
+    _In_ UINT iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ UINT cjMaxInfo)
+{
+    __debugbreak();
+    return 0;
+}
+
+INT
+NTAPI
+GreStretchDIBitsInternal(
+    _In_ HDC hdc,
+    _In_ INT xDst,
+    _In_ INT yDst,
+    _In_ INT cxDst,
+    _In_ INT cyDst,
+    _In_ INT xSrc,
+    _In_ INT ySrc,
+    _In_ INT cxSrc,
+    _In_ INT cySrc,
+    _In_opt_ LPBYTE pjInit,
+    _In_ LPBITMAPINFO pbmi,
+    _In_ ULONG iUsage,
+    _In_ DWORD dwRop,
+    _In_ ULONG cjMaxInfo,
+    _In_ ULONG cjMaxBits,
+    _In_ BOOL bTransformCoordinates,
+    _In_ HANDLE hcmXform)
+{
+    PDC pdc;
+    RECTL rcSrc, rcDst;
+    EXLATEOBJ exlo;
+    PSURFACE psurfDIB, psurfDst;
+    BOOL bResult;
+
+    /* Lock the DC */
+    pdc = DC_LockDc(hdc);
+    if (!pdc)
+    {
+        return 0;
+    }
+
+    /* Get the dest surface */
+    psurfDst = pdc->dclevel.pSurface;
+    if (!psurfDst)
+    {
+        DC_UnlockDc(pdc);
+        return 0;
+    }
+
+    /* Create the DIB surface */
+    psurfDIB = DibCreateDIBSurface(pbmi,
+                                   pdc,
+                                   iUsage,
+                                   0,
+                                   pjInit,
+                                   cjMaxBits);
+    if (!psurfDIB)
+    {
+        DC_UnlockDc(pdc);
+        return 0;
+    }
+
+    /* Calculate source and destination rect */
+    rcSrc.left = xSrc;
+    rcSrc.top = ySrc;
+    rcSrc.right = xSrc + cxSrc;
+    rcSrc.bottom = ySrc + cySrc;
+    rcDst.left = xDst;
+    rcDst.top = yDst;
+
+    if (bTransformCoordinates)
+    {
+        /* Use the size in logical units */
+        rcDst.right = rcDst.left + cxDst;
+        rcDst.bottom = rcDst.top + cyDst;
+
+        /* Transform destination rect to device coordinates */
+        IntLPtoDP(pdc, (POINTL*)&rcDst, 2);
+
+        /* Get the new dest size in device units */
+        cxDst = rcDst.right - rcDst.left;
+        cyDst = rcDst.bottom - rcDst.top;
+    }
+    else
+    {
+        /* Transform destination start point to device coordinates */
+        IntLPtoDP(pdc, (POINTL*)&rcDst, 1);
+
+        /* Use the size in device units */
+        rcDst.right = rcDst.left + cxDst;
+        rcDst.bottom = rcDst.top + cyDst;
+    }
+
+    /* Compensate for the DC origin */
+    RECTL_vOffsetRect(&rcDst, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
+
+    /* Initialize XLATEOBJ */
+    EXLATEOBJ_vInitialize(&exlo,
+                          psurfDIB->ppal,
+                          psurfDst->ppal,
+                          RGB(0xff, 0xff, 0xff),
+                          pdc->pdcattr->crBackgroundClr,
+                          pdc->pdcattr->crForegroundClr);
+
+    /* Prepare DC for blit */
+    DC_vPrepareDCsForBlit(pdc, rcDst, NULL, rcSrc);
+
+    /* Perform the stretch operation (note: this will go to
+       EngBitBlt when no stretching is needed) */
+    bResult = IntEngStretchBlt(&psurfDst->SurfObj,
+                               &psurfDIB->SurfObj,
+                               NULL,
+                               pdc->rosdc.CombinedClip,
+                               &exlo.xlo,
+                               &rcDst,
+                               &rcSrc,
+                               NULL,
+                               &pdc->eboFill.BrushObject,
+                               NULL,
+                               ROP3_TO_ROP4(dwRop));
+
+    /* Cleanup */
+    DC_vFinishBlit(pdc, NULL);
+    EXLATEOBJ_vCleanup(&exlo);
+    GDIOBJ_vDeleteObject(&psurfDIB->BaseObject);
+    DC_UnlockDc(pdc);
+
+    return bResult ? cySrc : 0;
+}
+
+INT
+APIENTRY
+NtGdiSetDIBitsToDeviceInternal(
+    _In_ HDC hdcDest,
+    _In_ INT xDst,
+    _In_ INT yDst,
+    _In_ DWORD cx,
+    _In_ DWORD cy,
+    _In_ INT xSrc,
+    _In_ INT ySrc,
+    _In_ DWORD iStartScan,
+    _In_ DWORD cNumScan,
+    _In_ LPBYTE pjInitBits,
+    _In_ LPBITMAPINFO pbmiUser,
+    _In_ DWORD iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ UINT cjMaxInfo,
+    _In_ BOOL bTransformCoordinates,
+    _In_opt_ HANDLE hcmXform)
+{
+    PBITMAPINFO pbmi;
+    HANDLE hSecure;
+    INT iResult = 0;
+
+    /* Capture a safe copy of the bitmap info */
+    pbmi = DibProbeAndCaptureBitmapInfo(pbmiUser, iUsage, &cjMaxInfo);
+    if (!pbmi)
+    {
+        /* Could not get bitmapinfo, fail. */
+        return 0;
+    }
+
+    /* Secure the user mode buffer for the bits */
+    hSecure = EngSecureMemForRead(pjInitBits, cjMaxBits);
+    if (hSecure)
+    {
+        /* Call the internal function with the secure pointers */
+        iResult = GreStretchDIBitsInternal(hdcDest,
+                                           xDst,
+                                           yDst,
+                                           cx,
+                                           cy,
+                                           xSrc,
+                                           ySrc,
+                                           cx,
+                                           cy,
+                                           pjInitBits,
+                                           pbmi,
+                                           iUsage,
+                                           MAKEROP4(SRCCOPY, SRCCOPY),
+                                           cjMaxInfo,
+                                           cjMaxBits,
+                                           bTransformCoordinates,
+                                           hcmXform);
+
+        /* Unsecure the memory */
+        EngUnsecureMem(hSecure);
+    }
+
+    /* Free the bitmap info */
+    DibFreeBitmapInfo(pbmi);
+
+    /* Return the result */
+    return iResult;
+}
+
+
+INT
+APIENTRY
+NtGdiStretchDIBitsInternal(
+    _In_ HDC hdc,
+    _In_ INT xDst,
+    _In_ INT yDst,
+    _In_ INT cxDst,
+    _In_ INT cyDst,
+    _In_ INT xSrc,
+    _In_ INT ySrc,
+    _In_ INT cxSrc,
+    _In_ INT cySrc,
+    _In_opt_ LPBYTE pjInit,
+    _In_ LPBITMAPINFO pbmiUser,
+    _In_ DWORD iUsage,
+    _In_ DWORD dwRop, // ms ntgdi.h says dwRop4(?)
+    _In_ UINT cjMaxInfo,
+    _In_ UINT cjMaxBits,
+    _In_ HANDLE hcmXform)
+{
+    PBITMAPINFO pbmi;
+    HANDLE hSecure;
+    INT iResult = 0;
+
+    /* Capture a safe copy of the bitmap info */
+    pbmi = DibProbeAndCaptureBitmapInfo(pbmiUser, iUsage, &cjMaxInfo);
+    if (!pbmi)
+    {
+        /* Could not get bitmapinfo, fail. */
+        return 0;
+    }
+
+    /* Secure the user mode buffer for the bits */
+    hSecure = EngSecureMemForRead(pjInit, cjMaxBits);
+    if (hSecure)
+    {
+        /* Call the internal function with the secure pointers */
+        iResult = GreStretchDIBitsInternal(hdc,
+                                           xDst,
+                                           yDst,
+                                           cxDst,
+                                           cyDst,
+                                           xSrc,
+                                           ySrc,
+                                           cxSrc,
+                                           cySrc,
+                                           pjInit,
+                                           pbmi,
+                                           iUsage,
+                                           dwRop,
+                                           cjMaxInfo,
+                                           cjMaxBits,
+                                           TRUE,
+                                           hcmXform);
+
+        /* Unsecure the memory */
+        EngUnsecureMem(hSecure);
+    }
+
+    /* Free the bitmap info */
+    DibFreeBitmapInfo(pbmi);
+
+    /* Return the result */
+    return iResult;
+}
+
+
+///////////////////////////////////////////////////////////////
+
+// old stuff
+
+BITMAPINFO*
+FASTCALL
+DIB_ConvertBitmapInfo(CONST BITMAPINFO* pbmi, DWORD Usage)
+{
+    __debugbreak();
+    return 0;
+}
+
+VOID
+FASTCALL
+DIB_FreeConvertedBitmapInfo(BITMAPINFO* converted, BITMAPINFO* orig)
+{
+    if(converted != orig)
+        ExFreePoolWithTag(converted, TAG_DIB);
+}
+

Propchange: branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.c
------------------------------------------------------------------------------
    svn:eol-style = native

Added: branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h?rev=56555&view=auto
==============================================================================
--- branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h (added)
+++ branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h [iso-8859-1] Wed May  9 20:36:16 2012
@@ -1,0 +1,86 @@
+
+/* Used as iUsage to create a PAL_BRUSHHACK palete */
+#define DIB_PAL_BRUSHHACK 3
+
+#define GDITAG_BITMAPINFO 'imbG'
+
+typedef struct _BITMAPFORMAT
+{
+    SIZEL sizel;
+    ULONG cBitsPixel;
+    ULONG iCompression;
+    ULONG iFormat;
+} BITMAPFORMAT, *PBITMAPFORMAT;
+
+ULONG
+NTAPI
+DibGetBitmapInfoSize(
+    _In_ const BITMAPINFO *pbmi,
+    _In_ ULONG iUsage);
+
+INT
+NTAPI
+GreGetDIBitsInternal(
+    _In_ HDC hdc,
+    _In_ HBITMAP hbm,
+    _In_ UINT iStartScan,
+    _In_ UINT cScans,
+    _Out_opt_ LPBYTE pjBits,
+    _Inout_ LPBITMAPINFO pbmi,
+    _In_ UINT iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ UINT cjMaxInfo);
+
+HBITMAP
+NTAPI
+GreCreateDIBitmapInternal(
+    _In_ HDC hdc,
+    _In_ INT cx,
+    _In_ INT cy,
+    _In_ DWORD fInit,
+    _In_opt_ LPBYTE pjInit,
+    _In_opt_ PBITMAPINFO pbmi,
+    _In_ DWORD iUsage,
+    _In_ UINT cjMaxBits,
+    _In_ FLONG fl,
+    _In_ HANDLE hcmXform);
+
+
+// other stuff
+
+HANDLE
+APIENTRY
+EngSecureMemForRead(PVOID Address, ULONG Length);
+
+#define ROP3_TO_ROP4(dwRop3) \
+    ((((dwRop3) & 0xFF0000) >> 8) | (((dwRop3) & 0xFF0000) >> 16))
+
+
+// old stuff
+
+BITMAPINFO*
+FASTCALL
+DIB_ConvertBitmapInfo(CONST BITMAPINFO* pbmi, DWORD Usage);
+
+VOID
+FASTCALL
+DIB_FreeConvertedBitmapInfo(BITMAPINFO* converted, BITMAPINFO* orig);
+
+INT FASTCALL DIB_BitmapInfoSize(const BITMAPINFO * info, WORD coloruse);
+
+INT
+FORCEINLINE
+DIB_GetDIBImageBytes(INT  width, INT height, INT depth)
+{
+    return WIDTH_BYTES_ALIGN32(width, depth) * (height < 0 ? -height : height);
+}
+
+UINT
+APIENTRY
+IntGetDIBColorTable(
+    HDC hDC,
+    UINT StartIndex,
+    UINT Entries,
+    RGBQUAD *Colors);
+
+#define DIB_BitmapInfoSize

Propchange: branches/dib_rewrite/win32ss/gdi/ntgdi/dibitmap.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: branches/dib_rewrite/win32ss/user/ntuser/clipboard.c
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/user/ntuser/clipboard.c?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/user/ntuser/clipboard.c [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/user/ntuser/clipboard.c [iso-8859-1] Wed May  9 20:36:16 2012
@@ -147,6 +147,8 @@
     hdc = UserGetDCEx(NULL, NULL, DCX_USESTYLE);
     if (!hdc)
         return;
+
+    // FIXME: use a less cheesy way to calculate the size of the bitmap!
 
     psurf = SURFACE_ShareLockSurface(hBm);
     if (!psurf)
@@ -165,7 +167,7 @@
     bi.bmiHeader.biYPelsPerMeter = 0;
     bi.bmiHeader.biClrUsed = 0;
 
-    NtGdiGetDIBitsInternal(hdc, hBm, 0, bm.bmHeight, NULL, &bi, DIB_RGB_COLORS, 0, 0);
+    GreGetDIBitsInternal(hdc, hBm, 0, bm.bmHeight, NULL, &bi, DIB_RGB_COLORS, 0, 0);
 
     pMemObj = (PCLIPBOARDDATA)UserCreateObject(gHandleTable, NULL, &hMem, otClipBoardData,
                                                sizeof(BITMAPINFOHEADER) + bi.bmiHeader.biSizeImage);
@@ -173,7 +175,7 @@
     {
         pMemObj->cbData = sizeof(BITMAPINFOHEADER) + bi.bmiHeader.biSizeImage;
         memcpy(pMemObj->Data, &bi, sizeof(BITMAPINFOHEADER));
-        NtGdiGetDIBitsInternal(hdc, hBm, 0, bm.bmHeight, (LPBYTE)pMemObj->Data + sizeof(BITMAPINFOHEADER), &bi, DIB_RGB_COLORS, 0, 0);
+        GreGetDIBitsInternal(hdc, hBm, 0, bm.bmHeight, (LPBYTE)pMemObj->Data + sizeof(BITMAPINFOHEADER), &bi, DIB_RGB_COLORS, 0, 0);
         IntAddFormatedData(pWinStaObj, CF_DIB, hMem, TRUE, TRUE);
     }
 
@@ -230,6 +232,7 @@
 
     if (hBm)
     {
+        // FIXME: this is broken!
         GreSetObjectOwner(hBm, GDI_OBJ_HMGR_PUBLIC);
         pBmEl->hData = hBm;
     }

Modified: branches/dib_rewrite/win32ss/user/ntuser/misc/file.c
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/user/ntuser/misc/file.c?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/user/ntuser/misc/file.c [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/user/ntuser/misc/file.c [iso-8859-1] Wed May  9 20:36:16 2012
@@ -155,8 +155,8 @@
     NTSTATUS Status = STATUS_SUCCESS;
     HANDLE hFile, hSection;
     BITMAPFILEHEADER *pbmfh;
-    LPBITMAPINFO pbmi;
-    PVOID pvBits;
+  //  LPBITMAPINFO pbmi;
+  //  PVOID pvBits;
     HBITMAP hbmp = 0;
 
     DPRINT("Enter UserLoadImage(%ls)\n", pwszName);
@@ -184,19 +184,23 @@
         return NULL;
     }
 
-    /* Get a pointer to the BITMAPINFO */
-    pbmi = (LPBITMAPINFO)(pbmfh + 1);
-
+__debugbreak();
+#if 0
 	_SEH2_TRY
 	{
 		ProbeForRead(&pbmfh->bfSize, sizeof(DWORD), 1);
 		ProbeForRead(pbmfh, pbmfh->bfSize, 1);
+		cjHeader =
 	}
 	_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 	{
 		Status = _SEH2_GetExceptionCode();
 	}
 	_SEH2_END
+
+    /* Get a pointer to the BITMAPINFO */
+    pbmi = ProbeAndConvertBitmapInfo((LPBITMAPINFO)(pbmfh + 1), cjHeader);
+    (LPBITMAPINFO)(pbmfh + 1);
 
 	if(!NT_SUCCESS(Status))
 	{
@@ -239,8 +243,8 @@
 	{
 		DPRINT1("Unknown file type!\n");
 	}
-
-leave:
+#endif
+//leave:
     /* Unmap our section, we don't need it anymore */
     ZwUnmapViewOfSection(NtCurrentProcess(), pbmfh);
 

Modified: branches/dib_rewrite/win32ss/win32kp.h
URL: http://svn.reactos.org/svn/reactos/branches/dib_rewrite/win32ss/win32kp.h?rev=56555&r1=56554&r2=56555&view=diff
==============================================================================
--- branches/dib_rewrite/win32ss/win32kp.h [iso-8859-1] (original)
+++ branches/dib_rewrite/win32ss/win32kp.h [iso-8859-1] Wed May  9 20:36:16 2012
@@ -57,7 +57,7 @@
 #include "gdi/ntgdi/palette.h"
 #include "gdi/ntgdi/region.h"
 #include "gdi/ntgdi/dc.h"
-#include "gdi/ntgdi/dib.h"
+#include "gdi/ntgdi/dibitmap.h"
 #include "gdi/ntgdi/cliprgn.h"
 #include "gdi/ntgdi/intgdi.h"
 #include "gdi/ntgdi/paint.h"




More information about the Ros-diffs mailing list