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