git.oblomov.eu Git - wine/blob - 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.  The caller should free the
  44  * returned LPWSTR from the process heap itself.
  45  */
  46 LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
  47 {
  48     UINT cp = CP_ACP;
  49     INT lenW;
  50     LPWSTR strW;
  51     CHARSETINFO csi;
  52     int charset = GetTextCharset(hdc);
  53
  54     /* Hmm, nicely designed api this one! */
  55     if(TranslateCharsetInfo((DWORD*)charset, &csi, TCI_SRCCHARSET))
  56         cp = csi.ciACP;
  57     else {
  58         switch(charset) {
  59         case SYMBOL_CHARSET: /* We don't want any translation here */
  60             cp = GetACP();
  61             break;
  62         case OEM_CHARSET:
  63             cp = GetOEMCP();
  64             break;
  65         case DEFAULT_CHARSET:
  66             cp = GetACP();
  67             break;
  68
  69         case VISCII_CHARSET:
  70         case TCVN_CHARSET:
  71         case KOI8_CHARSET:
  72         case ISO3_CHARSET:
  73         case ISO4_CHARSET:
  74         case ISO10_CHARSET:
  75         case CELTIC_CHARSET:
  76           /* FIXME: These have no place here, but because x11drv
  77              enumerates fonts with these (made up) charsets some apps
  78              might use them and then the FIXME below would become
  79              annoying.  Now we could pick the intended codepage for
  80              each of these, but since it's broken anyway we'll just
  81              use CP_ACP and hope it'll go away...
  82           */
  83             cp = CP_ACP;
  84             break;
  85
  86
  87         default:
  88             FIXME("Can't find codepage for charset %d\n", charset);
  89             break;
  90         }
  91     }
  92
  93     lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
  94     strW = HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
  95     MultiByteToWideChar(cp, 0, str, count, strW, lenW);
  96     strW[lenW] = '\0';
  97     if(plenW) *plenW = lenW;
  98     if(pCP) *pCP = cp;
  99     return strW;
 100 }
 101
 102 /***********************************************************************
 103  *           ExtTextOut (GDI.351)
 104  */
 105 BOOL16 WINAPI ExtTextOut16( HDC16 hdc, INT16 x, INT16 y, UINT16 flags,
 106                             const RECT16 *lprect, LPCSTR str, UINT16 count,
 107                             const INT16 *lpDx )
 108 {
 109     BOOL        ret;
 110     int         i;
 111     RECT        rect32;
 112     LPINT       lpdx32 = NULL;
 113
 114     if (lpDx) {
 115         lpdx32 = (LPINT)HeapAlloc( GetProcessHeap(),0, sizeof(INT)*count );
 116         if(lpdx32 == NULL) return FALSE;
 117         for (i=count;i--;) lpdx32[i]=lpDx[i];
 118     }
 119     if (lprect) CONV_RECT16TO32(lprect,&rect32);
 120     ret = ExtTextOutA(hdc,x,y,flags,lprect?&rect32:NULL,str,count,lpdx32);
 121     if (lpdx32) HeapFree( GetProcessHeap(), 0, lpdx32 );
 122     return ret;
 123 }
 124
 125
 126 /***********************************************************************
 127  *           ExtTextOutA    (GDI32.@)
 128  */
 129 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
 130                          const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
 131 {
 132     INT wlen;
 133     UINT codepage;
 134     LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
 135     BOOL ret;
 136     LPINT lpDxW = NULL;
 137
 138     if (lpDx) {
 139         unsigned int i = 0, j = 0;
 140
 141         lpDxW = (LPINT)HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(INT));
 142         while(i < count) {
 143             if(IsDBCSLeadByteEx(codepage, str[i])) {
 144                 lpDxW[j++] = lpDx[i] + lpDx[i+1];
 145                 i = i + 2;
 146             } else {
 147                 lpDxW[j++] = lpDx[i];
 148                 i = i + 1;
 149             }
 150         }
 151     }
 152
 153     ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
 154
 155     HeapFree( GetProcessHeap(), 0, p );
 156     if (lpDxW) HeapFree( GetProcessHeap(), 0, lpDxW );
 157     return ret;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           ExtTextOutW    (GDI32.@)
 163  */
 164 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
 165                          const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
 166 {
 167     BOOL ret = FALSE;
 168     DC * dc = DC_GetDCUpdate( hdc );
 169     if (dc)
 170     {
 171         if(PATH_IsPathOpen(dc->path))
 172             FIXME("called on an open path\n");
 173         else if(dc->funcs->pExtTextOut)
 174             ret = dc->funcs->pExtTextOut(dc->physDev,x,y,flags,lprect,str,count,lpDx);
 175         GDI_ReleaseObj( hdc );
 176     }
 177     return ret;
 178 }
 179
 180
 181 /***********************************************************************
 182  *           TextOut    (GDI.33)
 183  */
 184 BOOL16 WINAPI TextOut16( HDC16 hdc, INT16 x, INT16 y, LPCSTR str, INT16 count )
 185 {
 186     return ExtTextOut16( hdc, x, y, 0, NULL, str, count, NULL );
 187 }
 188
 189
 190 /***********************************************************************
 191  *           TextOutA    (GDI32.@)
 192  */
 193 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
 194 {
 195     return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
 196 }
 197
 198
 199 /***********************************************************************
 200  *           TextOutW    (GDI32.@)
 201  */
 202 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
 203 {
 204     return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
 205 }
 206
 207
 208 /***********************************************************************
 209  * GetTextCharset [GDI32.@]  Gets character set for font in DC
 210  *
 211  * NOTES
 212  *    Should it return a UINT32 instead of an INT32?
 213  *    => YES, as GetTextCharsetInfo returns UINT32
 214  *
 215  * RETURNS
 216  *    Success: Character set identifier
 217  *    Failure: DEFAULT_CHARSET
 218  */
 219 UINT WINAPI GetTextCharset(
 220     HDC hdc) /* [in] Handle to device context */
 221 {
 222     /* MSDN docs say this is equivalent */
 223     return GetTextCharsetInfo(hdc, NULL, 0);
 224 }
 225
 226 /***********************************************************************
 227  * GetTextCharset [GDI.612]
 228  */
 229 UINT16 WINAPI GetTextCharset16(HDC16 hdc)
 230 {
 231     return (UINT16)GetTextCharset(hdc);
 232 }
 233
 234 /***********************************************************************
 235  * GetTextCharsetInfo [GDI32.@]  Gets character set for font
 236  *
 237  * NOTES
 238  *    Should csi be an LPFONTSIGNATURE instead of an LPCHARSETINFO?
 239  *    Should it return a UINT32 instead of an INT32?
 240  *    => YES and YES, from win32.hlp from Borland
 241  *
 242  *    This returns the actual charset selected by the driver rather than the
 243  *    value in lf.lfCharSet during CreateFont, to get that use
 244  *    GetObject(GetCurrentObject(...),...)
 245  *
 246  * RETURNS
 247  *    Success: Character set identifier
 248  *    Failure: DEFAULT_CHARSET
 249  */
 250 UINT WINAPI GetTextCharsetInfo(
 251     HDC hdc,            /* [in]  Handle to device context */
 252     LPFONTSIGNATURE fs, /* [out] Pointer to struct to receive data */
 253     DWORD flags)        /* [in]  Reserved - must be 0 */
 254 {
 255     UINT charSet = DEFAULT_CHARSET;
 256     CHARSETINFO csinfo;
 257     TEXTMETRICW tm;
 258
 259     if(!GetTextMetricsW(hdc, &tm)) return DEFAULT_CHARSET;
 260     charSet = tm.tmCharSet;
 261
 262     if (fs != NULL) {
 263       if (!TranslateCharsetInfo((LPDWORD)charSet, &csinfo, TCI_SRCCHARSET))
 264            return DEFAULT_CHARSET;
 265       memcpy(fs, &csinfo.fs, sizeof(FONTSIGNATURE));
 266     }
 267     return charSet;
 268 }
 269
 270 /***********************************************************************
 271  *              PolyTextOutA (GDI32.@)
 272  *
 273  * Draw several Strings
 274  */
 275 BOOL WINAPI PolyTextOutA (
 276                           HDC hdc,               /* [in] Handle to device context */
 277                           PPOLYTEXTA pptxt,      /* [in] Array of strings */
 278                           INT cStrings           /* [in] Number of strings in array */
 279                           )
 280 {
 281   FIXME("stub!\n");
 282   SetLastError ( ERROR_CALL_NOT_IMPLEMENTED );
 283   return 0;
 284 }
 285
 286
 287
 288 /***********************************************************************
 289  *              PolyTextOutW (GDI32.@)
 290  *
 291  * Draw several Strings
 292  */
 293 BOOL WINAPI PolyTextOutW (
 294                           HDC hdc,               /* [in] Handle to device context */
 295                           PPOLYTEXTW pptxt,      /* [in] Array of strings */
 296                           INT cStrings           /* [in] Number of strings in array */
 297                           )
 298 {
 299   FIXME("stub!\n");
 300   SetLastError ( ERROR_CALL_NOT_IMPLEMENTED );
 301   return 0;
 302 }