dlls/wineps/text.c

   1 /*
   2  *      PostScript driver text functions
   3  *
   4  *      Copyright 1998  Huw D M Davies
   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 #include <string.h>
  21 #include "gdi.h"
  22 #include "psdrv.h"
  23 #include "wine/debug.h"
  24 #include "winspool.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  27
  28 static BOOL PSDRV_Text(PSDRV_PDEVICE *physDev, INT x, INT y, UINT flags,
  29                        LPCWSTR str, UINT count,
  30                        BOOL bDrawBackground, const INT *lpDx);
  31
  32 /***********************************************************************
  33  *           PSDRV_ExtTextOut
  34  */
  35 BOOL PSDRV_ExtTextOut( PSDRV_PDEVICE *physDev, INT x, INT y, UINT flags,
  36                        const RECT *lprect, LPCWSTR str, UINT count,
  37                        const INT *lpDx )
  38 {
  39     BOOL bResult = TRUE;
  40     BOOL bClipped = FALSE;
  41     BOOL bOpaque = FALSE;
  42     RECT rect;
  43
  44     TRACE("(x=%d, y=%d, flags=0x%08x, str=%s, count=%d, lpDx=%p)\n", x, y,
  45           flags, debugstr_wn(str, count), count, lpDx);
  46
  47     /* write font if not already written */
  48     PSDRV_SetFont(physDev);
  49
  50     /* set clipping and/or draw background */
  51     if ((flags & (ETO_CLIPPED | ETO_OPAQUE)) && (lprect != NULL))
  52     {
  53         rect = *lprect;
  54         LPtoDP( physDev->hdc, (POINT *)&rect, 2 );
  55         PSDRV_WriteGSave(physDev);
  56         PSDRV_WriteRectangle(physDev, rect.left, rect.top, rect.right - rect.left,
  57                              rect.bottom - rect.top);
  58
  59         if (flags & ETO_OPAQUE)
  60         {
  61             bOpaque = TRUE;
  62             PSDRV_WriteGSave(physDev);
  63             PSDRV_WriteSetColor(physDev, &physDev->bkColor);
  64             PSDRV_WriteFill(physDev);
  65             PSDRV_WriteGRestore(physDev);
  66         }
  67
  68         if (flags & ETO_CLIPPED)
  69         {
  70             bClipped = TRUE;
  71             PSDRV_WriteClip(physDev);
  72         }
  73
  74         bResult = PSDRV_Text(physDev, x, y, flags, str, count, !(bClipped && bOpaque), lpDx);
  75         PSDRV_WriteGRestore(physDev);
  76     }
  77     else
  78     {
  79         bResult = PSDRV_Text(physDev, x, y, flags, str, count, TRUE, lpDx);
  80     }
  81
  82     return bResult;
  83 }
  84
  85 /***********************************************************************
  86  *           PSDRV_Text
  87  */
  88 static BOOL PSDRV_Text(PSDRV_PDEVICE *physDev, INT x, INT y, UINT flags, LPCWSTR str,
  89                        UINT count, BOOL bDrawBackground, const INT *lpDx)
  90 {
  91     SIZE sz;
  92     TEXTMETRICW tm;
  93     POINT pt;
  94     INT ascent, descent;
  95     WORD *glyphs = NULL;
  96     DC *dc = physDev->dc;
  97     UINT align = GetTextAlign( physDev->hdc );
  98     INT char_extra;
  99     INT *deltas = NULL;
 100
 101     if (!count)
 102         return TRUE;
 103
 104
 105     if(physDev->font.fontloc == Download) {
 106         if(flags & ETO_GLYPH_INDEX)
 107             glyphs = (LPWORD)str;
 108         else {
 109             glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
 110             GetGlyphIndicesW(physDev->hdc, str, count, glyphs, 0);
 111         }
 112     }
 113
 114     if(align & TA_UPDATECP) {
 115         x = dc->CursPosX;
 116         y = dc->CursPosY;
 117     }
 118
 119     pt.x = x;
 120     pt.y = y;
 121     LPtoDP(physDev->hdc, &pt, 1);
 122     x = pt.x;
 123     y = pt.y;
 124
 125     if(physDev->font.fontloc == Download)
 126         GetTextExtentPointI(physDev->hdc, glyphs, count, &sz);
 127     else
 128         GetTextExtentPoint32W(physDev->hdc, str, count, &sz);
 129
 130     if((char_extra = GetTextCharacterExtra(physDev->hdc)) != 0) {
 131         INT i;
 132         SIZE tmpsz;
 133
 134         deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
 135         for(i = 0; i < count; i++) {
 136             deltas[i] = char_extra;
 137             if(lpDx)
 138                 deltas[i] += lpDx[i];
 139             else {
 140                 if(physDev->font.fontloc == Download)
 141                     GetTextExtentPointI(physDev->hdc, glyphs + i, 1, &tmpsz);
 142                 else
 143                     GetTextExtentPoint32W(physDev->hdc, str + i, 1, &tmpsz);
 144                 deltas[i] += tmpsz.cx;
 145             }
 146         }
 147     } else if(lpDx)
 148         deltas = (INT*)lpDx;
 149
 150     if(deltas) {
 151         SIZE tmpsz;
 152         INT i;
 153         /* Get the width of the last char and add on all the offsets */
 154         if(physDev->font.fontloc == Download)
 155             GetTextExtentPointI(physDev->hdc, glyphs + count - 1, 1, &tmpsz);
 156         else
 157             GetTextExtentPoint32W(physDev->hdc, str + count - 1, 1, &tmpsz);
 158         for(i = 0; i < count-1; i++)
 159             tmpsz.cx += deltas[i];
 160         sz.cx = tmpsz.cx; /* sz.cy remains untouched */
 161     }
 162
 163     sz.cx = INTERNAL_XWSTODS(dc, sz.cx);
 164     sz.cy = INTERNAL_YWSTODS(dc, sz.cy);
 165
 166     GetTextMetricsW(physDev->hdc, &tm);
 167     ascent = INTERNAL_YWSTODS(dc, tm.tmAscent);
 168     descent = INTERNAL_YWSTODS(dc, tm.tmDescent);
 169
 170     TRACE("textAlign = %x\n", align);
 171     switch(align & (TA_LEFT | TA_CENTER | TA_RIGHT) ) {
 172     case TA_LEFT:
 173         if(align & TA_UPDATECP)
 174         {
 175             POINT pt;
 176             pt.x = x + sz.cx;
 177             pt.y = y;
 178             DPtoLP( physDev->hdc, &pt, 1 );
 179             dc->CursPosX = pt.x;
 180         }
 181         break;
 182
 183     case TA_CENTER:
 184         x -= sz.cx/2;
 185         break;
 186
 187     case TA_RIGHT:
 188         x -= sz.cx;
 189         if(align & TA_UPDATECP)
 190         {
 191             POINT pt;
 192             pt.x = x;
 193             pt.y = y;
 194             DPtoLP( physDev->hdc, &pt, 1 );
 195             dc->CursPosX = pt.x;
 196         }
 197         break;
 198     }
 199
 200     switch(align & (TA_TOP | TA_BASELINE | TA_BOTTOM) ) {
 201     case TA_TOP:
 202         y += ascent;
 203         break;
 204
 205     case TA_BASELINE:
 206         break;
 207
 208     case TA_BOTTOM:
 209         y -= descent;
 210         break;
 211     }
 212
 213     if ((GetBkMode( physDev->hdc ) != TRANSPARENT) && bDrawBackground)
 214     {
 215         PSDRV_WriteGSave(physDev);
 216         PSDRV_WriteNewPath(physDev);
 217         PSDRV_WriteRectangle(physDev, x, y - ascent, sz.cx,
 218                              ascent + descent);
 219         PSDRV_WriteSetColor(physDev, &physDev->bkColor);
 220         PSDRV_WriteFill(physDev);
 221         PSDRV_WriteGRestore(physDev);
 222     }
 223
 224     PSDRV_WriteMoveTo(physDev, x, y);
 225
 226     if(!deltas) {
 227         if(physDev->font.fontloc == Download)
 228             PSDRV_WriteDownloadGlyphShow(physDev, glyphs, count);
 229         else
 230             PSDRV_WriteBuiltinGlyphShow(physDev, str, count);
 231     }
 232     else {
 233         INT i;
 234         float dx = 0.0, dy = 0.0;
 235         float cos_theta = cos(physDev->font.escapement * M_PI / 1800.0);
 236         float sin_theta = sin(physDev->font.escapement * M_PI / 1800.0);
 237         for(i = 0; i < count-1; i++) {
 238             TRACE("lpDx[%d] = %d\n", i, deltas[i]);
 239             if(physDev->font.fontloc == Download)
 240                 PSDRV_WriteDownloadGlyphShow(physDev, glyphs + i, 1);
 241             else
 242                 PSDRV_WriteBuiltinGlyphShow(physDev, str + i, 1);
 243             dx += deltas[i] * cos_theta;
 244             dy -= deltas[i] * sin_theta;
 245             PSDRV_WriteMoveTo(physDev, x + INTERNAL_XWSTODS(dc, dx),
 246                               y + INTERNAL_YWSTODS(dc, dy));
 247         }
 248         if(physDev->font.fontloc == Download)
 249             PSDRV_WriteDownloadGlyphShow(physDev, glyphs + i, 1);
 250         else
 251             PSDRV_WriteBuiltinGlyphShow(physDev, str + i, 1);
 252         if(deltas != lpDx)
 253             HeapFree(GetProcessHeap(), 0, deltas);
 254     }
 255
 256     /*
 257      * Underline and strikeout attributes.
 258      */
 259     if ((tm.tmUnderlined) || (tm.tmStruckOut)) {
 260
 261         /* Get the thickness and the position for the underline attribute */
 262         /* We'll use the same thickness for the strikeout attribute       */
 263
 264         INT escapement =  physDev->font.escapement;
 265
 266         /* Do the underline */
 267
 268         if (tm.tmUnderlined) {
 269             PSDRV_WriteNewPath(physDev); /* will be closed by WriteRectangle */
 270             if (escapement != 0)  /* rotated text */
 271             {
 272                 PSDRV_WriteGSave(physDev);  /* save the graphics state */
 273                 PSDRV_WriteMoveTo(physDev, x, y); /* move to the start */
 274
 275                 /* temporarily rotate the coord system */
 276                 PSDRV_WriteRotate(physDev, -escapement/10);
 277
 278                 /* draw the underline relative to the starting point */
 279                 PSDRV_WriteRRectangle(physDev, 0, -physDev->font.underlinePosition,
 280                                       sz.cx, physDev->font.underlineThickness);
 281             }
 282             else
 283                 PSDRV_WriteRectangle(physDev, x, y - physDev->font.underlinePosition,
 284                                      sz.cx, physDev->font.underlineThickness);
 285
 286             PSDRV_WriteFill(physDev);
 287
 288             if (escapement != 0)  /* rotated text */
 289                 PSDRV_WriteGRestore(physDev);  /* restore the graphics state */
 290         }
 291
 292         /* Do the strikeout */
 293
 294         if (tm.tmStruckOut) {
 295             PSDRV_WriteNewPath(physDev); /* will be closed by WriteRectangle */
 296             if (escapement != 0)  /* rotated text */
 297             {
 298                 PSDRV_WriteGSave(physDev);  /* save the graphics state */
 299                 PSDRV_WriteMoveTo(physDev, x, y); /* move to the start */
 300
 301                 /* temporarily rotate the coord system */
 302                 PSDRV_WriteRotate(physDev, -escapement/10);
 303
 304                 /* draw the line relative to the starting point */
 305                 PSDRV_WriteRRectangle(physDev, 0, -physDev->font.strikeoutPosition,
 306                                       sz.cx, physDev->font.strikeoutThickness);
 307             }
 308             else
 309                 PSDRV_WriteRectangle(physDev, x, y - physDev->font.strikeoutPosition,
 310                                      sz.cx, physDev->font.strikeoutThickness);
 311
 312             PSDRV_WriteFill(physDev);
 313
 314             if (escapement != 0)  /* rotated text */
 315                 PSDRV_WriteGRestore(physDev);  /* restore the graphics state */
 316         }
 317     }
 318
 319     if(glyphs && glyphs != str) HeapFree(GetProcessHeap(), 0, glyphs);
 320     return TRUE;
 321 }