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