WINGs/wfontpanel.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6 #include "WUtil.h"
   7
   8 #include <strings.h>
   9
  10
  11 typedef struct W_FontPanel {
  12     WMWindow *win;
  13
  14     WMFrame *upperF;
  15     WMLabel *sampleL;
  16
  17     WMSplitView *split;
  18
  19     WMFrame *lowerF;
  20     WMLabel *famL;
  21     WMList *famLs;
  22     WMLabel *typL;
  23     WMList *typLs;
  24     WMLabel *sizL;
  25     WMTextField *sizT;
  26     WMList *sizLs;
  27
  28     WMFrame *xlfdF;
  29     WMTextField *xlfdT;
  30
  31     WMFrame *encF;
  32     WMPopUpButton *encP;
  33
  34     WMButton *revertB;
  35     WMButton *previewB;
  36     WMButton *setB;
  37
  38     proplist_t fdb;
  39 } FontPanel;
  40
  41
  42 #define MIN_UPPER_HEIGHT        20
  43 #define MIN_LOWER_HEIGHT        140
  44
  45
  46 #define MAX_FONTS_TO_RETRIEVE   2000
  47
  48
  49 #define MIN_WIDTH       250
  50 #define MIN_HEIGHT      MIN_UPPER_HEIGHT+MIN_LOWER_HEIGHT+70
  51
  52 /*
  53 static char *scalableFontSizes[] = {
  54     "8",
  55         "10",
  56         "11",
  57         "12",
  58         "14",
  59         "16",
  60         "18",
  61         "20",
  62         "24",
  63         "36",
  64         "48",
  65         "64"
  66 };
  67 */
  68
  69
  70
  71
  72 static void arrangeLowerFrame(FontPanel *panel);
  73
  74 static void familyClick(WMWidget *, void *);
  75 static void typefaceClick(WMWidget *, void *);
  76 static void sizeClick(WMWidget *, void *);
  77
  78
  79 static void listFamilies(WMScreen *scr, WMFontPanel *panel);
  80
  81 static void
  82 splitViewConstrainCallback(WMSplitView *sPtr, int divIndex, int *min, int *max)
  83 {
  84     *min = MIN_UPPER_HEIGHT;
  85     *max = WMWidgetHeight(sPtr)-WMGetSplitViewDividerThickness(sPtr)-MIN_LOWER_HEIGHT;
  86 }
  87
  88
  89 static void
  90 notificationObserver(void *self, WMNotification *notif)
  91 {
  92     WMFontPanel *panel = (WMFontPanel*)self;
  93     void *object = WMGetNotificationObject(notif);
  94
  95     if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
  96         if (object == WMWidgetView(panel->win)) {
  97             int h = WMWidgetHeight(panel->win);
  98             int w = WMWidgetWidth(panel->win);
  99
 100             WMResizeWidget(panel->split, w, h-40);
 101
 102             WMMoveWidget(panel->setB, w-80, h-35);
 103             WMMoveWidget(panel->previewB, w-160, h-35);
 104             WMMoveWidget(panel->revertB, w-240, h-35);
 105         } else if (object == WMWidgetView(panel->upperF)) {
 106             WMResizeWidget(panel->sampleL, WMWidgetWidth(panel->upperF)-20,
 107                            WMWidgetHeight(panel->upperF)-10);
 108         } else if (object == WMWidgetView(panel->lowerF)) {
 109
 110             if (WMWidgetHeight(panel->lowerF) < MIN_LOWER_HEIGHT) {
 111                 int h;
 112
 113                 h =  WMWidgetHeight(panel->split)-MIN_LOWER_HEIGHT
 114                     - WMGetSplitViewDividerThickness(panel->split);
 115
 116                 WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF), h);
 117
 118                 WMMoveWidget(panel->lowerF, 0, WMWidgetHeight(panel->upperF)
 119                              + WMGetSplitViewDividerThickness(panel->split));
 120                 WMResizeWidget(panel->lowerF, WMWidgetWidth(panel->lowerF),
 121                                MIN_LOWER_HEIGHT);
 122             } else {
 123                 arrangeLowerFrame(panel);
 124             }
 125         }
 126     }
 127 }
 128
 129
 130 /*
 131 static void
 132 familyClick(WMWidget *w, void *data)
 133 {
 134     WMList *lPtr = (WMList*)w;
 135     FontPanel *panel = (FontPanel*)data;
 136
 137
 138
 139 }
 140 */
 141
 142 WMFontPanel*
 143 WMGetFontPanel(WMScreen *scr)
 144 {
 145     FontPanel *panel;
 146     WMColor *dark, *white;
 147     WMFont *font;
 148     int divThickness;
 149
 150     if (scr->sharedFontPanel)
 151         return scr->sharedFontPanel;
 152
 153
 154     panel = wmalloc(sizeof(FontPanel));
 155     memset(panel, 0, sizeof(FontPanel));
 156
 157     panel->win = WMCreateWindow(scr, "fontPanel");
 158     WMResizeWidget(panel->win, 320, 370);
 159     WMSetWindowMinSize(panel->win, MIN_WIDTH, MIN_HEIGHT);
 160     WMSetViewNotifySizeChanges(WMWidgetView(panel->win), True);
 161
 162     panel->split = WMCreateSplitView(panel->win);
 163     WMResizeWidget(panel->split, 320, 330);
 164     WMSetSplitViewConstrainProc(panel->split, splitViewConstrainCallback);
 165
 166     divThickness = WMGetSplitViewDividerThickness(panel->split);
 167
 168     panel->upperF = WMCreateFrame(panel->win);
 169     WMSetFrameRelief(panel->upperF, WRFlat);
 170     WMSetViewNotifySizeChanges(WMWidgetView(panel->upperF), True);
 171     panel->lowerF = WMCreateFrame(panel->win);
 172     WMSetFrameRelief(panel->lowerF, WRFlat);
 173     WMSetViewNotifySizeChanges(WMWidgetView(panel->lowerF), True);
 174
 175     WMAddSplitViewSubview(panel->split, W_VIEW(panel->upperF));
 176     WMAddSplitViewSubview(panel->split, W_VIEW(panel->lowerF));
 177
 178     WMResizeWidget(panel->upperF, 320, 60);
 179     WMResizeWidget(panel->lowerF, 320, 330-60-divThickness);
 180     WMMoveWidget(panel->lowerF, 0, 60+divThickness);
 181
 182     white = WMWhiteColor(scr);
 183     dark = WMDarkGrayColor(scr);
 184
 185     panel->sampleL = WMCreateLabel(panel->upperF);
 186     WMResizeWidget(panel->sampleL, 300, 50);
 187     WMMoveWidget(panel->sampleL, 10, 10);
 188     WMSetWidgetBackgroundColor(panel->sampleL, white);
 189     WMSetLabelRelief(panel->sampleL, WRSunken);
 190     WMSetLabelText(panel->sampleL, "It is not yet completed!!!");
 191
 192     font = WMBoldSystemFontOfSize(scr, 12);
 193
 194     panel->famL = WMCreateLabel(panel->lowerF);
 195     WMSetWidgetBackgroundColor(panel->famL, dark);
 196     WMSetLabelText(panel->famL, "Family");
 197     WMSetLabelFont(panel->famL, font);
 198     WMSetLabelTextColor(panel->famL, white);
 199     WMSetLabelRelief(panel->famL, WRSunken);
 200     WMSetLabelTextAlignment(panel->famL, WACenter);
 201
 202     panel->famLs = WMCreateList(panel->lowerF);
 203     WMSetListAction(panel->famLs, familyClick, panel);
 204
 205     panel->typL = WMCreateLabel(panel->lowerF);
 206     WMSetWidgetBackgroundColor(panel->typL, dark);
 207     WMSetLabelText(panel->typL, "Typeface");
 208     WMSetLabelFont(panel->typL, font);
 209     WMSetLabelTextColor(panel->typL, white);
 210     WMSetLabelRelief(panel->typL, WRSunken);
 211     WMSetLabelTextAlignment(panel->typL, WACenter);
 212
 213     panel->typLs = WMCreateList(panel->lowerF);
 214     WMSetListAction(panel->typLs, typefaceClick, panel);
 215
 216     panel->sizL = WMCreateLabel(panel->lowerF);
 217     WMSetWidgetBackgroundColor(panel->sizL, dark);
 218     WMSetLabelText(panel->sizL, "Size");
 219     WMSetLabelFont(panel->sizL, font);
 220     WMSetLabelTextColor(panel->sizL, white);
 221     WMSetLabelRelief(panel->sizL, WRSunken);
 222     WMSetLabelTextAlignment(panel->sizL, WACenter);
 223
 224     panel->sizT = WMCreateTextField(panel->lowerF);
 225
 226     panel->sizLs = WMCreateList(panel->lowerF);
 227     WMSetListAction(panel->sizLs, sizeClick, panel);
 228
 229     WMReleaseFont(font);
 230     WMReleaseColor(white);
 231     WMReleaseColor(dark);
 232
 233     panel->encF = WMCreateFrame(panel->lowerF);
 234     WMSetFrameTitle(panel->encF, "Encoding");
 235     WMResizeWidget(panel->encF, 130, 50);
 236
 237     panel->encP = WMCreatePopUpButton(panel->encF);
 238     WMMoveWidget(panel->encP, 10, 20);
 239     WMResizeWidget(panel->encP, 112, 20);
 240
 241     WMMapSubwidgets(panel->encF);
 242
 243     panel->xlfdF = WMCreateFrame(panel->lowerF);
 244     WMSetFrameTitle(panel->xlfdF, "Xtra Long Font Description");
 245
 246     panel->xlfdT = WMCreateTextField(panel->xlfdF);
 247     WMMoveWidget(panel->xlfdT, 10, 20);
 248
 249     WMMapSubwidgets(panel->xlfdF);
 250
 251     arrangeLowerFrame(panel);
 252
 253     panel->setB = WMCreateCommandButton(panel->win);
 254     WMResizeWidget(panel->setB, 70, 24);
 255     WMMoveWidget(panel->setB, 240, 335);
 256     WMSetButtonText(panel->setB, "Set");
 257
 258     panel->previewB = WMCreateCommandButton(panel->win);
 259     WMResizeWidget(panel->previewB, 70, 24);
 260     WMMoveWidget(panel->previewB, 160, 335);
 261     WMSetButtonText(panel->previewB, "Preview");
 262
 263     panel->revertB = WMCreateCommandButton(panel->win);
 264     WMResizeWidget(panel->revertB, 70, 24);
 265     WMMoveWidget(panel->revertB, 80, 335);
 266     WMSetButtonText(panel->revertB, "Revert");
 267
 268     WMRealizeWidget(panel->win);
 269
 270     WMMapSubwidgets(panel->upperF);
 271     WMMapSubwidgets(panel->lowerF);
 272     WMMapSubwidgets(panel->split);
 273     WMMapSubwidgets(panel->win);
 274
 275     scr->sharedFontPanel = panel;
 276
 277
 278     /* register notification observers */
 279     WMAddNotificationObserver(notificationObserver, panel,
 280                               WMViewSizeDidChangeNotification,
 281                               WMWidgetView(panel->win));
 282     WMAddNotificationObserver(notificationObserver, panel,
 283                               WMViewSizeDidChangeNotification,
 284                               WMWidgetView(panel->upperF));
 285     WMAddNotificationObserver(notificationObserver, panel,
 286                               WMViewSizeDidChangeNotification,
 287                               WMWidgetView(panel->lowerF));
 288
 289
 290     listFamilies(scr, panel);
 291
 292
 293     return panel;
 294 }
 295
 296
 297 void
 298 WMFreeFontPanel(WMFontPanel *panel)
 299 {
 300     if (panel == WMWidgetScreen(panel->win)->sharedFontPanel) {
 301         WMWidgetScreen(panel->win)->sharedFontPanel = NULL;
 302     }
 303     WMRemoveNotificationObserver(panel);
 304     WMUnmapWidget(panel->win);
 305     WMDestroyWidget(panel->win);
 306     free(panel);
 307 }
 308
 309
 310 void
 311 WMShowFontPanel(WMFontPanel *panel)
 312 {
 313     WMMapWidget(panel->win);
 314 }
 315
 316
 317 void
 318 WMHideFontPanel(WMFontPanel *panel)
 319 {
 320     WMUnmapWidget(panel->win);
 321 }
 322
 323
 324 void
 325 WMSetFontPanelFont(WMFontPanel *panel, WMFont *font)
 326 {
 327 }
 328
 329
 330 WMFont*
 331 WMGetFontPanelFont(WMFontPanel *panel)
 332 {
 333     return NULL;
 334 }
 335
 336
 337 char*
 338 WMGetFontPanelFontName(WMFontPanel *panel)
 339 {
 340     return NULL;
 341 }
 342
 343
 344
 345
 346 static void
 347 arrangeLowerFrame(FontPanel *panel)
 348 {
 349     int width = WMWidgetWidth(panel->lowerF) - 55 - 30;
 350     int height = WMWidgetHeight(panel->lowerF);
 351     int oheight = 330-60-WMGetSplitViewDividerThickness(panel->split);
 352     int fw, tw, sw;
 353     int h;
 354
 355     height -= 20 + 3 + 10 + 50;
 356     oheight -= 20 + 3 + 10 + 50;
 357
 358     fw = (125*width) / 235;
 359     tw = (110*width) / 235;
 360     sw = 55;
 361
 362     h = (174*height) / oheight;
 363
 364     WMMoveWidget(panel->famL, 10, 0);
 365     WMResizeWidget(panel->famL, fw, 20);
 366
 367     WMMoveWidget(panel->famLs, 10, 23);
 368     WMResizeWidget(panel->famLs, fw, h);
 369
 370     WMMoveWidget(panel->typL, 10+fw+3, 0);
 371     WMResizeWidget(panel->typL, tw, 20);
 372
 373     WMMoveWidget(panel->typLs, 10+fw+3, 23);
 374     WMResizeWidget(panel->typLs, tw, h);
 375
 376     WMMoveWidget(panel->sizL, 10+fw+3+tw+3, 0);
 377     WMResizeWidget(panel->sizL, sw+4, 20);
 378
 379     WMMoveWidget(panel->sizT, 10+fw+3+tw+3, 23);
 380     WMResizeWidget(panel->sizT, sw+4, 20);
 381
 382     WMMoveWidget(panel->sizLs, 10+fw+3+tw+3, 46);
 383     WMResizeWidget(panel->sizLs, sw+4, h-22);
 384
 385     WMMoveWidget(panel->encF, 10, WMWidgetHeight(panel->lowerF)-55);
 386
 387     WMMoveWidget(panel->xlfdF, 145, WMWidgetHeight(panel->lowerF)-55);
 388     WMResizeWidget(panel->xlfdF, WMWidgetWidth(panel->lowerF)-155, 50);
 389
 390     WMResizeWidget(panel->xlfdT, WMWidgetWidth(panel->lowerF)-155-20, 20);
 391 }
 392
 393
 394
 395
 396 #define ALL_FONTS_MASK  "-*-*-*-*-*-*-*-*-*-*-*-*-*-*"
 397
 398 #define FOUNDRY 0
 399 #define FAMILY  1
 400 #define WEIGHT  2
 401 #define SLANT   3
 402 #define SETWIDTH 4
 403 #define ADD_STYLE 5
 404 #define PIXEL_SIZE 6
 405 #define POINT_SIZE 7
 406 #define RES_X   8
 407 #define RES_Y   9
 408 #define SPACING 10
 409 #define AV_WIDTH 11
 410 #define REGISTRY 12
 411 #define ENCODING 13
 412
 413 #define NUM_FIELDS 14
 414
 415
 416 #if 1
 417
 418 static Bool
 419 parseFont(char *font, char values[NUM_FIELDS][256])
 420 {
 421     char *ptr;
 422     int part;
 423     char buffer[256], *bptr;
 424
 425     part = FOUNDRY;
 426     ptr = font;
 427     ptr++; /* skip first - */
 428     bptr = buffer;
 429     while (*ptr) {
 430         if (*ptr == '-') {
 431             *bptr = 0;
 432             strcpy(values[part], buffer);
 433             bptr = buffer;
 434             part++;
 435         } else {
 436             *bptr++ = *ptr;
 437         }
 438         ptr++;
 439     }
 440     *bptr = 0;
 441     strcpy(values[part], buffer);
 442
 443     return True;
 444 }
 445
 446
 447
 448 static int
 449 isXLFD(char *font, int *length_ret)
 450 {
 451     int c = 0;
 452
 453     *length_ret = 0;
 454     while (*font) {
 455         (*length_ret)++;
 456         if (*font++ == '-')
 457             c++;
 458     }
 459
 460     return c==NUM_FIELDS;
 461 }
 462
 463
 464
 465
 466 typedef struct {
 467     char *weight;
 468     char *slant;
 469
 470     char *setWidth;
 471     char *addStyle;
 472
 473     char showSetWidth; /* when duplicated */
 474     char showAddStyle; /* when duplicated */
 475
 476     WMBag *sizes;
 477 } Typeface;
 478
 479
 480 typedef struct {
 481     char *name;
 482
 483     char *foundry;
 484     char *registry, *encoding;
 485
 486     char showFoundry; /* when duplicated */
 487     char showRegistry; /* when duplicated */
 488
 489     WMBag *typefaces;
 490 } Family;
 491
 492
 493
 494 static void
 495 addTypefaceToFamily(Family *family, char fontFields[NUM_FIELDS][256])
 496 {
 497     Typeface *face;
 498     int i;
 499
 500     if (family->typefaces) {
 501         for (i = 0; i < WMGetBagItemCount(family->typefaces); i++) {
 502             int size;
 503
 504             face = WMGetFromBag(family->typefaces, i);
 505
 506             if (strcmp(face->weight, fontFields[WEIGHT]) != 0) {
 507                 continue;
 508             }
 509             if (strcmp(face->slant, fontFields[SLANT]) != 0) {
 510                 continue;
 511             }
 512
 513             size = atoi(fontFields[POINT_SIZE]);
 514             WMPutInBag(face->sizes, (void*)size);
 515
 516             return;
 517         }
 518     } else {
 519         family->typefaces = WMCreateBag(4);
 520     }
 521
 522     face = wmalloc(sizeof(Typeface));
 523     memset(face, 0, sizeof(Typeface));
 524
 525     face->weight = wstrdup(fontFields[WEIGHT]);
 526     face->slant = wstrdup(fontFields[SLANT]);
 527     face->setWidth = wstrdup(fontFields[SETWIDTH]);
 528     face->addStyle = wstrdup(fontFields[ADD_STYLE]);
 529
 530     face->sizes = WMCreateBag(4);
 531     WMPutInBag(face->sizes, (void*)atoi(fontFields[POINT_SIZE]));
 532
 533     WMPutInBag(family->typefaces, face);
 534 }
 535
 536
 537
 538 /*
 539  * families (same family name) (Hashtable of family -> bag)
 540  *      registries (same family but different registries)
 541  *
 542  */
 543
 544 static void
 545 addFontToFamily(WMHashTable *families, char fontFields[NUM_FIELDS][256])
 546 {
 547     int i;
 548     Family *fam;
 549     WMBag *family;
 550
 551     family = WMHashGet(families, fontFields[FAMILY]);
 552
 553     if (family) {
 554         /* look for same encoding/registry and foundry */
 555         for (i = 0; i < WMGetBagItemCount(family); i++) {
 556             int enc, reg, found;
 557
 558             fam = WMGetFromBag(family, i);
 559
 560             enc = (strcmp(fam->encoding, fontFields[ENCODING]) == 0);
 561             reg = (strcmp(fam->registry, fontFields[REGISTRY]) == 0);
 562             found = (strcmp(fam->foundry, fontFields[FOUNDRY]) == 0);
 563
 564             if (enc && reg && found) {
 565                 addTypefaceToFamily(fam, fontFields);
 566                 return;
 567             }
 568         }
 569         /* look for same encoding/registry */
 570         for (i = 0; i < WMGetBagItemCount(family); i++) {
 571             int enc, reg;
 572
 573             fam = WMGetFromBag(family, i);
 574
 575             enc = (strcmp(fam->encoding, fontFields[ENCODING]) == 0);
 576             reg = (strcmp(fam->registry, fontFields[REGISTRY]) == 0);
 577
 578             if (enc && reg) {
 579                 /* has the same encoding, but the foundry is different */
 580                 fam->showRegistry = 1;
 581
 582                 fam = wmalloc(sizeof(Family));
 583                 memset(fam, 0, sizeof(Family));
 584
 585                 fam->name = wstrdup(fontFields[FAMILY]);
 586                 fam->foundry = wstrdup(fontFields[FOUNDRY]);
 587                 fam->registry = wstrdup(fontFields[REGISTRY]);
 588                 fam->encoding = wstrdup(fontFields[ENCODING]);
 589                 fam->showRegistry = 1;
 590
 591                 addTypefaceToFamily(fam, fontFields);
 592
 593                 WMPutInBag(family, fam);
 594
 595                 return;
 596             }
 597         }
 598         /* look for same foundry */
 599         for (i = 0; i < WMGetBagItemCount(family); i++) {
 600             int found;
 601
 602             fam = WMGetFromBag(family, i);
 603
 604             found = (strcmp(fam->foundry, fontFields[FOUNDRY]) == 0);
 605
 606             if (found) {
 607                 /* has the same foundry, but encoding is different */
 608                 fam->showFoundry = 1;
 609
 610                 fam = wmalloc(sizeof(Family));
 611                 memset(fam, 0, sizeof(Family));
 612
 613                 fam->name = wstrdup(fontFields[FAMILY]);
 614                 fam->foundry = wstrdup(fontFields[FOUNDRY]);
 615                 fam->registry = wstrdup(fontFields[REGISTRY]);
 616                 fam->encoding = wstrdup(fontFields[ENCODING]);
 617                 fam->showFoundry = 1;
 618
 619                 addTypefaceToFamily(fam, fontFields);
 620
 621                 WMPutInBag(family, fam);
 622
 623                 return;
 624             }
 625         }
 626         /* foundry and encoding do not match anything known */
 627         fam = wmalloc(sizeof(Family));
 628         memset(fam, 0, sizeof(Family));
 629
 630         fam->name = wstrdup(fontFields[FAMILY]);
 631         fam->foundry = wstrdup(fontFields[FOUNDRY]);
 632         fam->registry = wstrdup(fontFields[REGISTRY]);
 633         fam->encoding = wstrdup(fontFields[ENCODING]);
 634         fam->showFoundry = 1;
 635         fam->showRegistry = 1;
 636
 637         addTypefaceToFamily(fam, fontFields);
 638
 639         WMPutInBag(family, fam);
 640
 641         return;
 642     }
 643
 644     family = WMCreateBag(8);
 645
 646     fam = wmalloc(sizeof(Family));
 647     memset(fam, 0, sizeof(Family));
 648
 649     fam->name = wstrdup(fontFields[FAMILY]);
 650     fam->foundry = wstrdup(fontFields[FOUNDRY]);
 651     fam->registry = wstrdup(fontFields[REGISTRY]);
 652     fam->encoding = wstrdup(fontFields[ENCODING]);
 653
 654     addTypefaceToFamily(fam, fontFields);
 655
 656     WMPutInBag(family, fam);
 657
 658     WMHashInsert(families, fam->name, family);
 659 }
 660
 661
 662
 663 static void
 664 listFamilies(WMScreen *scr, WMFontPanel *panel)
 665 {
 666     char **fontList;
 667     int count;
 668     int i;
 669     WMHashTable *families = WMCreateHashTable(WMStringHashCallbacks);
 670     char fields[NUM_FIELDS][256];
 671     WMHashEnumerator enumer;
 672     WMBag *bag;
 673
 674     fontList = XListFonts(scr->display, ALL_FONTS_MASK, MAX_FONTS_TO_RETRIEVE,
 675                           &count);
 676     if (!fontList) {
 677         WMRunAlertPanel(scr, panel->win, "Error",
 678                         "Could not retrieve font list", "OK", NULL, NULL);
 679         return;
 680     }
 681
 682     for (i = 0; i < count; i++) {
 683         int fname_len;
 684
 685         if (!isXLFD(fontList[i], &fname_len)) {
 686             *fontList[i] = '\0';
 687             continue;
 688         }
 689         if (fname_len > 255) {
 690             wwarning("font name %s is longer than 256, which is invalid.",
 691                      fontList[i]);
 692             *fontList[i] = '\0';
 693             continue;
 694         }
 695         if (!parseFont(fontList[i], fields)) {
 696             *fontList[i] = '\0';
 697             continue;
 698         }
 699         addFontToFamily(families, fields);
 700     }
 701
 702     enumer = WMEnumerateHashTable(families);
 703
 704     while ((bag = WMNextHashEnumeratorItem(&enumer))) {
 705         int i;
 706         Family *fam;
 707         char buffer[256];
 708         WMListItem *item;
 709
 710         for (i = 0; i < WMGetBagItemCount(bag); i++) {
 711             fam = WMGetFromBag(bag, i);
 712
 713             strcpy(buffer, fam->name);
 714
 715             if (fam->showFoundry) {
 716                 strcat(buffer, " ");
 717                 strcat(buffer, fam->foundry);
 718                 strcat(buffer, " ");
 719             }
 720             if (fam->showRegistry) {
 721                 strcat(buffer, " (");
 722                 strcat(buffer, fam->registry);
 723                 strcat(buffer, "-");
 724                 strcat(buffer, fam->encoding);
 725                 strcat(buffer, ")");
 726             }
 727             item = WMAddSortedListItem(panel->famLs, buffer);
 728
 729             item->clientData = fam;
 730         }
 731         WMFreeBag(bag);
 732     }
 733
 734     WMFreeHashTable(families);
 735 }
 736
 737
 738
 739 static void
 740 familyClick(WMWidget *w, void *data)
 741 {
 742     WMList *lPtr = (WMList*)w;
 743     WMListItem *item;
 744     Family *family;
 745     FontPanel *panel = (FontPanel*)data;
 746     Typeface *face;
 747     int i;
 748
 749     item = WMGetListSelectedItem(lPtr);
 750     family = (Family*)item->clientData;
 751
 752     WMClearList(panel->typLs);
 753
 754
 755     for (i = 0; i < WMGetBagItemCount(family->typefaces); i++) {
 756         char buffer[256];
 757
 758         face = WMGetFromBag(family->typefaces, i);
 759
 760         strcpy(buffer, face->weight);
 761         strcat(buffer, " ");
 762         strcat(buffer, face->slant);
 763
 764         WMAddListItem(panel->typLs, buffer);
 765     }
 766
 767 }
 768
 769
 770 static void
 771 typefaceClick(WMWidget *w, void *data)
 772 {
 773     WMList *lPtr = (WMList*)w;
 774     FontPanel *panel = (FontPanel*)data;
 775 }
 776
 777
 778 static void
 779 sizeClick(WMWidget *w, void *data)
 780 {
 781     WMList *lPtr = (WMList*)w;
 782     FontPanel *panel = (FontPanel*)data;
 783 }
 784
 785
 786 #endif