Ignore:
Timestamp:
Jan 11, 2004, 12:43:22 PM (22 years ago)
Author:
sandervl
Message:

Update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gdi32/gdi32.cpp

    r10349 r10374  
    1 /* $Id: gdi32.cpp,v 1.90 2003-12-01 13:27:38 sandervl Exp $ */
     1/* $Id: gdi32.cpp,v 1.91 2004-01-11 11:42:15 sandervl Exp $ */
    22
    33/*
    … …  
    2727#include <stats.h>
    2828#include <objhandle.h>
     29#include <winspool.h>
    2930
    3031#define DBG_LOCALLOG    DBG_gdi32
    … …  
    3334ODINDEBUGCHANNEL(GDI32-GDI32)
    3435
     36//******************************************************************************
     37//******************************************************************************
     38BOOL WIN32API GdiFlush()
     39{
     40    //NOP: DIB synchronization is done using exceptions
     41    return TRUE;
     42}
    3543//******************************************************************************
    3644//******************************************************************************
    … …  
    7886    ret = O32_InvertRect(hDC,lprc);
    7987    DIBSECTION_MARK_INVALID(hDC);
     88    return ret;
     89}
     90//******************************************************************************
     91//******************************************************************************
     92BOOL WIN32API StrokeAndFillPath(HDC hdc)
     93{
     94    DIBSECTION_CHECK_IF_DIRTY(hdc);
     95    BOOL ret = O32_StrokeAndFillPath(hdc);
     96    DIBSECTION_MARK_INVALID(hdc);
     97    return ret;
     98}
     99//******************************************************************************
     100//******************************************************************************
     101BOOL WIN32API StrokePath(HDC hdc)
     102{
     103    DIBSECTION_CHECK_IF_DIRTY(hdc);
     104    BOOL ret = O32_StrokePath(hdc);
     105    DIBSECTION_MARK_INVALID(hdc);
    80106    return ret;
    81107}
    … …  
    254280//******************************************************************************
    255281//******************************************************************************
    256 HDC WIN32API CreateCompatibleDC( HDC hdc)
    257 {
    258  HDC newHdc;
    259 
    260     newHdc = O32_CreateCompatibleDC(hdc);
    261     ULONG oldcp = OSLibGpiQueryCp(hdc);
    262     if (!oldcp) /* If new DC is to be created */
    263         oldcp = GetDisplayCodepage();
    264 
    265     if(newHdc) STATS_CreateCompatibleDC(hdc, newHdc);
    266     OSLibGpiSetCp(newHdc, oldcp);
    267     //PF Open32 seems not to move coordinates to 0,0 in newHdc
    268     MoveToEx(newHdc, 0, 0 , NULL);
    269 
    270     return newHdc;
    271 }
    272 //******************************************************************************
    273 //******************************************************************************
    274 BOOL WIN32API DeleteDC(HDC hdc)
    275 {
    276   pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    277   if(!pHps)
    278   {
    279       dprintf(("WARNING: DeleteDC %x; invalid hdc!", hdc));
    280       SetLastError(ERROR_INVALID_HANDLE);
    281       return 0;
    282   }
    283   SetLastError(ERROR_SUCCESS);
    284 
    285   DIBSection *dsect = DIBSection::findHDC(hdc);
    286   if(dsect)
    287   {
    288       //remove previously selected dibsection
    289       dprintf(("DeleteDC %x, unselect DIB section %x", hdc, dsect->GetBitmapHandle()));
    290       dsect->UnSelectDIBObject();
    291   }
    292 
    293   //Must call ReleaseDC for window dcs
    294   if(pHps->hdcType == TYPE_1) {
    295       return ReleaseDC(OS2ToWin32Handle(pHps->hwnd), hdc);
    296   }
    297 
    298   STATS_DeleteDC(hdc);
    299   return O32_DeleteDC(hdc);
    300 }
    301 //******************************************************************************
    302 //******************************************************************************
    303 BOOL WIN32API StrokeAndFillPath(HDC hdc)
    304 {
    305     return O32_StrokeAndFillPath(hdc);
    306 }
    307 //******************************************************************************
    308 //******************************************************************************
    309 BOOL WIN32API StrokePath(HDC hdc)
    310 {
    311     return O32_StrokePath(hdc);
    312 }
    313 //******************************************************************************
    314 //******************************************************************************
    315282int WIN32API SetBkMode( HDC hdc, int mode)
    316283{
    … …  
    396363//******************************************************************************
    397364//******************************************************************************
    398 HDC WIN32API CreateDCA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, const DEVMODEA *lpInitData)
    399 {
    400     HDC hdc;
    401 
    402     // 2001-05-28 PH
    403     // Ziff Davis Benchmarks come in here with "display".
    404     // Obviously, Windows does accept case-insensitive driver names,
    405     // whereas Open32 doesn't.
    406     if (*lpszDriver == 'd') // quick check
    407     {
    408         // then do a double-check and use the uppercase constant
    409         // instead
    410         if (stricmp(lpszDriver, "DISPLAY") == 0)
    411             lpszDriver = "DISPLAY";
    412     }
    413 
    414     hdc = O32_CreateDC(lpszDriver, lpszDevice, lpszOutput, lpInitData);
    415     if(hdc) {
    416         OSLibGpiSetCp(hdc, GetDisplayCodepage());
    417         STATS_CreateDCA(hdc, lpszDriver, lpszDevice, lpszOutput, lpInitData);
    418     }
    419 
    420     dprintf(("GDI32: CreateDCA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpInitData, hdc));
    421     return hdc;
    422 }
    423 //******************************************************************************
    424 //******************************************************************************
    425 HDC WIN32API CreateDCW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
    426 {
    427     char *astring4, *astring5;
    428 
    429     char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
    430     char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
    431     char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
    432 
    433     if(arg4)
    434     {
    435       astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
    436       astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
    437     }
    438 
    439     HDC   rc;
    440     DEVMODEA devmode;
    441 
    442     if(arg4)
    443     {
    444       strcpy((char*)devmode.dmDeviceName, astring4);
    445       strcpy((char*)devmode.dmFormName, astring5);
    446 
    447       devmode.dmSpecVersion      = arg4->dmSpecVersion;
    448       devmode.dmDriverVersion    = arg4->dmDriverVersion;
    449       devmode.dmSize             = arg4->dmSize;
    450       devmode.dmDriverExtra      = arg4->dmDriverExtra;
    451       devmode.dmFields           = arg4->dmFields;
    452 #if (__IBMCPP__ == 360)
    453       devmode.dmOrientation   = arg4->dmOrientation;
    454       devmode.dmPaperSize     = arg4->dmPaperSize;
    455       devmode.dmPaperLength   = arg4->dmPaperLength;
    456       devmode.dmPaperWidth    = arg4->dmPaperWidth;
    457 #else
    458       devmode.s1.dmOrientation   = arg4->s1.dmOrientation;
    459       devmode.s1.dmPaperSize     = arg4->s1.dmPaperSize;
    460       devmode.s1.dmPaperLength   = arg4->s1.dmPaperLength;
    461       devmode.s1.dmPaperWidth    = arg4->s1.dmPaperWidth;
    462 #endif
    463       devmode.dmScale            = arg4->dmScale;
    464       devmode.dmCopies           = arg4->dmCopies;
    465       devmode.dmDefaultSource    = arg4->dmDefaultSource;
    466       devmode.dmPrintQuality     = arg4->dmPrintQuality;
    467       devmode.dmColor            = arg4->dmColor;
    468       devmode.dmDuplex           = arg4->dmDuplex;
    469       devmode.dmYResolution      = arg4->dmYResolution;
    470       devmode.dmTTOption         = arg4->dmTTOption;
    471       devmode.dmCollate          = arg4->dmCollate;
    472       devmode.dmLogPixels        = arg4->dmLogPixels;
    473       devmode.dmBitsPerPel       = arg4->dmBitsPerPel;
    474       devmode.dmPelsWidth        = arg4->dmPelsWidth;
    475       devmode.dmPelsHeight       = arg4->dmPelsHeight;
    476       devmode.dmDisplayFlags     = arg4->dmDisplayFlags;
    477       devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
    478       devmode.dmICMMethod        = arg4->dmICMMethod;
    479       devmode.dmICMIntent        = arg4->dmICMIntent;
    480       devmode.dmMediaType        = arg4->dmMediaType;
    481       devmode.dmDitherType       = arg4->dmDitherType;
    482       devmode.dmReserved1        = arg4->dmReserved1;
    483       devmode.dmReserved2        = arg4->dmReserved2;
    484       rc = CreateDCA(astring1,astring2,astring3,&devmode);
    485     }
    486     else
    487       rc = CreateDCA(astring1,astring2,astring3, NULL);
    488 
    489     FreeAsciiString(astring1);
    490     FreeAsciiString(astring2);
    491     FreeAsciiString(astring3);
    492 
    493     if(arg4)
    494     {
    495       FreeAsciiString(astring4);
    496       FreeAsciiString(astring5);
    497     }
    498 
    499     return rc;
    500 }
    501 //******************************************************************************
    502 //******************************************************************************
    503 HDC WIN32API CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput,
    504                        const DEVMODEA *lpdvmInit)
    505 {
    506  static char *szDisplay = "DISPLAY";
    507  HDC          hdc;
    508 
    509     //SvL: Open32 tests for "DISPLAY"
    510     if(lpszDriver && !strcmp(lpszDriver, "display")) {
    511         lpszDriver = szDisplay;
    512     }
    513     //SvL: Open32 tests lpszDriver for NULL even though it's ignored
    514     if(lpszDriver == NULL) {
    515         lpszDriver = lpszDevice;
    516     }
    517     hdc = O32_CreateIC(lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
    518     if(hdc) STATS_CreateICA(hdc, lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
    519     return hdc;
    520 }
    521 //******************************************************************************
    522 //******************************************************************************
    523 HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
    524 {
    525     char *astring4, *astring5;
    526 
    527     char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
    528     char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
    529     char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
    530     if(arg4)
    531     {
    532       astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
    533       astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
    534     }
    535 
    536     HDC   rc;
    537     DEVMODEA devmode;
    538 
    539     if(arg4)
    540     {
    541       strcpy((char*)devmode.dmDeviceName, astring4);
    542       strcpy((char*)devmode.dmFormName, astring5);
    543 
    544       devmode.dmSpecVersion      = arg4->dmSpecVersion;
    545       devmode.dmDriverVersion    = arg4->dmDriverVersion;
    546       devmode.dmSize             = arg4->dmSize;
    547       devmode.dmDriverExtra      = arg4->dmDriverExtra;
    548       devmode.dmFields           = arg4->dmFields;
    549 #if (__IBMCPP__ == 360)
    550       devmode.dmOrientation      = arg4->dmOrientation;
    551       devmode.dmPaperSize        = arg4->dmPaperSize;
    552       devmode.dmPaperLength      = arg4->dmPaperLength;
    553       devmode.dmPaperWidth       = arg4->dmPaperWidth;
    554 #else
    555       devmode.s1.dmOrientation   = arg4->s1.dmOrientation;
    556       devmode.s1.dmPaperSize     = arg4->s1.dmPaperSize;
    557       devmode.s1.dmPaperLength   = arg4->s1.dmPaperLength;
    558       devmode.s1.dmPaperWidth    = arg4->s1.dmPaperWidth;
    559 #endif
    560       devmode.dmScale            = arg4->dmScale;
    561       devmode.dmCopies           = arg4->dmCopies;
    562       devmode.dmDefaultSource    = arg4->dmDefaultSource;
    563       devmode.dmPrintQuality     = arg4->dmPrintQuality;
    564       devmode.dmColor            = arg4->dmColor;
    565       devmode.dmDuplex           = arg4->dmDuplex;
    566       devmode.dmYResolution      = arg4->dmYResolution;
    567       devmode.dmTTOption         = arg4->dmTTOption;
    568       devmode.dmCollate          = arg4->dmCollate;
    569       devmode.dmLogPixels        = arg4->dmLogPixels;
    570       devmode.dmBitsPerPel       = arg4->dmBitsPerPel;
    571       devmode.dmPelsWidth        = arg4->dmPelsWidth;
    572       devmode.dmPelsHeight       = arg4->dmPelsHeight;
    573       devmode.dmDisplayFlags     = arg4->dmDisplayFlags;
    574       devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
    575       devmode.dmICMMethod        = arg4->dmICMMethod;
    576       devmode.dmICMIntent        = arg4->dmICMIntent;
    577       devmode.dmMediaType        = arg4->dmMediaType;
    578       devmode.dmDitherType       = arg4->dmDitherType;
    579       devmode.dmReserved1        = arg4->dmReserved1;
    580       devmode.dmReserved2        = arg4->dmReserved2;
    581 
    582       rc = CreateICA(astring1,astring2,astring3,&devmode);
    583     }
    584     else
    585       rc = CreateICA(astring1,astring2,astring3, NULL);
    586 
    587     FreeAsciiString(astring1);
    588     FreeAsciiString(astring2);
    589     FreeAsciiString(astring3);
    590     if(arg4)
    591     {
    592       FreeAsciiString(astring4);
    593       FreeAsciiString(astring5);
    594     }
    595 
    596     return rc;
    597 }
    598 //******************************************************************************
    599 //******************************************************************************
    600365BOOL WIN32API Ellipse(HDC hdc, int nLeftRect, int nTopRect, int nRightRect,
    601366                      int nBottomRect)
    … …  
    708473//******************************************************************************
    709474//******************************************************************************
    710 int WIN32API Escape( HDC hdc, int nEscape, int cbInput, LPCSTR lpvInData, PVOID lpvOutData)
    711 {
    712  int rc;
    713 
    714 #ifdef DEBUG
    715   if(cbInput && lpvInData) {
    716         ULONG *tmp = (ULONG *)lpvInData;
    717         for(int i=0;i<cbInput/4;i++) {
    718                 dprintf(("GDI32: Escape par %d: %x", i, *tmp++));
    719         }
    720   }
    721 #endif
    722     rc = O32_Escape(hdc, nEscape, cbInput, lpvInData, lpvOutData);
    723     if(rc == 0) {
    724          dprintf(("GDI32: Escape %x %d %d %x %x returned %d (WARNING: might not be implemented!!) ", hdc, nEscape, cbInput, lpvInData, lpvOutData, rc));
    725     }
    726     else dprintf(("GDI32: Escape %x %d %d %x %x returned %d ", hdc, nEscape, cbInput, lpvInData, lpvOutData, rc));
    727 
    728     return rc;
    729 }
    730 //******************************************************************************
    731 //******************************************************************************
    732475BOOL WIN32API ExtFloodFill( HDC arg1, int arg2, int arg3, COLORREF arg4, UINT  arg5)
    733476{
    … …  
    787530{
    788531    return O32_GetBrushOrgEx(arg1, arg2);
    789 }
    790 //******************************************************************************
    791 //******************************************************************************
    792 BOOL WIN32API GetCharABCWidthsA( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
    793 {
    794     return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
    795 }
    796 //******************************************************************************
    797 //******************************************************************************
    798 BOOL WIN32API GetCharABCWidthsW( HDC arg1, UINT arg2, UINT arg3, LPABC arg4)
    799 {
    800     dprintf(("GDI32: GetCharABCWidthsW not properly implemented."));
    801     // NOTE: This will not work as is (needs UNICODE support)
    802     return O32_GetCharABCWidths(arg1, arg2, arg3, arg4);
    803 }
    804 //******************************************************************************
    805 //******************************************************************************
    806 BOOL WIN32API GetCharWidth32A( HDC hdc, UINT iFirstChar, UINT iLastChar, PINT pWidthArray)
    807 {
    808  BOOL ret;
    809 
    810     dprintf(("GDI32: GetCharWidth32A %x %x %x %x", hdc, iFirstChar, iLastChar, pWidthArray));
    811     ret = O32_GetCharWidth(hdc, iFirstChar, iLastChar, pWidthArray);
    812     dprintf(("GDI32: GetCharWidth32A returned %d", ret));
    813 #ifdef DEBUG
    814     if(ret) {
    815       for(int i=iFirstChar;i<iLastChar;i++) {
    816           if((i >= 'a' && i <= 'z') || (i >= 'A' && i <= 'Z')) {
    817                 dprintf2(("Char %c -> width %d", i, pWidthArray[i]));
    818           }
    819           else  dprintf2(("Char %x -> width %d", i, pWidthArray[i]));
    820       }
    821     }
    822 #endif
    823     return ret;
    824 }
    825 //******************************************************************************
    826 //TODO: Cut off Unicode chars?
    827 //******************************************************************************
    828 BOOL WIN32API GetCharWidth32W(HDC hdc, UINT iFirstChar, UINT iLastChar, PINT pWidthArray)
    829 {
    830     dprintf(("GDI32: GetCharWidth32W might not work properly %x %x %x %x", hdc, iFirstChar, iLastChar, pWidthArray));
    831     return O32_GetCharWidth(hdc, iFirstChar, iLastChar, pWidthArray);
    832532}
    833533//******************************************************************************
    … …  
    841541    return rc;
    842542}
     543#ifdef DEBUG
     544//******************************************************************************
     545//******************************************************************************
     546char *GetDeviceCapsString(int nIndex)
     547{
     548    switch(nIndex) {
     549    case DRIVERVERSION:
     550        return "DRIVERVERSION";
     551    case TECHNOLOGY:
     552        return "TECHNOLOGY";
     553    case HORZSIZE:
     554        return "HORZSIZE";
     555    case VERTSIZE:
     556        return "VERTSIZE";
     557    case HORZRES:
     558        return "HORZRES";
     559    case VERTRES:
     560        return "VERTRES";
     561    case BITSPIXEL:
     562        return "BITSPIXEL";
     563    case PLANES:
     564        return "PLANES";
     565    case NUMBRUSHES:
     566        return "NUMBRUSHES";
     567    case NUMPENS:
     568        return "NUMPENS";
     569    case NUMMARKERS:
     570        return "NUMMARKERS";
     571    case NUMFONTS:
     572        return "NUMFONTS";
     573    case NUMCOLORS:
     574        return "NUMCOLORS";
     575    case PDEVICESIZE:
     576        return "PDEVICESIZE";
     577    case CURVECAPS:
     578        return "CURVECAPS";
     579    case LINECAPS:
     580        return "LINECAPS";
     581    case POLYGONALCAPS:
     582        return "POLYGONALCAPS";
     583    case TEXTCAPS:
     584        return "TEXTCAPS";
     585    case CLIPCAPS:
     586        return "CLIPCAPS";
     587    case RASTERCAPS:
     588        return "RASTERCAPS";
     589    case ASPECTX:
     590        return "ASPECTX";
     591    case ASPECTY:
     592        return "ASPECTY";
     593    case ASPECTXY:
     594        return "ASPECTXY";
     595    case LOGPIXELSX:
     596        return "LOGPIXELSX";
     597    case LOGPIXELSY:
     598        return "LOGPIXELSY";
     599    case SIZEPALETTE:
     600        return "SIZEPALETTE";
     601    case NUMRESERVED:
     602        return "NUMRESERVED";
     603    case COLORRES:
     604        return "COLORRES";
     605    case PHYSICALWIDTH:
     606        return "PHYSICALWIDTH";
     607    case PHYSICALHEIGHT:
     608        return "PHYSICALHEIGHT";
     609    case PHYSICALOFFSETX:
     610        return "PHYSICALOFFSETX";
     611    case PHYSICALOFFSETY:
     612        return "PHYSICALOFFSETY";
     613    case SCALINGFACTORX:
     614        return "SCALINGFACTORX";
     615    case SCALINGFACTORY:
     616        return "SCALINGFACTORY";
     617    }
     618    return "unknown";
     619}
     620#endif
    843621//******************************************************************************
    844622//******************************************************************************
    … …  
    848626
    849627    rc = O32_GetDeviceCaps(hdc, nIndex);
    850     dprintf(("GDI32: GetDeviceCaps %X, %d returned %d\n", hdc, nIndex, rc));
     628    dprintf(("GDI32: GetDeviceCaps %x %s returned %d\n", hdc, GetDeviceCapsString(nIndex), rc));
    851629    //SvL: 13-9-'98: NT returns -1 when using 16 bits colors, NOT 65536!
    852630    if(nIndex == NUMCOLORS && rc > 256)
    … …  
    854632
    855633    return(rc);
    856 }
    857 //******************************************************************************
    858 //******************************************************************************
    859 DWORD WIN32API GetKerningPairsA( HDC arg1, DWORD arg2, LPKERNINGPAIR  arg3)
    860 {
    861     return O32_GetKerningPairs(arg1, arg2, arg3);
    862 }
    863 //******************************************************************************
    864 //******************************************************************************
    865 DWORD WIN32API GetKerningPairsW( HDC arg1, DWORD arg2, LPKERNINGPAIR  arg3)
    866 {
    867     dprintf(("GDI32: GetKerningPairsW; might not work"));
    868     // NOTE: This will not work as is (needs UNICODE support)
    869     return O32_GetKerningPairs(arg1, arg2, arg3);
    870634}
    871635//******************************************************************************
    … …  
    952716//******************************************************************************
    953717//******************************************************************************
    954 BOOL WIN32API PolyDraw( HDC arg1, const POINT * arg2, const BYTE * arg3, DWORD  arg4)
    955 {
    956     return O32_PolyDraw(arg1, arg2, arg3, arg4);
    957 }
    958 //******************************************************************************
    959 //******************************************************************************
    960 BOOL WIN32API PolyPolygon( HDC arg1, const POINT * arg2, const INT * arg3, UINT  arg4)
    961 {
    962     return O32_PolyPolygon(arg1, arg2, arg3, arg4);
     718BOOL WIN32API PolyDraw( HDC hdc, const POINT * arg2, const BYTE * arg3, DWORD  arg4)
     719{
     720    return O32_PolyDraw(hdc, arg2, arg3, arg4);
     721}
     722//******************************************************************************
     723//******************************************************************************
     724BOOL WIN32API PolyPolygon( HDC hdc, const POINT * arg2, const INT * arg3, UINT  arg4)
     725{
     726    return O32_PolyPolygon(hdc, arg2, arg3, arg4);
    963727}
    964728//******************************************************************************
    … …  
    972736BOOL WIN32API Polygon( HDC hdc, const POINT *lpPoints, int count)
    973737{
     738    BOOL ret = FALSE;
     739#ifdef DEBUG
     740    if(lpPoints && count) {
     741        for(int i=0;i<count;i++) {
     742            dprintf(("Point (%d,%d)", lpPoints[i].x, lpPoints[i].y));
     743        }
     744    }
     745#endif
    974746    return O32_Polygon(hdc, lpPoints, count);
    975747}
    … …  
    994766//******************************************************************************
    995767//******************************************************************************
    996 HDC WIN32API ResetDCA( HDC arg1, const DEVMODEA *  arg2)
    997 {
    998     return (HDC)O32_ResetDC(arg1, arg2);
    999 }
    1000 //******************************************************************************
    1001 //******************************************************************************
    1002 HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW *  arg2)
    1003 {
    1004     dprintf(("GDI32: ResetDCW: not properly implemented"));
    1005     DebugInt3();
    1006     // NOTE: This will not work as is (needs UNICODE support)
    1007     return (HDC)O32_ResetDC(arg1, (const DEVMODEA *)arg2);
    1008 }
    1009 //******************************************************************************
    1010 //******************************************************************************
    1011 BOOL WIN32API RestoreDC(HDC hdc, int id)
    1012 {
    1013  BOOL ret;
    1014 
    1015     ret = O32_RestoreDC(hdc, id);
    1016     if(ret == FALSE) {
    1017         dprintf(("ERROR: GDI32: RestoreDC %x %d FAILED", hdc, id));
    1018     }
    1019     return ret;
    1020 }
    1021 //******************************************************************************
    1022 //******************************************************************************
    1023768BOOL WIN32API RoundRect( HDC arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int  arg7)
    1024769{
    1025770    return O32_RoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
    1026 }
    1027 //******************************************************************************
    1028 //******************************************************************************
    1029 int WIN32API SaveDC( HDC hdc)
    1030 {
    1031  int id;
    1032 
    1033     id = O32_SaveDC(hdc);
    1034     if(id == 0) {
    1035          dprintf(("ERROR: GDI32: SaveDC %x FAILED", hdc));
    1036     }
    1037     else dprintf(("GDI32: SaveDC %x returned %d", hdc, id));
    1038     return id;
    1039771}
    1040772//******************************************************************************
    … …  
    1128860//******************************************************************************
    1129861//******************************************************************************
    1130 BOOL WIN32API GdiFlush()
    1131 {
    1132   dprintf(("GDI32: GdiFlush, not implemented (TRUE)\n"));
    1133   return(TRUE);
    1134 }
    1135 //******************************************************************************
    1136 //******************************************************************************
    1137862BOOL WIN32API GdiComment(HDC hdc, UINT cbSize, CONST BYTE *lpData)
    1138863{
    … …  
    1143868//******************************************************************************
    1144869//******************************************************************************
    1145 BOOL WIN32API GetCharWidthFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
    1146 {
    1147   dprintf(("GDI32: GetCharWidthFloatA, not implemented\n"));
    1148   return(FALSE);
    1149 }
    1150 //******************************************************************************
    1151 //******************************************************************************
    1152 BOOL WIN32API GetCharWidthFloatW(HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBUffer)
    1153 {
    1154   dprintf(("GDI32: GetCharWidthFloatW, not implemented\n"));
    1155   return(FALSE);
    1156 }
    1157 //******************************************************************************
    1158 //******************************************************************************
    1159 BOOL WIN32API GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT pxBUffer)
    1160 {
    1161   dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
    1162   return(FALSE);
    1163 }
    1164 //******************************************************************************
    1165 //******************************************************************************
    1166 BOOL WIN32API GetCharABCWidthsFloatW(HDC hdc,
    1167                                      UINT iFirstChar,
    1168                                      UINT iLastChar,
    1169                                      LPABCFLOAT pxBUffer)
    1170 {
    1171   dprintf(("GDI32: GetCharABCWidthsFloatA, not implemented\n"));
    1172   return(FALSE);
    1173 }
    1174 //******************************************************************************
    1175 //******************************************************************************
    1176 INT WIN32API ExtEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData,
    1177                        INT cbOutput, LPSTR lpszOutData)
    1178 {
    1179   dprintf(("GDI32: ExtEscape, %x %x %d %x %d %x not implemented", hdc, nEscape, cbInput, lpszInData, cbOutput, lpszOutData));
    1180 #ifdef DEBUG
    1181   if(cbInput && lpszInData) {
    1182         ULONG *tmp = (ULONG *)lpszInData;
    1183         for(int i=0;i<cbInput/4;i++) {
    1184                 dprintf(("GDI32: ExtEscape par %d: %x", i, *tmp++));
    1185         }
    1186   }
    1187 #endif
    1188   return(0);
    1189 }
    1190 //******************************************************************************
    1191 //******************************************************************************
    1192870int WIN32API DrawEscape(HDC hdc, int nEscape, int cbInput, LPCSTR lpszInData)
    1193871{
    … …  
    1204882//******************************************************************************
    1205883//******************************************************************************
    1206 DWORD WIN32API GetGlyphOutlineA(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
    1207                                    DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
    1208 {
    1209   dprintf(("GDI32: GetGlyphOutLineA, not implemented (GDI_ERROR)\n"));
    1210   return(GDI_ERROR);
    1211 }
    1212 //******************************************************************************
    1213 
    1214 //******************************************************************************
    1215 /*KSO Thu 21.05.1998*/
    1216 DWORD WIN32API GetGlyphOutlineW(HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm,
    1217                                    DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
    1218 {
    1219   dprintf(("GDI32: GetGlyphOutLineW, not implemented\n"));
    1220   return(GDI_ERROR);
    1221 }
    1222 //******************************************************************************
    1223 
    1224 //******************************************************************************
     884
    1225885
    1226886/*****************************************************************************
    … …  
    13721032
    13731033
    1374 /*****************************************************************************
    1375  * Name      : DWORD GetCharacterPlacementA
    1376  * Purpose   : The GetCharacterPlacementA function retrieves information about
    1377  *             a character string, such as character widths, caret positioning,
    1378  *             ordering within the string, and glyph rendering. The type of
    1379  *             information returned depends on the dwFlags parameter and is
    1380  *             based on the currently selected font in the given display context.
    1381  *             The function copies the information to the specified GCP_RESULTSA
    1382  *             structure or to one or more arrays specified by the structure.
    1383  * Parameters: HDC     hdc        handle to device context
    1384  *             LPCSTR lpString   pointer to string
    1385  *             int     nCount     number of characters in string
    1386  *             int     nMaxExtent maximum extent for displayed string
    1387  *             LPGCP_RESULTSA *lpResults  pointer to buffer for placement result
    1388  *             DWORD   dwFlags    placement flags
    1389  * Variables :
    1390  * Result    :
    1391  * Remark    :
    1392  * Status    : UNTESTED STUB
    1393  *
    1394  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    1395  *****************************************************************************/
    1396 
    1397 DWORD WIN32API GetCharacterPlacementA(HDC           hdc,
    1398                                          LPCSTR       lpString,
    1399                                          int           nCount,
    1400                                          int           nMaxExtent,
    1401                                          GCP_RESULTSA * lpResults,
    1402                                          DWORD         dwFlags)
    1403 {
    1404   dprintf(("GDI32: GetCharacterPlacementA(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1405            hdc,
    1406            lpString,
    1407            nCount,
    1408            nMaxExtent,
    1409            lpResults,
    1410            dwFlags));
    1411 
    1412   return (0);
    1413 }
    1414 
    1415 
    1416 /*****************************************************************************
    1417  * Name      : DWORD GetCharacterPlacementW
    1418  * Purpose   : The GetCharacterPlacementW function retrieves information about
    1419  *             a character string, such as character widths, caret positioning,
    1420  *             ordering within the string, and glyph rendering. The type of
    1421  *             information returned depends on the dwFlags parameter and is
    1422  *             based on the currently selected font in the given display context.
    1423  *             The function copies the information to the specified GCP_RESULTSW
    1424  *             structure or to one or more arrays specified by the structure.
    1425  * Parameters: HDC     hdc        handle to device context
    1426  *             LPCSTR lpString   pointer to string
    1427  *             int     nCount     number of characters in string
    1428  *             int     nMaxExtent maximum extent for displayed string
    1429  *             GCP_RESULTSW *lpResults  pointer to buffer for placement result
    1430  *             DWORD   dwFlags    placement flags
    1431  * Variables :
    1432  * Result    :
    1433  * Remark    :
    1434  * Status    : UNTESTED STUB
    1435  *
    1436  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    1437  *****************************************************************************/
    1438 
    1439 DWORD WIN32API GetCharacterPlacementW(HDC           hdc,
    1440                                          LPCWSTR       lpString,
    1441                                          int           nCount,
    1442                                          int           nMaxExtent,
    1443                                          GCP_RESULTSW *lpResults,
    1444                                          DWORD         dwFlags)
    1445 {
    1446   dprintf(("GDI32: GetCharacterPlacementW(%08xh,%s,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    1447            hdc,
    1448            lpString,
    1449            nCount,
    1450            nMaxExtent,
    1451            lpResults,
    1452            dwFlags));
    1453 
    1454   return (0);
    1455 }
Note: See TracChangeset for help on using the changeset viewer.