graphics/x11drv/codepage.c

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