WPrefs.app/FontSimple.c

   1 /* FontSimple.c- simplified font configuration panel
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1998-2004 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include "WPrefs.h"
  25 #include <unistd.h>
  26 #include <fontconfig/fontconfig.h>
  27
  28
  29 /* workaround for older fontconfig, that doesn't define these constants */
  30 #ifndef FC_WEIGHT_NORMAL
  31 /* Weights */
  32 # define FC_WEIGHT_THIN              10
  33 # define FC_WEIGHT_EXTRALIGHT        40
  34 # define FC_WEIGHT_ULTRALIGHT        FC_WEIGHT_EXTRALIGHT
  35 # define FC_WEIGHT_REGULAR           80
  36 # define FC_WEIGHT_NORMAL            FC_WEIGHT_REGULAR
  37 # define FC_WEIGHT_SEMIBOLD          FC_WEIGHT_DEMIBOLD
  38 # define FC_WEIGHT_EXTRABOLD         205
  39 # define FC_WEIGHT_ULTRABOLD         FC_WEIGHT_EXTRABOLD
  40 # define FC_WEIGHT_HEAVY             FC_WEIGHT_BLACK
  41 /* Widths */
  42 # define FC_WIDTH                    "width"
  43 # define FC_WIDTH_ULTRACONDENSED     50
  44 # define FC_WIDTH_EXTRACONDENSED     63
  45 # define FC_WIDTH_CONDENSED          75
  46 # define FC_WIDTH_SEMICONDENSED      87
  47 # define FC_WIDTH_NORMAL             100
  48 # define FC_WIDTH_SEMIEXPANDED       113
  49 # define FC_WIDTH_EXPANDED           125
  50 # define FC_WIDTH_EXTRAEXPANDED      150
  51 # define FC_WIDTH_ULTRAEXPANDED      200
  52 #endif
  53
  54
  55 #define SAMPLE_TEXT "The Lazy Fox Jumped Ipsum Foobar 1234 - 56789"
  56
  57
  58 typedef struct {
  59     int weight;
  60     int width;
  61     int slant;
  62 } FontStyle;
  63
  64 typedef struct {
  65     char *name;
  66     int stylen;
  67     FontStyle *styles;
  68 } FontFamily;
  69
  70
  71 typedef struct {
  72     int familyn;
  73     FontFamily *families;
  74 } FontList;
  75
  76
  77 typedef struct _Panel {
  78     WMBox *box;
  79     char *sectionName;
  80
  81     char *description;
  82
  83     CallbackRec callbacks;
  84
  85     WMWidget *parent;
  86
  87     WMPopUpButton *optionP;
  88
  89     WMList *familyL;
  90     WMList *styleL;
  91
  92     WMList *sizeL;
  93
  94     WMTextField *sampleT;
  95
  96     FontList   *fonts;
  97 } _Panel;
  98
  99
 100 #define ICON_FILE       "fonts"
 101
 102
 103 static struct {
 104     char *option;
 105     char *label;
 106 } fontOptions[]= {
 107     {"WindowTitleFont", N_("Window Title")},
 108     {"MenuTitleFont", N_("Menu Title")},
 109     {"MenuTextFont", N_("Menu Text")},
 110     {"IconTitleFont", N_("Icon Title")},
 111     {"ClipTitleFont", N_("Clip Title")},
 112     {"LargeDisplayFont", N_("Desktop Caption")},
 113     {NULL, NULL},
 114 };
 115
 116
 117 static char *standardSizes[]= {
 118     "6",
 119     "8",
 120     "9",
 121     "10",
 122     "11",
 123     "12",
 124     "13",
 125     "14",
 126     "15",
 127     "16",
 128     "18",
 129     "20",
 130     "22",
 131     "24",
 132     "28",
 133     "32",
 134     "36",
 135     "48",
 136     "64",
 137     "72",
 138     NULL
 139 };
 140
 141
 142 static struct {
 143     int weight;
 144     char *name;
 145 } fontWeights[]= {
 146     {FC_WEIGHT_THIN, "Thin"},
 147     {FC_WEIGHT_EXTRALIGHT, "ExtraLight"},
 148     {FC_WEIGHT_LIGHT, "Light"},
 149     {FC_WEIGHT_NORMAL, "Normal"},
 150     {FC_WEIGHT_MEDIUM, ""}, /*"medium"},*/
 151     {FC_WEIGHT_DEMIBOLD, "DemiBold"},
 152     {FC_WEIGHT_BOLD, "Bold"},
 153     {FC_WEIGHT_EXTRABOLD, "ExtraBold"},
 154     {FC_WEIGHT_BLACK, "Black"},
 155     {0, NULL}
 156 };
 157
 158 static struct {
 159     int slant;
 160     char *name;
 161 } fontSlants[]= {
 162     {FC_SLANT_ROMAN, ""}, /*"Roman"},*/
 163     {FC_SLANT_ITALIC, "Italic"},
 164     {FC_SLANT_OBLIQUE, "Oblique"},
 165     {0, NULL}
 166 };
 167
 168 static struct {
 169     int width;
 170     char *name;
 171 } fontWidths[]= {
 172     {FC_WIDTH_ULTRACONDENSED, "UltraCondensed"},
 173     {FC_WIDTH_EXTRACONDENSED, "ExtraCondensed"},
 174     {FC_WIDTH_CONDENSED, "Condensed"},
 175     {FC_WIDTH_SEMICONDENSED, "SemiCondensed"},
 176     {FC_WIDTH_NORMAL, ""}, /*"normal"},*/
 177     {FC_WIDTH_SEMIEXPANDED, "SemiExpanded"},
 178     {FC_WIDTH_EXPANDED, "Expanded"},
 179     {FC_WIDTH_EXTRAEXPANDED, "ExtraExpanded"},
 180     {FC_WIDTH_ULTRAEXPANDED, "UltraExpanded"},
 181     {0, NULL}
 182 };
 183
 184
 185
 186
 187
 188 static int compare_family(const void *a, const void *b)
 189 {
 190     FontFamily *fa= (FontFamily*)a;
 191     FontFamily *fb= (FontFamily*)b;
 192     return strcmp(fa->name, fb->name);
 193 }
 194
 195
 196 static int compare_styles(const void *a, const void *b)
 197 {
 198     FontStyle *sa= (FontStyle*)a;
 199     FontStyle *sb= (FontStyle*)b;
 200     int compare;
 201
 202     compare = sa->weight - sb->weight;
 203     if (compare != 0)
 204         return compare;
 205     compare = sa->slant - sb->slant;
 206     if (compare != 0)
 207         return compare;
 208     return (sa->width - sb->width);
 209 }
 210
 211
 212 static void
 213 lookup_available_fonts(_Panel *panel)
 214 {
 215     FcPattern *pat = FcPatternCreate();
 216     FcObjectSet *os;
 217     FcFontSet *fonts;
 218     FontFamily *family;
 219
 220     os = FcObjectSetBuild(FC_FAMILY, FC_WEIGHT, FC_WIDTH, FC_SLANT, NULL);
 221
 222     fonts = FcFontList(0, pat, os);
 223
 224     if (fonts)
 225     {
 226         int i;
 227
 228         panel->fonts= wmalloc(sizeof(FontList));
 229         panel->fonts->familyn= 0;
 230         panel->fonts->families= wmalloc(sizeof(FontFamily)*fonts->nfont);
 231
 232         for (i= 0; i < fonts->nfont; i++)
 233         {
 234             char *name;
 235             int weight, slant, width;
 236             int j, found;
 237
 238             if (FcPatternGetString(fonts->fonts[i], FC_FAMILY, 0, (FcChar8**)&name) != FcResultMatch)
 239               continue;
 240
 241             if (FcPatternGetInteger(fonts->fonts[i], FC_WEIGHT, 0, &weight) != FcResultMatch)
 242               weight= FC_WEIGHT_MEDIUM;
 243
 244             if (FcPatternGetInteger(fonts->fonts[i], FC_WIDTH, 0, &width) != FcResultMatch)
 245               width= FC_WIDTH_NORMAL;
 246
 247             if (FcPatternGetInteger(fonts->fonts[i], FC_SLANT, 0, &slant) != FcResultMatch)
 248               slant= FC_SLANT_ROMAN;
 249
 250             found = -1;
 251             for (j = 0; j < panel->fonts->familyn && found<0; j++)
 252               if (strcasecmp(panel->fonts->families[j].name, name)==0)
 253                 found= j;
 254
 255             if (found < 0)
 256             {
 257                 panel->fonts->families[panel->fonts->familyn++].name= wstrdup(name);
 258                 family= panel->fonts->families + panel->fonts->familyn-1;
 259                 family->stylen= 0;
 260                 family->styles= NULL;
 261             }
 262             else
 263                 family= panel->fonts->families+found;
 264
 265             family->stylen++;
 266             family->styles= wrealloc(family->styles, sizeof(FontStyle)*family->stylen);
 267             family->styles[family->stylen-1].weight= weight;
 268             family->styles[family->stylen-1].slant= slant;
 269             family->styles[family->stylen-1].width= width;
 270         }
 271         qsort(panel->fonts->families, panel->fonts->familyn, sizeof(FontFamily),
 272               compare_family);
 273
 274         for (i=0; i < panel->fonts->familyn; i++)
 275         {
 276             qsort(panel->fonts->families[i].styles, panel->fonts->families[i].stylen,
 277                   sizeof(FontStyle), compare_styles);
 278         }
 279
 280         FcFontSetDestroy(fonts);
 281     }
 282     if (os)
 283       FcObjectSetDestroy(os);
 284     if (pat)
 285       FcPatternDestroy(pat);
 286
 287     panel->fonts->families[panel->fonts->familyn++].name= wstrdup("sans serif");
 288     family= panel->fonts->families + panel->fonts->familyn-1;
 289     family->styles= wmalloc(sizeof(FontStyle)*2);
 290     family->stylen= 2;
 291     family->styles[0].weight= FC_WEIGHT_MEDIUM;
 292     family->styles[0].slant= FC_SLANT_ROMAN;
 293     family->styles[0].width= FC_WIDTH_NORMAL;
 294     family->styles[1].weight= FC_WEIGHT_BOLD;
 295     family->styles[1].slant= FC_SLANT_ROMAN;
 296     family->styles[1].width= FC_WIDTH_NORMAL;
 297
 298     panel->fonts->families[panel->fonts->familyn++].name= wstrdup("serif");
 299     family= panel->fonts->families + panel->fonts->familyn-1;
 300     family->styles= wmalloc(sizeof(FontStyle)*2);
 301     family->stylen= 2;
 302     family->styles[0].weight= FC_WEIGHT_MEDIUM;
 303     family->styles[0].slant= FC_SLANT_ROMAN;
 304     family->styles[0].width= FC_WIDTH_NORMAL;
 305     family->styles[1].weight= FC_WEIGHT_BOLD;
 306     family->styles[1].slant= FC_SLANT_ROMAN;
 307     family->styles[1].width= FC_WIDTH_NORMAL;
 308 }
 309
 310
 311 static char*
 312 getSelectedFont(_Panel *panel, FcChar8 *curfont)
 313 {
 314     WMListItem *item;
 315     FcPattern *pat= FcNameParse(curfont);
 316     char *name;
 317
 318     item= WMGetListSelectedItem(panel->familyL);
 319     if (item)
 320     {
 321         FcPatternDel(pat, FC_FAMILY);
 322         FcPatternAddString(pat, FC_FAMILY, (FcChar8*)item->text);
 323     }
 324
 325     item= WMGetListSelectedItem(panel->styleL);
 326     if (item)
 327     {
 328         FontStyle *style= (FontStyle*)item->clientData;
 329
 330         FcPatternDel(pat, FC_WEIGHT);
 331         FcPatternAddInteger(pat, FC_WEIGHT, style->weight);
 332
 333         FcPatternDel(pat, FC_WIDTH);
 334         FcPatternAddInteger(pat, FC_WIDTH, style->width);
 335
 336         FcPatternDel(pat, FC_SLANT);
 337         FcPatternAddInteger(pat, FC_SLANT, style->slant);
 338     }
 339
 340     item= WMGetListSelectedItem(panel->sizeL);
 341     if (item)
 342     {
 343         FcPatternDel(pat, FC_PIXEL_SIZE);
 344         FcPatternAddDouble(pat, FC_PIXEL_SIZE, atoi(item->text));
 345     }
 346
 347     name = (char*)FcNameUnparse(pat);
 348     FcPatternDestroy(pat);
 349
 350     return name;
 351 }
 352
 353
 354
 355 static void
 356 updateSampleFont(_Panel *panel)
 357 {
 358     WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP,
 359                                            WMGetPopUpButtonSelectedItem(panel->optionP));
 360     char *fn= WMGetMenuItemRepresentedObject(item);
 361     WMFont *font= WMCreateFont(WMWidgetScreen(panel->box), fn);
 362
 363     if (font)
 364     {
 365         WMSetTextFieldFont(panel->sampleT, font);
 366         WMReleaseFont(font);
 367     }
 368 }
 369
 370
 371
 372
 373 static void
 374 selectedFamily(WMWidget *w, void *data)
 375 {
 376     _Panel *panel= (_Panel*)data;
 377     WMListItem *item;
 378     FontStyle *oldStyle= NULL;
 379     char buffer[1024];
 380
 381     item= WMGetListSelectedItem(panel->styleL);
 382     if (item)
 383       oldStyle= (FontStyle*)item->clientData;
 384
 385     item= WMGetListSelectedItem(panel->familyL);
 386
 387     if (item)
 388     {
 389         FontFamily *family= (FontFamily*)item->clientData;
 390         int i, oldi= 0, oldscore= 0;
 391
 392         WMClearList(panel->styleL);
 393         for (i = 0; i < family->stylen; i++)
 394         {
 395             int j;
 396             char *weight= "", *slant= "", *width= "";
 397             WMListItem *item;
 398
 399             for (j= 0; fontWeights[j].name; j++)
 400               if (fontWeights[j].weight == family->styles[i].weight)
 401               {
 402                   weight= fontWeights[j].name;
 403                   break;
 404               }
 405             for (j= 0; fontWidths[j].name; j++)
 406               if (fontWidths[j].width == family->styles[i].width)
 407               {
 408                   width= fontWidths[j].name;
 409                   break;
 410               }
 411             for (j= 0; fontSlants[j].name; j++)
 412               if (fontSlants[j].slant == family->styles[i].slant)
 413               {
 414                   slant= fontSlants[j].name;
 415                   break;
 416               }
 417             sprintf(buffer, "%s%s%s%s%s",
 418                     weight, *weight?" ":"",
 419                     slant, (*slant || *weight)?" ":"",
 420                     width);
 421             if (!buffer[0])
 422               strcpy(buffer, "Roman");
 423
 424             item= WMAddListItem(panel->styleL, buffer);
 425             item->clientData= family->styles+i;
 426
 427             if (oldStyle) {
 428                 int score= 0;
 429
 430                 if (oldStyle->width == family->styles[i].width)
 431                   score |= 1;
 432                 if (oldStyle->weight == family->styles[i].weight)
 433                   score |= 2;
 434                 if (oldStyle->slant == family->styles[i].slant)
 435                   score |= 4;
 436
 437                 if (score > oldscore)
 438                 {
 439                     oldi= i;
 440                     oldscore= score;
 441                 }
 442             }
 443         }
 444         WMSelectListItem(panel->styleL, oldi);
 445
 446         {
 447             int index= WMGetPopUpButtonSelectedItem(panel->optionP);
 448             WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP, index);
 449             FcChar8 *ofont;
 450             char *nfont;
 451
 452             ofont= (FcChar8*)WMGetMenuItemRepresentedObject(item);
 453             nfont= getSelectedFont(panel, ofont);
 454             wfree(ofont);
 455
 456             WMSetMenuItemRepresentedObject(item, nfont);
 457         }
 458         updateSampleFont(panel);
 459     }
 460 }
 461
 462
 463 static void
 464 selected(WMWidget *w, void *data)
 465 {
 466     _Panel *panel= (_Panel*)data;
 467     int index= WMGetPopUpButtonSelectedItem(panel->optionP);
 468     WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP, index);
 469     FcChar8 *ofont;
 470     char *nfont;
 471
 472     ofont = (FcChar8*)WMGetMenuItemRepresentedObject(item);
 473     nfont= getSelectedFont(panel, ofont);
 474     wfree(ofont);
 475
 476     WMSetMenuItemRepresentedObject(item, nfont);
 477
 478     updateSampleFont(panel);
 479 }
 480
 481
 482 static void
 483 selectedOption(WMWidget *w, void *data)
 484 {
 485     _Panel *panel= (_Panel*)data;
 486     int index = WMGetPopUpButtonSelectedItem(panel->optionP);
 487     WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP, index);
 488     char *font;
 489
 490     font= (char*)WMGetMenuItemRepresentedObject(item);
 491     if (font)
 492     {
 493         FcPattern *pat;
 494
 495         pat= FcNameParse((FcChar8*)font);
 496         if (pat)
 497         {
 498             char *name;
 499             int weight, slant, width;
 500             double size;
 501             int distance, closest, found;
 502             int i;
 503
 504             FcDefaultSubstitute(pat);
 505
 506             if (FcPatternGetString(pat, FC_FAMILY, 0, (FcChar8**)&name) != FcResultMatch)
 507                 name= "sans serif";
 508
 509             found= 0;
 510             /* select family */
 511             for (i= 0; i < WMGetListNumberOfRows(panel->familyL); i++)
 512             {
 513                 WMListItem *item= WMGetListItem(panel->familyL, i);
 514                 FontFamily *family= (FontFamily*)item->clientData;
 515
 516                 if (strcasecmp(family->name, name)==0)
 517                 {
 518                     found= 1;
 519                     WMSelectListItem(panel->familyL, i);
 520                     WMSetListPosition(panel->familyL, i);
 521                     break;
 522                 }
 523             }
 524             if (!found)
 525                 WMSelectListItem(panel->familyL, -1);
 526             selectedFamily(panel->familyL, panel);
 527
 528             /* select style */
 529             if (FcPatternGetInteger(pat, FC_WEIGHT, 0, &weight) != FcResultMatch)
 530                 weight= FC_WEIGHT_NORMAL;
 531             if (FcPatternGetInteger(pat, FC_WIDTH, 0, &width) != FcResultMatch)
 532                 width= FC_WIDTH_NORMAL;
 533             if (FcPatternGetInteger(pat, FC_SLANT, 0, &slant) != FcResultMatch)
 534                 slant= FC_SLANT_ROMAN;
 535
 536             if (FcPatternGetDouble(pat, FC_PIXEL_SIZE, 0, &size) != FcResultMatch)
 537                 size= 10.0;
 538
 539             for (i=0, found=0, closest=0; i < WMGetListNumberOfRows(panel->styleL); i++)
 540             {
 541                 WMListItem *item= WMGetListItem(panel->styleL, i);
 542                 FontStyle *style= (FontStyle*)item->clientData;
 543
 544                 distance = ((abs(style->weight - weight) << 16) +
 545                             (abs(style->slant - slant)   <<  8) +
 546                             (abs(style->width - width)));
 547
 548                 if (i==0 || distance < closest) {
 549                     closest = distance;
 550                     found = i;
 551                     if (distance == 0) {
 552                         break; /* perfect match */
 553                     }
 554                 }
 555             }
 556             WMSelectListItem(panel->styleL, found);
 557             WMSetListPosition(panel->styleL, found);
 558
 559             for (i=0, found=0, closest=0; i < WMGetListNumberOfRows(panel->sizeL); i++)
 560             {
 561                 WMListItem *item= WMGetListItem(panel->sizeL, i);
 562                 int distance;
 563
 564                 distance = abs(size - atoi(item->text));
 565
 566                 if (i==0 || distance < closest) {
 567                     closest= distance;
 568                     found= i;
 569                     if (distance == 0) {
 570                         break; /* perfect match */
 571                     }
 572                 }
 573             }
 574             WMSelectListItem(panel->sizeL, found);
 575             WMSetListPosition(panel->sizeL, found);
 576
 577             selected(NULL, panel);
 578         }
 579         else
 580             wwarning("Can't parse font '%s'", font);
 581     }
 582
 583     updateSampleFont(panel);
 584 }
 585
 586
 587 static WMLabel *
 588 createListLabel(WMScreen *scr, WMWidget *parent, char *text)
 589 {
 590     WMLabel *label;
 591     WMColor *color;
 592     WMFont *boldFont= WMBoldSystemFontOfSize(scr, 12);
 593
 594     label = WMCreateLabel(parent);
 595     WMSetLabelFont(label, boldFont);
 596     WMSetLabelText(label, text);
 597     WMSetLabelRelief(label, WRSunken);
 598     WMSetLabelTextAlignment(label, WACenter);
 599     color = WMDarkGrayColor(scr);
 600     WMSetWidgetBackgroundColor(label, color);
 601     WMReleaseColor(color);
 602     color = WMWhiteColor(scr);
 603     WMSetLabelTextColor(label, color);
 604     WMReleaseColor(color);
 605
 606     WMReleaseFont(boldFont);
 607
 608     return label;
 609 }
 610
 611
 612 static void
 613 showData(_Panel *panel)
 614 {
 615     int i;
 616     WMMenuItem *item;
 617
 618     for (i= 0; i < WMGetPopUpButtonNumberOfItems(panel->optionP); i++)
 619     {
 620         char *ofont, *font;
 621
 622         item= WMGetPopUpButtonMenuItem(panel->optionP, i);
 623
 624         ofont= WMGetMenuItemRepresentedObject(item);
 625         if (ofont)
 626           wfree(ofont);
 627
 628         font= GetStringForKey(fontOptions[i].option);
 629         if (font)
 630           font= wstrdup(font);
 631         WMSetMenuItemRepresentedObject(item, font);
 632     }
 633
 634     WMSetPopUpButtonSelectedItem(panel->optionP, 0);
 635     selectedOption(panel->optionP, panel);
 636 }
 637
 638
 639 static void
 640 storeData(_Panel *panel)
 641 {
 642     int i;
 643     WMMenuItem *item;
 644     for (i= 0; i < WMGetPopUpButtonNumberOfItems(panel->optionP); i++)
 645     {
 646         char *font;
 647
 648         item= WMGetPopUpButtonMenuItem(panel->optionP, i);
 649
 650         font= WMGetMenuItemRepresentedObject(item);
 651         if (font && *font)
 652         {
 653             SetStringForKey(font, fontOptions[i].option);
 654         }
 655     }
 656 }
 657
 658
 659 static void
 660 createPanel(Panel *p)
 661 {
 662     _Panel *panel = (_Panel*)p;
 663     WMScreen *scr = WMWidgetScreen(panel->parent);
 664     WMLabel *label;
 665     WMBox *hbox, *vbox;
 666     int i;
 667
 668     lookup_available_fonts(panel);
 669
 670     panel->box = WMCreateBox(panel->parent);
 671     WMSetViewExpandsToParent(WMWidgetView(panel->box), 5, 2, 5, 5);
 672     WMSetBoxHorizontal(panel->box, False);
 673     WMSetBoxBorderWidth(panel->box, 8);
 674     WMMapWidget(panel->box);
 675
 676     hbox = WMCreateBox(panel->box);
 677     WMSetBoxHorizontal(hbox, True);
 678     WMAddBoxSubview(panel->box, WMWidgetView(hbox), False, True, 40, 22, 8);
 679
 680     vbox= WMCreateBox(hbox);
 681     WMAddBoxSubview(hbox, WMWidgetView(vbox), False, True, 130, 0, 10);
 682     WMSetBoxHorizontal(vbox, False);
 683     panel->optionP = WMCreatePopUpButton(vbox);
 684     WMAddBoxSubviewAtEnd(vbox, WMWidgetView(panel->optionP), False, True, 20, 0, 8);
 685     for (i= 0; fontOptions[i].option; i++)
 686     {
 687       WMAddPopUpButtonItem(panel->optionP, _(fontOptions[i].label));
 688     }
 689     WMSetPopUpButtonAction(panel->optionP, selectedOption, panel);
 690
 691     label = WMCreateLabel(hbox);
 692     WMSetLabelText(label, _("Sample Text"));
 693     WMSetLabelTextAlignment(label, WARight);
 694     WMAddBoxSubview(hbox, WMWidgetView(label), False, True, 80, 0, 2);
 695
 696     panel->sampleT= WMCreateTextField(hbox);
 697     WMSetViewExpandsToParent(WMWidgetView(panel->sampleT), 10, 18, 10, 10);
 698     WMSetTextFieldText(panel->sampleT, SAMPLE_TEXT);
 699     WMAddBoxSubview(hbox, WMWidgetView(panel->sampleT), True, True, 60, 0, 0);
 700
 701
 702     hbox = WMCreateBox(panel->box);
 703     WMSetBoxHorizontal(hbox, True);
 704     WMAddBoxSubview(panel->box, WMWidgetView(hbox), True, True, 100, 0, 2);
 705
 706     vbox = WMCreateBox(hbox);
 707     WMSetBoxHorizontal(vbox, False);
 708     WMAddBoxSubview(hbox, WMWidgetView(vbox), False, True, 240, 20, 4);
 709
 710     label = createListLabel(scr, vbox, _("Family"));
 711     WMAddBoxSubview(vbox, WMWidgetView(label), False, True, 20, 0, 2);
 712
 713     /* family */
 714     panel->familyL = WMCreateList(vbox);
 715     WMAddBoxSubview(vbox, WMWidgetView(panel->familyL), True, True, 0, 0, 0);
 716     if (panel->fonts)
 717     {
 718         WMListItem *item;
 719         for (i= 0; i < panel->fonts->familyn; i++)
 720         {
 721             item = WMAddListItem(panel->familyL, panel->fonts->families[i].name);
 722             item->clientData= panel->fonts->families+i;
 723         }
 724     }
 725     else
 726       WMAddListItem(panel->familyL, "sans serif");
 727
 728     WMSetListAction(panel->familyL, selectedFamily, panel);
 729
 730     vbox = WMCreateBox(hbox);
 731     WMSetBoxHorizontal(vbox, False);
 732     WMAddBoxSubview(hbox, WMWidgetView(vbox), True, True, 10, 0, 0);
 733
 734     {
 735         WMBox *box = WMCreateBox(vbox);
 736         WMSetBoxHorizontal(box, True);
 737         WMAddBoxSubview(vbox, WMWidgetView(box), False, True, 20, 0, 2);
 738
 739         label = createListLabel(scr, box, _("Style"));
 740         WMAddBoxSubview(box, WMWidgetView(label), True, True, 20, 0, 4);
 741
 742         label = createListLabel(scr, box, _("Size"));
 743         WMAddBoxSubview(box, WMWidgetView(label), False, True, 60, 0, 0);
 744
 745         box = WMCreateBox(vbox);
 746         WMSetBoxHorizontal(box, True);
 747         WMAddBoxSubview(vbox, WMWidgetView(box), True, True, 20, 0, 0);
 748
 749         panel->styleL = WMCreateList(box);
 750         WMAddBoxSubview(box, WMWidgetView(panel->styleL), True, True, 0, 0, 4);
 751         WMSetListAction(panel->styleL, selected, panel);
 752
 753         panel->sizeL = WMCreateList(box);
 754         WMAddBoxSubview(box, WMWidgetView(panel->sizeL), False, True, 60, 0, 0);
 755         for (i= 0; standardSizes[i]; i++)
 756         {
 757             WMAddListItem(panel->sizeL, standardSizes[i]);
 758         }
 759         WMSetListAction(panel->sizeL, selected, panel);
 760     }
 761
 762
 763     WMMapSubwidgets(panel->box);
 764     WMMapWidget(panel->box);
 765     WMRealizeWidget(panel->box);
 766
 767     showData(panel);
 768 }
 769
 770
 771
 772 Panel*
 773 InitFontSimple(WMScreen *scr, WMWidget *parent)
 774 {
 775     _Panel *panel;
 776
 777     panel = wmalloc(sizeof(_Panel));
 778     memset(panel, 0, sizeof(_Panel));
 779
 780     panel->sectionName = _("Font Configuration");
 781
 782     panel->description = _("Configure fonts for Window Maker titlebars, menus etc.");
 783
 784     panel->parent = parent;
 785
 786     panel->callbacks.createWidgets = createPanel;
 787     panel->callbacks.updateDomain = storeData;
 788
 789     AddSection(panel, ICON_FILE);
 790
 791     return panel;
 792 }
 793