WINGs/wfontpanel.c

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