git.oblomov.eu Git - wine/blob - dlls/winex11.drv/codepage.c

   1 /*
   2  * X11 codepage handling
   3  *
   4  * Copyright 2000 Hidenori Takeshima <hidenori@a2.ctktv.ne.jp>
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "x11font.h"
  30
  31 /***********************************************************************
  32  *           IsLegalDBCSChar for cp932/936/949/950/euc
  33  */
  34 static inline
  35 int IsLegalDBCSChar_cp932( BYTE lead, BYTE trail )
  36 {
  37     return ( ( ( lead >= (BYTE)0x81 && lead <= (BYTE)0x9f ) ||
  38                ( lead >= (BYTE)0xe0 && lead <= (BYTE)0xfc ) ) &&
  39              ( ( trail >= (BYTE)0x40 && trail <= (BYTE)0x7e ) ||
  40                ( trail >= (BYTE)0x80 && trail <= (BYTE)0xfc ) ) );
  41 }
  42
  43 static inline
  44 int IsLegalDBCSChar_cp936( BYTE lead, BYTE trail )
  45 {
  46     return ( ( lead >= (BYTE)0x81 && lead <= (BYTE)0xfe ) &&
  47              ( trail >= (BYTE)0x40 && trail <= (BYTE)0xfe ) );
  48 }
  49
  50 static inline
  51 int IsLegalDBCSChar_cp949( BYTE lead, BYTE trail )
  52 {
  53     return ( ( lead >= (BYTE)0x81 && lead <= (BYTE)0xfe ) &&
  54              ( trail >= (BYTE)0x41 && trail <= (BYTE)0xfe ) );
  55 }
  56
  57 static inline
  58 int IsLegalDBCSChar_cp950( BYTE lead, BYTE trail )
  59 {
  60     return (   ( lead >= (BYTE)0x81 && lead <= (BYTE)0xfe ) &&
  61              ( ( trail >= (BYTE)0x40 && trail <= (BYTE)0x7e ) ||
  62                ( trail >= (BYTE)0xa1 && trail <= (BYTE)0xfe ) ) );
  63 }
  64
  65
  66 /***********************************************************************
  67  *           DBCSCharToXChar2b for cp932/euc
  68  */
  69
  70 static inline
  71 void DBCSCharToXChar2b_cp932( XChar2b* pch, BYTE lead, BYTE trail )
  72 {
  73     unsigned int  high, low;
  74
  75     high = (unsigned int)lead;
  76     low = (unsigned int)trail;
  77
  78     if ( high <= 0x9f )
  79         high = (high<<1) - 0xe0;
  80     else
  81         high = (high<<1) - 0x160;
  82     if ( low < 0x9f )
  83     {
  84         high --;
  85         if ( low < 0x7f )
  86             low -= 0x1f;
  87         else
  88             low -= 0x20;
  89     }
  90     else
  91     {
  92         low -= 0x7e;
  93     }
  94
  95     pch->byte1 = (unsigned char)high;
  96     pch->byte2 = (unsigned char)low;
  97 }
  98
  99
 100 static WORD X11DRV_enum_subfont_charset_normal( UINT index )
 101 {
 102     return DEFAULT_CHARSET;
 103 }
 104
 105 static WORD X11DRV_enum_subfont_charset_cp932( UINT index )
 106 {
 107     switch ( index )
 108     {
 109     case 0: return X11FONT_JISX0201_CHARSET;
 110     case 1: return X11FONT_JISX0212_CHARSET;
 111     }
 112
 113     return DEFAULT_CHARSET;
 114 }
 115
 116 static WORD X11DRV_enum_subfont_charset_cp936( UINT index )
 117 {
 118     switch ( index )
 119     {
 120     case 0: return ANSI_CHARSET;
 121     }
 122
 123     return DEFAULT_CHARSET;
 124 }
 125
 126 static WORD X11DRV_enum_subfont_charset_cp949( UINT index )
 127 {
 128     switch ( index )
 129     {
 130     case 0: return ANSI_CHARSET;
 131     }
 132
 133     return DEFAULT_CHARSET;
 134 }
 135
 136 static WORD X11DRV_enum_subfont_charset_cp950( UINT index )
 137 {
 138     switch ( index )
 139     {
 140     case 0: return ANSI_CHARSET;
 141     }
 142
 143     return DEFAULT_CHARSET;
 144 }
 145
 146
 147 static XChar2b* X11DRV_unicode_to_char2b_sbcs( fontObject* pfo,
 148                                                LPCWSTR lpwstr, UINT count )
 149 {
 150     XChar2b *str2b;
 151     UINT i;
 152     char *str;
 153     UINT codepage = pfo->fi->codepage;
 154     char ch = pfo->fs->default_char;
 155
 156     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 157         return NULL;
 158     if (!(str = HeapAlloc( GetProcessHeap(), 0, count )))
 159     {
 160         HeapFree( GetProcessHeap(), 0, str2b );
 161         return NULL;
 162     }
 163
 164     WideCharToMultiByte( codepage, 0, lpwstr, count, str, count, &ch, NULL );
 165
 166     for (i = 0; i < count; i++)
 167     {
 168         str2b[i].byte1 = 0;
 169         str2b[i].byte2 = str[i];
 170     }
 171     HeapFree( GetProcessHeap(), 0, str );
 172
 173     return str2b;
 174 }
 175
 176 static XChar2b* X11DRV_unicode_to_char2b_unicode( fontObject* pfo,
 177                                                   LPCWSTR lpwstr, UINT count )
 178 {
 179     XChar2b *str2b;
 180     UINT i;
 181
 182     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 183         return NULL;
 184
 185     for (i = 0; i < count; i++)
 186     {
 187         str2b[i].byte1 = lpwstr[i] >> 8;
 188         str2b[i].byte2 = lpwstr[i] & 0xff;
 189     }
 190
 191     return str2b;
 192 }
 193
 194 /* FIXME: handle jisx0212.1990... */
 195 static XChar2b* X11DRV_unicode_to_char2b_cp932( fontObject* pfo,
 196                                                 LPCWSTR lpwstr, UINT count )
 197 {
 198     XChar2b *str2b;
 199     XChar2b *str2b_dst;
 200     char *str;
 201     BYTE *str_src;
 202     UINT i;
 203     char ch = pfo->fs->default_char;
 204
 205     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 206         return NULL;
 207     if (!(str = HeapAlloc( GetProcessHeap(), 0, count*2 )))
 208     {
 209         HeapFree( GetProcessHeap(), 0, str2b );
 210         return NULL;
 211     }
 212
 213     /* handle jisx0212.1990... */
 214     WideCharToMultiByte( 932, 0, lpwstr, count, str, count*2, &ch, NULL );
 215
 216     str_src = (BYTE*) str;
 217     str2b_dst = str2b;
 218     for (i = 0; i < count; i++, str_src++, str2b_dst++)
 219     {
 220         if ( IsLegalDBCSChar_cp932( *str_src, *(str_src+1) ) )
 221         {
 222             DBCSCharToXChar2b_cp932( str2b_dst, *str_src, *(str_src+1) );
 223             str_src++;
 224         }
 225         else
 226         {
 227             str2b_dst->byte1 = 0;
 228             str2b_dst->byte2 = *str_src;
 229         }
 230     }
 231
 232     HeapFree( GetProcessHeap(), 0, str );
 233
 234     return str2b;
 235 }
 236
 237
 238 static XChar2b* X11DRV_unicode_to_char2b_cp936( fontObject* pfo,
 239                                                 LPCWSTR lpwstr, UINT count )
 240 {
 241     XChar2b *str2b;
 242     XChar2b *str2b_dst;
 243     char *str;
 244     BYTE *str_src;
 245     UINT i;
 246     char ch = pfo->fs->default_char;
 247
 248     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 249         return NULL;
 250     if (!(str = HeapAlloc( GetProcessHeap(), 0, count*2 )))
 251     {
 252         HeapFree( GetProcessHeap(), 0, str2b );
 253         return NULL;
 254     }
 255     WideCharToMultiByte( 936, 0, lpwstr, count, str, count*2, &ch, NULL );
 256
 257     str_src = (BYTE*) str;
 258     str2b_dst = str2b;
 259     for (i = 0; i < count; i++, str_src++, str2b_dst++)
 260     {
 261         if ( IsLegalDBCSChar_cp936( *str_src, *(str_src+1) ) )
 262         {
 263             str2b_dst->byte1 = *str_src;
 264             str2b_dst->byte2 = *(str_src+1);
 265             str_src++;
 266         }
 267         else
 268         {
 269             str2b_dst->byte1 = 0;
 270             str2b_dst->byte2 = *str_src;
 271         }
 272     }
 273
 274     HeapFree( GetProcessHeap(), 0, str );
 275
 276     return str2b;
 277 }
 278
 279 static XChar2b* X11DRV_unicode_to_char2b_cp949( fontObject* pfo,
 280                                                 LPCWSTR lpwstr, UINT count )
 281 {
 282     XChar2b *str2b;
 283     XChar2b *str2b_dst;
 284     char *str;
 285     BYTE *str_src;
 286     UINT i;
 287     char ch = pfo->fs->default_char;
 288
 289     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 290         return NULL;
 291     if (!(str = HeapAlloc( GetProcessHeap(), 0, count*2 )))
 292     {
 293         HeapFree( GetProcessHeap(), 0, str2b );
 294         return NULL;
 295     }
 296     WideCharToMultiByte( 949, 0, lpwstr, count, str, count*2, &ch, NULL );
 297
 298     str_src = (BYTE*) str;
 299     str2b_dst = str2b;
 300     for (i = 0; i < count; i++, str_src++, str2b_dst++)
 301     {
 302         if ( IsLegalDBCSChar_cp949( *str_src, *(str_src+1) ) )
 303         {
 304             str2b_dst->byte1 = *str_src;
 305             str2b_dst->byte2 = *(str_src+1);
 306             str_src++;
 307         }
 308         else
 309         {
 310             str2b_dst->byte1 = 0;
 311             str2b_dst->byte2 = *str_src;
 312         }
 313     }
 314
 315     HeapFree( GetProcessHeap(), 0, str );
 316
 317     return str2b;
 318 }
 319
 320
 321 static XChar2b* X11DRV_unicode_to_char2b_cp950( fontObject* pfo,
 322                                                 LPCWSTR lpwstr, UINT count )
 323 {
 324     XChar2b *str2b;
 325     XChar2b *str2b_dst;
 326     char *str;
 327     BYTE *str_src;
 328     UINT i;
 329     char ch = pfo->fs->default_char;
 330
 331     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 332         return NULL;
 333     if (!(str = HeapAlloc( GetProcessHeap(), 0, count*2 )))
 334     {
 335         HeapFree( GetProcessHeap(), 0, str2b );
 336         return NULL;
 337     }
 338     WideCharToMultiByte( 950, 0, lpwstr, count, str, count*2, &ch, NULL );
 339
 340     str_src = (BYTE*) str;
 341     str2b_dst = str2b;
 342     for (i = 0; i < count; i++, str_src++, str2b_dst++)
 343     {
 344         if ( IsLegalDBCSChar_cp950( *str_src, *(str_src+1) ) )
 345         {
 346             str2b_dst->byte1 = *str_src;
 347             str2b_dst->byte2 = *(str_src+1);
 348             str_src++;
 349         }
 350         else
 351         {
 352             str2b_dst->byte1 = 0;
 353             str2b_dst->byte2 = *str_src;
 354         }
 355     }
 356
 357     HeapFree( GetProcessHeap(), 0, str );
 358
 359     return str2b;
 360 }
 361
 362 static XChar2b* X11DRV_unicode_to_char2b_symbol( fontObject* pfo,
 363                                                  LPCWSTR lpwstr, UINT count )
 364 {
 365     XChar2b *str2b;
 366     UINT i;
 367     char ch = pfo->fs->default_char;
 368
 369     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
 370         return NULL;
 371
 372     for (i = 0; i < count; i++)
 373     {
 374         str2b[i].byte1 = 0;
 375         if(lpwstr[i] >= 0xf000 && lpwstr[i] < 0xf100)
 376             str2b[i].byte2 = lpwstr[i] - 0xf000;
 377         else if(lpwstr[i] < 0x100)
 378             str2b[i].byte2 = lpwstr[i];
 379         else
 380             str2b[i].byte2 = ch;
 381     }
 382
 383     return str2b;
 384 }
 385
 386
 387 static void X11DRV_DrawString_normal( fontObject* pfo, Display* pdisp,
 388                                       Drawable d, GC gc, int x, int y,
 389                                       XChar2b* pstr, int count )
 390 {
 391     wine_tsx11_lock();
 392     XDrawString16( pdisp, d, gc, x, y, pstr, count );
 393     wine_tsx11_unlock();
 394 }
 395
 396 static int X11DRV_TextWidth_normal( fontObject* pfo, XChar2b* pstr, int count )
 397 {
 398     int ret;
 399     wine_tsx11_lock();
 400     ret = XTextWidth16( pfo->fs, pstr, count );
 401     wine_tsx11_unlock();
 402     return ret;
 403 }
 404
 405 static void X11DRV_DrawText_normal( fontObject* pfo, Display* pdisp, Drawable d,
 406                                     GC gc, int x, int y, XTextItem16* pitems,
 407                                     int count )
 408 {
 409     wine_tsx11_lock();
 410     XDrawText16( pdisp, d, gc, x, y, pitems, count );
 411     wine_tsx11_unlock();
 412 }
 413
 414 static void X11DRV_TextExtents_normal( fontObject* pfo, XChar2b* pstr, int count,
 415                                        int* pdir, int* pascent, int* pdescent,
 416                                        int* pwidth, int max_extent, int* pfit,
 417                                        int* partial_extents )
 418 {
 419     XCharStruct info;
 420     int ascent, descent, width;
 421     int i, fit;
 422
 423     width = 0;
 424     fit = 0;
 425     *pascent = 0;
 426     *pdescent = 0;
 427     wine_tsx11_lock();
 428     for ( i = 0; i < count; i++ )
 429     {
 430         XTextExtents16( pfo->fs, pstr, 1, pdir, &ascent, &descent, &info );
 431         if ( *pascent < ascent ) *pascent = ascent;
 432         if ( *pdescent < descent ) *pdescent = descent;
 433         width += info.width;
 434         if ( partial_extents ) partial_extents[i] = width;
 435         if ( width < max_extent ) fit++;
 436
 437         pstr++;
 438     }
 439     wine_tsx11_unlock();
 440     *pwidth = width;
 441     if ( pfit ) *pfit = fit;
 442 }
 443
 444 static void X11DRV_GetTextMetricsW_normal( fontObject* pfo, LPTEXTMETRICW pTM )
 445 {
 446     LPIFONTINFO16 pdf = &pfo->fi->df;
 447
 448     if( ! pfo->lpX11Trans ) {
 449       pTM->tmAscent = pfo->fs->ascent;
 450       pTM->tmDescent = pfo->fs->descent;
 451     } else {
 452       pTM->tmAscent = pfo->lpX11Trans->ascent;
 453       pTM->tmDescent = pfo->lpX11Trans->descent;
 454     }
 455
 456     pTM->tmAscent *= pfo->rescale;
 457     pTM->tmDescent *= pfo->rescale;
 458
 459     pTM->tmHeight = pTM->tmAscent + pTM->tmDescent;
 460
 461     pTM->tmAveCharWidth = pfo->foAvgCharWidth * pfo->rescale;
 462     pTM->tmMaxCharWidth = pfo->foMaxCharWidth * pfo->rescale;
 463
 464     pTM->tmInternalLeading = pfo->foInternalLeading * pfo->rescale;
 465     pTM->tmExternalLeading = pdf->dfExternalLeading * pfo->rescale;
 466
 467     pTM->tmStruckOut = (pfo->fo_flags & FO_SYNTH_STRIKEOUT )
 468                         ? 1 : pdf->dfStrikeOut;
 469     pTM->tmUnderlined = (pfo->fo_flags & FO_SYNTH_UNDERLINE )
 470                         ? 1 : pdf->dfUnderline;
 471
 472     pTM->tmOverhang = 0;
 473     if( pfo->fo_flags & FO_SYNTH_ITALIC )
 474     {
 475         pTM->tmOverhang += pTM->tmHeight/3;
 476         pTM->tmItalic = 1;
 477     } else
 478         pTM->tmItalic = pdf->dfItalic;
 479
 480     pTM->tmWeight = pdf->dfWeight;
 481     if( pfo->fo_flags & FO_SYNTH_BOLD )
 482     {
 483         pTM->tmOverhang++;
 484         pTM->tmWeight += 100;
 485     }
 486
 487     pTM->tmFirstChar = pdf->dfFirstChar;
 488     pTM->tmLastChar = pdf->dfLastChar;
 489     pTM->tmDefaultChar = pdf->dfDefaultChar;
 490     pTM->tmBreakChar = pdf->dfBreakChar;
 491
 492     pTM->tmCharSet = pdf->dfCharSet;
 493     pTM->tmPitchAndFamily = pdf->dfPitchAndFamily;
 494
 495     pTM->tmDigitizedAspectX = pdf->dfHorizRes;
 496     pTM->tmDigitizedAspectY = pdf->dfVertRes;
 497 }
 498
 499
 500
 501 static
 502 void X11DRV_DrawString_dbcs( fontObject* pfo, Display* pdisp,
 503                              Drawable d, GC gc, int x, int y,
 504                              XChar2b* pstr, int count )
 505 {
 506     XTextItem16 item;
 507
 508     item.chars = pstr;
 509     item.delta = 0;
 510     item.nchars = count;
 511     item.font = None;
 512     X11DRV_cptable[pfo->fi->cptable].pDrawText(
 513                 pfo, pdisp, d, gc, x, y, &item, 1 );
 514 }
 515
 516 static
 517 int X11DRV_TextWidth_dbcs_2fonts( fontObject* pfo, XChar2b* pstr, int count )
 518 {
 519     int i;
 520     int width;
 521     int curfont;
 522     fontObject* pfos[X11FONT_REFOBJS_MAX+1];
 523
 524     pfos[0] = XFONT_GetFontObject( pfo->prefobjs[0] );
 525     pfos[1] = pfo;
 526     if ( pfos[0] == NULL ) pfos[0] = pfo;
 527
 528     width = 0;
 529     wine_tsx11_lock();
 530     for ( i = 0; i < count; i++ )
 531     {
 532         curfont = ( pstr->byte1 != 0 ) ? 1 : 0;
 533         width += XTextWidth16( pfos[curfont]->fs, pstr, 1 );
 534         pstr ++;
 535     }
 536     wine_tsx11_unlock();
 537     return width;
 538 }
 539
 540 static
 541 void X11DRV_DrawText_dbcs_2fonts( fontObject* pfo, Display* pdisp, Drawable d,
 542                                   GC gc, int x, int y, XTextItem16* pitems,
 543                                   int count )
 544 {
 545     int i, nitems, prevfont = -1, curfont;
 546     XChar2b* pstr;
 547     XTextItem16* ptibuf;
 548     XTextItem16* pti;
 549     fontObject* pfos[X11FONT_REFOBJS_MAX+1];
 550
 551     pfos[0] = XFONT_GetFontObject( pfo->prefobjs[0] );
 552     pfos[1] = pfo;
 553     if ( pfos[0] == NULL ) pfos[0] = pfo;
 554
 555     nitems = 0;
 556     for ( i = 0; i < count; i++ )
 557         nitems += pitems->nchars;
 558     ptibuf = HeapAlloc( GetProcessHeap(), 0, sizeof(XTextItem16) * nitems );
 559     if ( ptibuf == NULL )
 560         return; /* out of memory */
 561
 562     pti = ptibuf;
 563     while ( count-- > 0 )
 564     {
 565         pti->chars = pstr = pitems->chars;
 566         pti->delta = pitems->delta;
 567         pti->font = None;
 568         for ( i = 0; i < pitems->nchars; i++, pstr++ )
 569         {
 570             curfont = ( pstr->byte1 != 0 ) ? 1 : 0;
 571             if ( curfont != prevfont )
 572             {
 573                 if ( pstr != pti->chars )
 574                 {
 575                     pti->nchars = pstr - pti->chars;
 576                     pti ++;
 577                     pti->chars = pstr;
 578                     pti->delta = 0;
 579                 }
 580                 pti->font = pfos[curfont]->fs->fid;
 581                 prevfont = curfont;
 582             }
 583         }
 584         pti->nchars = pstr - pti->chars;
 585         pitems ++; pti ++;
 586     }
 587     wine_tsx11_lock();
 588     XDrawText16( pdisp, d, gc, x, y, ptibuf, pti - ptibuf );
 589     wine_tsx11_unlock();
 590     HeapFree( GetProcessHeap(), 0, ptibuf );
 591 }
 592
 593 static
 594 void X11DRV_TextExtents_dbcs_2fonts( fontObject* pfo, XChar2b* pstr, int count,
 595                                      int* pdir, int* pascent, int* pdescent,
 596                                      int* pwidth, int max_extent, int* pfit,
 597                                      int* partial_extents )
 598 {
 599     XCharStruct info;
 600     int ascent, descent, width;
 601     int i;
 602     int fit;
 603     int curfont;
 604     fontObject* pfos[X11FONT_REFOBJS_MAX+1];
 605
 606     pfos[0] = XFONT_GetFontObject( pfo->prefobjs[0] );
 607     pfos[1] = pfo;
 608     if ( pfos[0] == NULL ) pfos[0] = pfo;
 609
 610     width = 0;
 611     fit = 0;
 612     *pascent = 0;
 613     *pdescent = 0;
 614     wine_tsx11_lock();
 615     for ( i = 0; i < count; i++ )
 616     {
 617         curfont = ( pstr->byte1 != 0 ) ? 1 : 0;
 618         XTextExtents16( pfos[curfont]->fs, pstr, 1, pdir, &ascent, &descent, &info );
 619         if ( *pascent < ascent ) *pascent = ascent;
 620         if ( *pdescent < descent ) *pdescent = descent;
 621         width += info.width;
 622         if ( partial_extents ) partial_extents[i] = width;
 623         if ( width <= max_extent ) fit++;
 624
 625         pstr ++;
 626     }
 627     wine_tsx11_unlock();
 628     *pwidth = width;
 629     if ( pfit ) *pfit = fit;
 630 }
 631
 632 static void X11DRV_GetTextMetricsW_cp932( fontObject* pfo, LPTEXTMETRICW pTM )
 633 {
 634     fontObject* pfo_ansi = XFONT_GetFontObject( pfo->prefobjs[0] );
 635     LPIFONTINFO16 pdf = &pfo->fi->df;
 636     LPIFONTINFO16 pdf_ansi;
 637
 638     pdf_ansi = ( pfo_ansi != NULL ) ? (&pfo_ansi->fi->df) : pdf;
 639
 640     if( ! pfo->lpX11Trans ) {
 641       pTM->tmAscent = pfo->fs->ascent;
 642       pTM->tmDescent = pfo->fs->descent;
 643     } else {
 644       pTM->tmAscent = pfo->lpX11Trans->ascent;
 645       pTM->tmDescent = pfo->lpX11Trans->descent;
 646     }
 647
 648     pTM->tmAscent *= pfo->rescale;
 649     pTM->tmDescent *= pfo->rescale;
 650
 651     pTM->tmHeight = pTM->tmAscent + pTM->tmDescent;
 652
 653     if ( pfo_ansi != NULL )
 654     {
 655         pTM->tmAveCharWidth = floor((pfo_ansi->foAvgCharWidth * 2.0 + pfo->foAvgCharWidth) / 3.0 * pfo->rescale + 0.5);
 656         pTM->tmMaxCharWidth = max(pfo_ansi->foMaxCharWidth, pfo->foMaxCharWidth) * pfo->rescale;
 657     }
 658     else
 659     {
 660         pTM->tmAveCharWidth = floor((pfo->foAvgCharWidth * pfo->rescale + 1.0) / 2.0);
 661         pTM->tmMaxCharWidth = pfo->foMaxCharWidth * pfo->rescale;
 662     }
 663
 664     pTM->tmInternalLeading = pfo->foInternalLeading * pfo->rescale;
 665     pTM->tmExternalLeading = pdf->dfExternalLeading * pfo->rescale;
 666
 667     pTM->tmStruckOut = (pfo->fo_flags & FO_SYNTH_STRIKEOUT )
 668                         ? 1 : pdf->dfStrikeOut;
 669     pTM->tmUnderlined = (pfo->fo_flags & FO_SYNTH_UNDERLINE )
 670                         ? 1 : pdf->dfUnderline;
 671
 672     pTM->tmOverhang = 0;
 673     if( pfo->fo_flags & FO_SYNTH_ITALIC )
 674     {
 675         pTM->tmOverhang += pTM->tmHeight/3;
 676         pTM->tmItalic = 1;
 677     } else
 678         pTM->tmItalic = pdf->dfItalic;
 679
 680     pTM->tmWeight = pdf->dfWeight;
 681     if( pfo->fo_flags & FO_SYNTH_BOLD )
 682     {
 683         pTM->tmOverhang++;
 684         pTM->tmWeight += 100;
 685     }
 686
 687     pTM->tmFirstChar = pdf_ansi->dfFirstChar;
 688     pTM->tmLastChar = pdf_ansi->dfLastChar;
 689     pTM->tmDefaultChar = pdf_ansi->dfDefaultChar;
 690     pTM->tmBreakChar = pdf_ansi->dfBreakChar;
 691
 692     pTM->tmCharSet = pdf->dfCharSet;
 693     pTM->tmPitchAndFamily = pdf->dfPitchAndFamily;
 694
 695     pTM->tmDigitizedAspectX = pdf->dfHorizRes;
 696     pTM->tmDigitizedAspectY = pdf->dfVertRes;
 697 }
 698
 699
 700
 701
 702
 703 const X11DRV_CP X11DRV_cptable[X11DRV_CPTABLE_COUNT] =
 704 {
 705     { /* SBCS */
 706         X11DRV_enum_subfont_charset_normal,
 707         X11DRV_unicode_to_char2b_sbcs,
 708         X11DRV_DrawString_normal,
 709         X11DRV_TextWidth_normal,
 710         X11DRV_DrawText_normal,
 711         X11DRV_TextExtents_normal,
 712         X11DRV_GetTextMetricsW_normal,
 713     },
 714     { /* UNICODE */
 715         X11DRV_enum_subfont_charset_normal,
 716         X11DRV_unicode_to_char2b_unicode,
 717         X11DRV_DrawString_normal,
 718         X11DRV_TextWidth_normal,
 719         X11DRV_DrawText_normal,
 720         X11DRV_TextExtents_normal,
 721         X11DRV_GetTextMetricsW_normal,
 722     },
 723     { /* CP932 */
 724         X11DRV_enum_subfont_charset_cp932,
 725         X11DRV_unicode_to_char2b_cp932,
 726         X11DRV_DrawString_dbcs,
 727         X11DRV_TextWidth_dbcs_2fonts,
 728         X11DRV_DrawText_dbcs_2fonts,
 729         X11DRV_TextExtents_dbcs_2fonts,
 730         X11DRV_GetTextMetricsW_cp932,
 731     },
 732     { /* CP936 */
 733         X11DRV_enum_subfont_charset_cp936,
 734         X11DRV_unicode_to_char2b_cp936,
 735         X11DRV_DrawString_dbcs,
 736         X11DRV_TextWidth_dbcs_2fonts,
 737         X11DRV_DrawText_dbcs_2fonts,
 738         X11DRV_TextExtents_dbcs_2fonts,
 739         X11DRV_GetTextMetricsW_normal, /* FIXME */
 740     },
 741     { /* CP949 */
 742         X11DRV_enum_subfont_charset_cp949,
 743         X11DRV_unicode_to_char2b_cp949,
 744         X11DRV_DrawString_dbcs,
 745         X11DRV_TextWidth_dbcs_2fonts,
 746         X11DRV_DrawText_dbcs_2fonts,
 747         X11DRV_TextExtents_dbcs_2fonts,
 748         X11DRV_GetTextMetricsW_normal, /* FIXME */
 749     },
 750     { /* CP950 */
 751         X11DRV_enum_subfont_charset_cp950,
 752         X11DRV_unicode_to_char2b_cp950,
 753         X11DRV_DrawString_dbcs,
 754         X11DRV_TextWidth_dbcs_2fonts,
 755         X11DRV_DrawText_dbcs_2fonts,
 756         X11DRV_TextExtents_dbcs_2fonts,
 757         X11DRV_GetTextMetricsW_cp932,
 758     },
 759     { /* SYMBOL */
 760         X11DRV_enum_subfont_charset_normal,
 761         X11DRV_unicode_to_char2b_symbol,
 762         X11DRV_DrawString_normal,
 763         X11DRV_TextWidth_normal,
 764         X11DRV_DrawText_normal,
 765         X11DRV_TextExtents_normal,
 766         X11DRV_GetTextMetricsW_normal,
 767     }
 768 };