objects/text.c

   1 /*
   2  * text functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <string.h>
  22
  23 #include "windef.h"
  24 #include "wingdi.h"
  25 #include "wine/winuser16.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "gdi.h"
  29 #include "wine/debug.h"
  30 #include "winnls.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(text);
  33
  34 /***********************************************************************
  35  *           FONT_mbtowc
  36  *
  37  * Returns a '\0' terminated Unicode translation of str using the
  38  * charset of the currently selected font in hdc.  If count is -1 then
  39  * str is assumed to be '\0' terminated, otherwise it contains the
  40  * number of bytes to convert.  If plenW is non-NULL, on return it
  41  * will point to the number of WCHARs (excluding the '\0') that have
  42  * been written.  If pCP is non-NULL, on return it will point to the
  43  * codepage used in the conversion (NB, this may be CP_SYMBOL so watch
  44  * out).  The caller should free the returned LPWSTR from the process
  45  * heap itself.
  46  */
  47 LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
  48 {
  49     UINT cp = CP_ACP;
  50     INT lenW, i;
  51     LPWSTR strW;
  52     CHARSETINFO csi;
  53     int charset = GetTextCharset(hdc);
  54
  55     /* Hmm, nicely designed api this one! */
  56     if(TranslateCharsetInfo((DWORD*)charset, &csi, TCI_SRCCHARSET))
  57         cp = csi.ciACP;
  58     else {
  59         switch(charset) {
  60         case OEM_CHARSET:
  61             cp = GetOEMCP();
  62             break;
  63         case DEFAULT_CHARSET:
  64             cp = GetACP();
  65             break;
  66
  67         case VISCII_CHARSET:
  68         case TCVN_CHARSET:
  69         case KOI8_CHARSET:
  70         case ISO3_CHARSET:
  71         case ISO4_CHARSET:
  72         case ISO10_CHARSET:
  73         case CELTIC_CHARSET:
  74           /* FIXME: These have no place here, but because x11drv
  75              enumerates fonts with these (made up) charsets some apps
  76              might use them and then the FIXME below would become
  77              annoying.  Now we could pick the intended codepage for
  78              each of these, but since it's broken anyway we'll just
  79              use CP_ACP and hope it'll go away...
  80           */
  81             cp = CP_ACP;
  82             break;
  83
  84
  85         default:
  86             FIXME("Can't find codepage for charset %d\n", charset);
  87             break;
  88         }
  89     }
  90
  91     TRACE("cp == %d\n", cp);
  92
  93     if(count == -1) count = strlen(str);
  94     if(cp != CP_SYMBOL) {
  95         lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
  96         strW = HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
  97         MultiByteToWideChar(cp, 0, str, count, strW, lenW);
  98     } else {
  99         lenW = count;
 100         strW = HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
 101         for(i = 0; i < count; i++) strW[i] = (BYTE)str[i];
 102     }
 103     strW[lenW] = '\0';
 104     TRACE("mapped %s -> %s\n", debugstr_an(str, count), debugstr_wn(strW, lenW));
 105     if(plenW) *plenW = lenW;
 106     if(pCP) *pCP = cp;
 107     return strW;
 108 }
 109
 110
 111 /***********************************************************************
 112  *           ExtTextOutA    (GDI32.@)
 113  */
 114 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
 115                          const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
 116 {
 117     INT wlen;
 118     UINT codepage;
 119     LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
 120     BOOL ret;
 121     LPINT lpDxW = NULL;
 122
 123     if (lpDx) {
 124         unsigned int i = 0, j = 0;
 125
 126         lpDxW = (LPINT)HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(INT));
 127         while(i < count) {
 128             if(IsDBCSLeadByteEx(codepage, str[i])) {
 129                 lpDxW[j++] = lpDx[i] + lpDx[i+1];
 130                 i = i + 2;
 131             } else {
 132                 lpDxW[j++] = lpDx[i];
 133                 i = i + 1;
 134             }
 135         }
 136     }
 137
 138     ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
 139
 140     HeapFree( GetProcessHeap(), 0, p );
 141     if (lpDxW) HeapFree( GetProcessHeap(), 0, lpDxW );
 142     return ret;
 143 }
 144
 145
 146 /***********************************************************************
 147  *           ExtTextOutW    (GDI32.@)
 148  */
 149 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
 150                          const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
 151 {
 152     BOOL ret = FALSE;
 153     DC * dc = DC_GetDCUpdate( hdc );
 154     if (dc)
 155     {
 156         if(PATH_IsPathOpen(dc->path))
 157             FIXME("called on an open path\n");
 158                 else if(dc->funcs->pExtTextOut)
 159                 {
 160                         if( !(flags&(ETO_GLYPH_INDEX|ETO_IGNORELANGUAGE)) )
 161                         {
 162                                 /* The caller did not specify that language processing was already done,
 163                                  * and the font idetifies iteself as requiring language processing.
 164                                  */
 165                                 GCP_RESULTSW gcp;
 166
 167                                 gcp.lStructSize=sizeof(gcp);
 168                                 gcp.lpOutString=HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
 169                                 gcp.lpOrder=NULL;
 170                                 gcp.lpDx=NULL;
 171                                 gcp.lpCaretPos=NULL;
 172                                 gcp.lpClass=NULL;
 173                                 gcp.lpGlyphs=NULL;
 174                                 gcp.nGlyphs=0;
 175                                 gcp.nMaxFit=0;
 176
 177                                 GetCharacterPlacementW(hdc, str, count, 0, &gcp, GCP_REORDER );
 178
 179                                 ret = dc->funcs->pExtTextOut(dc->physDev,x,y,flags|ETO_IGNORELANGUAGE,
 180                                         lprect,gcp.lpOutString,count,lpDx);
 181                                 HeapFree(GetProcessHeap(), 0, gcp.lpOutString);
 182                         } else
 183                                 ret = dc->funcs->pExtTextOut(dc->physDev,x,y,flags,lprect,str,count,lpDx);
 184                 }
 185                 GDI_ReleaseObj( hdc );
 186     }
 187     return ret;
 188 }
 189
 190
 191 /***********************************************************************
 192  *           TextOutA    (GDI32.@)
 193  */
 194 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
 195 {
 196     return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
 197 }
 198
 199
 200 /***********************************************************************
 201  *           TextOutW    (GDI32.@)
 202  */
 203 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
 204 {
 205     return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
 206 }
 207
 208
 209 /***********************************************************************
 210  * GetTextCharset [GDI32.@]  Gets character set for font in DC
 211  *
 212  * NOTES
 213  *    Should it return a UINT32 instead of an INT32?
 214  *    => YES, as GetTextCharsetInfo returns UINT32
 215  *
 216  * RETURNS
 217  *    Success: Character set identifier
 218  *    Failure: DEFAULT_CHARSET
 219  */
 220 UINT WINAPI GetTextCharset(
 221     HDC hdc) /* [in] Handle to device context */
 222 {
 223     /* MSDN docs say this is equivalent */
 224     return GetTextCharsetInfo(hdc, NULL, 0);
 225 }
 226
 227
 228 /***********************************************************************
 229  * GetTextCharsetInfo [GDI32.@]  Gets character set for font
 230  *
 231  * NOTES
 232  *    Should csi be an LPFONTSIGNATURE instead of an LPCHARSETINFO?
 233  *    Should it return a UINT32 instead of an INT32?
 234  *    => YES and YES, from win32.hlp from Borland
 235  *
 236  *    This returns the actual charset selected by the driver rather than the
 237  *    value in lf.lfCharSet during CreateFont, to get that use
 238  *    GetObject(GetCurrentObject(...),...)
 239  *
 240  * RETURNS
 241  *    Success: Character set identifier
 242  *    Failure: DEFAULT_CHARSET
 243  */
 244 UINT WINAPI GetTextCharsetInfo(
 245     HDC hdc,            /* [in]  Handle to device context */
 246     LPFONTSIGNATURE fs, /* [out] Pointer to struct to receive data */
 247     DWORD flags)        /* [in]  Reserved - must be 0 */
 248 {
 249     UINT charSet = DEFAULT_CHARSET;
 250     CHARSETINFO csinfo;
 251     TEXTMETRICW tm;
 252
 253     if(!GetTextMetricsW(hdc, &tm)) return DEFAULT_CHARSET;
 254     charSet = tm.tmCharSet;
 255
 256     if (fs != NULL) {
 257       if (!TranslateCharsetInfo((LPDWORD)charSet, &csinfo, TCI_SRCCHARSET))
 258            return DEFAULT_CHARSET;
 259       memcpy(fs, &csinfo.fs, sizeof(FONTSIGNATURE));
 260     }
 261     return charSet;
 262 }
 263
 264 /***********************************************************************
 265  *              PolyTextOutA (GDI32.@)
 266  *
 267  * Draw several Strings
 268  */
 269 BOOL WINAPI PolyTextOutA (
 270                           HDC hdc,               /* [in] Handle to device context */
 271                           PPOLYTEXTA pptxt,      /* [in] Array of strings */
 272                           INT cStrings           /* [in] Number of strings in array */
 273                           )
 274 {
 275   FIXME("stub!\n");
 276   SetLastError ( ERROR_CALL_NOT_IMPLEMENTED );
 277   return 0;
 278 }
 279
 280
 281
 282 /***********************************************************************
 283  *              PolyTextOutW (GDI32.@)
 284  *
 285  * Draw several Strings
 286  */
 287 BOOL WINAPI PolyTextOutW (
 288                           HDC hdc,               /* [in] Handle to device context */
 289                           PPOLYTEXTW pptxt,      /* [in] Array of strings */
 290                           INT cStrings           /* [in] Number of strings in array */
 291                           )
 292 {
 293   FIXME("stub!\n");
 294   SetLastError ( ERROR_CALL_NOT_IMPLEMENTED );
 295   return 0;
 296 }