dlls/wineps/text.c

   1 /*
   2  *      PostScript driver text functions
   3  *
   4  *      Copyright 1998  Huw D M Davies
   5  *
   6  */
   7 #include <string.h>
   8 #include "psdrv.h"
   9 #include "debugtools.h"
  10 #include "winspool.h"
  11
  12 DEFAULT_DEBUG_CHANNEL(psdrv);
  13
  14 static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCWSTR str, UINT count,
  15                        BOOL bDrawBackground, const INT *lpDx);
  16
  17 /***********************************************************************
  18  *           PSDRV_ExtTextOut
  19  */
  20 BOOL PSDRV_ExtTextOut( DC *dc, INT x, INT y, UINT flags,
  21                        const RECT *lprect, LPCWSTR str, UINT count,
  22                        const INT *lpDx )
  23 {
  24     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
  25     BOOL bResult = TRUE;
  26     BOOL bClipped = FALSE;
  27     BOOL bOpaque = FALSE;
  28     RECT rect;
  29
  30     TRACE("(x=%d, y=%d, flags=0x%08x, str=%s, count=%d, lpDx=%p)\n", x, y,
  31           flags, debugstr_wn(str, count), count, lpDx);
  32
  33     /* write font if not already written */
  34     PSDRV_SetFont(dc);
  35
  36     /* set clipping and/or draw background */
  37     if ((flags & (ETO_CLIPPED | ETO_OPAQUE)) && (lprect != NULL))
  38     {
  39         rect.left = INTERNAL_XWPTODP(dc, lprect->left, lprect->top);
  40         rect.right = INTERNAL_XWPTODP(dc, lprect->right, lprect->bottom);
  41         rect.top = INTERNAL_YWPTODP(dc, lprect->left, lprect->top);
  42         rect.bottom = INTERNAL_YWPTODP(dc, lprect->right, lprect->bottom);
  43
  44         PSDRV_WriteGSave(dc);
  45         PSDRV_WriteRectangle(dc, rect.left, rect.top, rect.right - rect.left,
  46                              rect.bottom - rect.top);
  47
  48         if (flags & ETO_OPAQUE)
  49         {
  50             bOpaque = TRUE;
  51             PSDRV_WriteGSave(dc);
  52             PSDRV_WriteSetColor(dc, &physDev->bkColor);
  53             PSDRV_WriteFill(dc);
  54             PSDRV_WriteGRestore(dc);
  55         }
  56
  57         if (flags & ETO_CLIPPED)
  58         {
  59             bClipped = TRUE;
  60             PSDRV_WriteClip(dc);
  61         }
  62
  63         bResult = PSDRV_Text(dc, x, y, str, count, !(bClipped && bOpaque), lpDx);
  64         PSDRV_WriteGRestore(dc);
  65     }
  66     else
  67     {
  68         bResult = PSDRV_Text(dc, x, y, str, count, TRUE, lpDx);
  69     }
  70
  71     return bResult;
  72 }
  73
  74 /***********************************************************************
  75  *           PSDRV_Text
  76  */
  77 static BOOL PSDRV_Text(DC *dc, INT x, INT y, LPCWSTR str, UINT count,
  78                        BOOL bDrawBackground, const INT *lpDx)
  79 {
  80     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
  81     LPWSTR strbuf;
  82     SIZE sz;
  83
  84     if (!count)
  85         return TRUE;
  86
  87     strbuf = HeapAlloc( PSDRV_Heap, 0, (count + 1) * sizeof(WCHAR));
  88     if(!strbuf) {
  89         WARN("HeapAlloc failed\n");
  90         return FALSE;
  91     }
  92
  93     if(dc->textAlign & TA_UPDATECP) {
  94         x = dc->CursPosX;
  95         y = dc->CursPosY;
  96     }
  97
  98     x = INTERNAL_XWPTODP(dc, x, y);
  99     y = INTERNAL_YWPTODP(dc, x, y);
 100
 101     GetTextExtentPoint32W(dc->hSelf, str, count, &sz);
 102     if(lpDx) {
 103         SIZE tmpsz;
 104         INT i;
 105         /* Get the width of the last char and add on all the offsets */
 106         GetTextExtentPoint32W(dc->hSelf, str + count - 1, 1, &tmpsz);
 107         for(i = 0; i < count-1; i++)
 108             tmpsz.cx += lpDx[i];
 109         sz.cx = tmpsz.cx; /* sz.cy remains untouched */
 110     }
 111
 112     sz.cx = INTERNAL_XWSTODS(dc, sz.cx);
 113     sz.cy = INTERNAL_YWSTODS(dc, sz.cy);
 114     TRACE("textAlign = %x\n", dc->textAlign);
 115     switch(dc->textAlign & (TA_LEFT | TA_CENTER | TA_RIGHT) ) {
 116     case TA_LEFT:
 117         if(dc->textAlign & TA_UPDATECP) {
 118             dc->CursPosX = INTERNAL_XDPTOWP(dc, x + sz.cx, y);
 119         }
 120         break;
 121
 122     case TA_CENTER:
 123         x -= sz.cx/2;
 124         break;
 125
 126     case TA_RIGHT:
 127         x -= sz.cx;
 128         if(dc->textAlign & TA_UPDATECP) {
 129             dc->CursPosX = INTERNAL_XDPTOWP(dc, x, y);
 130         }
 131         break;
 132     }
 133
 134     switch(dc->textAlign & (TA_TOP | TA_BASELINE | TA_BOTTOM) ) {
 135     case TA_TOP:
 136         y += physDev->font.tm.tmAscent;
 137         break;
 138
 139     case TA_BASELINE:
 140         break;
 141
 142     case TA_BOTTOM:
 143         y -= physDev->font.tm.tmDescent;
 144         break;
 145     }
 146
 147     memcpy(strbuf, str, count * sizeof(WCHAR));
 148     *(strbuf + count) = '\0';
 149
 150     if ((dc->backgroundMode != TRANSPARENT) && (bDrawBackground != FALSE))
 151     {
 152         PSDRV_WriteGSave(dc);
 153         PSDRV_WriteNewPath(dc);
 154         PSDRV_WriteRectangle(dc, x, y - physDev->font.tm.tmAscent, sz.cx,
 155                              physDev->font.tm.tmAscent +
 156                              physDev->font.tm.tmDescent);
 157         PSDRV_WriteSetColor(dc, &physDev->bkColor);
 158         PSDRV_WriteFill(dc);
 159         PSDRV_WriteGRestore(dc);
 160     }
 161
 162     PSDRV_WriteMoveTo(dc, x, y);
 163
 164     if(!lpDx)
 165         PSDRV_WriteShow(dc, strbuf, lstrlenW(strbuf));
 166     else {
 167         INT i;
 168         float dx = 0.0, dy = 0.0;
 169         float cos_theta = cos(physDev->font.escapement * M_PI / 1800.0);
 170         float sin_theta = sin(physDev->font.escapement * M_PI / 1800.0);
 171         for(i = 0; i < count-1; i++) {
 172             TRACE("lpDx[%d] = %d\n", i, lpDx[i]);
 173             PSDRV_WriteShow(dc, &strbuf[i], 1);
 174             dx += lpDx[i] * cos_theta;
 175             dy -= lpDx[i] * sin_theta;
 176             PSDRV_WriteMoveTo(dc, x + INTERNAL_XWSTODS(dc, dx),
 177                               y + INTERNAL_YWSTODS(dc, dy));
 178         }
 179         PSDRV_WriteShow(dc, &strbuf[i], 1);
 180     }
 181
 182     /*
 183      * Underline and strikeout attributes.
 184      */
 185     if ((physDev->font.tm.tmUnderlined) || (physDev->font.tm.tmStruckOut)) {
 186
 187         /* Get the thickness and the position for the underline attribute */
 188         /* We'll use the same thickness for the strikeout attribute       */
 189
 190         float thick = physDev->font.afm->UnderlineThickness * physDev->font.scale;
 191         float pos   = -physDev->font.afm->UnderlinePosition * physDev->font.scale;
 192         SIZE size;
 193         INT escapement =  physDev->font.escapement;
 194
 195         TRACE("Position = %f Thickness %f Escapement %d\n",
 196               pos, thick, escapement);
 197
 198         /* Get the width of the text */
 199
 200         PSDRV_GetTextExtentPoint(dc, strbuf, lstrlenW(strbuf), &size);
 201         size.cx = INTERNAL_XWSTODS(dc, size.cx);
 202
 203         /* Do the underline */
 204
 205         if (physDev->font.tm.tmUnderlined) {
 206             if (escapement != 0)  /* rotated text */
 207             {
 208                 PSDRV_WriteGSave(dc);  /* save the graphics state */
 209                 PSDRV_WriteMoveTo(dc, x, y); /* move to the start */
 210
 211                 /* temporarily rotate the coord system */
 212                 PSDRV_WriteRotate(dc, -escapement/10);
 213
 214                 /* draw the underline relative to the starting point */
 215                 PSDRV_WriteRRectangle(dc, 0, (INT)pos, size.cx, (INT)thick);
 216             }
 217             else
 218                 PSDRV_WriteRectangle(dc, x, y + (INT)pos, size.cx, (INT)thick);
 219
 220             PSDRV_WriteFill(dc);
 221
 222             if (escapement != 0)  /* rotated text */
 223                 PSDRV_WriteGRestore(dc);  /* restore the graphics state */
 224         }
 225
 226         /* Do the strikeout */
 227
 228         if (physDev->font.tm.tmStruckOut) {
 229             pos = -physDev->font.tm.tmAscent / 2;
 230
 231             if (escapement != 0)  /* rotated text */
 232             {
 233                 PSDRV_WriteGSave(dc);  /* save the graphics state */
 234                 PSDRV_WriteMoveTo(dc, x, y); /* move to the start */
 235
 236                 /* temporarily rotate the coord system */
 237                 PSDRV_WriteRotate(dc, -escapement/10);
 238
 239                 /* draw the underline relative to the starting point */
 240                 PSDRV_WriteRRectangle(dc, 0, (INT)pos, size.cx, (INT)thick);
 241             }
 242             else
 243                 PSDRV_WriteRectangle(dc, x, y + (INT)pos, size.cx, (INT)thick);
 244
 245             PSDRV_WriteFill(dc);
 246
 247             if (escapement != 0)  /* rotated text */
 248                 PSDRV_WriteGRestore(dc);  /* restore the graphics state */
 249         }
 250     }
 251
 252     HeapFree(PSDRV_Heap, 0, strbuf);
 253     return TRUE;
 254 }