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, WMColor *color, WMFont *font,
 391              int x, int y, char *text, int length)
 392 {
 393     wassertr(font!=NULL);
 394
 395     XSetForeground(scr->display, scr->drawStringGC, W_PIXEL(color));
 396     if (font->notFontSet) {
 397         XSetFont(scr->display, scr->drawStringGC, font->font.normal->fid);
 398         XDrawString(scr->display, d, scr->drawStringGC, x, y + font->y, text,
 399                     length);
 400     } else {
 401         XmbDrawString(scr->display, d, font->font.set, scr->drawStringGC,
 402                       x, y + font->y, text, length);
 403     }
 404 }
 405
 406
 407 void
 408 WMDrawImageString(WMScreen *scr, Drawable d, WMColor *color, WMColor *background,
 409                   WMFont *font, int x, int y, char *text, int length)
 410 {
 411     wassertr(font != NULL);
 412
 413     XSetForeground(scr->display, scr->drawImStringGC, W_PIXEL(color));
 414     XSetBackground(scr->display, scr->drawImStringGC, W_PIXEL(background));
 415     if (font->notFontSet) {
 416         XSetFont(scr->display, scr->drawImStringGC, font->font.normal->fid);
 417         XDrawImageString(scr->display, d, scr->drawImStringGC, x, y + font->y,
 418                          text, length);
 419     } else {
 420         XmbDrawImageString(scr->display, d, font->font.set, scr->drawImStringGC,
 421                            x, y + font->y, text, length);
 422     }
 423 }
 424
 425
 426
 427
 428 static char*
 429 makeFontSetOfSize(char *fontset, int size)
 430 {
 431     char font[300], *f;
 432     char *newfs = NULL;
 433     char *ptr;
 434
 435     do {
 436         char *tmp;
 437         int end;
 438
 439
 440         f = fontset;
 441         ptr = strchr(fontset, ',');
 442         if (ptr) {
 443             int count = ptr-fontset;
 444
 445             if (count > 255) {
 446                 wwarning(_("font description %s is too large."), fontset);
 447             } else {
 448                 memcpy(font, fontset, count);
 449                 font[count] = 0;
 450                 f = (char*)font;
 451             }
 452         }
 453
 454         if (newfs)
 455             end = strlen(newfs);
 456         else
 457             end = 0;
 458
 459         tmp = wmalloc(end + strlen(f) + 8);
 460         if (end != 0) {
 461             sprintf(tmp, "%s,", newfs);
 462             sprintf(tmp + end + 1, f, size);
 463         } else {
 464             sprintf(tmp + end, f, size);
 465         }
 466
 467         if (newfs)
 468             wfree(newfs);
 469         newfs = tmp;
 470
 471         fontset = ptr+1;
 472     } while (ptr!=NULL);
 473
 474     return newfs;
 475 }
 476
 477
 478 static void
 479 changeFontProp(char *fname, char *newprop, int which)
 480 {
 481     char before[128], prop[128], after[128];
 482     char *ptr, *bptr;
 483     int part=0;
 484
 485     if(!fname || !prop)
 486         return;
 487
 488     ptr = fname;
 489     bptr = before;
 490     while (*ptr) {
 491         if(*ptr == '-') {
 492             *bptr = 0;
 493             if(part==which)
 494                 bptr = prop;
 495             else if(part==which+1)
 496                 bptr = after;
 497             *bptr++ = *ptr;
 498             part++;
 499         } else {
 500             *bptr++ = *ptr;
 501         }
 502         ptr++;
 503     }
 504     *bptr = 0;
 505     snprintf(fname, 255, "%s-%s%s", before, newprop, after);
 506 }
 507
 508
 509 WMFont*
 510 WMNormalizeFont(WMScreen *scr, WMFont *font)
 511 {
 512     WMFont *newfont=NULL;
 513     char fname[256];
 514
 515     if(!scr || !font)
 516         return NULL;
 517
 518     snprintf(fname, 255, font->name);
 519     changeFontProp(fname, "medium", 2);
 520     changeFontProp(fname, "r", 3);
 521     newfont = WMCreateNormalFont(scr, fname);
 522
 523     if(!newfont)
 524         return NULL;
 525
 526     return newfont;
 527 }
 528
 529
 530 WMFont*
 531 WMStrengthenFont(WMScreen *scr, WMFont *font)
 532 {
 533     WMFont *newfont=NULL;
 534     char fname[256];
 535
 536     if(!scr || !font)
 537         return NULL;
 538
 539     snprintf(fname, 255, font->name);
 540     changeFontProp(fname, "bold", 2);
 541     newfont = WMCreateNormalFont(scr, fname);
 542
 543     if(!newfont)
 544         return NULL;
 545
 546     return newfont;
 547 }
 548
 549
 550 WMFont*
 551 WMUnstrengthenFont(WMScreen *scr, WMFont *font)
 552 {
 553     WMFont *newfont=NULL;
 554     char fname[256];
 555
 556     if(!scr || !font)
 557         return NULL;
 558
 559     snprintf(fname, 255, font->name);
 560     changeFontProp(fname, "medium", 2);
 561     newfont = WMCreateNormalFont(scr, fname);
 562
 563     if(!newfont)
 564         return NULL;
 565
 566     return newfont;
 567 }
 568
 569
 570 WMFont*
 571 WMEmphasizeFont(WMScreen *scr, WMFont *font)
 572 {
 573     WMFont *newfont=NULL;
 574     char fname[256];
 575
 576     if(!scr || !font)
 577         return NULL;
 578
 579     snprintf(fname, 255, font->name);
 580     changeFontProp(fname, "o", 3);
 581     newfont = WMCreateNormalFont(scr, fname);
 582
 583     if(!newfont)
 584         return NULL;
 585
 586     return newfont;
 587 }
 588
 589
 590 WMFont*
 591 WMUnemphasizeFont(WMScreen *scr, WMFont *font)
 592 {
 593     WMFont *newfont=NULL;
 594     char fname[256];
 595
 596     if(!scr || !font)
 597         return NULL;
 598
 599     snprintf(fname, 255, font->name);
 600     changeFontProp(fname, "r", 3);
 601     newfont = WMCreateNormalFont(scr, fname);
 602
 603     if(!newfont)
 604         return NULL;
 605
 606     return newfont;
 607 }
 608
 609
 610 WMFont*
 611 WMGetFontOfSize(WMScreen *scr, WMFont *font, int size)
 612 {
 613     if(!scr || !font || size<1)
 614         return NULL;
 615
 616     return font;
 617 }
 618
 619