graphics/x11drv/text.c

   1 /*
   2  * X11 graphics driver text functions
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <X11/Xatom.h>
  10
  11 #include "ts_xlib.h"
  12
  13 #include <stdlib.h>
  14 #include <math.h>
  15
  16 #include "windef.h"
  17 #include "winnls.h"
  18 #include "dc.h"
  19 #include "gdi.h"
  20 #include "heap.h"
  21 #include "x11font.h"
  22 #include "debugtools.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(text);
  25
  26 #define SWAP_INT(a,b)  { int t = a; a = b; b = t; }
  27 #define IROUND(x) (int)((x)>0? (x)+0.5 : (x) - 0.5)
  28
  29
  30 /***********************************************************************
  31  *        unicode_to_char2b
  32  *
  33  * dup a Unicode string into a XChar2b array; must be HeapFree'd by the caller
  34  */
  35 static XChar2b *unicode_to_char2b( LPCWSTR wstr, UINT count, UINT codepage, UINT def_char )
  36 {
  37     XChar2b *str2b;
  38     UINT i;
  39
  40     if (!(str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) )))
  41         return NULL;
  42
  43     if (codepage != 0)  /* multibyte font */
  44     {
  45         BYTE *str;
  46         char ch = def_char;
  47         CPINFO cpinfo;
  48
  49         /* allocate the worst case count * 2 bytes */
  50         if (!(str = HeapAlloc( GetProcessHeap(), 0, count * 2 )))
  51         {
  52             HeapFree( GetProcessHeap(), 0, str2b );
  53             return NULL;
  54         }
  55
  56         /* we have to convert from unicode to codepage first */
  57         WideCharToMultiByte( codepage, 0, wstr, count, str, count, &ch, NULL );
  58
  59         GetCPInfo( codepage, &cpinfo );
  60
  61         if (cpinfo.MaxCharSize == 1)
  62         {
  63             for (i = 0; i < count; i++)
  64             {
  65                 str2b[i].byte1 = 0;
  66                 str2b[i].byte2 = str[i];
  67             }
  68         }
  69         else
  70         {
  71             XChar2b *str2b_dst = str2b;
  72             for (i = 0; i < count; i++, str2b_dst++)
  73             {
  74                 str2b_dst->byte2 = str[i];
  75                 if (IsDBCSLeadByteEx( codepage, str[i] ))
  76                 {
  77                     str2b_dst->byte1 = str[i + 1];
  78                     i++;
  79                 }
  80                 else
  81                     str2b_dst->byte1 = 0;
  82             }
  83         }
  84         HeapFree( GetProcessHeap(), 0, str );
  85     }
  86     else  /* codepage 0 -> unicode font */
  87     {
  88         for (i = 0; i < count; i++)
  89         {
  90             str2b[i].byte1 = wstr[i] >> 8;
  91             str2b[i].byte2 = wstr[i] & 0xff;
  92         }
  93     }
  94     return str2b;
  95 }
  96
  97
  98 /***********************************************************************
  99  *           X11DRV_ExtTextOut
 100  */
 101 BOOL
 102 X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
 103                    const RECT *lprect, LPCWSTR wstr, UINT count,
 104                    const INT *lpDx )
 105 {
 106     int                 i;
 107     fontObject*         pfo;
 108     INT                 width, ascent, descent, xwidth, ywidth;
 109     XFontStruct*        font;
 110     RECT                rect;
 111     char                dfBreakChar, lfUnderline, lfStrikeOut;
 112     BOOL                rotated = FALSE;
 113     X11DRV_PDEVICE      *physDev = (X11DRV_PDEVICE *)dc->physDev;
 114     XChar2b             *str2b = NULL;
 115     BOOL                dibUpdateFlag = FALSE;
 116     BOOL                result = TRUE;
 117
 118     if (!X11DRV_SetupGCForText( dc )) return TRUE;
 119
 120     pfo = XFONT_GetFontObject( physDev->font );
 121     font = pfo->fs;
 122
 123     if (pfo->lf.lfEscapement && pfo->lpX11Trans)
 124         rotated = TRUE;
 125     dfBreakChar = (char)pfo->fi->df.dfBreakChar;
 126     lfUnderline = (pfo->fo_flags & FO_SYNTH_UNDERLINE) ? 1 : 0;
 127     lfStrikeOut = (pfo->fo_flags & FO_SYNTH_STRIKEOUT) ? 1 : 0;
 128
 129     TRACE("hdc=%04x df=%04x %d,%d %s, %d  flags=%d lpDx=%p\n",
 130           dc->hSelf, (UINT16)(physDev->font), x, y,
 131           debugstr_wn (wstr, count), count, flags, lpDx);
 132
 133     /* some strings sent here end in a newline for whatever reason.  I have no
 134        clue what the right treatment should be in general, but ignoring
 135        terminating newlines seems ok.  MW, April 1998.  */
 136     if (count > 0 && wstr[count - 1] == '\n') count--;
 137
 138     if (lprect != NULL) TRACE("\trect=(%d,%d - %d,%d)\n",
 139                                      lprect->left, lprect->top,
 140                                      lprect->right, lprect->bottom );
 141       /* Setup coordinates */
 142
 143     if (dc->w.textAlign & TA_UPDATECP)
 144     {
 145         x = dc->w.CursPosX;
 146         y = dc->w.CursPosY;
 147     }
 148
 149     if (flags & (ETO_OPAQUE | ETO_CLIPPED))  /* there's a rectangle */
 150     {
 151         if (!lprect)  /* not always */
 152         {
 153             SIZE sz;
 154             if (flags & ETO_CLIPPED)  /* Can't clip with no rectangle */
 155               return FALSE;
 156             if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
 157               return FALSE;
 158             rect.left   = XLPTODP( dc, x );
 159             rect.right  = XLPTODP( dc, x+sz.cx );
 160             rect.top    = YLPTODP( dc, y );
 161             rect.bottom = YLPTODP( dc, y+sz.cy );
 162         }
 163         else
 164         {
 165             rect.left   = XLPTODP( dc, lprect->left );
 166             rect.right  = XLPTODP( dc, lprect->right );
 167             rect.top    = YLPTODP( dc, lprect->top );
 168             rect.bottom = YLPTODP( dc, lprect->bottom );
 169         }
 170         if (rect.right < rect.left) SWAP_INT( rect.left, rect.right );
 171         if (rect.bottom < rect.top) SWAP_INT( rect.top, rect.bottom );
 172     }
 173
 174     x = XLPTODP( dc, x );
 175     y = YLPTODP( dc, y );
 176
 177     TRACE("\treal coord: x=%i, y=%i, rect=(%d,%d - %d,%d)\n",
 178                           x, y, rect.left, rect.top, rect.right, rect.bottom);
 179
 180       /* Draw the rectangle */
 181
 182     if (flags & ETO_OPAQUE)
 183     {
 184         X11DRV_DIB_UpdateDIBSection( dc, FALSE );
 185         dibUpdateFlag = TRUE;
 186         TSXSetForeground( display, physDev->gc, physDev->backgroundPixel );
 187         TSXFillRectangle( display, physDev->drawable, physDev->gc,
 188                         dc->w.DCOrgX + rect.left, dc->w.DCOrgY + rect.top,
 189                         rect.right-rect.left, rect.bottom-rect.top );
 190     }
 191     if (!count) goto END;  /* Nothing more to do */
 192
 193       /* Compute text starting position */
 194
 195     if (lpDx) /* have explicit character cell x offsets in logical coordinates */
 196     {
 197         int extra = dc->wndExtX / 2;
 198         for (i = width = 0; i < count; i++) width += lpDx[i];
 199         width = (width * dc->vportExtX + extra ) / dc->wndExtX;
 200     }
 201     else
 202     {
 203         SIZE sz;
 204         if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
 205             return FALSE;
 206         width = XLSTODS(dc, sz.cx);
 207     }
 208     ascent = pfo->lpX11Trans ? pfo->lpX11Trans->ascent : font->ascent;
 209     descent = pfo->lpX11Trans ? pfo->lpX11Trans->descent : font->descent;
 210     xwidth = pfo->lpX11Trans ? width * pfo->lpX11Trans->a /
 211       pfo->lpX11Trans->pixelsize : width;
 212     ywidth = pfo->lpX11Trans ? width * pfo->lpX11Trans->b /
 213       pfo->lpX11Trans->pixelsize : 0;
 214
 215     switch( dc->w.textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER) )
 216     {
 217       case TA_LEFT:
 218           if (dc->w.textAlign & TA_UPDATECP) {
 219               dc->w.CursPosX = XDPTOLP( dc, x + xwidth );
 220               dc->w.CursPosY = YDPTOLP( dc, y - ywidth );
 221           }
 222           break;
 223       case TA_RIGHT:
 224           x -= xwidth;
 225           y += ywidth;
 226           if (dc->w.textAlign & TA_UPDATECP) {
 227               dc->w.CursPosX = XDPTOLP( dc, x );
 228               dc->w.CursPosY = YDPTOLP( dc, y );
 229           }
 230           break;
 231       case TA_CENTER:
 232           x -= xwidth / 2;
 233           y += ywidth / 2;
 234           break;
 235     }
 236
 237     switch( dc->w.textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
 238     {
 239       case TA_TOP:
 240           x -= pfo->lpX11Trans ? ascent * pfo->lpX11Trans->c /
 241             pfo->lpX11Trans->pixelsize : 0;
 242           y += pfo->lpX11Trans ? ascent * pfo->lpX11Trans->d /
 243             pfo->lpX11Trans->pixelsize : ascent;
 244           break;
 245       case TA_BOTTOM:
 246           x += pfo->lpX11Trans ? descent * pfo->lpX11Trans->c /
 247             pfo->lpX11Trans->pixelsize : 0;
 248           y -= pfo->lpX11Trans ? descent * pfo->lpX11Trans->d /
 249             pfo->lpX11Trans->pixelsize : descent;
 250           break;
 251       case TA_BASELINE:
 252           break;
 253     }
 254
 255       /* Set the clip region */
 256
 257     if (flags & ETO_CLIPPED)
 258     {
 259         SaveVisRgn16( dc->hSelf );
 260         CLIPPING_IntersectVisRect( dc, rect.left, rect.top, rect.right,
 261                                    rect.bottom, FALSE );
 262     }
 263
 264       /* Draw the text background if necessary */
 265
 266     if (!dibUpdateFlag)
 267     {
 268         X11DRV_DIB_UpdateDIBSection( dc, FALSE );
 269         dibUpdateFlag = TRUE;
 270     }
 271
 272     if (dc->w.backgroundMode != TRANSPARENT)
 273     {
 274           /* If rectangle is opaque and clipped, do nothing */
 275         if (!(flags & ETO_CLIPPED) || !(flags & ETO_OPAQUE))
 276         {
 277               /* Only draw if rectangle is not opaque or if some */
 278               /* text is outside the rectangle */
 279             if (!(flags & ETO_OPAQUE) ||
 280                 (x < rect.left) ||
 281                 (x + width >= rect.right) ||
 282                 (y - ascent < rect.top) ||
 283                 (y + descent >= rect.bottom))
 284             {
 285                 TSXSetForeground( display, physDev->gc,
 286                                   physDev->backgroundPixel );
 287                 TSXFillRectangle( display, physDev->drawable, physDev->gc,
 288                                 dc->w.DCOrgX + x,
 289                                 dc->w.DCOrgY + y - ascent,
 290                                 width,
 291                                 ascent + descent );
 292             }
 293         }
 294     }
 295
 296     /* Draw the text (count > 0 verified) */
 297     if (!(str2b = unicode_to_char2b( wstr, count, pfo->fi->codepage, pfo->fs->default_char )))
 298         goto FAIL;
 299
 300     TSXSetForeground( display, physDev->gc, physDev->textPixel );
 301     if(!rotated)
 302     {
 303       if (!dc->w.charExtra && !dc->w.breakExtra && !lpDx)
 304       {
 305         TSXDrawString16( display, physDev->drawable, physDev->gc,
 306                          dc->w.DCOrgX + x, dc->w.DCOrgY + y, str2b, count );
 307       }
 308       else  /* Now the fun begins... */
 309       {
 310         XTextItem16 *items, *pitem;
 311         int delta;
 312
 313         /* allocate max items */
 314
 315         pitem = items = HeapAlloc( GetProcessHeap(), 0,
 316                                    count * sizeof(XTextItem16) );
 317         if(items == NULL) goto FAIL;
 318         delta = i = 0;
 319         if( lpDx ) /* explicit character widths */
 320         {
 321             int extra = dc->wndExtX / 2;
 322
 323             while (i < count)
 324             {
 325                 /* initialize text item with accumulated delta */
 326
 327                 pitem->chars  = str2b + i;
 328                 pitem->delta  = delta;
 329                 pitem->nchars = 0;
 330                 pitem->font   = None;
 331                 delta = 0;
 332
 333                 /* add characters  to the same XTextItem until new delta
 334                  * becomes  non-zero */
 335
 336                 do
 337                 {
 338                     delta += (lpDx[i] * dc->vportExtX + extra) / dc->wndExtX
 339                       - TSXTextWidth16( font, str2b + i, 1);
 340                     pitem->nchars++;
 341                 } while ((++i < count) && !delta);
 342                 pitem++;
 343            }
 344         }
 345         else /* charExtra or breakExtra */
 346         {
 347             while (i < count)
 348             {
 349                 pitem->chars  = str2b + i;
 350                 pitem->delta  = delta;
 351                 pitem->nchars = 0;
 352                 pitem->font   = None;
 353                 delta = 0;
 354
 355                 do
 356                 {
 357                     delta += dc->w.charExtra;
 358                     if (str2b[i].byte2 == (char)dfBreakChar)
 359                       delta += dc->w.breakExtra;
 360                     pitem->nchars++;
 361                 } while ((++i < count) && !delta);
 362                 pitem++;
 363             }
 364         }
 365
 366         TSXDrawText16( display, physDev->drawable, physDev->gc,
 367                    dc->w.DCOrgX + x, dc->w.DCOrgY + y, items, pitem - items );
 368         HeapFree( GetProcessHeap(), 0, items );
 369       }
 370     }
 371     else /* rotated */
 372     {
 373       /* have to render character by character. */
 374       double offset = 0.0;
 375       int i;
 376
 377       for (i=0; i<count; i++)
 378       {
 379         int char_metric_offset = str2b[i].byte2 + (str2b[i].byte1 << 8)
 380           - font->min_char_or_byte2;
 381         int x_i = IROUND((double) (dc->w.DCOrgX + x) + offset *
 382                          pfo->lpX11Trans->a / pfo->lpX11Trans->pixelsize );
 383         int y_i = IROUND((double) (dc->w.DCOrgY + y) - offset *
 384                          pfo->lpX11Trans->b / pfo->lpX11Trans->pixelsize );
 385
 386         TSXDrawString16( display, physDev->drawable, physDev->gc,
 387                        x_i, y_i, &str2b[i], 1);
 388         if (lpDx)
 389           offset += XLSTODS(dc, lpDx[i]);
 390         else
 391         {
 392           offset += (double) (font->per_char ?
 393                               font->per_char[char_metric_offset].attributes:
 394                               font->min_bounds.attributes)
 395                           * pfo->lpX11Trans->pixelsize / 1000.0;
 396           offset += dc->w.charExtra;
 397           if (str2b[i].byte2 == (char)dfBreakChar)
 398             offset += dc->w.breakExtra;
 399         }
 400       }
 401     }
 402     HeapFree( GetProcessHeap(), 0, str2b );
 403
 404       /* Draw underline and strike-out if needed */
 405
 406     if (lfUnderline)
 407     {
 408         long linePos, lineWidth;
 409
 410         if (!TSXGetFontProperty( font, XA_UNDERLINE_POSITION, &linePos ))
 411             linePos = descent - 1;
 412         if (!TSXGetFontProperty( font, XA_UNDERLINE_THICKNESS, &lineWidth ))
 413             lineWidth = 0;
 414         else if (lineWidth == 1) lineWidth = 0;
 415         TSXSetLineAttributes( display, physDev->gc, lineWidth,
 416                               LineSolid, CapRound, JoinBevel );
 417         TSXDrawLine( display, physDev->drawable, physDev->gc,
 418                      dc->w.DCOrgX + x, dc->w.DCOrgY + y + linePos,
 419                      dc->w.DCOrgX + x + width, dc->w.DCOrgY + y + linePos );
 420     }
 421     if (lfStrikeOut)
 422     {
 423         long lineAscent, lineDescent;
 424         if (!TSXGetFontProperty( font, XA_STRIKEOUT_ASCENT, &lineAscent ))
 425             lineAscent = ascent / 2;
 426         if (!TSXGetFontProperty( font, XA_STRIKEOUT_DESCENT, &lineDescent ))
 427             lineDescent = -lineAscent * 2 / 3;
 428         TSXSetLineAttributes( display, physDev->gc, lineAscent + lineDescent,
 429                             LineSolid, CapRound, JoinBevel );
 430         TSXDrawLine( display, physDev->drawable, physDev->gc,
 431                    dc->w.DCOrgX + x, dc->w.DCOrgY + y - lineAscent,
 432                    dc->w.DCOrgX + x + width, dc->w.DCOrgY + y - lineAscent );
 433     }
 434
 435     if (flags & ETO_CLIPPED)
 436         RestoreVisRgn16( dc->hSelf );
 437
 438     goto END;
 439
 440 FAIL:
 441     if(str2b != NULL) HeapFree( GetProcessHeap(), 0, str2b );
 442     result = FALSE;
 443
 444 END:
 445     if (dibUpdateFlag) X11DRV_DIB_UpdateDIBSection( dc, TRUE );
 446     return result;
 447 }
 448
 449
 450 /***********************************************************************
 451  *           X11DRV_GetTextExtentPoint
 452  */
 453 BOOL X11DRV_GetTextExtentPoint( DC *dc, LPCWSTR str, INT count,
 454                                   LPSIZE size )
 455 {
 456     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
 457     fontObject* pfo = XFONT_GetFontObject( physDev->font );
 458
 459     TRACE("%s %d\n", debugstr_wn(str,count), count);
 460     if( pfo ) {
 461         if( !pfo->lpX11Trans ) {
 462             int dir, ascent, descent;
 463             XCharStruct info;
 464             XChar2b *p = unicode_to_char2b( str, count, pfo->fi->codepage, pfo->fs->default_char );
 465             if (!p) return FALSE;
 466             TSXTextExtents16( pfo->fs, p, count, &dir, &ascent, &descent, &info );
 467             size->cx = abs((info.width + dc->w.breakRem + count *
 468                             dc->w.charExtra) * dc->wndExtX / dc->vportExtX);
 469             size->cy = abs((pfo->fs->ascent + pfo->fs->descent) *
 470                            dc->wndExtY / dc->vportExtY);
 471             HeapFree( GetProcessHeap(), 0, p );
 472         } else {
 473             INT i;
 474             float x = 0.0, y = 0.0;
 475             for(i = 0; i < count; i++) {
 476                 x += pfo->fs->per_char ?
 477            pfo->fs->per_char[str[i] - pfo->fs->min_char_or_byte2].attributes :
 478            pfo->fs->min_bounds.attributes;
 479             }
 480             y = pfo->lpX11Trans->RAW_ASCENT + pfo->lpX11Trans->RAW_DESCENT;
 481             TRACE("x = %f y = %f\n", x, y);
 482             x *= pfo->lpX11Trans->pixelsize / 1000.0;
 483             y *= pfo->lpX11Trans->pixelsize / 1000.0;
 484             size->cx = fabs((x + dc->w.breakRem + count * dc->w.charExtra) *
 485                              dc->wndExtX / dc->vportExtX);
 486             size->cy = fabs(y * dc->wndExtY / dc->vportExtY);
 487         }
 488         size->cx *= pfo->rescale;
 489         size->cy *= pfo->rescale;
 490         return TRUE;
 491     }
 492     return FALSE;
 493 }