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             FcChar8 *name;
 235             int weight, slant, width;
 236             int j, found;
 237
 238             if (FcPatternGetString(fonts->fonts[i], FC_FAMILY, 0, &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, char *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, 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= 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             char *ofont, *nfont;
 450
 451             ofont= (char*)WMGetMenuItemRepresentedObject(item);
 452
 453             nfont= getSelectedFont(panel, ofont);
 454             free(ofont);
 455             WMSetMenuItemRepresentedObject(item, nfont);
 456         }
 457         updateSampleFont(panel);
 458     }
 459 }
 460
 461
 462 static void
 463 selected(WMWidget *w, void *data)
 464 {
 465     _Panel *panel= (_Panel*)data;
 466     int index= WMGetPopUpButtonSelectedItem(panel->optionP);
 467     WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP, index);
 468     char *ofont, *nfont;
 469
 470     ofont= (char*)WMGetMenuItemRepresentedObject(item);
 471
 472     nfont= getSelectedFont(panel, ofont);
 473     free(ofont);
 474     WMSetMenuItemRepresentedObject(item, nfont);
 475
 476     updateSampleFont(panel);
 477 }
 478
 479
 480 static void
 481 selectedOption(WMWidget *w, void *data)
 482 {
 483     _Panel *panel= (_Panel*)data;
 484     int index = WMGetPopUpButtonSelectedItem(panel->optionP);
 485     WMMenuItem *item= WMGetPopUpButtonMenuItem(panel->optionP, index);
 486     char *font;
 487
 488     font= (char*)WMGetMenuItemRepresentedObject(item);
 489     if (font)
 490     {
 491         FcPattern *pat;
 492
 493         pat= FcNameParse(font);
 494         if (pat)
 495         {
 496             FcChar8 *name;
 497             int weight, slant, width;
 498             double size;
 499             int distance, closest, found;
 500             int i;
 501
 502             FcDefaultSubstitute(pat);
 503
 504             if (FcPatternGetString(pat, FC_FAMILY, 0, &name) != FcResultMatch)
 505                 name= "sans serif";
 506
 507             found= 0;
 508             /* select family */
 509             for (i= 0; i < WMGetListNumberOfRows(panel->familyL); i++)
 510             {
 511                 WMListItem *item= WMGetListItem(panel->familyL, i);
 512                 FontFamily *family= (FontFamily*)item->clientData;
 513
 514                 if (strcasecmp(family->name, name)==0)
 515                 {
 516                     found= 1;
 517                     WMSelectListItem(panel->familyL, i);
 518                     WMSetListPosition(panel->familyL, i);
 519                     break;
 520                 }
 521             }
 522             if (!found)
 523                 WMSelectListItem(panel->familyL, -1);
 524             selectedFamily(panel->familyL, panel);
 525
 526             /* select style */
 527             if (FcPatternGetInteger(pat, FC_WEIGHT, 0, &weight) != FcResultMatch)
 528                 weight= FC_WEIGHT_NORMAL;
 529             if (FcPatternGetInteger(pat, FC_WIDTH, 0, &width) != FcResultMatch)
 530                 width= FC_WIDTH_NORMAL;
 531             if (FcPatternGetInteger(pat, FC_SLANT, 0, &slant) != FcResultMatch)
 532                 slant= FC_SLANT_ROMAN;
 533
 534             if (FcPatternGetDouble(pat, FC_PIXEL_SIZE, 0, &size) != FcResultMatch)
 535                 size= 10.0;
 536
 537             for (i=0, found=0, closest=0; i < WMGetListNumberOfRows(panel->styleL); i++)
 538             {
 539                 WMListItem *item= WMGetListItem(panel->styleL, i);
 540                 FontStyle *style= (FontStyle*)item->clientData;
 541
 542                 distance = ((abs(style->weight - weight) << 16) +
 543                             (abs(style->slant - slant)   <<  8) +
 544                             (abs(style->width - width)));
 545
 546                 if (i==0 || distance < closest) {
 547                     closest = distance;
 548                     found = i;
 549                     if (distance == 0) {
 550                         break; /* perfect match */
 551                     }
 552                 }
 553             }
 554             WMSelectListItem(panel->styleL, found);
 555             WMSetListPosition(panel->styleL, found);
 556
 557             for (i=0, found=0, closest=0; i < WMGetListNumberOfRows(panel->sizeL); i++)
 558             {
 559                 WMListItem *item= WMGetListItem(panel->sizeL, i);
 560                 int distance;
 561
 562                 distance = abs(size - atoi(item->text));
 563
 564                 if (i==0 || distance < closest) {
 565                     closest= distance;
 566                     found= i;
 567                     if (distance == 0) {
 568                         break; /* perfect match */
 569                     }
 570                 }
 571             }
 572             WMSelectListItem(panel->sizeL, found);
 573             WMSetListPosition(panel->sizeL, found);
 574
 575             selected(NULL, panel);
 576         }
 577         else
 578             wwarning("Can't parse font '%s'", font);
 579     }
 580
 581     updateSampleFont(panel);
 582 }
 583
 584
 585 static WMLabel *
 586 createListLabel(WMScreen *scr, WMWidget *parent, char *text)
 587 {
 588     WMLabel *label;
 589     WMColor *color;
 590     WMFont *boldFont= WMBoldSystemFontOfSize(scr, 12);
 591
 592     label = WMCreateLabel(parent);
 593     WMSetLabelFont(label, boldFont);
 594     WMSetLabelText(label, text);
 595     WMSetLabelRelief(label, WRSunken);
 596     WMSetLabelTextAlignment(label, WACenter);
 597     color = WMDarkGrayColor(scr);
 598     WMSetWidgetBackgroundColor(label, color);
 599     WMReleaseColor(color);
 600     color = WMWhiteColor(scr);
 601     WMSetLabelTextColor(label, color);
 602     WMReleaseColor(color);
 603
 604     WMReleaseFont(boldFont);
 605
 606     return label;
 607 }
 608
 609
 610 static void
 611 showData(_Panel *panel)
 612 {
 613     int i;
 614     WMMenuItem *item;
 615
 616     for (i= 0; i < WMGetPopUpButtonNumberOfItems(panel->optionP); i++)
 617     {
 618         char *ofont, *font;
 619
 620         item= WMGetPopUpButtonMenuItem(panel->optionP, i);
 621
 622         ofont= WMGetMenuItemRepresentedObject(item);
 623         if (ofont)
 624           wfree(ofont);
 625
 626         font= GetStringForKey(fontOptions[i].option);
 627         if (font)
 628           font= wstrdup(font);
 629         WMSetMenuItemRepresentedObject(item, font);
 630     }
 631
 632     WMSetPopUpButtonSelectedItem(panel->optionP, 0);
 633     selectedOption(panel->optionP, panel);
 634 }
 635
 636
 637 static void
 638 storeData(_Panel *panel)
 639 {
 640     int i;
 641     WMMenuItem *item;
 642     for (i= 0; i < WMGetPopUpButtonNumberOfItems(panel->optionP); i++)
 643     {
 644         char *font;
 645
 646         item= WMGetPopUpButtonMenuItem(panel->optionP, i);
 647
 648         font= WMGetMenuItemRepresentedObject(item);
 649         if (font && *font)
 650         {
 651             SetStringForKey(font, fontOptions[i].option);
 652         }
 653     }
 654 }
 655
 656
 657 static void
 658 createPanel(Panel *p)
 659 {
 660     _Panel *panel = (_Panel*)p;
 661     WMScreen *scr = WMWidgetScreen(panel->parent);
 662     WMLabel *label;
 663     WMBox *hbox, *vbox;
 664     int i;
 665
 666     lookup_available_fonts(panel);
 667
 668     panel->box = WMCreateBox(panel->parent);
 669     WMSetViewExpandsToParent(WMWidgetView(panel->box), 5, 2, 5, 5);
 670     WMSetBoxHorizontal(panel->box, False);
 671     WMSetBoxBorderWidth(panel->box, 8);
 672     WMMapWidget(panel->box);
 673
 674     hbox = WMCreateBox(panel->box);
 675     WMSetBoxHorizontal(hbox, True);
 676     WMAddBoxSubview(panel->box, WMWidgetView(hbox), False, True, 40, 22, 8);
 677
 678     vbox= WMCreateBox(hbox);
 679     WMAddBoxSubview(hbox, WMWidgetView(vbox), False, True, 130, 0, 10);
 680     WMSetBoxHorizontal(vbox, False);
 681     panel->optionP = WMCreatePopUpButton(vbox);
 682     WMAddBoxSubviewAtEnd(vbox, WMWidgetView(panel->optionP), False, True, 20, 0, 8);
 683     for (i= 0; fontOptions[i].option; i++)
 684     {
 685       WMAddPopUpButtonItem(panel->optionP, _(fontOptions[i].label));
 686     }
 687     WMSetPopUpButtonAction(panel->optionP, selectedOption, panel);
 688
 689     label = WMCreateLabel(hbox);
 690     WMSetLabelText(label, _("Sample Text"));
 691     WMSetLabelTextAlignment(label, WARight);
 692     WMAddBoxSubview(hbox, WMWidgetView(label), False, True, 80, 0, 2);
 693
 694     panel->sampleT= WMCreateTextField(hbox);
 695     WMSetViewExpandsToParent(WMWidgetView(panel->sampleT), 10, 18, 10, 10);
 696     WMSetTextFieldText(panel->sampleT, SAMPLE_TEXT);
 697     WMAddBoxSubview(hbox, WMWidgetView(panel->sampleT), True, True, 60, 0, 0);
 698
 699
 700     hbox = WMCreateBox(panel->box);
 701     WMSetBoxHorizontal(hbox, True);
 702     WMAddBoxSubview(panel->box, WMWidgetView(hbox), True, True, 100, 0, 2);
 703
 704     vbox = WMCreateBox(hbox);
 705     WMSetBoxHorizontal(vbox, False);
 706     WMAddBoxSubview(hbox, WMWidgetView(vbox), False, True, 240, 20, 4);
 707
 708     label = createListLabel(scr, vbox, _("Family"));
 709     WMAddBoxSubview(vbox, WMWidgetView(label), False, True, 20, 0, 2);
 710
 711     /* family */
 712     panel->familyL = WMCreateList(vbox);
 713     WMAddBoxSubview(vbox, WMWidgetView(panel->familyL), True, True, 0, 0, 0);
 714     if (panel->fonts)
 715     {
 716         WMListItem *item;
 717         for (i= 0; i < panel->fonts->familyn; i++)
 718         {
 719             item = WMAddListItem(panel->familyL, panel->fonts->families[i].name);
 720             item->clientData= panel->fonts->families+i;
 721         }
 722     }
 723     else
 724       WMAddListItem(panel->familyL, "sans serif");
 725
 726     WMSetListAction(panel->familyL, selectedFamily, panel);
 727
 728     vbox = WMCreateBox(hbox);
 729     WMSetBoxHorizontal(vbox, False);
 730     WMAddBoxSubview(hbox, WMWidgetView(vbox), True, True, 10, 0, 0);
 731
 732     {
 733         WMBox *box = WMCreateBox(vbox);
 734         WMSetBoxHorizontal(box, True);
 735         WMAddBoxSubview(vbox, WMWidgetView(box), False, True, 20, 0, 2);
 736
 737         label = createListLabel(scr, box, _("Style"));
 738         WMAddBoxSubview(box, WMWidgetView(label), True, True, 20, 0, 4);
 739
 740         label = createListLabel(scr, box, _("Size"));
 741         WMAddBoxSubview(box, WMWidgetView(label), False, True, 60, 0, 0);
 742
 743         box = WMCreateBox(vbox);
 744         WMSetBoxHorizontal(box, True);
 745         WMAddBoxSubview(vbox, WMWidgetView(box), True, True, 20, 0, 0);
 746
 747         panel->styleL = WMCreateList(box);
 748         WMAddBoxSubview(box, WMWidgetView(panel->styleL), True, True, 0, 0, 4);
 749         WMSetListAction(panel->styleL, selected, panel);
 750
 751         panel->sizeL = WMCreateList(box);
 752         WMAddBoxSubview(box, WMWidgetView(panel->sizeL), False, True, 60, 0, 0);
 753         for (i= 0; standardSizes[i]; i++)
 754         {
 755             WMAddListItem(panel->sizeL, standardSizes[i]);
 756         }
 757         WMSetListAction(panel->sizeL, selected, panel);
 758     }
 759
 760
 761     WMMapSubwidgets(panel->box);
 762     WMMapWidget(panel->box);
 763     WMRealizeWidget(panel->box);
 764
 765     showData(panel);
 766 }
 767
 768
 769
 770 Panel*
 771 InitFontSimple(WMScreen *scr, WMWidget *parent)
 772 {
 773     _Panel *panel;
 774
 775     panel = wmalloc(sizeof(_Panel));
 776     memset(panel, 0, sizeof(_Panel));
 777
 778     panel->sectionName = _("Font Configuration");
 779
 780     panel->description = _("Configure fonts for Window Maker titlebars, menus etc.");
 781
 782     panel->parent = parent;
 783
 784     panel->callbacks.createWidgets = createPanel;
 785     panel->callbacks.updateDomain = storeData;
 786
 787     AddSection(panel, ICON_FILE);
 788
 789     return panel;
 790 }
 791