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