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