git.oblomov.eu Git - wine/blob - 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 #ifndef X_DISPLAY_MISSING
  10
  11 #include <X11/Xatom.h>
  12 #include "ts_xlib.h"
  13
  14 #include <stdlib.h>
  15 #include "windef.h"
  16 #include <math.h>
  17 #include "dc.h"
  18 #include "gdi.h"
  19 #include "heap.h"
  20 #include "x11font.h"
  21 #include "debugtools.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(text)
  24
  25 #define SWAP_INT(a,b)  { int t = a; a = b; b = t; }
  26 #define IROUND(x) (int)((x)>0? (x)+0.5 : (x) - 0.5)
  27
  28 /***********************************************************************
  29  *           X11DRV_ExtTextOut
  30  */
  31 BOOL
  32 X11DRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
  33                    const RECT *lprect, LPCWSTR wstr, UINT count,
  34                    const INT *lpDx )
  35 {
  36     int                 i;
  37     fontObject*         pfo;
  38     INT         width, ascent, descent, xwidth, ywidth;
  39     XFontStruct*        font;
  40     RECT                rect;
  41     char                dfBreakChar, lfUnderline, lfStrikeOut;
  42     BOOL                rotated = FALSE;
  43     X11DRV_PDEVICE      *physDev = (X11DRV_PDEVICE *)dc->physDev;
  44     XChar2b *str2b;
  45     BOOL                dibUpdateFlag = FALSE;
  46
  47     if (!X11DRV_SetupGCForText( dc )) return TRUE;
  48
  49     pfo = XFONT_GetFontObject( physDev->font );
  50     font = pfo->fs;
  51
  52     if (pfo->lf.lfEscapement && pfo->lpX11Trans)
  53         rotated = TRUE;
  54     dfBreakChar = (char)pfo->fi->df.dfBreakChar;
  55     lfUnderline = (pfo->fo_flags & FO_SYNTH_UNDERLINE) ? 1 : 0;
  56     lfStrikeOut = (pfo->fo_flags & FO_SYNTH_STRIKEOUT) ? 1 : 0;
  57
  58     TRACE("hdc=%04x df=%04x %d,%d %s, %d  flags=%d lpDx=%p\n",
  59           dc->hSelf, (UINT16)(physDev->font), x, y,
  60           debugstr_wn (wstr, count), count, flags, lpDx);
  61
  62     /* some strings sent here end in a newline for whatever reason.  I have no
  63        clue what the right treatment should be in general, but ignoring
  64        terminating newlines seems ok.  MW, April 1998.  */
  65     if (count > 0 && wstr[count - 1] == '\n') count--;
  66
  67     if (lprect != NULL) TRACE("\trect=(%d,%d - %d,%d)\n",
  68                                      lprect->left, lprect->top,
  69                                      lprect->right, lprect->bottom );
  70       /* Setup coordinates */
  71
  72     if (dc->w.textAlign & TA_UPDATECP)
  73     {
  74         x = dc->w.CursPosX;
  75         y = dc->w.CursPosY;
  76     }
  77
  78     if (flags & (ETO_OPAQUE | ETO_CLIPPED))  /* there's a rectangle */
  79     {
  80         if (!lprect)  /* not always */
  81         {
  82             SIZE sz;
  83             if (flags & ETO_CLIPPED)  /* Can't clip with no rectangle */
  84               return FALSE;
  85             if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
  86               return FALSE;
  87             rect.left   = XLPTODP( dc, x );
  88             rect.right  = XLPTODP( dc, x+sz.cx );
  89             rect.top    = YLPTODP( dc, y );
  90             rect.bottom = YLPTODP( dc, y+sz.cy );
  91         }
  92         else
  93         {
  94             rect.left   = XLPTODP( dc, lprect->left );
  95             rect.right  = XLPTODP( dc, lprect->right );
  96             rect.top    = YLPTODP( dc, lprect->top );
  97             rect.bottom = YLPTODP( dc, lprect->bottom );
  98         }
  99         if (rect.right < rect.left) SWAP_INT( rect.left, rect.right );
 100         if (rect.bottom < rect.top) SWAP_INT( rect.top, rect.bottom );
 101     }
 102
 103     x = XLPTODP( dc, x );
 104     y = YLPTODP( dc, y );
 105
 106     TRACE("\treal coord: x=%i, y=%i, rect=(%d,%d - %d,%d)\n",
 107                           x, y, rect.left, rect.top, rect.right, rect.bottom);
 108
 109       /* Draw the rectangle */
 110
 111     if (flags & ETO_OPAQUE)
 112     {
 113         X11DRV_DIB_UpdateDIBSection( dc, FALSE );
 114         dibUpdateFlag = TRUE;
 115         TSXSetForeground( display, physDev->gc, physDev->backgroundPixel );
 116         TSXFillRectangle( display, physDev->drawable, physDev->gc,
 117                         dc->w.DCOrgX + rect.left, dc->w.DCOrgY + rect.top,
 118                         rect.right-rect.left, rect.bottom-rect.top );
 119     }
 120     if (!count) goto END;  /* Nothing more to do */
 121
 122       /* Compute text starting position */
 123
 124     if (lpDx) /* have explicit character cell x offsets in logical coordinates */
 125     {
 126         int extra = dc->wndExtX / 2;
 127         for (i = width = 0; i < count; i++) width += lpDx[i];
 128         width = (width * dc->vportExtX + extra ) / dc->wndExtX;
 129     }
 130     else
 131     {
 132         SIZE sz;
 133         if (!X11DRV_GetTextExtentPoint( dc, wstr, count, &sz ))
 134             return FALSE;
 135         width = XLSTODS(dc, sz.cx);
 136     }
 137     ascent = pfo->lpX11Trans ? pfo->lpX11Trans->ascent : font->ascent;
 138     descent = pfo->lpX11Trans ? pfo->lpX11Trans->descent : font->descent;
 139     xwidth = pfo->lpX11Trans ? width * pfo->lpX11Trans->a /
 140       pfo->lpX11Trans->pixelsize : width;
 141     ywidth = pfo->lpX11Trans ? width * pfo->lpX11Trans->b /
 142       pfo->lpX11Trans->pixelsize : 0;
 143
 144     switch( dc->w.textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER) )
 145     {
 146       case TA_LEFT:
 147           if (dc->w.textAlign & TA_UPDATECP) {
 148               dc->w.CursPosX = XDPTOLP( dc, x + xwidth );
 149               dc->w.CursPosY = YDPTOLP( dc, y - ywidth );
 150           }
 151           break;
 152       case TA_RIGHT:
 153           x -= xwidth;
 154           y += ywidth;
 155           if (dc->w.textAlign & TA_UPDATECP) {
 156               dc->w.CursPosX = XDPTOLP( dc, x );
 157               dc->w.CursPosY = YDPTOLP( dc, y );
 158           }
 159           break;
 160       case TA_CENTER:
 161           x -= xwidth / 2;
 162           y += ywidth / 2;
 163           break;
 164     }
 165
 166     switch( dc->w.textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
 167     {
 168       case TA_TOP:
 169           x -= pfo->lpX11Trans ? ascent * pfo->lpX11Trans->c /
 170             pfo->lpX11Trans->pixelsize : 0;
 171           y += pfo->lpX11Trans ? ascent * pfo->lpX11Trans->d /
 172             pfo->lpX11Trans->pixelsize : ascent;
 173           break;
 174       case TA_BOTTOM:
 175           x += pfo->lpX11Trans ? descent * pfo->lpX11Trans->c /
 176             pfo->lpX11Trans->pixelsize : 0;
 177           y -= pfo->lpX11Trans ? descent * pfo->lpX11Trans->d /
 178             pfo->lpX11Trans->pixelsize : descent;
 179           break;
 180       case TA_BASELINE:
 181           break;
 182     }
 183
 184       /* Set the clip region */
 185
 186     if (flags & ETO_CLIPPED)
 187     {
 188         SaveVisRgn16( dc->hSelf );
 189         CLIPPING_IntersectVisRect( dc, rect.left, rect.top, rect.right,
 190                                    rect.bottom, FALSE );
 191     }
 192
 193       /* Draw the text background if necessary */
 194
 195     if (!dibUpdateFlag)
 196     {
 197         X11DRV_DIB_UpdateDIBSection( dc, FALSE );
 198         dibUpdateFlag = TRUE;
 199     }
 200
 201     if (dc->w.backgroundMode != TRANSPARENT)
 202     {
 203           /* If rectangle is opaque and clipped, do nothing */
 204         if (!(flags & ETO_CLIPPED) || !(flags & ETO_OPAQUE))
 205         {
 206               /* Only draw if rectangle is not opaque or if some */
 207               /* text is outside the rectangle */
 208             if (!(flags & ETO_OPAQUE) ||
 209                 (x < rect.left) ||
 210                 (x + width >= rect.right) ||
 211                 (y - ascent < rect.top) ||
 212                 (y + descent >= rect.bottom))
 213             {
 214                 TSXSetForeground( display, physDev->gc,
 215                                   physDev->backgroundPixel );
 216                 TSXFillRectangle( display, physDev->drawable, physDev->gc,
 217                                 dc->w.DCOrgX + x,
 218                                 dc->w.DCOrgY + y - ascent,
 219                                 width,
 220                                 ascent + descent );
 221             }
 222         }
 223     }
 224
 225     /* Draw the text (count > 0 verified) */
 226     str2b = HeapAlloc( GetProcessHeap(), 0, count * sizeof(XChar2b) );
 227     for(i = 0; i < count; i++) {
 228       str2b[i].byte1 = wstr[i] >> 8;
 229       str2b[i].byte2 = wstr[i] & 0xff;
 230     }
 231
 232     TSXSetForeground( display, physDev->gc, physDev->textPixel );
 233     if(!rotated)
 234     {
 235       if (!dc->w.charExtra && !dc->w.breakExtra && !lpDx)
 236       {
 237         TSXDrawString16( display, physDev->drawable, physDev->gc,
 238                          dc->w.DCOrgX + x, dc->w.DCOrgY + y, str2b, count );
 239       }
 240       else  /* Now the fun begins... */
 241       {
 242         XTextItem16 *items, *pitem;
 243         int delta;
 244
 245         /* allocate max items */
 246
 247         pitem = items = HEAP_xalloc( GetProcessHeap(), 0,
 248                                      count * sizeof(XTextItem16) );
 249         delta = i = 0;
 250         if( lpDx ) /* explicit character widths */
 251         {
 252             int extra = dc->wndExtX / 2;
 253
 254             while (i < count)
 255             {
 256                 /* initialize text item with accumulated delta */
 257
 258                 pitem->chars  = str2b + i;
 259                 pitem->delta  = delta;
 260                 pitem->nchars = 0;
 261                 pitem->font   = None;
 262                 delta = 0;
 263
 264                 /* add characters  to the same XTextItem until new delta
 265                  * becomes  non-zero */
 266
 267                 do
 268                 {
 269                     delta += (lpDx[i] * dc->vportExtX + extra) / dc->wndExtX
 270                       - TSXTextWidth16( font, str2b + i, 1);
 271                     pitem->nchars++;
 272                 } while ((++i < count) && !delta);
 273                 pitem++;
 274            }
 275         }
 276         else /* charExtra or breakExtra */
 277         {
 278             while (i < count)
 279             {
 280                 pitem->chars  = str2b + i;
 281                 pitem->delta  = delta;
 282                 pitem->nchars = 0;
 283                 pitem->font   = None;
 284                 delta = 0;
 285
 286                 do
 287                 {
 288                     delta += dc->w.charExtra;
 289                     if (str2b[i].byte2 == (char)dfBreakChar)
 290                       delta += dc->w.breakExtra;
 291                     pitem->nchars++;
 292                 } while ((++i < count) && !delta);
 293                 pitem++;
 294             }
 295         }
 296
 297         TSXDrawText16( display, physDev->drawable, physDev->gc,
 298                    dc->w.DCOrgX + x, dc->w.DCOrgY + y, items, pitem - items );
 299         HeapFree( GetProcessHeap(), 0, items );
 300       }
 301     }
 302     else /* rotated */
 303     {
 304       /* have to render character by character. */
 305       double offset = 0.0;
 306       int i;
 307
 308       for (i=0; i<count; i++)
 309       {
 310         int char_metric_offset = str2b[i].byte2 + (str2b[i].byte1 << 8)
 311           - font->min_char_or_byte2;
 312         int x_i = IROUND((double) (dc->w.DCOrgX + x) + offset *
 313                          pfo->lpX11Trans->a / pfo->lpX11Trans->pixelsize );
 314         int y_i = IROUND((double) (dc->w.DCOrgY + y) - offset *
 315                          pfo->lpX11Trans->b / pfo->lpX11Trans->pixelsize );
 316
 317         TSXDrawString16( display, physDev->drawable, physDev->gc,
 318                        x_i, y_i, &str2b[i], 1);
 319         if (lpDx)
 320           offset += XLSTODS(dc, lpDx[i]);
 321         else
 322         {
 323           offset += (double) (font->per_char ?
 324                               font->per_char[char_metric_offset].attributes:
 325                               font->min_bounds.attributes)
 326                           * pfo->lpX11Trans->pixelsize / 1000.0;
 327           offset += dc->w.charExtra;
 328           if (str2b[i].byte2 == (char)dfBreakChar)
 329             offset += dc->w.breakExtra;
 330         }
 331       }
 332     }
 333     HeapFree( GetProcessHeap(), 0, str2b );
 334
 335       /* Draw underline and strike-out if needed */
 336
 337     if (lfUnderline)
 338     {
 339         long linePos, lineWidth;
 340
 341         if (!TSXGetFontProperty( font, XA_UNDERLINE_POSITION, &linePos ))
 342             linePos = descent - 1;
 343         if (!TSXGetFontProperty( font, XA_UNDERLINE_THICKNESS, &lineWidth ))
 344             lineWidth = 0;
 345         else if (lineWidth == 1) lineWidth = 0;
 346         TSXSetLineAttributes( display, physDev->gc, lineWidth,
 347                               LineSolid, CapRound, JoinBevel );
 348         TSXDrawLine( display, physDev->drawable, physDev->gc,
 349                      dc->w.DCOrgX + x, dc->w.DCOrgY + y + linePos,
 350                      dc->w.DCOrgX + x + width, dc->w.DCOrgY + y + linePos );
 351     }
 352     if (lfStrikeOut)
 353     {
 354         long lineAscent, lineDescent;
 355         if (!TSXGetFontProperty( font, XA_STRIKEOUT_ASCENT, &lineAscent ))
 356             lineAscent = ascent / 2;
 357         if (!TSXGetFontProperty( font, XA_STRIKEOUT_DESCENT, &lineDescent ))
 358             lineDescent = -lineAscent * 2 / 3;
 359         TSXSetLineAttributes( display, physDev->gc, lineAscent + lineDescent,
 360                             LineSolid, CapRound, JoinBevel );
 361         TSXDrawLine( display, physDev->drawable, physDev->gc,
 362                    dc->w.DCOrgX + x, dc->w.DCOrgY + y - lineAscent,
 363                    dc->w.DCOrgX + x + width, dc->w.DCOrgY + y - lineAscent );
 364     }
 365
 366     if (flags & ETO_CLIPPED)
 367         RestoreVisRgn16( dc->hSelf );
 368
 369 END:
 370     if (dibUpdateFlag) X11DRV_DIB_UpdateDIBSection( dc, TRUE );
 371     return TRUE;
 372 }
 373
 374 #endif /* !defined(X_DISPLAY_MISSING) */