WINGs/wfont.c

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