WINGs/wfontpanel.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6 #include "WUtil.h"
   7
   8 #include <ctype.h>
   9 #include <string.h>
  10
  11
  12 typedef struct W_FontPanel {
  13     WMWindow *win;
  14
  15     WMFrame *upperF;
  16     WMTextField *sampleT;
  17
  18     WMSplitView *split;
  19
  20     WMFrame *lowerF;
  21     WMLabel *famL;
  22     WMList *famLs;
  23     WMLabel *typL;
  24     WMList *typLs;
  25     WMLabel *sizL;
  26     WMTextField *sizT;
  27     WMList *sizLs;
  28
  29     WMButton *revertB;
  30     WMButton *setB;
  31
  32     proplist_t fdb;
  33 } FontPanel;
  34
  35
  36 #define MIN_UPPER_HEIGHT        20
  37 #define MIN_LOWER_HEIGHT        140
  38
  39
  40 #define MAX_FONTS_TO_RETRIEVE   2000
  41
  42 #define BUTTON_SPACE_HEIGHT 40
  43
  44 #define MIN_WIDTH       250
  45 #define MIN_HEIGHT      (MIN_UPPER_HEIGHT+MIN_LOWER_HEIGHT+BUTTON_SPACE_HEIGHT)
  46
  47 #define DEF_UPPER_HEIGHT 60
  48 #define DEF_LOWER_HEIGHT 310
  49
  50 #define DEF_WIDTH       320
  51 #define DEF_HEIGHT      (DEF_UPPER_HEIGHT+DEF_LOWER_HEIGHT)
  52
  53
  54
  55
  56 static int scalableFontSizes[] = {
  57     8,
  58         10,
  59         11,
  60         12,
  61         14,
  62         16,
  63         18,
  64         20,
  65         24,
  66         36,
  67         48,
  68         64
  69 };
  70
  71
  72
  73 static void getSelectedFont(FontPanel *panel, char buffer[]);
  74
  75
  76 static void arrangeLowerFrame(FontPanel *panel);
  77
  78 static void familyClick(WMWidget *, void *);
  79 static void typefaceClick(WMWidget *, void *);
  80 static void sizeClick(WMWidget *, void *);
  81
  82
  83 static void listFamilies(WMScreen *scr, WMFontPanel *panel);
  84
  85
  86 static void
  87 splitViewConstrainCallback(WMSplitView *sPtr, int indView, int *min, int *max)
  88 {
  89     if (indView == 0)
  90         *min = MIN_UPPER_HEIGHT;
  91     else
  92         *min = MIN_LOWER_HEIGHT;
  93 }
  94
  95 static void
  96 notificationObserver(void *self, WMNotification *notif)
  97 {
  98     WMFontPanel *panel = (WMFontPanel*)self;
  99     void *object = WMGetNotificationObject(notif);
 100
 101     if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
 102         if (object == WMWidgetView(panel->win)) {
 103             int h = WMWidgetHeight(panel->win);
 104             int w = WMWidgetWidth(panel->win);
 105
 106             WMResizeWidget(panel->split, w, h-BUTTON_SPACE_HEIGHT);
 107
 108             WMMoveWidget(panel->setB, w-80, h-(BUTTON_SPACE_HEIGHT-5));
 109
 110             WMMoveWidget(panel->revertB, w-240, h-(BUTTON_SPACE_HEIGHT-5));
 111
 112         } else if (object == WMWidgetView(panel->upperF)) {
 113
 114             if (WMWidgetHeight(panel->upperF) < MIN_UPPER_HEIGHT) {
 115                 WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF),
 116                                MIN_UPPER_HEIGHT);
 117             } else {
 118                 WMResizeWidget(panel->sampleT, WMWidgetWidth(panel->upperF)-20,
 119                                WMWidgetHeight(panel->upperF)-10);
 120             }
 121
 122         } else if (object == WMWidgetView(panel->lowerF)) {
 123
 124             if (WMWidgetHeight(panel->lowerF) < MIN_LOWER_HEIGHT) {
 125                 WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF),
 126                                MIN_UPPER_HEIGHT);
 127
 128                 WMMoveWidget(panel->lowerF, 0, WMWidgetHeight(panel->upperF)
 129                              + WMGetSplitViewDividerThickness(panel->split));
 130
 131                 WMResizeWidget(panel->lowerF, WMWidgetWidth(panel->lowerF),
 132                                WMWidgetWidth(panel->split) - MIN_UPPER_HEIGHT
 133                                - WMGetSplitViewDividerThickness(panel->split));
 134             } else {
 135                 arrangeLowerFrame(panel);
 136             }
 137         }
 138     }
 139 }
 140
 141
 142 static void
 143 closeWindow(WMWidget *w, void *data)
 144 {
 145     FontPanel *panel = (FontPanel*)data;
 146
 147     WMHideFontPanel(panel);
 148 }
 149
 150
 151
 152 WMFontPanel*
 153 WMGetFontPanel(WMScreen *scr)
 154 {
 155     FontPanel *panel;
 156     WMColor *dark, *white;
 157     WMFont *font;
 158     int divThickness;
 159
 160     if (scr->sharedFontPanel)
 161         return scr->sharedFontPanel;
 162
 163
 164     panel = wmalloc(sizeof(FontPanel));
 165     memset(panel, 0, sizeof(FontPanel));
 166
 167     panel->win = WMCreateWindow(scr, "fontPanel");
 168 /*    WMSetWidgetBackgroundColor(panel->win, WMWhiteColor(scr));*/
 169     WMResizeWidget(panel->win, DEF_WIDTH, DEF_HEIGHT);
 170     WMSetWindowMinSize(panel->win, MIN_WIDTH, MIN_HEIGHT);
 171     WMSetViewNotifySizeChanges(WMWidgetView(panel->win), True);
 172
 173     WMSetWindowCloseAction(panel->win, closeWindow, panel);
 174
 175     panel->split = WMCreateSplitView(panel->win);
 176     WMResizeWidget(panel->split, DEF_WIDTH, DEF_HEIGHT - BUTTON_SPACE_HEIGHT);
 177     WMSetSplitViewConstrainProc(panel->split, splitViewConstrainCallback);
 178
 179     divThickness = WMGetSplitViewDividerThickness(panel->split);
 180
 181     panel->upperF = WMCreateFrame(panel->win);
 182     WMSetFrameRelief(panel->upperF, WRFlat);
 183     WMSetViewNotifySizeChanges(WMWidgetView(panel->upperF), True);
 184     panel->lowerF = WMCreateFrame(panel->win);
 185 /*    WMSetWidgetBackgroundColor(panel->lowerF, WMBlackColor(scr));*/
 186     WMSetFrameRelief(panel->lowerF, WRFlat);
 187     WMSetViewNotifySizeChanges(WMWidgetView(panel->lowerF), True);
 188
 189     WMAddSplitViewSubview(panel->split, W_VIEW(panel->upperF));
 190     WMAddSplitViewSubview(panel->split, W_VIEW(panel->lowerF));
 191
 192     WMResizeWidget(panel->upperF, DEF_WIDTH, DEF_UPPER_HEIGHT);
 193
 194     WMResizeWidget(panel->lowerF, DEF_WIDTH, DEF_LOWER_HEIGHT);
 195
 196     WMMoveWidget(panel->lowerF, 0, 60+divThickness);
 197
 198     white = WMWhiteColor(scr);
 199     dark = WMDarkGrayColor(scr);
 200
 201     panel->sampleT = WMCreateTextField(panel->upperF);
 202     WMResizeWidget(panel->sampleT, DEF_WIDTH - 20, 50);
 203     WMMoveWidget(panel->sampleT, 10, 10);
 204     WMSetTextFieldText(panel->sampleT, "Test!!!");
 205
 206     font = WMBoldSystemFontOfSize(scr, 12);
 207
 208     panel->famL = WMCreateLabel(panel->lowerF);
 209     WMSetWidgetBackgroundColor(panel->famL, dark);
 210     WMSetLabelText(panel->famL, "Family");
 211     WMSetLabelFont(panel->famL, font);
 212     WMSetLabelTextColor(panel->famL, white);
 213     WMSetLabelRelief(panel->famL, WRSunken);
 214     WMSetLabelTextAlignment(panel->famL, WACenter);
 215
 216     panel->famLs = WMCreateList(panel->lowerF);
 217     WMSetListAction(panel->famLs, familyClick, panel);
 218
 219     panel->typL = WMCreateLabel(panel->lowerF);
 220     WMSetWidgetBackgroundColor(panel->typL, dark);
 221     WMSetLabelText(panel->typL, "Typeface");
 222     WMSetLabelFont(panel->typL, font);
 223     WMSetLabelTextColor(panel->typL, white);
 224     WMSetLabelRelief(panel->typL, WRSunken);
 225     WMSetLabelTextAlignment(panel->typL, WACenter);
 226
 227     panel->typLs = WMCreateList(panel->lowerF);
 228     WMSetListAction(panel->typLs, typefaceClick, panel);
 229
 230     panel->sizL = WMCreateLabel(panel->lowerF);
 231     WMSetWidgetBackgroundColor(panel->sizL, dark);
 232     WMSetLabelText(panel->sizL, "Size");
 233     WMSetLabelFont(panel->sizL, font);
 234     WMSetLabelTextColor(panel->sizL, white);
 235     WMSetLabelRelief(panel->sizL, WRSunken);
 236     WMSetLabelTextAlignment(panel->sizL, WACenter);
 237
 238     panel->sizT = WMCreateTextField(panel->lowerF);
 239 /*    WMSetTextFieldAlignment(panel->sizT, WARight);*/
 240
 241     panel->sizLs = WMCreateList(panel->lowerF);
 242     WMSetListAction(panel->sizLs, sizeClick, panel);
 243
 244     WMReleaseFont(font);
 245     WMReleaseColor(white);
 246     WMReleaseColor(dark);
 247
 248     panel->setB = WMCreateCommandButton(panel->win);
 249     WMResizeWidget(panel->setB, 70, 24);
 250     WMMoveWidget(panel->setB, 240, DEF_HEIGHT - (BUTTON_SPACE_HEIGHT-5));
 251     WMSetButtonText(panel->setB, "Set");
 252
 253     panel->revertB = WMCreateCommandButton(panel->win);
 254     WMResizeWidget(panel->revertB, 70, 24);
 255     WMMoveWidget(panel->revertB, 80, DEF_HEIGHT - (BUTTON_SPACE_HEIGHT-5));
 256     WMSetButtonText(panel->revertB, "Revert");
 257
 258     WMRealizeWidget(panel->win);
 259
 260     WMMapSubwidgets(panel->upperF);
 261     WMMapSubwidgets(panel->lowerF);
 262     WMMapSubwidgets(panel->split);
 263     WMMapSubwidgets(panel->win);
 264
 265     WMUnmapWidget(panel->revertB);
 266
 267     arrangeLowerFrame(panel);
 268
 269     scr->sharedFontPanel = panel;
 270
 271
 272     /* register notification observers */
 273     WMAddNotificationObserver(notificationObserver, panel,
 274                               WMViewSizeDidChangeNotification,
 275                               WMWidgetView(panel->win));
 276     WMAddNotificationObserver(notificationObserver, panel,
 277                               WMViewSizeDidChangeNotification,
 278                               WMWidgetView(panel->upperF));
 279     WMAddNotificationObserver(notificationObserver, panel,
 280                               WMViewSizeDidChangeNotification,
 281                               WMWidgetView(panel->lowerF));
 282
 283
 284     listFamilies(scr, panel);
 285
 286
 287     return panel;
 288 }
 289
 290
 291 void
 292 WMFreeFontPanel(WMFontPanel *panel)
 293 {
 294     if (panel == WMWidgetScreen(panel->win)->sharedFontPanel) {
 295         WMWidgetScreen(panel->win)->sharedFontPanel = NULL;
 296     }
 297     WMRemoveNotificationObserver(panel);
 298     WMUnmapWidget(panel->win);
 299     WMDestroyWidget(panel->win);
 300     wfree(panel);
 301 }
 302
 303
 304 void
 305 WMShowFontPanel(WMFontPanel *panel)
 306 {
 307     WMMapWidget(panel->win);
 308 }
 309
 310
 311 void
 312 WMHideFontPanel(WMFontPanel *panel)
 313 {
 314     WMUnmapWidget(panel->win);
 315 }
 316
 317
 318 void
 319 WMSetFontPanelFont(WMFontPanel *panel, WMFont *font)
 320 {
 321
 322 }
 323
 324
 325 Bool
 326 WMSetFontPanelFontName(WMFontPanel *panel, char *fontName)
 327 {
 328
 329     return True;
 330 }
 331
 332
 333 WMFont*
 334 WMGetFontPanelFont(WMFontPanel *panel)
 335 {
 336     return WMGetTextFieldFont(panel->sampleT);
 337 }
 338
 339
 340 char*
 341 WMGetFontPanelFontName(WMFontPanel *panel)
 342 {
 343     char name[256];
 344
 345     getSelectedFont(panel, name);
 346
 347     return wstrdup(name);
 348 }
 349
 350
 351
 352 static void
 353 arrangeLowerFrame(FontPanel *panel)
 354 {
 355     int width = WMWidgetWidth(panel->lowerF) - 55 - 30;
 356     int height = WMWidgetHeight(panel->split) - WMWidgetHeight(panel->upperF);
 357     int fw, tw, sw;
 358
 359 #define LABEL_HEIGHT 20
 360
 361     height -= WMGetSplitViewDividerThickness(panel->split);
 362
 363
 364     height -= LABEL_HEIGHT + 8;
 365
 366     fw = (125*width) / 235;
 367     tw = (110*width) / 235;
 368     sw = 55;
 369
 370     WMMoveWidget(panel->famL, 10, 0);
 371     WMResizeWidget(panel->famL, fw, LABEL_HEIGHT);
 372
 373     WMMoveWidget(panel->famLs, 10, 23);
 374     WMResizeWidget(panel->famLs, fw, height);
 375
 376     WMMoveWidget(panel->typL, 10+fw+3, 0);
 377     WMResizeWidget(panel->typL, tw, LABEL_HEIGHT);
 378
 379     WMMoveWidget(panel->typLs, 10+fw+3, 23);
 380     WMResizeWidget(panel->typLs, tw, height);
 381
 382     WMMoveWidget(panel->sizL, 10+fw+3+tw+3, 0);
 383     WMResizeWidget(panel->sizL, sw+4, LABEL_HEIGHT);
 384
 385     WMMoveWidget(panel->sizT, 10+fw+3+tw+3, 23);
 386     WMResizeWidget(panel->sizT, sw+4, 20);
 387
 388     WMMoveWidget(panel->sizLs, 10+fw+3+tw+3, 46);
 389     WMResizeWidget(panel->sizLs, sw+4, height-23);
 390 }
 391
 392
 393
 394
 395 #define ALL_FONTS_MASK  "-*-*-*-*-*-*-*-*-*-*-*-*-*-*"
 396
 397 #define FOUNDRY 0
 398 #define FAMILY  1
 399 #define WEIGHT  2
 400 #define SLANT   3
 401 #define SETWIDTH 4
 402 #define ADD_STYLE 5
 403 #define PIXEL_SIZE 6
 404 #define POINT_SIZE 7
 405 #define RES_X   8
 406 #define RES_Y   9
 407 #define SPACING 10
 408 #define AV_WIDTH 11
 409 #define REGISTRY 12
 410 #define ENCODING 13
 411
 412 #define NUM_FIELDS 14
 413
 414
 415
 416 static Bool
 417 parseFont(char *font, char values[NUM_FIELDS][256])
 418 {
 419     char *ptr;
 420     int part;
 421     char buffer[256], *bptr;
 422
 423     part = FOUNDRY;
 424     ptr = font;
 425     ptr++; /* skip first - */
 426     bptr = buffer;
 427     while (*ptr) {
 428         if (*ptr == '-') {
 429             *bptr = 0;
 430             strcpy(values[part], buffer);
 431             bptr = buffer;
 432             part++;
 433         } else {
 434             *bptr++ = *ptr;
 435         }
 436         ptr++;
 437     }
 438     *bptr = 0;
 439     strcpy(values[part], buffer);
 440
 441     return True;
 442 }
 443
 444
 445
 446 static int
 447 isXLFD(char *font, int *length_ret)
 448 {
 449     int c = 0;
 450
 451     *length_ret = 0;
 452     while (*font) {
 453         (*length_ret)++;
 454         if (*font++ == '-')
 455             c++;
 456     }
 457
 458     return c==NUM_FIELDS;
 459 }
 460
 461
 462
 463
 464 typedef struct {
 465     char *weight;
 466     char *slant;
 467
 468     char *setWidth;
 469     char *addStyle;
 470
 471     char showSetWidth; /* when duplicated */
 472     char showAddStyle; /* when duplicated */
 473
 474     WMBag *sizes;
 475 } Typeface;
 476
 477
 478 typedef struct {
 479     char *name;
 480
 481     char *foundry;
 482     char *registry, *encoding;
 483
 484     char showFoundry; /* when duplicated */
 485     char showRegistry; /* when duplicated */
 486
 487     WMBag *typefaces;
 488 } Family;
 489
 490
 491
 492
 493 static int
 494 compare_int(const void *a, const void *b)
 495 {
 496     int i1 = *(int*)a;
 497     int i2 = *(int*)b;
 498
 499     if (i1 < i2)
 500         return -1;
 501     else if (i1 > i2)
 502         return 1;
 503     else
 504         return 0;
 505 }
 506
 507
 508
 509 static void
 510 addSizeToTypeface(Typeface *face, int size)
 511 {
 512     if (size == 0) {
 513         int j;
 514
 515         for (j = 0; j < sizeof(scalableFontSizes)/sizeof(int); j++) {
 516             size = scalableFontSizes[j];
 517
 518             if (!WMCountInBag(face->sizes, (void*)size)) {
 519                 WMPutInBag(face->sizes, (void*)size);
 520             }
 521         }
 522         WMSortBag(face->sizes, compare_int);
 523     } else {
 524         if (!WMCountInBag(face->sizes, (void*)size)) {
 525             WMPutInBag(face->sizes, (void*)size);
 526             WMSortBag(face->sizes, compare_int);
 527         }
 528     }
 529 }
 530
 531
 532
 533 static void
 534 addTypefaceToFamily(Family *family, char fontFields[NUM_FIELDS][256])
 535 {
 536     Typeface *face;
 537     WMBagIterator i;
 538
 539     if (family->typefaces) {
 540         for (face = WMBagFirst(family->typefaces, &i);
 541              face != NULL;
 542              face = WMBagNext(family->typefaces, &i)) {
 543             int size;
 544
 545             if (strcmp(face->weight, fontFields[WEIGHT]) != 0) {
 546                 continue;
 547             }
 548             if (strcmp(face->slant, fontFields[SLANT]) != 0) {
 549                 continue;
 550             }
 551
 552             size = atoi(fontFields[PIXEL_SIZE]);
 553
 554             addSizeToTypeface(face, size);
 555
 556             return;
 557         }
 558     } else {
 559         family->typefaces = WMCreateBag(4);
 560     }
 561
 562     face = wmalloc(sizeof(Typeface));
 563     memset(face, 0, sizeof(Typeface));
 564
 565     face->weight = wstrdup(fontFields[WEIGHT]);
 566     face->slant = wstrdup(fontFields[SLANT]);
 567     face->setWidth = wstrdup(fontFields[SETWIDTH]);
 568     face->addStyle = wstrdup(fontFields[ADD_STYLE]);
 569
 570     face->sizes = WMCreateBag(4);
 571     addSizeToTypeface(face, atoi(fontFields[PIXEL_SIZE]));
 572
 573     WMPutInBag(family->typefaces, face);
 574 }
 575
 576
 577
 578 /*
 579  * families (same family name) (Hashtable of family -> bag)
 580  *      registries (same family but different registries)
 581  *
 582  */
 583
 584 static void
 585 addFontToFamily(WMHashTable *families, char fontFields[NUM_FIELDS][256])
 586 {
 587     WMBagIterator i;
 588     Family *fam;
 589     WMBag *family;
 590
 591
 592     family = WMHashGet(families, fontFields[FAMILY]);
 593
 594     if (family) {
 595         /* look for same encoding/registry and foundry */
 596         for (fam = WMBagFirst(family, &i);
 597              fam != NULL;
 598              fam = WMBagNext(family, &i)) {
 599             int enc, reg, found;
 600
 601             enc = (strcmp(fam->encoding, fontFields[ENCODING]) == 0);
 602             reg = (strcmp(fam->registry, fontFields[REGISTRY]) == 0);
 603             found = (strcmp(fam->foundry, fontFields[FOUNDRY]) == 0);
 604
 605             if (enc && reg && found) {
 606                 addTypefaceToFamily(fam, fontFields);
 607                 return;
 608             }
 609         }
 610         /* look for same encoding/registry */
 611         for (fam = WMBagFirst(family, &i);
 612              fam != NULL;
 613              fam = WMBagNext(family, &i)) {
 614             int enc, reg;
 615
 616             enc = (strcmp(fam->encoding, fontFields[ENCODING]) == 0);
 617             reg = (strcmp(fam->registry, fontFields[REGISTRY]) == 0);
 618
 619             if (enc && reg) {
 620                 /* has the same encoding, but the foundry is different */
 621                 fam->showFoundry = 1;
 622
 623                 fam = wmalloc(sizeof(Family));
 624                 memset(fam, 0, sizeof(Family));
 625
 626                 fam->name = wstrdup(fontFields[FAMILY]);
 627                 fam->foundry = wstrdup(fontFields[FOUNDRY]);
 628                 fam->registry = wstrdup(fontFields[REGISTRY]);
 629                 fam->encoding = wstrdup(fontFields[ENCODING]);
 630                 fam->showFoundry = 1;
 631
 632                 addTypefaceToFamily(fam, fontFields);
 633
 634                 WMPutInBag(family, fam);
 635                 return;
 636             }
 637         }
 638         /* look for same foundry */
 639         for (fam = WMBagFirst(family, &i);
 640              fam != NULL;
 641              fam = WMBagNext(family, &i)) {
 642             int found;
 643
 644             found = (strcmp(fam->foundry, fontFields[FOUNDRY]) == 0);
 645
 646             if (found) {
 647                 /* has the same foundry, but encoding is different */
 648                 fam->showRegistry = 1;
 649
 650                 fam = wmalloc(sizeof(Family));
 651                 memset(fam, 0, sizeof(Family));
 652
 653                 fam->name = wstrdup(fontFields[FAMILY]);
 654                 fam->foundry = wstrdup(fontFields[FOUNDRY]);
 655                 fam->registry = wstrdup(fontFields[REGISTRY]);
 656                 fam->encoding = wstrdup(fontFields[ENCODING]);
 657                 fam->showRegistry = 1;
 658
 659                 addTypefaceToFamily(fam, fontFields);
 660
 661                 WMPutInBag(family, fam);
 662                 return;
 663             }
 664         }
 665         /* foundry and encoding do not match anything known */
 666         fam = wmalloc(sizeof(Family));
 667         memset(fam, 0, sizeof(Family));
 668
 669         fam->name = wstrdup(fontFields[FAMILY]);
 670         fam->foundry = wstrdup(fontFields[FOUNDRY]);
 671         fam->registry = wstrdup(fontFields[REGISTRY]);
 672         fam->encoding = wstrdup(fontFields[ENCODING]);
 673         fam->showFoundry = 1;
 674         fam->showRegistry = 1;
 675
 676         addTypefaceToFamily(fam, fontFields);
 677
 678         WMPutInBag(family, fam);
 679         return;
 680     }
 681
 682     family = WMCreateBag(8);
 683
 684     fam = wmalloc(sizeof(Family));
 685     memset(fam, 0, sizeof(Family));
 686
 687     fam->name = wstrdup(fontFields[FAMILY]);
 688     fam->foundry = wstrdup(fontFields[FOUNDRY]);
 689     fam->registry = wstrdup(fontFields[REGISTRY]);
 690     fam->encoding = wstrdup(fontFields[ENCODING]);
 691
 692     addTypefaceToFamily(fam, fontFields);
 693
 694     WMPutInBag(family, fam);
 695
 696     WMHashInsert(families, fam->name, family);
 697 }
 698
 699
 700
 701 static void
 702 listFamilies(WMScreen *scr, WMFontPanel *panel)
 703 {
 704     char **fontList;
 705     int count;
 706     int i;
 707     WMHashTable *families = WMCreateHashTable(WMStringPointerHashCallbacks);
 708     char fields[NUM_FIELDS][256];
 709     WMHashEnumerator enumer;
 710     WMBag *bag;
 711
 712     fontList = XListFonts(scr->display, ALL_FONTS_MASK, MAX_FONTS_TO_RETRIEVE,
 713                           &count);
 714     if (!fontList) {
 715         WMRunAlertPanel(scr, panel->win, "Error",
 716                         "Could not retrieve font list", "OK", NULL, NULL);
 717         return;
 718     }
 719
 720     for (i = 0; i < count; i++) {
 721         int fname_len;
 722
 723         if (!isXLFD(fontList[i], &fname_len)) {
 724             *fontList[i] = '\0';
 725             continue;
 726         }
 727         if (fname_len > 255) {
 728             wwarning("font name %s is longer than 256, which is invalid.",
 729                      fontList[i]);
 730             *fontList[i] = '\0';
 731             continue;
 732         }
 733         if (!parseFont(fontList[i], fields)) {
 734             *fontList[i] = '\0';
 735             continue;
 736         }
 737         addFontToFamily(families, fields);
 738     }
 739
 740     enumer = WMEnumerateHashTable(families);
 741
 742     while ((bag = WMNextHashEnumeratorItem(&enumer))) {
 743         WMBagIterator i;
 744         Family *fam;
 745         char buffer[256];
 746         WMListItem *item;
 747
 748         for (fam = WMBagFirst(bag, &i);
 749              fam != NULL;
 750              fam = WMBagNext(bag, &i)) {
 751
 752             strcpy(buffer, fam->name);
 753
 754             if (fam->showFoundry) {
 755                 strcat(buffer, " ");
 756                 strcat(buffer, fam->foundry);
 757                 strcat(buffer, " ");
 758             }
 759             if (fam->showRegistry) {
 760                 strcat(buffer, " (");
 761                 strcat(buffer, fam->registry);
 762                 strcat(buffer, "-");
 763                 strcat(buffer, fam->encoding);
 764                 strcat(buffer, ")");
 765             }
 766             item = WMAddListItem(panel->famLs, buffer);
 767
 768             item->clientData = fam;
 769         }
 770         WMFreeBag(bag);
 771     }
 772     WMSortListItems(panel->famLs);
 773
 774     WMFreeHashTable(families);
 775 }
 776
 777
 778 static void
 779 getSelectedFont(FontPanel *panel, char buffer[])
 780 {
 781     WMListItem *item;
 782     Family *family;
 783     Typeface *face;
 784     char *size;
 785
 786
 787     item = WMGetListSelectedItem(panel->famLs);
 788     if (!item)
 789         return;
 790     family = (Family*)item->clientData;
 791
 792     item = WMGetListSelectedItem(panel->typLs);
 793     if (!item)
 794         return;
 795     face = (Typeface*)item->clientData;
 796
 797     size = WMGetTextFieldText(panel->sizT);
 798
 799     sprintf(buffer, "-%s-%s-%s-%s-%s-%s-%s-*-*-*-*-*-%s-%s",
 800             family->foundry,
 801             family->name,
 802             face->weight,
 803             face->slant,
 804             face->setWidth,
 805             face->addStyle,
 806             size,
 807             family->registry,
 808             family->encoding);
 809 }
 810
 811
 812
 813 static void
 814 preview(FontPanel *panel)
 815 {
 816     char buffer[256];
 817     WMFont *font;
 818
 819     getSelectedFont(panel, buffer);
 820
 821     font = WMCreateFont(WMWidgetScreen(panel->win), buffer);
 822     if (font) {
 823         WMSetTextFieldFont(panel->sampleT, font);
 824         WMReleaseFont(font);
 825     }
 826 }
 827
 828
 829
 830 static void
 831 familyClick(WMWidget *w, void *data)
 832 {
 833     WMList *lPtr = (WMList*)w;
 834     WMListItem *item;
 835     Family *family;
 836     FontPanel *panel = (FontPanel*)data;
 837     Typeface *face;
 838     WMBagIterator i;
 839     /* current typeface and size */
 840     char *oface = NULL;
 841     char *osize = NULL;
 842     int facei = -1;
 843     int sizei = -1;
 844
 845     /* must try to keep the same typeface and size for the new family */
 846     item = WMGetListSelectedItem(panel->typLs);
 847     if (item)
 848         oface = wstrdup(item->text);
 849
 850     osize = WMGetTextFieldText(panel->sizT);
 851
 852
 853     item = WMGetListSelectedItem(lPtr);
 854     family = (Family*)item->clientData;
 855
 856     WMClearList(panel->typLs);
 857
 858
 859     for (face = WMBagFirst(family->typefaces, &i);
 860          face != NULL;
 861          face = WMBagNext(family->typefaces, &i)) {
 862         char buffer[256];
 863         int top=0;
 864         WMListItem *fitem;
 865
 866         if (strcmp(face->weight, "medium") == 0) {
 867             buffer[0] = 0;
 868         } else {
 869             if (*face->weight) {
 870                 strcpy(buffer, face->weight);
 871                 buffer[0] = toupper(buffer[0]);
 872                 strcat(buffer, " ");
 873             } else {
 874                 buffer[0] = 0;
 875             }
 876         }
 877
 878         if (strcmp(face->slant, "r") == 0) {
 879             strcat(buffer, "Roman");
 880             top = 1;
 881         } else if (strcmp(face->slant, "i") == 0) {
 882             strcat(buffer, "Italic");
 883         } else if (strcmp(face->slant, "o") == 0) {
 884             strcat(buffer, "Oblique");
 885         } else if (strcmp(face->slant, "ri") == 0) {
 886             strcat(buffer, "Rev Italic");
 887         } else if (strcmp(face->slant, "ro") == 0) {
 888             strcat(buffer, "Rev Oblique");
 889         } else {
 890             strcat(buffer, face->slant);
 891         }
 892
 893         if (buffer[0] == 0) {
 894             strcpy(buffer, "Normal");
 895         }
 896
 897         if (top)
 898             fitem = WMInsertListItem(panel->typLs, 0, buffer);
 899         else
 900             fitem = WMAddListItem(panel->typLs, buffer);
 901         fitem->clientData = face;
 902     }
 903
 904     if (oface) {
 905         facei = WMFindRowOfListItemWithTitle(panel->typLs, oface);
 906         wfree(oface);
 907     }
 908     if (facei < 0) {
 909         facei = 0;
 910     }
 911     WMSelectListItem(panel->typLs, facei);
 912     typefaceClick(panel->typLs, panel);
 913
 914     if (osize) {
 915         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
 916     }
 917     if (sizei >= 0) {
 918         WMSelectListItem(panel->sizLs, sizei);
 919         sizeClick(panel->sizLs, panel);
 920     }
 921
 922     if (osize)
 923         wfree(osize);
 924
 925
 926     preview(panel);
 927 }
 928
 929
 930 static void
 931 typefaceClick(WMWidget *w, void *data)
 932 {
 933     FontPanel *panel = (FontPanel*)data;
 934     WMListItem *item;
 935     Typeface *face;
 936     WMBagIterator i;
 937     char buffer[32];
 938
 939     char *osize = NULL;
 940     int sizei = -1;
 941     int size;
 942
 943     osize = WMGetTextFieldText(panel->sizT);
 944
 945
 946     item = WMGetListSelectedItem(panel->typLs);
 947     face = (Typeface*)item->clientData;
 948
 949     WMClearList(panel->sizLs);
 950
 951     for (size = (int)WMBagFirst(face->sizes, &i);
 952          i != NULL;
 953          size = (int)WMBagNext(face->sizes, &i)) {
 954
 955         if (size != 0) {
 956             sprintf(buffer, "%i", size);
 957
 958             WMAddListItem(panel->sizLs, buffer);
 959         }
 960     }
 961
 962     if (osize) {
 963         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
 964     }
 965     if (sizei < 0) {
 966         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, "12");
 967     }
 968     if (sizei < 0) {
 969         sizei = 0;
 970     }
 971     WMSelectListItem(panel->sizLs, sizei);
 972     WMSetListPosition(panel->sizLs, sizei);
 973     sizeClick(panel->sizLs, panel);
 974
 975     if (osize)
 976         wfree(osize);
 977
 978     preview(panel);
 979 }
 980
 981
 982 static void
 983 sizeClick(WMWidget *w, void *data)
 984 {
 985     FontPanel *panel = (FontPanel*)data;
 986     WMListItem *item;
 987
 988     item = WMGetListSelectedItem(panel->sizLs);
 989
 990     WMSetTextFieldText(panel->sizT, item->text);
 991
 992     WMSelectTextFieldRange(panel->sizT, wmkrange(0, strlen(item->text)));
 993
 994     preview(panel);
 995 }
 996