Changeset 10373 for trunk/src

Timestamp:

Jan 11, 2004, 12:42:14 PM (22 years ago)

Author:

sandervl

Message:

Update

Location:

trunk/src/gdi32

Files:

• blit.cpp (modified) (16 diffs)
• dbglocal.cpp (modified) (2 diffs)
• dbglocal.h (modified) (2 diffs)
• dbgwrap.cpp (modified) (6 diffs)
• devcontext.cpp (added)
• dibitmap.cpp (modified) (9 diffs)
• dibsect.cpp (modified) (20 diffs)
• dibsect.h (modified) (7 diffs)
• font.cpp (modified) (28 diffs)
• font.h (modified) (1 diff)
• fontres.cpp (added)
• ft2supp.cpp (added)

trunk/src/gdi32/blit.cpp

@@ -1 @@
-/* $Id: blit.cpp,v 1.45 2003-07-16 10:46:16 sandervl Exp $ */
+/* $Id: blit.cpp,v 1.46 2004-01-11 11:42:08 sandervl Exp $ */
 
 /*
@@ -17 +17 @@
 #include <winuser32.h>
 #include <dbglog.h>
+#include "oslibgpi.h"
+#include <dcdata.h>
 #include "dibsect.h"
 #include "rgbcvt.h"
@@ -48 +50 @@
             rc  = dsect->BitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
                                 nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, dwRop);
-            return rc;
+            goto blitdone;
         }
     }
     rc = O32_StretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, dwRop);
-    if(DIBSection::getSection() != NULL) {
-        DIBSection *destdib = DIBSection::findHDC(hdcDest);
-        if(destdib) {
-            destdib->sync(hdcDest, nYOriginDest, nHeightDest);
-        }
-    }
+
+blitdone:
+    DIBSECTION_MARK_INVALID(hdcDest);
+
     if(rc == FALSE) {
         dprintf(("!WARNING!: GDI32: StretchBlt returned FALSE; last error %x", rc, GetLastError()));
@@ -78 +78 @@
 
 #ifdef DEBUG
-      POINT point1, point2;
+    POINT point1, point2;
     GetViewportOrgEx(hdcDest, &point1);
     GetViewportOrgEx(hdcSrc, &point2);
@@ -90 +90 @@
         if(dsect) 
         {
-            return dsect->BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, nXSrc, nYSrc, nWidth, nHeight, dwRop);
+            rc = dsect->BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, nXSrc, nYSrc, nWidth, nHeight, dwRop);
+            goto blitdone;
         }
     }
@@ -98 +99 @@
     rc = O32_BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight, hdcSrc, nXSrc, nYSrc, dwRop);
 
-    if(DIBSection::getSection() != NULL) {
-        DIBSection *destdib = DIBSection::findHDC(hdcDest);
-        if(destdib) {
-            destdib->sync(hdcDest, nYDest, nHeight);
-        }
-    }
+blitdone:
+    DIBSECTION_MARK_INVALID(hdcDest);
     return rc;
 }
@@ -193 +190 @@
     }
     if(startscan != 0 || lines != info->bmiHeader.biHeight) {
-            dprintf(("WARNING: SetDIBitsToDevice startscan != 0 || lines != info->bmiHeader.biHeight"));
+        dprintf(("WARNING: SetDIBitsToDevice startscan != 0 || lines != info->bmiHeader.biHeight"));
         dprintf(("info bmp (%d,%d)", info->bmiHeader.biWidth, info->bmiHeader.biHeight));
     }
@@ -209 +206 @@
         result = info->bmiHeader.biHeight;
 
-        DIBSection *destdib = DIBSection::findHDC(hdc);
-        if(destdib) {
-                if(cx == info->bmiHeader.biWidth && cy == info->bmiHeader.biHeight &&
-                   destdib->GetBitCount() == info->bmiHeader.biBitCount &&
-                   destdib->GetBitCount() == 8) 
-                {
-                        destdib->sync(xDest, yDest, cx, cy, (PVOID)bits);
-                }
-                else    destdib->sync(hdc, yDest, cy);
-        }
+        DIBSECTION_MARK_INVALID(hdc);
     }
     dprintf(("GDI32: SetDIBitsToDevice hdc:%X xDest:%d yDest:%d, cx:%d, cy:%d, xSrc:%d, ySrc:%d, startscan:%d, lines:%d \nGDI32: bits 0x%X, info 0x%X, coloruse %d returned %d",
-                 hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (LPVOID) bits, (PBITMAPINFO)info, coloruse, result));
+              hdc, xDest, yDest, cx, cy, xSrc, ySrc, startscan, lines, (LPVOID) bits, (PBITMAPINFO)info, coloruse, result));
     dprintf(("GDI32: SetDIBitsToDevice %d %d %d %d %x %d", info->bmiHeader.biWidth, info->bmiHeader.biHeight, info->bmiHeader.biPlanes, info->bmiHeader.biBitCount, info->bmiHeader.biCompression, info->bmiHeader.biSizeImage));
 
@@ -358 +346 @@
     rc = O32_PatBlt(hdc,nXLeft,nYLeft,nWidth,nHeight,dwRop);
     if(rc) {
-        DIBSection *destdib = DIBSection::findHDC(hdc);
-        if(destdib) {
-                    destdib->sync(hdc, nYLeft, nHeight);
-            }
+        DIBSECTION_MARK_INVALID(hdc);
     }
     return(rc);
@@ -367 +352 @@
 //******************************************************************************
 //******************************************************************************
-BOOL WIN32API MaskBlt( HDC arg1, int arg2, int arg3, int arg4, int arg5, HDC   arg6, int arg7, int arg8, HBITMAP arg9, int arg10, int arg11, DWORD  arg12)
-{
-    return O32_MaskBlt(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+BOOL WIN32API MaskBlt( HDC hdcDest, int arg2, int arg3, int arg4, int arg5, HDC hdcSrc, int arg7, int arg8, HBITMAP arg9, int arg10, int arg11, DWORD  arg12)
+{
+    BOOL ret;
+
+    DIBSECTION_CHECK_IF_DIRTY(hdcSrc);
+
+    ret = O32_MaskBlt(hdcDest, arg2, arg3, arg4, arg5, hdcSrc, arg7, arg8, arg9, arg10, arg11, arg12);
+    if(ret) {
+        DIBSECTION_MARK_INVALID(hdcDest);
+    }
+    return ret;
 }
 //******************************************************************************
@@ -426 +419 @@
         //Open32 always returns height of bitmap (regardless of how many scanlines were copied)
         if(rc != heightSrc && rc != infoLoc->bmiHeader.biHeight) {
-                    dprintf(("StretchDIBits failed with rc %x", rc));
+            dprintf(("StretchDIBits failed with rc %x", rc));
         }
-            else {
-                    rc = heightSrc;
-
-                    DIBSection *destdib = DIBSection::findHDC(hdc);
-                    if(destdib) {
-                        if(widthDst == widthSrc && heightDst == heightSrc &&
-                            destdib->GetBitCount() == infoLoc->bmiHeader.biBitCount &&
-                            destdib->GetBitCount() == 8) 
-                {
-                                    destdib->sync(xDst, yDst, widthDst, heightDst, (PVOID)bits);
-                            }
-                            else        destdib->sync(hdc, yDst, heightDst);
-                    }
-            }
+        else {
+            rc = heightSrc;
+
+            DIBSECTION_MARK_INVALID(hdc);
+        }
     
         return rc;
@@ -489 +473 @@
 
     rc = O32_StretchDIBits(hdc, xDst, yDst, widthDst, heightDst, xSrc, ySrc,
-                             widthSrc, heightSrc, (void *)bits,
-                             (PBITMAPINFO)info, wUsage, dwRop);
+                           widthSrc, heightSrc, (void *)bits,
+                           (PBITMAPINFO)info, wUsage, dwRop);
 
     if(compression == BI_BITFIELDS) {
@@ -505 +489 @@
             rc = heightSrc;
 
-            DIBSection *destdib = DIBSection::findHDC(hdc);
-            if(destdib) {
-                if(widthDst == widthSrc && heightDst == heightSrc &&
-                    destdib->GetBitCount() == info->bmiHeader.biBitCount &&
-                    destdib->GetBitCount() == 8) 
-            {
-                             destdib->sync(xDst, yDst, widthDst, heightDst, (PVOID)bits);
-                    }
-                    else destdib->sync(hdc, yDst, heightDst);
-            }
+            DIBSECTION_MARK_INVALID(hdc);
     }
 
@@ -526 +501 @@
                            const BITMAPINFO *info, UINT wUsage, DWORD dwRop )
 {
-
     if(info->bmiHeader.biHeight < 0) {
         // upside down
@@ -563 +537 @@
 int WIN32API SetStretchBltMode( HDC arg1, int  arg2)
 {
+#ifdef DEBUG
     if(DIBSection::getSection() != NULL)
     {
@@ -571 +546 @@
         }
     }
+#endif
     return O32_SetStretchBltMode(arg1, arg2);
 }

trunk/src/gdi32/dbglocal.cpp

@@ -1 @@
-/* $Id: dbglocal.cpp,v 1.9 2002-11-26 10:53:07 sandervl Exp $ */
+/* $Id: dbglocal.cpp,v 1.10 2004-01-11 11:42:08 sandervl Exp $ */
 
 /*
@@ -43 +43 @@
 "printer",
 "icm",
-"trace"
+"trace",
+"fontres",
+"devcontext"
 };
 //******************************************************************************

trunk/src/gdi32/dbglocal.h

@@ -1 @@
-/* $Id: dbglocal.h,v 1.8 2002-11-26 10:53:07 sandervl Exp $ */
+/* $Id: dbglocal.h,v 1.9 2004-01-11 11:42:09 sandervl Exp $ */
 
 /*
@@ -42 +42 @@
 #define DBG_icm             20
 #define DBG_trace           21
-#define DBG_MAXFILES        22
+#define DBG_fontres         22
+#define DBG_devcontext      23
+#define DBG_MAXFILES        24
 
 extern USHORT DbgEnabledGDI32[DBG_MAXFILES];

trunk/src/gdi32/dbgwrap.cpp

@@ -90 +90 @@
 DEBUGWRAP20(IntersectClipRect)
 DEBUGWRAP8(GetRgnBox)
-DEBUGWRAP12(GetRandomRgn)
 NODEF_DEBUGWRAP8(GetMetaRgn)
 DEBUGWRAP8(GetClipRgn)
 DEBUGWRAP20(FrameRgn)
 DEBUGWRAP12(FillRgn)
+DEBUGWRAP12(GetRandomRgn)
 DEBUGWRAP12(ExtSelectClipRgn)
 DEBUGWRAP8(EqualRgn)
@@ -214 +214 @@
 DEBUGWRAP_LVL2_4(GetObjectType)
 DEBUGWRAP12(GetObjectW)
-DEBUGWRAP4(GetStockObject)
+DEBUGWRAP_LVL2_4(GetStockObject)
 DEBUGWRAP_LVL2_8(SelectObject)
 NODEF_DEBUGWRAP8(SetObjectOwner)
@@ -295 +295 @@
 DEBUGWRAP4(CreateColorSpaceA)
 DEBUGWRAP4(CreateColorSpaceW)
-DEBUGWRAP4(CreateCompatibleDC)
-DEBUGWRAP16(CreateDCA)
-DEBUGWRAP16(CreateDCW)
 DEBUGWRAP8(CreateDIBPatternBrush)
 DEBUGWRAP8(CreateDIBPatternBrushPt)
 DEBUGWRAP8(CreateHatchBrush)
-DEBUGWRAP16(CreateICA)
-DEBUGWRAP16(CreateICW)
 DEBUGWRAP4(CreatePatternBrush)
 DEBUGWRAP12(CreatePen)
@@ -309 +304 @@
 DEBUGWRAP12(DPtoLP)
 DEBUGWRAP4(DeleteColorSpace)
-DEBUGWRAP4(DeleteDC)
 DEBUGWRAP16(DescribePixelFormat)
 //;    DeviceCapabilitiesEx       = _DeviceCapabilitiesEx@??    @177
@@ -356 +350 @@
 NODEF_DEBUGWRAP8(GetDeviceGammaRamp)
 DEBUGWRAP12(GetKerningPairsA)
-DEBUGWRAP12(GetKerningPairsW)
 NODEF_DEBUGWRAP12(GetLogColorSpaceA)
 NODEF_DEBUGWRAP12(GetLogColorSpaceW)
@@ -423 +416 @@
 DEBUGWRAP4(UpdateColors)
 DEBUGWRAP4(WidenPath)
+
+
+#undef DBG_LOCALLOG
+#define DBG_LOCALLOG    DBG_devcontext
+
+DEBUGWRAP4(CreateCompatibleDC)
+DEBUGWRAP16(CreateDCA)
+DEBUGWRAP16(CreateDCW)
+DEBUGWRAP16(CreateICA)
+DEBUGWRAP16(CreateICW)
+DEBUGWRAP4(DeleteDC)

trunk/src/gdi32/dibitmap.cpp

@@ -1 @@
-/* $Id: dibitmap.cpp,v 1.41 2003-07-16 10:46:17 sandervl Exp $ */
+/* $Id: dibitmap.cpp,v 1.42 2004-01-11 11:42:10 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Patrick Haller
+ * Copyright 2002-2003 Innotek Systemberatung GmbH (sandervl@innotek.de)
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -320 +321 @@
     if(dsect)
     {
-        return(dsect->SetDIBColorTable(uStartIndex, cEntries, pColors));
+         return(dsect->SetDIBColorTable(uStartIndex, cEntries, pColors));
     }
     else return(0);
@@ -326 +327 @@
 //******************************************************************************
 //******************************************************************************
-LONG WIN32API GetBitmapBits( HBITMAP hBitmap, LONG arg2, PVOID  arg3)
+LONG WIN32API GetBitmapBits( HBITMAP hBitmap, LONG arg2, PVOID lpvBits)
 {
     dprintf(("GDI32: GetBitmapBits %x", hBitmap));
-    return O32_GetBitmapBits(hBitmap, arg2, arg3);
+
+    if(lpvBits)
+    {
+        DIBSECTION_CHECK_IF_DIRTY_BMP(hBitmap);
+    }
+    return O32_GetBitmapBits(hBitmap, arg2, lpvBits);
 }
 //******************************************************************************
@@ -335 +341 @@
 LONG WIN32API SetBitmapBits( HBITMAP hBitmap, LONG arg2, const VOID *  arg3)
 {
+    LONG ret;
+
     dprintf(("GDI32: SetBitmapBits %x", hBitmap));
-    return O32_SetBitmapBits(hBitmap, (DWORD)arg2, arg3);
+    ret = O32_SetBitmapBits(hBitmap, (DWORD)arg2, arg3);
+    DIBSECTION_MARK_INVALID_BMP(hBitmap);
+    return ret;
 }
 //******************************************************************************
@@ -364 +374 @@
     dprintf(("GDI32: GetDIBits %x %x %d %d %x %x (biBitCount %d) %d", hdc, hBitmap, uStartScan, cScanLines, lpvBits, lpbi, lpbi->bmiHeader.biBitCount, uUsage));
 
-#if 0
-    if(lpvBits && DIBSection::getSection() != NULL)
-    {
-        DIBSection *dsect;
-
-        dsect = DIBSection::findObj(hBitmap);
-        if(dsect) {
-             char *bmpBits = dsect->GetDIBObject();
-
-             if(lpbi->bmiHeader.biBitCount == dsect->GetBitCount() && 
-                lpbi->bmiHeader.biWidth > 0) 
-             {
-                 LONG lLineByte;
-
-                 dprintf(("Quick copy from DIB section memory"));
-                 lLineByte = DIB_GetDIBWidthBytes(lpbi->bmiHeader.biWidth, lpbi->bmiHeader.biBitCount);
-                 
-                 memcpy(lpvBits, bmpBits+(uStartScan*lLineByte), cScanLines*lLineByte);
-                 return cScanLines;
-             }
-        }
-    }
-#endif
+    if(lpvBits)
+    {
+        DIBSECTION_CHECK_IF_DIRTY_BMP(hBitmap);
+    }
 
     //SvL: WGSS screws up the DC if it's a memory DC
@@ -397 +388 @@
     }
     if(pHps->isMemoryPS) {
-          hdcMem = CreateCompatibleDC(0);
-    }
-    else  hdcMem = hdc;
+         hdcMem = CreateCompatibleDC(0);
+    }
+    else hdcMem = hdc;
 
     if(lpvBits) {
@@ -547 +538 @@
         ret = O32_SetBitmapBits(hBitmap, pBitmapInfo->bmiHeader.biSizeImage, newpix);
 
+        DIBSECTION_MARK_INVALID_BMP(hBitmap);
+
         free(newpix);
         return ret;
@@ -624 +617 @@
     if(newbits) free(newbits);
 
-    if(DIBSection::getSection() != NULL)
-    {
-        DIBSection *dsect;
-
-        dsect = DIBSection::findObj(hBitmap);
-        if(dsect) {
-             HBITMAP hBmpOld = SelectObject(hdc, hBitmap);
-             dsect->sync(hdc, 0, dsect->GetHeight());
-             SelectObject(hdc, hBmpOld);
-        }
-    }
+    DIBSECTION_MARK_INVALID_BMP(hBitmap);
 
     return ret;

trunk/src/gdi32/dibsect.cpp

@@ -1 @@
-/* $Id: dibsect.cpp,v 1.67 2003-07-16 10:46:17 sandervl Exp $ */
+/* $Id: dibsect.cpp,v 1.68 2004-01-11 11:42:10 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Patrick Haller
+ * Copyright 2002-2003 Innotek Systemberatung GmbH (sandervl@innotek.de)
  *
  * Project Odin Software License can be found in LICENSE.TXT
  *
- * NOTE:
- * This is not a complete solution for CreateDIBSection, but enough for Quake 2!
+ * Basic GPI object and bitmap data synchronization:
+ *
+ * - CreateDIBSection:
+ *      register a memory range for exception notification
+ *      set to read/commit during creation
+ *
+ * - if(exception)
+ *      if(invalid)
+ *         sync and set to commit/read, clear invalid flag
+ *      if(write violation) 
+ *         make as dirty and set range to read/write
+ *
+ * - before GDI operation
+ *       if(dirty) 
+ *           flush (set bitmap bits), clear dirty flag, set range to readonly
+ *
+ * - after GDI operation
+ *       set invalid flag, set range to invalid
+ *
+ * - GdiFlush: 
+ *       NOP
+ *
+ * Should probably detect partial changes to avoid having to sync the entire
+ * DIB section each time something minor changes.
+ *
+ * Might get a little bit more complicated when the application gives us a memory
+ * mapped file handle. (although we can change the protection flags of aliased pages)
  *
  */
@@ -27 +53 @@
 #include "oslibgpi.h"
 #include "rgbcvt.h"
+#include <memmap.h>
 
 #define DBG_LOCALLOG  DBG_dibsect
 #include "dbglocal.h"
 
-
-//******************************************************************************
-//******************************************************************************
-DIBSection::DIBSection(BITMAPINFOHEADER_W *pbmi, char *pColors, DWORD iUsage, DWORD hSection, DWORD dwOffset, DWORD handle, int fFlip)
+static BOOL WIN32API DIBExceptionNotify(LPVOID lpBase, ULONG offset, BOOL fWriteAccess, 
+                                        DWORD dwSize, DWORD dwUserData);
+
+
+//******************************************************************************
+//******************************************************************************
+DIBSection::DIBSection(BITMAPINFOHEADER_W *pbmi, char *pColors, DWORD iUsage, DWORD hSection, DWORD dwOffset, HBITMAP hBitmap, int fFlip)
                 : bmpBits(NULL), pOS2bmp(NULL), next(NULL), bmpBitsDblBuffer(NULL),
-                  hdc(0), hwndParent(0)
+                  hdc(0), hwndParent(0), fDirty(FALSE), fInvalid(FALSE), dwSize(0)
 {
  int  palsize=0;
@@ -90 +120 @@
    }
    if(!bmpBits) {
-        DosAllocMem((PPVOID)&bmpBits, bmpsize*pbmi->biHeight, PAG_READ|PAG_WRITE|PAG_COMMIT);
-   }
-   memset(bmpBits, 0, bmpsize*pbmi->biHeight);
+        APIRET rc = DosAllocMem((PPVOID)&bmpBits, bmpsize*pbmi->biHeight, PAG_READ|PAG_COMMIT);
+        if(rc) {
+            dprintf(("DosAllocMem failed with %d", rc));
+            DebugInt3();
+        }
+        if(MMAP_RegisterMemoryRange(DIBExceptionNotify, bmpBits, bmpsize*pbmi->biHeight, hBitmap) == FALSE) 
+        {
+            dprintf(("MMAP_RegisterMemoryRange failed!!"));
+            DebugInt3();
+        }
+        dwSize = bmpsize*pbmi->biHeight;
+   }
+   else memset(bmpBits, 0, bmpsize*pbmi->biHeight);
 
    pOS2bmp = (BITMAPINFO2 *)malloc(os2bmphdrsize);
@@ -111 +151 @@
    }
    pOS2bmp->cbImage       = pbmi->biSizeImage;
-   dprintf(("handle                 %x", handle));
+   dprintf(("hBitmap                %x", hBitmap));
    dprintf(("pOS2bmp->cx            %d\n", pOS2bmp->cx));
    dprintf(("pOS2bmp->cy            %d\n", pOS2bmp->cy));
@@ -169 +209 @@
    }
 
-   this->handle = handle;
+   this->hBitmap = hBitmap;
    this->iUsage = iUsage;
 
@@ -197 +237 @@
 DIBSection::~DIBSection()
 {
-   dprintf(("Delete DIBSection %x", handle));
+   dprintf(("Delete DIBSection %x", hBitmap));
 
    if(hSection) {
-        UnmapViewOfFile(bmpBits);
-   }
-   else
-   if(bmpBits)
-        DosFreeMem(bmpBits);
+       UnmapViewOfFile(bmpBits);
+   }
+   else 
+   {
+       if(MMAP_UnregisterMemoryRange(bmpBits) == FALSE) 
+       {
+           dprintf(("MMAP_UnregisterMemoryRange failed!!"));
+           DebugInt3();
+       }
+       if(bmpBits)
+           DosFreeMem(bmpBits);
+   }
 
    if(bmpBitsDblBuffer)
-        DosFreeMem(bmpBitsDblBuffer);
+       DosFreeMem(bmpBitsDblBuffer);
 
    if(pOS2bmp)
-        free(pOS2bmp);
+       free(pOS2bmp);
 
    lock();
    if(section == this)
    {
-     section = this->next;
+       section = this->next;
    }
    else
    {
-     DIBSection *dsect = section;
-
-     while(dsect->next != this)
-     {
-       dsect = dsect->next;
-     }
-     dsect->next = this->next;
+       DIBSection *dsect = section;
+
+       while(dsect->next != this)
+       {
+           dsect = dsect->next;
+       }
+       dsect->next = this->next;
    }
    unlock();
-}
-//******************************************************************************
-//******************************************************************************
-int DIBSection::SetDIBits(HDC hdc, HBITMAP hbitmap, UINT startscan, UINT
-                          lines, const VOID *bits, BITMAPINFOHEADER_W *pbmi,
-                          UINT coloruse)
-{
-  lines = (int)lines >= 0 ? (int)lines : (int)-lines;
-  int  palsize=0;
-
-  bmpsize = pbmi->biWidth;
-  os2bmphdrsize = sizeof(BITMAPINFO2);
-
-  switch(pbmi->biBitCount)
-  {
-    case 1:
-      bmpsize = ((bmpsize + 31) & ~31) / 8;
-      palsize = ((1 << pbmi->biBitCount))*sizeof(RGB2);
-      os2bmphdrsize += palsize;
-      break;
-    case 4:
-      bmpsize = ((bmpsize + 7) & ~7) / 2;
-      palsize = ((1 << pbmi->biBitCount))*sizeof(RGB2);
-      os2bmphdrsize += palsize;
-      break;
-    case 8:
-      palsize = ((1 << pbmi->biBitCount))*sizeof(RGB2);
-      os2bmphdrsize += palsize;
-      bmpsize = (bmpsize + 3) & ~3;
-      break;
-    case 16:
-      bmpsize *= 2;
-      bmpsize = (bmpsize + 3) & ~3;
-      break;
-    case 24:
-      bmpsize *= 3;
-      bmpsize = (bmpsize + 3) & ~3;
-      break;
-    case 32:
-      bmpsize *= 4;
-      break;
-   }
-
-   //SvL: TODO: Correct??
-   if(!hSection && pOS2bmp->cx != pbmi->biWidth && pOS2bmp->cy != pbmi->biHeight &&
-      pOS2bmp->cBitCount != pbmi->biBitCount)
-   {
-        char *oldbits = bmpBits;
-        int oldsize = dibinfo.dsBm.bmWidthBytes * dibinfo.dsBm.bmHeight;
-
-        DosAllocMem((PPVOID)&bmpBits, bmpsize*pbmi->biHeight, PAG_READ|PAG_WRITE|PAG_COMMIT);
-        memcpy(bmpBits, oldbits, min(oldsize, bmpsize*pbmi->biHeight));
-        DosFreeMem(oldbits);
-   }
-   pOS2bmp    = (BITMAPINFO2 *)realloc(pOS2bmp, os2bmphdrsize);
-   pOS2bmp->cbFix         = sizeof(BITMAPINFO2) - sizeof(RGB2);
-   pOS2bmp->cx            = pbmi->biWidth;
-   pOS2bmp->cy            = pbmi->biHeight;
-   pOS2bmp->cPlanes       = pbmi->biPlanes;
-   pOS2bmp->cBitCount     = pbmi->biBitCount;
-   pOS2bmp->ulCompression = pbmi->biCompression; //same as OS/2 (uncompressed, rle8, rle4)
-   //SvL: Ignore BI_BITFIELDS_W type (GpiDrawBits fails otherwise)
-   if(pOS2bmp->ulCompression == BI_BITFIELDS_W) {
-        pOS2bmp->ulCompression = 0;
-   }
-   pOS2bmp->cbImage       = pbmi->biSizeImage;
-
-   // clear DIBSECTION structure
-   memset(&dibinfo, 0, sizeof(dibinfo));
-
-   // copy BITMAPINFOHEADER data into DIBSECTION structure
-   memcpy(&dibinfo.dsBmih, pbmi, sizeof(*pbmi));
-   dibinfo.dsBm.bmType      = 0;
-   dibinfo.dsBm.bmWidth     = pbmi->biWidth;
-   dibinfo.dsBm.bmHeight    = pbmi->biHeight;
-   dibinfo.dsBm.bmWidthBytes= bmpsize;
-   dibinfo.dsBm.bmPlanes    = pbmi->biPlanes;
-   dibinfo.dsBm.bmBitsPixel = pbmi->biBitCount;
-   dibinfo.dsBm.bmBits      = bmpBits;
-
-   dibinfo.dshSection       = hSection;
-   dibinfo.dsOffset         = dwOffset;
-
-   if(coloruse == DIB_PAL_COLORS || pbmi->biBitCount <= 8)
-   {
-        dibinfo.dsBitfields[0] = dibinfo.dsBitfields[1] = dibinfo.dsBitfields[2] = 0;
-   }
-   else {
-        char *pColors = (char *)pbmi + 1;
-
-        switch(pbmi->biBitCount)
-        {
-           case 16:
-                dibinfo.dsBitfields[0] = (pbmi->biCompression == BI_BITFIELDS_W) ? *(DWORD *)pColors : 0x7c00;
-                dibinfo.dsBitfields[1] = (pbmi->biCompression == BI_BITFIELDS_W) ? *((DWORD *)pColors + 1) : 0x03e0;
-                dibinfo.dsBitfields[2] = (pbmi->biCompression == BI_BITFIELDS_W) ? *((DWORD *)pColors + 2) : 0x001f;
-                break;
-
-           case 24:
-           case 32:
-                dibinfo.dsBitfields[0] = (pbmi->biCompression == BI_BITFIELDS_W) ? *(DWORD *)pColors       : 0xff0000;
-                dibinfo.dsBitfields[1] = (pbmi->biCompression == BI_BITFIELDS_W) ? *((DWORD *)pColors + 1) : 0x00ff00;
-                dibinfo.dsBitfields[2] = (pbmi->biCompression == BI_BITFIELDS_W) ? *((DWORD *)pColors + 2) : 0x0000ff;
-                if(dibinfo.dsBitfields[0] != 0xff0000 && dibinfo.dsBitfields[1] != 0xff00 && dibinfo.dsBitfields[2] != 0xff) {
-                    dprintf(("DIBSection: unsupported bitfields for 32 bits bitmap!!"));
-                }
-                break;
-        }
-        dprintf(("BI_BITFIELDS_W %x %x %x", dibinfo.dsBitfields[0], dibinfo.dsBitfields[1], dibinfo.dsBitfields[2]));
-   }
-
-   //double buffer for rgb 555 dib sections (for conversion) or flipped sections
-   if(dibinfo.dsBitfields[1] == 0x03e0 || (fFlip & FLIP_VERT)) {
-        if(bmpBitsDblBuffer) {
-            DosFreeMem(bmpBitsDblBuffer);
-        }
-        DosAllocMem((PPVOID)&bmpBitsDblBuffer, dibinfo.dsBm.bmWidthBytes*pbmi->biHeight, PAG_READ|PAG_WRITE|PAG_COMMIT);
-   }
-
-   dprintf(("DIBSection::SetDIBits (%d,%d), %d %d", pbmi->biWidth, pbmi->biHeight, pbmi->biBitCount, pbmi->biCompression));
-   if(palsize) {
-        SetDIBColorTable(0, (pbmi->biClrUsed) ? pbmi->biClrUsed : (1 << pbmi->biBitCount), (RGBQUAD *)(pbmi+1));
-   }
-
-   if(bits)
-   {
-      if(pOS2bmp->ulCompression == BCA_UNCOMP) {
-          int size = bmpsize*lines;
-          memcpy(bmpBits+bmpsize*startscan, bits, size);
-      }
-      else {
-          dprintf(("Compressed image!!"));
-          if(startscan != 0) {
-               dprintf(("WARNING: Compressed image & startscan != 0!!!!"));
-          }
-          memcpy(bmpBits, bits, pbmi->biSizeImage);
-      }
-   }
-   return(lines);
 }
 //******************************************************************************
@@ -472 +380 @@
 
   dprintf(("DIBSection::BitBlt %x %X (hps %x) %x to(%d,%d)(%d,%d) from (%d,%d)(%d,%d) rop %x flip %x",
-          handle, hdcDest, hps, hwndDest, nXdest, nYdest, nDestWidth, nDestHeight,
+          hBitmap, hdcDest, hps, hwndDest, nXdest, nYdest, nDestWidth, nDestHeight,
           nXsrc, nYsrc, nSrcWidth, nSrcHeight, Rop, fFlip));
+
+  //shortcut; better to sync it here instead of in the exception handler
+  //(pages touched inside PMGPI)
+  if(isInvalid()) {
+      sync();
+  }
 
   if(hwndDest) {
@@ -637 +551 @@
   }
   if(rc == GPI_OK) {
-        DIBSection *destdib = DIBSection::findHDC(hdcDest);
-        if(destdib) {
-            destdib->sync(hps, nYdest, nDestHeight, FALSE);
-        }
 #ifdef INVERT
         //restore old y inversion height
@@ -664 +574 @@
  char  *destBuf;
 
-  dprintf(("Sync destination dibsection %x (%x) (%d,%d) flip %d", handle, hdc, nYdest, nDestHeight, fFlip));
+  dprintf(("Sync destination dibsection %x (%x) (%d,%d) flip %d", hBitmap, hdc, nYdest, nDestHeight, fFlip));
 
   BITMAPINFO2 *tmphdr = (BITMAPINFO2 *)malloc(os2bmphdrsize);
@@ -692 +602 @@
   if(fFlip & FLIP_VERT) {
 #endif
+        //origin is top left, so no y conversion is necessary
         destBuf = bmpBitsDblBuffer + nYdest*dibinfo.dsBm.bmWidthBytes;
 
@@ -729 +640 @@
         tmphdr->cbImage = dibinfo.dsBm.bmHeight*dibinfo.dsBm.bmWidthBytes;
 
-        destBuf = GetDIBObject() + nYdest*dibinfo.dsBm.bmWidthBytes;
-
+        //origin is bottom left, nYdest is based on top left coordinate system
 #ifdef INVERT
         int dest = dibinfo.dsBm.bmHeight - nYdest - nDestHeight;
@@ -736 +646 @@
         int dest = nYdest;
 #endif
-        rc = GpiQueryBitmapBits(hdc, nYdest, nDestHeight, destBuf,
+
+        destBuf = GetDIBObject() + dest*dibinfo.dsBm.bmWidthBytes;
+
+        rc = GpiQueryBitmapBits(hdc, dest, nDestHeight, destBuf,
                                 tmphdr);
         if(rc == GPI_ALTERROR) {
@@ -769 +682 @@
 #endif
 
+}
+//******************************************************************************
+//******************************************************************************
+void DIBSection::flush(HDC hdc, DWORD nYdest, DWORD nDestHeight, BOOL orgYInversion)
+{
+ APIRET rc;
+ char  *destBuf;
+
+  dprintf(("flush destination dibsection %x (%x) (%d,%d) flip %d", hBitmap, hdc, nYdest, nDestHeight, fFlip));
+
+#ifdef INVERT
+  int oldyinversion = 0;
+  if(orgYInversion == TRUE) {
+      oldyinversion = GpiQueryYInversion(hdc);
+      dprintf(("Flush destination dibsection: hdc y inversion = %d", oldyinversion));
+      if(oldyinversion != 0) {
+#ifdef DEBUG
+          POINT point;
+          GetViewportOrgEx(hdc, &point);
+          dprintf(("Viewport origin (%d,%d)", point.x, point.y));
+#endif
+          GpiEnableYInversion(hdc, 0);
+      }
+  }
+#else
+  dprintf(("flush destination dibsection: hdc y inversion = %d", GpiQueryYInversion(hdc)));
+#endif
+
+#ifndef INVERT
+  if(!(fFlip & FLIP_VERT)) {
+#else
+  if(fFlip & FLIP_VERT) {
+#endif
+        //origin is top left, so no y conversion is necessary
+        destBuf = bmpBitsDblBuffer + nYdest*dibinfo.dsBm.bmWidthBytes;
+
+        //SvL: cbImage can be too small for compressed images; GpiQueryBitmapBits
+        //     will fail in that case (CoolEdit 2000). Perhaps because the returned
+        //     compressed image is larger than the original.
+        //     Use uncompressed size instead
+        //     NOTE: The correct size will be returned by GpiQueryBitmapBits
+        pOS2bmp->cbImage = dibinfo.dsBm.bmHeight*dibinfo.dsBm.bmWidthBytes;
+
+        //manually reverse bitmap data
+        char *src = GetDIBObject() + (nYdest+nDestHeight-1)*dibinfo.dsBm.bmWidthBytes;
+        char *dst = destBuf;
+        for(int i=0;i<nDestHeight;i++) {
+            memcpy(dst, src, dibinfo.dsBm.bmWidthBytes);
+            dst += dibinfo.dsBm.bmWidthBytes;
+            src -= dibinfo.dsBm.bmWidthBytes;
+        }
+
+        if(dibinfo.dsBitfields[1] == 0x3E0) {//RGB 555?
+            dprintf(("DIBSection::flush: convert RGB 565 to RGB 555"));
+
+            pRGB565to555((WORD *)destBuf, (WORD *)destBuf, (nDestHeight*dibinfo.dsBm.bmWidthBytes)/sizeof(WORD));
+        }
+
+#ifdef INVERT
+        int dest = dibinfo.dsBm.bmHeight - nYdest - nDestHeight;
+#else
+        int dest = nYdest;
+#endif
+        rc = GpiSetBitmapBits(hdc, dest, nDestHeight, destBuf,
+                              pOS2bmp);
+        if(rc == GPI_ALTERROR) {
+            dprintf(("ERROR: GpiQueryBitmapBits failed with %x", WinGetLastError(0)));
+        }
+
+  }
+  else {
+        //SvL: cbImage can be too small for compressed images; GpiQueryBitmapBits
+        //     will fail in that case (CoolEdit 2000). Perhaps because the returned
+        //     compressed image is larger than the original.
+        //     Use uncompressed size instead
+        //     NOTE: The correct size will be returned by GpiQueryBitmapBits
+        pOS2bmp->cbImage = dibinfo.dsBm.bmHeight*dibinfo.dsBm.bmWidthBytes;
+
+        //origin is bottom left, nYdest is based on top left coordinate system
+#ifdef INVERT
+        int dest = dibinfo.dsBm.bmHeight - nYdest - nDestHeight;
+#else
+        int dest = nYdest;
+#endif
+
+        destBuf = GetDIBObject() + dest*dibinfo.dsBm.bmWidthBytes;
+
+        if(dibinfo.dsBitfields[1] == 0x3E0) {//RGB 555?
+            dprintf(("DIBSection::flush: convert RGB 565 to RGB 555"));
+
+            pRGB565to555((WORD *)bmpBitsDblBuffer, (WORD *)destBuf, (nDestHeight*dibinfo.dsBm.bmWidthBytes)/sizeof(WORD));
+            destBuf = bmpBitsDblBuffer;
+        }
+
+        rc = GpiSetBitmapBits(hdc, dest, nDestHeight, destBuf,
+                              pOS2bmp);
+        if(rc == GPI_ALTERROR) {
+            dprintf(("ERROR: GpiQueryBitmapBits failed with %x", WinGetLastError(0)));
+        }
+#ifdef DEBUG_PALETTE
+        if(rc != GPI_ALTERROR && pOS2bmp->cBitCount <= 8) {
+            for(int i=0;i<(1<<pOS2bmp->cBitCount);i++)
+            {
+                dprintf2(("Index %d : 0x%08X\n",i, *((ULONG*)(&pOS2bmp->argbColor[i])) ));
+            }
+        }
+#endif
+  }
+  if(rc != nDestHeight) {
+      dprintf(("!WARNING!: GpiQueryBitmapBits returned %d instead of %d scanlines", rc, nDestHeight));
+  }
+
+#ifdef INVERT
+  if(oldyinversion) GpiEnableYInversion(hdc, oldyinversion);
+#endif
+
+}
+//******************************************************************************
+//Mark the DIB section as invalid; a subsequent read or write access must
+//cause a pagefault
+//******************************************************************************
+void DIBSection::setInvalid()
+{
+    if(!fInvalid) {
+        dprintf(("DIBSection::setInvalid %x (%x)", GetBitmapHandle(), GetDIBObject()));
+        APIRET rc = DosSetMem(bmpBits, dwSize, PAG_DECOMMIT);
+        if(rc) {
+            dprintf(("DIBSection::setInvalid: DosSetMem failed with %d!!", rc));
+            DebugInt3();
+        }
+        fInvalid = TRUE;
+    }
+}
+//******************************************************************************
+//******************************************************************************
+void DIBSection::flush()
+{ 
+    if(pOS2bmp == NULL) {
+        DebugInt3();
+        return;
+    }
+    if(hdc == 0) {
+         HBITMAP hOldBmp;
+         HDC hdcFlush = CreateCompatibleDC(0);
+
+         hOldBmp = SelectObject(hdcFlush, hBitmap);
+         flush(hdcFlush, 0, pOS2bmp->cy); 
+
+         SelectObject(hdcFlush, hOldBmp);
+         DeleteDC(hdcFlush);
+    }
+    else flush(hdc, 0, pOS2bmp->cy); 
+
+    APIRET rc = DosSetMem(bmpBits, dwSize, PAG_READ);
+    if(rc) {
+        dprintf(("DIBSection::flush: DosSetMem failed with %d!!", rc));
+        DebugInt3();
+    }
+    fDirty = FALSE;
+}
+//******************************************************************************
+//******************************************************************************
+void DIBSection::sync() 
+{ 
+    if(pOS2bmp == NULL) {
+        DebugInt3();
+        return;
+    }
+    APIRET rc = DosSetMem(bmpBits, dwSize, PAG_COMMIT|PAG_READ|PAG_WRITE);
+    if(rc) {
+        //might already be committed
+        rc = DosSetMem(bmpBits, dwSize, PAG_READ|PAG_WRITE);
+        if(rc) {
+            dprintf(("DIBSection::sync: DosSetMem failed with %d!!", rc));
+            DebugInt3();
+        }
+    }
+    if(hdc == 0) {
+         HBITMAP hOldBmp;
+         HDC hdcFlush = CreateCompatibleDC(0);
+
+         hOldBmp = SelectObject(hdcFlush, hBitmap);
+         sync(hdcFlush, 0, pOS2bmp->cy); 
+
+         SelectObject(hdcFlush, hOldBmp);
+         DeleteDC(hdcFlush);
+    }
+    else sync(hdc, 0, pOS2bmp->cy); 
+   
+    fInvalid = FALSE;
+
+    //Set bitmap memory to readonly again to detect updates
+    rc = DosSetMem(bmpBits, dwSize, PAG_READ);
+    if(rc) {
+        dprintf(("DosSetMem failed with %d!!", rc));
+        DebugInt3();
+    }
+}
+//******************************************************************************
+//******************************************************************************
+void DIBSection::syncAll()
+{
+  if (!section)
+      return;
+
+  lock();
+  DIBSection *dsect = section;
+
+  do
+  {
+      if(dsect->isDirty() && dsect->isInvalid()) {
+          DebugInt3();
+      }
+      if(dsect->isInvalid())
+      {
+          dsect->sync();
+      }
+      dsect = dsect->next;
+  }
+  while(dsect);
+
+  unlock();
+
+  return;
 }
 //******************************************************************************
@@ -796 +933 @@
   this->hdc  = hdc;
   hwndParent = WindowFromDC(hdc);
-  dprintf(("SelectDIBObject %x into %x hwndParent = %x", handle, hdc, hwndParent));
-}
-//******************************************************************************
-//******************************************************************************
-DIBSection *DIBSection::findObj(HANDLE handle)
+  dprintf(("SelectDIBObject %x into %x hwndParent = %x", hBitmap, hdc, hwndParent));
+}
+//******************************************************************************
+//******************************************************************************
+DIBSection *DIBSection::findObj(HBITMAP hBitmap)
 {
   // PH 2001-08-18 shortcut for performance optimization
@@ -806 +943 @@
       return NULL;
 
+  lock();
   DIBSection *dsect = section;
-  lock();
 
   do
   {
-    if(dsect->handle == handle)
+    if(dsect->hBitmap == hBitmap)
     {
         unlock();
@@ -832 +969 @@
       return NULL;
   
+  lock();
   DIBSection *dsect = section;
   
-  lock();
   do
   {
@@ -851 +988 @@
 //******************************************************************************
 //******************************************************************************
-void DIBSection::deleteSection(HANDLE handle)
-{
- DIBSection *dsect = findObj(handle);
+void DIBSection::deleteSection(HBITMAP hBitmap)
+{
+ DIBSection *dsect = findObj(hBitmap);
 
   if(dsect)
@@ -865 +1002 @@
  LPBITMAP_W  dsBm        = (LPBITMAP_W)lpBuffer;
 
-  dprintf2(("GetDIBSection %x %d %x", handle, iSize, lpBuffer));
+  dprintf2(("GetDIBSection %x %d %x", hBitmap, iSize, lpBuffer));
   if(iSize == sizeof(DIBSECTION))
   {
@@ -917 +1054 @@
 DIBSection      *DIBSection::section = NULL;
 CRITICAL_SECTION DIBSection::dibcritsect;
+
+
+//******************************************************************************
+//******************************************************************************
+static BOOL WIN32API DIBExceptionNotify(LPVOID lpBase, ULONG offset, BOOL fWriteAccess, 
+                                        DWORD dwSize, DWORD dwUserData)
+{
+    DIBSection *dsect;
+    HBITMAP hBitmap = (HBITMAP)dwUserData;
+
+    dprintf(("DIBExceptionNotify %x %x %d %d %x", lpBase, offset, fWriteAccess, dwSize, dwUserData));
+
+    dsect = DIBSection::findObj(hBitmap);
+    if(dsect == NULL) {
+        dprintf(("dib section not found!!"));
+        DebugInt3();
+        return FALSE;
+    }
+    if(dsect->isInvalid()) 
+    {//implies read or write to reserved pages
+        //synchronize bitmap memory and bitmap object
+        dsect->sync();
+    }
+    else
+    if(!fWriteAccess) {
+        APIRET rc = DosSetMem(lpBase, dwSize, PAG_READ|PAG_COMMIT);
+        if(rc) {
+            dprintf(("DosSetMem failed with %d!!", rc));
+            DebugInt3();
+            return FALSE;
+        }
+    }
+
+    if(fWriteAccess) {
+        APIRET rc = DosSetMem(lpBase, dwSize, PAG_READ|PAG_WRITE);
+        if(rc) {
+            dprintf(("DosSetMem failed with %d!!", rc));
+            DebugInt3();
+            return FALSE;
+        }
+        dsect->setDirty();
+    }
+
+
+    return TRUE;
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/gdi32/dibsect.h

@@ -1 @@
-/* $Id: dibsect.h,v 1.27 2003-11-14 17:31:47 sandervl Exp $ */
+/* $Id: dibsect.h,v 1.28 2004-01-11 11:42:11 sandervl Exp $ */
 
 /*
@@ -75 +75 @@
 #endif
 
+//
+//Mark DIB section as invalid (dib section memory is out of sync with
+//GDI bitmap).
+//
+//This must be done for any GDI function that modifies the bitmap
+//
+#define DIBSECTION_MARK_INVALID(hdc)                              \
+    if(DIBSection::getSection() != NULL) {                        \
+        DIBSection *dib = DIBSection::findHDC(hdc);               \
+        if(dib) {                                                 \
+            dib->setInvalid();                                    \
+        }                                                         \
+    }
+
+#define DIBSECTION_MARK_INVALID_BMP(hBitmap)                      \
+    if(DIBSection::getSection() != NULL) {                        \
+        DIBSection *dib = DIBSection::findObj(hBitmap);           \
+        if(dib) {                                                 \
+            dib->setInvalid();                                    \
+        }                                                         \
+    }
+
+//
+//Check if DIB section is marked dirty (bitmap data modified by application)
+//If true, then update the GDI bitmap
+//
+//This must be done for any GDI function that accesses the bitmap
+//
+#define DIBSECTION_CHECK_IF_DIRTY(hdc)                            \
+    if(DIBSection::getSection() != NULL) {                        \
+        DIBSection *dib = DIBSection::findHDC(hdc);               \
+        if(dib && dib->isDirty()) {                               \
+            dib->flush();                                         \
+        }                                                         \
+    }
+
+#define DIBSECTION_CHECK_IF_DIRTY_BMP(hBitmap)                    \
+    if(DIBSection::getSection() != NULL) {                        \
+        DIBSection *dib = DIBSection::findObj(hBitmap);           \
+        if(dib && dib->isDirty()) {                               \
+            dib->flush();                                         \
+        }                                                         \
+    }
+
+
 class DIBSection
 {
 public:
-              DIBSection(BITMAPINFOHEADER_W *pbmi, char *pColors, DWORD iUsage, DWORD hSection, DWORD dwOffset, DWORD handle, int fFlip);
+              DIBSection(BITMAPINFOHEADER_W *pbmi, char *pColors, DWORD iUsage, DWORD hSection, DWORD dwOffset, HBITMAP hBitmap, int fFlip);
              ~DIBSection();
 
@@ -88 +133 @@
               void  UnSelectDIBObject()      { this->hdc = 0;   };
 
-        DWORD GetBitmapHandle()      { return handle; };
-              void  SetBitmapHandle(DWORD bmphandle) { handle = bmphandle; };
+              void  setDirty()               { fDirty = TRUE;   };
+              BOOL  isDirty()                { return fDirty;   }
+              void  setInvalid();
+              BOOL  isInvalid()              { return fInvalid; };
+
+        DWORD GetBitmapHandle()              { return hBitmap; };
+              void  SetBitmapHandle(DWORD bmphandle) { hBitmap = bmphandle; };
         DWORD GetRGBUsage()            { return iUsage; };
 
@@ -97 +147 @@
                            int nSrcWidth, int nSrcHeight,
                            DWORD Rop);
+
+              void  flush();
+              void  sync();
+
               void  sync(HDC hdc, DWORD nYdest, DWORD nDestHeight, BOOL orgYInversion = TRUE);
+              void  flush(HDC hdc, DWORD nYdest, DWORD nDestHeight, BOOL orgYInversion = TRUE);
               void  sync(DWORD xDst, DWORD yDst, DWORD widthDst, DWORD heightDst, PVOID bits);
+
                int  SetDIBColorTable(int startIdx, int cEntries, RGBQUAD *rgb);
                int  GetDIBColorTable(int startIdx, int cEntries, RGBQUAD *rgb);
                int  SetDIBColorTable(int startIdx, int cEntries, PALETTEENTRY *rgb);
 
-               int  SetDIBits(HDC hdc, HBITMAP hbitmap, UINT startscan, UINT
-                              lines, const VOID *bits, BITMAPINFOHEADER_W *pbmi,
-                              UINT coloruse);
-
                int  GetDIBSection(int iSize , void *lpBuffer);
 
  static DIBSection *getSection() { return section; } ;
- static DIBSection *findObj(HANDLE handle);
+ static DIBSection *findObj(HBITMAP hBitmap);
  static DIBSection *findHDC(HDC hdc);
- static       void  deleteSection(HANDLE handle);
+ static       void  deleteSection(HBITMAP hBitmap);
 
  static       void  initDIBSection();
@@ -119 +171 @@
  static       void  unlock() { LeaveCriticalSection(&dibcritsect); };
 
+ static       void  syncAll();
+
 protected:
 
 private:
-          DWORD handle, iUsage;
-          DWORD hSection, dwOffset;
+          HBITMAP hBitmap;
+ 
+          DWORD hSection, dwOffset, iUsage, dwSize;
           HWND  hwndParent;
           HDC   hdc;
@@ -131 +186 @@
     DIBSECTION  dibinfo;
 
+          BOOL  fDirty;         //bitmap is out of sync with dib memory
+          BOOL  fInvalid;       //dib memory is out of sync with bitmap
+
     BITMAPINFO2 *pOS2bmp;
                              // Linked list management
@@ -139 +197 @@
 };
 
-#define DIBSECTION_MARK_INVALID(a)
-#define DIBSECTION_CHECK_IF_DIRTY(a)
-
 #endif
 

trunk/src/gdi32/font.cpp

@@ -1 @@
-/* $Id: font.cpp,v 1.34 2004-01-08 11:11:55 sandervl Exp $ */
+/* $Id: font.cpp,v 1.35 2004-01-11 11:42:11 sandervl Exp $ */
 
 /*
@@ -7 +7 @@
  * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1998 Patrick Haller
+ * Copyright 2003 Innotek Systemberatung GmbH (stauff@innotek.de)
  *
  * TODO: EnumFontsA/W, EnumFontFamiliesExA/W not complete
@@ -32 +33 @@
 #include <ctype.h>
 #include <string.h>
-#include "misc.h"
+#include <dbglog.h>
 #include "unicode.h"
 #include <heapstring.h>
@@ -40 +41 @@
 #include <stats.h>
 #include "oslibgpi.h"
+#include "font.h"
+#include "ft2supp.h"
 
 #define DBG_LOCALLOG    DBG_font
@@ -45 +48 @@
 
 ODINDEBUGCHANNEL(GDI32-FONT)
-
 
 typedef struct {
@@ -95 +97 @@
   /* reserved for system */
   { DEFAULT_CHARSET, 0, FS(0)},
-  { DEFAULT_CHARSET, 0, FS(0)},
+  { SYMBOL_CHARSET, CP_SYMBOL, FS(31)},
 };
 
@@ -146 +148 @@
                                   LF_FACESIZE);
 }
-/***********************************************************************
- *           FONT_mbtowc
- *
- * Returns a '\0' terminated Unicode translation of str using the
- * charset of the currently selected font in hdc.  If count is -1 then
- * str is assumed to be '\0' terminated, otherwise it contains the
- * number of bytes to convert.  If plenW is non-NULL, on return it
- * will point to the number of WCHARs (excluding the '\0') that have
- * been written.  If pCP is non-NULL, on return it will point to the
- * codepage used in the conversion (NB, this may be CP_SYMBOL so watch
- * out).  The caller should free the returned LPWSTR from the process
- * heap itself.
- */
-LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
-{
-    UINT cp = CP_ACP;
-    INT lenW, i;
-    LPWSTR strW;
-    CHARSETINFO csi;
-    int charset = GetTextCharset(hdc);
-
-    if( IsDBCSEnv() && ( charset == 0 ))
-        cp = CP_ACP;
-    else
-    /* Hmm, nicely designed api this one! */
-    if(TranslateCharsetInfo((DWORD*)charset, &csi, TCI_SRCCHARSET))
-        cp = csi.ciACP;
-    else {
-        switch(charset) {
-    case OEM_CHARSET:
-        cp = GetOEMCP();
-        break;
-    case DEFAULT_CHARSET:
-        cp = GetACP();
-        break;
-
-    case VISCII_CHARSET:
-    case TCVN_CHARSET:
-    case KOI8_CHARSET:
-    case ISO3_CHARSET:
-    case ISO4_CHARSET:
-      /* FIXME: These have no place here, but because x11drv
-         enumerates fonts with these (made up) charsets some apps
-         might use them and then the FIXME below would become
-         annoying.  Now we could pick the intended codepage for
-         each of these, but since it's broken anyway we'll just
-         use CP_ACP and hope it'll go away...
-      */
-        cp = CP_ACP;
-        break;
-
-
-    default:
-        dprintf(("Can't find codepage for charset %d\n", charset));
-        break;
-    }
-    }
-
-    dprintf(("cp == %d\n", cp));
-
-    if(count == -1) count = strlen(str);
-    if(cp != CP_SYMBOL) {
-        lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
-    strW = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
-    MultiByteToWideChar(cp, 0, str, count, strW, lenW);
-    } else {
-        lenW = count;
-    strW = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
-    for(i = 0; i < count; i++) strW[i] = (BYTE)str[i];
-    }
-    strW[lenW] = '\0';
-    dprintf(("mapped %s -> %ls\n", str, strW));
-    if(plenW) *plenW = lenW;
-    if(pCP) *pCP = cp;
-    return strW;
-}
+#ifdef DEBUG
+//******************************************************************************
+//******************************************************************************
+void dprintfLogFont(LOGFONTA *lplf)
+{
+  dprintf(("GDI32: lfHeight        = %d\n", lplf->lfHeight));
+  dprintf(("GDI32: lfWidth          = %d\n", lplf->lfWidth));
+  dprintf(("GDI32: lfEscapement    = %d\n", lplf->lfEscapement));
+  dprintf(("GDI32: lfOrientation   = %d\n", lplf->lfOrientation));
+  dprintf(("GDI32: lfWeight        = %d\n", lplf->lfWeight));
+  dprintf(("GDI32: lfItalic        = %d\n", lplf->lfItalic));
+  dprintf(("GDI32: lfUnderline     = %d\n", lplf->lfUnderline));
+  dprintf(("GDI32: lfStrikeOut     = %d\n", lplf->lfStrikeOut));
+  dprintf(("GDI32: lfCharSet       = %X\n", lplf->lfCharSet));
+  dprintf(("GDI32: lfOutPrecision  = %X\n", lplf->lfOutPrecision));
+  dprintf(("GDI32: lfClipPrecision = %X\n", lplf->lfClipPrecision));
+  dprintf(("GDI32: lfQuality       = %X\n", lplf->lfQuality));
+  dprintf(("GDI32: lfPitchAndFamily= %X\n", lplf->lfPitchAndFamily));
+  dprintf(("GDI32: lfFaceName      = %s\n", lplf->lfFaceName));
+}
+//******************************************************************************
+//******************************************************************************
+void dprintfTextMetrics(TEXTMETRICA *pwtm)
+{
+    dprintf(("pwtm->tmHeight %d", pwtm->tmHeight));
+    dprintf(("pwtm->tmAscent %d", pwtm->tmAscent));
+    dprintf(("pwtm->tmDescent %d", pwtm->tmDescent));
+    dprintf(("pwtm->tmInternalLeading %d", pwtm->tmInternalLeading));
+    dprintf(("pwtm->tmExternalLeading %d", pwtm->tmExternalLeading));
+    dprintf(("pwtm->tmAveCharWidth %d", pwtm->tmAveCharWidth));
+    dprintf(("pwtm->tmMaxCharWidth %d", pwtm->tmMaxCharWidth));
+    dprintf(("pwtm->tmWeight %d", pwtm->tmWeight));
+    dprintf(("pwtm->tmOverhang %d", pwtm->tmOverhang));
+    dprintf(("pwtm->tmDigitizedAspectX %d", pwtm->tmDigitizedAspectX));
+    dprintf(("pwtm->tmDigitizedAspectY %d", pwtm->tmDigitizedAspectY));
+    dprintf(("pwtm->tmFirstChar %d", pwtm->tmFirstChar));
+    dprintf(("pwtm->tmLastChar %d", pwtm->tmLastChar));
+    dprintf(("pwtm->tmDefaultChar %d", pwtm->tmDefaultChar));
+    dprintf(("pwtm->tmBreakChar %d", pwtm->tmBreakChar));
+    dprintf(("pwtm->tmItalic %x", pwtm->tmItalic));
+    dprintf(("pwtm->tmUnderlined %x", pwtm->tmUnderlined));
+    dprintf(("pwtm->tmStruckOut %x", pwtm->tmStruckOut));
+    dprintf(("pwtm->tmPitchAndFamily %x", pwtm->tmPitchAndFamily));
+    dprintf(("pwtm->tmCharSet %x", pwtm->tmCharSet));
+}
+#else
+#define dprintfLogFont(a)
+#define dprintfTextMetrics(a)
+#endif
 //******************************************************************************
 //******************************************************************************
@@ -336 +311 @@
   dprintf(("lpszFace = (%x) %s -> %s\n", lplf->lfFaceName, lplf->lfFaceName, afont.lfFaceName));
 
-  dprintf(("GDI32: CreateFontIndirectA\n"));
-  dprintf(("GDI32: lfHeight        = %d\n", lplf->lfHeight));
-  dprintf(("GDI32: lfWidth          = %d\n", lplf->lfWidth));
-  dprintf(("GDI32: lfEscapement    = %d\n", lplf->lfEscapement));
-  dprintf(("GDI32: lfOrientation   = %d\n", lplf->lfOrientation));
-  dprintf(("GDI32: lfWeight        = %d\n", lplf->lfWeight));
-  dprintf(("GDI32: lfItalic        = %d\n", lplf->lfItalic));
-  dprintf(("GDI32: lfUnderline     = %d\n", lplf->lfUnderline));
-  dprintf(("GDI32: lfStrikeOut     = %d\n", lplf->lfStrikeOut));
-  dprintf(("GDI32: lfCharSet       = %X\n", lplf->lfCharSet));
-  dprintf(("GDI32: lfOutPrecision  = %X\n", lplf->lfOutPrecision));
-  dprintf(("GDI32: lfClipPrecision = %X\n", lplf->lfClipPrecision));
-  dprintf(("GDI32: lfQuality       = %X\n", lplf->lfQuality));
-  dprintf(("GDI32: lfPitchAndFamily= %X\n", lplf->lfPitchAndFamily));
-  dprintf(("GDI32: lfFaceName      = %s\n", lplf->lfFaceName));
-
   if( IsDBCSEnv())
   {
@@ -362 +321 @@
   }
 
+  dprintf(("GDI32: CreateFontIndirectA\n"));
+  dprintfLogFont((LOGFONTA *)lplf);
+
   hFont = O32_CreateFontIndirect(&afont);
   if(hFont) {
       STATS_CreateFontIndirect(hFont, &afont);
+      RegisterFont(hFont, (LPSTR)lplf->lfFaceName);
   }
   return(hFont);
@@ -387 +350 @@
 //******************************************************************************
 int  EXPENTRY_O32 EnumFontProcA(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA
-                                   lpTextM, DWORD arg3, LPARAM arg4)
-{
- ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
- FONTENUMPROCA proc = (FONTENUMPROCA)lpEnumData->userProc;
- USHORT selTIB = SetWin32TIB(); // save current FS selector and set win32 sel
+                                lpTextM, DWORD arg3, LPARAM arg4)
+{
+  ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
+  FONTENUMPROCA proc = (FONTENUMPROCA)lpEnumData->userProc;
+  USHORT selTIB = SetWin32TIB(); // save current FS selector and set win32 sel
+
+  if(FT2Module.Ft2QueryFontType(0, lpLogFont->elfLogFont.lfFaceName) == FT2_FONTTYPE_TRUETYPE) {
+      lpTextM->tmPitchAndFamily |= TMPF_TRUETYPE;
+  }
+
+  dprintfLogFont(&lpLogFont->elfLogFont);
+  dprintfTextMetrics((TEXTMETRICA *)lpTextM);
 
   int rc = proc(lpLogFont, lpTextM, arg3, lpEnumData->userData);
@@ -408 +378 @@
  USHORT selTIB = SetWin32TIB(); // save current FS selector and set win32 sel
  int rc;
+
+  if(FT2Module.Ft2QueryFontType(0, lpLogFont->elfLogFont.lfFaceName) == FT2_FONTTYPE_TRUETYPE) {
+      lpTextM->tmPitchAndFamily |= TMPF_TRUETYPE;
+  }
+
+  dprintfLogFont(&lpLogFont->elfLogFont);
+  dprintfTextMetrics((TEXTMETRICA *)lpTextM);
 
   memcpy(&LogFont, lpLogFont, ((ULONG)&LogFont.elfLogFont.lfFaceName -
@@ -448 +425 @@
 //******************************************************************************
 int  EXPENTRY_O32 EnumFontProcExA(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA
-                                     lpTextM, DWORD arg3, LPARAM arg4)
+                                     lpTextM, DWORD FontType, LPARAM arg4)
 {
  ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
@@ -456 +433 @@
  USHORT selTIB = SetWin32TIB(); // save current FS selector and set win32 sel
 
+  if(FT2Module.Ft2QueryFontType(0, lpLogFont->elfLogFont.lfFaceName) == FT2_FONTTYPE_TRUETYPE) {
+      lpTextM->tmPitchAndFamily |= TMPF_TRUETYPE;
+  }
+
+  dprintfLogFont(&lpLogFont->elfLogFont);
+  dprintfTextMetrics((TEXTMETRICA *)lpTextM);
+
   memcpy(&logFont, lpLogFont, sizeof(ENUMLOGFONTA));
   memset(logFont.elfScript, 0, sizeof(logFont.elfScript));
@@ -461 +445 @@
   memset(&textM.ntmFontSig, 0, sizeof(textM.ntmFontSig));
 
-  dprintf(("EnumFontProcExA %s height %d", logFont.elfLogFont.lfFaceName, textM.ntmTm.tmHeight));
-
-  int rc = proc(&logFont, &textM, arg3, lpEnumData->userData);
+  dprintf(("EnumFontProcExA %s type %x height %d", logFont.elfLogFont.lfFaceName, FontType, textM.ntmTm.tmHeight));
+
+  int rc = proc(&logFont, &textM, FontType, lpEnumData->userData);
   SetFS(selTIB);           // switch back to the saved FS selector
   return rc;
@@ -471 +455 @@
 //******************************************************************************
 int EXPENTRY_O32 EnumFontProcExW(LPENUMLOGFONTA lpLogFont, LPNEWTEXTMETRICA lpTextM,
-                                    DWORD arg3, LPARAM arg4)
+                                    DWORD FontType, LPARAM arg4)
 {
  ENUMUSERDATA *lpEnumData = (ENUMUSERDATA *)arg4;
@@ -479 +463 @@
  USHORT selTIB = SetWin32TIB(); // save current FS selector and set win32 sel
  int rc;
+
+  if(FT2Module.Ft2QueryFontType(0, lpLogFont->elfLogFont.lfFaceName) == FT2_FONTTYPE_TRUETYPE) {
+      lpTextM->tmPitchAndFamily |= TMPF_TRUETYPE;
+  }
+
+  dprintfLogFont(&lpLogFont->elfLogFont);
+  dprintfTextMetrics((TEXTMETRICA *)lpTextM);
 
   memcpy(&LogFont, lpLogFont, ((ULONG)&LogFont.elfLogFont.lfFaceName - (ULONG)&LogFont));
@@ -512 +503 @@
   memset(&textM.ntmFontSig, 0, sizeof(textM.ntmFontSig));
 
-  dprintf(("EnumFontProcExW %s height %d", lpLogFont->elfLogFont.lfFaceName, textM.ntmTm.tmHeight));
-  rc = proc(&LogFont, &textM, arg3, lpEnumData->userData);
+  dprintf(("EnumFontProcExW %s type %x height %d charset %d/%d", lpLogFont->elfLogFont.lfFaceName, FontType, textM.ntmTm.tmHeight, lpTextM->tmCharSet, lpLogFont->elfLogFont.lfCharSet));
+  rc = proc(&LogFont, &textM, FontType, lpEnumData->userData);
   SetFS(selTIB);           // switch back to the saved FS selector
   return rc;
@@ -586 +577 @@
 //******************************************************************************
 INT WIN32API EnumFontFamiliesExA(HDC hdc,
-                                 LPLOGFONTA arg2,
+                                 LPLOGFONTA lpLogFont,
                                  FONTENUMPROCEXA arg3,
                                  LPARAM arg4,
@@ -594 +585 @@
   int rc;
 
-  dprintf(("GDI32: EnumFontFamiliesExA not complete %s", arg2->lfFaceName));
+  dprintf(("GDI32: EnumFontFamiliesExA not complete %s", lpLogFont->lfFaceName));
+  dprintf(("GDI32: EnumFontFamiliesExA font name %s character set %x", lpLogFont->lfFaceName, lpLogFont->lfCharSet));
 
   enumData.userProc = (DWORD)arg3;
@@ -600 +592 @@
   enumData.dwFlags  = dwFlags;
 
-  rc = O32_EnumFontFamilies(hdc, arg2->lfFaceName, &EnumFontProcExA, (LPARAM)&enumData);
+  rc = O32_EnumFontFamilies(hdc, lpLogFont->lfFaceName, &EnumFontProcExA, (LPARAM)&enumData);
 
   return rc;
@@ -607 +599 @@
 //******************************************************************************
 INT WIN32API EnumFontFamiliesExW(HDC hdc,
-                                 LPLOGFONTW arg2,
+                                 LPLOGFONTW lpLogFont,
                                  FONTENUMPROCEXW arg3,
                                  LPARAM arg4,
@@ -614 +606 @@
   ENUMUSERDATA enumData;
   int rc;
-  char *astring = UnicodeToAsciiString((LPWSTR)arg2->lfFaceName);
+  char *astring = UnicodeToAsciiString((LPWSTR)lpLogFont->lfFaceName);
 
   dprintf(("GDI32: EnumFontFamiliesExW not complete %s", astring));
+  dprintf(("GDI32: EnumFontFamiliesExW font name %s character set %x", astring, lpLogFont->lfCharSet));
 
   enumData.userProc = (DWORD)arg3;
@@ -627 +620 @@
   return rc;
 }
-//******************************************************************************
-//******************************************************************************
-DWORD WIN32API GetFontData(HDC hdc, DWORD dwTable,
-                           DWORD dwOffset,
-                           LPVOID lpvBuffer,
-                           DWORD dbData)
-{
-  dprintf(("GDI32: GetFontData, not implemented (GDI_ERROR)\n"));
-  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
-  return(GDI_ERROR);
-}
-//******************************************************************************
-//******************************************************************************
-int WIN32API AddFontResourceA(LPCSTR szFont)
-{
-    HINSTANCE hInstance;
-
-    dprintf(("GDI32: AddFontResourceA %s", szFont));
-    hInstance = LoadLibraryA(szFont);
-    if(hInstance) {
-        dprintf(("AddFontResourceA: executable file; NOT IMPLEMENTED"));
-        FreeLibrary(hInstance);
-        return 1;
-    }
-    return 1;
-}
-//******************************************************************************
-//******************************************************************************
-int WIN32API AddFontResourceW(LPCWSTR szFont)
-{
- char *astring = UnicodeToAsciiString((LPWSTR)szFont);
- BOOL  rc;
-
-    dprintf(("GDI32: AddFontResourceW"));
-    // NOTE: This will not work as is (needs UNICODE support)
-    rc = AddFontResourceA(astring);
-    FreeAsciiString(astring);
-    return rc;
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WIN32API RemoveFontResourceA(LPCSTR lpszFont)
-{
-    dprintf(("GDI32: RemoveFontResourceA %s", lpszFont));
-    return FALSE;
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WIN32API RemoveFontResourceW(LPCWSTR szFont)
-{
- char *astring = UnicodeToAsciiString((LPWSTR)szFont);
- BOOL  rc;
-
-    dprintf(("GDI32: RemoveFontResourceW"));
-    rc = RemoveFontResourceA(astring);
-    FreeAsciiString(astring);
-    return(rc);
-}
-/*****************************************************************************
- * Name      : BOOL CreateScalableFontResourceA
- * Purpose   : The CreateScalableFontResourceA function creates a font resource
- *             file for a scalable font.
- * Parameters: DWORD   fdwHidden       flag for read-only embedded font
- *             LPCSTR lpszFontRes     address of filename for font resource
- *             LPCSTR lpszFontFile    address of filename for scalable font
- *             LPCSTR lpszCurrentPath address of path to font file
- * Variables :
- * Result    : TRUE / FALSE
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
- *****************************************************************************/
-
-BOOL WIN32API CreateScalableFontResourceA(DWORD fdwHidden,
-                                          LPCSTR lpszFontRes,
-                                          LPCSTR lpszFontFile,
-                                          LPCSTR lpszCurrentPath)
-{
-  dprintf(("GDI32: CreateScalableFontResourceA %x %s %s %s not implemented", fdwHidden, lpszFontRes, lpszFontFile, lpszCurrentPath));
-
-//  return OSLibGpiLoadFonts((LPSTR)lpszFontFile);
-  return FALSE;
-}
-
-
-/*****************************************************************************
- * Name      : BOOL CreateScalableFontResourceW
- * Purpose   : The CreateScalableFontResourceW function creates a font resource
- *             file for a scalable font.
- * Parameters: DWORD   fdwHidden       flag for read-only embedded font
- *             LPCSTR lpszFontRes     address of filename for font resource
- *             LPCSTR lpszFontFile    address of filename for scalable font
- *             LPCSTR lpszCurrentPath address of path to font file
- * Variables :
- * Result    : TRUE / FALSE
- * Remark    :
- * Status    : UNTESTED STUB
- *
- * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
- *****************************************************************************/
-
-BOOL WIN32API CreateScalableFontResourceW(DWORD fdwHidden,
-                                          LPCWSTR lpszFontRes,
-                                          LPCWSTR lpszFontFile,
-                                          LPCWSTR lpszCurrentPath)
-{
-  LPSTR lpszFontFileA = NULL, lpszFontResA = NULL, lpszCurrentPathA = NULL;
-
-  dprintf(("GDI32: CreateScalableFontResourceW %x %ls %ls %ls not implemented", fdwHidden, lpszFontRes, lpszFontFile, lpszCurrentPath));
-
-  STACK_strdupWtoA(lpszFontFile, lpszFontFileA);
-  STACK_strdupWtoA(lpszFontRes, lpszFontResA);
-  STACK_strdupWtoA(lpszCurrentPath, lpszCurrentPathA);
-  return CreateScalableFontResourceA(fdwHidden, lpszFontResA, lpszFontFileA, lpszCurrentPathA);
-}
-
 
 /*****************************************************************************
@@ -819 +694 @@
 
     rc = O32_GetTextMetrics(hdc, pwtm);
-    dprintf(("GDI32: GetTextMetricsA %x %x returned %d", hdc, pwtm, rc));
+
+    if(rc == TRUE) {
+       if(FT2Module.Ft2QueryFontType(hdc, NULL) == FT2_FONTTYPE_TRUETYPE) {
+           pwtm->tmPitchAndFamily |= TMPF_TRUETYPE;
+       }
+    }
+    dprintfTextMetrics(pwtm);
     return(rc);
 }
@@ -826 +707 @@
 BOOL WIN32API GetTextMetricsW( HDC hdc, LPTEXTMETRICW pwtm)
 {
- BOOL rc;
- TEXTMETRICA atm;
-
-    dprintf(("GDI32: GetTextMetricsW"));
-
-    rc = O32_GetTextMetrics(hdc, &atm);
+    BOOL rc;
+    TEXTMETRICA atm;
+
+    rc = GetTextMetricsA(hdc, &atm);
     pwtm->tmHeight = atm.tmHeight;
     pwtm->tmAscent = atm.tmAscent;
@@ -853 +732 @@
     pwtm->tmCharSet = atm.tmCharSet;
 
-    dprintf(("GDI32: GetTextMetricsW %x %x returned %d", hdc, pwtm, rc));
     return(rc);
 }
 //******************************************************************************
 //******************************************************************************
-int WIN32API GetTextFaceA( HDC hdc, int arg2, LPSTR  arg3)
-{
-    dprintf(("GDI32: GetTextFaceA %x %d %x", hdc, arg2, arg3));
-    return O32_GetTextFace(hdc, arg2, arg3);
-}
-//******************************************************************************
-//******************************************************************************
-int WIN32API GetTextFaceW( HDC hdc, int arg2, LPWSTR  arg3)
-{
- char *astring = NULL;
- int   lenA = GetTextFaceA( hdc, 0, NULL );
- int   rc;
-
-    dprintf(("GDI32: GetTextFaceW"));
+int WIN32API GetTextFaceA( HDC hdc, int nCount, LPSTR lpFaceName)
+{
+    int ret;
+
+    dprintf(("GDI32: GetTextFaceA %x %d %x", hdc, nCount, lpFaceName));
+    ret = O32_GetTextFace(hdc, nCount, lpFaceName);
+    if(ret > 0 && lpFaceName) {
+        dprintf(("GDI32: GetTextFaceA returned %s", lpFaceName));
+    }
+    //We should return the length including null terminator (WGSS doesn't)
+    if(!lpFaceName) ret++;
+
+    return ret;
+}
+//******************************************************************************
+//******************************************************************************
+int WIN32API GetTextFaceW( HDC hdc, int nCount, LPWSTR  lpFaceName)
+{
+    char *astring = NULL;
+    int   lenA = GetTextFaceA( hdc, 0, NULL );
+    int   rc;
+
     astring = ( char * )malloc( lenA );
-    if( astring )
+    if( astring == NULL ) //@@VP:2003-11-05 was 'if ( astring )'
         return 0;
 
@@ -880 +766 @@
     if( rc )
     {
-        if( arg3 )
+        if( lpFaceName )
         {
-            AsciiToUnicodeN(astring, arg3, arg2);
-            rc = lstrlenW( arg3 );
+            AsciiToUnicodeN(astring, lpFaceName, nCount);
+            rc = lstrlenW( lpFaceName );
         }
         else
@@ -911 +797 @@
     return 0;
 }
-//******************************************************************************
-//******************************************************************************
+/*****************************************************************************
+ * Name      : DWORD GetCharacterPlacementA
+ * Purpose   : The GetCharacterPlacementA function retrieves information about
+ *             a character string, such as character widths, caret positioning,
+ *             ordering within the string, and glyph rendering. The type of
+ *             information returned depends on the dwFlags parameter and is
+ *             based on the currently selected font in the given display context.
+ *             The function copies the information to the specified GCP_RESULTSA
+ *             structure or to one or more arrays specified by the structure.
+ * Parameters: HDC     hdc        handle to device context
+ *             LPCSTR lpString   pointer to string
+ *             int     nCount     number of characters in string
+ *             int     nMaxExtent maximum extent for displayed string
+ *             LPGCP_RESULTSA *lpResults  pointer to buffer for placement result
+ *             DWORD   dwFlags    placement flags
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
+ *****************************************************************************/
+
+DWORD WIN32API GetCharacterPlacementA(HDC           hdc,
+                                         LPCSTR       lpString,
+                                         int           nCount,
+                                         int           nMaxExtent,
+                                         GCP_RESULTSA * lpResults,
+                                         DWORD         dwFlags)
+{
+  dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
+           hdc,
+           lpString,
+           nCount,
+           nMaxExtent,
+           lpResults,
+           dwFlags));
+
+  return (0);
+}
+
+/*****************************************************************************
+ * Name      : DWORD GetCharacterPlacementW
+ * Purpose   : The GetCharacterPlacementW function retrieves information about
+ *             a character string, such as character widths, caret positioning,
+ *             ordering within the string, and glyph rendering. The type of
+ *             information returned depends on the dwFlags parameter and is
+ *             based on the currently selected font in the given display context.
+ *             The function copies the information to the specified GCP_RESULTSW
+ *             structure or to one or more arrays specified by the structure.
+ * Parameters: HDC     hdc        handle to device context
+ *             LPCSTR lpString   pointer to string
+ *             int     nCount     number of characters in string
+ *             int     nMaxExtent maximum extent for displayed string
+ *             GCP_RESULTSW *lpResults  pointer to buffer for placement result
+ *             DWORD   dwFlags    placement flags
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : Partly working
+ *
+ * Author    : Borrowed Rewind Code
+ *****************************************************************************/
+
+DWORD WIN32API GetCharacterPlacementW(HDC           hdc,
+                                         LPCWSTR       lpString,
+                                         int           uCount,
+                                         int           nMaxExtent,
+                                         GCP_RESULTSW *lpResults,
+                                         DWORD         dwFlags)
+{
+    return FT2Module.Ft2GetCharacterPlacementW(hdc, lpString, uCount, nMaxExtent, lpResults, dwFlags);
+}
+
+
+/***********************************************************************
+ *           FONT_mbtowc
+ *
+ * Returns a '\0' terminated Unicode translation of str using the
+ * charset of the currently selected font in hdc.  If count is -1 then
+ * str is assumed to be '\0' terminated, otherwise it contains the
+ * number of bytes to convert.  If plenW is non-NULL, on return it
+ * will point to the number of WCHARs (excluding the '\0') that have
+ * been written.  If pCP is non-NULL, on return it will point to the
+ * codepage used in the conversion (NB, this may be CP_SYMBOL so watch
+ * out).  The caller should free the returned LPWSTR from the process
+ * heap itself.
+ */
+LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
+{
+    UINT cp = CP_ACP;
+    INT lenW, i;
+    LPWSTR strW;
+    CHARSETINFO csi;
+    int charset = GetTextCharset(hdc);
+
+    if( IsDBCSEnv() && ( charset == 0 ))
+        cp = CP_ACP;
+    else
+    /* Hmm, nicely designed api this one! */
+    if(TranslateCharsetInfo((DWORD*)charset, &csi, TCI_SRCCHARSET))
+        cp = csi.ciACP;
+    else {
+        switch(charset) {
+        case OEM_CHARSET:
+            cp = GetOEMCP();
+            break;
+        case DEFAULT_CHARSET:
+            cp = GetACP();
+            break;
+
+        case VISCII_CHARSET:
+        case TCVN_CHARSET:
+        case KOI8_CHARSET:
+        case ISO3_CHARSET:
+        case ISO4_CHARSET:
+          /* FIXME: These have no place here, but because x11drv
+             enumerates fonts with these (made up) charsets some apps
+             might use them and then the FIXME below would become
+             annoying.  Now we could pick the intended codepage for
+             each of these, but since it's broken anyway we'll just
+             use CP_ACP and hope it'll go away...
+          */
+            cp = CP_ACP;
+            break;
+
+
+        default:
+            dprintf(("Can't find codepage for charset %d\n", charset));
+            break;
+        }
+    }
+
+    dprintf(("cp == %d\n", cp));
+
+    if(count == -1) count = strlen(str);
+    if(cp != CP_SYMBOL) {
+        lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
+        strW = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
+        MultiByteToWideChar(cp, 0, str, count, strW, lenW);
+    } else {
+        lenW = count;
+        strW = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
+        for(i = 0; i < count; i++) strW[i] = (BYTE)str[i];
+    }
+    strW[lenW] = '\0';
+    dprintf(("mapped %s -> %ls\n", str, strW));
+    if(plenW) *plenW = lenW;
+    if(pCP) *pCP = cp;
+    return strW;
+}
+
+/*************************************************************************
+ * GetGlyphIndicesA [GDI32.@]
+ */
+DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
+                              LPWORD pgi, DWORD flags)
+{
+    DWORD ret;
+    WCHAR *lpstrW;
+    INT countW;
+
+    dprintf(("GDI32: GetGlyphIndicesA (%p, %s, %d, %p, 0x%lx)\n",
+          hdc, lpstr, count, pgi, flags));
+
+    lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
+    ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
+    HeapFree(GetProcessHeap(), 0, lpstrW);
+
+    return ret;
+}
+
+/*************************************************************************
+ * GetGlyphIndicesW [GDI32.@]
+ */
+DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
+                              LPWORD pgi, DWORD flags)
+{
+    DWORD ret;
+
+    dprintf(("GDI32: GetGlyphIndicesW (%ls, %d, %p, 0x%lx)",
+             lpstr, count, pgi, flags));
+
+    if(!hdc) return GDI_ERROR;
+
+    ret = FT2Module.Ft2GetGlyphIndices(hdc, lpstr, count , pgi, flags); 
+    if(ret != GDI_ERROR) {
+        for(int i=0;i<ret;i++) {
+            dprintf(("GetGlyphIndices: %c (%x)-> %d", lpstr[i], lpstr[i], pgi[i]));
+        }
+    }
+    return ret;
+}
+
+/***********************************************************************
+ *           GetGlyphOutlineA    (GDI32.@)
+ */
+DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
+                                 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
+                                 LPVOID lpBuffer, const MAT2 *lpmat2 )
+{
+    LPWSTR p = NULL;
+    DWORD ret;
+    UINT c;
+
+    if ((fuFormat & GGO_GLYPH_INDEX) == 0)
+    {
+        p = FONT_mbtowc(hdc, (char*)&uChar, 1, NULL, NULL);
+        if (p)
+        {
+            c = p[0];
+        }
+        else
+        {
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+            return GDI_ERROR;
+        }
+    }
+    else
+    {
+        c = uChar;
+    }
+    
+    ret = GetGlyphOutlineW (hdc, c, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2);
+    
+    if (p != NULL)
+    {
+        HeapFree (GetProcessHeap(), 0, p);
+    }
+    
+    return ret;
+}
+
+/***********************************************************************
+ *           GetGlyphOutlineW    (GDI32.@)
+ */
+DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
+                               LPGLYPHMETRICS lpgm, DWORD cbBuffer,
+                               LPVOID lpBuffer, const MAT2 *lpmat2 )
+{
+    pDCData pHps = (pDCData)OSLibGpiQueryDCData(hdc);
+
+    dprintf(("GDI32: GetGlyphOutlineW(%p, %04x, %04x, %p, %ld, %p, %p)\n",
+              pHps, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 ));
+
+    if (!hdc || !pHps)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return GDI_ERROR;
+    }
+
+    return FT2Module.Ft2GetGlyphOutline(pHps->hps, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2);
+}
+//******************************************************************************
+//******************************************************************************
+DWORD WIN32API GetKerningPairsA( HDC hdc, DWORD nNumPairs, LPKERNINGPAIR lpkrnpair)
+{
+    return O32_GetKerningPairs(hdc, nNumPairs, lpkrnpair);
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/gdi32/font.h

@@ -7 +7 @@
 BOOL WIN32API IsSystemFont(HFONT hFont);
 
+BOOL RegisterFont(HFONT hFont, LPSTR lfFaceName);
+
 LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP);
 
+//text.cpp
+BOOL WIN32API GetStringWidthW(HDC hdc, LPWSTR lpszString, UINT cbString, PINT pWidthArray);
+
 #endif //__FONT_H__