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