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