WINGs/wfontpanel.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6 #include "WUtil.h"
   7
   8 #include <ctype.h>
   9 #include <strings.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     int i;
 538
 539     if (family->typefaces) {
 540         for (i = 0; i < WMGetBagItemCount(family->typefaces); i++) {
 541             int size;
 542
 543             face = WMGetFromBag(family->typefaces, i);
 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     int 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 (i = 0; i < WMGetBagItemCount(family); i++) {
 597             int enc, reg, found;
 598
 599             fam = WMGetFromBag(family, i);
 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 (i = 0; i < WMGetBagItemCount(family); i++) {
 612             int enc, reg;
 613
 614             fam = WMGetFromBag(family, i);
 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 (i = 0; i < WMGetBagItemCount(family); i++) {
 640             int found;
 641
 642             fam = WMGetFromBag(family, i);
 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         int i;
 744         Family *fam;
 745         char buffer[256];
 746         WMListItem *item;
 747
 748         for (i = 0; i < WMGetBagItemCount(bag); i++) {
 749             fam = WMGetFromBag(bag, i);
 750
 751             strcpy(buffer, fam->name);
 752
 753             if (fam->showFoundry) {
 754                 strcat(buffer, " ");
 755                 strcat(buffer, fam->foundry);
 756                 strcat(buffer, " ");
 757             }
 758             if (fam->showRegistry) {
 759                 strcat(buffer, " (");
 760                 strcat(buffer, fam->registry);
 761                 strcat(buffer, "-");
 762                 strcat(buffer, fam->encoding);
 763                 strcat(buffer, ")");
 764             }
 765             item = WMAddListItem(panel->famLs, buffer);
 766
 767             item->clientData = fam;
 768         }
 769         WMFreeBag(bag);
 770     }
 771     WMSortListItems(panel->famLs);
 772
 773     WMFreeHashTable(families);
 774 }
 775
 776
 777 static void
 778 getSelectedFont(FontPanel *panel, char buffer[])
 779 {
 780     WMListItem *item;
 781     Family *family;
 782     Typeface *face;
 783     char *size;
 784
 785
 786     item = WMGetListSelectedItem(panel->famLs);
 787     if (!item)
 788         return;
 789     family = (Family*)item->clientData;
 790
 791     item = WMGetListSelectedItem(panel->typLs);
 792     if (!item)
 793         return;
 794     face = (Typeface*)item->clientData;
 795
 796     size = WMGetTextFieldText(panel->sizT);
 797
 798     sprintf(buffer, "-%s-%s-%s-%s-%s-%s-%s-*-*-*-*-*-%s-%s",
 799             family->foundry,
 800             family->name,
 801             face->weight,
 802             face->slant,
 803             face->setWidth,
 804             face->addStyle,
 805             size,
 806             family->registry,
 807             family->encoding);
 808 }
 809
 810
 811
 812 static void
 813 preview(FontPanel *panel)
 814 {
 815     char buffer[256];
 816     WMFont *font;
 817
 818     getSelectedFont(panel, buffer);
 819
 820     font = WMCreateFont(WMWidgetScreen(panel->win), buffer);
 821     if (font) {
 822         WMSetTextFieldFont(panel->sampleT, font);
 823         WMReleaseFont(font);
 824     }
 825 }
 826
 827
 828
 829 static void
 830 familyClick(WMWidget *w, void *data)
 831 {
 832     WMList *lPtr = (WMList*)w;
 833     WMListItem *item;
 834     Family *family;
 835     FontPanel *panel = (FontPanel*)data;
 836     Typeface *face;
 837     int i;
 838     /* current typeface and size */
 839     char *oface = NULL;
 840     char *osize = NULL;
 841     int facei = -1;
 842     int sizei = -1;
 843
 844     /* must try to keep the same typeface and size for the new family */
 845     item = WMGetListSelectedItem(panel->typLs);
 846     if (item)
 847         oface = wstrdup(item->text);
 848
 849     osize = WMGetTextFieldText(panel->sizT);
 850
 851
 852     item = WMGetListSelectedItem(lPtr);
 853     family = (Family*)item->clientData;
 854
 855     WMClearList(panel->typLs);
 856
 857     for (i = 0; i < WMGetBagItemCount(family->typefaces); i++) {
 858         char buffer[256];
 859         int top=0;
 860         WMListItem *fitem;
 861
 862         face = WMGetFromBag(family->typefaces, i);
 863
 864         if (strcmp(face->weight, "medium") == 0) {
 865             buffer[0] = 0;
 866         } else {
 867             if (*face->weight) {
 868                 strcpy(buffer, face->weight);
 869                 buffer[0] = toupper(buffer[0]);
 870                 strcat(buffer, " ");
 871             } else {
 872                 buffer[0] = 0;
 873             }
 874         }
 875
 876         if (strcmp(face->slant, "r") == 0) {
 877             strcat(buffer, "Roman");
 878             top = 1;
 879         } else if (strcmp(face->slant, "i") == 0) {
 880             strcat(buffer, "Italic");
 881         } else if (strcmp(face->slant, "o") == 0) {
 882             strcat(buffer, "Oblique");
 883         } else if (strcmp(face->slant, "ri") == 0) {
 884             strcat(buffer, "Rev Italic");
 885         } else if (strcmp(face->slant, "ro") == 0) {
 886             strcat(buffer, "Rev Oblique");
 887         } else {
 888             strcat(buffer, face->slant);
 889         }
 890
 891         if (buffer[0] == 0) {
 892             strcpy(buffer, "Normal");
 893         }
 894
 895         if (top)
 896             fitem = WMInsertListItem(panel->typLs, 0, buffer);
 897         else
 898             fitem = WMAddListItem(panel->typLs, buffer);
 899         fitem->clientData = face;
 900     }
 901
 902     if (oface) {
 903         facei = WMFindRowOfListItemWithTitle(panel->typLs, oface);
 904         wfree(oface);
 905     }
 906     if (facei < 0) {
 907         facei = 0;
 908     }
 909     WMSelectListItem(panel->typLs, facei);
 910     typefaceClick(panel->typLs, panel);
 911
 912     if (osize) {
 913         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
 914     }
 915     if (sizei >= 0) {
 916         WMSelectListItem(panel->sizLs, sizei);
 917         sizeClick(panel->sizLs, panel);
 918     }
 919
 920     if (osize)
 921         wfree(osize);
 922
 923
 924     preview(panel);
 925 }
 926
 927
 928 static void
 929 typefaceClick(WMWidget *w, void *data)
 930 {
 931     FontPanel *panel = (FontPanel*)data;
 932     WMListItem *item;
 933     Typeface *face;
 934     int i;
 935     char buffer[32];
 936
 937     char *osize = NULL;
 938     int sizei = -1;
 939
 940     osize = WMGetTextFieldText(panel->sizT);
 941
 942
 943     item = WMGetListSelectedItem(panel->typLs);
 944     face = (Typeface*)item->clientData;
 945
 946     WMClearList(panel->sizLs);
 947
 948     for (i = 0; i < WMGetBagItemCount(face->sizes); i++) {
 949         int size;
 950
 951         size = (int)WMGetFromBag(face->sizes, i);
 952
 953         if (size != 0) {
 954             sprintf(buffer, "%i", size);
 955
 956             WMAddListItem(panel->sizLs, buffer);
 957         }
 958     }
 959
 960     if (osize) {
 961         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, osize);
 962     }
 963     if (sizei < 0) {
 964         sizei = WMFindRowOfListItemWithTitle(panel->sizLs, "12");
 965     }
 966     if (sizei < 0) {
 967         sizei = 0;
 968     }
 969     WMSelectListItem(panel->sizLs, sizei);
 970     WMSetListPosition(panel->sizLs, sizei);
 971     sizeClick(panel->sizLs, panel);
 972
 973     if (osize)
 974         wfree(osize);
 975
 976     preview(panel);
 977 }
 978
 979
 980 static void
 981 sizeClick(WMWidget *w, void *data)
 982 {
 983     FontPanel *panel = (FontPanel*)data;
 984     WMListItem *item;
 985
 986     item = WMGetListSelectedItem(panel->sizLs);
 987
 988     WMSetTextFieldText(panel->sizT, item->text);
 989
 990     WMSelectTextFieldRange(panel->sizT, wmkrange(0, strlen(item->text)));
 991
 992     preview(panel);
 993 }
 994