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+60;
  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->fontSetCache, 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->fontSetCache, 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         wfree(fname);
 197         return NULL;
 198     }
 199
 200     font->height = font->font.normal->ascent+font->font.normal->descent;
 201     font->y = font->font.normal->ascent;
 202
 203     font->refCount = 1;
 204
 205     font->name = fname;
 206
 207     assert(WMHashInsert(scrPtr->fontCache, font->name, font)==NULL);
 208
 209     return font;
 210 }
 211
 212
 213
 214 WMFont*
 215 WMCreateFont(WMScreen *scrPtr, char *fontName)
 216 {
 217     if (scrPtr->useMultiByte)
 218         return WMCreateFontSet(scrPtr, fontName);
 219     else
 220         return WMCreateNormalFont(scrPtr, fontName);
 221 }
 222
 223
 224
 225 WMFont*
 226 WMRetainFont(WMFont *font)
 227 {
 228     wassertrv(font!=NULL, NULL);
 229
 230     font->refCount++;
 231
 232     return font;
 233 }
 234
 235
 236 void
 237 WMReleaseFont(WMFont *font)
 238 {
 239     wassertr(font!=NULL);
 240
 241     font->refCount--;
 242     if (font->refCount < 1) {
 243         if (font->notFontSet)
 244             XFreeFont(font->screen->display, font->font.normal);
 245         else {
 246             XFreeFontSet(font->screen->display, font->font.set);
 247         }
 248         if (font->name) {
 249             if (font->notFontSet) {
 250                 WMHashRemove(font->screen->fontCache, font->name);
 251             } else {
 252                 WMHashRemove(font->screen->fontSetCache, font->name);
 253             }
 254             wfree(font->name);
 255         }
 256         wfree(font);
 257     }
 258 }
 259
 260
 261
 262 unsigned int
 263 WMFontHeight(WMFont *font)
 264 {
 265     wassertrv(font!=NULL, 0);
 266
 267     return font->height;
 268 }
 269
 270
 271 WMFont*
 272 WMDefaultSystemFont(WMScreen *scrPtr)
 273 {
 274     return WMRetainFont(scrPtr->normalFont);
 275 }
 276
 277
 278 WMFont*
 279 WMDefaultBoldSystemFont(WMScreen *scrPtr)
 280 {
 281     return WMRetainFont(scrPtr->boldFont);
 282 }
 283
 284
 285 WMFont*
 286 WMSystemFontOfSize(WMScreen *scrPtr, int size)
 287 {
 288     WMFont *font;
 289     char *fontSpec;
 290
 291     fontSpec = makeFontSetOfSize(WINGsConfiguration.systemFont, size);
 292
 293     if (scrPtr->useMultiByte)
 294         font = WMCreateFontSet(scrPtr, fontSpec);
 295     else
 296         font = WMCreateNormalFont(scrPtr, fontSpec);
 297
 298     if (!font) {
 299         if (scrPtr->useMultiByte) {
 300             wwarning(_("could not load font set %s. Trying fixed."), fontSpec);
 301             font = WMCreateFontSet(scrPtr, "fixed");
 302             if (!font) {
 303                 font = WMCreateFontSet(scrPtr, "-*-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*");
 304             }
 305         } else {
 306             wwarning(_("could not load font %s. Trying fixed."), fontSpec);
 307             font = WMCreateNormalFont(scrPtr, "fixed");
 308         }
 309         if (!font) {
 310             wwarning(_("could not load fixed font!"));
 311             wfree(fontSpec);
 312             return NULL;
 313         }
 314     }
 315     wfree(fontSpec);
 316
 317     return font;
 318 }
 319
 320
 321 WMFont*
 322 WMBoldSystemFontOfSize(WMScreen *scrPtr, int size)
 323 {
 324     WMFont *font;
 325     char *fontSpec;
 326
 327     fontSpec = makeFontSetOfSize(WINGsConfiguration.boldSystemFont, size);
 328
 329     if (scrPtr->useMultiByte)
 330         font = WMCreateFontSet(scrPtr, fontSpec);
 331     else
 332         font = WMCreateNormalFont(scrPtr, fontSpec);
 333
 334     if (!font) {
 335         if (scrPtr->useMultiByte) {
 336             wwarning(_("could not load font set %s. Trying fixed."), fontSpec);
 337             font = WMCreateFontSet(scrPtr, "fixed");
 338             if (!font) {
 339                 font = WMCreateFontSet(scrPtr, "-*-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*");
 340             }
 341         } else {
 342             wwarning(_("could not load font %s. Trying fixed."), fontSpec);
 343             font = WMCreateNormalFont(scrPtr, "fixed");
 344         }
 345         if (!font) {
 346             wwarning(_("could not load fixed font!"));
 347             wfree(fontSpec);
 348             return NULL;
 349         }
 350     }
 351     wfree(fontSpec);
 352
 353     return font;
 354 }
 355
 356
 357 XFontSet
 358 WMGetFontFontSet(WMFont *font)
 359 {
 360     wassertrv(font!=NULL, NULL);
 361
 362     if (font->notFontSet)
 363         return NULL;
 364     else
 365         return font->font.set;
 366 }
 367
 368
 369 int
 370 WMWidthOfString(WMFont *font, char *text, int length)
 371 {
 372     wassertrv(font!=NULL, 0);
 373     wassertrv(text!=NULL, 0);
 374
 375     if (font->notFontSet)
 376         return XTextWidth(font->font.normal, text, length);
 377     else {
 378         XRectangle rect;
 379         XRectangle AIXsucks;
 380
 381         XmbTextExtents(font->font.set, text, length, &AIXsucks, &rect);
 382
 383         return rect.width;
 384     }
 385 }
 386
 387
 388
 389 void
 390 WMDrawString(WMScreen *scr, Drawable d, GC gc, WMFont *font, int x, int y,
 391              char *text, int length)
 392 {
 393     wassertr(font!=NULL);
 394
 395     if (font->notFontSet) {
 396         XSetFont(scr->display, gc, font->font.normal->fid);
 397         XDrawString(scr->display, d, gc, x, y + font->y, text, length);
 398     } else {
 399         XmbDrawString(scr->display, d, font->font.set, gc, x, y + font->y,
 400                       text, length);
 401     }
 402 }
 403
 404
 405 void
 406 WMDrawImageString(WMScreen *scr, Drawable d, GC gc, WMFont *font, int x, int y,
 407                   char *text, int length)
 408 {
 409     wassertr(font != NULL);
 410
 411     if (font->notFontSet) {
 412         XSetFont(scr->display, gc, font->font.normal->fid);
 413         XDrawImageString(scr->display, d, gc, x, y + font->y, text, length);
 414     } else {
 415         XmbDrawImageString(scr->display, d, font->font.set, gc, x, y + font->y,
 416                            text, length);
 417     }
 418 }
 419
 420
 421
 422
 423 static char*
 424 makeFontSetOfSize(char *fontset, int size)
 425 {
 426     char font[300], *f;
 427     char *newfs = NULL;
 428     char *ptr;
 429
 430     do {
 431         char *tmp;
 432         int end;
 433
 434
 435         f = fontset;
 436         ptr = strchr(fontset, ',');
 437         if (ptr) {
 438             int count = ptr-fontset;
 439
 440             if (count > 255) {
 441                 wwarning(_("font description %s is too large."), fontset);
 442             } else {
 443                 memcpy(font, fontset, count);
 444                 font[count] = 0;
 445                 f = (char*)font;
 446             }
 447         }
 448
 449         if (newfs)
 450             end = strlen(newfs);
 451         else
 452             end = 0;
 453
 454         tmp = wmalloc(end + strlen(f) + 8);
 455         if (end != 0) {
 456             sprintf(tmp, "%s,", newfs);
 457             sprintf(tmp + end + 1, f, size);
 458         } else {
 459             sprintf(tmp + end, f, size);
 460         }
 461
 462         if (newfs)
 463             wfree(newfs);
 464         newfs = tmp;
 465
 466         fontset = ptr+1;
 467     } while (ptr!=NULL);
 468
 469     return newfs;
 470 }
 471
 472
 473 static void
 474 changeFontProp(char *fname, char *newprop, int which)
 475 {
 476     char before[128], prop[128], after[128];
 477     char *ptr, *bptr;
 478     int part=0;
 479
 480     if(!fname || !prop)
 481         return;
 482
 483     ptr = fname;
 484     bptr = before;
 485     while (*ptr) {
 486         if(*ptr == '-') {
 487             *bptr = 0;
 488             if(part==which)
 489                 bptr = prop;
 490             else if(part==which+1)
 491                 bptr = after;
 492             *bptr++ = *ptr;
 493             part++;
 494         } else {
 495             *bptr++ = *ptr;
 496         }
 497         ptr++;
 498     }
 499     *bptr = 0;
 500     snprintf(fname, 255, "%s-%s%s", before, newprop, after);
 501 }
 502
 503
 504 WMFont*
 505 WMNormalizeFont(WMScreen *scr, WMFont *font)
 506 {
 507     WMFont *newfont=NULL;
 508     char fname[256];
 509
 510     if(!scr || !font)
 511         return NULL;
 512
 513     snprintf(fname, 255, font->name);
 514     changeFontProp(fname, "medium", 2);
 515     changeFontProp(fname, "r", 3);
 516     newfont = WMCreateNormalFont(scr, fname);
 517
 518     if(!newfont)
 519         return NULL;
 520
 521     return newfont;
 522 }
 523
 524
 525 WMFont*
 526 WMStrengthenFont(WMScreen *scr, WMFont *font)
 527 {
 528     WMFont *newfont=NULL;
 529     char fname[256];
 530
 531     if(!scr || !font)
 532         return NULL;
 533
 534     snprintf(fname, 255, font->name);
 535     changeFontProp(fname, "bold", 2);
 536     newfont = WMCreateNormalFont(scr, fname);
 537
 538     if(!newfont)
 539         return NULL;
 540
 541     return newfont;
 542 }
 543
 544
 545 WMFont*
 546 WMUnstrengthenFont(WMScreen *scr, WMFont *font)
 547 {
 548     WMFont *newfont=NULL;
 549     char fname[256];
 550
 551     if(!scr || !font)
 552         return NULL;
 553
 554     snprintf(fname, 255, font->name);
 555     changeFontProp(fname, "medium", 2);
 556     newfont = WMCreateNormalFont(scr, fname);
 557
 558     if(!newfont)
 559         return NULL;
 560
 561     return newfont;
 562 }
 563
 564
 565 WMFont*
 566 WMEmphasizeFont(WMScreen *scr, WMFont *font)
 567 {
 568     WMFont *newfont=NULL;
 569     char fname[256];
 570
 571     if(!scr || !font)
 572         return NULL;
 573
 574     snprintf(fname, 255, font->name);
 575     changeFontProp(fname, "o", 3);
 576     newfont = WMCreateNormalFont(scr, fname);
 577
 578     if(!newfont)
 579         return NULL;
 580
 581     return newfont;
 582 }
 583
 584
 585 WMFont*
 586 WMUnemphasizeFont(WMScreen *scr, WMFont *font)
 587 {
 588     WMFont *newfont=NULL;
 589     char fname[256];
 590
 591     if(!scr || !font)
 592         return NULL;
 593
 594     snprintf(fname, 255, font->name);
 595     changeFontProp(fname, "r", 3);
 596     newfont = WMCreateNormalFont(scr, fname);
 597
 598     if(!newfont)
 599         return NULL;
 600
 601     return newfont;
 602 }
 603
 604
 605 WMFont*
 606 WMGetFontOfSize(WMScreen *scr, WMFont *font, int size)
 607 {
 608     if(!scr || !font || size<1)
 609         return NULL;
 610
 611     return font;
 612 }
 613
 614