Ignore:
Timestamp:
Dec 16, 1999, 5:52:33 PM (26 years ago)
Author:
cbratschi
Message:

text output API changes, line speed improvements

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gdi32/text.cpp

    r2052 r2092  
    1 /* $Id: text.cpp,v 1.4 1999-12-10 08:34:06 achimha Exp $ */
     1/* $Id: text.cpp,v 1.5 1999-12-16 16:52:33 cbratschi Exp $ */
    22
    33/*
    … …  
    77 *
    88 * Copyright 1993, 1994 Alexandre Julliard
    9  *
     9 * Copyright 1999 Christoph Bratschi
    1010 *
    1111 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    1717#include <string.h>
    1818#include "oslibgpi.h"
     19
     20#define ELLIPSIS    "..."
     21#define ELLIPSISLEN 3
     22
     23typedef struct _POLYTEXTA
     24{
     25    int     x;
     26    int     y;
     27    UINT    n;
     28    LPCSTR lpstr;
     29    UINT    uiFlags;
     30    RECT    rcl;
     31    int     *pdx;
     32} POLYTEXTA;
     33
     34typedef struct _POLYTEXTW
     35{
     36    int     x;
     37    int     y;
     38    UINT    n;
     39    LPCWSTR lpstr;
     40    UINT    uiFlags;
     41    RECT    rcl;
     42    int     *pdx;
     43} POLYTEXTW;
    1944
    2045//******************************************************************************
    … …  
    6489// CB: USER32 function, but here is the better place
    6590//******************************************************************************
    66 INT WIN32API InternalDrawTextExA(HDC hdc,LPCSTR lpchText,INT cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams)
    67 {
    68   //CB: todo
    69   dprintf(("GDI32: InternalDrawTextExA, unimplemented stub!\n"));
     91INT SYSTEM EXPORT InternalDrawTextExA(HDC hdc,LPCSTR lpchText,INT cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams,BOOL isDrawTextEx)
     92{
     93/*
     94  PVOID pHps = OSLibGpiQueryDCData(hdc);
     95  INT rc;
     96  ULONG flCmd;
     97  RECT localRectangle;
     98  PRECT rectPtr;
     99  LONG lTabs,xLeft,yTop;
     100
     101  if (!lpchText || cchText == 0 || cchText < -1 || !lprc == NULL)
     102  {
     103    SetLastError(ERROR_INVALID_PARAMETER);
     104    return 0;
     105  }
     106
     107  if (!pHps)
     108  {
     109    SetLastError(ERROR_INVALID_HANDLE);
     110    return 0;
     111  }
     112
     113  if (cchText == -1)
     114  {
     115    cchText = strlen(lpchText);
     116    if (cchText == 0)
     117      return 0; //CB: does Win32 return textheight in this case?
     118  }
     119
     120  if (lpDTParams)
     121  {
     122    // set margins
     123    lprc->left += lpDTParams->iLeftMargin;
     124    lprc->right -= lpDTParams->iRightMargin;
     125
     126    // just assume all the text has been drawn
     127    lpDTParams->uiLengthDrawn = cchText;
     128  }
     129
     130  if (!(dwDTFormat & DT_CALCRECT))
     131  {
     132    BOOL bTopBottomIsOkay;
     133
     134    if ((getIsTopTop(pHps) && lprc->top > lprc->bottom) ||
     135        (!getIsTopTop(pHps) && lprc->top < lprc->bottom))
     136      bTopBottomIsOkay = FALSE;
     137    else
     138      bTopBottomIsOkay = TRUE;
     139
     140    if (lprc->left >= lprc->right || !bTopBottomIsOkay)
     141    {
     142      TEXTMETRICA txtMetrics;
     143      BOOL result;
     144
     145      result = GetTextMetricsA(hdc,&txtMetrics);
     146      if (result)
     147        rc = (int)txtMetrics.tmHeight;
     148      else
     149        rc = 0;
     150
     151      if (lpDTParams)
     152      {
     153        lprc->left -= lpDTParams->iLeftMargin;
     154        lprc->right += lpDTParams->iRightMargin;
     155      }
     156
     157      return rc;
     158    }
     159  }
     160
     161  flCmd = DTOS_INVERT | DTOS_WORLDRECT | DTOS_TEXTATTRS | DTOS_AMPERSAND | DTOS_VERTICALEXTENT;
     162
     163  LONG lMixMode = OSLibGpiQueryBackMix(pHps);
     164  if (lMixMode == BMOS_OVERPAINT) flCmd |= DTOS_OPAQUE;
     165
     166  if (dwDTFormat & DT_CALCRECT)
     167  {
     168    rectPtr = lprc;
     169    flCmd |= DTOS_QUERYEXTENT;
     170
     171    xLeft = rectPtr->left;
     172    yTop = rectPtr->top;
     173
     174    if (dwDTFormat & DT_RIGHT)
     175    {
     176      if (rectPtr->left >= rectPtr->right)
     177        rectPtr->left = rectPtr->right-1;
     178    } else
     179    {
     180      if (rectPtr->right <= rectPtr->left)
     181        rectPtr->right = rectPtr->left+1;
     182    }
     183
     184    if (dwDTFormat & DT_BOTTOM)
     185    {
     186      if (rectPtr->top >= rectPtr->bottom)
     187        rectPtr->top = rectPtr->bottom-1;
     188    } else
     189    {
     190      if (rectPtr->bottom <= rectPtr->top)
     191        rectPtr->bottom = rectPtr->top+1;
     192    }
     193  } else
     194  {
     195    rectPtr = &localRectangle;
     196
     197    if (getMapMode(pHps) == MMOS_ANISOTROPIC || getMapMode(pHps) == MMOS_ISOTROPIC)
     198    {
     199      if (doesYAxisGrowNorth(pHps))
     200      {
     201        flCmd &= ~DTOS_INVERT;
     202        flCmd |=  DTOS_INVERTCHAR;
     203      }
     204    }
     205
     206    if (lprc->left > lprc->right)
     207    {
     208      rectPtr->left  = lprc->right;
     209      rectPtr->right = lprc->left;
     210    } else
     211    {
     212      rectPtr->left  = lprc->left;
     213      rectPtr->right = lprc->right;
     214    }
     215    if (lprc->top > lprc->bottom)
     216    {
     217      rectPtr->top    = lprc->bottom;
     218      rectPtr->bottom = lprc->top;
     219    } else
     220    {
     221      rectPtr->top    = lprc->top;
     222      rectPtr->bottom = lprc->bottom;
     223    }
     224  }
     225
     226  if (dwDTFormat & DT_EXPANDTABS)
     227  {
     228    if (isDrawTextEx)
     229    {
     230      lTabs = (lpDTParams && dwDTFormat & DT_TABSTOP) ? lpDTParams->iTabLength:8;
     231    } else
     232    {
     233      lTabs = 8;
     234
     235      if (dwDTFormat & DT_TABSTOP)
     236      {
     237        lTabs = (dwDTFormat >> 8) & 0x000000FF;
     238        dwDTFormat &= 0xFFFF00FF;
     239      }
     240    }
     241  } else lTabs = -1;
     242
     243  if (dwDTFormat & DT_RIGHT)
     244    flCmd |= DTOS_RIGHT;
     245  else
     246    if (dwDTFormat & DT_CENTER) flCmd |= DTOS_CENTER;
     247  if (dwDTFormat & DT_BOTTOM)          flCmd |= DTOS_BOTTOM;
     248  if (dwDTFormat & DT_VCENTER)         flCmd |= DTOS_VCENTER;
     249  if (dwDTFormat & DT_WORDBREAK)       flCmd |= DTOS_WORDBREAK;
     250  if (dwDTFormat & DT_EXTERNALLEADING) flCmd |= DTOS_EXTERNALLEADING;
     251  if (!(dwDTFormat & DT_NOPREFIX))     flCmd |= DTOS_MNEMONIC;
     252  if (dwDTFormat & DT_SINGLELINE)
     253    flCmd |= DTOS_SINGLELINE;
     254  else
     255    flCmd |= DTOS_MULTILINE;
     256  if (dwDTFormat & DT_NOCLIP)          flCmd |= DTOS_NOCLIP;
     257
     258  //CB: DT_EDITCONTROL, DT_RTLREADING ignored
     259
     260  BOOL done = FALSE;
     261
     262  if (dwDTFormat & DT_END_ELLIPSIS && cchText > 1)
     263  {
     264    int textWidth,width;
     265    RECT rect;
     266
     267    SetRectEmpty(&rect);
     268    OSLibWinDrawTabbedText(pHps,cchText,lTabs,lpchText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     269    width = rectPtr->right-rectPtr->left;
     270    textWidth = rect.right-rect.left;
     271    if (textWidth > width && width > 0)
     272    {
     273      char* newText;
     274      int newTextLen = cchText-1+ELLIPSISLEN;
     275      int preLen = cchText-1;
     276
     277      newText = (char*)malloc(newTextLen+1);
     278      strncpy(newText,lpchText,cchText-1);
     279      do
     280      {
     281        strcpy(&newText[preLen],ELLIPSIS);
     282        OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     283        textWidth = rect.right-rect.left;
     284        if (textWidth <= width || preLen == 1) break;
     285        newTextLen--;
     286        preLen--;
     287      } while (TRUE);
     288      rc = OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,rectPtr,0,0,flCmd);
     289      if (dwDTFormat & DT_MODIFYSTRING) strcpy((LPSTR)lpchText,newText); //check length?
     290      free(newText);
     291
     292      done = TRUE;
     293    }
     294  } else if (dwDTFormat & DT_PATH_ELLIPSIS && cchText > 1)
     295  {
     296    int textWidth,width;
     297    RECT rect;
     298
     299//CB: code not yet checked (-> testcase)
     300
     301    SetRectEmpty(&rect);
     302    OSLibWinDrawTabbedText(pHps,cchText,lTabs,lpchText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     303    width = rectPtr->right-rectPtr->left;
     304    textWidth = rect.right-rect.left;
     305    if (textWidth > width && width > 0)
     306    {
     307      char *newText,*slashPos;
     308      int newTextLen = cchText+ELLIPSISLEN;
     309
     310      newText = (char*)malloc(newTextLen+1);
     311      strncpy(newText,lpchText,cchText);
     312      slashPos = strrchr(newText,(int)"\\");
     313      if (slashPos != NULL)
     314      {
     315        int preLen = slashPos-newText;
     316        char* endPtr = (char*)lpchText+preLen;
     317        int endLen = cchText-preLen;
     318        BOOL ok = FALSE;
     319
     320        //delete start
     321        do
     322        {
     323          strcpy(&newText[preLen],ELLIPSIS);
     324          strncpy(&newText[preLen+ELLIPSISLEN],endPtr,endLen);
     325          OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     326          textWidth = rect.right-rect.left;
     327          if (textWidth <= width)
     328          {
     329            ok = TRUE;
     330            break;
     331          }
     332          if (preLen == 0) break;
     333          newTextLen--;
     334          preLen--;
     335        } while (TRUE);
     336
     337        if (!ok)
     338        {
     339          //delete end
     340          do
     341          {
     342            endPtr++;
     343            endLen--;
     344            newTextLen--;
     345            strncpy(&newText[ELLIPSISLEN],endPtr,endLen);
     346            OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     347            textWidth = rect.right-rect.left;
     348            if (textWidth <= width || endLen == 0) break;
     349          } while (TRUE);
     350        }
     351      } else
     352      {
     353        int preLen,endLen;
     354
     355        preLen = cchText/2;
     356        endLen = cchText-preLen; //endLen >= preLen
     357        char* endPtr = (char*)lpchText+preLen;
     358
     359        do
     360        {
     361          strcpy(&newText[preLen],ELLIPSIS);
     362          strncpy(&newText[preLen+ELLIPSISLEN],endPtr,endLen);
     363          OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,&rect,0,0,flCmd | DTOS_QUERYEXTENT);
     364          textWidth = rect.right-rect.left;
     365          if (textWidth <= width || preLen+endLen == 0) break;
     366          if (endLen > preLen)
     367          {
     368            endLen--;
     369            endPtr++;
     370          } else preLen--;
     371          newTextLen--;
     372        } while (TRUE);
     373      }
     374      rc = OSLibWinDrawTabbedText(pHps,newTextLen,lTabs,newText,rectPtr,0,0,flCmd);
     375      if (dwDTFormat & DT_MODIFYSTRING) strcpy((LPSTR)lpchText,newText); //check length?
     376      free(newText);
     377
     378      done = TRUE;
     379    }
     380  }
     381
     382  if (!done)
     383    rc = OSLibWinDrawTabbedText(pHps,cchText,lTabs,lpchText,rectPtr,0,0,flCmd);
     384
     385  if (dwDTFormat & DT_CALCRECT)
     386  {
     387    if (!(dwDTFormat & DT_RIGHT) && (rectPtr->left < xLeft))
     388    {
     389      rectPtr->right = xLeft+(rectPtr->right-rectPtr->left);
     390      rectPtr->left = xLeft;
     391    }
     392    if (!(dwDTFormat & DT_BOTTOM) && (rectPtr->top < yTop))
     393    {
     394      rectPtr->bottom = yTop+(rectPtr->bottom-rectPtr->top);
     395      rectPtr->top = yTop;
     396    }
     397  }
     398
     399  if (lpDTParams)
     400  {
     401    // don't forget to restore the margins
     402    lprc->left -= lpDTParams->iLeftMargin;
     403    lprc->right += lpDTParams->iRightMargin;
     404  }
     405
     406  return rc;
     407*/
     408
     409  dwDTFormat &= ~(DT_END_ELLIPSIS | DT_PATH_ELLIPSIS);
     410  return O32_DrawText(hdc,lpchText,cchText,lprc,dwDTFormat);
     411}
     412//******************************************************************************
     413//******************************************************************************
     414INT SYSTEM EXPORT InternalDrawTextExW(HDC hdc,LPCWSTR lpchText,INT cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams,BOOL isDrawTextEx)
     415{
     416  char *astring = (cchText == -1) ? UnicodeToAsciiString((LPWSTR)lpchText):UnicodeToAsciiStringN((LPWSTR)lpchText,cchText);
     417  INT  rc;
     418
     419  rc = InternalDrawTextExA(hdc,astring,cchText,lprc,dwDTFormat,lpDTParams,isDrawTextEx);
     420  if (dwDTFormat & DT_MODIFYSTRING && (dwDTFormat & (DT_END_ELLIPSIS | DT_PATH_ELLIPSIS))) AsciiToUnicode(astring,(LPWSTR)lpchText);
     421  FreeAsciiString(astring);
     422
     423  return(rc);
     424}
     425//******************************************************************************
     426// CB: USER32 function, but here is the better place
     427//******************************************************************************
     428DWORD SYSTEM EXPORT InternalGetTabbedTextExtentA(HDC hDC,LPCSTR lpString,INT nCount,INT nTabPositions,LPINT lpnTabStopPositions)
     429{
     430  PVOID pHps = OSLibGpiQueryDCData(hDC);
     431  BOOL result;
     432  POINTLOS2 pts[TXTBOXOS_COUNT];
     433  POINTLOS2 widthHeight = {0,0};
     434
     435  if (!pHps || nCount == 0 || nTabPositions < 0)
     436    return 0;
     437
     438  if (nCount < 0)
     439  {
     440    SetLastError(ERROR_STACK_OVERFLOW);
     441    return 0;
     442  }
     443  if (lpString == NULL || nCount >  512 || (nTabPositions > 0 && lpnTabStopPositions == NULL))
     444  {
     445    SetLastError(ERROR_INVALID_PARAMETER);
     446    return 0;
     447  }
     448  //CB: Win95 supports negative values for right aligned text
     449  for (INT i = 0;i < nTabPositions;i++)
     450  {
     451    if (lpnTabStopPositions[i] < 0)
     452    {
     453      SetLastError(ERROR_INVALID_PARAMETER);
     454      return 0;
     455    }
     456  }
     457
     458  result = OSLibGpiQueryTextBox(pHps,(nCount > 1) ? 1:nCount,lpString,TXTBOXOS_COUNT,pts);
     459  if (result == FALSE)
     460    return 0;
     461  calcDimensions(pts,&widthHeight);
     462
     463  LONG rv1 = OSLibGpiQueryTabbedTextExtent(pHps,nCount,lpString,nTabPositions,lpnTabStopPositions);
     464  if (rv1 == GPIOS_ERROR)
     465    return 0;
     466
     467  return (widthHeight.y <<16)+labs(rv1);
     468}
     469//******************************************************************************
     470//******************************************************************************
     471DWORD SYSTEM EXPORT InternalGetTabbedTextExtentW(HDC hDC,LPCWSTR lpString,INT nCount,INT nTabPositions,LPINT lpnTabStopPositions)
     472{
     473  char *astring = (nCount == -1) ? UnicodeToAsciiString((LPWSTR)lpString):UnicodeToAsciiStringN((LPWSTR)lpString,nCount);
     474  DWORD rc;
     475
     476  rc = InternalGetTabbedTextExtentA(hDC,astring,nCount,nTabPositions,lpnTabStopPositions);
     477  FreeAsciiString(astring);
     478
     479  return(rc);
     480}
     481//******************************************************************************
     482// CB: USER32 function, but here is the better place
     483//******************************************************************************
     484LONG SYSTEM EXPORT InternalTabbedTextOutA(HDC hdc,INT x,INT y,LPCSTR lpString,INT nCount,INT nTabPositions,LPINT lpnTabStopPositions,INT nTabOrigin)
     485{
     486  PVOID pHps = OSLibGpiQueryDCData(hdc);
     487  POINTLOS2 ptl;
     488  DWORD dimensions;
     489
     490  if (pHps == NULL || lpString == NULL)
     491  {
     492    SetLastError(ERROR_INVALID_HANDLE);
     493    return 0;
     494  }
     495  if (nCount == -1)
     496    nCount = strlen(lpString);
     497  if (nCount < 1)
     498  {
     499    SetLastError(ERROR_INVALID_HANDLE);
     500    return 0;
     501  }
     502  if (lpnTabStopPositions == NULL)
     503    nTabPositions = 0;
     504  if (nTabPositions == 0)
     505    lpnTabStopPositions = NULL;
     506  if (nTabPositions < 0)
     507  {
     508    SetLastError(ERROR_INVALID_HANDLE);
     509    return 0;
     510  }
     511  if (getAlignUpdateCP(pHps) == TRUE)
     512    OSLibGpiQueryCurrentPosition(pHps,&ptl);
     513  else
     514  {
     515    ptl.x = x;
     516    ptl.y = y;
     517  }
     518
     519  //CB: nTabOrigin is ignored! -> wrong size (width)!
     520  //    todo: change low word (width), height is ok
     521  dimensions = InternalGetTabbedTextExtentA(hdc,lpString,nCount,nTabPositions,lpnTabStopPositions);
     522  if (dimensions != 0)
     523  {
     524    LONG rcGPI;
     525
     526    ptl.y += getWorldYDeltaFor1Pixel(pHps);
     527
     528    rcGPI = OSLibGpiTabbedCharStringAt(pHps,&ptl,NULL,0,nCount,lpString,nTabPositions,lpnTabStopPositions,nTabOrigin);
     529    if (rcGPI == GPIOS_ALTERROR)
     530      return 0;
     531    if (getAlignUpdateCP(pHps))
     532    {
     533      OSLibGpiQueryCurrentPosition (pHps,&ptl);
     534      ptl.y -= getWorldYDeltaFor1Pixel(pHps);
     535      OSLibGpiSetCurrentPosition (pHps,&ptl);
     536    }
     537
     538    return dimensions;
     539  }
    70540  return 0;
    71541}
    72542//******************************************************************************
    73543//******************************************************************************
    74 INT WIN32API InternalDrawTextExW(HDC hdc,LPWSTR lpchText,INT cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams)
    75 {
    76   char *astring = UnicodeToAsciiStringN((LPWSTR)lpchText,cchText);
    77   INT  rc;
    78 
    79   rc = InternalDrawTextExA(hdc,astring,cchText,lprc,dwDTFormat,lpDTParams);
    80   FreeAsciiString(astring);
    81 
    82   return(rc);
    83 }
    84 //******************************************************************************
    85 // CB: USER32 function, but here is the better place
    86 //******************************************************************************
    87 LONG WIN32API InternalTabbedTextOutA( HDC hdc, int x, int y, LPCSTR lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions, int  nTabOrigin)
    88 {
    89   //CB: todo
    90   dprintf(("GDI32: InternalTabbedTextOutA, unimplemented stub!\n"));
    91   return 0;
    92 }
    93 //******************************************************************************
    94 //******************************************************************************
    95 LONG WIN32API InternalTabbedTextOutW( HDC hdc, int x, int y, LPCWSTR lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions, int  nTabOrigin)
    96 {
    97   char *astring = UnicodeToAsciiStringN((LPWSTR)lpString,nCount);
     544LONG SYSTEM EXPORT InternalTabbedTextOutW(HDC hdc,INT x,INT y,LPCWSTR lpString,INT nCount,INT nTabPositions,LPINT lpnTabStopPositions,INT nTabOrigin)
     545{
     546  char *astring = (nCount == -1) ? UnicodeToAsciiString((LPWSTR)lpString):UnicodeToAsciiStringN((LPWSTR)lpString,nCount);
    98547  LONG rc;
    99548
    100549  rc = InternalTabbedTextOutA(hdc,x,y,astring,nCount,nTabPositions,lpnTabStopPositions,nTabOrigin);
    101   FreeAsciiString(astring);
    102 
    103   return(rc);
    104 }
    105 //******************************************************************************
    106 // CB: USER32 function, but here is the better place
    107 //******************************************************************************
    108 DWORD WIN32API InternalGetTabbedTextExtentA( HDC hDC, LPCSTR lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions)
    109 {
    110   //CB: todo
    111   dprintf(("GDI32: InternalGetTabbedTexExtentA, unimplemented stub!\n"));
    112   return 0;
    113 }
    114 //******************************************************************************
    115 //******************************************************************************
    116 DWORD WIN32API InternalGetTabbedTextExtentW( HDC hDC, LPCWSTR lpString, int nCount, int nTabPositions, LPINT lpnTabStopPositions)
    117 {
    118   char *astring = UnicodeToAsciiStringN((LPWSTR)lpString,nCount);
    119   DWORD rc;
    120 
    121   rc = InternalGetTabbedTextExtentA(hDC,astring,nCount,nTabPositions,lpnTabStopPositions);
    122550  FreeAsciiString(astring);
    123551
    … …  
    188616    flOptions |= CHSOS_VECTOR;
    189617
    190   if (getAlignUpdateCP(pHps) == FALSE)
     618  if (!getAlignUpdateCP(pHps))
    191619  {
    192620    ptl.x = X;
    … …  
    199627  LONG pmHAlign,pmVAlign;
    200628
    201   //CB: TA_RIGHT not supported, only TA_CENTER and TA_LEFT
     629  //CB: TA_RIGHT not supported by PM, only TA_CENTER and TA_LEFT
    202630  if ((align & 0x6) == TA_RIGHT)
    203631  {
    … …  
    225653
    226654  if (hits == GPIOS_ERROR)
    227   {
    228655    return FALSE;
    229   }
     656
    230657  if (getAlignUpdateCP(pHps))
    231658  {
    … …  
    241668BOOL InternalTextOutW(HDC hdc,int X,int Y,UINT fuOptions,CONST RECT *lprc,LPCWSTR lpszString,INT cbCount,CONST INT *lpDx,BOOL IsExtTextOut)
    242669{
    243   char *astring = UnicodeToAsciiStringN((LPWSTR)lpszString,cbCount);
     670  char *astring = (cbCount == -1) ? UnicodeToAsciiString((LPWSTR)lpszString):UnicodeToAsciiStringN((LPWSTR)lpszString,cbCount);
    244671  BOOL  rc;
    245672
    … …  
    283710//******************************************************************************
    284711//******************************************************************************
     712BOOL WIN32API PolyTextOutA(HDC hdc,POLYTEXTA *pptxt,int cStrings)
     713{
     714  dprintf(("GDI32: PolyTextOutA"));
     715
     716  for (INT x = 0;x < cStrings;x++)
     717  {
     718    BOOL rc;
     719
     720    rc = InternalTextOutA(hdc,pptxt[x].x,pptxt[x].y,pptxt[x].uiFlags,&pptxt[x].rcl,pptxt[x].lpstr,pptxt[x].n,pptxt[x].pdx,TRUE);
     721    if (!rc) return FALSE;
     722  }
     723
     724  return TRUE;
     725}
     726//******************************************************************************
     727//******************************************************************************
     728BOOL WIN32API PolyTextOutW(HDC hdc,POLYTEXTW *pptxt,int cStrings)
     729{
     730  dprintf(("GDI32: PolyTextOutW"));
     731
     732  for (INT x = 0;x < cStrings;x++)
     733  {
     734    BOOL rc;
     735
     736    rc = InternalTextOutW(hdc,pptxt[x].x,pptxt[x].y,pptxt[x].uiFlags,&pptxt[x].rcl,pptxt[x].lpstr,pptxt[x].n,pptxt[x].pdx,TRUE);
     737    if (!rc) return FALSE;
     738  }
     739
     740  return TRUE;
     741}
Note: See TracChangeset for help on using the changeset viewer.