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