WINGs/wfont.c

   1
   2 #include "WINGsP.h"
   3 #include "wconfig.h"
   4
   5
   6 #include <wraster.h>
   7 #include <assert.h>
   8 #include <X11/Xlocale.h>
   9
  10 static char *makeFontSetOfSize(char *fontset, int size);
  11
  12
  13
  14 /* XLFD pattern matching */
  15 static char*
  16 xlfd_get_element (const char *xlfd, int index)
  17 {
  18     const char *p = xlfd;
  19     while (*p != 0) {
  20         if (*p == '-' && --index == 0) {
  21             const char *end = strchr(p + 1, '-');
  22             char *buf;
  23             size_t len;
  24             if (end == 0) end = p + strlen(p);
  25             len = end - (p + 1);
  26             buf = wmalloc(len);
  27             memcpy(buf, p + 1, len);
  28             buf[len] = 0;
  29             return buf;
  30         }
  31         p++;
  32     }
  33     return strdup("*");
  34 }
  35
  36 /* XLFD pattern matching */
  37 static char*
  38 generalize_xlfd (const char *xlfd)
  39 {
  40     char *buf;
  41     int len;
  42     char *weight = xlfd_get_element(xlfd, 3);
  43     char *slant  = xlfd_get_element(xlfd, 4);
  44     char *pxlsz  = xlfd_get_element(xlfd, 7);
  45
  46 #define Xstrlen(A) ((A)?strlen(A):0)
  47     len = Xstrlen(xlfd)+Xstrlen(weight)+Xstrlen(slant)+Xstrlen(pxlsz)*2+50;
  48 #undef Xstrlen
  49
  50     buf = wmalloc(len + 1);
  51     snprintf(buf, len + 1, "%s,-*-*-%s-%s-*-*-%s-*-*-*-*-*-*-*,"
  52              "-*-*-*-*-*-*-%s-*-*-*-*-*-*-*,*",
  53              xlfd, weight, slant, pxlsz, pxlsz);
  54
  55     wfree(pxlsz);
  56     wfree(slant);
  57     wfree(weight);
  58
  59     return buf;
  60 }
  61
  62 /* XLFD pattern matching */
  63 static XFontSet
  64 W_CreateFontSetWithGuess(Display *dpy, char *xlfd, char ***missing,
  65                         int *nmissing, char **def_string)
  66 {
  67     XFontSet fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
  68
  69     if (fs != NULL && *nmissing == 0) return fs;
  70
  71     /* for non-iso8859-1 language and iso8859-1 specification
  72        (this fontset is only for pattern analysis) */
  73     if (fs == NULL) {
  74         if (*nmissing != 0) XFreeStringList(*missing);
  75         setlocale(LC_CTYPE, "C");
  76         fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
  77         setlocale(LC_CTYPE, "");
  78     }
  79
  80     /* make XLFD font name for pattern analysis */
  81     if (fs != NULL) {
  82         XFontStruct **fontstructs;
  83         char **fontnames;
  84         if (XFontsOfFontSet(fs, &fontstructs, &fontnames) > 0)
  85             xlfd = fontnames[0];
  86     }
  87
  88     xlfd = generalize_xlfd (xlfd);
  89
  90     if (*nmissing != 0) XFreeStringList(*missing);
  91     if (fs != NULL) XFreeFontSet(dpy, fs);
  92
  93     fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
  94
  95     wfree(xlfd);
  96     return fs;
  97 }
  98
  99 WMFont*
 100 WMCreateFontSet(WMScreen *scrPtr, char *fontName)
 101 {
 102     WMFont *font;
 103     Display *display = scrPtr->display;
 104     char **missing;
 105     int nmissing = 0;
 106     char *defaultString;
 107     XFontSetExtents *extents;
 108
 109     font = WMHashGet(scrPtr->fontCache, fontName);
 110     if (font) {
 111         WMRetainFont(font);
 112         return font;
 113     }
 114
 115     font = malloc(sizeof(WMFont));
 116     if (!font)
 117       return NULL;
 118     memset(font, 0, sizeof(WMFont));
 119
 120     font->notFontSet = 0;
 121
 122     font->screen = scrPtr;
 123
 124     font->font.set = W_CreateFontSetWithGuess(display, fontName, &missing,
 125                                              &nmissing, &defaultString);
 126     if (nmissing > 0 && font->font.set) {
 127         int i;
 128
 129         wwarning(_("the following character sets are missing in %s:"),
 130                  fontName);
 131         for (i = 0; i < nmissing; i++) {
 132             wwarning(missing[i]);
 133         }
 134         XFreeStringList(missing);
 135         if (defaultString)
 136             wwarning(_("the string \"%s\" will be used in place of any characters from those sets."),
 137                      defaultString);
 138     }
 139     if (!font->font.set) {
 140         wfree(font);
 141         return NULL;
 142     }
 143
 144     extents = XExtentsOfFontSet(font->font.set);
 145
 146     font->height = extents->max_logical_extent.height;
 147     font->y = font->height - (font->height + extents->max_logical_extent.y);
 148
 149     font->refCount = 1;
 150
 151     font->name = wstrdup(fontName);
 152
 153     assert(WMHashInsert(scrPtr->fontCache, font->name, font)==NULL);
 154
 155     return font;
 156 }
 157
 158
 159
 160 WMFont*
 161 WMCreateNormalFont(WMScreen *scrPtr, char *fontName)
 162 {
 163     WMFont *font;
 164     Display *display = scrPtr->display;
 165     char *fname, *ptr;
 166
 167     if ((ptr = strchr(fontName, ','))) {
 168         fname = wmalloc(ptr - fontName + 1);
 169         strncpy(fname, fontName, ptr - fontName);
 170         fname[ptr - fontName] = 0;
 171     } else {
 172         fname = wstrdup(fontName);
 173     }
 174
 175     font = WMHashGet(scrPtr->fontCache, fname);
 176     if (font) {
 177         WMRetainFont(font);
 178         wfree(fname);
 179         return font;
 180     }
 181
 182     font = malloc(sizeof(WMFont));
 183     if (!font) {
 184         wfree(fname);
 185         return NULL;
 186     }
 187     memset(font, 0, sizeof(WMFont));
 188
 189     font->notFontSet = 1;
 190
 191     font->screen = scrPtr;
 192
 193     font->font.normal = XLoadQueryFont(display, fname);
 194     if (!font->font.normal) {
 195         wfree(font);
 196         return NULL;
 197     }
 198
 199     font->height = font->font.normal->ascent+font->font.normal->descent;
 200     font->y = font->font.normal->ascent;
 201
 202     font->refCount = 1;
 203
 204     font->name = fname;
 205
 206     assert(WMHashInsert(scrPtr->fontCache, font->name, font)==NULL);
 207
 208     return font;
 209 }
 210
 211
 212
 213 WMFont*
 214 WMCreateFont(WMScreen *scrPtr, char *fontName)
 215 {
 216     if (scrPtr->useMultiByte)
 217         return WMCreateFontSet(scrPtr, fontName);
 218     else
 219         return WMCreateNormalFont(scrPtr, fontName);
 220 }
 221
 222
 223
 224 WMFont*
 225 WMRetainFont(WMFont *font)
 226 {
 227     wassertrv(font!=NULL, NULL);
 228
 229     font->refCount++;
 230
 231     return font;
 232 }
 233
 234
 235 void
 236 WMReleaseFont(WMFont *font)
 237 {
 238     wassertr(font!=NULL);
 239
 240     font->refCount--;
 241     if (font->refCount < 1) {
 242         if (font->notFontSet)
 243             XFreeFont(font->screen->display, font->font.normal);
 244         else {
 245             XFreeFontSet(font->screen->display, font->font.set);
 246         }
 247         if (font->name) {
 248             WMHashRemove(font->screen->fontCache, font->name);
 249             wfree(font->name);
 250         }
 251         wfree(font);
 252     }
 253 }
 254
 255
 256
 257 unsigned int
 258 WMFontHeight(WMFont *font)
 259 {
 260     wassertrv(font!=NULL, 0);
 261
 262     return font->height;
 263 }
 264
 265
 266
 267 WMFont*
 268 WMSystemFontOfSize(WMScreen *scrPtr, int size)
 269 {
 270     WMFont *font;
 271     char *fontSpec;
 272
 273     fontSpec = makeFontSetOfSize(WINGsConfiguration.systemFont, size);
 274
 275     if (scrPtr->useMultiByte)
 276         font = WMCreateFontSet(scrPtr, fontSpec);
 277     else
 278         font = WMCreateNormalFont(scrPtr, fontSpec);
 279
 280     if (!font) {
 281         if (scrPtr->useMultiByte) {
 282             wwarning(_("could not load font set %s. Trying fixed."), fontSpec);
 283             font = WMCreateFontSet(scrPtr, "fixed");
 284             if (!font) {
 285                 font = WMCreateFontSet(scrPtr, "-*-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*");
 286             }
 287         } else {
 288             wwarning(_("could not load font %s. Trying fixed."), fontSpec);
 289             font = WMCreateNormalFont(scrPtr, "fixed");
 290         }
 291         if (!font) {
 292             wwarning(_("could not load fixed font!"));
 293             wfree(fontSpec);
 294             return NULL;
 295         }
 296     }
 297     wfree(fontSpec);
 298
 299     return font;
 300 }
 301
 302
 303 WMFont*
 304 WMBoldSystemFontOfSize(WMScreen *scrPtr, int size)
 305 {
 306     WMFont *font;
 307     char *fontSpec;
 308
 309     fontSpec = makeFontSetOfSize(WINGsConfiguration.boldSystemFont, size);
 310
 311     if (scrPtr->useMultiByte)
 312         font = WMCreateFontSet(scrPtr, fontSpec);
 313     else
 314         font = WMCreateNormalFont(scrPtr, fontSpec);
 315
 316     if (!font) {
 317         if (scrPtr->useMultiByte) {
 318             wwarning(_("could not load font set %s. Trying fixed."), fontSpec);
 319             font = WMCreateFontSet(scrPtr, "fixed");
 320             if (!font) {
 321                 font = WMCreateFontSet(scrPtr, "-*-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*");
 322             }
 323         } else {
 324             wwarning(_("could not load font %s. Trying fixed."), fontSpec);
 325             font = WMCreateNormalFont(scrPtr, "fixed");
 326         }
 327         if (!font) {
 328             wwarning(_("could not load fixed font!"));
 329             wfree(fontSpec);
 330             return NULL;
 331         }
 332     }
 333     wfree(fontSpec);
 334
 335     return font;
 336 }
 337
 338
 339 XFontSet
 340 WMGetFontFontSet(WMFont *font)
 341 {
 342     wassertrv(font!=NULL, NULL);
 343
 344     if (font->notFontSet)
 345         return NULL;
 346     else
 347         return font->font.set;
 348 }
 349
 350
 351 int
 352 WMWidthOfString(WMFont *font, char *text, int length)
 353 {
 354     wassertrv(font!=NULL, 0);
 355     wassertrv(text!=NULL, 0);
 356
 357     if (font->notFontSet)
 358         return XTextWidth(font->font.normal, text, length);
 359     else {
 360         XRectangle rect;
 361         XRectangle AIXsucks;
 362
 363         XmbTextExtents(font->font.set, text, length, &AIXsucks, &rect);
 364
 365         return rect.width;
 366     }
 367 }
 368
 369
 370
 371 void
 372 WMDrawString(WMScreen *scr, Drawable d, GC gc, WMFont *font, int x, int y,
 373              char *text, int length)
 374 {
 375     wassertr(font!=NULL);
 376
 377     if (font->notFontSet) {
 378         XSetFont(scr->display, gc, font->font.normal->fid);
 379         XDrawString(scr->display, d, gc, x, y + font->y, text, length);
 380     } else {
 381         XmbDrawString(scr->display, d, font->font.set, gc, x, y + font->y,
 382                       text, length);
 383     }
 384 }
 385
 386
 387 void
 388 WMDrawImageString(WMScreen *scr, Drawable d, GC gc, WMFont *font, int x, int y,
 389                   char *text, int length)
 390 {
 391     wassertr(font != NULL);
 392
 393     if (font->notFontSet) {
 394         XSetFont(scr->display, gc, font->font.normal->fid);
 395         XDrawImageString(scr->display, d, gc, x, y + font->y, text, length);
 396     } else {
 397         XmbDrawImageString(scr->display, d, font->font.set, gc, x, y + font->y,
 398                            text, length);
 399     }
 400 }
 401
 402
 403
 404
 405 static char*
 406 makeFontSetOfSize(char *fontset, int size)
 407 {
 408     char font[300], *f;
 409     char *newfs = NULL;
 410     char *ptr;
 411
 412     do {
 413         char *tmp;
 414         int end;
 415
 416
 417         f = fontset;
 418         ptr = strchr(fontset, ',');
 419         if (ptr) {
 420             int count = ptr-fontset;
 421
 422             if (count > 255) {
 423                 wwarning(_("font description %s is too large."), fontset);
 424             } else {
 425                 memcpy(font, fontset, count);
 426                 font[count] = 0;
 427                 f = (char*)font;
 428             }
 429         }
 430
 431         if (newfs)
 432             end = strlen(newfs);
 433         else
 434             end = 0;
 435
 436         tmp = wmalloc(end + strlen(f) + 8);
 437         if (end != 0) {
 438             sprintf(tmp, "%s,", newfs);
 439             sprintf(tmp + end + 1, f, size);
 440         } else {
 441             sprintf(tmp + end, f, size);
 442         }
 443
 444         if (newfs)
 445             wfree(newfs);
 446         newfs = tmp;
 447
 448         fontset = ptr+1;
 449     } while (ptr!=NULL);
 450
 451     return newfs;
 452 }
 453
 454
 455 static void
 456 changeFontProp(char *fname, char *newprop, int which)
 457 {
 458         char before[128], prop[128], after[128];
 459         char *ptr, *bptr;
 460         int part=0;
 461
 462         if(!fname || !prop)
 463                 return;
 464
 465         ptr = fname;
 466         bptr = before;
 467         while (*ptr) {
 468                 if(*ptr == '-') {
 469             *bptr = 0;
 470                         if(part==which) bptr = prop;
 471                         else if(part==which+1) bptr = after;
 472                 *bptr++ = *ptr;
 473                         part++;
 474                 } else {
 475           *bptr++ = *ptr;
 476                 }  ptr++;
 477         }*bptr = 0;
 478         snprintf(fname, 255, "%s-%s%s", before, newprop, after);
 479 }
 480
 481
 482 WMFont *
 483 WMNormalizeFont(WMScreen *scr, WMFont *font)
 484 {
 485     WMFont *newfont=NULL;
 486     char fname[256];
 487
 488     if(!scr || !font)
 489         return NULL;
 490
 491     snprintf(fname, 255, font->name);
 492     changeFontProp(fname, "medium", 2);
 493         changeFontProp(fname, "r", 3);
 494     newfont = WMCreateNormalFont(scr, fname);
 495
 496     if(!newfont)
 497         return NULL;
 498
 499     return newfont;
 500 }
 501
 502
 503 WMFont *
 504 WMStrengthenFont(WMScreen *scr, WMFont *font)
 505 {
 506         WMFont *newfont=NULL;
 507         char fname[256];
 508
 509         if(!scr || !font)
 510         return NULL;
 511
 512         snprintf(fname, 255, font->name);
 513         changeFontProp(fname, "bold", 2);
 514         newfont = WMCreateNormalFont(scr, fname);
 515
 516         if(!newfont)
 517         return NULL;
 518
 519         return newfont;
 520 }
 521
 522
 523 WMFont *
 524 WMUnstrengthenFont(WMScreen *scr, WMFont *font)
 525 {
 526         WMFont *newfont=NULL;
 527         char fname[256];
 528
 529         if(!scr || !font)
 530         return NULL;
 531
 532         snprintf(fname, 255, font->name);
 533         changeFontProp(fname, "medium", 2);
 534         newfont = WMCreateNormalFont(scr, fname);
 535
 536         if(!newfont)
 537         return NULL;
 538
 539         return newfont;
 540 }
 541
 542
 543 WMFont *
 544 WMEmphasizeFont(WMScreen *scr, WMFont *font)
 545 {
 546         WMFont *newfont=NULL;
 547         char fname[256];
 548
 549         if(!scr || !font)
 550         return NULL;
 551
 552         snprintf(fname, 255, font->name);
 553         changeFontProp(fname, "o", 3);
 554         newfont = WMCreateNormalFont(scr, fname);
 555
 556         if(!newfont)
 557         return NULL;
 558
 559         return newfont;
 560 }
 561
 562
 563 WMFont *
 564 WMUnemphasizeFont(WMScreen *scr, WMFont *font)
 565 {
 566         WMFont *newfont=NULL;
 567         char fname[256];
 568
 569         if(!scr || !font)
 570         return NULL;
 571
 572         snprintf(fname, 255, font->name);
 573         changeFontProp(fname, "r", 3);
 574         newfont = WMCreateNormalFont(scr, fname);
 575
 576         if(!newfont)
 577         return NULL;
 578
 579         return newfont;
 580 }
 581
 582 WMFont *
 583 WMGetFontOfSize(WMScreen *scr, WMFont *font, int size)
 584 {
 585     if(!scr || !font || size<1)
 586         return NULL;
 587
 588     return font;
 589 }
 590
 591