WINGs/wfontpanel.c

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