WINGs/wfont.c

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