WINGs/wfont.c

   1
   2 #include "wconfig.h"
   3
   4 #ifdef XFT
   5
   6 #include <X11/Xft/Xft.h>
   7 #include <fontconfig/fontconfig.h>
   8
   9 #include <stdlib.h>
  10
  11 #include "WINGsP.h"
  12
  13 #include <wraster.h>
  14 #include <assert.h>
  15 #include <X11/Xlocale.h>
  16
  17
  18 #define DEFAULT_SIZE WINGsConfiguration.defaultFontSize
  19
  20 static char*
  21 fixXLFD(char *xlfd, int size)
  22 {
  23     char *fname, *ptr;
  24
  25     fname = wmalloc(strlen(xlfd) + 20);
  26     if (strstr(xlfd, "%d")!=NULL)
  27         sprintf(fname, xlfd, size ? size : DEFAULT_SIZE);
  28     else
  29         strcpy(fname, xlfd);
  30
  31     if ((ptr = strchr(fname, ','))) {
  32         *ptr = 0;
  33     }
  34
  35     return fname;
  36 }
  37
  38
  39 static Bool
  40 hasProperty(FcPattern *pattern, const char *property)
  41 {
  42     FcValue val;
  43
  44     if (FcPatternGet(pattern, property, 0, &val)==FcResultMatch) {
  45         return True;
  46     }
  47
  48     return False;
  49 }
  50
  51
  52 static Bool
  53 hasPropertyWithStringValue(FcPattern *pattern, const char *object, char *value)
  54 {
  55     FcChar8 *str;
  56     int id;
  57
  58     if (!value || value[0]==0)
  59         return True;
  60
  61     id = 0;
  62     while (FcPatternGetString(pattern, object, id, &str)==FcResultMatch) {
  63         if (strcasecmp(value, (char*)str) == 0) {
  64             return True;
  65         }
  66         id++;
  67     }
  68
  69     return False;
  70 }
  71
  72
  73 // also handle an xlfd with %d for size?
  74 static char*
  75 makeFontOfSize(char *font, int size, char *fallback)
  76 {
  77     FcPattern *pattern;
  78     char *result;
  79
  80     if (font[0]=='-') {
  81         char *fname;
  82
  83         fname = fixXLFD(font, size);
  84         pattern = XftXlfdParse(fname, False, False);
  85         wfree(fname);
  86     } else {
  87         pattern = FcNameParse(font);
  88     }
  89
  90     //FcPatternPrint(pattern);
  91     if (size > 0) {
  92         FcPatternDel(pattern, "pixelsize");
  93         FcPatternAddDouble(pattern, "pixelsize", (double)size);
  94     } else if (size==0 && !hasProperty(pattern, "size") &&
  95                !hasProperty(pattern, "pixelsize")) {
  96         FcPatternAddDouble(pattern, "pixelsize", (double)DEFAULT_SIZE);
  97     }
  98
  99     if (fallback && !hasPropertyWithStringValue(pattern, "family", fallback)) {
 100         FcPatternAddString(pattern, "family", fallback);
 101     }
 102
 103     result = FcNameUnparse(pattern);
 104     FcPatternDestroy(pattern);
 105
 106     return result;
 107 }
 108
 109
 110 WMFont*
 111 WMCreateFont(WMScreen *scrPtr, char *fontName)
 112 {
 113     WMFont *font;
 114     Display *display = scrPtr->display;
 115     char *fname, *ptr;
 116
 117     /* This is for back-compat (to allow reading of old xlfd descriptions) */
 118     if (fontName[0]=='-' && (ptr = strchr(fontName, ','))) {
 119         // warn for deprecation
 120         fname = wmalloc(ptr - fontName + 1);
 121         strncpy(fname, fontName, ptr - fontName);
 122         fname[ptr - fontName] = 0;
 123     } else {
 124         fname = wstrdup(fontName);
 125     }
 126
 127     font = WMHashGet(scrPtr->fontCache, fname);
 128     if (font) {
 129         WMRetainFont(font);
 130         wfree(fname);
 131         return font;
 132     }
 133
 134     font = wmalloc(sizeof(WMFont));
 135     memset(font, 0, sizeof(WMFont));
 136
 137     font->screen = scrPtr;
 138
 139     // remove
 140     printf("WMCreateFont: %s\n", fname);
 141
 142     if (fname[0] == '-') {
 143         // Backward compat thing. Remove in a later version
 144         font->font = XftFontOpenXlfd(display, scrPtr->screen, fname);
 145     } else {
 146         font->font = XftFontOpenName(display, scrPtr->screen, fname);
 147     }
 148     if (!font->font) {
 149         wfree(font);
 150         wfree(fname);
 151         return NULL;
 152     }
 153     font->height = font->font->ascent+font->font->descent;
 154     font->y = font->font->ascent;
 155
 156     font->refCount = 1;
 157
 158     font->name = fname;
 159
 160     assert(WMHashInsert(scrPtr->fontCache, font->name, font)==NULL);
 161
 162     return font;
 163 }
 164
 165
 166 WMFont*
 167 WMRetainFont(WMFont *font)
 168 {
 169     wassertrv(font!=NULL, NULL);
 170
 171     font->refCount++;
 172
 173     return font;
 174 }
 175
 176
 177 void
 178 WMReleaseFont(WMFont *font)
 179 {
 180     wassertr(font!=NULL);
 181
 182     font->refCount--;
 183     if (font->refCount < 1) {
 184         XftFontClose(font->screen->display, font->font);
 185         if (font->name) {
 186             WMHashRemove(font->screen->fontCache, font->name);
 187             wfree(font->name);
 188         }
 189         wfree(font);
 190     }
 191 }
 192
 193
 194 Bool
 195 WMIsAntialiasingEnabled(WMScreen *scrPtr)
 196 {
 197     return scrPtr->antialiasedText;
 198 }
 199
 200
 201 unsigned int
 202 WMFontHeight(WMFont *font)
 203 {
 204     wassertrv(font!=NULL, 0);
 205
 206     return font->height;
 207 }
 208
 209
 210 char*
 211 WMGetFontName(WMFont *font)
 212 {
 213     wassertrv(font!=NULL, NULL);
 214
 215     return font->name;
 216 }
 217
 218
 219 WMFont*
 220 WMDefaultSystemFont(WMScreen *scrPtr)
 221 {
 222     return WMRetainFont(scrPtr->normalFont);
 223 }
 224
 225
 226 WMFont*
 227 WMDefaultBoldSystemFont(WMScreen *scrPtr)
 228 {
 229     return WMRetainFont(scrPtr->boldFont);
 230 }
 231
 232
 233 WMFont*
 234 WMSystemFontOfSize(WMScreen *scrPtr, int size)
 235 {
 236     WMFont *font;
 237     char *fontSpec;
 238
 239     fontSpec = makeFontOfSize(WINGsConfiguration.systemFont, size, "sans");
 240
 241     font = WMCreateFont(scrPtr, fontSpec);
 242
 243     if (!font) {
 244         wwarning(_("could not load font %s."), fontSpec);
 245     }
 246
 247     wfree(fontSpec);
 248
 249     return font;
 250 }
 251
 252
 253 WMFont*
 254 WMBoldSystemFontOfSize(WMScreen *scrPtr, int size)
 255 {
 256     WMFont *font;
 257     char *fontSpec;
 258
 259     fontSpec = makeFontOfSize(WINGsConfiguration.boldSystemFont, size, "sans");
 260
 261     font = WMCreateFont(scrPtr, fontSpec);
 262
 263     if (!font) {
 264         wwarning(_("could not load font %s."), fontSpec);
 265     }
 266
 267     wfree(fontSpec);
 268
 269     return font;
 270 }
 271
 272
 273 int
 274 WMWidthOfString(WMFont *font, char *text, int length)
 275 {
 276     XGlyphInfo extents;
 277
 278     wassertrv(font!=NULL && text!=NULL, 0);
 279
 280     XftTextExtentsUtf8(font->screen->display, font->font,
 281                        (XftChar8 *)text, length, &extents);
 282
 283     return extents.xOff; /* don't ask :P */
 284 }
 285
 286
 287
 288 void
 289 WMDrawString(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
 290              int x, int y, char *text, int length)
 291 {
 292     XftColor xftcolor;
 293
 294     wassertr(font!=NULL);
 295
 296     xftcolor.color.red = color->color.red;
 297     xftcolor.color.green = color->color.green;
 298     xftcolor.color.blue = color->color.blue;
 299     xftcolor.color.alpha = color->alpha;;
 300     xftcolor.pixel = W_PIXEL(color);
 301
 302     XftDrawChange(scr->xftdraw, d);
 303
 304     XftDrawStringUtf8(scr->xftdraw, &xftcolor, font->font,
 305                       x, y + font->y, (XftChar8*)text, length);
 306 }
 307
 308
 309 void
 310 WMDrawImageString(WMScreen *scr, Drawable d, WMColor *color, WMColor *background,
 311                   WMFont *font, int x, int y, char *text, int length)
 312 {
 313     XftColor textColor;
 314     XftColor bgColor;
 315
 316     wassertr(font!=NULL);
 317
 318     textColor.color.red = color->color.red;
 319     textColor.color.green = color->color.green;
 320     textColor.color.blue = color->color.blue;
 321     textColor.color.alpha = color->alpha;;
 322     textColor.pixel = W_PIXEL(color);
 323
 324     bgColor.color.red = background->color.red;
 325     bgColor.color.green = background->color.green;
 326     bgColor.color.blue = background->color.blue;
 327     bgColor.color.alpha = background->alpha;;
 328     bgColor.pixel = W_PIXEL(background);
 329
 330     XftDrawChange(scr->xftdraw, d);
 331
 332     XftDrawRect(scr->xftdraw, &bgColor, x, y,
 333                 WMWidthOfString(font, text, length),
 334                 font->height);
 335
 336     XftDrawStringUtf8(scr->xftdraw, &textColor, font->font,
 337                       x, y + font->y, (XftChar8*)text, length);
 338 }
 339
 340
 341 WMFont*
 342 WMCopyFontWithStyle(WMScreen *scrPtr, WMFont *font, WMFontStyle style)
 343 {
 344     FcPattern *pattern;
 345     WMFont *copy;
 346     char *name;
 347
 348     if (!font)
 349         return NULL;
 350
 351     pattern = FcNameParse(WMGetFontName(font));
 352     switch (style) {
 353     case WFSNormal:
 354         FcPatternDel(pattern, "weight");
 355         FcPatternDel(pattern, "slant");
 356         FcPatternAddString(pattern, "weight", "regular");
 357         FcPatternAddString(pattern, "weight", "medium");
 358         FcPatternAddString(pattern, "slant", "roman");
 359         break;
 360     case WFSBold:
 361         FcPatternDel(pattern, "weight");
 362         FcPatternAddString(pattern, "weight", "bold");
 363         break;
 364     case WFSEmphasized:
 365         FcPatternDel(pattern, "slant");
 366         FcPatternAddString(pattern, "slant", "italic");
 367         FcPatternAddString(pattern, "slant", "oblique");
 368         break;
 369     case WFSBoldEmphasized:
 370         FcPatternDel(pattern, "weight");
 371         FcPatternDel(pattern, "slant");
 372         FcPatternAddString(pattern, "weight", "bold");
 373         FcPatternAddString(pattern, "slant", "italic");
 374         FcPatternAddString(pattern, "slant", "oblique");
 375         break;
 376     }
 377
 378     name = FcNameUnparse(pattern);
 379     copy = WMCreateFont(scrPtr, name);
 380     FcPatternDestroy(pattern);
 381     wfree(name);
 382
 383     return copy;
 384 }
 385
 386
 387 #endif /* XFT */
 388
 389